logisheets 1.15.0 → 1.16.0

package/dist/src/api/workbook.js

@@ -6,6 +6,10 @@ const worksheet_1 = require("./worksheet");
 const calculator_1 = require("./calculator");
 const utils_1 = require("./utils");
 const block_manager_1 = require("./block_manager");
+// Every engine call is one `handle(msg, bookId)` into the WASM, where `msg` is
+// the bare method name for a parameterless call and `{method, value}`
+// otherwise. `handle` never throws for an engine failure: it returns an
+// `ErrorMessage`, which is why the methods below type their result `Result<T>`.
 function rpc(method, params, bookId
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
@@ -17,7 +21,27 @@ function rpc(method, params, bookId
 function newGuid() {
     return `{${crypto.randomUUID()}}`;
 }
+/**
+ * A synchronous handle on one engine workbook, living in the calling thread.
+ *
+ * In the browser, `initWasm()` must have resolved before the constructor runs;
+ * the Node build needs no init. The app does not use this directly on the main
+ * thread: logisheets-engine runs one inside its web worker and exposes it as
+ * the async {@link Client}. Shared code should target `Client`.
+ *
+ * Conventions for every method:
+ *  - Sheet, row and column indexes are 0-based. `sheetIdx` is the tab
+ *    position (changes when sheets move); `sheetId` is stable. Convert with
+ *    {@link getSheetId} / {@link getSheetIdx}.
+ *  - Reads return `Result<T>`: an `ErrorMessage` on failure, never a throw.
+ *  - Writes go through {@link execTransaction}, which reports a rejection in
+ *    the returned `ActionEffect` rather than throwing.
+ *
+ * Call {@link release} when done; the engine keeps the workbook alive until
+ * then.
+ */
 class Workbook {
+    /** Allocates a new, empty workbook in the engine. */
     constructor() {
         this._id = rpc('newWorkbook');
         this._blockManager = new block_manager_1.BlockManager((sheetIdx, blockId, rowCount, colCount) => {
@@ -26,19 +50,28 @@ class Workbook {
             return rpc('getAvailableBlockId', { sheetIdx }, this._id);
         });
     }
+    /** Current tab position of the sheet with stable id `sheetId`. */
     getSheetIdx(sheetId) {
         return rpc('getSheetIdx', { sheetId }, this._id);
     }
     getBlockValues(params) {
         return rpc('getBlockValues', params, this._id);
     }
+    /**
+     * An unused block id on the sheet, asked of the engine every call and not
+     * reserved: two calls before a `createBlock` return the same id.
+     * {@link createBlockForNewCraft} instead hands out ids from a local
+     * counter.
+     */
     getAvailableBlockId(params) {
         return rpc('getAvailableBlockId', params, this._id);
     }
     /**
-     * @returns the block id if success, otherwise the error message
+     * Create a `rowCnt` x `colCnt` block whose master (top-left) cell is at
+     * (`masterRow`, `masterCol`), as a non-undoable transaction.
      *
-     * It is caller's responsibility to store the block id.
+     * @returns the new block id, or an `ErrorMessage` if the engine rejected
+     * the block. The caller must store the id; nothing else records it.
      */
     createBlockForNewCraft(sheetIdx, masterRow, masterCol, rowCnt, colCnt) {
         const id = this._blockManager.getAvailableBlockId(sheetIdx);
@@ -168,6 +201,8 @@ class Workbook {
             temp: false,
         });
     }
+    /** Undo the last undoable transaction. `false` when there was nothing to
+     *  undo; on `true` the cell and sheet update callbacks fire. */
     undo() {
         const result = rpc('undo', undefined, this._id);
         if (result) {
@@ -176,6 +211,7 @@ class Workbook {
         }
         return result;
     }
+    /** Redo the last undone transaction. Same contract as {@link undo}. */
     redo() {
         const result = rpc('redo', undefined, this._id);
         if (result) {
@@ -184,9 +220,13 @@ class Workbook {
         }
         return result;
     }
+    /** Called after a transaction reporting cell changes, after undo/redo,
+     *  and when async custom-function results land. No unsubscribe. */
     registerCellUpdatedCallback(callback) {
         this._cellUpdatedCallbacks.push(callback);
     }
+    /** Called after a transaction reporting sheet-level changes, and after
+     *  undo/redo. No unsubscribe. */
     registerSheetInfoUpdateCallback(callback) {
         this._sheetInfoUpdatedCallbacks.push(callback);
     }
@@ -201,6 +241,7 @@ class Workbook {
     getSheetNameByIdx(idx) {
         return rpc('getSheetNameByIdx', { idx }, this._id);
     }
+    /** Every sheet, in tab order. */
     getAllSheetInfo() {
         return rpc('getAllSheetInfo', undefined, this._id);
     }
@@ -212,9 +253,17 @@ class Workbook {
     getFormulaFunctionNames() {
         return rpc('getFormulaFunctionNames', undefined, this._id);
     }
+    /** Whether `f` looks like a formula: it must start with `=` and the rest
+     *  must lex. A cheap syntax screen, not a full parse; nothing is evaluated. */
     checkFormula(f) {
         return rpc('checkFormula', { formula: f }, this._id);
     }
+    /**
+     * Evaluate a boolean formula on sheet `sheetIdx`. `f` is written as cell
+     * content into one engine-owned scratch ephemeral cell, so a formula needs
+     * its leading `=`. An `ErrorMessage` when the result is an error value or
+     * the write is rejected.
+     */
     calcCondition(sheetIdx, f) {
         return rpc('calcCondition', { sheetIdx, condition: f }, this._id);
     }
@@ -255,6 +304,7 @@ class Workbook {
     isInTempMode() {
         return rpc('isInTempMode', undefined, this._id);
     }
+    /** Stable id of the sheet at tab position `sheetIdx`. */
     getSheetId(sheetIdx) {
         return rpc('getSheetId', { sheetIdx }, this._id);
     }
@@ -267,6 +317,11 @@ class Workbook {
     getDisplayUnitsOfFormula(f) {
         return rpc('getDisplayUnitsOfFormula', { formula: f }, this._id);
     }
+    /**
+     * Subscribe to value changes of the cell now at (sheetIdx, rowIdx,
+     * colIdx). The coordinate is resolved to a cell id once, up front.
+     * Returns an `ErrorMessage` if it cannot be resolved.
+     */
     onCellValueChanged(sheetIdx, rowIdx, colIdx, callback) {
         const cellId = this.getCellId({ sheetIdx, rowIdx, colIdx });
         if ((0, utils_1.isErrorMessage)(cellId)) {
@@ -307,21 +362,45 @@ class Workbook {
     registerCellValueChangedByCellId(cellId, callback) {
         this._registerCellValueChangedCallback(cellId, callback);
     }
+    /**
+     * Temp branch (speculative edits). Transactions sent with `temp: true`
+     * land on ONE workbook-wide branch; {@link commitTempStatus} folds it into
+     * the real state, {@link cleanupTempStatus} discards all of it, and
+     * {@link toggleStatus} picks which state reads are served from. Any
+     * non-temp write discards the branch. Check {@link isInTempMode} before
+     * assuming the slot is free.
+     */
     commitTempStatus() {
-        rpc('commitTempStatus', undefined, this._id);
+        return rpc('commitTempStatus', undefined, this._id);
     }
     cleanupTempStatus() {
-        rpc('cleanupTempStatus', undefined, this._id);
+        return rpc('cleanupTempStatus', undefined, this._id);
     }
+    /** Serve reads from the temp branch (`true`) or the committed state. */
     toggleStatus(useTemp) {
-        rpc('toggleStatus', { useTemp }, this._id);
+        return rpc('toggleStatus', { useTemp }, this._id);
     }
+    /** Cell infos for stable cell ids, in input order. Works for ephemeral and
+     *  shadow cells, which have no coordinate. */
     batchGetCellInfoById(ids) {
         return rpc('batchGetCellInfoById', { ids }, this._id);
     }
     batchGetCellCoordinateWithSheetById(ids) {
         return rpc('batchGetCellCoordinateWithSheetById', { ids }, this._id);
     }
+    /**
+     * Apply a transaction: all payloads, in order, as one unit and (when
+     * `tx.undoable`) one undo step.
+     *
+     * Never throws for an engine refusal. A rejected transaction applies
+     * nothing and returns an `ActionEffect` with `status.type === 'err'` and
+     * the reason (naming the offending payload) in `errorMessage`; check it
+     * whenever the write must land. Callbacks fire only on success.
+     *
+     * Custom-function calls in the new formulas come back as `asyncTasks`;
+     * they are run here through the registered {@link CustomFunc}s and their
+     * results fed back later, so those cells update after this returns.
+     */
     execTransaction(tx) {
         const result = rpc('handleTransaction', { transaction: tx }, this._id);
         if (result.asyncTasks.length > 0) {
@@ -371,6 +450,10 @@ class Workbook {
         }
         return result;
     }
+    /**
+     * Replace this workbook's contents with a parsed .xlsx. An unreadable file
+     * comes back as an {@link ErrorMessage} and leaves this workbook as it was.
+     */
     load(buf, bookName) {
         return rpc('loadWorkbook', { content: Array.from(buf), name: bookName }, this._id);
     }
@@ -383,10 +466,16 @@ class Workbook {
      * so a file Excel must recalculate needs the coordinates. One-way — a
      * resolved `BLOCKREFS` becomes a plain range, which LogiSheets does not
      * parse back when it straddles a block.
+     *
+     * `data` is the opaque AppData string stored in the file (craft state and
+     * friends); read it back with {@link getAppData} after a load. Despite the
+     * return type, a failed save returns an `ErrorMessage`: check with
+     * `isErrorMessage`.
      */
     save(data, resolveBlockRefs = false) {
         return rpc('saveWorkbook', { appData: data, resolveBlockRefs }, this._id);
     }
+    /** The AppData entries carried by the loaded file (see {@link save}). */
     getAppData() {
         return rpc('getAppData', undefined, this._id);
     }
@@ -395,12 +484,16 @@ class Workbook {
     getVersion() {
         return rpc('getVersion', undefined, this._id);
     }
+    /** Free the engine workbook. Every later call on this handle, or on a
+     *  `Worksheet` taken from it, is invalid. */
     release() {
         rpc('release', undefined, this._id);
     }
     getSheetCount() {
         return rpc('getSheetCount', undefined, this._id);
     }
+    /** The sheet at tab position `idx`. THROWS when `idx` is out of range,
+     *  unlike the `Result`-returning reads. */
     getWorksheet(idx) {
         if (idx >= this.getSheetCount())
             throw Error(`invalid sheet index: ${idx}`);
@@ -538,12 +631,21 @@ class Workbook {
             temp: false,
         });
     }
+    /** The sheet with stable id `id`. Not validated: an unknown id yields a
+     *  `Worksheet` whose calls fail. */
     getWorksheetById(id) {
         return new worksheet_1.Worksheet(this._id, id, false);
     }
+    /** Make `customFunc.funcName` callable from formulas. The engine hands
+     *  such calls back as async tasks, see {@link execTransaction}. */
     registryCustomFunc(customFunc) {
         this._calculator.registry(customFunc);
     }
+    /**
+     * The id of a cell's shadow: an ephemeral companion cell the engine keeps
+     * per (cell, kind) for validation-style formulas. Allocated on first ask
+     * and stable afterwards.
+     */
     getShadowCellId(params) {
         return rpc('getShadowCellId', params, this._id);
     }
@@ -553,6 +655,8 @@ class Workbook {
     getShadowInfoById(params) {
         return rpc('getShadowInfoById', params, this._id);
     }
+    /** The stable id of the cell at a coordinate. It survives row/column
+     *  insertion and deletion, unlike the coordinate. */
     getCellId(params) {
         return rpc('getCellId', params, this._id);
     }
@@ -599,6 +703,15 @@ class Workbook {
     getEnumSets() {
         return rpc('getEnumSets', undefined, this._id);
     }
+    /**
+     * The workbook's defined names, ordered by name. Each definition is
+     * sheet-qualified (`Sheet1!$B$2:$B$9`) so it reads the same from any sheet.
+     * Define, rename and remove them with the `defineName` / `renameName` /
+     * `removeName` payloads.
+     */
+    getDefinedNames() {
+        return rpc('getDefinedNames', undefined, this._id);
+    }
     /**
      * Every duplicated block row key in the workbook.
      *
@@ -672,6 +785,9 @@ class Workbook {
     _cellUpdatedCallbacks = [];
     _sheetInfoUpdatedCallbacks = [];
     _headerUpdatedCallbacks = [];
+    // NOTE: keyed by SheetCellId OBJECT identity, while execTransaction looks
+    // up the fresh objects each ActionEffect carries, so these lookups do not
+    // match. logisheets-engine's client keys by a string form instead.
     _cellValueChangedCallbacks = new Map();
     _cellRemovedCallbacks = new Map();
     // The book id which is generated by `WASM`

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

@@ -1,7 +1,24 @@
 import { BlockInfo, CellPosition, ColInfo, DisplayWindow, DisplayWindowWithStartPoint, RowInfo, Style, Value, CellInfo, SheetDimension, MergeCell, AppendixWithCell, ReproducibleCell, SheetCoordinate, CellInput, Comment, CellImageInfo, ChartInfo, CfRuleInfo, DependentCell, CellRefRange, LinkInfo } from '../bindings';
 import { Cell } from './cell';
 import { Result } from './utils';
+/**
+ * The read surface of one sheet of a {@link Workbook}. Obtain it from
+ * `Workbook.getWorksheet` / `getWorksheetById`; writes go through the
+ * workbook's transactions.
+ *
+ * The constructor resolves the sheet's tab index AND its stable id once and
+ * caches both. Methods send one or the other to the engine, so after sheets
+ * are created, deleted or moved, take a fresh `Worksheet` rather than keep an
+ * old one.
+ *
+ * Rows and columns are 0-based; `start..end` ranges are inclusive on both
+ * ends. Reads return an `ErrorMessage` instead of throwing. Some are typed
+ * without `Result` but can still return one when the engine refuses (e.g. a
+ * stale sheet), so guard them with `isErrorMessage` too.
+ */
 export declare class Worksheet {
+    /** @param id the engine book id. `sheetIdxOrId` is a tab index, or a
+     *  stable sheet id when `isSheetIdx` is false. */
     constructor(id: number, sheetIdxOrId: number, isSheetIdx?: boolean);
     getSheetDimension(): Result<SheetDimension>;
     /**
@@ -31,15 +48,22 @@ export declare class Worksheet {
     getRightwardDataBoundary(row: number, col: number): CellPosition;
     getDisplayWindowWithCellPosition(row: number, col: number, height: number, width: number): DisplayWindowWithStartPoint;
     getBlockDisplayWindow(blockId: number): Result<DisplayWindow>;
+    /** Row height in points; the sheet default when the row has none set. */
     getRowHeight(rowIdx: number): Result<number>;
     getColWidth(colIdx: number): Result<number>;
     getRowInfo(rowIdx: number): Result<RowInfo>;
     getColInfo(colIdx: number): Result<ColInfo>;
+    /** Value, formula, style and block membership of one cell. An empty cell
+     *  still yields a `CellInfo` (value `'empty'`). */
     getCellInfo(rowIdx: number, colIdx: number): Result<CellInfo>;
     getCellListValidation(rowIdx: number, colIdx: number): Result<readonly string[] | undefined>;
     getReproducibleCell(rowIdx: number, colIdx: number): Result<ReproducibleCell>;
     getReproducibleCells(coordinates: readonly SheetCoordinate[]): Result<readonly ReproducibleCell[]>;
+    /** One `CellInfo` per cell of the inclusive rectangle, row-major. Fails
+     *  whole if any cell fails. */
     getCellInfos(startRow: number, startCol: number, endRow: number, endCol: number): Result<readonly CellInfo[]>;
+    /** Like {@link getCellInfos}, skipping the cells inside the inclusive
+     *  `window*` rectangle (already fetched by the caller). */
     getCellInfosExceptWindow(startRow: number, startCol: number, endRow: number, endCol: number, windowStartRow: number, windowStartCol: number, windowEndRow: number, windowEndCol: number): Result<readonly CellInfo[]>;
     /**
      * Predict the fill-handle result: given a source block and the target
@@ -62,11 +86,18 @@ export declare class Worksheet {
         endRow: number;
         endCol: number;
     }): Result<readonly CellInput[]>;
+    /** A block's geometry, schema and governance fields. Typed without
+     *  `Result` but returns an `ErrorMessage` for an unknown block. */
     getBlockInfo(blockId: number): BlockInfo;
     getMergedCells(startRow: number, startCol: number, endRow: number, endCol: number): readonly MergeCell[];
     getCell(rowIdx: number, colIdx: number): Result<Cell>;
+    /** The cell's formula without the leading `=`, or `''` for a plain value.
+     *  Regenerated from the parsed formula, so not necessarily the text as
+     *  typed. */
     getFormula(rowIdx: number, colIdx: number): Result<string>;
     getStyle(rowIdx: number, colIdx: number): Result<Style>;
+    /** The evaluated value. An empty cell is the string `'empty'`, not an
+     *  object. */
     getValue(rowIdx: number, colIdx: number): Result<Value>;
     getDiyCellIdWithBlockId(blockId: number, row: number, col: number): Result<number>;
     lookupAppendixUpward(blockId: number, row: number, col: number, craftId: string, tag: number): Result<AppendixWithCell>;

package/dist/src/api/worksheet.js

@@ -10,7 +10,24 @@ function rpc(method, params, bookId
     const msg = params === undefined ? method : { method, value: params };
     return (0, logisheets_wasm_server_1.handle)(msg, bookId ?? null);
 }
+/**
+ * The read surface of one sheet of a {@link Workbook}. Obtain it from
+ * `Workbook.getWorksheet` / `getWorksheetById`; writes go through the
+ * workbook's transactions.
+ *
+ * The constructor resolves the sheet's tab index AND its stable id once and
+ * caches both. Methods send one or the other to the engine, so after sheets
+ * are created, deleted or moved, take a fresh `Worksheet` rather than keep an
+ * old one.
+ *
+ * Rows and columns are 0-based; `start..end` ranges are inclusive on both
+ * ends. Reads return an `ErrorMessage` instead of throwing. Some are typed
+ * without `Result` but can still return one when the engine refuses (e.g. a
+ * stale sheet), so guard them with `isErrorMessage` too.
+ */
 class Worksheet {
+    /** @param id the engine book id. `sheetIdxOrId` is a tab index, or a
+     *  stable sheet id when `isSheetIdx` is false. */
     constructor(id, sheetIdxOrId, isSheetIdx = true) {
         this._id = id;
         if (isSheetIdx) {
@@ -128,6 +145,7 @@ class Worksheet {
     getBlockDisplayWindow(blockId) {
         return rpc('getBlockDisplayWindow', { sheetId: this._sheetId, blockId }, this._id);
     }
+    /** Row height in points; the sheet default when the row has none set. */
     getRowHeight(rowIdx) {
         return rpc('getRowHeight', { sheetId: this._sheetId, rowIdx }, this._id);
     }
@@ -140,6 +158,8 @@ class Worksheet {
     getColInfo(colIdx) {
         return rpc('getColInfo', { sheetIdx: this._sheetIdx, colIdx }, this._id);
     }
+    /** Value, formula, style and block membership of one cell. An empty cell
+     *  still yields a `CellInfo` (value `'empty'`). */
     getCellInfo(rowIdx, colIdx) {
         return rpc('getCell', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
@@ -155,9 +175,13 @@ class Worksheet {
     getReproducibleCells(coordinates) {
         return rpc('getReproducibleCells', { sheetIdx: this._sheetIdx, coordinates }, this._id);
     }
+    /** One `CellInfo` per cell of the inclusive rectangle, row-major. Fails
+     *  whole if any cell fails. */
     getCellInfos(startRow, startCol, endRow, endCol) {
         return rpc('getCellInfos', { sheetIdx: this._sheetIdx, startRow, startCol, endRow, endCol }, this._id);
     }
+    /** Like {@link getCellInfos}, skipping the cells inside the inclusive
+     *  `window*` rectangle (already fetched by the caller). */
     getCellInfosExceptWindow(startRow, startCol, endRow, endCol, windowStartRow, windowStartCol, windowEndRow, windowEndCol) {
         return rpc('getCellsExceptWindow', {
             sheetIdx: this._sheetIdx,
@@ -194,6 +218,8 @@ class Worksheet {
             dstEndCol: dst.endCol,
         }, this._id);
     }
+    /** A block's geometry, schema and governance fields. Typed without
+     *  `Result` but returns an `ErrorMessage` for an unknown block. */
     getBlockInfo(blockId) {
         return rpc('getBlockInfo', { sheetId: this._sheetId, blockId }, this._id);
     }
@@ -207,12 +233,17 @@ class Worksheet {
         }
         return new cell_1.Cell(cellInfo);
     }
+    /** The cell's formula without the leading `=`, or `''` for a plain value.
+     *  Regenerated from the parsed formula, so not necessarily the text as
+     *  typed. */
     getFormula(rowIdx, colIdx) {
         return rpc('getFormula', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
     getStyle(rowIdx, colIdx) {
         return rpc('getStyle', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }
+    /** The evaluated value. An empty cell is the string `'empty'`, not an
+     *  object. */
     getValue(rowIdx, colIdx) {
         return rpc('getValue', { sheetIdx: this._sheetIdx, row: rowIdx, col: colIdx }, this._id);
     }

package/dist/src/bindings/block_schema.d.ts

@@ -10,5 +10,6 @@ export interface BlockSchema {
     fields: readonly BlockSchemaFieldEntry[];
     randomEntries: readonly BlockSchemaRandomEntry[];
     headerIdx?: number;
+    keyIdx?: number;
     uniqueTogether: readonly UniqueTogetherGroup[];
 }

package/dist/src/bindings/define_name.d.ts

@@ -0,0 +1,18 @@
+export interface DefineName {
+    name: string;
+    formula: string;
+    sheetIdx: number;
+}
+export declare class DefineNameBuilder {
+    private _name;
+    private _formula;
+    private _sheetIdx;
+    name(value: string): this;
+    formula(value: string): this;
+    sheetIdx(value: number): this;
+    build(): {
+        name: string;
+        formula: string;
+        sheetIdx: number;
+    };
+}

package/dist/src/bindings/define_name.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefineNameBuilder = void 0;
+class DefineNameBuilder {
+    _name;
+    _formula;
+    _sheetIdx;
+    name(value) {
+        this._name = value;
+        return this;
+    }
+    formula(value) {
+        this._formula = value;
+        return this;
+    }
+    sheetIdx(value) {
+        this._sheetIdx = value;
+        return this;
+    }
+    build() {
+        if (this._name === undefined)
+            throw new Error('missing name');
+        if (this._formula === undefined)
+            throw new Error('missing formula');
+        if (this._sheetIdx === undefined)
+            throw new Error('missing sheetIdx');
+        return { name: this._name, formula: this._formula, sheetIdx: this._sheetIdx };
+    }
+}
+exports.DefineNameBuilder = DefineNameBuilder;

package/dist/src/bindings/defined_name_info.d.ts

@@ -0,0 +1,4 @@
+export interface DefinedNameInfo {
+    name: string;
+    formula: string;
+}

package/dist/src/bindings/defined_name_info.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/bindings/edit_payload.d.ts

@@ -18,6 +18,7 @@ import { CreateDiyCell } from './create_diy_cell';
 import { CreateDiyCellById } from './create_diy_cell_by_id';
 import { CreateLink } from './create_link';
 import { CreateSheet } from './create_sheet';
+import { DefineName } from './define_name';
 import { DeleteCellImage } from './delete_cell_image';
 import { DeleteChart } from './delete_chart';
 import { DeleteCols } from './delete_cols';
@@ -47,6 +48,8 @@ import { RemoveBlock } from './remove_block';
 import { RemoveDiyCell } from './remove_diy_cell';
 import { RemoveDiyCellById } from './remove_diy_cell_by_id';
 import { RemoveEnumSet } from './remove_enum_set';
+import { RemoveName } from './remove_name';
+import { RenameName } from './rename_name';
 import { ReorderBlockLines } from './reorder_block_lines';
 import { ReproduceCells } from './reproduce_cells';
 import { ResizeBlock } from './resize_block';
@@ -159,6 +162,15 @@ export type EditPayload = {
 } | {
     type: 'removeEnumSet';
     value: RemoveEnumSet;
+} | {
+    type: 'defineName';
+    value: DefineName;
+} | {
+    type: 'renameName';
+    value: RenameName;
+} | {
+    type: 'removeName';
+    value: RemoveName;
 } | {
     type: 'cellFormatBrush';
     value: CellFormatBrush;

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

@@ -88,6 +88,8 @@ export * from './ct_font';
 export * from './ct_gradient_fill';
 export * from './ct_gradient_stop';
 export * from './ct_pattern_fill';
+export * from './define_name';
+export * from './defined_name_info';
 export * from './delete_cell_image';
 export * from './delete_chart';
 export * from './delete_cols';
@@ -165,6 +167,8 @@ export * from './remove_block';
 export * from './remove_diy_cell';
 export * from './remove_diy_cell_by_id';
 export * from './remove_enum_set';
+export * from './remove_name';
+export * from './rename_name';
 export * from './reorder_block_lines';
 export * from './reproduce_cells';
 export * from './reproducible_cell';

package/dist/src/bindings/index.js

@@ -105,6 +105,8 @@ __exportStar(require("./ct_font"), exports);
 __exportStar(require("./ct_gradient_fill"), exports);
 __exportStar(require("./ct_gradient_stop"), exports);
 __exportStar(require("./ct_pattern_fill"), exports);
+__exportStar(require("./define_name"), exports);
+__exportStar(require("./defined_name_info"), exports);
 __exportStar(require("./delete_cell_image"), exports);
 __exportStar(require("./delete_chart"), exports);
 __exportStar(require("./delete_cols"), exports);
@@ -182,6 +184,8 @@ __exportStar(require("./remove_block"), exports);
 __exportStar(require("./remove_diy_cell"), exports);
 __exportStar(require("./remove_diy_cell_by_id"), exports);
 __exportStar(require("./remove_enum_set"), exports);
+__exportStar(require("./remove_name"), exports);
+__exportStar(require("./rename_name"), exports);
 __exportStar(require("./reorder_block_lines"), exports);
 __exportStar(require("./reproduce_cells"), exports);
 __exportStar(require("./reproducible_cell"), exports);

package/dist/src/bindings/remove_name.d.ts

@@ -0,0 +1,10 @@
+export interface RemoveName {
+    name: string;
+}
+export declare class RemoveNameBuilder {
+    private _name;
+    name(value: string): this;
+    build(): {
+        name: string;
+    };
+}

package/dist/src/bindings/remove_name.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveNameBuilder = void 0;
+class RemoveNameBuilder {
+    _name;
+    name(value) {
+        this._name = value;
+        return this;
+    }
+    build() {
+        if (this._name === undefined)
+            throw new Error('missing name');
+        return { name: this._name };
+    }
+}
+exports.RemoveNameBuilder = RemoveNameBuilder;

package/dist/src/bindings/rename_name.d.ts

@@ -0,0 +1,14 @@
+export interface RenameName {
+    oldName: string;
+    newName: string;
+}
+export declare class RenameNameBuilder {
+    private _oldName;
+    private _newName;
+    oldName(value: string): this;
+    newName(value: string): this;
+    build(): {
+        oldName: string;
+        newName: string;
+    };
+}

package/dist/src/bindings/rename_name.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenameNameBuilder = void 0;
+class RenameNameBuilder {
+    _oldName;
+    _newName;
+    oldName(value) {
+        this._oldName = value;
+        return this;
+    }
+    newName(value) {
+        this._newName = value;
+        return this;
+    }
+    build() {
+        if (this._oldName === undefined)
+            throw new Error('missing oldName');
+        if (this._newName === undefined)
+            throw new Error('missing newName');
+        return { oldName: this._oldName, newName: this._newName };
+    }
+}
+exports.RenameNameBuilder = RenameNameBuilder;