@sheetxl/sdk 0.8.0-beta.7 → 0.8.0-beta.9

package/types/src/calculation/Calculation.d.ts

@@ -90,12 +90,16 @@ export declare class Calculation extends AbstractModel<State, ICalculation.JSON,
     /** The model-side grids, by grid id (DESIGN-CALC-SERVICE §13.23): what a copy lands on, what a start seeds from. */
     protected readonly _fronts: Map<string, CalcGrid>;
     /** What each model grid is, for the `create` a start sends for it (its size is read then). */
-    protected readonly _gridSpecs: Map<string, Omit<CalcGridSpec, 'name' | 'entireCoords'>>;
+    protected readonly _gridSpecs: Map<string, CalcGridSpec>;
     /** The engine holds grids: from a start's boot until a stop. */
     protected _engineUp: boolean;
     protected _modelStoreRemoveListener: IListener.Remove | null;
     protected _mirrorRemoveListener: IListener.Remove | null;
     _modelMirrorId: string | null;
+    /** Where the owner's sheet list is held ({@link _setSheets}): the model's store, or a transient one with no model. */
+    protected _ownerStore: ITransaction.IStore;
+    /** The record holding the owner's sheet list, in {@link _ownerStore}. */
+    protected _sheetListId: string;
     protected _engineIds: Map<string, string>;
     protected _landingOf: Map<string, string>;
     protected _mirroredId: string | null;
@@ -564,7 +568,7 @@ export declare class Calculation extends AbstractModel<State, ICalculation.JSON,
      * @internal
      */
     _createCalcGrid(options: Calculation.CalcGridOptions): CalcGrid;
-    /** What a `create` for a model grid carries: its description, and its size as it is now. */
+    /** What a `create` for a model grid carries: its description. */
     protected _specOf(front: CalcGrid): CalcGridSpec;
     /**
      * The engine's grid for a model grid, as a `create` describes it. What it pushes reaches the
@@ -611,18 +615,25 @@ export declare class Calculation extends AbstractModel<State, ICalculation.JSON,
     protected _createBackendGrid(options?: CalcGridBackend.ConstructorOptions): CalcGridBackend;
     protected _registerGrid(grid: CalcGridBackend): void;
     protected _unregisterGrid(gridId: string): void;
-    /**
-     * The sheet list as the model holds it now: what a `sheets` message carries, and what a start
-     * seeds the replica from. Read only at those two moments.
-     */
-    protected _liveSheets(): [id: string, name: string | null][];
-    /**
-     * Tells the engine the sheet list as the model holds it now (DESIGN-CALC-SERVICE §8): one
-     * message through the channel, applied at once on a `Running` engine, held in order while
-     * `Starting`, dropped by an `Off` one (whose next start seeds the replica afresh, and which
-     * reads the drop as a write made meanwhile, so that start's pass is full).
+    /** The owner's sheet list as it last said ({@link _setSheets}): what a start seeds the replica from. */
+    protected _heldSheets(): Calculation.SheetList['sheets'];
+    /** One sheet of {@link _heldSheets} by its grid id, or `undefined` for a grid that is no sheet. */
+    protected _heldSheetAt(id: string): Calculation.SheetList['sheets'][number] | undefined;
+    /**
+     * The owner's sheet list as it is now: every sheet's grid id and name, in tab order, hidden ones
+     * included (DESIGN-CALC-SERVICE §8). The owner calls this whenever its list changes - a sheet
+     * added, deleted, moved, copied or renamed - and before any grid that names a sheet in it
+     * seeds. Not on a restore: this record is restored with the owner's own, and the engine's
+     * replica with the engine's store.
+     *
+     * @remarks
+     * Held in the caller's operation (folded into the current commit when none is open) and sent
+     * to the engine as one `sheets` message: applied at once on a `Running` engine, held in order
+     * while `Starting`. An `Off` engine is told nothing; its next start seeds the replica from this
+     * record, and owes a full pass only when a sheet already listed was renamed, moved or removed.
+     * @internal
      */
-    protected _sendSheets(): void;
+    _setSheets(sheets: readonly (readonly [id: string, name: string | null])[]): void;
     /**
      * Replaces the replica with the list a `sheets` message carries.
      *
@@ -634,6 +645,13 @@ export declare class Calculation extends AbstractModel<State, ICalculation.JSON,
      * appended moves nothing; one inserted or deleted ahead of a survivor moves it, and counts.
      */
     protected _applySheets(sheets: readonly (readonly [id: string, name: string | null])[]): void;
