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

package/types/src/sheet/{Sheet.d.ts → Worksheet.d.ts}

@@ -4,6 +4,7 @@ import { ITypes, ICollection, IProperties } from '../type';
 import { IWorkbook } from '../workbook';
 import { IListener } from '../listener';
 import { ITransaction } from '../transaction';
+import { BatchHandle } from '../transaction/_BatchHandle';
 import { IResource, IResourceCollection } from '../resource';
 import { IStringCollection } from '../string';
 import { IProtection } from '../protection';
@@ -28,6 +29,9 @@ import { IChartCollection } from '../chart';
 import { IPicture } from '../picture';
 import { InsertableCollection } from '../movable/_InsertableCollection';
 import { IPivotTable, IPivotTableCollection } from '../pivot';
+import { IDataTable, IDataTableCollection } from '../dataTable';
+import { AnomalyFindings, AnomalySet, AnomalySource, RoleSource } from './_Anomalies';
+import { CellKind } from './_Kinds';
 import { ICell } from '../cell';
 import { ICellRange, ICellRegions, ICellRanges } from '../cellRange';
 import { ICellStyle, IStyleCollection } from '../style';
@@ -44,15 +48,19 @@ import { ProtectedRange } from '../protectedRange/ProtectedRange';
 import { Comment } from '../comment/Comment';
 import { NoteMovable } from '../comment/NoteMovable';
 import { NoteLayout } from '../comment/_NoteBox';
-import { ISheetProtection } from '../sheetProtection';
+import { IWorksheetProtection } from '../sheetProtection';
 import { IOutline } from '../outline';
+import { IPageLayout } from '../print';
 import { ISheetHeader } from '../sheetHeader';
-import { ISheetView } from '../sheetView';
+import { IWorksheetView } from '../sheetView';
+import { IWorksheet } from './IWorksheet';
 import { ISheet } from './ISheet';
 import { ScalarListFactory } from './_ScalarListFactory';
 import { ListenerAnchor } from './_ListenerAnchor';
 import { WatchAnchor } from './_WatchAnchor';
+import { ShiftIntent } from './_SheetIntents';
 import { EventCategory, SheetEvents } from './_SheetEvents';
+import { SheetChangeDetails } from './_SheetChangeEvent';
 import { SheetHeader } from '../sheetHeader/SheetHeader';
 import { SheetDirectStyle } from './style/SheetDirectStyle';
 import { IUsedRangeSpatialMap } from './style/UsedRangeSpatialMap';
@@ -61,37 +69,43 @@ import { CellBuffer } from './_CellBuffer';
 import { SheetReadContext, GetTypedRangeOptions, OverFlowsAndStops } from './_SheetStateReader';
 import { AutoFillProjection, AutoFillPreviewCache } from './_SheetAutoFillUtils';
 import { ProtectionCheck } from './_SheetCoords';
-import { SheetProtection } from '../sheetProtection/SheetProtection';
+import { WorksheetProtection } from '../sheetProtection/WorksheetProtection';
 import { Outline } from '../outline/Outline';
+import { PageLayout } from '../print/PageLayout';
 import { SheetCellOptions } from './SheetCell';
 import { ICalculation } from '../calculation';
 import { ICalcGrid } from '../calculation/grid';
 import * as _SheetFilterUtils from './_SheetFilterUtils';
+/** The font colors a workbook writes its roles in, and a key that compares by content. */
+interface WorkbookRoleColors {
+    readonly key: string;
+    readonly colors: ReadonlySet<string>;
+}
 /**
- * Implementation of {@link ISheet}.
+ * Implementation of {@link IWorksheet}.
  */
 /**
- * The internal capability surface a {@link Sheet} vends to `SheetRange`/`SheetRanges` and (later)
- * extracted operation modules. It carries ONLY genuinely-internal operations; the public `ISheet`
- * API is reached via `getSheet()` and never duplicated here. The type is derived from the concrete
+ * The internal capability surface a {@link Worksheet} vends to `SheetRange`/`SheetRanges` and (later)
+ * extracted operation modules. It carries ONLY genuinely-internal operations; the public `IWorksheet`
+ * API is reached via `getWorksheet()` and never duplicated here. The type is derived from the concrete
  * `_internal` object so it can never drift from the implementation.
  * @internal
  */
-export type ISheetInternal = ReturnType<Sheet['_getInternal']>;
+export type IWorksheetInternal = ReturnType<Worksheet['_getInternal']>;
 /**
- * The context a {@link Sheet} vends to `_SheetMutations` (the shift/insert/delete engine). Derived
+ * The context a {@link Worksheet} vends to `_SheetMutations` (the shift/insert/delete engine). Derived
  * from the concrete `_buildMutationCtx` object so it can never drift from the implementation.
  * @internal
  */
-export type SheetMutationContext = ReturnType<Sheet['_buildMutationCtx']>;
+export type SheetMutationContext = ReturnType<Worksheet['_buildMutationCtx']>;
 /**
- * The context a {@link Sheet} vends to `_SheetCoords` (address/coord resolution). Derived from the
+ * The context a {@link Worksheet} vends to `_SheetCoords` (address/coord resolution). Derived from the
  * concrete `_buildCoordCtx` object so it can never drift from the implementation.
  * @internal
  */
