logisheets 0.7.0 → 1.0.0

package/dist/src/api/block_manager.d.ts

@@ -0,0 +1,21 @@
+export declare class BlockManager {
+    constructor(checkBindBlock: (sheetIdx: number, blockId: number, rowCount: number, colCount: number) => boolean, getAvailableBlockId: (sheetIdx: number) => number);
+    /**
+     * Todo: make sure that the block/craft will never be changed by other
+     * crafts.
+     */
+    bindBlock(sheetIdx: number, blockId: number, rowCount: number, colCount: number): boolean;
+    /**
+     * This function should only find the greatest block id when the available block id
+     * has been set. After that, it will always use the cached value.
+     * This means that every time you call this function after initialization,
+     * it will return a new block id. It will lead to the waste of block ids if you don't create
+     * a block with this id.
+     *
+     * Block id is `usize` in `WASM` side. It should be enough for most cases even we waste some of the ids.
+     */
+    getAvailableBlockId(sheetIdx: number): number;
+    private sheetAvailableBlockIds;
+    private _checkBindBlock;
+    private _getAvailableBlockId;
+}

package/dist/src/api/block_manager.js

@@ -0,0 +1,35 @@
+export class BlockManager {
+    constructor(checkBindBlock, getAvailableBlockId) {
+        this._checkBindBlock = checkBindBlock;
+        this._getAvailableBlockId = getAvailableBlockId;
+    }
+    /**
+     * Todo: make sure that the block/craft will never be changed by other
+     * crafts.
+     */
+    bindBlock(sheetIdx, blockId, rowCount, colCount) {
+        return this._checkBindBlock(sheetIdx, blockId, rowCount, colCount);
+    }
+    /**
+     * This function should only find the greatest block id when the available block id
+     * has been set. After that, it will always use the cached value.
+     * This means that every time you call this function after initialization,
+     * it will return a new block id. It will lead to the waste of block ids if you don't create
+     * a block with this id.
+     *
+     * Block id is `usize` in `WASM` side. It should be enough for most cases even we waste some of the ids.
+     */
+    getAvailableBlockId(sheetIdx) {
+        if (this.sheetAvailableBlockIds.has(sheetIdx)) {
+            const result = this.sheetAvailableBlockIds.get(sheetIdx);
+            this.sheetAvailableBlockIds.set(sheetIdx, result + 1);
+            return result;
+        }
+        const id = this._getAvailableBlockId(sheetIdx);
+        this.sheetAvailableBlockIds.set(sheetIdx, id);
+        return id;
+    }
+    sheetAvailableBlockIds = new Map();
+    _checkBindBlock;
+    _getAvailableBlockId;
+}

package/dist/src/api/calculator.d.ts

@@ -0,0 +1,19 @@
+import { AsyncFuncResult, Task } from '../bindings';
+export declare const enum CalcException {
+    Unspecified = 0,
+    ArgErr = 1,
+    TimeOut = 2,
+    NotFound = 3
+}
+export type Executor = (args: readonly string[]) => Promise<string | CalcException>;
+export declare class CustomFunc {
+    readonly funcName: string;
+    executor: Executor;
+    constructor(funcName: string, executor: Executor);
+}
+export declare class Calculator {
+    calc(tasks: readonly Task[]): Promise<AsyncFuncResult>;
+    registry(f: CustomFunc): void;
+    private _exec;
+    private _registry;
+}

package/dist/src/api/calculator.js

