CellStore | @sheetwrite/wasm

The workbook-wide store: every sheet, one string pool.

Package: @sheetwrite/wasm
Source: packages/wasm/pkg/sheetwrite_wasm.d.ts#L20

Members 90

acknowledgeRevision

acknowledgeRevision: (revision: bigint) => void;

addPagedSheet Allocate a logical sheet whose cell chunks materialize on page load or edit.

addPagedSheet: (n_cols: number, row_count: number, chunk_rows: number, byte_budget: number, max_dirty_cells: number) => number;

addRows

addRows: (sheet: number, at: number, count: number) => void;

addSheet Allocate a sheet grid and return its numeric handle.

addSheet: (n_cols: number, row_count: number) => number;

aggregate Column aggregate over numeric cells.

aggregate: (sheet: number, col: number, op: number) => number;

Column aggregate over numeric cells. op: 0 sum, 1 avg, 2 min, 3 max, 4 count.

beginMutation

beginMutation: () => bigint;

beginPageLoad

beginPageLoad: () => void;

canDirtyCell

canDirtyCell: (sheet: number, row: number, col: number) => boolean;

captureRange Capture a dense rectangle into an opaque store-local history resource.

captureRange: (sheet: number, r0: number, c0: number, rows: number, cols: number) => RangeSnapshot | undefined;

captureReferences Capture only persisted references for one sheet.

captureReferences: (sheet: number, max_entries: number) => SourceSnapshot | undefined;

Capture only persisted references for one sheet. The explicit entry cap bounds allocation for host-side structural admission simulation.

captureSources Capture only persisted formula/reference sources in a rectangle.

captureSources: (sheet: number, r0: number, c0: number, rows: number, cols: number) => SourceSnapshot | undefined;

Capture only persisted formula/reference sources in a rectangle. The returned opaque object is compact in source cardinality, not cell count.

captureSourcesForRows Capture persisted formula/reference sources and derived-spill identity for arbitrary row/column coordinates in one boundary crossing.

captureSourcesForRows: (sheet: number, rows: Uint32Array, cols: Uint32Array) => SourceSnapshot | undefined;

Capture persisted formula/reference sources and derived-spill identity for arbitrary row/column coordinates in one boundary crossing. Offsets follow the caller's row-major coordinate order.

cellState 0 unloaded, 1 loaded-empty, 2 loaded-value, 3 dirty local edit.

cellState: (sheet: number, row: number, col: number) => number;

clearCell

clearCell: (sheet: number, row: number, col: number, style: number) => void;

clearRange Clear a rectangle while independently controlling contents and style.

clearRange: (sheet: number, r0: number, c0: number, r1: number, c1: number, contents: boolean, style: boolean) => boolean;

colCount

colCount: (sheet: number) => number;

columnsFullyLoaded

columnsFullyLoaded: (sheet: number, start_row: number, end_row: number, cols: Uint32Array) => boolean;

compactStringStorage Release geometric growth slack after a bounded bulk ingest.

compactStringStorage: () => void;

dataEdge Ctrl+Arrow destination: from (row, col) stepping by (drow, dcol) (exactly one of them ±1), return the destination row (vertical moves) or column (horizontal moves), Google Sheets semantics: - current and adjacent…

dataEdge: (sheet: number, row: number, col: number, d_row: number, d_col: number) => number;

Ctrl+Arrow destination: from `(row, col)` stepping by `(d_row, d_col)` (exactly one of them ±1), return the destination row (vertical moves) or column (horizontal moves), Google Sheets semantics:

current and adjacent cell non-empty → end of the contiguous non-empty run;
otherwise → the next non-empty cell in that direction;
nothing ahead → the sheet edge.

dataEdgeOrdered

dataEdgeOrdered: (sheet: number, order: Uint32Array, row: number, col: number, d_row: number, d_col: number) => number;

dirtyRevision

dirtyRevision: (sheet: number, row: number, col: number) => bigint;

distinctValues

distinctValues: (sheet: number, col: number, limit: number) => DistinctColumn;

endMutation

endMutation: () => void;

endPageLoad

endPageLoad: () => void;

filterRows Data-row indices whose column text contains needle (case-insensitive).

filterRows: (sheet: number, col: number, needle: string) => Uint32Array;

filterRowsMulti

filterRowsMulti: (sheet: number, cols: Uint32Array, kinds: Uint8Array, flags: Uint8Array, nums: Float64Array, num_counts: Uint32Array, text_counts: Uint32Array, value_nums: Float64Array, value_texts: string[]) => Uint32Array;

