Store | @sheetwrite/core

Columnar workbook storage, query, transaction, and subscription contract.

Package: @sheetwrite/core
Source: packages/core/src/types/store.ts#L108

Members 17

getWorkbook

getWorkbook(): Workbookinterface Workbook {
  sheets: Sheet[];
  activeSheet: SheetId;
  namedRanges?: NamedRangeSnapshot[];
}interface Workbook {
  sheets: Sheet[];
  activeSheet: SheetId;
  namedRanges?: NamedRangeSnapshot[];
}interface Workbook {
  sheets: Sheet[];
  activeSheet: SheetId;
  namedRanges?: NamedRangeSnapshot[];
}Live workbook schema containing ordered sheets and the active sheet ID.API reference →;

getCell Single-cell read for interactions, API reads, and tests.

getCell(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): ResolvedCellinterface ResolvedCell {
  resolved: CellScalar;
  style: CellStyle;
}interface ResolvedCell {
  resolved: CellScalar;
  style: CellStyle;
}interface ResolvedCell {
  resolved: CellScalar;
  style: CellStyle;
}Authoritative source value, evaluated value, style, and load state for a cell.API reference →;

Single-cell read for interactions, API reads, and tests. NOT for the render hot path — renderers use `getVisibleWindow`.

getFormula Formula source at addr, or null when the cell is not a formula.

getFormula(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): string | null;

getRefTarget Plain-reference target at addr, or null when the cell is not a ref.

getRefTarget(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference → | null;

recalculateVolatile Recompute volatile formulas (TODAY/NOW) from one captured instant.

recalculateVolatile(now?: Date): void;

Recompute volatile formulas (`TODAY`/`NOW`) from one captured instant. The supplied Date is interpreted as an absolute UTC instant.

getVisibleWindow Bulk read of a visible window; the only read a renderer should use per frame.

getVisibleWindow( sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →, rows: { start: number; end: number }, cols: readonly number[], ): VisibleWindowViewinterface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: {
    start: number;
    end: number;
  };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}One rectangular window of resolved cells, returned by Store.getVisibleWindow in a single call. The renderer paints from this view and MUST NOT call Store.getCell per cell. styleIds are view-local indices into this view's compact styles dictionary; on the worker renderer path, styleIds.buffer is transferred during paint, so main-thread code must not read it after paint. Lifetime: valid until the next store mutation or window refresh.API reference →;

getDataWindow Optional packed canonical data-row window used by file export.

getDataWindow?( sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →, rows: { start: number; end: number }, cols: readonly number[], ): VisibleWindowViewinterface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: {
    start: number;
    end: number;
  };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}One rectangular window of resolved cells, returned by Store.getVisibleWindow in a single call. The renderer paints from this view and MUST NOT call Store.getCell per cell. styleIds are view-local indices into this view's compact styles dictionary; on the worker renderer path, styleIds.buffer is transferred during paint, so main-thread code must not read it after paint. Lifetime: valid until the next store mutation or window refresh.API reference →;

Optional packed canonical data-row window used by file export. Unlike `getVisibleWindow`, sort/filter state never remaps `rows`.

getClipboardWindow Optional packed clipboard read.

getClipboardWindow?( sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →, viewRows: { start: number; end: number }, cols: readonly number[], ): ClipboardWindowView;

Optional packed clipboard read. Custom stores may omit it; the controller preserves the per-cell Store fallback contract.

ensureColumns Ensure a sheet can address at least columns.length columns without producing user changes or dirty patches.

ensureColumns(sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →, columns: readonly Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →[]): void;

Ensure a sheet can address at least `columns.length` columns without producing user changes or dirty patches. Used for presentation padding.

applyTransaction Apply a low-level storage transaction.