@@ -0,0 +1,46 @@
+export class CustomFunc {
+    funcName;
+    executor;
+    constructor(funcName, executor) {
+        this.funcName = funcName;
+        this.executor = executor;
+    }
+}
+export class Calculator {
+    async calc(tasks) {
+        const promises = tasks.map((t) => this._exec(t.asyncFunc, t.args));
+        return Promise.all(promises).then((values) => {
+            const res = values.map((v) => {
+                if (typeof v === 'string') {
+                    return v;
+                }
+                switch (v) {
+                    case 1 /* CalcException.ArgErr */:
+                        return '#ARGERR!';
+                    case 2 /* CalcException.TimeOut */:
+                        return '#TIMEOUT!';
+                    case 3 /* CalcException.NotFound */:
+                        return '#NOTFOUND!';
+                    default:
+                        return '#UNKNOWN!';
+                }
+            });
+            const asyncFuncResult = {
+                tasks,
+                values: res,
+            };
+            return asyncFuncResult;
+        });
+    }
+    registry(f) {
+        this._registry.set(f.funcName, f.executor);
+    }
+    async _exec(func, args) {
+        const executor = this._registry.get(func);
+        if (executor === undefined) {
+            return 3 /* CalcException.NotFound */;
+        }
+        return executor(args);
+    }
+    _registry = new Map();
+}

package/dist/src/api/cell.d.ts

@@ -0,0 +1,29 @@
+import { CellInfo, Value, Style } from '../bindings';
+export declare class Cell {
+    constructor(cellInfo: CellInfo);
+    getText(): string;
+    getStyle(): Style;
+    getFormula(): string;
+    getBlockId(): number | undefined;
+    toCellInfo(): CellInfo;
+    private _value;
+    private _info;
+}
+export declare class CellValue {
+    cellValueOneof?: {
+        $case: 'str';
+        str: string;
+    } | {
+        $case: 'number';
+        number: number;
+    } | {
+        $case: 'bool';
+        bool: boolean;
+    } | {
+        $case: 'error';
+        error: string;
+    };
+    get value(): string | number | boolean;
+    get valueStr(): string;
+    static from(value: Value): CellValue;
+}

package/dist/src/api/cell.js

@@ -0,0 +1,55 @@
+export class Cell {
+    constructor(cellInfo) {
+        this._value = CellValue.from(cellInfo.value);
+        this._info = cellInfo;
+    }
+    getText() {
+        return this._value.valueStr ?? '';
+    }
+    getStyle() {
+        return this._info.style;
+    }
+    getFormula() {
+        return this._info.formula;
+    }
+    getBlockId() {
+        return this._info.blockId;
+    }
+    toCellInfo() {
+        return this._info;
+    }
+    _value;
+    _info;
+}
+export class CellValue {
+    cellValueOneof;
+    get value() {
+        if (this.cellValueOneof?.$case === 'str')
+            return this.cellValueOneof.str;
+        else if (this.cellValueOneof?.$case === 'bool')
+            return this.cellValueOneof.bool;
+        else if (this.cellValueOneof?.$case === 'error')
+            return this.cellValueOneof.error;
+        else if (this.cellValueOneof?.$case === 'number')
+            return this.cellValueOneof.number;
+        else
+            return '';
+    }
+    get valueStr() {
+        return this.value.toString();
+    }
+    static from(value) {
+        const v = new CellValue();
+        if (value === 'empty')
+            return v;
+        if (value.type === 'str')
+            v.cellValueOneof = { $case: 'str', str: value.value };
+        else if (value.type === 'bool')
+            v.cellValueOneof = { $case: 'bool', bool: value.value };
+        else if (value.type === 'number')
+            v.cellValueOneof = { $case: 'number', number: value.value };
+        else if (value.type === 'error')
+            v.cellValueOneof = { $case: 'error', error: value.value };
+        return v;
+    }
+}

package/dist/src/api/craft-calc.d.ts