+    /**
+     * Before a start applies what it held: every sheet a held \`sheets\` message adds enters the
+     * replica at the end, under the name it was first listed by. A defined name's body is applied
+     * ahead of the seeds and may name a sheet listed while starting; the messages themselves still
+     * apply in send order, so a seed sent before a rename binds the name it was sent under.
+     */
+    protected _enterHeldSheets(held: readonly HeldRequest[]): void;
     /** The model's tables as the replica holds them: by id, each table's name and columns. */
     protected _liveTables(): Map<string, TableSymbols>;
     /** The defined names as the replica holds them: by id, each name's spelling and scope sheet. */
@@ -932,21 +950,22 @@ export declare namespace Calculation {
         /** Told after every pass that wrote the grid. */
         onCalculated?: (results: ICalcGrid.Results) => void;
     }
+    /** The owner's sheet list as {@link Calculation._setSheets} holds it. */
+    interface SheetList {
+        /** Every sheet's grid id and name, in tab order. */
+        readonly sheets: readonly (readonly [id: string, name: string | null])[];
+    }
     /** See {@link Calculation._createCalcGrid}. */
     interface CalcGridOptions extends CalcGrid.HostOptions, Pick<CalcGrid.ConstructorOptions, 'valuesAxis'> {
         /** The grid's id; a new one is made when absent. */
         uuid?: string;
-        /** See {@link CalcGridSpec.name}: a sheet's grid. */
-        name?: string | null;
         /** See {@link CalcGridSpec.shadowOf}. */
         shadowOf?: string;
         /** See {@link CalcGridSpec.unanchored}. */
         unanchored?: boolean;
         /** See {@link CalcGridSpec.arrayFirstCell}. */
         arrayFirstCell?: boolean;
-        /** The grid's size, as the model knows it: a sheet's, read when asked. */
-        getEntireCoords?: () => IRange.Coords;
-        /** The grid's size, fixed. */
+        /** See {@link CalcGridSpec.entireCoords}. */
         entireCoords?: IRange.Coords;
         /** See {@link CalcGridSpec.sizeOf}. */
         sizeOf?: string;
@@ -978,22 +997,6 @@ export declare namespace Calculation {
          * workbook answers with its structure protection.
          */
         isNamesReadOnly?: () => boolean;
-        /**
-         * Returns a sheet handle given an id.
-         */
-        /**
-         * `getRange`/`getRanges` are OPTIONAL and structural on purpose — this keeps `Calculation` decoupled
-         * from `ISheet` while letting a real sheet hand over its own address resolvers. A temporary formula
-         * anchored to that sheet uses them so an unscoped (same-sheet) reference resolves THERE rather than
-         * against the workbook's active sheet. See `createFormula`.
-         */
-        getSheetById?: (sheetId: string) => {
-            getId(): string;
-            getName(): string;
-            getEntireCoords: () => IRange.Coords | null;
-            getRange?: (address: ICellRange.Address, options?: ICellRange.GetRangeOptions) => ICellRange;
-            getRanges?: (address: ICellRanges.Address, options?: ICellRange.GetRangeOptions) => ICellRanges;
-        } | null;
         /**
          * External books to hydrate at construction, in `IWorkbook.JSON.externalBooks` form — `[n]`
          * order, `null` for a DDE/OLE gap.
@@ -1039,17 +1042,6 @@ export declare namespace Calculation {
         createGraphRanges?: (cells: readonly IRange.Coords[], names: readonly NamedNodeInfo[]) => ICellRanges | null;
         getSheetIndex?: (sheetName?: string) => number;
         getSheetCount?: () => number;
-        /**
-         * Every sheet's stable id in tab order, hidden and very hidden included — the order a 3-D
-         * reference's members are read from.
-         */
-        getSheetIds?: () => string[];
-        /**
-         * Subscribes to the sheet list changing by an operation - a sheet added, deleted, moved,
-         * copied or renamed. Not a restore: an undo or a redo reaches the engine through its own
-         * store, which is restored with the model's (DESIGN-CALC-SERVICE §7.5, §8).
-         */
-        addSheetsListener?: (callback: () => void, options?: IListener.Options) => IListener.Remove;
         strings?: IStringCollection;
         /**
          * Whether to perform iterative calculations when there are circular dependencies.

package/types/src/calculation/grid/CalcGrid.d.ts

@@ -41,6 +41,8 @@ export declare class CalcGrid implements ICalcGrid {
     protected readonly _host: CalcGrid.HostOptions;
     protected readonly _valuesAxis: IRange.Axis;
     protected readonly _runtime: IRuntime;
+    /** See {@link CalcGrid.ConstructorOptions.sizeOf}. */
+    protected readonly _sizeOf: string | undefined;
     /** The aggregate cache over the values; bound to the map INSTANCE, so it follows every clone. */
     protected _rangeStats: RangeStats;
     /**
@@ -222,16 +224,16 @@ export declare class CalcGrid implements ICalcGrid {
     /** {@inheritDoc ICalcGrid.getEntireCoords} */
     getEntireCoords(): IRange.Coords;
     /** {@inheritDoc ICalcGrid.resize} */
-    resize(options?: ICalcGrid.RequestOptions): void;
+    resize(entireCoords: IRange.Coords, options?: ICalcGrid.RequestOptions): void;
     /** {@inheritDoc ICalcGrid.setHidden} */
     setHidden(axis: IRange.Axis, runs: readonly RunCoords[], options?: ICalcGrid.RequestOptions): void;
     /** {@inheritDoc ICalcGrid.setFiltered} */
     setFiltered(filtered: boolean, options?: ICalcGrid.RequestOptions): void;
     /**
-     * Holds what the owner says of itself - what it hides, whether it is filtered - in the caller's
-     * operation: an undo restores it with whatever changed it.
+     * Holds what the owner says of itself - its size, what it hides, whether it is filtered - in the
+     * caller's operation: an undo restores it with whatever changed it.
      */
-    protected _holdOwnerState(update: Pick<Partial<CalcGrid.State>, 'hiddenRows' | 'hiddenColumns' | 'filtered'>): void;
+    protected _holdOwnerState(update: Pick<Partial<CalcGrid.State>, 'hiddenRows' | 'hiddenColumns' | 'filtered' | 'entireCoords'>): void;
     /** {@inheritDoc ICalcGrid.getId} */
     getId(): string;
     /** {@inheritDoc ICalcGrid.toJSON} */
@@ -381,6 +383,8 @@ export declare namespace CalcGrid {
         hiddenColumns: readonly RunCoords[] | null;
         /** Whether the owner is filtered. See {@link ICalcGrid.setFiltered}. */
         filtered: boolean;
+        /** The grid's size; `null` for one that has the size of its {@link ConstructorOptions.sizeOf} grid. See {@link ICalcGrid.resize}. */
+        entireCoords: IRange.Coords | null;
     }
     /**
      * The maps a write may change. Each is cloned once, on first ask, under the caller's key; a map
@@ -434,6 +438,10 @@ export declare namespace CalcGrid {
         runtime: IRuntime;
         /** The orientation of the value tuples a write carries. */
         valuesAxis?: IRange.Axis;
+        /** The grid's size, until a seed or a {@link ICalcGrid.resize} says otherwise: a name's fixed one. */
+        entireCoords?: IRange.Coords;
+        /** The grid whose size this one has, whatever it is then: a body on a sheet. Ignored with {@link entireCoords}. */
+        sizeOf?: string;
     }
 }
 /** A snapshot a vend lands in: this grid's record there, and whether it is the operation in progress. */

