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

package/types/src/sheet/Worksheet.d.ts

@@ -0,0 +1,2250 @@
+import { IRange, Scalar, InteropScalar, IRangeStats, IRuntime } from '@sheetxl/primitives';
+import { CoordUtils, Size, Bounds, Point } from '@sheetxl/utils';
+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';
+import { IComment, ICommentCollection } from '../comment';
+import { IColor } from '../color';
+import { IHyperlink } from '../hyperlink';
+import { ISort } from '../sort';
+import { IAutoFill } from '../autoFill';
+import { IAnchored } from '../anchored';
+import { Anchored } from '../anchored/Anchored';
+import { IAnchoredMap } from '../anchored/IAnchoredMap';
+import { ITable, ITableCollection } from '../table';
+import { NamedTableSource } from '../table/_NamedTableSource';
+import { AnchoredTable } from '../table/AnchoredTable';
+import { INamedCollection } from '../named';
+import { IModuleCollection } from '../scripting';
+import { ModuleCollection } from '../scripting/ModuleCollection';
+import { IMovable, IMovableCollection } from '../movable';
+import { Movable } from '../movable/Movable';
+import { AbstractMovableContent } from '../movable/AbstractMovableContent';
+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';
+import { IRangeSelection } from '../selection';
+import { IConditionalFormat, IConditionalFormatCollection } from '../conditionalFormat';
+import { IProtectedRange, IProtectedRangeCollection } from '../protectedRange';
+import { Tuple, ISpatialMap, ISpatialQuery } from '../collections';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { ICondition } from '../condition';
+import { ConditionalFormat } from '../conditionalFormat/ConditionalFormat';
+import { IDataValidationCollection, IDataValidation } from '../dataValidation';
+import { DataValidation } from '../dataValidation/DataValidation';
+import { ProtectedRange } from '../protectedRange/ProtectedRange';
+import { Comment } from '../comment/Comment';
+import { NoteMovable } from '../comment/NoteMovable';
+import { NoteLayout } from '../comment/_NoteBox';
+import { IWorksheetProtection } from '../sheetProtection';
+import { IOutline } from '../outline';
+import { IPageLayout } from '../print';
+import { ISheetHeader } from '../sheetHeader';
+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';
+import { RangeState, CellState, State, MovableEntry, MovableIndex, InternalTupleUpdate } from './_SheetStateTypes';
+import { CellBuffer } from './_CellBuffer';
+import { SheetReadContext, GetTypedRangeOptions, OverFlowsAndStops } from './_SheetStateReader';
+import { AutoFillProjection, AutoFillPreviewCache } from './_SheetAutoFillUtils';
+import { ProtectionCheck } from './_SheetCoords';
+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 IWorksheet}.
+ */
+/**
+ * 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 IWorksheetInternal = ReturnType<Worksheet['_getInternal']>;
+/**
+ * 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<Worksheet['_buildMutationCtx']>;
+/**
+ * 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<Worksheet['_buildCoordCtx']>;
+/**
+ * What an operation hands {@link Worksheet._commitWithDirectives} beyond its selection and options.
+ * @internal
+ */
+export interface CommitDirectives {
+    /** Where an undo lands, when it is not the selection. See `Sheet._recordSelection`. */
+    undo?: Partial<IRangeSelection.Coords> | null;
+    /** The axis the selection is scrolled along. */
+    axis?: IRange.Axis;
+    /** Handed to the commit. */
+    commit?: ITransaction.StoreOperationOptions;
+}
+/** 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[];
+}
+interface LegacyDrawingImage {
+    /** The id {@link LegacyDrawing.xml} references this image by. */
+    id: string;
+    resource: IResource;
+}
+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;
+    protected _transactions: ITransaction.IStore;
+    protected _ownTransactions: boolean;
+    protected _transactionsRemoveListener: IListener.Remove;
+    protected _transactionsCloseRemoveListener: IListener.Remove;
+    /** The view's selection when the open root began. See {@link _onRootTransactionClose}. */
+    protected _selectionAtCommitStart: IRangeSelection.Coords | null;
+    /**
+     * The movables each closed root selects once it lands, by id. Kept per commit: other roots can
+     * close before an earlier one lands. See {@link _onRootTransactionClose}.
+     */
+    protected _movableSelectionAtCommitEnd: Map<ITransaction.ICommit, readonly string[]>;
+    /**
+     * 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;
+    /** Makes the lists cell values are stored as, over `_strings`. */
+    protected _lists: ScalarListFactory;
+    protected _ownStrings: boolean;
+    protected _styles: IStyleCollection;
+    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;
+    protected _ownResources: boolean;
+    /**
+     * The sheet's own legacy drawing and the header/footer's, held as read until the shapes in them
+     * have models of their own. Not sheet state: nothing edits them, so they neither transact nor
+     * notify.
+     */
+    protected _legacyDrawing: LegacyDrawing | null;
+    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.
+     *
+     * @remarks
+     * An item's `onDelete` reaches the sheet after the operation lands, and the sheet re-announces
+     * it as the collection's change — that is how a delete driven by a row or column removal is
+     * announced at all. An item deleted through its own `delete()` comes back to the sheet's
+     * `deleteFromContainer`, which announces inside the operation; it records the item here so the
+     * later `onDelete` is not a second announcement of the same delete.
+     */
+    protected _announcedDeletes: WeakSet<IAnchored>;
+    protected _names: INamedCollection;
+    /** Lazy sheet-anchored view over {@link _names} — see {@link getNames}. */
+    protected _namesScoped: INamedCollection | null;
+    protected _ownNames: boolean;
+    /** Presents this sheet's tables to {@link _names}. Single stable instance — see `Workbook`. */
+    protected _namedTableSource: NamedTableSource;
+    protected _namesRemoveListener: IListener.Remove;
+    protected _calculation: ICalculation;
+    protected _ownCalculation: boolean;
+    protected _calculationScoped: ICalculation;
+    protected _workbook: IWorkbook | null;
+    protected _cacheTableColumnHeaders: TableColumnHeaders;
+    protected _tables: ITableCollection;
+    protected _conditionals: IConditionalFormatCollection;
+    protected _dataValidations: IDataValidationCollection;
+    protected _protectedRanges: IProtectedRangeCollection;
+    protected _comments: ICommentCollection;
+    protected _movables: IMovableCollection;
+    protected _charts: IChartCollection;
+    protected _emitterMovables: ListenerEmitter<IMovableCollection, ICollection.IListeners>;
+    /**
+     * The callbacks for the reference nodes in `State.listeners`, keyed by node id.
+     *
+     * @remarks
+     * On the instance, never in state: a listener is an observer, not part of the document. An entry
+     * in the map with no callback here belongs to a snapshot this sheet no longer serves and is inert.
+     */
+    protected _listenerNodes: Map<number, ListenerNodeEntry>;
+    protected _lastCellDecoded: {
+        address: ICell.Address | null;
+        coords: IRange.CellCoords | null;
+    };
+    protected _lastCellSelected: {
+        coords: IRange.CellCoords | null;
+        cell: ICell | null;
+    };
+    protected _lastCellRead: {
+        coords: IRange.CellCoords | null;
+        cell: ICell | null;
+    };
+    protected _lastValueRead: {
+        range: IRange.Coords | null;
+        isDateOrTime: boolean | null;
+    };
+    protected _lastGetRangeRead: Record<string, {
+        ranges: readonly IRange.Coords[];
+        ignoreHidden: boolean | IRange.Axis;
+        results: any[];
+    }> | null;
+    protected _lastUsedCoordsRead: {
+        coords: IRange.Coords | null;
+        range: ICellRange | null;
+    };
+    protected _lastRangeRead: {
+        address: ICellRange.Address | null;
+        range: ICellRange | null;
+        ranges: ICellRanges | null;
+    };
+    protected _entireCoordsCache: IRange.Coords | null;
+    protected _entireRangeCache: ICellRange | null;
+    protected _isDataColumn: boolean;
+    protected _view: IWorksheetView;
+    protected _viewListener: IWorksheetView.IListeners;
+    protected _viewRemoveListener: IListener.Remove;
+    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 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}.
+     *
+     * Built with the sheet rather than on first ask, because building one opens a transaction and
+     * `getModules()` is a READ: a lazy build would fold an initialization commit into whatever
+     * unrelated commit happened to be the tip, every time a report walked the sheets.
+     */
+    protected _modules: ModuleCollection;
+    protected _runtime: IRuntime;
+    protected _isDate1904: boolean;
+    protected _colHeaders: SheetHeader;
+    protected _colHeadersShiftCallback: SheetHeader.ShiftCallback | null;
+    protected _colHeadersListener: ISheetHeader.IListeners | null;
+    protected _colHeadersRemoveListener: IListener.Remove | null;
+    protected _colHeadersHiddenRemoveListener: IListener.Remove | null;
+    protected _rowHeaders: SheetHeader;
+    protected _rowHeadersShiftCallback: SheetHeader.ShiftCallback | null;
+    protected _rowHeadersListener: ISheetHeader.IListeners | null;
+    protected _rowHeadersRemoveListener: IListener.Remove | null;
+    protected _rowHeadersHiddenRemoveListener: IListener.Remove | null;
+    protected _isAdjustHeaders: boolean;
+    /** Built by the movables moved in the shift under way, and taken by it when it writes. */
+    protected _shiftedMovableModels: Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+    /** The same for the note boxes, which shift as their own index. */
+    protected _shiftedNoteModels: Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+    /** The placed movables' index and the note boxes' index, as the entry builder addresses them. */
+    protected _placedIndex: MovableIndex;
+    protected _noteIndex: MovableIndex;
+    /** What every comment on this sheet places its note's box through. */
+    protected _noteBoxes: Comment.Boxes;
+    protected _emptyCell: ICell;
+    protected _cellOptions: SheetCellOptions;
+    protected _closed: boolean;
+    protected _cellBuffer: CellBuffer | null;
+    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 `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 `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 IWorksheetInternal}. */
+    _getInternal(): {
+        getSheet: () => IWorksheet;
+        getState: () => Readonly<State>;
+        getCalcGrid: () => ICalcGrid;
+        isDataColumn: () => boolean;
+        createRange: (coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null) => ICellRange;
+        isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => boolean;
+        cellToCoords: (address: ICell.Address) => IRange.CellCoords;
+        rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
+        rangesToCoords: (address: ICellRanges.Address, protectionCheck?: ProtectionCheck | null | undefined, lookupNames?: boolean, requireSameSheet?: boolean, allowOutOfBounds?: boolean) => IRange.Coords[];
+        validateCoords: (coords: IRange.Coords, oobMessage?: string, allowOutOfBounds?: boolean) => void;
+        getScalar: (rowIndex: number, columnIndex: number, asJSDate?: boolean) => Scalar | InteropScalar;
+        getCellAt: (rowIndex: number, colIndex: number) => ICell;
+        cellIterator: (options: CellState.IteratorOptions) => IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
+        getVisible: (coords: readonly IRange.Coords[], options?: ICellRange.GetVisibleOptions) => readonly IRange.Coords[];
+        getUsedCoords: (options?: ICellRange.GetRangeOptions) => IRange.Coords | null;
+        updateTuples: (boundedTuples: Tuple.Region<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null) => void;
+        merge: (ranges: readonly IRange.Coords[], options?: IRange.AxisSelection | ICellRange.MergeOptions | null) => void;
+        unmerge: (ranges: readonly IRange.Coords[], options?: ITransaction.OperationOptions) => void;
+        getMerges: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => IRange.Coords[];
+        insertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => Promise<IRange.Coords>;
+        canInsertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => boolean;
+        insertCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.InsertOptions, coordValidator?: CoordUtils.CoordValidator) => void;
+        deleteCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.DeleteOptions) => void;
+        getStyle: (ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: ICellStyle.Update, options?: ICellStyle.UpdateOptions) => void) => ICellStyle;
+        updateStyles: (ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean) => void;
+        getSnapshot: (coordsFrom: readonly IRange.Coords[], optionsMark?: ICellRange.CopyOptions, getTransactionId?: () => string) => ICellRange.ISnapshot;
+        getRangeStats: (coords: readonly IRange.Coords[], iteratorOptions?: ICellRange.GetStatsOptions) => IRangeStats;
+        getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
+        getDefaultSortCriteria: (rangeCoords: IRange.Coords, axis?: IRange.Axis, cell?: ICell.Address) => ISort.DefaultSortCriteria;
+        getDefaultAutoFillCriteria: (rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords) => IAutoFill.DefaultCriteria | null;
+        find: (ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions) => Iterator<ICell>;
+        copyFrom: (destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions) => Promise<IRange.Coords>;
+        contentCounts: (ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => Partial<Record<ICell.Content, number>>;
+        featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => ICellRange.Counts;
+        featureRegions: (bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions) => IRange.Coords[];
+        dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => Promise<ICellRanges | null>;
+        clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, cutFrom?: IRange.Coords | null) => void;
+        calculate: (ranges: ICellRanges.Coords, options?: ICalculation.CalculateOptions) => void;
+        autoSelect: (options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
+        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, holdWhileLoading?: boolean) => void;
+        getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
+        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?: 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;
+        filter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions) => Promise<IRange.Coords>;
+        evalFilter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined) => Promise<_SheetFilterUtils.FilterRuns>;
+        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>;
+        createTupleBuilder: <T>(transpose?: boolean) => Tuple.IBuilder<T>;
+        createSparseBuilder: (options?: ICellRange.SparseBuilderOptions, sheetRange?: ICellRange | null, internal?: InternalTupleUpdate) => ICellRange.SparseBuilder;
+        autoFill: (template: IRange.Coords, destination: IRange.Coords, options?: ICellRange.AutoFillOptions) => boolean | AutoFillProjection;
+        autoFillRange: (template: IRange.Coords, destination: IRange.Coords) => IRange.Coords;
+    };
+    /** @internal Cached read-engine context. State/headers/cellOptions are getters so they stay
+     * current if reassigned; the bound functions are stable. See {@link SheetReadContext}. */
+    protected _readCtx: SheetReadContext | null;
+    /**
+     * The context handed to `_SheetStateReader` functions. Callers can spread to override a portion
+     * for a scoped read (e.g. `{ ...ctx, cellOptions }`). See {@link SheetReadContext}.
+     * @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
+     * values and the indexes over them - and forwarding every verb to its backend.
+     *
+     * @remarks
+     * A plain field, NOT part of `State` (§13.24 a): one grid serves every version of the sheet, so
+     * a versioned slot would answer with the CURRENT maps from a historic record - which the sheet
+     * reads (`_resolveInheritedFormats`, the snapshot sheets). What the grid HOLDS versions, in its
+     * own record; its reads take the transaction to answer for. Opened by `_fromJSON`, so it is
+     * absent until then; a snapshot sheet is handed the source's grid by `_clone`.
+     * @internal
+     */
+    protected _calcGrid: ICalcGrid;
+    /** `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<Worksheet['_buildMutationCtx']> | null;
+    /** @internal Access the mutation context (cached). See {@link SheetMutationContext}. */
+    protected _getMutationCtx(): SheetMutationContext;
+    /**
+     * The context handed to `_SheetMutations` functions (the shift/insert/delete engine). Richer than
+     * {@link SheetReadContext}: it carries the commit/state-write machinery mutation orchestration
+     * needs. The `SheetMutationContext` type is derived from this object so it can never drift.
+     * @internal
+     */
+    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: () => IWorksheetView;
+        beginCommit: (options?: ITransaction.StoreOperationOptions | string) => ITransaction;
+        updateState: (updateState?: Partial<State>, options?: ITransaction.OperationOptions | string) => State;
+        getState: () => Readonly<State>;
+        stateFor: (trans: ITransaction) => State;
+        readonly calcGrid: ICalcGrid;
+        /** Invalidate the cached used-range read (a mutation may change the used bounds). */
+        invalidateUsedCoords: () => void;
+        validateCoords: (coords: IRange.Coords, oobMessage?: string, allowOutOfBounds?: boolean) => void;
+        protectionCheck: (check?: ProtectionCheck | null, coords?: Readonly<IRange.Coords> | readonly IRange.Coords[] | null, action?: string | null) => void;
+        getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
+        processLayoutChange: () => void;
+        /** The movables' by-model index as a shift left it, or `null` if the shift moved none. */
+        takeShiftedMovableModels: () => Map<IMovable, ISpatialMap.Entry<MovableEntry>> | null;
+        /** The same for the note boxes' index. */
+        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;
+        composeDirectStyleView: (region?: IRange.Coords, sourceMaps?: {
+            border: IUsedRangeSpatialMap<SheetDirectStyle>;
+            fill: IUsedRangeSpatialMap<SheetDirectStyle>;
+            content: IUsedRangeSpatialMap<SheetDirectStyle>;
+        }) => IUsedRangeSpatialMap<SheetDirectStyle>;
+        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 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[];
+        indexMerges: (mergeInserts: IRange.Coords[] | null, mergeRemoves?: IRange.Coords[] | null) => void;
+        validateOrRemoveOverlaps: (rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean, absorbAutoTable?: boolean) => void;
+        autoSelect: (options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
+        readonly isDataColumn: boolean;
+        readonly strings: IStringCollection;
+        readonly lists: ScalarListFactory;
+        readonly cellOptions: SheetCellOptions;
+        readonly runtime: IRuntime;
+        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, 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;
+        recordFormulasEntered: (trans: ITransaction, ranges: readonly IRange.Coords[] | null | undefined) => void;
+        getTables: () => ITableCollection;
+        getAutoTable: () => ITable | null;
+        cellIterator: (options: CellState.IteratorOptions) => IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
+        cellStateIterator: (options?: CellState.IteratorOptions) => CellState.Iterator;
+        rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
+        getCell: (address?: ICell.Address) => ICell;
+        createCell: (update: ICell.Update, coords?: IRange.CellCoords | null, options?: ICell.CreateCellOptions) => ICell;
+        getAutoFillPreviewCache: () => AutoFillPreviewCache | null;
+        setAutoFillPreviewCache: (cache: AutoFillPreviewCache) => void;
+    };
+    /** @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<Worksheet['_buildCoordCtx']> | null;
+    /** @internal Access the coord-resolution context (cached). See {@link SheetCoordContext}. */
+    protected _getCoordCtx(): SheetCoordContext;
+    /**
+     * The context handed to `_SheetCoords` functions (address/coord resolution + range construction).
+     * The `SheetCoordContext` type is derived from this object so it can never drift.
+     * @internal
+     */
+    protected _buildCoordCtx(): {
+        readonly internal: {
+            getSheet: () => IWorksheet;
+            getState: () => Readonly<State>;
+            getCalcGrid: () => ICalcGrid;
+            isDataColumn: () => boolean;
+            createRange: (coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null) => ICellRange;
+            isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => boolean;
+            cellToCoords: (address: ICell.Address) => IRange.CellCoords;
+            rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
+            rangesToCoords: (address: ICellRanges.Address, protectionCheck?: ProtectionCheck | null | undefined, lookupNames?: boolean, requireSameSheet?: boolean, allowOutOfBounds?: boolean) => IRange.Coords[];
+            validateCoords: (coords: IRange.Coords, oobMessage?: string, allowOutOfBounds?: boolean) => void;
+            getScalar: (rowIndex: number, columnIndex: number, asJSDate?: boolean) => Scalar | InteropScalar;
+            getCellAt: (rowIndex: number, colIndex: number) => ICell;
+            cellIterator: (options: CellState.IteratorOptions) => IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
+            getVisible: (coords: readonly IRange.Coords[], options?: ICellRange.GetVisibleOptions) => readonly IRange.Coords[];
+            getUsedCoords: (options?: ICellRange.GetRangeOptions) => IRange.Coords | null;
+            updateTuples: (boundedTuples: Tuple.Region<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null) => void;
+            merge: (ranges: readonly IRange.Coords[], options?: IRange.AxisSelection | ICellRange.MergeOptions | null) => void;
+            unmerge: (ranges: readonly IRange.Coords[], options?: ITransaction.OperationOptions) => void;
+            getMerges: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => IRange.Coords[];
+            insertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => Promise<IRange.Coords>;
+            canInsertFrom: (ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions) => boolean;
+            insertCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.InsertOptions, coordValidator?: CoordUtils.CoordValidator) => void;
+            deleteCells: (ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.DeleteOptions) => void;
+            getStyle: (ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: ICellStyle.Update, options?: ICellStyle.UpdateOptions) => void) => ICellStyle;
+            updateStyles: (ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean) => void;
+            getSnapshot: (coordsFrom: readonly IRange.Coords[], optionsMark?: ICellRange.CopyOptions, getTransactionId?: () => string) => ICellRange.ISnapshot;
+            getRangeStats: (coords: readonly IRange.Coords[], iteratorOptions?: ICellRange.GetStatsOptions) => IRangeStats;
+            getDefaultShiftAxis: (coords?: IRange.Coords) => IRange.Axis;
+            getDefaultSortCriteria: (rangeCoords: IRange.Coords, axis?: IRange.Axis, cell?: ICell.Address) => ISort.DefaultSortCriteria;
+            getDefaultAutoFillCriteria: (rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords) => IAutoFill.DefaultCriteria | null;
+            find: (ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions) => Iterator<ICell>;
+            copyFrom: (destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions) => Promise<IRange.Coords>;
+            contentCounts: (ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => Partial<Record<ICell.Content, number>>;
+            featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean) => ICellRange.Counts;
+            featureRegions: (bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions) => IRange.Coords[];
+            dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => Promise<ICellRanges | null>;
+            clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, cutFrom?: IRange.Coords | null) => void;
+            calculate: (ranges: ICellRanges.Coords, options?: ICalculation.CalculateOptions) => void;
+            autoSelect: (options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
+            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, holdWhileLoading?: boolean) => void;
+            getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
+            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?: 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;
+            filter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions) => Promise<IRange.Coords>;
+            evalFilter: (coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined) => Promise<_SheetFilterUtils.FilterRuns>;
+            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>;
+            createTupleBuilder: <T>(transpose?: boolean) => Tuple.IBuilder<T>;
+            createSparseBuilder: (options?: ICellRange.SparseBuilderOptions, sheetRange?: ICellRange | null, internal?: InternalTupleUpdate) => ICellRange.SparseBuilder;
+            autoFill: (template: IRange.Coords, destination: IRange.Coords, options?: ICellRange.AutoFillOptions) => boolean | AutoFillProjection;
+            autoFillRange: (template: IRange.Coords, destination: IRange.Coords) => IRange.Coords;
+        };
+        readonly readonly: boolean;
+        readonly isClosed: boolean;
+        readonly isInitializing: boolean;
+        readonly lastCellDecoded: {
+            address: ICell.Address | null;
+            coords: IRange.CellCoords | null;
+        };
+        getEntireCoords: () => IRange.Coords;
+        getNamedFormulas: () => import('..').INamedFormulasCollection;
+        getNames: () => INamedCollection;
+        getProtection: () => IWorksheetProtection;
+        getName: () => string;
+        resolveRange: (coord: ICellRange.Address) => ICellRange | null | undefined;
+    };
+    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 IWorksheet.getRange} */
+    getRange(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc IWorksheet.getCell} */
+    getCell(address?: ICell.Address): ICell;
+    /** {@inheritDoc IWorksheet.getRange} */
+    getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
+    /** {@inheritDoc IWorksheet.getEntireRange} */
+    getEntireRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    protected _getEntireCoords(): IRange.Coords;
+    /** {@inheritDoc IWorksheet.getEntireCoords} */
+    getEntireCoords(): IRange.Coords;
+    /** {@inheritDoc IWorksheet.getUsedRange} */
+    getUsedRange(options?: ICellRange.GetRangeOptions): ICellRange | null;
+    /** {@inheritDoc IWorksheet.getStats} */
+    getStats(options?: ICellRange.GetStatsOptions): IRangeStats;
+    /** {@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`. */
+    protected _validateCoords(coords: IRange.Coords, oobMessage?: string, allowOutOfBounds?: boolean): void;
+    /** @internal Logic lives in `_SheetCoords.createRangeError`. */
+    protected _createRangeError(address: ICellRanges.Address): Error;
+    /** @internal Logic lives in `_SheetCoords.protectionCheck`. */
+    protected _protectionCheck(check?: ProtectionCheck | null, coords?: Readonly<IRange.Coords> | readonly IRange.Coords[] | null, action?: string | null): void;
+    /**
+     * Returns an array of ranges. Logic lives in `_SheetCoords.rangesToCoords`.
+     *
+     * @remarks
+     * Defaults to maxCoords. Returns an error if the address is unparsable.
+     * @internal
+     */
+    protected _rangesToCoords(address: ICellRanges.Address, protectionCheck?: ProtectionCheck | null | undefined, lookupNames?: boolean, requireSameSheet?: boolean, allowOutOfBounds?: boolean): IRange.Coords[];
+    /**
+     * Returns exactly 1 range. Logic lives in `_SheetCoords.rangeToCoords`.
+     *
+     * @remarks
+     * This does not default address to maxCoords and fill error if anything other than 1 range is returned.
+     * @internal
+     */
+    protected _rangeToCoords(address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean): IRange.Coords;
+    /**
+     * Collects ranges.
+     *
+     * @param searchTypes If value is in record it will be search, boolean flag is used for fullyEnclosed.
+     * @internal
+     */
+    protected _collectRanges(queryCoords: IRange.Coords, rangesByType?: ISpatialMap.Entry<RangeState.Intersection>[], searchTypes?: boolean | RangeState.SearchTypes | null, state?: State, injectReferences?: IRange.JSONReference<any>[][], transaction?: ITransaction | null): void;
+    /**
+     * This wraps the stateIterator with a ICell.IteratorContext.
+     * // TODO - **PERFORMANCE** We are creating a new CellState on very call
+     * // TODO - **PERFORMANCE** This slower than expected but _cellStateIterator but still reasonable.
+     * @internal
+     */
+    protected _cellIterator(options: CellState.IteratorOptions): IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
+    /**
+     * `Options` is required. Will return Done if not provided.
+     * @internal
+     */
+    protected _rangeStateIterator(options: RangeState.IteratorOptions): RangeState.Iterator;
+    /**
+     * iterator for overlaps and stops.
+     *
+     * @param view
+     *
+     * @internal
+     */
+    protected _overflowAndStops(bounds: IRange.Coords, maxDistance?: number): OverFlowsAndStops | null;
+    /**
+     * Creates a an iterator that combines the values and ranges into a single iterator.
+     * @internal
+     */
+    protected _cellStateIterator(options?: CellState.IteratorOptions): CellState.Iterator;
+    /** @internal */
+    protected _indexMerges(mergeInserts: IRange.Coords[] | null, mergeRemoves?: IRange.Coords[] | null): void;
+    /**
+     * SHEET-STYLE-SPLIT: rebuild a transient merged (blob-shaped) directStyle map from the three
+     * per-feature maps, overlaying **border-last** so bordered ranges keep their range/tile (the merge
+     * itself lives in {@link SheetDirectStyle.mergeOverlay}). Lets the persistent blob retire while the
+     * few places that still want a single merged view — serialization (`toJSON`) and the function-form /
+     * hyperlink write paths — reconstruct it on demand. Pass `region` to scope the overlay.
+     *
+     * `sourceMaps` overrides which maps are composed. It defaults to the committed state maps (what
+     * `toJSON`/`merge` want), but a write in progress must pass its WORKING clones — otherwise a later
+     * overlapping update composes stale committed state and its `rederiveFeatureMaps` clears the region,
+     * wiping an earlier in-call write (e.g. two dates set together lost the first cell's number format).
+     * @internal
+     */
+    protected _composeDirectStyleView(region?: IRange.Coords, sourceMaps?: {
+        border: IUsedRangeSpatialMap<SheetDirectStyle>;
+        fill: IUsedRangeSpatialMap<SheetDirectStyle>;
+        content: IUsedRangeSpatialMap<SheetDirectStyle>;
+    }): IUsedRangeSpatialMap<SheetDirectStyle>;
+    /** @internal Logic lives in `_SheetMutations.updateStyles`. */
+    protected _updateStyles(ranges: readonly ISpatialMap.Entry<ICellStyle.Update>[], defaultUpdate?: ICellStyle.Update, // we do this because updateTuples may update each
+    options?: ICellStyle.UpdateOptions, calcedNumberFormat?: boolean): void;
+    /**
+     * Holds a style set on one cell in the buffer the cell writes of an open transaction are held in
+     * ({@link CellBuffer.holdStyle}).
+     *
+     * @returns `false` if it is to be written as it comes.
+     * @internal
+     */
+    protected _holdStyle(range: ISpatialMap.Entry<ICellStyle.Update>, defaultUpdate?: ICellStyle.Update, options?: ICellStyle.UpdateOptions): boolean;
+    /**
+     * Whether a style update written to one cell changes that cell alone; a caller's callback is not
+     * known to. (The style typed input implies is not asked: it is a number format, a quote prefix or
+     * a wrap.)
+     * @internal
+     */
+    protected _isLocalStyle(state: Readonly<State>, rowIndex: number, colIndex: number, update: ICellStyle.Update): boolean;
+    /** @internal */
+    protected _createSparseBuilder(options?: ICellRange.SparseBuilderOptions, sheetRange?: ICellRange | null, internal?: InternalTupleUpdate): ICellRange.SparseBuilder;
+    /**
+     * TODO - how to support virtual lists (we need to allow for direct sets of lists (that don't iterator over each value) )
+     * Logic lives in `_SheetMutations.updateTuples`.
+     * @internal
+     */
+    protected _updateTuples(boundedTuples: Tuple.Region<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null): void;
+    /**
+     * The buffer single-cell writes made inside an open transaction are held in ({@link CellBuffer}).
+     * @internal
+     */
+    protected _getCellBuffer(): CellBuffer;
+    /** @internal */
+    protected _sort(coords: Readonly<IRange.Coords>, options?: boolean | ISort.Options[] | ISort.RangeOptions & ITransaction.OperationOptions): IRange.Coords;
+    /** @internal */
+    protected _filter(coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): Promise<IRange.Coords>;
+    /** @internal The read-only half of {@link _filter}: settles the runs without writing. */
+    protected _evalFilter(coords: Readonly<IRange.Coords>, condition: ICondition.Input | ICondition.RangeOptions | null | undefined): Promise<_SheetFilterUtils.FilterRuns>;
+    /** @internal The write half of {@link _filter}: inside the caller's open transaction. */
+    protected _applyFilterRuns(runs: _SheetFilterUtils.FilterRuns, options?: ITransaction.OperationOptions): void;
+    /** @internal Logic lives in `_SheetMutations.autoFill`. */
+    protected _autoFill(template: IRange.Coords, destination: IRange.Coords, options?: ICellRange.AutoFillOptions): boolean | AutoFillProjection;
+    /** @internal Logic lives in `_SheetMutations.autoFillRange`. */
+    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;
+    /**
+     * The request options for a grid call made under `transaction`: the snapshot it names and the
+     * savepoint its maps are cloned under.
+     * @internal
+     */
+    protected _requestFor(transaction: ITransaction | null): ICalcGrid.RequestOptions;
+    /**
+     * The formats the entered cells of the blocks inherit, as of a commit.
+     *
+     * Excel's entry rule: a formula typed into a General cell takes the number format of the first
+     * cell it reads that has one - `=A1+B1` shows currency when `A1` does. Which cells, and in what
+     * order, the engine reports with the results ({@link ICalcGrid.Results.formatInserts}); which
+     * formats they carry is read from the ENTERING commit's snapshot, so a pass that comes late -
+     * after an engine start, or an F9 under manual calculation - sees the inputs as they were when
+     * the formula was entered, whatever was formatted since. Never through a name.
+     *
+     * @remarks
+     * Range-shaped, not per cell. A relative reference names a different cell from each cell of
+     * its block, so the cells a block reads through it are a rectangle the block's size offset by
+     * the reference; the styled entries found there are shifted back onto the block. A fixed axis
+     * reads one row or column for the whole block. A reference stands for its top-left cell.
+     * References are written from the last to the first, so the first reference that formats a
+     * cell is the one that stands - "the first that is not General", per cell.
+     * @internal
+     */
+    protected _resolveInheritedFormats(commitId: string, blocks: readonly EnteredBlock[], entered: readonly IRange.Coords[]): ISpatialMap.Entry<ICellStyle.Update>[];
+    /**
+     * Land a record the engine pushed - a pass's results, a seed's - in the sheet's snapshots.
+     *
+     * @remarks
+     * The record names the snapshot it answers for (`commitId`). Everything it says about cells -
+     * the formulas, the values, the spills, the errors, the pending and circular marks - has been
+     * landed in the grid's own snapshots by the time this runs, and a record naming a snapshot off
+     * the live history never reaches here at all. What is left is the sheet's: what is PROMOTED -
+     * number formats, sizes - amended into the commit that entered the formulas, and the
+     * notifications, which realize has to make by hand.
+     * @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.
+     *
+     * @remarks
+     * Excel's rule: entering a formula formats and fits it; recalculating it does not. So the set is
+     * the formulas the target commit entered on this sheet, clipped to what this pass realized; the
+     * directives are the target's own (`autoFormat`, `autoFit`); and once resolved the sheet is
+     * marked on the target ({@link IntentCalcResolved}), so a later pass for the same commit - a
+     * dependent on another sheet, an explicit recalculation, the pass a redo triggers - leaves what
+     * is now in the snapshot alone. The mark is written with the sheet's record so that it lands
+     * even when nothing was promoted; an amend with no writes is elided. It is written only by a
+     * pass that realized the entered cells: an engine starting up runs a pass that realizes
+     * nothing before the one that carries the results.
+     *
+     * The number format is the engine's pick per cell ({@link ICalcGrid.Results.formatInserts}):
+     * 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;
+    /**
+     * 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;
+    /** @internal */
+    protected _calculateFull(): void;
+    /** @internal */
+    /** @internal Logic lives in `_SheetMutations.setComments`. */
+    protected _setComments(ranges: readonly ISpatialMap.Entry<IComment.Update>[], comments?: IComment.Update | IComment.JSON, // `undefined` = each entry carries its own (updateTuples)
+    options?: ITransaction.OperationOptions): void;
+    /** @internal Logic lives in `_SheetMutations.clear`. */
+    protected _clear(ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, cutFrom?: IRange.Coords | null): void;
+    /** @internal Logic lives in `_SheetMutations.merge`. */
+    protected _merge(ranges: readonly IRange.Coords[], options?: IRange.AxisSelection | ICellRange.MergeOptions | null): void;
+    /** @internal Logic lives in `_SheetMutations.unmerge`. */
+    protected _unmerge(ranges: readonly IRange.Coords[], options?: ITransaction.OperationOptions): void;
+    /** @internal */
+    protected _getMerges(ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis): IRange.Coords[];
+    /** @internal */
+    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: 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;
+    /**
+     * 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:
+     *
+     * - A cut lands the source's own size at the destination's top-left (it can't tile).
+     * - A single cell - or one merged cell - copied onto exactly one merged cell fills that merge,
+     *   bigger or not (the snapshot pastes it values-only). A cut gets no such treatment.
+     * - A copy that would cut through a merge is refused, its own source's included.
+     * - A cut destroys the merges it lands across instead - but not its OWN merge, which it would have
+     *   to tear in two; that is refused (Excel silently loses the merge).
+     *
+     * Runs inside the copy's transaction: the merges a cut destroys roll back with it.
+     * @internal
+     */
+    protected _resolveCopyDestination(destination: IRange.Coords, snapshot: ICellRange.ISnapshot, options: ICellRange.CopyOptions | undefined, isCut: boolean): IRange.Coords;
+    /** {@inheritDoc IWorksheet.addAutoTable} */
+    addAutoTable(address?: ICellRange.Address, options?: ICellRange.AddAutoTableOptions): ITable;
+    /** {@inheritDoc IWorksheet.getAutoTable} */
+    getAutoTable(): ITable | null;
+    /**
+     * The tables on this sheet that hold a filter condition: the AutoTable, then the tables. What
+     * makes the sheet "filtered" ({@link ISheetHeader.getFilteredRanges}).
+     */
+    private _filteredTables;
+    /**
+     * Tells the grid whether this sheet is filtered now ({@link _filteredTables}), from
+     * inside the operation that may have changed it: a table's condition set or cleared, a table
+     * added or deleted. The grid writes only a different answer, so telling it more often than it
+     * changes costs a walk of the tables. A restore is not told, as {@link _tellHidden}.
+     */
+    protected _tellFiltered(): void;
+    /** @internal */
+    protected _getDefaultShiftAxis(coords?: IRange.Coords): IRange.Axis;
+    /** @internal */
+    protected _getTables(address: ICellRanges.Address, ignoreHidden?: boolean, fullyContained?: boolean): ITable[];
+    /** @internal */
+    protected _getDefaultAutoFillCriteria(rangeCoords: IRange.Coords, direction?: IRange.Direction, destination?: IRange.Coords): IAutoFill.DefaultCriteria | null;
+    /** @internal */
+    protected _getDefaultSortCriteria(rangeCoords: IRange.Coords, axis?: IRange.Axis, cell?: ICell.Address): ISort.DefaultSortCriteria;
+    /**
+     * The refusal an {@link ICellRange.insertFrom} would raise, as a localized message - `null` when it
+     * would go through. Asked BEFORE anything is committed, both by `_insertFrom` itself (so a refusal
+     * leaves nothing to roll back and carries the message that fits the reason) and by the public
+     * `canInsertFrom`, which is what lets a drag preview show a drop as refused before it is attempted.
+     *
+     * @internal
+     */
+    protected _getInsertFromRefusal(coordsInsert: IRange.Coords, coordsCut: IRange.Coords, axis: IRange.Axis, isCut: boolean, isSameSheet: boolean): string | null;
+    /**
+     * {@inheritDoc ICellRange.canInsertFrom}
+     * @internal
+     */
+    protected _canInsertFrom(ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): boolean;
+    /**
+     * 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
+     */
+    protected _insertCells(ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.InsertOptions, coordValidator?: CoordUtils.CoordValidator): void;
+    /** Delete cells, shifting existing content up/left. */
+    protected _deleteCells(ranges: readonly IRange.Coords[], options?: IRange.Axis | ICellRange.DeleteOptions): void;
+    /**
+     * The shared insert/delete engine. Logic lives in `_SheetMutations.shiftCells`.
+     * @internal
+     */
+    protected _shiftCells(ranges: readonly IRange.Coords[], options: IRange.Axis | ICellRange.InsertOptions | ICellRange.DeleteOptions | undefined, isInsert: boolean, coordValidator?: CoordUtils.CoordValidator): void;
+    protected _processLayoutChange(): void;
+    /**
+     * Automatically adjusts row heights and column widths to fit cell content and styles.
+     *
+     * @param ranges Ranges to autofit.
+     * @param options AutoFit options (axis, expandOnly, skipCustomSize, etc).
+     * @internal
+     *
+     * @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, 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}.
+     *
+     * @internal
+     */
+    protected _getBestFit(range: IRange.Coords, options?: ICellRange.BestFitOptions): Size;
+    /** @internal */
+    protected _createRangeEvent(coords: (readonly IRange.FixableCoords[]) | IRange.FixableCoords, options: NotifierOptions, coordsFrom?: (readonly IRange.FixableCoords[]) | IRange.FixableCoords): ICellRange.Event;
+    /**
+     * Register a reference node for a range listener.
+     *
+     * @remarks
+     * The node is written into the anchored map by an AMEND on the current commit, so registering
+     * never becomes an undo step, and every snapshot from this commit forward carries the node at
+     * whatever coords it has then. That one write is where the whole contract comes from: undo to a
+     * snapshot at or after registration and the node is there, at the coords of that moment; undo to
+     * one from BEFORE it and the map simply has no entry, which is what `#N/A` is.
+     *
+     * The callback never enters state - it is held on the instance, keyed by node id.
+     *
+     * @internal
+     */
+    protected _addListenerNode(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
+    /**
+     * {@link _addListenerNode}, also handing back the node, for a caller that reads its coords.
+     * @internal
+     */
+    protected _registerListenerNode(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions, createNode?: (options: ListenerAnchor.ConstructorOptions) => ListenerAnchor): {
+        node: ListenerAnchor;
+        remove: IListener.Remove;
+    };
+    /**
+     * Register a watch: an expression kept evaluated over a range.
+     *
+     * @remarks
+     * A watch is a range listener that fires on formula evaluation - see {@link WatchAnchor}. Its
+     * location is a node in `State.listeners`, and its body is a formula block in a grid of its own
+     * that shadows this sheet, written at the watched coords exactly as if it had been typed there.
+     * A watch is allowed to overlap other formulas, which is why the body has a grid of its own: the
+     * sheet's formula map holds one formula per cell, and a validation, a conditional format and a
+     * real formula can all sit on D1:D3 at once.
+     *
+     * Registration waits for the engine and never starts it: a watch added while calculation is off
+     * delivers nothing until calculation is started, and registers then. It lands as one amend: the node, the grid and the body join the current commit, so a
+     * watch is never an undo step. A snapshot older than the watch has neither, which is `#N/A`.
+     * The first delivery is the first pass that evaluates the body.
+     *
+     * @param coords The range the body is evaluated over.
+     * @param formula The expression, authored at `origin`, or a compiled formula anchored at
+     *                `coords`' top-left.
+     * @param handlers `onValues` receives the body's values after every pass that changed them;
+     *                 `onChange` is told that an evaluation happened, without the values.
+     * @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?: WatchAnchor.Options): IListener.Remove;
+    /**
+     * The one amend that creates a watch: its node, its grid and its body.
+     *
+     * @remarks
+     * Everything about the BODY is the node's ({@link WatchAnchor.reconcile},
+     * {@link WatchAnchor.deliver}). What is here is what every listener gets from the sheet: the
+     * 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, 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
+     * its grid's maps would land in that snapshot alone: the engine would hold a grid the current
+     * snapshot has no record of, and removing it later would leave the engine its body.
+     */
+    protected _ensureWatchAtCurrent(action: 'added' | 'removed'): void;
+    /**
+     * The `addWatch` a content is given: holds a formula that belongs to no cell - a chart's
+     * series, a control's linked cell - in the calculation engine, and tells the content each time
+     * the engine rewrites it.
+     *
+     * @remarks
+     * One unanchored formula host per call, its body authored at `origin` (the content's anchor
+     * top-left unless given), exactly as a defined name's body is held: the engine keeps its
+     * references on the cells they name, so an insert or delete rewrites them, a cut carries them, a
+     * deleted sheet leaves `#REF!`, and undo puts all of it back. The body demands its first cell
+     * only, so holding a reference to a column costs a pass one read, not the column.
+     *
+     * The callback carries a {@link HeldFormula}, a live view over the host: every read answers the
+     * body as the store holds it now. It is delivered once the engine has compiled the body and
+     * again after every change to its text - a structural edit, a pass that rewrote it, a restore.
+     *
+     * Registration waits for the engine's next safe point and then amends the current commit, as a
+     * watch's does. An engine that is never started holds nothing, and the content reads its text as
+     * set. A formula the engine cannot compile is not held either.
+     *
+     * A {@link HeldFormula} handed back in - a content restored after a delete re-holding what it
+     * had - attaches to the grid the formula lived in when that grid came back with the restore, and
+     * is held afresh from the formula's last text otherwise.
+     *
+     * @param getAnchor The content's anchor top-left, read when the watch registers.
+     * @internal
+     */
+    _contentAddWatch(getAnchor: () => IRange.CellCoords | null): AbstractMovableContent.AddWatch;
+    /**
+     * Carry every reference a cut encloses from its source to its destination.
+     *
+     * @remarks
+     * A cut moves cells, and everything that NAMES those cells goes with them - which is what the
+     * calc graph does for a formula precedent (`movePrecedents`), and what a range listener's
+     * reference and a watch's location must do for the same reason and by the same rule: the cut
+     * carries a reference only when it fully encloses it. Cut B2 to D5 and a listener on B2 reads
+     * D5; cut a block that merely clips the reference and it stays put, pointing at cells that are
+     * now empty.
+     *
+     * Called from the cut path beside the calc grid's own move, so the two land in one commit and
+     * one undo puts both back. A watch's body follows its node from the node's own address event
+     * at commit end (see {@link WatchAnchor.reconcile}).
+     *
+     * @param from The cut's source.
+     * @param to Where the cut's source lands.
+     * @internal
+     */
+    protected _moveReferences(from: IRange.Coords, to: IRange.Coords): void;
+    /**
+     * Drop a node from the current snapshot.
+     *
+     * @remarks
+     * The same amend as registering. Older snapshots keep the entry; one whose callback is gone from
+     * the instance is inert, and is swept the next time this runs.
+     *
+     * @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.
+     *
+     * @remarks
+     * A transactional node is told from inside the transaction, before the commit seals, so what it
+     * writes joins that commit; every other node is told once the store has settled. The two are
+     * never told from the same place, so `transactional` selects which half this call is for.
+     *
+     * `ranges` is the commit's change set, so a batch of operations is ONE change to a node: it is
+     * told once, carrying every range of the commit that reached it.
+     *
+     * @internal
+     */
+    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.
+     *
+     * @remarks
+     * Nothing is compared against the log, and the direction the store moved does not matter. The
+     * map either holds the node - at whatever coords it has in THIS snapshot - or it does not, and
+     * each case answers itself: a difference from the coords last delivered is an `address` change,
+     * and no entry at all is `#N/A`, a world from before the node was registered.
+     *
+     * `transactional` selects which nodes this call is for (see {@link _notifyListenerNodes}). With
+     * `notificationOptions` `null` the nodes are only re-based - their last-delivered coords are set
+     * to this snapshot's without a delivery. That is a restore seen by a transactional node: it is
+     * never told about one, but the next forward move must be measured from where the restore left
+     * the reference, not from where it was before.
+     *
+     * @internal
+     */
+    protected _notifyListenerNodeMoves(state: State, transactional: boolean, notificationOptions: NotifierOptions | null, includes?: ((entry: ListenerNodeEntry) => boolean) | null): void;
+    /**
+     * One delivery, after the option filters.
+     *
+     * @internal
+     */
+    protected _deliverToNode(entry: ListenerNodeEntry, trigger: 'data' | 'address' | 'restore', notificationOptions: NotifierOptions, from?: readonly IRange.Coords[]): void;
+    /** @internal */
+    protected _notifyUsedRangeChange(): void;
+    /** @internal */
+    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 `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
+     */
+    protected _notifyConditionalFormatsChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyTablesChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyDataValidationsChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyProtectedRangesChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyCommentsChange(): void;
+    /**
+     * Presents one of the sheet's own events as a collection's `onCollectionChange`, and the
+     * sheet's `onInvalidated` as the collection's, with the collection as the source of both.
+     *
+     * @remarks
+     * The sheet keeps the state and fires the fine-grained event; the collection is a front over
+     * it. Forwarding, rather than a second emitter, is what keeps the two from drifting apart.
+     * @internal
+     */
+    protected _forwardCollectionListeners(key: 'onTablesChange' | 'onConditionalFormatsChange' | 'onDataValidationsChange' | 'onProtectedRangesChange' | 'onCommentsChange', collection: () => ICollection<any>): (listeners: ICollection.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 */
+    protected _getRangeStats(coords: readonly IRange.Coords[], iteratorOptions?: ICellRange.GetStatsOptions): IRangeStats;
+    /** @internal */
+    protected _isContentful(ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean): boolean;
+    /**
+     * Legacy Content-keyed counting — internal callers only (`clear` preflight).
+     * The public path is `_featureCounts`, keyed by `ICellRange.Feature`.
+     * @internal
+     */
+    protected _contentCounts(ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean): Partial<Record<ICell.Content, number>>;
+    /**
+     * Per-feature cell counts — the engine behind `ICellRange.getCounts`.
+     *
+     * 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, 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
+     * derived `Date`), all of which have since either been retired from the public vocabulary
+     * (`range.getStats().getTypedCounts()` already answers "how many numbers", richer) or replaced
+     * by a real, directly indexed feature (`DateFormat`).
+     * @internal
+     */
+    protected _featureCounts(ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis, ignoreSpilled?: boolean): ICellRange.Counts;
+    /**
+     * Calculation-graph neighbors of a range — the engine behind `ICellRange`'s and `ICell`'s
+     * precedents/dependents family.
+     *
+     * The calc grid is already range-shaped (`getPrecedentsAt` and friends take `IRange.Coords`),
+     * so a range query is the same call a cell makes, not a fan-out over cells: the cell form is
+     * this one over a 1×1. The result is the UNION over the range and is not filtered against it —
+     * a range that contains both a formula and its input legitimately lists that input, and
+     * removing it would answer a different question than "what does this block read".
+     * @internal
+     */
+    protected _dependencyRanges(coords: IRange.Coords, kind: 'precedents' | 'dependents', direct: boolean): Promise<ICellRanges | null>;
+    /**
+     * Name ids -> the range objects that carry them in a graph answer.
+     *
+     * @remarks
+     * The id half of step 3. Liveness and "is this actually a name" were already applied by the
+     * grid; an id that no longer resolves simply drops. Each node is anchored on ITS OWN sheet
+     * (the name's defining cell), which is why the internal is re-resolved per id.
+     * @internal
+     */
+    private _namedGraphRanges;
+    /**
+     * Calc-currency scopes → range-currency scopes: the boundary the whole scope model rests on.
+     *
+     * @remarks
+     * A neighbor found in the graph is scoped by its GRID — a sheet's stableId, or (for a named
+     * formula, which compiles into a virtual grid holding one cell at 0,0) the name's id. Neither is
+     * addressable: `getRanges` looks sheets up by name, so a stableId reaching it is a `#REF!` and a
+     * name's id is a phantom `A1` on whatever sheet was asked.
+     *
+     * So sheet grids are translated to display names here, and everything else is either COLLECTED
+     * (`nameGrids` — a dependent landing on a name's virtual grid is that name's body reading these
+     * cells, reported as a name NODE by the caller under the phase-5 liveness rule) or dropped. The
+     * consuming cell is reported directly either way (references apply at eval, so `C1 = SUM(MyRange)`
+     * is a direct dependent of `A1` in its own right) — the node is additive labeling, which is why
+     * a dead name's silence degrades nothing but the label.
+     * @internal
+     */
+    private _toRangeScopes;
+    /**
+     * A sheet stableId → its display name, across the workbook when attached, else just this sheet.
+     *
+     * @remarks
+     * Calc scopes references by stableId so a rename cannot break them; every public surface speaks
+     * names. Returns `null` when the id names no sheet — a deleted one, or a grid that was never a
+     * sheet at all.
+     * @internal
+     */
+    protected _resolveSheetScope(stableId: string): string | null;
+    /**
+     * Uniform feature regions — the engine behind `ICellRange.getRegions`.
+     *
+     * Returns the coords of rectangles whose cells agree on every requested feature; the public
+     * objects (`CellRegions`/`CellRegion`) are built by the caller, which is also what defers the
+     * whole computation until the partition is actually used. Blocks carrying none of the
+     * requested features are elided. `features` arrives already resolved (`resolveRegionFeatures`).
+     *
+     * Known v1 bounds, recorded in AGENT-PLAN B2: the blank/complement side of the partition is
+     * not yielded. Every requested feature partitions — there is no unsupported-feature throw left
+     * in this function.
+     * @internal
+     */
+    protected _featureRegions(bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): IRange.Coords[];
+    /** {@inheritDoc IWorksheet.find} */
+    find(options?: string | ICellRange.FindOptions): Iterator<ICell>;
+    /** {@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 IWorksheet.getRuntime} */
+    getRuntime(): IRuntime;
+    /**
+     * The region a bare-cursor traverse from `cell` wraps within, or `null` for a plain move. A table
+     * under the cursor answers for itself.
+     * @internal
+     */
+    protected _getTraverseRegion(cell: IRange.CellCoords, axis: IRange.Axis, reverse: boolean): IRange.Coords | null;
+    /** @internal */
+    protected _surroundingRegion(range: IRange.Coords, options?: ICellRange.GetSurroundingOptions): IRange.Coords;
+    /** @internal */
+    protected _extendRange(direction: IRange.Direction, cell: IRange.CellCoords): Readonly<IRange.Coords>;
+    /** @internal */
+    protected _defaultFontDims(): Readonly<Size>;
+    /** {@inheritDoc IWorksheet.getColumnWidthAsFontUnit} */
+    getColumnWidthAsFontUnit(pixelWidth: number): number;
+    protected _createTupleBuilder<T>(transpose?: boolean): Tuple.IBuilder<T>;
+    /**
+     * col width in character units
+     * @internal
+     */
+    protected _defaultColWidth(): number;
+    /**
+     * row height in character pts. To get pixels multiple by scale
+     * @internal
+     */
+    protected _defaultRowHeight(): number;
+    /** {@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 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;
+    /**
+     * Record the operation's directives over what it produced, then commit.
+     *
+     * @remarks
+     * `options` is the object the operation was handed, so what it declares through
+     * {@link ICellRange.OperationOptions} is what is honored here: `autoSelect` names where the
+     * operation leaves the user, `autoFit` fits the ranges it produced. Both are read from the one
+     * object, so an operation cannot accept a directive it then ignores.
+     *
+     * @internal
+     */
+    protected _commitWithDirectives(trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, options?: ICellRange.OperationOptions, directives?: CommitDirectives): void;
+    /**
+     * Declare where the operation leaves the user, and where an undo of it lands when that is not
+     * the same place.
+     *
+     * @param selection Where the operation leaves the user - what it acted on, or what it produced
+     * when that is somewhere else (a paste fitted to its source). Also where a redo lands.
+     * @param options The operation's own options, passed through as they were given: its `autoSelect`
+     * and `autoSelectRestore`.
+     * @param undo Where an undo lands, when it is not `selection`: a cut-drag and an insert-from
+     * undo to the SOURCE, an auto-fill to the TEMPLATE it was dragged from.
+     *
+     * @remarks
+     * A declaration, never an action: every operation declares, whatever it was asked, and whether
+     * the view moves - now, on undo or on redo - is decided once, when the commit closes
+     * ({@link resolveSelection}).
+     *
+     * @internal
+     */
+    protected _recordSelection(trans: ITransaction, selection: Partial<IRangeSelection.Coords>, options?: Pick<ICellRange.OperationOptions, 'autoSelect' | 'autoSelectRestore'> | null, undo?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis): void;
+    /**
+     * Where an undo or a redo of a commit puts this sheet's view, or `null` when it leaves it
+     * alone. See {@link resolveSelection}.
+     *
+     * @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 IWorksheetView.getId}.
+     *
+     * @internal
+     */
+    protected _restoredSelection(intents: Readonly<Record<string, any>> | undefined, isUndo: boolean): {
+        selection: Partial<IRangeSelection.Coords>;
+        options: boolean | ICellRange.SelectOptions;
+    } | null;
+    /**
+     * Record what this operation has to announce when it lands, under one category.
+     *
+     * @remarks
+     * Recorded as the `sheet.events` intent on the ROOT and unioned there, so a batch of operations
+     * announces all of them rather than the last. Keyed by {@link getId}, so a commit that spans
+     * sheets announces each sheet separately. The intent travels on the commit, which is what lets
+     * an undo deliver the same categories the forward commit did.
+     *
+     * Copy-on-write: an amend's accumulator is handed the value on the commit it folds into, and
+     * mutating that would announce the whole of the target commit rather than what the amend
+     * recorded - which is what makes a registration amend silent. The range list is the exception
+     * once this operation has made its own ({@link _appendOwnedRanges}): one write per cell in a
+     * batch would otherwise copy every range recorded so far on each of them.
+     *
+     * @internal
+     */
+    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.
+     *
+     * @remarks
+     * A subset of the `data` category that no event fires for: it is what the calculation's amend
+     * formats and fits once the results exist ({@link _promoteCalcResults}). Unioned and written
+     * copy-on-write for the same reasons as {@link _recordChange}.
+     *
+     * @internal
+     */
+    protected _recordFormulasEntered(trans: ITransaction, ranges: readonly IRange.Coords[] | null | undefined): void;
+    /**
+     * This sheet's half of what a commit announces.
+     *
+     * @internal
+     */
+    protected _sheetEvents(intents: Readonly<Record<string, any>> | undefined): SheetEvents | null;
+    /**
+     * Every range this sheet announces from a commit, across the given categories (all of them when
+     * `categories` is omitted).
+     *
+     * @remarks
+     * The union is what a consumer asking "did anything happen in my box" wants, and taking it over
+     * every category is what keeps a category added later from silently ceasing to reach one.
+     *
+     * @internal
+     */
+    protected _changedRanges(intents: Readonly<Record<string, any>> | undefined, categories?: readonly EventCategory[]): readonly IRange.Coords[] | null;
+    /**
+     * Record ranges to fit when the operation completes.
+     *
+     * @remarks
+     * The fit is a union over the operation: entries for the same sheet and the same options
+     * accumulate ranges, so a batch measures each column once, at the end, against the finished
+     * content. Resolved by {@link _resolveAutoFit} as the operation's last write.
+     *
+     * @internal
+     */
+    protected _recordAutoFit(trans: ITransaction, ranges: readonly IRange.Coords[], autoFit: boolean | ICellRange.AutoFitOptions): void;
+    /**
+     * Record that the formulas this operation enters take the number format their results carry.
+     *
+     * @remarks
+     * Resolved by the calculation's amend into this commit rather than when the operation
+     * completes: the results do not exist yet. See {@link IntentAutoFormat}.
+     *
+     * @internal
+     */
+    protected _recordAutoFormat(trans: ITransaction): void;
+    /**
+     * Record that this operation has ruled on its own protection, so the commit-time catch-all
+     * stands down. See {@link IntentSkipProtectionCheck}.
+     *
+     * @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}.
+     *
+     * @internal
+     */
+    protected _recordInitial(trans: ITransaction): void;
+    /**
+     * Record where the freeze panes were and where the operation moved them. See
+     * {@link FreezePanesIntent} for how a batch merges the pair.
+     *
+     * @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.
+     *
+     * @internal
+     */
+    protected _movablesOfIds(ids: readonly string[]): IMovable[];
+    /**
+     * Fold writes into the current commit without a log entry. See `IStore.amend`.
+     * @internal
+     */
+    protected _amendCurrent<R>(callback: () => R): R;
+    /**
+     * An amend the sheet makes for itself (a listener node, a watch, a promoted calc result) is not
+     * a user's write, so a protected sheet must not refuse it. Only an amend that opens its own
+     * root stands the check down; nested, it joins an operation that answers for itself.
+     * @internal
+     */
+    protected _amendBookkeeping<R>(commitId: string, callback: (commit: ITransaction.ICommit) => R): R;
+    /**
+     * Fit the ranges the operation asked for, as its last write.
+     *
+     * @remarks
+     * Runs while the root transaction is still open so the sizes belong to the same commit as the
+     * content they measure - one undo puts both back. The intent is left on the record: it is what
+     * a redo fits from.
+     *
+     * @internal
+     */
+    protected _resolveAutoFit(commit: ITransaction.ICommit): void;
+    /**
+     * Resolve the operation's directives once its root transaction has closed.
+     *
+     * @internal
+     */
+    protected _onRootTransactionClose(commit: ITransaction.ICommit, isRollback?: boolean, isElided?: boolean, isAmend?: boolean): void;
+    /**
+     * Keep the view's selection somewhere it can be once the sheet has changed: inside the sheet,
+     * and with its active cell on the top-left of the merge it falls in.
+     *
+     * @param isMergesChanged Whether the change merged anything, which is the only way the active
+     * cell comes to sit inside a merge.
+     *
+     * @remarks
+     * A correction of the view, not an operation's selection: it applies whoever made the change,
+     * and is not undone with it.
+     *
+     * @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 IWorksheet.getSelection} */
+    getSelection(): IRangeSelection;
+    /** {@inheritDoc IWorksheet.getSelectedCell} */
+    getSelectedCell(): ICell;
+    /** {@inheritDoc IWorksheet.getSelectedRange} */
+    getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc IWorksheet.getSelectedRanges} */
+    getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
+    /** {@inheritDoc IWorksheet.getView} */
+    getView(): IWorksheetView;
+    /** {@inheritDoc IWorksheet.setView} */
+    setView(view: IWorksheetView): this;
+    /** {@inheritDoc IWorksheet.getTabColor} */
+    getTabColor(): IColor;
+    /** {@inheritDoc IWorksheet.setTabColor} */
+    setTabColor(color: IColor | string | null): this;
+    /** {@inheritDoc IWorksheet.getCodeName} */
+    getCodeName(): string | null;
+    /** {@inheritDoc IWorksheet.getOutline} */
+    getOutline(): IOutline;
+    /** {@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 IWorksheet.getModules} */
+    getModules(): IModuleCollection;
+    /** {@inheritDoc IWorksheet.getRowHeaders} */
+    getRowHeaders(): ISheetHeader;
+    /** {@inheritDoc IWorksheet.getColumnHeaders} */
+    getColumnHeaders(): ISheetHeader;
+    /**
+     * The sheet's grid, whatever the calculation hands back (DESIGN-CALC-SERVICE §5): opened from
+     * `json` (§6.6), the file's formulas, array extents and cached values, trusted. What the engine
+     * makes of them arrives through the grid's `onComplete`, before this returns when the engine is
+     * `Running`. The grid holds every cell map, and answers an `Off` save and a start's seed itself.
+     * A snapshot sheet over another sheet's state (a copy) shares the grid: the owner answers, with
+     * the state as it is now.
+     */
+    protected _openCalcGrid(json: ICalcGrid.JSON | undefined): ICalcGrid;
+    /** {@inheritDoc IWorksheet.toJSON} */
+    toJSON(options?: IWorksheet.ToJSONOptions): Promise<IWorksheet.JSON>;
+    /** {@inheritDoc IWorksheet.getStyles} */
+    getStyles(): IStyleCollection;
+    /** {@inheritDoc IWorksheet.getResources} */
+    getResources(): IResourceCollection;
+    /** {@inheritDoc IWorksheet.getTransactions} */
+    getTransactions(): ITransaction.IStore;
+    /** {@inheritDoc IWorksheet.getStrings} */
+    getStrings(): IStringCollection;
+    /**
+     * The sheet's movables: those placed on it, then the boxes of its notes.
+     * @internal
+     */
+    protected _searchMovables(options?: IMovableCollection.GetItemsOptions): IMovable[];
+    /**
+     * Places a note's box among the sheet's movables. See {@link Comment.Boxes.add}.
+     * @internal
+     */
+    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
+     * sites have not evaluated yet is followed once they have, folded into the commit then current.
+     */
+    protected _glueConnectors(movable: IMovable, translated?: boolean): void;
+    /** Whether the movable index read last holds a connector or a group; groups are not looked into. */
+    private _connectorScan;
+    /**
+     * The cells under the movables changed size, after the operation that sized them: every glued
+     * connector whose ends left their sites is put back, folded into that operation. Nothing is
+     * written when every end is in place, as on an undo or redo of that operation.
+     */
+    protected _glueStrayConnectors(): void;
+    /**
+     * 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;
+    /**
+     * Called when a movable's content has a newer answer for what it paints: the next search reads
+     * it, and listeners are told once per batch of answers.
+     */
+    private _drawnNotifyQueued;
+    private _onMovableDrawnReady;
+    /**
+     * The farthest any of `models` paints past its anchor, in pixels.
+     * @internal
+     */
+    protected _maxMovableOverhang(models: Map<IMovable, unknown>): number;
+    /**
+     * The movables of one index that match the filter, in z-order.
+     * @internal
+     */
+    protected _searchMovableIndex(spatial: ISpatialMap<MovableEntry>, options?: IMovableCollection.GetItemsOptions): IMovable[];
+    /** @internal */
+    /**
+     * @param description A COMPLETE undo description (callers pass a `messageKey`). It used to be a
+     * verb that this method glued a noun onto (`${action} Picture`); that produced an untranslatable
+     * fragment, and once callers began passing keys it produced literal `op.x Picture` text.
+     */
+    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
+     * caller left open, down and right off any movable already in that spot, so repeated inserts
+     * cascade instead of stacking.
+     *
+     * Resolved before the insert transaction opens: the viewport request must reach the live listeners
+     * (not the transactional set) and must not `await` mid-commit (that desyncs the movable from its
+     * resizers). The grid answers `onRequestViewport` with the visible window in absolute px; headless
+     * (no responder) falls back to the selection.
+     */
+    protected _placeMovable(options: IMovableCollection.AddOptions, bounds: Size & Partial<Point>): Promise<Bounds>;
+    /** Refuses an insert this sheet cannot take. */
+    protected _checkInsertMovable(options?: IMovableCollection.AddOptions): asserts options is IMovableCollection.AddOptions;
+    /**
+     * Inserts a movable whose content kind is already loaded, without waiting: what an operation
+     * that cannot wait, such as a delete that dissolves a group, frees onto the sheet.
+     * @internal
+     */
+    protected _insertMovable(options: InsertableCollection.InsertOptions): IMovable;
+    /**
+     * Groups movables of this sheet into one (GROUPS-DESIGN §5 Phase B): the group's frame is the
+     * union of the boxes they occupy as rotated, its child space equals its frame, and each member
+     * keeps its frame, rotation and flips; the originals are deleted. One undo step, the selection
+     * recorded for undo and redo.
+     * @internal
+     */
+    protected _groupMovables(movables: readonly IMovable[], options?: IMovableCollection.GroupOptions): Promise<IMovable>;
+    /**
+     * 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 IWorksheet.getPicture} */
+    getPicture(): IPicture | null;
+    /** {@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 IWorksheet.getTables} */
+    getTables(): ITableCollection;
+    /** {@inheritDoc IWorksheet.getDataValidations} */
+    getDataValidations(): IDataValidationCollection;
+    /** {@inheritDoc IWorksheet.getConditionalFormats} */
+    getConditionalFormats(): IConditionalFormatCollection;
+    /** {@inheritDoc IWorksheet.getProtectedRanges} */
+    getProtectedRanges(): IProtectedRangeCollection;
+    /** {@inheritDoc IWorksheet.getComments} */
+    getComments(): ICommentCollection;
+    /** @deprecated Use {@link IWorksheet.getConditionalFormats} */
+    getConditionals(): IConditionalFormatCollection;
+    /** {@inheritDoc IWorksheet.getMovables} */
+    getMovables(): IMovableCollection;
+    /** {@inheritDoc IWorksheet.getCharts} */
+    getCharts(): IChartCollection;
+    /** @internal */
+    protected _validateOrRemoveOverlaps(rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean, absorbAutoTable?: boolean): void;
+    /**
+     * The filter and sort criteria a sheet AutoFilter hands over to a table built in its place.
+     *
+     * @remarks
+     * Read BEFORE `_validateOrRemoveOverlaps` absorbs the AutoFilter and replayed once the table
+     * exists. Excel moves them across only when the table takes EXACTLY the AutoFilter's range —
+     * probed: one extra row or column, or a shifted start, and the new table starts clean. Answers
+     * `null` when there is nothing to carry, which is the common case.
+     * @internal
+     */
+    protected _getAutoTableCarryOver(rangeCoords: IRange.Coords): {
+        conditions: ICondition.Input[];
+        sorts: ISort.Options[];
+    } | null;
+    /**
+     * Used by the TableCollection wrapper so we resolve ICellRange.Address here
+     * @internal
+     */
+    protected _addTable(address: ICellRange.Address, options: ITableCollection.AddOptions | boolean): ITable;
+    /**
+     * The add shared by the anchored collections — conditional formats, data validations, protected
+     * ranges. Resolves an item-or-address input, keeps the option keys out of the persisted JSON, and
+     * either redefines the item at `index` (when `replaceExisting` and the collection agrees it is the
+     * same item) or inserts there — first by default, as in Excel.
+     * @internal
+     */
+    protected _addAnchored<T extends IAnchored & {
+        getRanges(): ICellRanges;
+        toJSON(): J | null;
+    }, J extends object>(add: ICellRanges.Address | T | null | undefined, options: (IAnchored.AddOptions & J) | undefined, spec: {
+        /** The sheet-state slot the collection lives in. */
+        key: 'conditionalFormats' | 'dataValidations' | 'protectedRanges' | 'comments';
+        /**
+         * The sheet-protection allowances the add needs. Empty when no option allows it, so the add is
+         * refused whenever the sheet is locked.
+         */
+        allowance: IWorksheetProtection.PropertyKeys[];
+        isItem: (add: unknown) => add is T;
+        description: string;
+        /** Loads one ref into the map, handing the created model to `capture`. */
+        load: (map: IAnchoredMap<T, J>, ref: IRange.JSONReference<J>, capture: (model: T) => void) => IAnchoredMap<T, J>;
+        /**
+         * Whether the item at `index` — already known to cover exactly the same ranges — is the one
+         * `json` redefines: the per-collection half of `replaceExisting`. Omit to match on ranges alone.
+         */
+        isSameItem?: (existing: T, json: J) => boolean;
+        /** Redefines `existing` from `json`, inside the add's commit. */
+        replace: (existing: T, json: J, options: ITransaction.OperationOptions) => void;
+        /** A last look at the JSON before it is inserted (a protected range mints its name here). */
+        prepareInsert?: (json: J) => J;
+        notify: () => void;
+        /** Widen the item's columns after an insert — a validation or format may show a dropdown. */
+        autoFit?: boolean;
+    }): T;
+    /**
+     * @internal
+     */
+    protected _addDataValidation(add: ICellRanges.Address | IDataValidation, options?: IDataValidationCollection.AddOptions): IDataValidation;
+    /**
+     * @internal
+     */
+    protected _addConditionalFormat(add: ICellRanges.Address | IConditionalFormat, options?: IConditionalFormatCollection.AddOptions): IConditionalFormat;
+    /**
+     * The first unused `Range<n>` name, matching Excel's default for a new Allow-Edit-Range.
+     * @internal
+     */
+    protected _nextProtectedRangeName(): string;
+    /**
+     * @internal
+     */
+    protected _addProtectedRange(add: ICellRanges.Address | IProtectedRange, options?: IProtectedRangeCollection.AddOptions): IProtectedRange;
+    /**
+     * @internal
+     */
+    protected _addComment(address: ICellRange.Address, content: IComment.Content, options?: ICommentCollection.AddOptions): IComment;
+    /** {@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 IWorksheet.getRangeAtBounds} */
+    getRangeAtBounds(bounds: Bounds, options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@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[];
+    /**
+     * Check if the spatial map has any entries in the given range.
+     * @internal
+     */
+    protected _hasRangedEntries(key: keyof State, range: IRange.Coords): boolean;
+    /**
+     * Search spatial map for entries in the given range.
+     *
+     * @remarks
+     * Tries to cache and can exclude hidden.
+     * @internal
+     */
+    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 IWorksheet.delete} */
+    delete(): void;
+    /** {@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 IWorksheet.isClosed} */
+    isClosed(): boolean;
+    /** {@inheritDoc IWorksheet.close} */
+    close(): void;
+    /** {@inheritDoc ITransaction.ITransactional.beginCommit} */
+    beginCommit(options?: string | ITransaction.OperationOptions): ITransaction;
+    /** @internal */
+    protected _getState(): Readonly<State>;
+    /**
+     * The store-issued key for this sheet's state record.
+     * @internal
+     */
+    _getStateId(): string;
+    /** @internal */
+    protected _beginCommit(options?: ITransaction.StoreOperationOptions | string): ITransaction;
+    /** @internal */
+    protected _updateState(updateState?: Partial<State>, options?: ITransaction.OperationOptions | string): State;
+    /** @internal */
+    protected _getScalar(rowIndex: number, columnIndex: number, asJSDate?: boolean): Scalar | InteropScalar;
+    /**
+     *  This is mostly optimized except for scrolling. On scroll y it must requery. We could debounce this.
+     * @internal
+     */
+    protected _markColumnHeaderTableNames(): void;
+    /**
+     * Fast single-cell access: resolves the value + intersection directly and builds the cell,
+     * skipping the iterator machinery the range readers use. Produces a cell equivalent to the
+     * iterator path (AllRangeTypes intersection, no merge-overflow rewrite). Used for random access
+     * (`ICellRange.getCell()`/`getFormula()`).
+     * @internal
+     */
+    protected _getCellAt(rowIndex: number, colIndex: number): ICell;
+    /**
+     * The cell as `state` has it, or - for `held` - as the held write to it leaves it.
+     *
+     * @returns `null` if the write has to be made to know: the cell has a formula or a calculation
+     * status the write changes, or a style update that reaches past the cell (see
+     * `intersectionAfterStyleUpdate`).
+     * @internal
+     */
+    protected _getCellAtState(state: Readonly<State>, transaction: ITransaction | null, rowIndex: number, colIndex: number, held: CellBuffer.HeldCell | null): ICell | null;
+    protected _queryStyle(anchorCoords: IRange.Coords, cellOptions: SheetCellOptions, extent?: IRange.Coords): ICellStyle;
+    /**
+     * @param updateStyles Replaces the write half of the returned style. A style READS from the
+     *   anchor cell and WRITES to every range, so a set spanning sheets needs the read to stay here
+     *   (this sheet owns `ranges[0]`) while the write fans out across the others — which only the
+     *   caller holding the whole set can do. See `SheetRanges.getStyle`.
+     * @internal
+     */
+    protected _getStyle(ranges: IRange.Coords[], anchor?: IRangeSelection.Coords, updateStyles?: (update: ICellStyle.Update, options?: ICellStyle.UpdateOptions) => void): ICellStyle;
+    /** @internal */
+    protected _initHeadersState(jsonColumns?: ISheetHeader.JSON, jsonRows?: ISheetHeader.JSON): void;
+    /**
+     * Tells the grid which rows or columns are hidden now, from inside the operation that changed
+     * them: the formulas that skip hidden cells recalculate under that operation.
+     *
+     * @remarks
+     * A restore is heard here too, with no operation open, and is not told: the grid's record of
+     * the set is restored with the sheet's, and the engine's with its own history
+     * (DESIGN-CALC-SERVICE §7.5). Telling it as well would land the restored set under the snapshot
+     * being left.
+     */
+    protected _tellHidden(axis: IRange.Axis): void;
+    /**
+     * Drop every read-through cache that a data change can invalidate.
+     *
+     * @remarks
+     * Normally driven by the transaction state listener, but `_realizeCalcedValues` must call it
+     * directly — see the note there on why calc results never reach that listener.
+     * @internal
+     */
+    protected _invalidateCaches(): void;
+    /**
+     * Initialize static listeners
+     * @internal
+     */
+    protected _initListenerState(): void;
+    /**
+     * Re-derive everything that is a function of how a cell *paints* rather than of what it holds:
+     * the default font metrics, the layout, and the header sizes fitted to that paint.
+     *
+     * @remarks
+     * The theme is the familiar case. A language or locale switch is the same shape — the cell
+     * paints a different word (`WAHR`, `#WERT!`, `15.03.2023`) for a value that never changed — so
+     * the columns fitted to the old word are stale, and nothing below the sheet is told otherwise.
+     * The fit only grows: a maintenance pass must never take back a width the sheet already had.
+     *
+     * @internal
+     */
+    /**
+     * 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: 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): 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 */
+    protected _createConditionalFormats(conditionalFormats: IAnchoredMap<IConditionalFormat, IConditionalFormat.JSON>, key: keyof State, refs: IRange.JSONReference<IConditionalFormat.JSON>[], createModel: (options: ConditionalFormat.ConstructorOptions) => IConditionalFormat, addListeners?: (model: IConditionalFormat) => IListener.Remove): IAnchoredMap<IConditionalFormat, IConditionalFormat.JSON>;
+    /** @internal */
+    protected _createProtectedRanges(protectedRanges: IAnchoredMap<IProtectedRange, IProtectedRange.JSON>, key: keyof State, refs: IRange.JSONReference<IProtectedRange.JSON>[], createModel: (options: ProtectedRange.ConstructorOptions) => IProtectedRange, addListeners?: (model: IProtectedRange) => IListener.Remove): IAnchoredMap<IProtectedRange, IProtectedRange.JSON>;
+    /**
+     * Loads the pivot tables into their anchored map, each anchored where its part says it sits.
+     * The map moves and deletes them with structural edits; the table itself rules on the edit
+     * (`PivotTable._processContainerShift`).
+     * @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>;
+    /**
+     * The JSON for a comment authored now: modifiers with an id, an author and a date minted.
+     * @internal
+     */
+    protected _newCommentJSON(modifiers: IComment.Modifiers): IComment.JSON;
+    /** @internal */
+    protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource, index?: MovableIndex, contentGiven?: Movable.Content): ISpatialMap.Entry<MovableEntry>;
+    /** @internal */
+    protected _fromJSON(json: IWorksheet.JSON | undefined, disableLoadAutoFit?: boolean): void;
+    /** {@inheritDoc ITransaction.ITransactional.getId} */
+    getId(): string;
+    /** {@inheritDoc ITransaction.ITransactional.getVersionId} */
+    getVersionId(): number;
+    /** {@inheritDoc IWorksheet.getName} */
+    getName(): string;
+    /** {@inheritDoc IWorksheet.setName} */
+    setName(name: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IWorksheet.getVisibility} */
+    getVisibility(): ISheet.Visibility;
+    /** {@inheritDoc IWorksheet.setVisibility} */
+    setVisibility(visibility?: ISheet.Visibility | boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IWorksheet.select} */
+    select(options: ITypes.SelectOptions): Promise<this>;
+    /** {@inheritDoc IWorksheet.duplicate} */
+    duplicate(): Promise<this>;
+    /** {@inheritDoc IWorksheet.getIndex} */
+    getIndex(): number;
+    /** {@inheritDoc IWorksheet.setIndex} */
+    setIndex(index: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc IWorksheet.getNames} */
+    getNames(): INamedCollection;
+    /** {@inheritDoc IWorksheet.getCalculation} */
+    /** {@inheritDoc IWorksheet.getCalculation} */
+    getCalculation(): ICalculation;
+    /** {@inheritDoc IWorksheet.createFormula} */
+    createFormula(expression: string, coords?: Partial<IRange.CellCoords>, options?: ICalculation.CreateFormulaOptions): ICalculation.IFormula;
+    /** {@inheritDoc IWorksheet.evaluate} */
+    evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords> & ICalculation.CreateFormulaOptions): Promise<Scalar | IRange>;
+    /** {@inheritDoc IWorksheet.whenCalculationReady} */
+    whenCalculationReady(): Promise<ICalculation.Status>;
+    /** {@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.
+ *
+ * @remarks
+ * For callers that have to total a set spanning more than one sheet (`SheetRanges.getCounts`):
+ * each sheet counts its own coords and the records are summed, which needs the brand applied
+ * somewhere that is not a sheet.
+ * @internal
+ */
+export declare function createCellRangeCounts(counts: Readonly<Record<ICellRange.Feature, number>>): ICellRange.Counts;
+/**
+ * Used for signalling tupleUpdate was called via private apis.
+ * This allows use to 'avoid side effects' and skip validation checks.
+ * @internal
+ */
+interface NotifierOptions {
+    /**
+     * Which error an invalid source reports - `#REF!` when the cells were deleted, `#N/A` when the
+     * world predates the listener.
+     *
+     * @defaultValue `#REF!`
+     */
+    invalidError?: string;
+    isDataChange?: boolean;
+    getTransactionId: () => string;
+    isUndo?: boolean;
+    isRestoreOrRevert?: boolean;
+    trigger?: string;
+    /** Spell the source with its sheet qualifier (a workbook range), as the listener registered it. */
+    qualified?: boolean;
+    from?: ICellRanges;
+    timeStamp?: number;
+}
+interface TableColumnHeaders {
+    table: ITable | null;
+    tableMin: number;
+    tableMax: number;
+    showInHeader: boolean;
+    lastTop: number;
+    lastRowIndex: number;
+    lastColIndex: number;
+}
+/**
+ * A live range listener: its node in the versioned map, and the callback the map must never hold.
+ * @internal
+ */
+interface ListenerNodeEntry {
+    node: ListenerAnchor;
+    handler: ICellRange.Listener | null;
+    handlerW: WeakRef<ICellRange.Listener> | null;
+    options: ICellRange.ListenerOptions;
+    /** The coords last delivered, so a restore can tell whether the reference moved. */
+    lastCoords: IRange.Coords[] | null;
+    /**
+     * Whether the ranges were registered with a sheet qualifier. A qualified address names its
+     * sheet, so a rename of the sheet changes it: the node is told, and its source is spelled
+     * qualified. A bare address is the anchor's and a rename is nothing to it.
+     */
+    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
+ * run's top-left ({@link ICalcGrid.Results.formatInserts}) - what `Sheet._resolveInheritedFormats`
+ * resolves.
+ */
+interface EnteredBlock {
+    coords: IRange.Coords;
+    references: readonly IRange.FixableCoords[];
+}
+export {};
+//# sourceMappingURL=Worksheet.d.ts.map