@@ -0,0 +1,83 @@
+import type { Value } from '../bindings/value';
+import type { Client } from '../client';
+/**
+ * Per-craft temporary-calculation handle.
+ *
+ * Each craft (or the host UI, treated identically) acquires one of these
+ * via {@link acquireCraftCalc}. The handle scopes a private range of
+ * ephemeral cell ids; the craft picks small `localId` numbers and never
+ * sees engine-wide ids.
+ *
+ * Two flavours:
+ *  - {@link calcOnce} — fire-and-forget. Uses one reserved slot inside
+ *    the craft's range; each call overwrites the previous result.
+ *  - {@link setCalc} / {@link getCalc} / {@link dropCalc} — caller-owned
+ *    `localId`. The slot persists (and auto-recomputes on dep changes)
+ *    until dropped.
+ *
+ * Slot 0 inside each craft range is reserved for `calcOnce`; user
+ * `localId`s are transparently offset by 1 so they cannot collide.
+ *
+ * Lifetime notes:
+ *  - Ephemeral cells are wiped on file save/load (that's what "ephemeral"
+ *    means). No reload-survival design is needed.
+ *  - `dropCalc` removes one slot; `dropAll` removes every slot the craft
+ *    has touched in this session — both emit `ephemeralCellRemove`
+ *    payloads which free the container slot and detach the cell from the
+ *    dependency graph.
+ */
+export declare class CraftCalc {
+    private readonly _workbook;
+    private static readonly HOST_SHEET_IDX;
+    private readonly _base;
+    private _sheetId;
+    private readonly _live;
+    constructor(_workbook: Client, base: number);
+    /**
+     * Evaluate `formula` once and return the result. Internally uses the
+     * craft's reserved one-shot slot; consecutive calls overwrite each
+     * other. Safe across calls within the same craft (the slot is
+     * craft-private); concurrent in-flight calls within one craft race
+     * for the slot — caller should await one before issuing the next.
+     *
+     * `formula` may be passed with or without a leading `=`.
+     */
+    calcOnce(formula: string): Promise<Value>;
+    /**
+     * Set (or replace) the formula in a caller-owned slot and return the
+     * freshly computed value. `localId` is craft-local — pick any
+     * non-negative integer; collisions between crafts are impossible.
+     */
+    setCalc(localId: number, formula: string): Promise<Value>;
+    /**
+     * Read the current value of a previously-set slot. The value
+     * auto-tracks dependency changes (same depgraph the workbook uses
+     * for normal cells), so repeated `getCalc` calls reflect the latest
+     * state without re-issuing the formula.
+     *
+     * Throws if `localId` was never `setCalc`-ed (or has been dropped).
+     */
+    getCalc(localId: number): Promise<Value>;
+    /**
+     * Release a caller-owned slot. Emits one `ephemeralCellRemove`
+     * payload — frees the container slot and removes the cell from the
+     * dependency graph. Safe to call on a slot that was never written
+     * (the engine treats it as a no-op).
+     */
+    dropCalc(localId: number): Promise<void>;
+    /**
+     * Release every slot this handle has touched this session in one
+     * transaction. Call on craft unmount.
+     */
+    dropAll(): Promise<void>;
+    private _oneShotEngineId;
+    private _userEngineId;
+    private _resolveSheetId;
+    private _remove;
+    private _evaluate;
+}
+/**
+ * Allocate a fresh ephemeral-id range and return a {@link CraftCalc}
+ * handle scoped to it. Call once per craft (or per host-UI context).
+ */
+export declare function acquireCraftCalc(workbook: Client): CraftCalc;

package/dist/src/api/craft-calc.js