applyTransaction( tx: Transactioninterface Transaction {
  patches: DocumentOp[];
  epoch?: number;
}interface Transaction {
  patches: DocumentOp[];
  epoch?: number;
}interface Transaction {
  patches: DocumentOp[];
  epoch?: number;
}Low-level Store transaction. epoch provides optional optimistic concurrency at the storage boundary. Calling Store.applyTransaction bypasses Grid read-only checks and Grid undo/redo history. Host-driven edits should use Grid.applyTransaction.API reference →, options?: TransactionApplicationOptionsinterface TransactionApplicationOptions {
  source?: OperationSource;
  commitReason?: CommitReason;
}interface TransactionApplicationOptions {
  source?: OperationSource;
  commitReason?: CommitReason;
}interface TransactionApplicationOptions {
  source?: OperationSource;
  commitReason?: CommitReason;
}Source and commit classification used when applying a transaction.API reference →, ): ApplyTransactionResulttype ApplyTransactionResult =
  | {
      status: "applied";
      epoch: number;
      transaction: Transaction;
      warnings?: MutationIssue[];
      rejections?: MutationIssue[];
    }
  | {
      status: "conflict";
      expectedEpoch: number;
      actualEpoch: number;
    }
  | { status: "rejected"; epoch: number; issues: MutationIssue[] }
  | {
  // … 5 more lines — see the API reference
}type ApplyTransactionResult =
  | {
      status: "applied";
      epoch: number;
      transaction: Transaction;
      warnings?: MutationIssue[];
      rejections?: MutationIssue[];
    }
  | {
      status: "conflict";
      expectedEpoch: number;
      actualEpoch: number;
    }
  | { status: "rejected"; epoch: number; issues: MutationIssue[] }
  | {
  // … 5 more lines — see the API reference
}type ApplyTransactionResult =
  | {
      status: "applied";
      epoch: number;
      transaction: Transaction;
      warnings?: MutationIssue[];
      rejections?: MutationIssue[];
    }
  | {
      status: "conflict";
      expectedEpoch: number;
      actualEpoch: number;
    }
  | {
      status: "rejected";
      epoch: number;
      issues: MutationIssue[];
    }
  | {
  // … 8 more lines — see the API reference
}Outcome of applying a document transaction, including conflict, rejection, and no-op states.API reference →;

Apply a low-level storage transaction.

This bypasses Grid read-only checks and Grid undo/redo history. Use Grid.applyTransaction for normal host-driven edits. Queued and flushed at a barrier — never reentrant.

setProtectionResolver Configure host-owned protected-range permissions.

setProtectionResolver?(resolver: ProtectionResolvertype ProtectionResolver = (
  request: ProtectionRequest,
) => "allow" | "deny";type ProtectionResolver = (
  request: ProtectionRequest,
) => "allow" | "deny";type ProtectionResolver = (
  request: ProtectionRequest,
) => "allow" | "deny";Host-owned client UX permission callback for protected mutations.API reference → | undefined, mode?: MutationPolicyModetype MutationPolicyMode = "atomic" | "partial";type MutationPolicyMode = "atomic" | "partial";type MutationPolicyMode =
  "atomic" | "partial";Atomic or partial handling for locally denied operations.API reference →): void;

Configure host-owned protected-range permissions. The resolver is synchronous so every local mutation ingress shares one atomic commit barrier.

on

on(evt: "change", fn: (event: ChangeEventinterface ChangeEvent {
  transaction: Transaction;
  changes: CellChange[];
  commitReason: CommitReason;
  source: OperationSource;
  epoch?: number;
}interface ChangeEvent {
  transaction: Transaction;
  changes: CellChange[];
  commitReason: CommitReason;
  source: OperationSource;
  epoch?: number;
}interface ChangeEvent {
  transaction: Transaction;
  changes: CellChange[];
  commitReason: CommitReason;
  source: OperationSource;
  epoch?: number;
}Payload of the change event; flows OUT for API submission/reconcile.API reference →) => void): () => void;

queryCapability Explicit partial-data state for paged datasource stores.

queryCapability?(sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →): QueryCapabilitytype QueryCapability =
  | { status: "complete" }
  | {
      status: "incomplete";
      loadedCells: number;
      totalCells: number;
    };type QueryCapability =
  | { status: "complete" }
  | {
      status: "incomplete";
      loadedCells: number;
      totalCells: number;
    };type QueryCapability =
  | { status: "complete" }
  | {
      status: "incomplete";
      loadedCells: number;
      totalCells: number;
    };Whether a query is complete for the currently loaded datasource pages.API reference →;

getCellLoadState Loaded/empty/local state; dense stores always return a loaded state.

getCellLoadState?(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): CellLoadStatetype CellLoadState =
  "unloaded" | "loaded-empty" | "loaded-value" | "local-edit";type CellLoadState =
  "unloaded" | "loaded-empty" | "loaded-value" | "local-edit";type CellLoadState =
  | "unloaded"
  | "loaded-empty"
  | "loaded-value"
  | "local-edit";Datasource loading state for a resolved cell.API reference →;