formulaMatrixResourceStats Benchmark diagnostic: [current matrix bytes, peak matrix bytes, allocations].

formulaMatrixResourceStats: () => Float64Array;

formulaSource

formulaSource: (sheet: number, row: number, col: number) => string | undefined;

free

free: () => void;

getCell Single-cell read for interactions/tests — never the render hot path.

getCell: (sheet: number, row: number, col: number) => CellOut;

getWindow One bulk read of a rectangular window for the renderer.

getWindow: (sheet: number, row_start: number, row_end: number, cols: Uint32Array) => WindowView;

One bulk read of a rectangular window for the renderer. Returns contiguous packed cell data (row-major over `rows x cols`) plus the unique strings referenced by the window, so the host paints without crossing the boundary per cell.

getWindowRows Bulk read of an explicit row list (sorted/filtered views) — same output shape as getwindow, rows taken from rows rather than a range.

getWindowRows: (sheet: number, rows: Uint32Array, cols: Uint32Array) => WindowView;

Bulk read of an explicit row list (sorted/filtered views) — same output shape as `get_window`, rows taken from `rows` rather than a range.

hydratePageNumbers Hydrate one datasource page column while retaining local dirty cells and request-revision exceptions.

hydratePageNumbers: (sheet: number, col: number, start_row: number, values: Float64Array, style: number, protected_offsets: Uint32Array) => void;

Hydrate one datasource page column while retaining local dirty cells and request-revision exceptions. `protected_offsets` is sorted and relative to `start_row`.

hydratePageStringsPacked Packed-string counterpart to [CellStore::hydratepagenumbers].

hydratePageStringsPacked: (sheet: number, col: number, start_row: number, buf: string, utf16_lens: Uint32Array, style: number, protected_offsets: Uint32Array) => void;

Packed-string counterpart to [`CellStore::hydrate_page_numbers`].

insertCols

insertCols: (sheet: number, at: number, count: number) => void;

isFullyLoaded

isFullyLoaded: (sheet: number) => boolean;

isPaged

isPaged: (sheet: number) => boolean;

isSheetAlive

isSheetAlive: (sheet: number) => boolean;

markCellCleanRevision

markCellCleanRevision: (sheet: number, row: number, col: number, revision: bigint) => boolean;

markRangeClean

markRangeClean: (sheet: number, start_row: number, end_row: number, start_col: number, end_col: number) => void;

memoryStats

memoryStats: () => Float64Array;

pagedDirtyCoordinates

pagedDirtyCoordinates: (sheet: number) => Float64Array;

pagedStats [chunks, loaded cells, dirty cells, clean chunk bytes, fully loaded, dirty bytes].

pagedStats: (sheet: number) => Float64Array;

persistedCellData Sparse persisted-cell records.

persistedCellData: (sheet: number) => Float64Array;

Sparse persisted-cell records. Each record starts with `[row, col, kind, number, style, string_id, source_kind, source_length]`. Formula UTF-8 is packed into little-endian u32 words; references append one `[sheet, row, col]` triple. The allocation scales with serialized cells and source bytes, never the logical sheet rectangle.

pinRange

pinRange: (sheet: number, start_row: number, end_row: number, cols: Uint32Array) => void;

poolStrings

poolStrings: (ids: Uint32Array) => string[];

queryResourceStats [contains cache constructions, owned distinct strings].

queryResourceStats: () => Float64Array;

rangeFullyLoaded

rangeFullyLoaded: (sheet: number, r0: number, c0: number, r1: number, c1: number) => boolean;

rangeStyleIds Unique style ids present in a rectangle; cost stays inside WASM.

rangeStyleIds: (sheet: number, r0: number, c0: number, r1: number, c1: number) => Uint32Array;

recompute Recompute formulas affected by cells changed since the last call.

recompute: (sheet: number) => void;

Recompute formulas affected by cells changed since the last call.

The pass first grows the dirty cell set through formula read-sets to find all dependent formulas. It then evaluates only those formulas, using a per-pass memo table so each formula cell is evaluated at most once even when many downstream formulas reference it.

recomputeChanged Recompute the union of every dirty sheet once at the host transaction barrier, including cross-sheet formula and plain-reference dependents.

recomputeChanged: () => void;

recomputeVolatile Explicit volatile barrier.

recomputeVolatile: (serial: number) => boolean;