@@ -0,0 +1,223 @@
+import { EphemeralCellInputBuilder } from '../bindings/ephemeral_cell_input';
+import { EphemeralCellRemoveBuilder } from '../bindings/ephemeral_cell_remove';
+import { isErrorMessage } from './utils';
+// Ephemeral-cell-id partitioning:
+//
+//   0x0000_0000_0000_0000 .. 0x0000_0000_FFFF_FFFF   engine-reserved
+//   0x0000_0001_0000_0000 .. ...                     per-craft ranges
+//
+// Each craft gets a fresh range of CRAFT_RANGE_SIZE ids on acquire.
+// JS Number is safe to 2^53, the bindings take id as `number`, so we
+// keep both base and offset in plain Number. With 2^32 reserved for the
+// engine and 2^20 per craft, we can hand out ~2^21 craft ranges before
+// running into precision concerns — plenty.
+const ENGINE_RESERVED_END = 0x1_0000_0000; // 2^32
+const CRAFT_RANGE_SIZE = 1 << 20; // 2^20 ids per craft
+// Bumped on every acquire. Lives for the JS session only; on reload
+// crafts re-acquire and get fresh ranges. Since crafts hold no state of
+// their own and rebuild from blocks, the id range identity does not need
+// to survive reloads.
+let nextCraftBase = ENGINE_RESERVED_END;
+/**
+ * Per-craft temporary-calculation handle.
+ *
+ * Each craft (or the host UI, treated identically) acquires one of these
+ * via {@link acquireCraftCalc}. The handle scopes a private range of
+ * ephemeral cell ids; the craft picks small `localId` numbers and never
+ * sees engine-wide ids.
+ *
+ * Two flavours:
+ *  - {@link calcOnce} — fire-and-forget. Uses one reserved slot inside
+ *    the craft's range; each call overwrites the previous result.
+ *  - {@link setCalc} / {@link getCalc} / {@link dropCalc} — caller-owned
+ *    `localId`. The slot persists (and auto-recomputes on dep changes)
+ *    until dropped.
+ *
+ * Slot 0 inside each craft range is reserved for `calcOnce`; user
+ * `localId`s are transparently offset by 1 so they cannot collide.
+ *
+ * Lifetime notes:
+ *  - Ephemeral cells are wiped on file save/load (that's what "ephemeral"
+ *    means). No reload-survival design is needed.
+ *  - `dropCalc` removes one slot; `dropAll` removes every slot the craft
+ *    has touched in this session — both emit `ephemeralCellRemove`
+ *    payloads which free the container slot and detach the cell from the
+ *    dependency graph.
+ */
+export class CraftCalc {
+    _workbook;
+    // Host scratch sheet hosting all ephemeral calc cells. Sheet 0 is
+    // always present in any workbook this API targets. BLOCKREF and
+    // other ref-name lookups don't care which sheet hosts the cell.
+    static HOST_SHEET_IDX = 0;
+    _base;
+    // Cached resolved sheetId for HOST_SHEET_IDX.
+    _sheetId;
+    // Engine ids of every slot we've written this session, so dropAll
+    // can flush them all. `_oneShotEngineId()` lazily lands here too the
+    // first time calcOnce runs.
+    _live = new Set();
+    constructor(_workbook, base) {
+        this._workbook = _workbook;
+        this._base = base;
+    }
+    /**
+     * Evaluate `formula` once and return the result. Internally uses the
+     * craft's reserved one-shot slot; consecutive calls overwrite each
+     * other. Safe across calls within the same craft (the slot is
+     * craft-private); concurrent in-flight calls within one craft race
+     * for the slot — caller should await one before issuing the next.
+     *
+     * `formula` may be passed with or without a leading `=`.
+     */
+    async calcOnce(formula) {
+        return this._evaluate(this._oneShotEngineId(), formula);
+    }
+    /**
+     * Set (or replace) the formula in a caller-owned slot and return the
+     * freshly computed value. `localId` is craft-local — pick any
+     * non-negative integer; collisions between crafts are impossible.
+     */
+    async setCalc(localId, formula) {
+        return this._evaluate(this._userEngineId(localId), formula);
+    }
+    /**
+     * Read the current value of a previously-set slot. The value
+     * auto-tracks dependency changes (same depgraph the workbook uses
+     * for normal cells), so repeated `getCalc` calls reflect the latest
+     * state without re-issuing the formula.
+     *
+     * Throws if `localId` was never `setCalc`-ed (or has been dropped).
+     */
+    async getCalc(localId) {
+        const sheetId = await this._resolveSheetId();
+        const engineId = this._userEngineId(localId);
+        const infos = await this._workbook.batchGetCellInfoById({
+            ids: [
+                {
+                    sheetId,
+                    cellId: { type: 'ephemeralCell', value: engineId },
+                },
+            ],
+        });
+        if (isErrorMessage(infos))
+            throw new Error(`getCalc(${localId}) failed: ${JSON.stringify(infos)}`);
+        return infos[0].value;
+    }
+    /**
+     * Release a caller-owned slot. Emits one `ephemeralCellRemove`
+     * payload — frees the container slot and removes the cell from the
+     * dependency graph. Safe to call on a slot that was never written
+     * (the engine treats it as a no-op).
+     */
+    async dropCalc(localId) {
+        await this._remove(this._userEngineId(localId));
+    }
+    /**
+     * Release every slot this handle has touched this session in one
+     * transaction. Call on craft unmount.
+     */
+    async dropAll() {
+        if (this._live.size === 0)
+            return;
+        const payloads = Array.from(this._live).map((engineId) => ({
+            type: 'ephemeralCellRemove',
+            value: new EphemeralCellRemoveBuilder()
+                .sheetIdx(CraftCalc.HOST_SHEET_IDX)
+                .id(engineId)
+                .build(),
+        }));
+        this._live.clear();
+        const res = await this._workbook.handleTransaction({
+            transaction: { payloads, undoable: false, temp: false },
+        });
+        if (isErrorMessage(res))
+            throw new Error(`dropAll failed: ${JSON.stringify(res)}`);
+    }
+    // -- internals ------------------------------------------------------
+    _oneShotEngineId() {
+        return this._base; // slot 0 inside the range
+    }
+    _userEngineId(localId) {
+        if (!Number.isInteger(localId) || localId < 0)
+            throw new Error(`localId must be a non-negative integer: ${localId}`);
+        const offset = localId + 1; // reserve slot 0 for calcOnce
+        if (offset >= CRAFT_RANGE_SIZE)
+            throw new Error(`localId ${localId} exceeds craft range size ${CRAFT_RANGE_SIZE}`);
+        return this._base + offset;
+    }
+    async _resolveSheetId() {
+        if (this._sheetId !== undefined)
+            return this._sheetId;
+        const r = await this._workbook.getSheetId({
+            sheetIdx: CraftCalc.HOST_SHEET_IDX,
+        });
+        if (isErrorMessage(r))
+            throw new Error(`CraftCalc: getSheetId(0) failed: ${JSON.stringify(r)}`);
+        this._sheetId = r;
+        return r;
+    }
+    async _remove(engineId) {
+        this._live.delete(engineId);
+        const res = await this._workbook.handleTransaction({
+            transaction: {
+                payloads: [
+                    {
+                        type: 'ephemeralCellRemove',
+                        value: new EphemeralCellRemoveBuilder()
+                            .sheetIdx(CraftCalc.HOST_SHEET_IDX)
+                            .id(engineId)
+                            .build(),
+                    },
+                ],
+                undoable: false,
+                temp: false,
+            },
+        });
+        if (isErrorMessage(res))
+            throw new Error(`CraftCalc: drop failed: ${JSON.stringify(res)}`);
+    }
+    async _evaluate(engineId, formula) {
+        this._live.add(engineId);
+        const expr = formula.startsWith('=') ? formula : `=${formula}`;
+        const writeResult = await this._workbook.handleTransaction({
+            transaction: {
+                payloads: [
+                    {
+                        type: 'ephemeralCellInput',
+                        value: new EphemeralCellInputBuilder()
+                            .sheetIdx(CraftCalc.HOST_SHEET_IDX)
+                            .id(engineId)
+                            .content(expr)
+                            .build(),
+                    },
+                ],
+                undoable: false,
+                temp: false,
+            },
+        });
+        if (isErrorMessage(writeResult))
+            throw new Error(`CraftCalc: formula evaluation failed: ${JSON.stringify(writeResult)}`);
+        const sheetId = await this._resolveSheetId();
+        const infos = await this._workbook.batchGetCellInfoById({
+            ids: [
+                {
+                    sheetId,
+                    cellId: { type: 'ephemeralCell', value: engineId },
+                },
+            ],
+        });
+        if (isErrorMessage(infos))
+            throw new Error(`CraftCalc: read-back failed: ${JSON.stringify(infos)}`);
+        return infos[0].value;
+    }
+}
+/**
+ * Allocate a fresh ephemeral-id range and return a {@link CraftCalc}
+ * handle scoped to it. Call once per craft (or per host-UI context).
+ */
+export function acquireCraftCalc(workbook) {
+    const base = nextCraftBase;
+    nextCraftBase += CRAFT_RANGE_SIZE;
+    return new CraftCalc(workbook, base);
+}