acknowledgeOperations Release paged dirty pins after server acknowledgement.

acknowledgeOperations?(operations: readonly DocumentOptype DocumentOp =
  | {
      op: "set";
      addr: CellAddress;
      value: CellValue;
      style?: CellStyle;
    }
  | { op: "setRange"; range: Range; cells: SnapshotCell[] }
  | { op: "setBlock"; range: Range; block: PackedCellBlock }
  | {
      op: "setRangeStyle";
      range: Range;
      style: Partial<CellStyle> | null;
    }
  | {
  // … 78 more lines — see the API reference
}type DocumentOp =
  | {
      op: "set";
      addr: CellAddress;
      value: CellValue;
      style?: CellStyle;
    }
  | { op: "setRange"; range: Range; cells: SnapshotCell[] }
  | { op: "setBlock"; range: Range; block: PackedCellBlock }
  | {
      op: "setRangeStyle";
      range: Range;
      style: Partial<CellStyle> | null;
    }
  | {
  // … 78 more lines — see the API reference
}type DocumentOp =
  | {
      op: "set";
      addr: CellAddress;
      value: CellValue;
      style?: CellStyle;
    }
  | {
      op: "setRange";
      range: Range;
      cells: SnapshotCell[];
    }
  | {
      op: "setBlock";
      range: Range;
      block: PackedCellBlock;
    }
  | {
      op: "setRangeStyle";
  // … 138 more lines — see the API reference
}Exhaustive serializable operation union for workbook mutations.API reference →[]): void;

exportSnapshot Deterministic, JSON-safe authoritative runtime document.

exportSnapshot?(): WorkbookSnapshotinterface WorkbookSnapshot {
  schemaVersion: 1;
  documentId?: string;
  version?: number;
  workbook: {
    activeSheet: SheetId;
    namedRanges?: NamedRangeSnapshot[];
  };
  sheets: SheetSnapshot[];
}interface WorkbookSnapshot {
  schemaVersion: 1;
  documentId?: string;
  version?: number;
  workbook: {
    activeSheet: SheetId;
    namedRanges?: NamedRangeSnapshot[];
  };
  sheets: SheetSnapshot[];
}interface WorkbookSnapshot {
  schemaVersion: 1;
  documentId?: string;
  version?: number;
  workbook: {
    activeSheet: SheetId;
    namedRanges?: NamedRangeSnapshot[];
  };
  sheets: SheetSnapshot[];
}Schema-versioned serializable workbook document.API reference →;

viewRowCount Displayed row count after any active sort/filter view.

viewRowCount(sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →): number;

Declaration

View full TypeScript declaration