Explicit volatile barrier. `serial` is a UTC spreadsheet serial using the 1899-12-30 epoch; only TODAY/NOW formulas and their dependents dirty.

referenceTarget

referenceTarget: (sheet: number, row: number, col: number) => Uint32Array | undefined;

referencesTargeting Return packed [sourcesheet, sourcerow, sourcecol, ...] references targeting one sheet, bounded before crossing into the host.

referencesTargeting: (target_sheet: number, max_entries: number) => Uint32Array | undefined;

Return packed `[source_sheet, source_row, source_col, ...]` references targeting one sheet, bounded before crossing into the host.

remapRangeStyles Remap styles over a rectangle using parallel old/new id tables.

remapRangeStyles: (sheet: number, r0: number, c0: number, r1: number, c1: number, old_ids: Uint32Array, new_ids: Uint32Array) => boolean;

removeCols

removeCols: (sheet: number, at: number, count: number) => void;

removeNamedRange

removeNamedRange: (name: string, scope: number) => boolean;

removeRows

removeRows: (sheet: number, at: number, count: number) => void;

removeSheet Tombstone a stable sheet handle and invalidate every formula reference to it.

removeSheet: (sheet: number) => boolean;

removeTable

removeTable: (id: string) => boolean;

renameSheet Rename a live stable sheet handle and rewrite every resolved formula AST reference.

renameSheet: (sheet: number, id: string, name: string) => boolean;

resetFormulaMatrixResourceStats

resetFormulaMatrixResourceStats: () => void;

resetQueryResourceStats

resetQueryResourceStats: () => void;

restoreRange Restore a captured block at a destination of the same dimensions.

restoreRange: (sheet: number, r0: number, c0: number, snapshot: RangeSnapshot) => boolean;

rowCount

rowCount: (sheet: number) => number;

search Cell coordinates whose text matches query, as a flat [row, col, ...] list.

search: (sheet: number, cols: Uint32Array, query: string, case_insensitive: boolean, whole_cell: boolean) => Uint32Array;

Cell coordinates whose text matches `query`, as a flat `[row, col, ...]` list. Scans the requested columns column-major (cache-local), then sorts row-major so search navigation runs top-to-bottom, left-to-right.

setBlock Atomically write one row-major mixed literal/formula/reference block.

setBlock: (sheet: number, start_row: number, start_col: number, rows: number, cols: number, kinds: Uint8Array, numbers: Float64Array, texts: string[], styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array) => number;

Atomically write one row-major mixed literal/formula/reference block. Formula/reference offsets are sparse row-major exceptions. Reference targets are packed `[sheet_handle, row, col]` triples. The compact status is `0` success, `1` invalid shape/bounds, `2` invalid or duplicate source metadata, and `3` paged dirty-capacity rejection.

setBool

setBool: (sheet: number, row: number, col: number, value: boolean, style: number) => void;

setColumnNumbers Bulk-load one column with numbers starting at startrow.

setColumnNumbers: (sheet: number, col: number, start_row: number, values: Float64Array, style: number) => void;

Bulk-load one column with numbers starting at `start_row`.

setColumnStrings Bulk-load one column with strings starting at startrow.

setColumnStrings: (sheet: number, col: number, start_row: number, values: string[], style: number) => void;

Bulk-load one column with strings starting at `start_row`.

setColumnStringsPacked Bulk-load one column of strings from a single concatenated buffer plus per-row lengths in UTF-16 code units (the JS string.length unit).

setColumnStringsPacked: (sheet: number, col: number, start_row: number, buf: string, utf16_lens: Uint32Array, style: number) => void;

Bulk-load one column of strings from a single concatenated buffer plus per-row lengths in UTF-16 code units (the JS `string.length` unit). One boundary decode and one Rust allocation for the whole column, instead of one per row — the dominant ingest cost for text columns.

setConditionalRules Replace a sheet's conditional-format rules.

setConditionalRules: (sheet: number, kinds: Uint8Array, bounds: Uint32Array, nums: Float64Array, strs: string[], flags: Uint8Array) => void;

Replace a sheet's conditional-format rules. Packed columnar encoding, one entry per rule: `kinds` 0 gt / 1 lt / 2 eqNum / 3 eqStr / 4 eqEmpty / 5 contains / 6 boolean formula; `bounds` = normalized `[r0, c0, r1, c1]` per rule; `nums` carries the numeric operand; `strs` the text/formula operand; `flags` bit 0 = match-case for `contains`, bit 1 = stop-if-true. Formula strings are parsed once here, never once per visible cell.