package/dist/src/api/index.d.ts

@@ -1,2 +1,8 @@
 export * from './workbook';
 export * from './worksheet';
+export { CalcException, CustomFunc, Calculator } from './calculator';
+export type { Executor } from './calculator';
+export * from './cell';
+export { CraftCalc, acquireCraftCalc } from './craft-calc';
+export { isErrorMessage, getPatternFill } from './utils';
+export type { Result } from './utils';

package/dist/src/api/index.js

@@ -1,2 +1,6 @@
 export * from './workbook';
 export * from './worksheet';
+export { CustomFunc, Calculator } from './calculator';
+export * from './cell';
+export { CraftCalc, acquireCraftCalc } from './craft-calc';
+export { isErrorMessage, getPatternFill } from './utils';

package/dist/src/api/utils.d.ts

@@ -1,3 +1,5 @@
+import { Fill, PatternFill } from '../bindings';
 import { ErrorMessage } from '../bindings/error_message';
 export declare function isErrorMessage(v: any): v is ErrorMessage;
-export declare type Result<V> = V | ErrorMessage;
+export type Result<V> = V | ErrorMessage;
+export declare function getPatternFill(v: Fill): PatternFill | null;

package/dist/src/api/utils.js

@@ -1,4 +1,11 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isErrorMessage(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
     return 'msg' in v && 'ty' in v;
 }