package/types/src/calculation/grid/CalcGridBackend.d.ts

@@ -436,12 +436,6 @@ export declare namespace CalcGridBackend {
          * A unique id that never changes for the grid.
          */
         uuid?: string;
-        /**
-         * The sheet's name, for a grid that is a sheet: its entry in the engine's replica of the
-         * sheet list (DESIGN-CALC-SERVICE §8). `null` for a sheet that has no name yet, which a
-         * formula names by its id. Absent for a compilation host, which no formula can name.
-         */
-        name?: string | null;
         /**
          * Returns the entire coordinate bounds for this grid.
          * If not provided, defaults to the maximum sheet dimensions.

package/types/src/calculation/grid/CalcGridProxy.d.ts

@@ -21,7 +21,6 @@ export declare class CalcGridProxy implements ICalcGrid.Backend {
     protected readonly _gridId: string;
     protected readonly _sendRequest: CalcGridProxy.ConstructorOptions['send'];
     _calculation: ICalculation | null;
-    protected readonly _getEntireCoordsOf: (() => IRange.Coords) | null;
     protected _emitter: ListenerEmitter<ICalcGrid, ICalcGrid.IListeners> | null;
     constructor(options: CalcGridProxy.ConstructorOptions);
     /**
@@ -37,10 +36,8 @@ export declare class CalcGridProxy implements ICalcGrid.Backend {
     protected _send(landingId: string | undefined, request: CalcRequest): Promise<ICalcGrid.Results>;
     /** @inheritdoc ICalcGrid.getId */
     getId(): string;
-    /** {@inheritDoc ICalcGrid.getEntireCoords} */
-    getEntireCoords(): IRange.Coords;
     /** {@inheritDoc ICalcGrid.resize} */
-    resize(options?: ICalcGrid.RequestOptions): void;
+    resize(c: IRange.Coords, options?: ICalcGrid.RequestOptions): void;
     /** {@inheritDoc ICalcGrid.setHidden} */
     setHidden(axis: IRange.Axis, runs: readonly RunCoords[], options?: ICalcGrid.RequestOptions): void;
     /** {@inheritDoc ICalcGrid.setFiltered} */
@@ -131,8 +128,6 @@ export declare namespace CalcGridProxy {
         send: (gridId: string, landingId: string | undefined, request: CalcRequest) => Promise<ICalcGrid.Results>;
         /** For the engine's status, and `ready()` ahead of an evaluation. */
         calculation?: ICalculation | null;
-        /** The grid's size, as the model knows it. */
-        getEntireCoords?: () => IRange.Coords;
     }
 }
 //# sourceMappingURL=CalcGridProxy.d.ts.map