export interface Store {
  getWorkbook(): Workbookinterface Workbook {
  sheets: Sheet[];
  activeSheet: SheetId;
  namedRanges?: NamedRangeSnapshot[];
}interface Workbook {
  sheets: Sheet[];
  activeSheet: SheetId;
  namedRanges?: NamedRangeSnapshot[];
}interface Workbook {
  sheets: Sheet[];
  activeSheet: SheetId;
  namedRanges?: NamedRangeSnapshot[];
}Live workbook schema containing ordered sheets and the active sheet ID.API reference →;
  getCell(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): ResolvedCellinterface ResolvedCell {
  resolved: CellScalar;
  style: CellStyle;
}interface ResolvedCell {
  resolved: CellScalar;
  style: CellStyle;
}interface ResolvedCell {
  resolved: CellScalar;
  style: CellStyle;
}Authoritative source value, evaluated value, style, and load state for a cell.API reference →;
  getFormula(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): string | null;
  getRefTarget(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference → | null;
  recalculateVolatile(now?: Date): void;
  getVisibleWindow(
    sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →,
    rows: {
      start: number;
      end: number;
    },
    cols: readonly number[],
  ): VisibleWindowViewinterface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: {
    start: number;
    end: number;
  };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}One rectangular window of resolved cells, returned by Store.getVisibleWindow in a single call. The renderer paints from this view and MUST NOT call Store.getCell per cell. styleIds are view-local indices into this view's compact styles dictionary; on the worker renderer path, styleIds.buffer is transferred during paint, so main-thread code must not read it after paint. Lifetime: valid until the next store mutation or window refresh.API reference →;
  getDataWindow?(
    sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →,
    rows: {
      start: number;
      end: number;
    },
    cols: readonly number[],
  ): VisibleWindowViewinterface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: { start: number; end: number };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}interface VisibleWindowView {
  sheet: SheetId;
  rows: {
    start: number;
    end: number;
  };
  cols: readonly number[];
  values: ArrayLike<CellScalar>;
  styleIds: Uint32Array;
  styles: readonly CellStyle[];
  valueKinds?: Uint8Array;
  numberValues?: Float64Array;
  stringPoolIds?: Uint32Array;
  stringLocalIds?: Int32Array;
  stringPoolUpdateIds?: Uint32Array;
  stringPoolUpdateValues?: readonly string[];
  localStrings?: readonly string[];
  ffiCalls?: number;
}One rectangular window of resolved cells, returned by Store.getVisibleWindow in a single call. The renderer paints from this view and MUST NOT call Store.getCell per cell. styleIds are view-local indices into this view's compact styles dictionary; on the worker renderer path, styleIds.buffer is transferred during paint, so main-thread code must not read it after paint. Lifetime: valid until the next store mutation or window refresh.API reference →;
  getClipboardWindow?(
    sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →,
    viewRows: {
      start: number;
      end: number;
    },
    cols: readonly number[],
  ): ClipboardWindowView;
  ensureColumns(sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →, columns: readonly Columninterface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}interface Column {
  key: string;
  header: string;
  width: number;
  type: CellFormat;
  numberFormat?: string;
  numberLocale?: string;
  headerStyle?: CellStyle;
  cellStyle?: CellStyle;
  visible?: boolean;
  renderer?: string;
}Schema and default presentation for one workbook column.API reference →[]): void;
  applyTransaction(
    tx: Transactioninterface Transaction {
  patches: DocumentOp[];
  epoch?: number;
}interface Transaction {
  patches: DocumentOp[];
  epoch?: number;
}interface Transaction {
  patches: DocumentOp[];
  epoch?: number;
}Low-level Store transaction. epoch provides optional optimistic concurrency at the storage boundary. Calling Store.applyTransaction bypasses Grid read-only checks and Grid undo/redo history. Host-driven edits should use Grid.applyTransaction.API reference →,
    options?: TransactionApplicationOptionsinterface TransactionApplicationOptions {
  source?: OperationSource;
  commitReason?: CommitReason;
}interface TransactionApplicationOptions {
  source?: OperationSource;
  commitReason?: CommitReason;
}interface TransactionApplicationOptions {
  source?: OperationSource;
  commitReason?: CommitReason;
}Source and commit classification used when applying a transaction.API reference →,
  ): ApplyTransactionResulttype ApplyTransactionResult =
  | {
      status: "applied";
      epoch: number;
      transaction: Transaction;
      warnings?: MutationIssue[];
      rejections?: MutationIssue[];
    }
  | {
      status: "conflict";
      expectedEpoch: number;
      actualEpoch: number;
    }
  | { status: "rejected"; epoch: number; issues: MutationIssue[] }
  | {
  // … 5 more lines — see the API reference
}type ApplyTransactionResult =
  | {
      status: "applied";
      epoch: number;
      transaction: Transaction;
      warnings?: MutationIssue[];
      rejections?: MutationIssue[];
    }
  | {
      status: "conflict";
      expectedEpoch: number;
      actualEpoch: number;
    }
  | { status: "rejected"; epoch: number; issues: MutationIssue[] }
  | {
  // … 5 more lines — see the API reference
}type ApplyTransactionResult =
  | {
      status: "applied";
      epoch: number;
      transaction: Transaction;
      warnings?: MutationIssue[];
      rejections?: MutationIssue[];
    }
  | {
      status: "conflict";
      expectedEpoch: number;
      actualEpoch: number;
    }
  | {
      status: "rejected";
      epoch: number;
      issues: MutationIssue[];
    }
  | {
  // … 8 more lines — see the API reference
}Outcome of applying a document transaction, including conflict, rejection, and no-op states.API reference →;
  setProtectionResolver?(
    resolver: ProtectionResolvertype ProtectionResolver = (
  request: ProtectionRequest,
) => "allow" | "deny";type ProtectionResolver = (
  request: ProtectionRequest,
) => "allow" | "deny";type ProtectionResolver = (
  request: ProtectionRequest,
) => "allow" | "deny";Host-owned client UX permission callback for protected mutations.API reference → | undefined,
    mode?: MutationPolicyModetype MutationPolicyMode = "atomic" | "partial";type MutationPolicyMode = "atomic" | "partial";type MutationPolicyMode =
  "atomic" | "partial";Atomic or partial handling for locally denied operations.API reference →,
  ): void;
  on(evt: "change", fn: (event: ChangeEventinterface ChangeEvent {
  transaction: Transaction;
  changes: CellChange[];
  commitReason: CommitReason;
  source: OperationSource;
  epoch?: number;
}interface ChangeEvent {
  transaction: Transaction;
  changes: CellChange[];
  commitReason: CommitReason;
  source: OperationSource;
  epoch?: number;
}interface ChangeEvent {
  transaction: Transaction;
  changes: CellChange[];
  commitReason: CommitReason;
  source: OperationSource;
  epoch?: number;
}Payload of the change event; flows OUT for API submission/reconcile.API reference →) => void): () => void;
  queryCapability?(sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →): QueryCapabilitytype QueryCapability =
  | { status: "complete" }
  | {
      status: "incomplete";
      loadedCells: number;
      totalCells: number;
    };type QueryCapability =
  | { status: "complete" }
  | {
      status: "incomplete";
      loadedCells: number;
      totalCells: number;
    };type QueryCapability =
  | { status: "complete" }
  | {
      status: "incomplete";
      loadedCells: number;
      totalCells: number;
    };Whether a query is complete for the currently loaded datasource pages.API reference →;
  getCellLoadState?(addr: CellAddressinterface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}interface CellAddress {
  sheet: SheetId;
  row: number;
  col: number;
}Zero-based address of one cell on a stable sheet ID.API reference →): CellLoadStatetype CellLoadState =
  "unloaded" | "loaded-empty" | "loaded-value" | "local-edit";type CellLoadState =
  "unloaded" | "loaded-empty" | "loaded-value" | "local-edit";type CellLoadState =
  | "unloaded"
  | "loaded-empty"
  | "loaded-value"
  | "local-edit";Datasource loading state for a resolved cell.API reference →;
  acknowledgeOperations?(operations: readonly DocumentOptype DocumentOp =
  | {
      op: "set";
      addr: CellAddress;
      value: CellValue;
      style?: CellStyle;
    }
  | { op: "setRange"; range: Range; cells: SnapshotCell[] }
  | { op: "setBlock"; range: Range; block: PackedCellBlock }
  | {
      op: "setRangeStyle";
      range: Range;
      style: Partial<CellStyle> | null;
    }
  | {
  // … 78 more lines — see the API reference
}type DocumentOp =
  | {
      op: "set";
      addr: CellAddress;
      value: CellValue;
      style?: CellStyle;
    }
  | { op: "setRange"; range: Range; cells: SnapshotCell[] }
  | { op: "setBlock"; range: Range; block: PackedCellBlock }
  | {
      op: "setRangeStyle";
      range: Range;
      style: Partial<CellStyle> | null;
    }
  | {
  // … 78 more lines — see the API reference
}type DocumentOp =
  | {
      op: "set";
      addr: CellAddress;
      value: CellValue;
      style?: CellStyle;
    }
  | {
      op: "setRange";
      range: Range;
      cells: SnapshotCell[];
    }
  | {
      op: "setBlock";
      range: Range;
      block: PackedCellBlock;
    }
  | {
      op: "setRangeStyle";
  // … 138 more lines — see the API reference
}Exhaustive serializable operation union for workbook mutations.API reference →[]): void;
  exportSnapshot?(): WorkbookSnapshotinterface WorkbookSnapshot {
  schemaVersion: 1;
  documentId?: string;
  version?: number;
  workbook: {
    activeSheet: SheetId;
    namedRanges?: NamedRangeSnapshot[];
  };
  sheets: SheetSnapshot[];
}interface WorkbookSnapshot {
  schemaVersion: 1;
  documentId?: string;
  version?: number;
  workbook: {
    activeSheet: SheetId;
    namedRanges?: NamedRangeSnapshot[];
  };
  sheets: SheetSnapshot[];
}interface WorkbookSnapshot {
  schemaVersion: 1;
  documentId?: string;
  version?: number;
  workbook: {
    activeSheet: SheetId;
    namedRanges?: NamedRangeSnapshot[];
  };
  sheets: SheetSnapshot[];
}Schema-versioned serializable workbook document.API reference →;
  viewRowCount(sheet: SheetIdtype SheetId = string;type SheetId = string;type SheetId = string;Stable identifier used to address a workbook sheet.API reference →): number;
}