+export function getPatternFill(v) {
+    if (v.type === 'patternFill')
+        return v.value;
+    return null;
+}

package/dist/src/api/workbook.d.ts

@@ -1,18 +1,90 @@
-import { ActionEffect, AsyncFuncResult, DisplayResponse } from '../bindings';
-import { Transaction } from '../transactions';
+import { ActionEffect, BlockField, FormulaDisplayInfo, ShadowCellInfo, SheetCellId, SheetInfo, SaveFileResult, AppData, CellInfo, CellCoordinateWithSheet, Transaction, GetBlockValuesParams, GetCellIdParams, GetShadowCellIdParams, GetShadowCellIdsParams, GetAvailableBlockIdParams, TempStatusDiff } from '../bindings';
+import { ColId, RowId } from '../types';
 import { Worksheet } from './worksheet';
-export declare type ReturnCode = number;
+import { CustomFunc } from './calculator';
+import { Result } from './utils';
+export type ReturnCode = number;
+export type Callback = () => void;
+export type CellIdCallback = (cellId: SheetCellId) => void;
 export declare class Workbook {
     constructor();
+    getSheetIdx(sheetId: number): Result<number>;
+    getBlockValues(params: GetBlockValuesParams): Result<readonly string[]>;
+    getAvailableBlockId(params: GetAvailableBlockIdParams): Result<number>;
+    /**
+     * @returns the block id if success, otherwise the error message
+     *
+     * It is caller's responsibility to store the block id.
+     */
+    createBlockForNewCraft(sheetIdx: number, masterRow: number, masterCol: number, rowCnt: number, colCnt: number): Result<number>;
     undo(): boolean;
     redo(): boolean;
-    execTransaction(tx: Transaction, undoable: boolean): ActionEffect;
-    load(buf: Uint8Array, book_name: string): ReturnCode;
+    registerCellUpdatedCallback(callback: Callback): void;
+    registerSheetInfoUpdateCallback(callback: Callback): void;
+    /**
+     * Fires after a transaction with sheet indices whose row/column headers
+     * changed (i.e. SetRowHeight / SetColWidth payloads). Useful for the UI
+     * to know which sheets need their header strip re-rendered.
+     */
+    registerHeaderUpdatedCallback(callback: (sheetIdxes: readonly number[]) => void): void;
+    getSheetNameByIdx(idx: number): Result<string>;
+    getAllSheetInfo(): Array<SheetInfo>;
+    checkFormula(f: string): boolean;
+    calcCondition(sheetIdx: number, f: string): Result<boolean>;
+    /**
+     * Resolve a (refName, key, field) triple to a concrete cell, the same
+     * way the BLOCKREF formula resolves at evaluation time. Useful for
+     * subscribing to block cells without threading sheet/block/row/col
+     * coordinates.
+     */
+    getCellIdByBlockRef(refName: string, key: string, field: string): Result<SheetCellId>;
+    /**
+     * Snapshot of all cell-value differences between the active temp
+     * branch and the committed (fork) status. Returns an empty diff
+     * when no temp branch is active. Used by the host's diff layer to
+     * drive its overlay without needing JS-side snapshot/compare.
+     */
+    getTempStatusChanges(): Result<TempStatusDiff>;
+    getSheetId(sheetIdx: number): Result<number>;
+    getBlockRowId(sheetId: number, blockId: number, rowIdx: number): Result<RowId>;
+    getBlockColId(sheetId: number, blockId: number, colIdx: number): Result<ColId>;
+    getDisplayUnitsOfFormula(f: string): Result<FormulaDisplayInfo>;
+    onCellValueChanged(sheetIdx: number, rowIdx: number, colIdx: number, callback: Callback): Result<void>;
+    onCellRemoved(sheetIdx: number, rowIdx: number, colIdx: number, callback: Callback): Result<void>;
+    onShadowCellValueChanged(sheetIdx: number, rowIdx: number, colIdx: number, callback: Callback): Result<void>;
+    private _registerCellRemovedCallback;
+    private _registerCellValueChangedCallback;
+    registerCellValueChangedByCellId(cellId: SheetCellId, callback: Callback): void;
+    commitTempStatus(): void;
+    cleanupTempStatus(): void;
+    toggleStatus(useTemp: boolean): void;
+    batchGetCellInfoById(ids: readonly SheetCellId[]): Result<readonly CellInfo[]>;
+    batchGetCellCoordinateWithSheetById(ids: readonly SheetCellId[]): Result<readonly CellCoordinateWithSheet[]>;
+    execTransaction(tx: Transaction): ActionEffect;
+    load(buf: Uint8Array, bookName: string): ReturnCode;
+    save(data: string): SaveFileResult;
+    getAppData(): readonly AppData[];
     release(): void;
-    inputAsyncResult(r: AsyncFuncResult): ActionEffect;
-    getPatches(sheet_idx: number, version: number): DisplayResponse;
-    get_sheet_count(): number;
-    get_worksheet(idx: number): Worksheet;
-    private _addPayload;
+    getSheetCount(): number;
+    getWorksheet(idx: number): Worksheet;
+    getWorksheetById(id: number): Worksheet;
+    registryCustomFunc(customFunc: CustomFunc): void;
+    getShadowCellId(params: GetShadowCellIdParams): Result<number>;
+    getShadowCellIds(params: GetShadowCellIdsParams): Result<readonly number[]>;
+    getShadowInfoById(params: {
+        shadowId: number;
+    }): Result<ShadowCellInfo>;
+    getCellId(params: GetCellIdParams): Result<SheetCellId>;
+    getAllBlockFields(): Result<readonly BlockField[]>;
+    private _inputAsyncResult;
+    private _onCellUpdate;
+    private _onSheetUpdate;
+    private _cellUpdatedCallbacks;
+    private _sheetInfoUpdatedCallbacks;
+    private _headerUpdatedCallbacks;
+    private _cellValueChangedCallbacks;
+    private _cellRemovedCallbacks;
     private _id;
+    private _blockManager;
+    private _calculator;
 }