package/types/src/calculation/grid/ICalcGrid.d.ts

@@ -307,12 +307,15 @@ export interface ICalcGrid {
      */
     getEntireCoords(): IRange.Coords;
     /**
-     * The grid's size changed: {@link getEntireCoords} answers the new one. The engine is told in
-     * order with the grid's writes, under the snapshot named, so an undo restores the old size there.
+     * Sets the grid's size: what {@link getEntireCoords} answers from now on. Recorded with the
+     * grid's other content, in the caller's operation, and told to the engine in order with the
+     * grid's writes, so an undo restores the old size in both. The size a grid opens with is its
+     * seed's ({@link ICalcGrid.JSON.entireCoords}).
      *
+     * @param entireCoords The grid's new size.
      * @param options See {@link ICalcGrid.RequestOptions}.
      */
-    resize(options?: ICalcGrid.RequestOptions): void;
+    resize(entireCoords: IRange.Coords, options?: ICalcGrid.RequestOptions): void;
     /**
      * Sets the rows or columns the grid's owner hides: the whole set on that axis, replacing the
      * one before. Recorded with the grid's other content, in the caller's operation, and told to the
@@ -396,7 +399,7 @@ export declare namespace ICalcGrid {
      * the engine answers, and nothing the model holds for itself. The in-process engine grid is
      * one; a message-passing proxy under a worker is another.
      */
-    type Backend = Omit<ICalcGrid, 'getStateId' | 'getFormulaAt' | 'getFormulas' | 'getValues' | 'getContentful' | 'getSpills' | 'getPending' | 'getCalcErrors' | 'getCirculars' | 'getErrorValues' | 'getVolatileRegions' | 'getRangeStats'> & {
+    type Backend = Omit<ICalcGrid, 'getStateId' | 'getEntireCoords' | 'getFormulaAt' | 'getFormulas' | 'getValues' | 'getContentful' | 'getSpills' | 'getPending' | 'getCalcErrors' | 'getCirculars' | 'getErrorValues' | 'getVolatileRegions' | 'getRangeStats'> & {
         /** Write a body as authored; the engine anchors it (see {@link ICalcGrid.BodyOptions}). */
         setBody(options: ICalcGrid.BodyOptions): Promise<ICalcGrid.Results>;
         /** {@link ICalcGrid.evaluateAt} coerced to one scalar, as a defined name's `evaluate()` is. */
@@ -847,6 +850,11 @@ export declare namespace ICalcGrid {
          * Whether the grid's owner is filtered ({@link ICalcGrid.setFiltered}); absent for not.
          */
         filtered?: boolean;
+        /**
+         * The grid's size ({@link ICalcGrid.resize}), read by a seed; absent to keep the one it has. A
+         * save does not write it: the owner keeps its own.
+         */
+        entireCoords?: IRange.Coords;
     }
     /**
      * Options for {@link ICalcGrid.seed}.

package/types/src/calculation/grid/_CalcRequest.d.ts

@@ -180,10 +180,11 @@ export type CalcRequest =
     body: ICalcGrid.BodyOptions;
 }
 /**
- * The sheet list as the model holds it when the message is sent - every sheet's grid id and
+ * The sheet list as its owner holds it when the message is sent - every sheet's grid id and
  * name, in tab order - for the engine's replica (DESIGN-CALC-SERVICE §8). A message of the
  * service, not of a grid: the channel holds it in order with the grids' requests, which is what
- * lets a seed sent before a rename compile against the names it was sent under.
+ * lets a seed sent before a rename compile against the names it was sent under. The owner tells
+ * a sheet before any grid that names it seeds (`Calculation._setSheets`).
  */
  | {
     type: 'sheets';
@@ -229,19 +230,13 @@ export type CalcRequest =
 export interface CalcGridSpec {
     /** The grid's id: a sheet's stable id, or a host's. */
     id: string;
-    /**
-     * The sheet's name when the grid is a sheet's made after the list was sent: it enters the
-     * engine's sheet replica at the end of the list. Absent for a grid made at a start, whose list
-     * is sent whole.
-     */
-    name?: string | null;
     /** See `CalcGridBackend.ConstructorOptions.shadowOf`. */
     shadowOf?: string;
     /** See `CalcGridBackend.ConstructorOptions.unanchored`. */
     unanchored?: boolean;
     /** See `CalcGridBackend.ConstructorOptions.arrayFirstCell`. */
     arrayFirstCell?: boolean;
-    /** The grid's size, until a `resize` says otherwise: a sheet's. */
+    /** The grid's size, fixed: a name's. A sheet's is its seed's. */
     entireCoords?: IRange.Coords;
     /** The grid whose size this one has, whatever it is then: a body on a sheet. */
     sizeOf?: string;

package/types/src/cell/ICell.d.ts

@@ -482,17 +482,17 @@ export declare namespace ICell {
         /**
          * Present when the cell's text is rotated (angle not a multiple of 180°): per-line rotated
          * strip geometry — each laid-out line is an independent strip drawn at
-         * {@link TextRotation.Layout.angle}, wrapped against the content height and marching
+         * {@link TextRotation.RotatedLayout.angle}, wrapped against the content height and marching
          * horizontally. See {@link TextRotation.layoutLines} for the model.
          */
-        rotation?: TextRotation.Layout;
+        rotation?: TextRotation.RotatedLayout;
         /**
          * Present when the cell's text is stacked ("vertical text"): per-column slot geometry — every
          * glyph upright in its own slot of the line pitch, columns from line breaks (and from wrapping
          * against the content height), each column aligned on its own. See
          * {@link TextStacked.layoutColumns} for the model. {@link bounds} is then the column group.
          */
-        stacked?: TextStacked.Layout;
+        stacked?: TextStacked.StackedLayout;
     }
     /**
      * Expansive way to set cell updates options.

package/types/src/cell/ICellHeader.d.ts

@@ -56,6 +56,12 @@ export interface ICellHeader {
      * {@link https://support.microsoft.com/en-us/office/change-the-column-width-and-row-height-72f5e3cc-994d-43e8-ae58-9774a0905f46}
      */
     getSizeRelative(): number;
+    /**
+     * The outline level, `0` to `7`. `0` is not grouped; `1` is the outermost group.
+     *
+     * @see `IOutline`
+     */
+    getOutlineLevel(): number;
     /**
      * For runtime introspection.
      */
@@ -104,6 +110,22 @@ export declare namespace ICellHeader {
          * {@link ICellHeader.getSizeRelative()}
          */
         relativeSize?: boolean;
+        /**
+         * The outline level, `0` to `7`, or a function of the current one.
+         *
+         * @remarks
+         * To group or ungroup, prefer `ICellRange.group` and `ICellRange.ungroup`.
+         *
+         * @see
+         * {@link ICellHeader.getOutlineLevel()}
+         */
+        outlineLevel?: number | ((level: number) => number);
+        /**
+         * Whether the group this header is the summary of is collapsed.
+         *
+         * @internal
+         */
+        collapsed?: boolean;
     }
     /**
      * Stores information about header runs.
@@ -122,11 +144,11 @@ export declare namespace ICellHeader {
          */
         h?: boolean;
         /**
-         * Header level
+         * Outline level, `1` to `7`. Absent when not grouped.
          */
         l?: number;
         /**
-         * Collapsed level
+         * Collapsed. Set on the summary header of a collapsed group.
          */
         cl?: boolean;
         /**

package/types/src/cellRange/ICellRange.d.ts

@@ -832,6 +832,64 @@ export interface ICellRange {
      * @returns The current `ICellRange`.
      */
     autoFit(options?: ICellRange.AutoFitOptions): this;
+    /**
+     * Groups the rows or columns of the range: each one moves one outline level deeper.
+     *
+     * @param axis Whether to group the rows or the columns. When omitted, entire rows group the rows,
+     * entire columns group the columns, and any other range groups both.
+     * @returns The current `ICellRange`.
+     * @throws `Error` If a row or column in the range is already at the deepest level, `7`. Nothing is
+     * grouped.
+     *
+     * @see {@link ISheet.getOutline}
+     */
+    group(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    /**
+     * Ungroups the rows or columns of the range: each grouped one moves one outline level out.
+     * Rows or columns that are not grouped are left alone.
+     *
+     * @param axis Whether to ungroup the rows or the columns. When omitted, chosen as for
+     * {@link group}.
+     * @returns The current `ICellRange`.
+     */
+    ungroup(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    /**
+     * Expands the groups the range selects: those whose summary row or column is in the range or,
+     * when there are none, the innermost groups the range meets.
+     *
+     * @param axis Whether to expand row groups or column groups. Inferred when the range is entire
+     * rows or entire columns; required otherwise.
+     * @returns The current `ICellRange`.
+     * @throws `Error` If the axis is not given and cannot be inferred.
+     *
+     * @remarks
+     * Groups nested inside that are collapsed stay collapsed.
+     */
+    showGroupDetails(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    /**
+     * Collapses the groups the range selects, chosen as for {@link showGroupDetails}: their details are
+     * hidden.
+     *
+     * @param axis Whether to collapse row groups or column groups. Inferred as for
+     * {@link showGroupDetails}.
+     * @returns The current `ICellRange`.
+     * @throws `Error` If the axis is not given and cannot be inferred.
+     */
+    hideGroupDetails(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    /**
+     * Removes the outline levels from the rows and columns of the range. Hidden rows and columns
+     * stay hidden.
+     *
+     * @param axes Which levels to remove. Default `IRange.AxisSelection.Both`.
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * The counterpart of Excel's `Range.ClearOutline`: both axes over the range's rows and columns,
+     * so entire rows also clear every column's levels unless `axes` names the rows, and a single
+     * cell clears the whole sheet. To outline a sheet from its formulas see
+     * {@link IOutline.autoOutline}.
+     */
+    clearGroups(axes?: IRange.AxisSelection, options?: ITransaction.OperationOptions): this;
     /**
      * Clear the range.
      *
@@ -1213,11 +1271,17 @@ export interface ICellRange {
      */
     isContentful(features?: ICellRange.Feature | readonly ICellRange.Feature[]): boolean;
     /**
-     * Returns `true` if the range represents the entire rows.
+     * Returns `true` if the range is entire rows, such as `2:4`: it spans every column of the sheet.
+     *
+     * @remarks
+     * The counterpart of Office Scripts' `isEntireRow`.
      */
     isEntireRows(): boolean;
     /**
-     * Returns `true` if the range represents the entire columns.
+     * Returns `true` if the range is entire columns, such as `B:D`: it spans every row of the sheet.
+     *
+     * @remarks
+     * The counterpart of Office Scripts' `isEntireColumn`.
      */
     isEntireColumns(): boolean;
     /**
@@ -2316,7 +2380,7 @@ export declare namespace ICellRange {
      * Represents an immutable reference to an `ICellRange`, capturing its content and metadata.
      * It may include complex objects such as tables, movables, images, listeners, or other items.
      *
-     * `ISnapshot` can be provided to `ICellRange.copyFrom``.
+     * `ISnapshot` can be provided to `ICellRange.copyFrom`.
      */
     interface ISnapshot<T = any, J = any> {
         /**

package/types/src/cellRange/ICellRanges.d.ts

@@ -218,35 +218,35 @@ export interface ICellRanges {
      */
     isOverlapping(): boolean;
     /**
-     * Returns `true` if all of the the ranges have selected all of the rows.
+     * Returns `true` if every range is entire rows, such as `2:4`.
      *
      * @remarks
-     * This is different from `isEntireRowsAny` in that it will return `true` if 'ALL' of the
-     * ranges have isEntireRows `true`.
+     * {@link isEntireRowsAny} asks the same of any one range.
+     *
+     * @see {@link ICellRange.isEntireRows}
      */
     isEntireRows(): boolean;
     /**
-     * Returns `true` if any of the ranges have selected all of the rows.
+     * Returns `true` if any range is entire rows, such as `2:4`.
      *
      * @remarks
-     * This is different from `isEntireRows` in that it it will return true if 'ANY' of the
-     * ranges have isEntireRows `true`.
+     * {@link isEntireRows} asks the same of every range.
      */
     isEntireRowsAny(): boolean;
     /**
-     * Returns `true` if all of the the ranges have selected all of the columns.
+     * Returns `true` if every range is entire columns, such as `B:D`.
      *
      * @remarks
-     * This is different from `isEntireColumnsAny` in that it will return `true` if 'ALL' of the
-     * ranges have isEntireColumns `true`.
+     * {@link isEntireColumnsAny} asks the same of any one range.
+     *
+     * @see {@link ICellRange.isEntireColumns}
      */
     isEntireColumns(): boolean;
     /**
-     * Returns `true` if any of the ranges have selected all of the columns.
+     * Returns `true` if any range is entire columns, such as `B:D`.
      *
      * @remarks
-     * This is different from `isEntireColumns` in that it will return `true` if 'ANY' of the
-     * ranges have isEntireColumns `true`.
+     * {@link isEntireColumns} asks the same of every range.
      */
     isEntireColumnsAny(): boolean;
     /**

package/types/src/chart/Chart.d.ts

@@ -1,3 +1,4 @@
+import { IMovable } from '../movable/IMovable';
 import { IResource, IResourceCollection } from '../resource';
 import { AbstractMovableContent } from '../movable/AbstractMovableContent';
 import { ICellRange } from '../cellRange';
@@ -91,19 +92,7 @@ export declare namespace Chart {
          *
          * @param getExpressions Asked once, when the engine can compile.
          */
-        holdFormulas?: (getExpressions: () => readonly string[]) => Chart.HeldFormulas;
-    }
-    /**
-     * A chart's formulas as the calculation engine holds them.
-     */
-    interface HeldFormulas {
-        /**
-         * The formula at `index` as it reads now, or `null` while it reads as it was handed over:
-         * the engine does not hold it, or nothing has moved what it names.
-         */
-        getText(index: number): string | null;
-        /** Takes the formulas out of the engine, as part of the current operation. */
-        release(): void;
+        holdFormulas?: (getExpressions: () => readonly string[]) => IMovable.HeldFormulas;
     }
 }
 export {};

package/types/src/condition/AnchoredConditional.d.ts

@@ -271,6 +271,8 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
          * resolver can tell which cells it answers for.
          */
         onBlank?: (resolve: _ConditionUtils.BlankResolver, area: IRange.Coords) => void;
+        /** {@inheritDoc DoRunConditionsOptions.spacesAreBlank} */
+        spacesAreBlank?: boolean;
     }): Promise<void>;
     get [Symbol.toStringTag](): string;
     toString(): string;

package/types/src/condition/BuiltInOperators/ColorOperator.d.ts

@@ -1,5 +1,9 @@
 import { ICondition } from '../ICondition';
 import { AbstractOperator } from './AbstractOperator';
+/**
+ * Filter by cell or font color. Carried and written back; not evaluated until a condition can
+ * read a cell's style, so applying one throws.
+ */
 export declare class ColorOperator extends AbstractOperator<ICondition.ColorOption> implements ICondition.IOperator<ICondition.ColorOption> {
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */

package/types/src/condition/BuiltInOperators/IconOperator.d.ts

@@ -1,5 +1,9 @@
 import { ICondition } from '../ICondition';
 import { AbstractOperator } from './AbstractOperator';
+/**
+ * Filter by conditional-format icon. Carried and written back; not evaluated until a condition
+ * can read a cell's decorations, so applying one throws.
+ */
 export declare class IconOperator extends AbstractOperator<ICondition.IconOption> implements ICondition.IOperator<ICondition.IconOption> {
     constructor();
     /** {@inheritDoc ICondition.IOperator.createPredicate} */