@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.11

package/types/src/collections/SpatialMap.d.ts

@@ -5,7 +5,6 @@ import { ISpatialMap } from './ISpatialMap';
  * The default implementation for {@link ISpatialMap}
  */
 export declare class SpatialMap<T = any> implements ISpatialMap<T> {
-    protected _shared: SharedRecord<T> | null;
     protected _rTree: FilterRTree<T>;
     protected _cloneKey: any;
     protected _options: ISpatialMap.ConstructorOptions<T> | undefined;
@@ -60,13 +59,12 @@ export declare class SpatialMap<T = any> implements ISpatialMap<T> {
     delete(coords: RangeCoords | null): this;
     /** {@inheritDoc ISpatialMap.clone} */
     clone(cloneKey?: any): this;
-    protected _copy(source: SharedRecord<T>, entries?: ReadonlyArray<ISpatialMap.Entry<T>>): SharedRecord<T>;
     protected _updateNodes(nodesInsert: ISpatialMap.Entry<T>[], nodesRemove?: ISpatialMap.Entry<T>[], onUpdates?: (nodesInsert: ISpatialMap.Entry<T>[], nodesRemove: ISpatialMap.Entry<T>[], map: ISpatialMap<T>) => void): void;
     protected _mergeNodes(range: RangeCoords, fullyContained?: boolean): ISpatialMap.Entry<T>[];
     protected _getReadTree(): FilterRTree<T>;
-    protected _ensureWritable(entries?: ReadonlyArray<ISpatialMap.Entry<T>>): void;
     /**
-     * entries is a special performance optimization to allow a single bulk load.
+     * The tree, with the search caches invalidated for a write; loads `entries` into it first if
+     * given.
      */
     protected _getWritableTree(entries?: ReadonlyArray<ISpatialMap.Entry<T>>): FilterRTree<T>;
     /**
@@ -78,10 +76,6 @@ export declare class SpatialMap<T = any> implements ISpatialMap<T> {
      */
     protected _createClone(options: ISpatialMap.ConstructorOptions<T> | undefined): this;
 }
-interface SharedRecord<T> {
-    refCount: number;
-    rTree: FilterRTree<T>;
-}
 /**
  * Internal class that extends RTree to support Filters.
  * is needed — the default passthrough in RTree works directly.

package/types/src/collections/SpatialMap3D.d.ts

@@ -11,6 +11,8 @@ import { ISpatialMap3D } from './ISpatialMap3D';
  */
 export declare class SpatialMap3D<T = any> implements ISpatialMap3D<T> {
     protected _mapScopeTo2Ds: Map<string, ISpatialMap<T>>;
+    /** The key this map was cloned under, if any - see {@link clone}. */
+    protected _cloneKey: any;
     protected _last2DKey: string | null | undefined;
     protected _last2DMap: ISpatialMap<T> | undefined;
     protected _options: SpatialMap3D.ConstructorOptions<T> | undefined;

package/types/src/collections/index.d.ts

@@ -9,7 +9,7 @@ export * from './ISpatialMap3D';
 export * as IteratorUtils from './IteratorUtils';
 export * from './ImmutableList';
 export * from './IList';
-export * from './OverlappingRangeIterator';
+export { OverlappingRange } from '@sheetxl/utils';
 export * from './SortedMap';
 export * from './SparseGrid';
 export * from './ScalarGrid';

package/types/src/comment/Comment.d.ts

@@ -1,11 +1,15 @@
 import { IRange } from '@sheetxl/primitives';
+import { Bounds } from '@sheetxl/utils';
 import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
 import { ICellRange, ICellRanges } from '../cellRange';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { IPerson, IPersonCollection } from '../person';
 import { IMovable } from '../movable';
 import { IRichText } from '../text';
+import { IFill, IStroke } from '../fill';
+import { IStyleCollection } from '../style';
+import { IShapeStyle } from '../shape';
 import { Anchored } from '../anchored/Anchored';
 import { AbstractAnchored } from '../anchored/AbstractAnchored';
 import { IComment } from './IComment';
@@ -31,6 +35,7 @@ export declare class Comment extends AbstractAnchored<State, IComment.Events> im
      * brings the same one back, and a note made again from a thread is given a new one.
      */
     private _boxes;
+    private _style;
     /** @internal */
     protected _initialize(options: Comment.ConstructorOptions): void;
     /** @internal */
@@ -54,8 +59,8 @@ export declare class Comment extends AbstractAnchored<State, IComment.Events> im
      * never asks the model for it, so this is free to answer the way Office Scripts does.
      */
     getId(): string;
-    /** {@inheritDoc IComment.getSheet} */
-    getSheet(): ISheet;
+    /** {@inheritDoc IComment.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc IComment.getRange} */
     getRange(options?: ICellRange.GetRangeOptions): ICellRange;
     /** {@inheritDoc IComment.getContent} */
@@ -94,17 +99,19 @@ export declare class Comment extends AbstractAnchored<State, IComment.Events> im
     setDescription(description: string | null): this;
     /** {@inheritDoc IComment.getMovable} */
     getMovable(): IMovable | null;
+    /** {@inheritDoc IComment.getStyle} */
+    getStyle(): IShapeStyle | null;
     /**
      * The live box, if there is one.
      * @internal
      */
     protected _getBox(): NoteMovable | null;
     /**
-     * Asks the sheet for a box: at `anchor`, its cells counted from this comment's, or where Excel
-     * puts a new note's. A comment with no sheet to place one on has no box.
+     * Asks the sheet for a box: at `placement`, or where Excel puts a new note's. A comment with no
+     * sheet to place one on has no box.
      * @internal
      */
-    protected _placeBox(anchor: IMovable.AnchorOffset | null, hidden: boolean): void;
+    protected _placeBox(placement: Comment.BoxPlacement | null, hidden: boolean): void;
     /**
      * The note is gone, or is a thread now: its box goes with it.
      * @internal
@@ -182,7 +189,20 @@ export declare namespace Comment {
          * What places a note's box. A comment given none has no movable.
          */
         boxes?: Comment.Boxes;
+        /**
+         * The workbook's styles, for resolving a note's colors. Lazy, as {@link getPeople} is.
+         */
+        getStyles?: () => IStyleCollection | null;
     }
+    /**
+     * Where a note's box is placed: by its cells counted from the note's, or by pixels from the
+     * sheet's top-left (see {@link IComment.BoxJSON.bounds}).
+     */
+    type BoxPlacement = {
+        anchor: IMovable.AnchorOffset;
+    } | {
+        bounds: Bounds;
+    };
     /**
      * What a note's box needs of the sheet it is on: to be placed, and to know whether it is where
      * a new note's goes.
@@ -192,11 +212,10 @@ export declare namespace Comment {
          * Places a note's box among the sheet's movables, with the note as its content.
          *
          * @param comment The note.
-         * @param anchor Where the box is, its cells counted from the note's; `null` for where Excel
-         * puts a new note's.
+         * @param placement Where the box is; `null` for where Excel puts a new note's.
          * @param hidden Whether the box appears only while its cell is pointed at.
          */
-        add(comment: Comment, anchor: IMovable.AnchorOffset | null, hidden: boolean): NoteMovable;
+        add(comment: Comment, placement: BoxPlacement | null, hidden: boolean): NoteMovable;
         /**
          * Whether a box is where a new note's goes, which a note saves nothing for.
          */
@@ -218,6 +237,10 @@ interface State extends AbstractAnchored.State {
     description: string | null;
     /** How a note's box is drawn when not the default: markup a file's writer replays. */
     boxXml: string | null;
+    /** The fill a note's box states. */
+    boxFill: IFill.JSON | null;
+    /** The line a note's box states. */
+    boxStroke: IStroke.JSON | null;
 }
 export {};
 //# sourceMappingURL=Comment.d.ts.map

package/types/src/comment/IComment.d.ts

@@ -1,11 +1,14 @@
+import { Bounds } from '@sheetxl/utils';
 import { IAnchored } from '../anchored';
 import { ICellRange } from '../cellRange';
 import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
 import { IPerson } from '../person';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { IMovable } from '../movable';
 import { IRichText } from '../text';
+import { IFill, IStroke } from '../fill';
+import { IShapeStyle } from '../shape';
 /**
  * A comment on a cell: the root of a thread, with its replies, or a note.
  *
@@ -54,6 +57,22 @@ export interface IComment extends IAnchored, IMovable.IContent {
      * ```
      */
     getMovable(): IMovable | null;
+    /**
+     * The fill and line of a note's box, or `null` for a threaded comment, which has no box.
+     *
+     * @remarks
+     * A note that states neither draws Excel's default: the system tooltip background
+     * ({@link IColor.Named.InfoBk}) and a thin line in the tooltip text color. Excel takes only
+     * literal colors here; a theme color is written to a file as the color it resolves to.
+     *
+     * @example
+     * ```ts
+     * const note = sheet.getComments().add('B2', 'Check this', { asNote: true });
+     * note.getStyle()!.setFill('#ccffcc');
+     * note.getStyle()!.getStroke().setWidth(2.25);
+     * ```
+     */
+    getStyle(): IShapeStyle | null;
     /**
      * Deletes the comment: its replies with it, or a note's box.
      */
@@ -61,7 +80,7 @@ export interface IComment extends IAnchored, IMovable.IContent {
     /**
      * The sheet the comment is on.
      */
-    getSheet(): ISheet;
+    getWorksheet(): IWorksheet;
     /**
      * The cell the comment is on.
      *
@@ -339,8 +358,26 @@ export declare namespace IComment {
          */
         anchor?: IMovable.AnchorOffset;
         /**
-         * How the box is drawn when that is not Excel's default, held as it was read: the VML
-         * `<v:shape>` without its id, its position or its cell.
+         * Where the box is in pixels from the sheet's top-left, for a box placed by position rather
+         * than by cells. Used only when there is no {@link anchor}; once loaded, the box is anchored
+         * to the cells under it and saves an `anchor`.
+         *
+         * @remarks
+         * A VML note shape with no `<x:Anchor>` (openpyxl writes them) is placed this way in Excel,
+         * literally, wherever its note's cell is.
+         */
+        bounds?: Bounds;
+        /**
+         * The box's fill, where it states one. Absent draws Excel's default.
+         */
+        fill?: IFill.JSON;
+        /**
+         * The box's line, where it states one. Absent draws Excel's default.
+         */
+        stroke?: IStroke.JSON;
+        /**
+         * The rest of how the box is drawn when that is not Excel's default, held as it was read: the
+         * VML `<v:shape>` without its id, its position, its cell, its fill or its line.
          */
         xml?: string;
     }

package/types/src/comment/_NoteBox.d.ts

@@ -1,6 +1,7 @@
 import { IRange } from '@sheetxl/primitives';
 import { Bounds } from '@sheetxl/utils';
 import { IMovable } from '../movable';
+import { IWorksheet } from '../sheet';
 import { Movable } from '../movable/Movable';
 /**
  * Where a note's box goes when nothing has moved it, and how a note stores where its box is.
@@ -8,7 +9,8 @@ import { Movable } from '../movable/Movable';
  * @remarks
  * The default is Excel's, probed with hidden COM on a 96-DPI machine (2026-09-30): a 144×79 px
  * box hung 15 px right of its cell and 10 px above its top, flipped to the other side when it
- * would pass the sheet's last column or row. It is pixel geometry first and the cells those
+ * would pass the sheet's last column or row. A note on a merged cell hangs beside the merge
+ * (probed 2026-10-20). It is pixel geometry first and the cells those
  * pixels fall on second, so tall, narrow and hidden rows and columns need no rule of their own.
  *
  * A note stores its box's anchor with the cells counted from the note's own, so a note copied
@@ -24,10 +26,25 @@ export declare const NOTE_DEFAULT_HEIGHT = 79;
  * The cell geometry placing a box needs: the same three a movable is built with.
  */
 export type NoteLayout = Required<Pick<Movable.ConstructorOptions, 'getBoundsAtCoords' | 'getCoordsAtBounds' | 'getMaxBounds'>>;
+/** The merge a cell is in, or `null` when it is in none. */
+export type MergeAt = (cell: IRange.CellCoords) => IRange.Coords | null;
+/** {@link MergeAt} through a sheet's cells, for once it has loaded. */
+export declare const sheetMergeAt: (sheet: IWorksheet) => MergeAt;
+/**
+ * The cells a note's box hangs beside: the note's cell, or the merge it anchors.
+ */
+export declare function noteBoxTarget(mergeAt: MergeAt, cell: IRange.CellCoords): IRange.Coords;
 /**
  * The bounds of a note's box when nothing has moved or resized it.
+ *
+ * @param target The cells the box hangs beside, from {@link noteBoxTarget}.
+ */
+export declare function defaultNoteBounds(target: IRange.Coords, layout: NoteLayout): Bounds;
+/**
+ * Bounds measured from the sheet's top-left (as a file's VML `style` places a box with no anchor)
+ * in the layout's coordinates.
  */
-export declare function defaultNoteBounds(cell: IRange.CellCoords, layout: NoteLayout): Bounds;
+export declare function sheetNoteBounds(bounds: Bounds, layout: NoteLayout): Bounds;
 /**
  * The cells and offsets a box's corners fall on, as a movable is loaded from.
  */

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

@@ -4,6 +4,7 @@ import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
 import { Tuple, ISparseGrid } from '../collections';
 import { ICalculation } from '../calculation';
+import { FormulaHost } from '../calculation/grid';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { ICondition } from '../condition';
 import { ConditionFormulaBinding } from '../condition/_ConditionFormula';
@@ -45,8 +46,29 @@ export declare abstract class AnchoredConditional<STATE extends AnchoredConditio
     protected abstract _getActionDescription(action: 'delete' | 'initialize' | 'updateListener'): string | null;
     /** @internal */
     protected abstract _getType(): string;
-    /** @internal */
-    protected abstract _processValueUpdates(range: ICellRange | null): void;
+    /**
+     * Re-judges the rule after a change.
+     *
+     * @returns What the re-judging awaits, when it does: counted as calculation in flight until it
+     * settles (see `ICalculation.waitUntil`).
+     * @internal
+     */
+    protected abstract _processValueUpdates(range: ICellRange | null): void | Promise<void>;
+    /**
+     * Whether this rule's formula watches evaluate a blank region the answer of which depends on
+     * the position only where the rule is read (`WatchAnchor.Options.paged`): a cell not read yet
+     * has no answer and judges as no match until its tile is delivered. Right for a rule read a
+     * window at a time - a format, painted where it is on screen - and not for one whose every
+     * answer is wanted at once.
+     * @internal
+     */
+    protected _pagesWatches(): boolean;
+    /**
+     * Whether every formula watch of this rule holds its answer at a cell of the area at
+     * `areaIndex`, asking for the cell where one does not (see `FormulaHost.request`).
+     * @internal
+     */
+    protected _requestWatchedCell(areaIndex: number, row: number, column: number): boolean;
     /** @internal */
     protected abstract _fromJSON(json: JSON | undefined, options?: ITransaction.OperationOptions): void;
     /** @internal */
@@ -309,9 +331,13 @@ export declare class AreaResultCollector {
  */
 interface WatchEntry {
     remove: IListener.Remove;
+    /** The areas the watch was registered over, as an address: a rule reshaped since asks again. */
+    areas: string;
     values: (IRange | null)[];
     /** Resolvers waiting on an area's first delivery — a LIST: passes overlap, and each has its own. */
     pending: (((values: IRange | null) => void)[])[];
+    /** Each area's host, once registered: what a paged watch is asked for cells through. */
+    hosts: (FormulaHost | undefined)[];
 }
 /**
  * Tables are designed to be instantiated as both standalone and anchored items that represent a table of data on a sheet.

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

@@ -389,9 +389,10 @@ export declare namespace ICondition {
          */
         cellColor?: boolean;
         /**
-         * If filtered then the id.
+         * The format to match: its fill when {@link ICondition.ColorOption.cellColor} is `true`,
+         * otherwise its font color.
          */
-        styleId?: number;
+        style?: ICellStyle.Properties;
     }
     /**
      * Types of time-periods.

package/types/src/conditionalFormat/ConditionalFormat.d.ts

@@ -4,7 +4,7 @@ import { ITransaction } from '../transaction';
 import { IListener } from '../listener';
 import { ICellRange, ICellRanges } from '../cellRange';
 import { ICellStyle, IStyleCollection } from '../style';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { ISparseGrid, ISpatialMap } from '../collections';
 import { ICalculation } from '../calculation';
 import { BlankResolver } from '../condition/_ConditionUtils';
@@ -61,12 +61,18 @@ export declare class ConditionalFormat extends AnchoredConditional<State, ICondi
     protected _initialize(options: ConditionalFormat.ConstructorOptions): void;
     /** @internal */
     protected _getType(): string;
+    /**
+     * A format is read where it is painted, so a whole-column rule whose answer depends on the row
+     * (`ISODD(ROW())`) is evaluated a window at a time rather than a million cells at once.
+     * @internal
+     */
+    protected _pagesWatches(): boolean;
     /** @internal */
     protected _getActionDescription(action: 'delete' | 'initialize' | 'updateListener'): string | null;
     /** @internal */
     protected _getDefaultState(options: ConditionalFormat.ConstructorOptions): Readonly<State>;
     /** @internal */
-    protected _processValueUpdates(_range?: ICellRange | null): void;
+    protected _processValueUpdates(_range?: ICellRange | null): Promise<void>;
     /**
      * Resolves every stop to the number it stands for, in the order they were authored.
      *
@@ -168,7 +174,7 @@ export declare class ConditionalFormat extends AnchoredConditional<State, ICondi
 }
 export declare namespace ConditionalFormat {
     interface ConstructorOptions extends AnchoredConditional.ConstructorOptions<IConditionalFormat.JSON> {
-        sheet?: ISheet;
+        sheet?: IWorksheet;
     }
 }
 interface State extends AnchoredConditional.State {

package/types/src/conditionalFormat/IConditionalFormat.d.ts

@@ -26,7 +26,7 @@ export interface IConditionalFormat extends IAnchored, ICondition.Stateful, IPro
     /**
      * Re-anchors this rule to `address`, REPLACING every range it currently covers.
      *
-     * @param address The range or ranges to cover — anything `ISheet.getRanges` accepts
+     * @param address The range or ranges to cover — anything `IWorksheet.getRanges` accepts
      *   (`'A1:C20'`, `'A1:A5, C1:C5'`, coords). Resolved against this rule's own sheet.
      * @param options Transaction options; `description` names the entry in undo history.
      *
@@ -281,7 +281,7 @@ export declare namespace IConditionalFormat {
     interface DataBar {
         type: typeof IConditionalFormat.ScaleType.DataBar;
         /**
-         * The lower and upper bound of the bar. Always two.
+         * The lower and upper bound of the bar. Always two; a missing bound is `min` / `max`.
          */
         stops: IConditionalFormat.Stop[];
         /**
@@ -332,7 +332,8 @@ export declare namespace IConditionalFormat {
     interface IconSet {
         type: typeof IConditionalFormat.ScaleType.IconSet;
         /**
-         * Where each icon's band starts. One per icon in the set.
+         * Where each icon's band starts. One per icon in the set. With fewer than two, the bands are
+         * even percents of the range (`0/33/67` for three icons).
          */
         stops: IConditionalFormat.Stop[];
         /**

package/types/src/dataTable/DataTable.d.ts

@@ -0,0 +1,67 @@
+import { IRange } from '@sheetxl/primitives';
+import { Anchored } from '../anchored/Anchored';
+import { AbstractAnchored } from '../anchored/AbstractAnchored';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
+import { IDataTable } from './IDataTable';
+interface State extends AbstractAnchored.State {
+    anchorCoords: IRange.Coords;
+}
+/**
+ * Implementation for {@link IDataTable}: anchored on its result cells, its input cells held in the
+ * engine as references.
+ *
+ * @remarks
+ * Excel's rules, from `openpy-parity/probe-data-table.ps1` (2026-10-18): the results move whole or
+ * go whole ({@link _processContainerShift}), and the input cells follow their cells, a deleted
+ * one keeping its last address.
+ */
+export declare class DataTable extends AbstractAnchored<State, IDataTable.Events> implements IDataTable {
+    private _rowInput;
+    private _columnInput;
+    private _calculateAlways;
+    private _removeWatches;
+    constructor(options: DataTable.ConstructorOptions);
+    protected _initialize(options: DataTable.ConstructorOptions): void;
+    /** {@inheritDoc IDataTable.getRowInput} */
+    getRowInput(): string | null;
+    /** {@inheritDoc IDataTable.getColumnInput} */
+    getColumnInput(): string | null;
+    /** {@inheritDoc IDataTable.isRowInputDeleted} */
+    isRowInputDeleted(): boolean;
+    /** {@inheritDoc IDataTable.isColumnInputDeleted} */
+    isColumnInputDeleted(): boolean;
+    /** {@inheritDoc IDataTable.toJSON} */
+    toJSON(): IDataTable.JSON | null;
+    /**
+     * Excel's "Can't change part of a data table": an insert or delete through the results, or one
+     * that moves part of them, is refused before anything of the edit commits. An edit before them
+     * moves them whole; one taking all of them deletes the table.
+     * @internal
+     */
+    protected _processContainerShift(options: Anchored.ShiftOptions): IRange.Coords | null | void;
+    /**
+     * The results may no longer be what the table calculates: has Excel recalculate it on open.
+     * TODO - goes when the engine evaluates `TABLE`; see `Sheet._markDataTablesStale`.
+     * @internal
+     */
+    _markStale(): void;
+    /**
+     * Lets go of the input cells' references.
+     * @internal
+     */
+    _releaseWatches(): void;
+    /** @internal */
+    protected _getActionDescription(action: 'delete' | 'initialize' | 'updateListener'): string | null;
+    /** {@inheritDoc IDataTable.isIDataTable} */
+    get isIDataTable(): true;
+}
+export declare namespace DataTable {
+    interface ConstructorOptions extends Anchored.ConstructorOptions<IDataTable.JSON> {
+        /**
+         * Holds an input cell's reference in the engine. Without it the inputs are kept as read.
+         */
+        addWatch?: AbstractMovableContent.AddWatch;
+    }
+}
+export {};
+//# sourceMappingURL=DataTable.d.ts.map

package/types/src/dataTable/DataTableCollection.d.ts

@@ -0,0 +1,19 @@
+import { AbstractCollection } from '../type';
+import { IDataTable } from './IDataTable';
+import { IDataTableCollection } from './IDataTableCollection';
+/**
+ * Implementation for {@link IDataTableCollection}: a front over the sheet's anchored map. Nothing
+ * edits a data table yet, so there is nothing to announce.
+ */
+export declare class DataTableCollection extends AbstractCollection<IDataTable> implements IDataTableCollection {
+    private _getItemsDelegate;
+    /**
+     * @param getItems Returns the tables, as an array the caller may keep.
+     */
+    constructor(getItems: () => IDataTable[]);
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(): IDataTable[];
+    /** {@inheritDoc IDataTableCollection.isIDataTableCollection} */
+    get isIDataTableCollection(): true;
+}
+//# sourceMappingURL=DataTableCollection.d.ts.map

package/types/src/dataTable/IDataTable.d.ts

@@ -0,0 +1,99 @@
+import { ICellRange } from '../cellRange';
+import { IAnchored } from '../anchored';
+/**
+ * A what-if data table (Excel's **What-If Analysis > Data Table**): a block of result cells, each
+ * the table's formula evaluated with its row and column values put in the input cells.
+ *
+ * @remarks
+ * The table is carried, not calculated: its results are the values the file held, and nothing
+ * recalculates them. Excel recalculates it when it opens the file (when the calculation mode and
+ * {@link IDataTable.JSON.calculateAlways} allow).
+ *
+ * The anchor is the result cells; the formula, the row values above them and the column values to
+ * their left are ordinary cells. As in Excel, an edit to part of the results is refused, and one
+ * that clears or deletes all of them deletes the table.
+ */
+export interface IDataTable extends IAnchored {
+    toJSON(): IDataTable.JSON | null;
+    /**
+     * Returns the result cells.
+     *
+     * @remarks
+     * An insert or delete before them moves them, one taking all of them deletes the table
+     * ({@link IAnchored.isDeleted}), and one that would move part of them is refused.
+     */
+    getRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    /**
+     * Returns the input cell the row values are put in, as an A1 address on this sheet, or `null`
+     * when the table has none (a one-input table down a column).
+     *
+     * @remarks
+     * Follows the cell through inserts, deletes and moves. Once the cell is deleted this is the last
+     * address it had, and {@link isRowInputDeleted} is `true`.
+     */
+    getRowInput(): string | null;
+    /**
+     * Returns the input cell the column values are put in, as an A1 address on this sheet, or `null`
+     * when the table has none (a one-input table along a row).
+     *
+     * @remarks
+     * Follows the cell as {@link getRowInput} does.
+     */
+    getColumnInput(): string | null;
+    /**
+     * Returns whether the row input cell was deleted. The table's results are then `#REF!` in Excel.
+     */
+    isRowInputDeleted(): boolean;
+    /**
+     * Returns whether the column input cell was deleted.
+     */
+    isColumnInputDeleted(): boolean;
+    /** For runtime type checking. */
+    readonly isIDataTable: true;
+}
+export declare namespace IDataTable {
+    /**
+     * JSON representation of a data table.
+     *
+     * @remarks
+     * A table has a row input, a column input, or both (a two-input table).
+     */
+    interface JSON {
+        /**
+         * The result cells, as an A1 range.
+         */
+        ref: string;
+        /**
+         * The input cell the row values are put in, as an A1 address on the same sheet.
+         */
+        rowInput?: string;
+        /**
+         * The input cell the column values are put in, as an A1 address on the same sheet.
+         */
+        columnInput?: string;
+        /**
+         * Whether the row input cell was deleted; {@link rowInput} is then its last address.
+         */
+        rowInputDeleted?: boolean;
+        /**
+         * Whether the column input cell was deleted; {@link columnInput} is then its last address.
+         */
+        columnInputDeleted?: boolean;
+        /**
+         * Whether Excel recalculates the table when it opens the file. Without it, Excel shows the
+         * results as saved until something recalculates the table.
+         *
+         * @remarks
+         * Kept as read until the workbook's cell data is edited, on any sheet. Then it is set on every
+         * table, because nothing here recalculates the results and they may no longer be right. It stays
+         * set when the edit is undone.
+         */
+        calculateAlways?: boolean;
+    }
+    /**
+     * `Events` for {@link IDataTable}.
+     */
+    interface Events extends IAnchored.Events<IDataTable> {
+    }
+}
+//# sourceMappingURL=IDataTable.d.ts.map

package/types/src/dataTable/IDataTableCollection.d.ts

@@ -0,0 +1,18 @@
+import { ICollection } from '../type';
+import { IDataTable } from './IDataTable';
+/**
+ * Holds a sheet's {@link IDataTable | data tables}.
+ *
+ * @remarks
+ * Read-only for now: a table is carried as it was read and written back. Creating one and
+ * calculating it wait on the engine evaluating `TABLE`.
+ */
+export interface IDataTableCollection extends ICollection<IDataTable> {
+    /**
+     * Returns the data tables, in the order they were read.
+     */
+    getItems(options?: ICollection.GetItemsOptions): IDataTable[];
+    /** For runtime type checking. */
+    readonly isIDataTableCollection: true;
+}
+//# sourceMappingURL=IDataTableCollection.d.ts.map

package/types/src/dataTable/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @hidden
+ */
+export * from './IDataTable';
+export * from './IDataTableCollection';
+//# sourceMappingURL=index.d.ts.map

package/types/src/dataValidation/DataValidation.d.ts

@@ -52,7 +52,7 @@ export declare class DataValidation extends AnchoredConditional<State, IDataVali
     /** @internal */
     protected _getDefaultState(options: DataValidation.ConstructorOptions): Readonly<State>;
     /** @internal */
-    protected _processValueUpdates(_range?: ICellRange | null): void;
+    protected _processValueUpdates(_range?: ICellRange | null): void | Promise<void>;
     /** Swaps in one evaluation's answers; everything derived from the previous ones goes with them. */
     protected _setResults(results: IGrid<boolean> | null, blankAreas: BlankArea[] | null, blankPerCell?: boolean): void;
     /** Whether an EMPTY cell of `areas` fails. Every area covering the cell has a say, as for values. */