setFormula Parse and store an arithmetic formula at (row, col).

setFormula: (sheet: number, row: number, col: number, src: string, style: number) => number;

Parse and store an arithmetic formula at `(row, col)`.

Setters only mark cells dirty; they do not recompute formulas. The host calls recompute(sheet) once at the transaction barrier so a multi-cell edit performs one dependency-scoped pass instead of one full-sheet pass per setter. The returned value is the previous cached value until that barrier recompute runs, and the store facade ignores it for batched edits.

setNamedRange

setNamedRange: (name: string, scope: number, sheet: number, row_start: number, col_start: number, row_end: number, col_end: number) => boolean;

setNumber

setNumber: (sheet: number, row: number, col: number, value: number, style: number) => void;

setSheetName

setSheetName: (sheet: number, id: string, name: string) => void;

setSparseBlock Write one sparse mixed transaction/page/snapshot block without allocating by logical rectangle size.

setSparseBlock: (sheet: number, start_row: number, start_col: number, rows: number, cols: number, offsets: Uint32Array, kinds: Uint8Array, numbers: Float64Array, texts: string[], styles: Uint32Array, formula_offsets: Uint32Array, formula_sources: string[], reference_offsets: Uint32Array, reference_targets: Uint32Array) => number;

Write one sparse mixed transaction/page/snapshot block without allocating by logical rectangle size. Inside `beginPageLoad`, dirty paged cells are skipped; otherwise the whole sparse write is preflighted.

setSpillBlockers Replace the host-owned merge/protection collision ranges.

setSpillBlockers: (sheet: number, bounds: Uint32Array) => boolean;

Replace the host-owned merge/protection collision ranges. Packed as `[row_start, col_start, row_end, col_end, ...]`; invalid input fails without weakening the old gate.

setString

setString: (sheet: number, row: number, col: number, value: string, style: number) => void;

setTable

setTable: (id: string, name: string, sheet: number, row_start: number, col_start: number, row_end: number, col_end: number, header_row: boolean, totals_row: boolean, column_ids: string[], column_names: string[]) => boolean;

snapshotNumbers

snapshotNumbers: (snapshot: RangeSnapshot) => Float64Array;

snapshotTexts

snapshotTexts: (snapshot: RangeSnapshot) => string[];

sortRows Stable row order sorted by a column.

sortRows: (sheet: number, col: number, ascending: boolean) => Uint32Array;

Stable row order sorted by a column. Returns a data-row permutation.

sortRowsMulti

sortRowsMulti: (sheet: number, cols: Uint32Array, ascending: Uint8Array, candidates: Uint32Array) => Uint32Array;

spillAnchorCol

spillAnchorCol: (sheet: number, row: number, col: number) => number;

spillAnchorRow Stable spill owner coordinate, or u32::MAX when cell is not part of a materialized spill.

spillAnchorRow: (sheet: number, row: number, col: number) => number;

spillDerivedMask Row-major mask aligned with render-window layout; 1 marks a derived spill cell and deliberately excludes the anchor.

spillDerivedMask: (sheet: number, row_start: number, row_end: number, cols: Uint32Array) => Uint8Array;

spillOwnerCoordinates Packed row-major [anchorrow, anchorcol, ...] owner coordinates.

spillOwnerCoordinates: (sheet: number, row_start: number, row_end: number, cols: Uint32Array) => Uint32Array;

Packed row-major `[anchor_row, anchor_col, ...]` owner coordinates.

styleIdAt Current style-dictionary id at a cell; 0 when out of bounds.

styleIdAt: (sheet: number, row: number, col: number) => number;

Current style-dictionary id at a cell; `0` when out of bounds. Used by the host to write derived (reference-shadow) values without disturbing the cell's style.

wasmCommittedBytes

wasmCommittedBytes: () => number

Declaration

View full TypeScript declaration