-export type SheetCoordContext = ReturnType<Sheet['_buildCoordCtx']>;
+export type SheetCoordContext = ReturnType<Worksheet['_buildCoordCtx']>;
 /**
- * What an operation hands {@link Sheet._commitWithDirectives} beyond its selection and options.
+ * What an operation hands {@link Worksheet._commitWithDirectives} beyond its selection and options.
  * @internal
  */
 export interface CommitDirectives {
@@ -102,7 +116,7 @@ export interface CommitDirectives {
     /** Handed to the commit. */
     commit?: ITransaction.StoreOperationOptions;
 }
-/** The sheet's legacy drawing as it holds it: {@link ISheet.LegacyDrawingJSON} with each image resolved to its {@link IResource}, so paste and `.sxl` keep working. */
+/** The sheet's legacy drawing as it holds it: {@link IWorksheet.LegacyDrawingJSON} with each image resolved to its {@link IResource}, so paste and `.sxl` keep working. */
 interface LegacyDrawing {
     xml: string;
     images?: LegacyDrawingImage[];
@@ -112,8 +126,8 @@ interface LegacyDrawingImage {
     id: string;
     resource: IResource;
 }
-export declare class Sheet implements ISheet {
-    protected _options: ISheet.ConstructorOptions;
+export declare class Worksheet implements IWorksheet {
+    protected _options: IWorksheet.ConstructorOptions;
     protected _id: string;
     /** The store-issued key for this sheet's state record. Distinct from `_id`, the document-level id (formula scope / JSON). */
     protected _stateId: string;
@@ -128,7 +142,12 @@ export declare class Sheet implements ISheet {
      * close before an earlier one lands. See {@link _onRootTransactionClose}.
      */
     protected _movableSelectionAtCommitEnd: Map<ITransaction.ICommit, readonly string[]>;
-    protected _emitter: ListenerEmitter<ISheet, ISheet.IListeners>;
+    /**
+     * What calculation passes realized while a root was open, told to listener nodes once it
+     * closes. See {@link _realizeCalcedValues}.
+     */
+    protected _heldPassRanges: IRange.Coords[] | null;
+    protected _emitter: ListenerEmitter<IWorksheet, IWorksheet.IListeners>;
     protected _initializing: boolean;
     protected _starting: Promise<void> | null;
     protected _strings: IStringCollection;
@@ -139,7 +158,22 @@ export declare class Sheet implements ISheet {
     protected _ownStyles: boolean;
     protected _stylesRemoveListener: IListener.Remove;
     protected _languageRemoveListener?: IListener.Remove;
+    protected _fontsRemoveListener?: IListener.Remove;
     protected _regionalRemoveListener?: IListener.Remove;
+    /** Autofits that measured with a stand-in while a face was loading; taken again when it lands. */
+    /** Fits owed once the faces have loaded: held before they ran (`ran` false), or run against a stand-in. */
+    protected _pendingFits: {
+        ranges: readonly IRange.Coords[];
+        options?: ICellRange.AutoFitOptions;
+        ran: boolean;
+    }[];
+    /** Set while fits are owed to the text engine's arrival; see {@link _autoFit}. */
+    private _engineWait;
+    /**
+     * Whether the load-time row fit was skipped (`disableLoadAutoFit`): the stored heights are the
+     * file's, so no row was measured with a stand-in and a font arriving has none to correct.
+     */
+    protected _loadFitSkipped: boolean;
     protected _stylesListener: IStyleCollection.IListeners;
     protected _normalStyleRanged: IProperties.ICellRanged<ICellStyle.Properties>;
     protected _resources: IResourceCollection;
@@ -153,6 +187,8 @@ export declare class Sheet implements ISheet {
     protected _legacyDrawingHF: LegacyDrawing | null;
     /** The sheet's pivot tables, held as read for the same reason. */
     protected _pivotTableCollection: IPivotTableCollection;
+    /** The sheet's data tables, carried as read. */
+    protected _dataTableCollection: IDataTableCollection;
     /**
      * Anchored items whose delete this sheet announced itself.
      *
@@ -225,17 +261,24 @@ export declare class Sheet implements ISheet {
     protected _entireCoordsCache: IRange.Coords | null;
     protected _entireRangeCache: ICellRange | null;
     protected _isDataColumn: boolean;
-    protected _view: ISheetView;
-    protected _viewListener: ISheetView.IListeners;
+    protected _view: IWorksheetView;
+    protected _viewListener: IWorksheetView.IListeners;
     protected _viewRemoveListener: IListener.Remove;
-    protected _protection: SheetProtection;
+    protected _protection: WorksheetProtection;
     protected _protectionListener: IProtection.IListeners;
     protected _protectionRemoveListener: IListener.Remove;
     protected _tabColor: IColor | null;
-    /** VBA binding identity; carried from the file, never minted. See {@link ISheet.getCodeName}. */
+    /** VBA binding identity; carried from the file, never minted. See {@link IWorksheet.getCodeName}. */
     protected _codeName: string | null;
+    /** See {@link IWorksheet.JSON.baseColSize}. `null` is the default, 8. */
+    protected _baseColSize: number | null;
     protected _outline: Outline;
+    protected _pageLayout: PageLayout;
     protected _conditionalFormatCalculation: boolean;
+    /** Carried from `sheetPr`; see {@link IWorksheet.isTransitionFormulaEvaluation} and its neighbors. */
+    /** Carried from the file. See {@link IDataValidationCollection.getSettings}. */
+    protected _validationSettings: Readonly<IDataValidationCollection.Settings>;
+    protected _sheetPr: Pick<IWorksheet.JSON, 'transitionFormulaEvaluation' | 'transitionFormulaEntry' | 'excludeFromPublishing' | 'syncScroll'>;
     /**
      * Modules this sheet owns — see {@link getModules}.
      *
@@ -273,19 +316,20 @@ export declare class Sheet implements ISheet {
     protected _defaultColWidthCache: number | null;
     protected _defaultRowHeightCache: number | null;
     protected _defaultFontBoundsCache: Readonly<Size> | null;
+    protected _defaultFontsVersion: number;
     /**
      * The internal capability object handed to `SheetRange`/`SheetRanges` (and future extracted
      * modules) so they can drive the sheet without touching its (non-public) methods or the concrete
      * class shape. The closures reach `Sheet`'s protected members because they are lexically inside the
-     * class. Public `ISheet` API is reached via `getSheet()` (never duplicated here). As internal logic
+     * class. Public `IWorksheet` API is reached via `getWorksheet()` (never duplicated here). As internal logic
      * moves out to modules, only the relevant closure repoints — consumers never change.
-     * The `ISheetInternal` type is derived from this object (see below) so it can never drift.
+     * The `IWorksheetInternal` type is derived from this object (see below) so it can never drift.
      * @internal
      */
     private readonly _internal;
-    /** @internal Access the internal capability object. See {@link ISheetInternal}. */
+    /** @internal Access the internal capability object. See {@link IWorksheetInternal}. */
     _getInternal(): {
-        getSheet: () => ISheet;
+        getSheet: () => IWorksheet;
         getState: () => Readonly<State>;
         getCalcGrid: () => ICalcGrid;
         isDataColumn: () => boolean;
@@ -327,11 +371,11 @@ export declare class Sheet implements ISheet {
         beginCommit: (options?: ITransaction.StoreOperationOptions | string) => ITransaction;
         recordSelection: (trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => void;
         commitWithDirectives: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives) => void;
-        autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
+        autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions, holdWhileLoading?: boolean) => void;
         getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
-        invalidateRendering: () => void;
+        invalidateRendering: (axes?: IRange.AxisSelection | null) => void;
         addListenerNode: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
-        addWatch: (coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: ICellRange.WatchOptions) => IListener.Remove;
+        addWatch: (coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: WatchAnchor.Options) => IListener.Remove;
         surroundingRegion: (range: IRange.Coords, options?: ICellRange.GetSurroundingOptions) => IRange.Coords;
         getTraverseRegion: (cell: IRange.CellCoords, axis: IRange.Axis, reverse: boolean) => IRange.Coords | null;
         sort: (coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | (ISort.RangeOptions & ITransaction.OperationOptions)) => IRange.Coords;
@@ -340,6 +384,7 @@ export declare class Sheet implements ISheet {
         applyFilterRuns: (runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions) => void;
         filteredTables: () => ITable[];
         setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
+        setErrorIgnored: (ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean, options?: ITransaction.OperationOptions) => void;
         setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
         getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
         extendRange: (direction: IRange.Direction, cell: IRange.CellCoords) => Readonly<IRange.Coords>;
@@ -357,6 +402,96 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _getReadCtx(): SheetReadContext;
+    /** This sheet's first-pass findings and what they were derived from; see {@link _getAnomalyFindings}. */
+    protected _anomalyFindings: {
+        state: Readonly<State>;
+        values: unknown;
+        formulas: unknown;
+        epoch: number;
+        roleColors: string;
+        findings: AnomalyFindings;
+    } | null;
+    /**
+     * The error checks' findings on this sheet, each ranked alone. Derived on the first read that
+     * asks for it and kept until the sheet's state, its formulas or its values move, or the
+     * workbook's role colors change.
+     * @internal
+     */
+    protected _getAnomalyFindings(roleColors?: WorkbookRoleColors): AnomalyFindings;
+    /** This worksheet and the workbook's others, very hidden included. */
+    protected _getWorkbookSheets(): Worksheet[];
+    /** The workbook's role colors and the sheets' sets they were the union of; see {@link _getWorkbookRoleColors}. */
+    protected _workbookRoleColors: (WorkbookRoleColors & {
+        sheets: readonly ReadonlySet<string>[];
+    }) | null;
+    /**
+     * The font colors any sheet writes a role in, the union `styleRole` reads. `key` changes only
+     * when the union does, so an edit that recolors nothing keeps the other sheets' findings.
+     * @internal
+     */
+    protected _getWorkbookRoleColors(): WorkbookRoleColors;
+    /** The anomalies map and the workbook's findings it was ranked against; see {@link _getAnomalies}. */
+    protected _anomalies: {
+        workbook: readonly AnomalyFindings[];
+        map: ISpatialMap<AnomalySet>;
+    } | null;
+    /**
+     * Where the error checks fire on this sheet (`ICellRange.Feature.Anomalies`).
+     *
+     * @remarks
+     * A finding's rank depends on how often it repeats across the workbook, so the first read on
+     * any sheet derives every sheet's findings; each is kept until its own sheet moves, and this map
+     * until any of them does. Nothing on a write or a calculation pays for it.
+     * @internal
+     */
+    protected _getAnomalies(): ISpatialMap<AnomalySet>;
+    /** What the role layer is read from: this sheet's content and formulas, as they are now. */
+    protected _roleSource(): RoleSource;
+    /** The roles map and what it was derived from; see {@link _getRoles}. */
+    protected _roles: {
+        state: Readonly<State>;
+        values: unknown;
+        formulas: unknown;
+        epoch: number;
+        map: ISpatialMap<ICell.Role>;
+    } | null;
+    /**
+     * Each cell's job (`ICellRange.Feature.Role`), derived on the first read that asks for it and
+     * kept, like {@link _getAnomalies}, until the sheet moves.
+     * @internal
+     */
+    protected _getRoles(): ISpatialMap<ICell.Role>;
+    /** What the checks read of this sheet, as it is now. */
+    protected _anomalySource(): AnomalySource;
+    /** The role colors and what they were derived from; see {@link _getRoleColors}. */
+    protected _roleColors: {
+        state: Readonly<State>;
+        values: unknown;
+        formulas: unknown;
+        epoch: number;
+        colors: ReadonlySet<string>;
+    } | null;
+    /**
+     * The font colors this sheet writes its roles in, for another sheet's `styleRole` check. Derived
+     * on the first read and kept, like {@link _getAnomalies}, until the sheet moves.
+     */
+    protected _getRoleColors(): ReadonlySet<string>;
+    /** The kinds map and what it was derived from; see {@link _getKinds}. */
+    protected _kinds: {
+        state: Readonly<State>;
+        values: unknown;
+        epoch: number;
+        map: ISpatialMap<CellKind>;
+    } | null;
+    /**
+     * What each cell holds, by kind (`ICellRange.Feature.Kind`).
+     *
+     * @remarks
+     * One scan of the values, derived on the first read that asks for it and kept until the sheet's
+     * state or its values move, as {@link _getAnomalies} is.
+     * @internal
+     */
+    protected _getKinds(): ISpatialMap<CellKind>;
     /**
      * The sheet's grid: the synchronous half of the calculation service for this sheet
      * (DESIGN-CALC-SERVICE §13.23, §13.24), holding everything a cell contains - the formulas, the
@@ -374,7 +509,7 @@ export declare class Sheet implements ISheet {
     /** `false` for a snapshot sheet, which holds its source's grid and must not close it. */
     protected _ownsCalcGrid: boolean;
     /** @internal Cached mutation-engine context. See {@link SheetMutationContext}. */
-    protected _mutationCtx: ReturnType<Sheet['_buildMutationCtx']> | null;
+    protected _mutationCtx: ReturnType<Worksheet['_buildMutationCtx']> | null;
     /** @internal Access the mutation context (cached). See {@link SheetMutationContext}. */
     protected _getMutationCtx(): SheetMutationContext;
     /**
@@ -386,10 +521,11 @@ export declare class Sheet implements ISheet {
     protected _buildMutationCtx(): {
         readonly rowHeaders: SheetHeader;
         readonly columnHeaders: SheetHeader;
+        readonly pageLayout: PageLayout;
         readonly rowHeadersShiftCallback: SheetHeader.ShiftCallback | null;
         readonly columnHeadersShiftCallback: SheetHeader.ShiftCallback | null;
         getEntireCoords: () => IRange.Coords;
-        getView: () => ISheetView;
+        getView: () => IWorksheetView;
         beginCommit: (options?: ITransaction.StoreOperationOptions | string) => ITransaction;
         updateState: (updateState?: Partial<State>, options?: ITransaction.OperationOptions | string) => State;
         getState: () => Readonly<State>;
@@ -407,6 +543,7 @@ export declare class Sheet implements ISheet {
         takeShiftedNoteModels: () => Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
         markColumnHeaderTableNames: () => void;
         commitWithDirectives: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives) => void;
+        recordAutoFit: (trans: ITransaction, ranges: readonly IRange.Coords[], autoFit: boolean | ICellRange.AutoFitOptions) => void;
         readonly styles: IStyleCollection;
         getRangedEntries: <T, E = T>(spatial: ISpatialQuery, ranges: readonly IRange.Coords[], options?: GetTypedRangeOptions<T, E>, spatialSort?: boolean) => T[];
         createSparseBuilder: (options?: ICellRange.SparseBuilderOptions, sheetRange?: ICellRange | null, internal?: InternalTupleUpdate) => ICellRange.SparseBuilder;
@@ -415,12 +552,13 @@ export declare class Sheet implements ISheet {
             fill: IUsedRangeSpatialMap<SheetDirectStyle>;
             content: IUsedRangeSpatialMap<SheetDirectStyle>;
         }) => IUsedRangeSpatialMap<SheetDirectStyle>;
-        autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
+        autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions, holdWhileLoading?: boolean) => void;
         recordAutoFormat: (trans: ITransaction) => void;
         recordSkipProtectionCheck: (trans: ITransaction) => void;
         recordFreezePanes: (trans: ITransaction, before: IRange.CellCoords, after: IRange.CellCoords) => void;
+        recordShift: (trans: ITransaction, kind: IWorksheet.ShiftKind, axis: IRange.Axis, ranges: readonly IRange.Coords[]) => void;
         recordSelection: (trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => void;
-        notify: (key: keyof ISheet.IListeners) => void | Promise<any>;
+        notify: (key: keyof IWorksheet.IListeners) => void | Promise<any>;
         getRange: (address?: ICellRange.Address, options?: ICellRange.GetRangeOptions) => ICellRange;
         getSelection: () => IRangeSelection;
         getMerges: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => IRange.Coords[];
@@ -432,10 +570,10 @@ export declare class Sheet implements ISheet {
         readonly lists: ScalarListFactory;
         readonly cellOptions: SheetCellOptions;
         readonly runtime: IRuntime;
-        getProtection: () => ISheetProtection;
+        getProtection: () => IWorksheetProtection;
         hasRangedEntries: (key: keyof State, range: IRange.Coords) => boolean;
         rangeStateIterator: (options: RangeState.IteratorOptions) => RangeState.Iterator;
-        recordChange: (trans: ITransaction, category: EventCategory, ranges: readonly IRange.Coords[] | null | undefined) => void;
+        recordChange: (trans: ITransaction, category: EventCategory, ranges: readonly IRange.Coords[] | null | undefined, shifts?: readonly ShiftIntent[]) => void;
         loadComments: (map: IAnchoredMap<IComment, IComment.JSON>, refs: IRange.JSONReference<IComment.JSON>[]) => IAnchoredMap<IComment, IComment.JSON>;
         newCommentJSON: (modifiers: IComment.Modifiers) => IComment.JSON;
         notifyCommentsChange: () => void;
@@ -453,7 +591,7 @@ export declare class Sheet implements ISheet {
     /** @internal Single-entry memo behind `autoFill({ preview })`. See {@link AutoFillPreviewCache}. */
     protected _autoFillPreviewCache: AutoFillPreviewCache | null;
     /** @internal Cached coord-resolution context. See {@link SheetCoordContext}. */
-    protected _coordCtx: ReturnType<Sheet['_buildCoordCtx']> | null;
+    protected _coordCtx: ReturnType<Worksheet['_buildCoordCtx']> | null;
     /** @internal Access the coord-resolution context (cached). See {@link SheetCoordContext}. */
     protected _getCoordCtx(): SheetCoordContext;
     /**
@@ -463,7 +601,7 @@ export declare class Sheet implements ISheet {
      */
     protected _buildCoordCtx(): {
         readonly internal: {
-            getSheet: () => ISheet;
+            getSheet: () => IWorksheet;
             getState: () => Readonly<State>;
             getCalcGrid: () => ICalcGrid;
             isDataColumn: () => boolean;
@@ -505,11 +643,11 @@ export declare class Sheet implements ISheet {
             beginCommit: (options?: ITransaction.StoreOperationOptions | string) => ITransaction;
             recordSelection: (trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, "autoSelect" | "autoSelectRestore"> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => void;
             commitWithDirectives: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives) => void;
-            autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
+            autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions, holdWhileLoading?: boolean) => void;
             getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
-            invalidateRendering: () => void;
+            invalidateRendering: (axes?: IRange.AxisSelection | null) => void;
             addListenerNode: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
-            addWatch: (coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: ICellRange.WatchOptions) => IListener.Remove;
+            addWatch: (coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: WatchAnchor.Options) => IListener.Remove;
             surroundingRegion: (range: IRange.Coords, options?: ICellRange.GetSurroundingOptions) => IRange.Coords;
             getTraverseRegion: (cell: IRange.CellCoords, axis: IRange.Axis, reverse: boolean) => IRange.Coords | null;
             sort: (coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | (ISort.RangeOptions & ITransaction.OperationOptions)) => IRange.Coords;
@@ -518,6 +656,7 @@ export declare class Sheet implements ISheet {
             applyFilterRuns: (runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions) => void;
             filteredTables: () => ITable[];
             setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
+            setErrorIgnored: (ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean, options?: ITransaction.OperationOptions) => void;
             setComments: (ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, options?: ITransaction.OperationOptions) => void;
             getBoundsAtCoords: (coords: IRange.Coords) => Bounds;
             extendRange: (direction: IRange.Direction, cell: IRange.CellCoords) => Readonly<IRange.Coords>;
@@ -536,32 +675,34 @@ export declare class Sheet implements ISheet {
         getEntireCoords: () => IRange.Coords;
         getNamedFormulas: () => import('..').INamedFormulasCollection;
         getNames: () => INamedCollection;
-        getProtection: () => ISheetProtection;
+        getProtection: () => IWorksheetProtection;
         getName: () => string;
         resolveRange: (coord: ICellRange.Address) => ICellRange | null | undefined;
     };
-    constructor(options?: ISheet.ConstructorOptions);
+    constructor(options?: IWorksheet.ConstructorOptions);
     /** @internal Logic lives in `_SheetCoords.createRange`. */
     protected _createRange(coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null): ICellRange;
     /** @internal Logic lives in `_SheetCoords.createRanges`. */
     protected _createRanges(coords: readonly (IRange.Coords | string | ICellRange)[], getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null): ICellRanges;
-    /** {@inheritDoc ISheet.getRange} */
+    /** {@inheritDoc IWorksheet.getRange} */
     getRange(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
-    /** {@inheritDoc ISheet.getCell} */
+    /** {@inheritDoc IWorksheet.getCell} */
     getCell(address?: ICell.Address): ICell;
-    /** {@inheritDoc ISheet.getRange} */
+    /** {@inheritDoc IWorksheet.getRange} */
     getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
-    /** {@inheritDoc ISheet.getEntireRange} */
+    /** {@inheritDoc IWorksheet.getEntireRange} */
     getEntireRange(options?: ICellRange.GetRangeOptions): ICellRange;
     protected _getEntireCoords(): IRange.Coords;
-    /** {@inheritDoc ISheet.getEntireCoords} */
+    /** {@inheritDoc IWorksheet.getEntireCoords} */
     getEntireCoords(): IRange.Coords;
-    /** {@inheritDoc ISheet.getUsedRange} */
+    /** {@inheritDoc IWorksheet.getUsedRange} */
     getUsedRange(options?: ICellRange.GetRangeOptions): ICellRange | null;
-    /** {@inheritDoc ISheet.getStats} */
+    /** {@inheritDoc IWorksheet.getStats} */
     getStats(options?: ICellRange.GetStatsOptions): IRangeStats;
-    /** {@inheritDoc ISheet.getRegions} */
+    /** {@inheritDoc IWorksheet.getRegions} */
     getRegions(features?: ICellRange.Feature | readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): ICellRegions;
+    /** {@inheritDoc IWorksheet.getAnomalies} */
+    getAnomalies(options?: ICellRange.GetAnomaliesOptions): ICellRegions;
     /** @internal Logic lives in `_SheetCoords.cellToCoords`. */
     protected _cellToCoords(address: ICell.Address): IRange.CellCoords;
     /** @internal Logic lives in `_SheetCoords.validateCoords`. */
@@ -683,6 +824,8 @@ export declare class Sheet implements ISheet {
     protected _autoFillRange(template: IRange.Coords, destination: IRange.Coords): IRange.Coords;
     /** @internal Logic lives in `_SheetMutations.autoFillShrink`. */
     protected _autoFillShrink(template: IRange.Coords, destination: IRange.Coords, direction: IRange.Direction, options?: ICellRange.AutoFillOptions): boolean;
+    /** @internal Logic lives in `_SheetMutations.setErrorIgnored`. */
+    protected _setErrorIgnored(ranges: readonly IRange.Coords[], check: ICell.ErrorCheck, ignored: boolean, options?: ITransaction.OperationOptions): void;
     /** @internal Logic lives in `_SheetMutations.setHyperlinks`. */
     protected _setHyperlinks(ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, // we do this because updateTuples may update each
     options?: ITransaction.OperationOptions): void;
@@ -725,6 +868,12 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _realizeCalcedValues(results: ICalcGrid.Results): void;
+    /**
+     * Tell listener nodes what calculation passes realized. A pass belongs to no commit, so the
+     * event carries no transaction id.
+     * @internal
+     */
+    protected _notifyPassToListenerNodes(ranges: readonly IRange.Coords[]): void;
     /**
      * Land the promoted half of a pass's results - number formats and sizes - in the commit that
      * entered the formulas they belong to.
@@ -744,10 +893,32 @@ export declare class Sheet implements ISheet {
      * the references the formula inherits one from, resolved here against the entering commit's
      * snapshot ({@link _resolveInheritedFormats}), or else the format its functions supplied.
      *
+     * One pass can answer for several entering commits: writes made before the engine runs are
+     * calculated together, and the pass names only the last of them. Each one still formats and
+     * fits under its own directives and against its own snapshot ({@link _enteredSince}), but the
+     * writes land in the target, since an amend reaches only the snapshot it names.
+     *
      * @internal
      */
     protected _promoteCalcResults(target: ITransaction.ICommit, results: ICalcGrid.Results): void;
-    /** {@inheritDoc ISheet.calculate} */
+    /**
+     * The commits a pass targeting `target` answers for on this sheet, newest first, each with the
+     * cells it entered that the pass realized and no newer one of them re-entered.
+     *
+     * @remarks
+     * Walks back from the target to the first commit already resolved for this sheet: anything
+     * older was answered by that commit's pass. Bounded by {@link _MAX_PROMOTE_WALK}, since the walk
+     * runs on every pass.
+     *
+     * @internal
+     */
+    protected _enteredSince(target: ITransaction.ICommit, bounds: IRange.Coords): {
+        commit: ITransaction.ICommit;
+        entered: IRange.Coords[];
+    }[];
+    /** How far back a pass looks for entering commits it answers for. */
+    private static readonly _MAX_PROMOTE_WALK;
+    /** {@inheritDoc IWorksheet.calculate} */
     calculate(full?: boolean): Promise<ICalculation.Status>;
     /** @internal */
     protected _calculate(ranges: ICellRanges.Coords, options?: ICalculation.CalculateOptions): void;
@@ -766,21 +937,46 @@ export declare class Sheet implements ISheet {
     /** @internal */
     protected _getMerges(ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis): IRange.Coords[];
     /** @internal */
-    protected _clone(): ISheet;
+    protected _clone(): IWorksheet;
+    /**
+     * A read-only sheet as this sheet was at a commit, or `null` when the store no longer has the
+     * commit or the sheet did not exist at it.
+     *
+     * @remarks
+     * Built on demand and not kept: it copies no cells, only the state record and a grid pinned
+     * to the commit's record.
+     * @internal
+     */
+    _snapshotAt(commitId: string): IWorksheet | null;
+    /** The snapshot sheet `_clone` and `_snapshotAt` build, over a given state and grid. */
+    private _cloneOver;
     /** @internal */
     protected _getSnapshot(coordsFrom: readonly IRange.Coords[], optionsMark?: ICellRange.CopyOptions, getTransactionId?: () => string): ICellRange.ISnapshot;
     /**
      * Copy all items at a sheetRange.
      * @internal
      `*/
-    protected _copyRange(sheetFrom: Sheet, sheetMark: Sheet, coordsFrom: readonly IRange.Coords[], sheetRangeTo: ICellRange, options: ICellRange.CopyOptions | undefined, toInfo: any): Promise<IRange.Coords>;
+    protected _copyRange(sheetFrom: Worksheet, sheetMark: Worksheet, coordsFrom: readonly IRange.Coords[], sheetRangeTo: ICellRange, options: ICellRange.CopyOptions | undefined, toInfo: any): IRange.Coords;
     /**
      * Returns `null` if invalid.
      * @internal
      */
     protected _snapShotFromSource(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
-    /** @internal */
+    /**
+     * A paste: what the snapshot has to wait for is waited for first, outside any transaction
+     * ({@link ICellRange.ISnapshot.prepare}), and the paste itself then opens, writes and commits its
+     * transaction in one synchronous extent ({@link _copyFromNow}). With nothing to wait for, the
+     * whole paste runs in the caller's synchronous extent: a paste begun while another is suspended
+     * is never nested in it, and a read made right after sees the pasted cells.
+     * @internal
+     */
     protected _copyFrom(destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<IRange.Coords>;
+    /**
+     * The paste itself, once its snapshot has prepared: one transaction, opened, written and
+     * committed here.
+     * @internal
+     */
+    protected _copyFromNow(destination: IRange.Coords, snapshot: ICellRange.ISnapshot, options?: ICellRange.CopyOptions): IRange.Coords;
     /**
      * Where a {@link _copyFrom} lands, and whether the merges there let it - Excel's rules:
      *
@@ -795,9 +991,9 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _resolveCopyDestination(destination: IRange.Coords, snapshot: ICellRange.ISnapshot, options: ICellRange.CopyOptions | undefined, isCut: boolean): IRange.Coords;
-    /** {@inheritDoc ISheet.addAutoTable} */
+    /** {@inheritDoc IWorksheet.addAutoTable} */
     addAutoTable(address?: ICellRange.Address, options?: ICellRange.AddAutoTableOptions): ITable;
-    /** {@inheritDoc ISheet.getAutoTable} */
+    /** {@inheritDoc IWorksheet.getAutoTable} */
     getAutoTable(): ITable | null;
     /**
      * The tables on this sheet that hold a filter condition: the AutoTable, then the tables. What
@@ -833,8 +1029,14 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _canInsertFrom(ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): boolean;
-    /** @internal */
+    /**
+     * An insert-paste, in the two parts of a {@link _copyFrom}: the snapshot prepares outside any
+     * transaction, then {@link _insertFromNow} inserts, pastes and commits in one synchronous extent.
+     * @internal
+     */
     protected _insertFrom(ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<IRange.Coords>;
+    /** @internal */
+    protected _insertFromNow(ranges: readonly IRange.Coords[], snapshot: ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): IRange.Coords;
     /**
      * Insert cells, shifting existing content down/right.
      * @internal
@@ -857,8 +1059,18 @@ export declare class Sheet implements ISheet {
      *
      * @remarks
      * Implementation lives in `_SheetAutoFitUtils` (same pattern as `_SheetSortUtils.doSort`).
+     * A fit that measured a face still loading (answered with a stand-in) is kept and taken again
+     * when the face lands; a fit that measured only loaded faces is final.
      */
-    protected _autoFit(ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
+    protected _autoFit(ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions, holdWhileLoading?: boolean): void;
+    /**
+     * Runs the fits owed (see {@link _autoFit}): one held runs for the first time as it was asked;
+     * one that ran against a stand-in runs again, leaving alone a custom size or a hidden row set
+     * since (its first run already cleared what the caller asked to override).
+     *
+     * @returns `false` if none were owed.
+     */
+    private _runPendingFits;
     /**
      * The size a range's content needs, without writing it. See {@link ICellRange.getBestFit}.
      *
@@ -914,9 +1126,11 @@ export declare class Sheet implements ISheet {
      * @param origin Where `formula` is authored when it is not `coords`' own top-left: the shared
      *               origin of a multi-area watch, from which the body is filled to `coords`.
      * @param options `arrayFirstCell`: every cell of the body is its own 1x1 array-entered formula.
+     *                `paged`: the body's blank region is evaluated where its owner asks (see
+     *                {@link WatchAnchor.Options.paged}).
      * @internal
      */
-    protected _addWatch(coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: ICellRange.WatchOptions): IListener.Remove;
+    protected _addWatch(coords: IRange.Coords, formula: ICalculation.IFormula | string, handlers: WatchAnchor.Handlers, origin?: IRange.CellCoords, options?: WatchAnchor.Options): IListener.Remove;
     /**
      * The one amend that creates a watch: its node, its grid and its body.
      *
@@ -926,7 +1140,7 @@ export declare class Sheet implements ISheet {
      * node in the versioned map, the entry that holds its callbacks, and the removal.
      * @internal
      */
-    protected _registerWatch(coords: IRange.Coords, expression: string, authoredAt: IRange.CellCoords, handlers: WatchAnchor.Handlers, arrayFirstCell: boolean): IListener.Remove;
+    protected _registerWatch(coords: IRange.Coords, expression: string, authoredAt: IRange.CellCoords, handlers: WatchAnchor.Handlers, arrayFirstCell: boolean, paged: boolean): IListener.Remove;
     /**
      * A watch's body is a grid the engine holds once, for every snapshot, so a watch is made and
      * removed against the commit the store is at. Inside an amend of any other commit its node and
@@ -992,6 +1206,17 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _removeListenerNode(node: ListenerAnchor): void;
+    /**
+     * Tell the participants bound to `batch` of each of its steps, from the step's own intents.
+     *
+     * @remarks
+     * Told inline, as the step commits and before the operation that made it returns, so what a
+     * participant writes is the batch's next step. Moves first, as at the root's end.
+     *
+     * @internal
+     */
+    protected _hearBatchSteps(batch: BatchHandle): void;
+    protected _batchesHeard: WeakSet<BatchHandle> | null;
     /**
      * Deliver to every node whose reference intersects what changed.
      *
@@ -1005,7 +1230,7 @@ export declare class Sheet implements ISheet {
      *
      * @internal
      */
-    protected _notifyListenerNodes(state: State, ranges: readonly IRange.Coords[] | null, notificationOptions: NotifierOptions, transactional: boolean, renamed?: boolean): void;
+    protected _notifyListenerNodes(state: State, ranges: readonly IRange.Coords[] | null, notificationOptions: NotifierOptions, transactional: boolean, renamed?: boolean, includes?: ((entry: ListenerNodeEntry) => boolean) | null): void;
     /**
      * Deliver to every live node whose reference is no longer where it was.
      *
@@ -1023,7 +1248,7 @@ export declare class Sheet implements ISheet {
      *
      * @internal
      */
-    protected _notifyListenerNodeMoves(state: State, transactional: boolean, notificationOptions: NotifierOptions | null): void;
+    protected _notifyListenerNodeMoves(state: State, transactional: boolean, notificationOptions: NotifierOptions | null, includes?: ((entry: ListenerNodeEntry) => boolean) | null): void;
     /**
      * One delivery, after the option filters.
      *
@@ -1033,10 +1258,33 @@ export declare class Sheet implements ISheet {
     /** @internal */
     protected _notifyUsedRangeChange(): void;
     /** @internal */
-    protected _notify(key: keyof ISheet.IListeners): void | Promise<any>;
+    protected _notify(key: keyof IWorksheet.IListeners): void | Promise<any>;
+    /**
+     * Fires one of the events that carry a {@link IWorksheet.ChangeEvent}.
+     *
+     * @param coords What changed, or `null` for the whole sheet.
+     * @param details What wrote it; a `null` commit for a change not written.
+     * @internal
+     */
+    protected _notifyChange(key: IWorksheet.ChangeEventKey, coords: readonly IRange.Coords[] | null, details: SheetChangeDetails): void;
+    /**
+     * The change events a commit announces on this sheet, in the order they fire: what the commit
+     * path delivers and {@link IWorkbook.getChanges} reads back.
+     * @internal
+     */
+    protected _commitChanges(scoped: SheetEvents | null, details: SheetChangeDetails): {
+        key: IWorksheet.ChangeEventKey;
+        coords: IRange.Coords[];
+        details: SheetChangeDetails;
+    }[];
+    /**
+     * What a commit wrote on this sheet, as {@link IWorkbook.getChanges} reports it.
+     * @internal
+     */
+    _changeEventsOf(commit: ITransaction.ICommit, previous: ITransaction.ICommit | null): IWorksheet.ChangeEvent[];
     /**
      * Every collection change fires its fine-grained event PLUS the coarse class event it belongs
-     * to (see `ISheet.Events.onStyleChange` / `onProtectionChange`), so renderers subscribe to the
+     * to (see `IWorksheet.Events.onStyleChange` / `onProtectionChange`), so renderers subscribe to the
      * class alone. These helpers are the single place that pairing lives — fire sites must use them
      * rather than `_notify` directly so a collection can never drift out of its class.
      * @internal
@@ -1060,8 +1308,8 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _forwardCollectionListeners(key: 'onTablesChange' | 'onConditionalFormatsChange' | 'onDataValidationsChange' | 'onProtectedRangesChange' | 'onCommentsChange', collection: () => ICollection<any>): (listeners: ICollection.IListeners, options?: IListener.Options) => IListener.Remove;
-    /** {@inheritDoc ISheet.addListeners} */
-    addListeners(listeners: ISheet.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc IWorksheet.addListeners} */
+    addListeners(listeners: IWorksheet.IListeners, options?: IListener.Options): IListener.Remove;
     /** @internal */
     protected _getUsedCoords(options?: ICellRange.GetRangeOptions): IRange.Coords | null;
     /** @internal */
@@ -1079,7 +1327,7 @@ export declare class Sheet implements ISheet {
      *
      * Every public feature is counted INDEPENDENTLY (no refinement — a refined count is
      * `getRegions`), and the result carries the full `ICellRange.Feature` key set with explicit
-     * zeros. Every feature reads off its own state map now — `DateFormat` off `dateFormatSpatial`,
+     * zeros, except `anomalies`, which is keyed only when requested. Every feature reads off its own state map now — `DateFormat` off `dateFormatSpatial`,
      * `Error` off the reconciled error spatial (cached per state version) — grouped by backing map
      * so shared backings (the three content-style projections) iterate once. There is no value-scan
      * branch left: that used to exist for the scalar kinds (`String`/`Number`/`Boolean`, and the old
@@ -1153,13 +1401,21 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _featureRegions(bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): IRange.Coords[];
-    /** {@inheritDoc ISheet.find} */
+    /** {@inheritDoc IWorksheet.find} */
     find(options?: string | ICellRange.FindOptions): Iterator<ICell>;
-    /** {@inheritDoc ISheet.setEntireSize} */
-    setEntireSize(size?: Partial<Size> | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IWorksheet.setEntireSize} */
+    setEntireSize(size?: Partial<IWorksheet.EntireSize> | null, options?: ITransaction.OperationOptions): this;
+    private _getEntireSize;
+    /** The size that ends where the sheet's content does. */
+    private _getFittedSize;
+    /**
+     * Moves the sheet's end to `size`, within the caller's transaction. The cells it adds or removes
+     * are inserted and deleted at the end, so ranges that reach the end follow it.
+     */
+    private _resizeEntire;
     /** @internal */
     protected _find(ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions): Iterator<ICell>;
-    /** {@inheritDoc ISheet.getRuntime} */
+    /** {@inheritDoc IWorksheet.getRuntime} */
     getRuntime(): IRuntime;
     /**
      * The region a bare-cursor traverse from `cell` wraps within, or `null` for a plain move. A table
@@ -1173,7 +1429,7 @@ export declare class Sheet implements ISheet {
     protected _extendRange(direction: IRange.Direction, cell: IRange.CellCoords): Readonly<IRange.Coords>;
     /** @internal */
     protected _defaultFontDims(): Readonly<Size>;
-    /** {@inheritDoc ISheet.getColumnWidthAsFontUnit} */
+    /** {@inheritDoc IWorksheet.getColumnWidthAsFontUnit} */
     getColumnWidthAsFontUnit(pixelWidth: number): number;
     protected _createTupleBuilder<T>(transpose?: boolean): Tuple.IBuilder<T>;
     /**
@@ -1186,14 +1442,14 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _defaultRowHeight(): number;
-    /** {@inheritDoc ISheet.getProtection} */
-    getProtection(): ISheetProtection;
+    /** {@inheritDoc IWorksheet.getProtection} */
+    getProtection(): IWorksheetProtection;
     /** @internal */
     protected _scrollIntoView(coords: IRange.Coords, scrollIntoView?: boolean | ICellRange.ScrollIntoViewOptions): Promise<boolean>;
     /** @internal */
     protected _selectSheet(coords: IRange.Coords, scrollIntoView?: boolean | ICellRange.ScrollIntoViewOptions): Promise<boolean>;
-    /** {@inheritDoc ISheet.scrollTo} */
-    scrollTo(coords: Partial<IRange.Coords>, options?: ISheet.ScrollToOptions): Promise<boolean>;
+    /** {@inheritDoc IWorksheet.scrollTo} */
+    scrollTo(coords: Partial<IRange.Coords>, options?: IWorksheet.ScrollToOptions): Promise<boolean>;
     /** @internal */
     protected _resolveSelectOptions(selectOptions: boolean | ICellRange.SelectOptions, axis?: IRange.Axis): ICellRange.SelectOptions | null;
     /**
@@ -1233,7 +1489,7 @@ export declare class Sheet implements ISheet {
      *
      * @remarks
      * A sheet can be shown through more than one view, and a view instance is replaced on load and
-     * by {@link setView}, so the match is on {@link ISheetView.getId}.
+     * by {@link setView}, so the match is on {@link IWorksheetView.getId}.
      *
      * @internal
      */
@@ -1258,7 +1514,23 @@ export declare class Sheet implements ISheet {
      *
      * @internal
      */
-    protected _recordChange(trans: ITransaction, category: EventCategory, ranges: readonly IRange.Coords[] | null | undefined): void;
+    protected _recordChange(trans: ITransaction, category: EventCategory, ranges: readonly IRange.Coords[] | null | undefined, shifts?: readonly ShiftIntent[]): void;
+    /** Whether a participant hears this sheet's change events, so its writes are made as they come. */
+    protected _hasChangeParticipants(): boolean;
+    /**
+     * Announce a write as it is made, under the event its category belongs to.
+     *
+     * @remarks
+     * Announced inside the operation, so a participant hears each write inline and what it writes
+     * joins the operation, while an observer is told once the operation lands, every write of it
+     * merged into one event (`SheetChangeEvent.merge`). An undo or a redo has no writes to announce
+     * from, and announces what the commit recorded instead (`onAfterStateChange`).
+     *
+     * A load announces nothing ({@link IntentInitial}).
+     *
+     * @internal
+     */
+    protected _announceChange(trans: ITransaction, category: EventCategory, ranges: readonly IRange.Coords[], shifts?: readonly ShiftIntent[]): void;
     /**
      * Record the ranges a formula was entered over.
      *
@@ -1315,6 +1587,13 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _recordSkipProtectionCheck(trans: ITransaction): void;
+    /**
+     * Whether the open operation has ruled on this sheet's protection. See
+     * {@link _recordSkipProtectionCheck}.
+     *
+     * @internal
+     */
+    protected _isProtectionRuled(): boolean;
     /**
      * Record that this commit is a load of the sheet: not a user's write, so the protection check
      * stands down, and not an edit, so nothing it wrote is announced. See {@link IntentInitial}.
@@ -1329,6 +1608,19 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _recordFreezePanes(trans: ITransaction, before: IRange.CellCoords, after: IRange.CellCoords): void;
+    /**
+     * Record an insert or delete of cells. See {@link ShiftsIntent}.
+     *
+     * @internal
+     */
+    protected _recordShift(trans: ITransaction, kind: IWorksheet.ShiftKind, axis: IRange.Axis, ranges: readonly IRange.Coords[]): void;
+    /**
+     * This sheet's inserts and deletes in a commit, as a change event reports them: for an undo,
+     * the inverse of each, last first.
+     *
+     * @internal
+     */
+    protected _sheetShifts(intents: Readonly<Record<string, any>> | undefined, isUndo: boolean): readonly ShiftIntent[];
     /**
      * The movables of this sheet with the given ids, in that order. Ids no longer on the sheet are
      * skipped: an undo of the insert that created a movable lands on a state without it.
@@ -1379,40 +1671,64 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _normalizeSelection(isMergesChanged: boolean): void;
+    /** The selection pulled inside the sheet's end, or itself when it already is. */
+    protected _selectionWithinEntire(coords: IRangeSelection.Coords, entire?: IRange.Coords): IRangeSelection.Coords;
     /** @internal */
     protected _autoSelect(options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis): Promise<IRange.Coords[]>;
-    /** {@inheritDoc ISheet.getSelection} */
+    /** {@inheritDoc IWorksheet.getSelection} */
     getSelection(): IRangeSelection;
-    /** {@inheritDoc ISheet.getSelectedCell} */
+    /** {@inheritDoc IWorksheet.getSelectedCell} */
     getSelectedCell(): ICell;
-    /** {@inheritDoc ISheet.getSelectedRange} */
+    /** {@inheritDoc IWorksheet.getSelectedRange} */
     getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
-    /** {@inheritDoc ISheet.getSelectedRanges} */
+    /** {@inheritDoc IWorksheet.getSelectedRanges} */
     getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
-    /** {@inheritDoc ISheet.getView} */
-    getView(): ISheetView;
-    /** {@inheritDoc ISheet.setView} */
-    setView(view: ISheetView): this;
-    /** {@inheritDoc ISheet.getTabColor} */
+    /** {@inheritDoc IWorksheet.getView} */
+    getView(): IWorksheetView;
+    /** {@inheritDoc IWorksheet.setView} */
+    setView(view: IWorksheetView): this;
+    /** {@inheritDoc IWorksheet.getTabColor} */
     getTabColor(): IColor;
-    /** {@inheritDoc ISheet.setTabColor} */
+    /** {@inheritDoc IWorksheet.setTabColor} */
     setTabColor(color: IColor | string | null): this;
-    /** {@inheritDoc ISheet.getCodeName} */
+    /** {@inheritDoc IWorksheet.getCodeName} */
     getCodeName(): string | null;
-    /** {@inheritDoc ISheet.getOutline} */
+    /** {@inheritDoc IWorksheet.getOutline} */
     getOutline(): IOutline;
-    /** {@inheritDoc ISheet.isConditionalFormatCalculationEnabled} */
+    /** {@inheritDoc IWorksheet.getPageLayout} */
+    getPageLayout(): IPageLayout;
+    /** {@inheritDoc IWorksheet.getHorizontalPageBreaks} */
+    getHorizontalPageBreaks(): IPageLayout.IPageBreak[];
+    /** {@inheritDoc IWorksheet.getVerticalPageBreaks} */
+    getVerticalPageBreaks(): IPageLayout.IPageBreak[];
+    /** {@inheritDoc IWorksheet.addHorizontalPageBreak} */
+    addHorizontalPageBreak(pageBreakRange: ICellRange.Address, options?: ITransaction.OperationOptions): IPageLayout.IPageBreak;
+    /** {@inheritDoc IWorksheet.addVerticalPageBreak} */
+    addVerticalPageBreak(pageBreakRange: ICellRange.Address, options?: ITransaction.OperationOptions): IPageLayout.IPageBreak;
+    /** {@inheritDoc IWorksheet.removeAllHorizontalPageBreaks} */
+    removeAllHorizontalPageBreaks(options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc IWorksheet.removeAllVerticalPageBreaks} */
+    removeAllVerticalPageBreaks(options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc IWorksheet.isConditionalFormatCalculationEnabled} */
     isConditionalFormatCalculationEnabled(): boolean;
+    /** {@inheritDoc IWorksheet.isTransitionFormulaEvaluation} */
+    isTransitionFormulaEvaluation(): boolean;
+    /** {@inheritDoc IWorksheet.isTransitionFormulaEntry} */
+    isTransitionFormulaEntry(): boolean;
+    /** {@inheritDoc IWorksheet.isExcludedFromPublishing} */
+    isExcludedFromPublishing(): boolean;
+    /** {@inheritDoc IWorksheet.getSyncScroll} */
+    getSyncScroll(): IWorksheet.SyncScroll | null;
     /**
      * A sheet's scripts are workbook structure, like the workbook's own.
      * @internal
      */
     protected _isModulesReadOnly(): boolean;
-    /** {@inheritDoc ISheet.getModules} */
+    /** {@inheritDoc IWorksheet.getModules} */
     getModules(): IModuleCollection;
-    /** {@inheritDoc ISheet.getRowHeaders} */
+    /** {@inheritDoc IWorksheet.getRowHeaders} */
     getRowHeaders(): ISheetHeader;
-    /** {@inheritDoc ISheet.getColumnHeaders} */
+    /** {@inheritDoc IWorksheet.getColumnHeaders} */
     getColumnHeaders(): ISheetHeader;
     /**
      * The sheet's grid, whatever the calculation hands back (DESIGN-CALC-SERVICE §5): opened from
@@ -1423,15 +1739,15 @@ export declare class Sheet implements ISheet {
      * the state as it is now.
      */
     protected _openCalcGrid(json: ICalcGrid.JSON | undefined): ICalcGrid;
-    /** {@inheritDoc ISheet.toJSON} */
-    toJSON(options?: ISheet.ToJSONOptions): Promise<ISheet.JSON>;
-    /** {@inheritDoc ISheet.getStyles} */
+    /** {@inheritDoc IWorksheet.toJSON} */
+    toJSON(options?: IWorksheet.ToJSONOptions): Promise<IWorksheet.JSON>;
+    /** {@inheritDoc IWorksheet.getStyles} */
     getStyles(): IStyleCollection;
-    /** {@inheritDoc ISheet.getResources} */
+    /** {@inheritDoc IWorksheet.getResources} */
     getResources(): IResourceCollection;
-    /** {@inheritDoc ISheet.getTransactions} */
+    /** {@inheritDoc IWorksheet.getTransactions} */
     getTransactions(): ITransaction.IStore;
-    /** {@inheritDoc ISheet.getStrings} */
+    /** {@inheritDoc IWorksheet.getStrings} */
     getStrings(): IStringCollection;
     /**
      * The sheet's movables: those placed on it, then the boxes of its notes.
@@ -1442,7 +1758,7 @@ export declare class Sheet implements ISheet {
      * Places a note's box among the sheet's movables. See {@link Comment.Boxes.add}.
      * @internal
      */
-    protected _addNoteBox(comment: Comment, anchor: IMovable.AnchorOffset | null, hidden: boolean): NoteMovable;
+    protected _addNoteBox(comment: Comment, placement: Comment.BoxPlacement | null, hidden: boolean): NoteMovable;
     /**
      * A movable, or something in it, was placed anew as part of the open operation: every connector
      * glued to it follows in the same operation (`translated` when it only moved). A target whose
@@ -1461,6 +1777,8 @@ export declare class Sheet implements ISheet {
      * The cell geometry a note's box is placed with.
      * @internal
      */
+    /** The merge a cell is in, from the merges themselves: a sheet still loading has no cells to ask. */
+    protected _mergeAt(cell: IRange.CellCoords): IRange.Coords | null;
     protected _noteLayout(): NoteLayout;
     /** The farthest any movable of the index paints past its anchor, for each `drawn` version. */
     private _movableOverhangs;
@@ -1489,6 +1807,15 @@ export declare class Sheet implements ISheet {
     protected _updateSelectedMovables(update: (movable: IMovable) => void, description?: string): void;
     /** @internal */
     protected _addMovable(options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /**
+     * Everything an add waits for, before the insert opens its transaction.
+     *
+     * A kind registered with a loader is loaded first, so the movable is made with its real content,
+     * a group's members included. A load that fails leaves the stand-in, as it does on a read. A
+     * position the caller left open is settled here too ({@link _placeMovable}).
+     * @internal
+     */
+    protected _prepareMovable(options?: IMovableCollection.AddOptions): Promise<InsertableCollection.InsertOptions>;
     /**
      * Where a new movable of a known size goes when the caller left its position open: the visible
      * window's center for `autoPlace: 'viewport'`, else the selection's top-left; then, on the axes the
@@ -1517,29 +1844,50 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _groupMovables(movables: readonly IMovable[], options?: IMovableCollection.GroupOptions): Promise<IMovable>;
-    /** @internal */
-    protected _addMovablePicture(picture: string | IResourceCollection.AddOptions | IResource, options?: IMovableCollection.AddOptions): Promise<IMovable>;
-    /** {@inheritDoc ISheet.setPicture} */
+    /**
+     * Everything an added picture waits for, before the insert opens its transaction: the image
+     * decoded for its size, then what {@link _prepareMovable} waits for.
+     * @internal
+     */
+    protected _preparePicture(picture: string | IResourceCollection.AddOptions | IResource, options?: IMovableCollection.AddOptions): Promise<InsertableCollection.InsertOptions>;
+    /** {@inheritDoc IWorksheet.setPicture} */
     setPicture(picture: string | IResource | IResourceCollection.AddOptions | null, options?: ITransaction.OperationOptions): this;
-    /** {@inheritDoc ISheet.getPicture} */
+    /** {@inheritDoc IWorksheet.getPicture} */
     getPicture(): IPicture | null;
-    /** {@inheritDoc ISheet.getPivotTables} */
+    /** {@inheritDoc IWorksheet.getDataTables} */
+    getDataTables(): IDataTableCollection;
+    /**
+     * An edit to cell data, here or on any sheet, can change what every data table in the workbook
+     * would calculate, and nothing recalculates their results. Marks each to be recalculated by Excel
+     * when it opens the file ({@link IDataTable.JSON.calculateAlways}).
+     *
+     * TODO - A stand-in until the engine evaluates `TABLE`. A data table is a calculation: each result
+     * is the table's formula evaluated with that cell's row and column values put in the input cells.
+     * The engine should own it like an array block, its dependencies being the formula's plus the
+     * input cells and the row and column values, and recalculate it when one changes. Its results
+     * are then never stale, `calculateAlways` stays as read, and this method and
+     * `DataTable._markStale` go. Until then it marks every table on any data edit, because which
+     * cells the formula depends on is only known to the engine.
+     * @internal
+     */
+    protected _markDataTablesStale(): void;
+    /** {@inheritDoc IWorksheet.getPivotTables} */
     getPivotTables(): IPivotTableCollection;
-    /** {@inheritDoc ISheet.getTables} */
+    /** {@inheritDoc IWorksheet.getTables} */
     getTables(): ITableCollection;
-    /** {@inheritDoc ISheet.getDataValidations} */
+    /** {@inheritDoc IWorksheet.getDataValidations} */
     getDataValidations(): IDataValidationCollection;
-    /** {@inheritDoc ISheet.getConditionalFormats} */
+    /** {@inheritDoc IWorksheet.getConditionalFormats} */
     getConditionalFormats(): IConditionalFormatCollection;
-    /** {@inheritDoc ISheet.getProtectedRanges} */
+    /** {@inheritDoc IWorksheet.getProtectedRanges} */
     getProtectedRanges(): IProtectedRangeCollection;
-    /** {@inheritDoc ISheet.getComments} */
+    /** {@inheritDoc IWorksheet.getComments} */
     getComments(): ICommentCollection;
-    /** @deprecated Use {@link ISheet.getConditionalFormats} */
+    /** @deprecated Use {@link IWorksheet.getConditionalFormats} */
     getConditionals(): IConditionalFormatCollection;
-    /** {@inheritDoc ISheet.getMovables} */
+    /** {@inheritDoc IWorksheet.getMovables} */
     getMovables(): IMovableCollection;
-    /** {@inheritDoc ISheet.getCharts} */
+    /** {@inheritDoc IWorksheet.getCharts} */
     getCharts(): IChartCollection;
     /** @internal */
     protected _validateOrRemoveOverlaps(rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean, absorbAutoTable?: boolean): void;
@@ -1579,7 +1927,7 @@ export declare class Sheet implements ISheet {
          * The sheet-protection allowances the add needs. Empty when no option allows it, so the add is
          * refused whenever the sheet is locked.
          */
-        allowance: ISheetProtection.PropertyKeys[];
+        allowance: IWorksheetProtection.PropertyKeys[];
         isItem: (add: unknown) => add is T;
         description: string;
         /** Loads one ref into the map, handing the created model to `capture`. */
@@ -1618,15 +1966,15 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _addComment(address: ICellRange.Address, content: IComment.Content, options?: ICommentCollection.AddOptions): IComment;
-    /** {@inheritDoc ISheet.createCell} */
+    /** {@inheritDoc IWorksheet.createCell} */
     createCell(update: ICell.Update, coords?: IRange.CellCoords | null, options?: ICell.CreateCellOptions): ICell;
     /** @internal */
     protected _getBoundsAtCoords(coords: IRange.Coords): Bounds;
     /** @internal */
     protected _getCoordsAtBounds(bounds: Bounds): IRange.Coords;
-    /** {@inheritDoc ISheet.getRangeAtBounds} */
+    /** {@inheritDoc IWorksheet.getRangeAtBounds} */
     getRangeAtBounds(bounds: Bounds, options?: ICellRange.GetRangeOptions): ICellRange;
-    /** {@inheritDoc ISheet.getRangeAtBounds} */
+    /** {@inheritDoc IWorksheet.getRangeAtBounds} */
     getRangeAt(rowStart: number, colStart: number, rowEnd?: number, colEnd?: number, options?: ICellRange.GetRangeOptions): ICellRange;
     /** @internal */
     protected _getVisible(coords: readonly IRange.Coords[], options?: ICellRange.GetVisibleOptions): readonly IRange.Coords[];
@@ -1645,15 +1993,15 @@ export declare class Sheet implements ISheet {
     protected _getRangedEntries<T, E = T>(spatial: ISpatialQuery, ranges: readonly IRange.Coords[], options?: GetTypedRangeOptions<T, E>, spatialSort?: boolean): T[];
     /** @internal */
     protected _processAnchorShift<T extends Anchored.Entry<any>>(options: ISpatialMap.ShiftDetails<T>): ISpatialMap.Entry<T> | null;
-    /** {@inheritDoc ISheet.delete} */
+    /** {@inheritDoc IWorksheet.delete} */
     delete(): void;
-    /** {@inheritDoc ITransaction.ITransactional.doBatch} */
-    doBatch<R>(callback: (commit: ITransaction.ICommit) => Promise<R> | R, options?: string | ITransaction.OperationOptions): Promise<R> | R;
-    /** {@inheritDoc ISheet.isDeleted} */
+    /** {@inheritDoc IWorksheet.doBatch} */
+    doBatch<R>(callback: (commit: ITransaction.ICommit, sheet: this) => Promise<R> | R, options?: string | ITransaction.OperationOptions): Promise<R> | R;
+    /** {@inheritDoc IWorksheet.isDeleted} */
     isDeleted(): boolean;
-    /** {@inheritDoc ISheet.isClosed} */
+    /** {@inheritDoc IWorksheet.isClosed} */
     isClosed(): boolean;
-    /** {@inheritDoc ISheet.close} */
+    /** {@inheritDoc IWorksheet.close} */
     close(): void;
     /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
     beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
@@ -1740,12 +2088,18 @@ export declare class Sheet implements ISheet {
      *
      * @internal
      */
-    protected _invalidateRendering(): void;
+    /**
+     * Everything measured is stale: drop the caches, tell the views, and re-fit what grows with its
+     * content (expand only, never a custom size). A language switch re-fits both axes; a font
+     * arriving re-fits rows only, as the load autofit does, since Excel never widens a column for
+     * a font.
+     */
+    protected _invalidateRendering(axes?: IRange.AxisSelection | null): void;
     /** @internal */
-    protected _initViewState(entireCoords: IRange.Coords, json: ISheetView.JSON): void;
+    protected _initViewState(entireCoords: IRange.Coords, json: IWorksheetView.JSON): void;
     protected _initCellState(): void;
     /** @internal */
-    protected _createTables(tables: IAnchoredMap<ITable, ITable.JSON>, key: keyof State, refs: IRange.JSONReference<ITable.JSON>[], createModel: (options: AnchoredTable.ConstructorOptions) => ITable, addListeners?: (model: ITable) => IListener.Remove): IAnchoredMap<ITable, ITable.JSON>;
+    protected _createTables(tables: IAnchoredMap<ITable, ITable.JSON>, key: keyof State, refs: IRange.JSONReference<ITable.JSON>[], createModel: (options: AnchoredTable.ConstructorOptions) => ITable): IAnchoredMap<ITable, ITable.JSON>;
     /** @internal */
     protected _createDataValidations(dataValidations: IAnchoredMap<IDataValidation, IDataValidation.JSON>, key: keyof State, refs: IRange.JSONReference<IDataValidation.JSON>[], createModel: (options: DataValidation.ConstructorOptions) => IDataValidation, addListeners?: (model: IDataValidation) => IListener.Remove): IAnchoredMap<IDataValidation, IDataValidation.JSON>;
     /** @internal */
@@ -1759,6 +2113,13 @@ export declare class Sheet implements ISheet {
      * @internal
      */
     protected _createPivotTables(pivotTables: IAnchoredMap<IPivotTable, IPivotTable.JSON>, key: keyof State, refs: IRange.JSONReference<IPivotTable.JSON>[], fromResourceId?: (resourceId: number) => IResource): IAnchoredMap<IPivotTable, IPivotTable.JSON>;
+    /**
+     * Loads the data tables into their anchored map, each anchored on its result cells, its input
+     * cells held in the engine. The table rules on structural edits itself
+     * (`DataTable._processContainerShift`).
+     * @internal
+     */
+    protected _createDataTables(dataTables: IAnchoredMap<IDataTable, IDataTable.JSON>, key: keyof State, refs: IRange.JSONReference<IDataTable.JSON>[]): IAnchoredMap<IDataTable, IDataTable.JSON>;
     /** @internal */
     protected _createComments(comments: IAnchoredMap<IComment, IComment.JSON>, key: keyof State, refs: IRange.JSONReference<IComment.JSON>[], createModel: (options: Comment.ConstructorOptions) => IComment, addListeners?: (model: IComment) => IListener.Remove): IAnchoredMap<IComment, IComment.JSON>;
     /**
@@ -1769,44 +2130,48 @@ export declare class Sheet implements ISheet {
     /** @internal */
     protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource, index?: MovableIndex, contentGiven?: Movable.Content): ISpatialMap.Entry<MovableEntry>;
     /** @internal */
-    protected _fromJSON(json: ISheet.JSON | undefined, disableLoadAutoFit?: boolean): void;
+    protected _fromJSON(json: IWorksheet.JSON | undefined, disableLoadAutoFit?: boolean): void;
     /** {@inheritDoc ITransaction.ITransactional.getId} */
     getId(): string;
     /** {@inheritDoc ITransaction.ITransactional.getVersionId} */
     getVersionId(): number;
-    /** {@inheritDoc ISheet.getName} */
+    /** {@inheritDoc IWorksheet.getName} */
     getName(): string;
-    /** {@inheritDoc ISheet.setName} */
+    /** {@inheritDoc IWorksheet.setName} */
     setName(name: string, options?: ITransaction.OperationOptions): this;
-    /** {@inheritDoc ISheet.getVisibility} */
+    /** {@inheritDoc IWorksheet.getVisibility} */
     getVisibility(): ISheet.Visibility;
-    /** {@inheritDoc ISheet.setVisibility} */
+    /** {@inheritDoc IWorksheet.setVisibility} */
     setVisibility(visibility?: ISheet.Visibility | boolean, options?: ITransaction.OperationOptions): this;
-    /** {@inheritDoc ISheet.select} */
+    /** {@inheritDoc IWorksheet.select} */
     select(options: ITypes.SelectOptions): Promise<this>;
-    /** {@inheritDoc ISheet.duplicate} */
+    /** {@inheritDoc IWorksheet.duplicate} */
     duplicate(): Promise<this>;
-    /** {@inheritDoc ISheet.getIndex} */
+    /** {@inheritDoc IWorksheet.getIndex} */
     getIndex(): number;
-    /** {@inheritDoc ISheet.setIndex} */
+    /** {@inheritDoc IWorksheet.setIndex} */
     setIndex(index: number, options?: ITransaction.OperationOptions): this;
-    /** {@inheritDoc ISheet.getNames} */
+    /** {@inheritDoc IWorksheet.getNames} */
     getNames(): INamedCollection;
-    /** {@inheritDoc ISheet.getCalculation} */
-    /** {@inheritDoc ISheet.getCalculation} */
+    /** {@inheritDoc IWorksheet.getCalculation} */
+    /** {@inheritDoc IWorksheet.getCalculation} */
     getCalculation(): ICalculation;
-    /** {@inheritDoc ISheet.createFormula} */
+    /** {@inheritDoc IWorksheet.createFormula} */
     createFormula(expression: string, coords?: Partial<IRange.CellCoords>, options?: ICalculation.CreateFormulaOptions): ICalculation.IFormula;
-    /** {@inheritDoc ISheet.evaluate} */
+    /** {@inheritDoc IWorksheet.evaluate} */
     evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords> & ICalculation.CreateFormulaOptions): Promise<Scalar | IRange>;
-    /** {@inheritDoc ISheet.whenCalculationReady} */
+    /** {@inheritDoc IWorksheet.whenCalculationReady} */
     whenCalculationReady(): Promise<ICalculation.Status>;
-    /** {@inheritDoc ISheet.getWorkbook} */
+    /** {@inheritDoc IWorksheet.getWorkbook} */
     getWorkbook(): IWorkbook | null;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /** {@inheritDoc IWorksheet.getKind} */
+    getKind(): typeof ISheet.Kind.Worksheet;
     /** {@inheritDoc ISheet.isISheet} */
     get isISheet(): true;
+    /** {@inheritDoc IWorksheet.isIWorksheet} */
+    get isIWorksheet(): true;
 }
 /**
  * Builds an {@link ICellRange.Counts} from a plain feature record.
@@ -1839,7 +2204,6 @@ interface NotifierOptions {
     /** Spell the source with its sheet qualifier (a workbook range), as the listener registered it. */
     qualified?: boolean;
     from?: ICellRanges;
-    to?: ICellRange;
     timeStamp?: number;
 }
 interface TableColumnHeaders {
@@ -1870,6 +2234,8 @@ interface ListenerNodeEntry {
     qualified: boolean;
     /** Present when the node is a {@link WatchAnchor}: what the watch is told. */
     watch?: WatchAnchor.Handlers;
+    /** The batch a participant was added through: it is told as each step of that batch is made. */
+    batch?: BatchHandle | null;
 }
 /**
  * A run of formula cells with the references they inherit a number format from, relative to the
@@ -1881,4 +2247,4 @@ interface EnteredBlock {
     references: readonly IRange.FixableCoords[];
 }
 export {};
-//# sourceMappingURL=Sheet.d.ts.map
+//# sourceMappingURL=Worksheet.d.ts.map