class CellStore {
  acknowledgeRevision: (revision: bigint) => void;
  addPagedSheet: (
    n_cols: number,
    row_count: number,
    chunk_rows: number,
    byte_budget: number,
    max_dirty_cells: number,
  ) => number;
  addRows: (sheet: number, at: number, count: number) => void;
  addSheet: (n_cols: number, row_count: number) => number;
  aggregate: (sheet: number, col: number, op: number) => number;
  beginMutation: () => bigint;
  beginPageLoad: () => void;
  canDirtyCell: (sheet: number, row: number, col: number) => boolean;
  captureRange: (
    sheet: number,
    r0: number,
    c0: number,
    rows: number,
    cols: number,
  ) => RangeSnapshot | undefined;
  captureReferences: (
    sheet: number,
    max_entries: number,
  ) => SourceSnapshot | undefined;
  captureSources: (
    sheet: number,
    r0: number,
    c0: number,
    rows: number,
    cols: number,
  ) => SourceSnapshot | undefined;
  captureSourcesForRows: (
    sheet: number,
    rows: Uint32Array,
    cols: Uint32Array,
  ) => SourceSnapshot | undefined;
  cellState: (sheet: number, row: number, col: number) => number;
  clearCell: (sheet: number, row: number, col: number, style: number) => void;
  clearRange: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
    contents: boolean,
    style: boolean,
  ) => boolean;
  colCount: (sheet: number) => number;
  columnsFullyLoaded: (
    sheet: number,
    start_row: number,
    end_row: number,
    cols: Uint32Array,
  ) => boolean;
  compactStringStorage: () => void;
  dataEdge: (
    sheet: number,
    row: number,
    col: number,
    d_row: number,
    d_col: number,
  ) => number;
  dataEdgeOrdered: (
    sheet: number,
    order: Uint32Array,
    row: number,
    col: number,
    d_row: number,
    d_col: number,
  ) => number;
  dirtyRevision: (sheet: number, row: number, col: number) => bigint;
  distinctValues: (
    sheet: number,
    col: number,
    limit: number,
  ) => DistinctColumn;
  endMutation: () => void;
  endPageLoad: () => void;
  filterRows: (sheet: number, col: number, needle: string) => Uint32Array;
  filterRowsMulti: (
    sheet: number,
    cols: Uint32Array,
    kinds: Uint8Array,
    flags: Uint8Array,
    nums: Float64Array,
    num_counts: Uint32Array,
    text_counts: Uint32Array,
    value_nums: Float64Array,
    value_texts: string[],
  ) => Uint32Array;
  formulaMatrixResourceStats: () => Float64Array;
  formulaSource: (
    sheet: number,
    row: number,
    col: number,
  ) => string | undefined;
  free: () => void;
  getCell: (sheet: number, row: number, col: number) => CellOut;
  getWindow: (
    sheet: number,
    row_start: number,
    row_end: number,
    cols: Uint32Array,
  ) => WindowView;
  getWindowRows: (
    sheet: number,
    rows: Uint32Array,
    cols: Uint32Array,
  ) => WindowView;
  hydratePageNumbers: (
    sheet: number,
    col: number,
    start_row: number,
    values: Float64Array,
    style: number,
    protected_offsets: Uint32Array,
  ) => void;
  hydratePageStringsPacked: (
    sheet: number,
    col: number,
    start_row: number,
    buf: string,
    utf16_lens: Uint32Array,
    style: number,
    protected_offsets: Uint32Array,
  ) => void;
  insertCols: (sheet: number, at: number, count: number) => void;
  isFullyLoaded: (sheet: number) => boolean;
  isPaged: (sheet: number) => boolean;
  isSheetAlive: (sheet: number) => boolean;
  markCellCleanRevision: (
    sheet: number,
    row: number,
    col: number,
    revision: bigint,
  ) => boolean;
  markRangeClean: (
    sheet: number,
    start_row: number,
    end_row: number,
    start_col: number,
    end_col: number,
  ) => void;
  memoryStats: () => Float64Array;
  pagedDirtyCoordinates: (sheet: number) => Float64Array;
  pagedStats: (sheet: number) => Float64Array;
  persistedCellData: (sheet: number) => Float64Array;
  pinRange: (
    sheet: number,
    start_row: number,
    end_row: number,
    cols: Uint32Array,
  ) => void;
  poolStrings: (ids: Uint32Array) => string[];
  queryResourceStats: () => Float64Array;
  rangeFullyLoaded: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
  ) => boolean;
  rangeStyleIds: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
  ) => Uint32Array;
  recompute: (sheet: number) => void;
  recomputeChanged: () => void;
  recomputeVolatile: (serial: number) => boolean;
  referenceTarget: (
    sheet: number,
    row: number,
    col: number,
  ) => Uint32Array | undefined;
  referencesTargeting: (
    target_sheet: number,
    max_entries: number,
  ) => Uint32Array | undefined;
  remapRangeStyles: (
    sheet: number,
    r0: number,
    c0: number,
    r1: number,
    c1: number,
    old_ids: Uint32Array,
    new_ids: Uint32Array,
  ) => boolean;
  removeCols: (sheet: number, at: number, count: number) => void;
  removeNamedRange: (name: string, scope: number) => boolean;
  removeRows: (sheet: number, at: number, count: number) => void;
  removeSheet: (sheet: number) => boolean;
  removeTable: (id: string) => boolean;
  renameSheet: (sheet: number, id: string, name: string) => boolean;
  resetFormulaMatrixResourceStats: () => void;
  resetQueryResourceStats: () => void;
  restoreRange: (
    sheet: number,
    r0: number,
    c0: number,
    snapshot: RangeSnapshot,
  ) => boolean;
  rowCount: (sheet: number) => number;
  search: (
    sheet: number,
    cols: Uint32Array,
    query: string,
    case_insensitive: boolean,
    whole_cell: boolean,
  ) => Uint32Array;
  setBlock: (
    sheet: number,
    start_row: number,
    start_col: number,
    rows: number,
    cols: number,
    kinds: Uint8Array,
    numbers: Float64Array,
    texts: string[],
    styles: Uint32Array,
    formula_offsets: Uint32Array,
    formula_sources: string[],
    reference_offsets: Uint32Array,
    reference_targets: Uint32Array,
  ) => number;
  setBool: (
    sheet: number,
    row: number,
    col: number,
    value: boolean,
    style: number,
  ) => void;
  setColumnNumbers: (
    sheet: number,
    col: number,
    start_row: number,
    values: Float64Array,
    style: number,
  ) => void;
  setColumnStrings: (
    sheet: number,
    col: number,
    start_row: number,
    values: string[],
    style: number,
  ) => void;
  setColumnStringsPacked: (
    sheet: number,
    col: number,
    start_row: number,
    buf: string,
    utf16_lens: Uint32Array,
    style: number,
  ) => void;
  setConditionalRules: (
    sheet: number,
    kinds: Uint8Array,
    bounds: Uint32Array,
    nums: Float64Array,
    strs: string[],
    flags: Uint8Array,
  ) => void;
  setFormula: (
    sheet: number,
    row: number,
    col: number,
    src: string,
    style: number,
  ) => number;
  setNamedRange: (
    name: string,
    scope: number,
    sheet: number,
    row_start: number,
    col_start: number,
    row_end: number,
    col_end: number,
  ) => boolean;
  setNumber: (
    sheet: number,
    row: number,
    col: number,
    value: number,
    style: number,
  ) => void;
  setSheetName: (sheet: number, id: string, name: string) => void;
  setSparseBlock: (
    sheet: number,
    start_row: number,
    start_col: number,
    rows: number,
    cols: number,
    offsets: Uint32Array,
    kinds: Uint8Array,
    numbers: Float64Array,
    texts: string[],
    styles: Uint32Array,
    formula_offsets: Uint32Array,
    formula_sources: string[],
    reference_offsets: Uint32Array,
    reference_targets: Uint32Array,
  ) => number;
  setSpillBlockers: (sheet: number, bounds: Uint32Array) => boolean;
  setString: (
    sheet: number,
    row: number,
    col: number,
    value: string,
    style: number,
  ) => void;
  setTable: (
    id: string,
    name: string,
    sheet: number,
    row_start: number,
    col_start: number,
    row_end: number,
    col_end: number,
    header_row: boolean,
    totals_row: boolean,
    column_ids: string[],
    column_names: string[],
  ) => boolean;
  snapshotNumbers: (snapshot: RangeSnapshot) => Float64Array;
  snapshotTexts: (snapshot: RangeSnapshot) => string[];
  sortRows: (sheet: number, col: number, ascending: boolean) => Uint32Array;
  sortRowsMulti: (
    sheet: number,
    cols: Uint32Array,
    ascending: Uint8Array,
    candidates: Uint32Array,
  ) => Uint32Array;
  spillAnchorCol: (sheet: number, row: number, col: number) => number;
  spillAnchorRow: (sheet: number, row: number, col: number) => number;
  spillDerivedMask: (
    sheet: number,
    row_start: number,
    row_end: number,
    cols: Uint32Array,
  ) => Uint8Array;
  spillOwnerCoordinates: (
    sheet: number,
    row_start: number,
    row_end: number,
    cols: Uint32Array,
  ) => Uint32Array;
  styleIdAt: (sheet: number, row: number, col: number) => number;
  wasmCommittedBytes: () => number;
}