@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

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

@@ -0,0 +1,1068 @@
+import { IRange, Scalar, InteropScalar, IRangeStats, IRuntime } from '@sheetxl/primitives';
+import { CoordUtils, Size, Bounds } from '@sheetxl/utils';
+import { ITypes, ICollection, IProperties } from '../type';
+import { IWorkbook } from '../workbook';
+import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
+import { IResource, IResourceCollection } from '../resource';
+import { IStringCollection } from '../string';
+import { IProtection } from '../protection';
+import { IComment } from '../comment';
+import { IColor } from '../color';
+import { IHyperlink } from '../hyperlink';
+import { ISort } from '../sort';
+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 { IMovable, IMovableCollection } from '../movable';
+import { IPicture } from '../picture';
+import { ICell } from '../cell';
+import { ICellRange, ICellRegions, ICellRanges } from '../cellRange';
+import { IStyle, IStyleCollection } from '../style';
+import { IRangeSelection } from '../selection';
+import { IConditionalFormat, IConditionalFormatCollection } from '../conditionalFormat';
+import { IProtectedRange, IProtectedRangeCollection } from '../protectedRange';
+import { Tuple, ISortedMap, ISparseGrid, ISpatialMap, ISpatialQuery } from '../collections';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { RangeStats } from '../primitives';
+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 { ISheetProtection } from '../sheetProtection';
+import { ISheetHeader } from '../sheetHeader';
+import { ISheetView } from '../sheetView';
+import { ISheet } from './ISheet';
+import { SheetHeader } from '../sheetHeader/SheetHeader';
+import { SheetDirectStyle } from './style/SheetDirectStyle';
+import { IUsedRangeSpatialMap } from './style/UsedRangeSpatialMap';
+import { RangeState, CellState, State, MovableEntry, ICellRangeListenerEntry, ICellRangesListenerEntry, BeforeAfterRange, InternalTupleUpdate } from './_SheetStateTypes';
+import { SheetReadContext, GetTypedRangeOptions, OverFlowsAndStops } from './_SheetStateReader';
+import { AutoFillProjection, AutoFillPreviewCache } from './_SheetMutations';
+import { ProtectionCheck } from './_SheetCoords';
+import { RangesListener, RangesListenerEntry } from './listener';
+import { SheetProtection } from '../sheetProtection/SheetProtection';
+import { SheetCellOptions } from './SheetCell';
+import { ICalculation } from '../calculation';
+import { ICalcGrid } from '../calculation/grid';
+/**
+ * Implementation of {@link ISheet}.
+ */
+/**
+ * The internal capability surface a {@link Sheet} vends to `SheetRange`/`SheetRanges` and (later)
+ * extracted operation modules. It carries ONLY genuinely-internal operations; the public `ISheet`
+ * API is reached via `getSheet()` and never duplicated here. The type is derived from the concrete
+ * `_internal` object so it can never drift from the implementation.
+ * @internal
+ */
+export type ISheetInternal = ReturnType<Sheet['_getInternal']>;
+/**
+ * The context a {@link Sheet} vends to `_SheetMutations` (the shift/insert/delete engine). Derived
+ * from the concrete `_buildMutationCtx` object so it can never drift from the implementation.
+ * @internal
+ */
+export type SheetMutationContext = ReturnType<Sheet['_buildMutationCtx']>;
+/**
+ * The context a {@link Sheet} vends to `_SheetCoords` (address/coord resolution). Derived from the
+ * concrete `_buildCoordCtx` object so it can never drift from the implementation.
+ * @internal
+ */
+export type SheetCoordContext = ReturnType<Sheet['_buildCoordCtx']>;
+export declare class Sheet implements ISheet {
+    protected _options: ISheet.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 _lastTransactionUUID: string | null;
+    protected _emitter: ListenerEmitter<ISheet, ISheet.IListeners>;
+    protected _initializing: boolean;
+    protected _starting: Promise<void> | null;
+    protected _strings: IStringCollection;
+    protected _ownStrings: boolean;
+    protected _styles: IStyleCollection;
+    protected _ownStyles: boolean;
+    protected _stylesRemoveListener: IListener.Remove;
+    protected _stylesListener: IStyleCollection.IListeners;
+    protected _normalStyleRanged: IProperties.ICellRanged<IStyle.Properties>;
+    protected _resources: IResourceCollection;
+    protected _ownResources: boolean;
+    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 _rangeStats: RangeStats;
+    protected _tables: ITableCollection;
+    protected _conditionals: IConditionalFormatCollection;
+    protected _dataValidations: IDataValidationCollection;
+    protected _protectedRanges: IProtectedRangeCollection;
+    protected _movables: IMovableCollection;
+    protected _emitterMovables: ListenerEmitter<IMovableCollection, ICollection.IListeners>;
+    protected _rangesListenerSorted: ISortedMap<number, RangesListener> | null;
+    protected _rangeListenerSpatial: ISpatialMap<ICellRangeListenerEntry>;
+    protected _rangesListenerMap: Map<number, ICellRangesListenerEntry>;
+    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: ISheetView;
+    protected _viewListener: ISheetView.IListeners;
+    protected _viewRemoveListener: IListener.Remove;
+    protected _protection: SheetProtection;
+    protected _protectionListener: IProtection.IListeners;
+    protected _protectionRemoveListener: IListener.Remove;
+    protected _tabColor: IColor | null;
+    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;
+    protected _emptyCell: ICell;
+    protected _cellOptions: SheetCellOptions;
+    protected _closed: boolean;
+    protected _defaultColWidthCache: number | null;
+    protected _defaultRowHeightCache: number | null;
+    protected _defaultFontBoundsCache: Readonly<Size> | null;
+    /**
+     * The internal capability object handed to `SheetRange`/`SheetRanges` (and future extracted
+     * modules) so they can drive the sheet without touching its (non-public) methods or the concrete
+     * class shape. The closures reach `Sheet`'s protected members because they are lexically inside the
+     * class. Public `ISheet` API is reached via `getSheet()` (never duplicated here). As internal logic
+     * moves out to modules, only the relevant closure repoints — consumers never change.
+     * The `ISheetInternal` type is derived from this object (see below) so it can never drift.
+     * @internal
+     */
+    private readonly _internal;
+    /** @internal Access the internal capability object. See {@link ISheetInternal}. */
+    _getInternal(): {
+        getSheet: () => ISheet;
+        getState: () => Readonly<State>;
+        isDataColumn: () => boolean;
+        createRange: (coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null) => ICellRange;
+        isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => 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.BoundedTuples<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>;
+        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: IStyle.Update, options?: IStyle.UpdateOptions) => void) => IStyle;
+        updateStyles: (ranges: readonly ISpatialMap.Entry<IStyle.Update>[], defaultUpdate?: IStyle.Update, options?: IStyle.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;
+        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) => Partial<Record<ICell.Content, number>>;
+        featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis) => ICellRange.Counts;
+        featureRegions: (bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions) => IRange.Coords[];
+        dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => ICellRanges | null;
+        clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, isCut?: boolean) => 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[]>;
+        autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
+        addRangesListeners: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
+        addRangesListeners2: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options: ICellRange.ListenerOptions | undefined, isRanges: boolean) => IListener.Remove;
+        surroundingRegion: (range: IRange.Coords, options?: ICellRange.GetSurroundingOptions) => IRange.Coords;
+        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>;
+        setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
+        setComments: (ranges: readonly ISpatialMap.Entry<IComment.Properties>[], comments?: IComment.JSON | null, 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;
+    /** @internal Reconciled error-VALUE view; see {@link _getErrorSpatialReconciled}. */
+    protected _errorReconciled: {
+        grid: ISparseGrid<Scalar> | null;
+        epoch: number;
+        spatial: ISpatialMap<boolean>;
+    } | null;
+    /**
+     * @internal Bumped whenever `cellValuesGrid` is mutated IN PLACE (calc realize, re-load) —
+     * grid identity alone catches every other mutation (they clone).
+     */
+    protected _errorEpoch: number;
+    /**
+     * The reconciled error-VALUE spatial backing `RangeState.Type.Error` — merge-on-READ.
+     *
+     * @remarks
+     * `state.errorSpatial` is write-path only and stale for formula cells after a recalc, so the
+     * truth is the current values: built here by one scan of `cellValuesGrid`, cached against
+     * (grid identity, in-place epoch). The calc path pays nothing; the scan runs at agent cadence
+     * (first error-aware read after a change) and multi-altitude reads share the cache. When the
+     * calc executor emits error deltas, `state.errorSpatial` becomes fully fresh and this method
+     * reduces to returning it.
+     * @internal
+     */
+    protected _getErrorSpatialReconciled(): ISpatialMap<boolean>;
+    /** @internal Cached mutation-engine context. See {@link SheetMutationContext}. */
+    protected _mutationCtx: ReturnType<Sheet['_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 rowHeadersShiftCallback: SheetHeader.ShiftCallback | null;
+        readonly columnHeadersShiftCallback: SheetHeader.ShiftCallback | null;
+        getEntireCoords: () => IRange.Coords;
+        getView: () => ISheetView;
+        beginCommit: (options?: ITransaction.StoreOperationOptions<CommitView> | string) => ITransaction;
+        updateState: (updateState?: Partial<State>, options?: ITransaction.OperationOptions | string) => State;
+        getState: () => Readonly<State>;
+        stateFor: (trans: ITransaction) => State;
+        /** 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;
+        processListenerShift: (rangesListenerMap: Map<number, ICellRangesListenerEntry>, beforeAfterMap: Map<number, BeforeAfterRange>, beforeStates: Map<number, ICellRangesListenerEntry>, options: ISpatialMap.ShiftDetails<ICellRangeListenerEntry>) => ISpatialMap.Entry<ICellRangeListenerEntry>[] | void;
+        processLayoutChange: () => void;
+        markColumnHeaderTableNames: () => void;
+        commitAndAutoSelect: (trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, selectOptions?: boolean | ICellRange.SelectOptions, commitOptions?: ITransaction.StoreOperationOptions<CommitView>, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
+        /** Read-clone-write the `_rangeStats` cache against a new values grid. */
+        cloneRangeStats: (grid: ISparseGrid<Scalar>) => 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) => void;
+        notify: (key: keyof ISheet.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) => void;
+        autoSelect: (options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis) => Promise<IRange.Coords[]>;
+        readonly isDataColumn: boolean;
+        readonly strings: IStringCollection;
+        readonly cellOptions: SheetCellOptions;
+        readonly runtime: IRuntime;
+        getProtection: () => ISheetProtection;
+        hasRangedEntries: (key: keyof State, range: IRange.Coords) => boolean;
+        rangeStateIterator: (options: RangeState.IteratorOptions) => RangeState.Iterator;
+        addEvent: (type: keyof CommitEvents, value: any) => void;
+        getTables: () => ITableCollection;
+        getAutoTable: () => ITable | null;
+        cellIterator: (options: CellState.IteratorOptions) => IterableIterator<ICellRange.Entry, ICellRange.Entry, IRange.CellCoords>;
+        rangeToCoords: (address: ICellRange.Address, protectionCheck?: ProtectionCheck | null, lookupNames?: boolean) => IRange.Coords;
+        getCell: (address?: ICell.Address) => ICell;
+        createCell: (update: ICell.Update, coords?: IRange.CellCoords | null) => 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<Sheet['_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: () => ISheet;
+            getState: () => Readonly<State>;
+            isDataColumn: () => boolean;
+            createRange: (coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null) => ICellRange;
+            isContentful: (ranges: readonly IRange.Coords[], ignoreHidden?: boolean | IRange.Axis) => 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.BoundedTuples<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>;
+            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: IStyle.Update, options?: IStyle.UpdateOptions) => void) => IStyle;
+            updateStyles: (ranges: readonly ISpatialMap.Entry<IStyle.Update>[], defaultUpdate?: IStyle.Update, options?: IStyle.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;
+            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) => Partial<Record<ICell.Content, number>>;
+            featureCounts: (ranges: readonly IRange.Coords[], features?: ICellRange.Feature | readonly ICellRange.Feature[], ignoreHidden?: boolean | IRange.Axis) => ICellRange.Counts;
+            featureRegions: (bounds: IRange.Coords, requested: readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions) => IRange.Coords[];
+            dependencyRanges: (coords: IRange.Coords, kind: "precedents" | "dependents", direct: boolean) => ICellRanges | null;
+            clear: (ranges: readonly IRange.Coords[], applyTo?: ICell.Content | null, options?: ITransaction.OperationOptions, excludeSorts?: boolean, isCut?: boolean) => 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[]>;
+            autoFit: (ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions) => void;
+            addRangesListeners: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions) => IListener.Remove;
+            addRangesListeners2: (ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options: ICellRange.ListenerOptions | undefined, isRanges: boolean) => IListener.Remove;
+            surroundingRegion: (range: IRange.Coords, options?: ICellRange.GetSurroundingOptions) => IRange.Coords;
+            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>;
+            setHyperlinks: (ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, options?: ITransaction.OperationOptions) => void;
+            setComments: (ranges: readonly ISpatialMap.Entry<IComment.Properties>[], comments?: IComment.JSON | null, 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: () => ISheetProtection;
+        getName: () => string;
+        resolveRange: (coord: ICellRange.Address) => ICellRange | null | undefined;
+    };
+    constructor(options?: ISheet.ConstructorOptions);
+    /** @internal Logic lives in `_SheetCoords.createRange`. */
+    protected _createRange(coords: Readonly<IRange.FixableCoords> | string, getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null): ICellRange;
+    /** @internal Logic lives in `_SheetCoords.createRanges`. */
+    protected _createRanges(coords: readonly (IRange.Coords | string | ICellRange)[], getOptions?: ICellRange.GetRangeOptions, readOnly?: string | null): ICellRanges;
+    /** {@inheritDoc ISheet.getRange} */
+    getRange(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc ISheet.getCell} */
+    getCell(address?: ICell.Address): ICell;
+    /** {@inheritDoc ISheet.getRange} */
+    getRanges(address: ICellRanges.Address, options?: ICellRange.GetRangeOptions): ICellRanges;
+    /** {@inheritDoc ISheet.getEntireRange} */
+    getEntireRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    protected _getEntireCoords(): IRange.Coords;
+    /** {@inheritDoc ISheet.getEntireCoords} */
+    getEntireCoords(): IRange.Coords;
+    /** {@inheritDoc ISheet.getUsedRange} */
+    getUsedRange(options?: ICellRange.GetRangeOptions): ICellRange | null;
+    /** {@inheritDoc ISheet.getStats} */
+    getStats(options?: ICellRange.GetStatsOptions): IRangeStats;
+    /** {@inheritDoc ISheet.getRegions} */
+    getRegions(features?: ICellRange.Feature | readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): 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>[][]): 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<IStyle.Update>[], defaultUpdate?: IStyle.Update, // we do this because updateTuples may update each
+    options?: IStyle.UpdateOptions, calcedNumberFormat?: boolean): void;
+    /** @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.BoundedTuples<ICell.Update> | null, options?: ICellRange.UpdateCellsOptions, coordValidator?: CoordUtils.CoordValidator | null | undefined, internalOptions?: InternalTupleUpdate | null): void;
+    /** @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 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.setHyperlinks`. */
+    protected _setHyperlinks(ranges: readonly ISpatialMap.Entry<IHyperlink.Update>[], defaultUpdate?: IHyperlink.Update, // we do this because updateTuples may update each
+    options?: ITransaction.OperationOptions): void;
+    /** @internal */
+    protected _realizeCalcedValues(results: ICalcGrid.Results): void;
+    /** {@inheritDoc ISheet.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.Properties>[], comments?: IComment.JSON | null, // we do this because updateTuples may update each
+    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, isCut?: boolean): 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(): ISheet;
+    /** @internal */
+    protected _getSnapshot(coordsFrom: readonly IRange.Coords[], optionsMark?: ICellRange.CopyOptions, getTransactionId?: () => string): ICellRange.ISnapshot;
+    /**
+     * Copy all items at a sheetRange.
+     * @internal
+     `*/
+    protected _copyRange(sheetFrom: Sheet, sheetMark: Sheet, coordsFrom: readonly IRange.Coords[], sheetRangeTo: ICellRange, options: ICellRange.CopyOptions | undefined, toInfo: any): Promise<IRange.Coords>;
+    /**
+     * Returns `null` if invalid.
+     * @internal
+     */
+    protected _snapShotFromSource(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
+    /** @internal */
+    protected _copyFrom(destination: IRange.Coords, source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<IRange.Coords>;
+    /** {@inheritDoc ISheet.addAutoTable} */
+    addAutoTable(address?: ICellRange.Address, options?: ICellRange.AddAutoTableOptions): ITable;
+    /** {@inheritDoc ISheet.getAutoTable} */
+    getAutoTable(): ITable | null;
+    /** @internal */
+    protected _getDefaultShiftAxis(coords?: IRange.Coords): IRange.Axis;
+    /** @internal */
+    protected _getTables(address: ICellRanges.Address, ignoreHidden?: boolean, fullyContained?: boolean): ITable[];
+    /** @internal */
+    protected _getDefaultSortCriteria(rangeCoords: IRange.Coords, axis?: IRange.Axis, cell?: ICell.Address): ISort.DefaultSortCriteria;
+    /** @internal */
+    protected _insertFrom(ranges: readonly IRange.Coords[], source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<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`).
+     */
+    protected _autoFit(ranges: readonly IRange.Coords[], options?: ICellRange.AutoFitOptions): void;
+    /** @internal */
+    protected _createRangeEvent(coords: (readonly IRange.FixableCoords[]) | IRange.FixableCoords, options: NotifierOptions, coordsFrom?: (readonly IRange.FixableCoords[]) | IRange.FixableCoords): ICellRange.Event;
+    /**
+     * Notifies listeners with a range.
+     * @internal
+     */
+    protected _notifyAddressListeners(listenerMapAll: Map<string, RangesListener>, listenerMapEvent: Map<string, RangesListener | null>, // address-only events store null values
+    visited: Set<string>, options: NotifierOptions): void;
+    /**
+     * Notifies listeners with a range.
+     * @internal
+     */
+    protected _notifyDataListeners(spatialMap: ISpatialMap<RangesListenerEntry>, listenerMap: Map<string, RangesListener>, ranges: (readonly IRange.FixableCoords[] | null) | undefined, visited: Set<string>, options: NotifierOptions): void;
+    /**
+     * Notifies listeners with a range.
+     * @internal
+     */
+    protected _notifyRangeListeners(spatial: ISpatialMap<ICellRangeListenerEntry>, listenerMap: Map<number, ICellRangesListenerEntry>, ranges: (readonly IRange.FixableCoords[] | null) | undefined, notificationOptions: NotifierOptions): void;
+    /** @internal */
+    protected _notifyRangeListener2(entry: ICellRangesListenerEntry, event?: ICellRange.Event | null, notificationOptions?: NotifierOptions | null): void;
+    /** @internal */
+    protected _notifyUsedRangeChange(): void;
+    /** @internal */
+    protected _notify(key: keyof ISheet.IListeners): void | Promise<any>;
+    /**
+     * Every collection change fires its fine-grained event PLUS the coarse class event it belongs
+     * to (see `ISheet.Events.onStyleChange` / `onProtectionChange`), so renderers subscribe to the
+     * 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 _notifyDataValidationsChange(): void;
+    /** {@inheritDoc Sheet._notifyConditionalFormatsChange} @internal */
+    protected _notifyProtectedRangesChange(): void;
+    /** {@inheritDoc ISheet.addListeners} */
+    addListeners(listeners: ISheet.IListeners, options?: IListener.Options): IListener.Remove;
+    /** @internal */
+    protected _addRangesListeners(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
+    /** @internal */
+    protected _addRangesListeners2(ranges: readonly IRange.Coords[], listener: ICellRange.Listener, options: ICellRange.ListenerOptions | undefined, isRanges: boolean): 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): boolean;
+    /** @internal */
+    protected _getCount(coords: IRange.Coords[], ignoreHidden?: boolean): number;
+    /**
+     * Legacy Content-keyed counting — internal callers only (`clear` preflight, `_getCount`).
+     * The public path is `_featureCounts`, keyed by `ICellRange.Feature`.
+     * @internal
+     */
+    protected _contentCounts(ranges: readonly IRange.Coords[], types: ICell.Content[] | undefined, ignoreHidden?: boolean | IRange.Axis): 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. 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): 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): ICellRanges | null;
+    /**
+     * 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; regions for the projected style features (`NumberFormat`/`Alignment`/`Font`)
+     * are correct but may be finer than maximal (the shared content-style map splits on parts the
+     * projection ignores). 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 ISheet.find} */
+    find(options?: string | ICellRange.FindOptions): Iterator<ICell>;
+    /** {@inheritDoc ISheet.setEntireSize} */
+    setEntireSize(size?: Partial<Size> | null, options?: ITransaction.OperationOptions): this;
+    /** @internal */
+    protected _find(ranges: readonly IRange.Coords[], options: string | ICellRange.FindOptions): Iterator<ICell>;
+    /** {@inheritDoc ISheet.getRuntime} */
+    getRuntime(): IRuntime;
+    /** @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 ISheet.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 ISheet.getProtection} */
+    getProtection(): ISheetProtection;
+    /** @internal */
+    protected _scrollIntoView(coords: IRange.Coords, scrollIntoView?: boolean | ICellRange.ScrollIntoViewOptions): Promise<boolean>;
+    /** @internal */
+    protected _selectSheet(coords: IRange.Coords, scrollIntoView?: boolean | ICellRange.ScrollIntoViewOptions): Promise<boolean>;
+    /** {@inheritDoc ISheet.scrollTo} */
+    scrollTo(coords: Partial<IRange.Coords>, options?: ISheet.ScrollToOptions): Promise<boolean>;
+    /** @internal */
+    protected _resolveSelectOptions(selectOptions: boolean | ICellRange.SelectOptions, axis?: IRange.Axis): ICellRange.SelectOptions | null;
+    /** @internal */
+    protected _commitAndAutoSelect(trans: ITransaction, selection: Partial<IRangeSelection.Coords> | null, selectOptions?: boolean | ICellRange.SelectOptions, commitOptions?: ITransaction.StoreOperationOptions<CommitView>, axis?: IRange.Axis): Promise<IRange.Coords[]>;
+    /** @internal */
+    protected _autoSelect(options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords> | null, axis?: IRange.Axis): Promise<IRange.Coords[]>;
+    /** {@inheritDoc ISheet.getSelection} */
+    getSelection(): IRangeSelection;
+    /** {@inheritDoc ISheet.getSelectedCell} */
+    getSelectedCell(): ICell;
+    /** {@inheritDoc ISheet.getSelectedRange} */
+    getSelectedRange(options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc ISheet.getSelectedRanges} */
+    getSelectedRanges(options?: ICellRange.GetRangeOptions): ICellRanges;
+    /** {@inheritDoc ISheet.getView} */
+    getView(): ISheetView;
+    /** {@inheritDoc ISheet.setView} */
+    setView(view: ISheetView): this;
+    /** {@inheritDoc ISheet.getTabColor} */
+    getTabColor(): IColor;
+    /** {@inheritDoc ISheet.setTabColor} */
+    setTabColor(color: IColor | string | null): this;
+    /** {@inheritDoc ISheet.getRowHeaders} */
+    getRowHeaders(): ISheetHeader;
+    /** {@inheritDoc ISheet.getColumnHeaders} */
+    getColumnHeaders(): ISheetHeader;
+    /** {@inheritDoc ISheet.toJSON} */
+    toJSON(options?: ISheet.ToJSONOptions): Promise<ISheet.JSON>;
+    /** {@inheritDoc ISheet.getStyles} */
+    getStyles(): IStyleCollection;
+    /** {@inheritDoc ISheet.getResources} */
+    getResources(): IResourceCollection;
+    /** {@inheritDoc ISheet.getTransactions} */
+    getTransactions(): ITransaction.IStore;
+    /** {@inheritDoc ISheet.getStrings} */
+    getStrings(): IStringCollection;
+    /** @internal */
+    protected _searchMovables(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>;
+    /** @internal */
+    protected _addMovablePicture(picture: string | IResourceCollection.AddOptions | IResource, options?: IMovableCollection.AddOptions): Promise<IMovable>;
+    /** {@inheritDoc ISheet.setPicture} */
+    setPicture(picture: string | IResource | IResourceCollection.AddOptions | null, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISheet.getPicture} */
+    getPicture(): IPicture | null;
+    /** {@inheritDoc ISheet.getTables} */
+    getTables(): ITableCollection;
+    /** {@inheritDoc ISheet.getDataValidations} */
+    getDataValidations(): IDataValidationCollection;
+    /** {@inheritDoc ISheet.getConditionalFormats} */
+    getConditionalFormats(): IConditionalFormatCollection;
+    /** {@inheritDoc ISheet.getProtectedRanges} */
+    getProtectedRanges(): IProtectedRangeCollection;
+    /** @deprecated Use {@link ISheet.getConditionalFormats} */
+    getConditionals(): IConditionalFormatCollection;
+    /** {@inheritDoc ISheet.getMovables} */
+    getMovables(): IMovableCollection;
+    /** @internal */
+    protected _validateOrRemoveOverlaps(rangeCoords: IRange.Coords, type: string, table?: ITable | null, removeIfContains?: boolean): void;
+    /**
+     * Used by the TableCollection wrapper so we resolve ICellRange.Address here
+     * @internal
+     */
+    protected _addTable(address: ICellRange.Address, options: ITableCollection.AddOptions | boolean): ITable;
+    /**
+     * @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;
+    /** {@inheritDoc ISheet.createCell} */
+    createCell(update: ICell.Update, coords?: IRange.CellCoords | null): ICell;
+    /** @internal */
+    protected _getBoundsAtCoords(coords: IRange.Coords): Bounds;
+    /** @internal */
+    protected _getCoordsAtBounds(bounds: Bounds): IRange.Coords;
+    /** {@inheritDoc ISheet.getRangeAtBounds} */
+    getRangeAtBounds(bounds: Bounds, options?: ICellRange.GetRangeOptions): ICellRange;
+    /** {@inheritDoc ISheet.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;
+    /** @internal */
+    protected _processListenerShift(rangesListenerMap: Map<number, ICellRangesListenerEntry>, beforeAfterMap: Map<number, BeforeAfterRange>, beforeStates: Map<number, ICellRangesListenerEntry>, options: ISpatialMap.ShiftDetails<ICellRangeListenerEntry>): ISpatialMap.Entry<ICellRangeListenerEntry>[] | void;
+    /** {@inheritDoc ISheet.delete} */
+    delete(): void;
+    /** {@inheritDoc ITransaction.ITransactional.doBatch} */
+    doBatch<R>(callback: (commit: ITransaction.ICommit) => Promise<R> | R, options?: string | ITransaction.OperationOptions): Promise<R> | R;
+    /** {@inheritDoc ISheet.isDeleted} */
+    isDeleted(): boolean;
+    /** {@inheritDoc ISheet.isClosed} */
+    isClosed(): boolean;
+    /** {@inheritDoc ISheet.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<CommitView> | string): ITransaction;
+    /** @internal */
+    protected _updateState(updateState?: Partial<State>, options?: ITransaction.OperationOptions | string): State;
+    /** @internal */
+    protected _addEvent(type: keyof CommitEvents, value: any): void;
+    /** @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;
+    protected _queryStyle(anchorCoords: IRange.Coords, cellOptions: SheetCellOptions, extent?: IRange.Coords): IStyle;
+    /**
+     * @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: IStyle.Update, options?: IStyle.UpdateOptions) => void): IStyle;
+    /** @internal */
+    protected _initHeadersState(jsonColumns?: ISheetHeader.JSON, jsonRows?: ISheetHeader.JSON): 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;
+    /** @internal */
+    protected _initViewState(entireCoords: IRange.Coords, json: ISheetView.JSON): void;
+    protected _initCellState(): void;
+    /** @internal */
+    protected _createTables(tables: IAnchoredMap<ITable, ITable.JSON>, key: keyof State, refs: IRange.JSONReference<ITable.JSON>[], createModel: (options: AnchoredTable.ConstructorOptions) => ITable, addListeners?: (model: ITable) => IListener.Remove): IAnchoredMap<ITable, ITable.JSON>;
+    /** @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>;
+    /** @internal */
+    protected _createMovableEntry(json: IMovable.JSON, zIndex: number, fromResourceId?: (resourceId: number) => IResource): ISpatialMap.Entry<MovableEntry>;
+    /** @internal */
+    protected _fromJSON(json: ISheet.JSON | undefined, disableLoadAutoFit?: boolean): void;
+    /** {@inheritDoc ITransaction.ITransactional.getId} */
+    getId(): string;
+    /** {@inheritDoc ITransaction.ITransactional.getVersionId} */
+    getVersionId(): number;
+    /** {@inheritDoc ISheet.getName} */
+    getName(): string;
+    /** {@inheritDoc ISheet.setName} */
+    setName(name: string, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISheet.getVisibility} */
+    getVisibility(): ISheet.Visibility;
+    /** {@inheritDoc ISheet.setVisibility} */
+    setVisibility(visibility?: ISheet.Visibility | boolean, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISheet.select} */
+    select(options: ITypes.SelectOptions): Promise<this>;
+    /** {@inheritDoc ISheet.duplicate} */
+    duplicate(): Promise<this>;
+    /** {@inheritDoc ISheet.getIndex} */
+    getIndex(): number;
+    /** {@inheritDoc ISheet.setIndex} */
+    setIndex(index: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISheet.getNames} */
+    getNames(): INamedCollection;
+    /** {@inheritDoc ISheet.getCalculation} */
+    /** {@inheritDoc ISheet.getCalculation} */
+    getCalculation(): ICalculation;
+    /** {@inheritDoc ISheet.createFormula} */
+    createFormula(expression: string, coords?: Partial<IRange.CellCoords>): ICalculation.IFormula;
+    /** {@inheritDoc ISheet.evaluate} */
+    evaluate(expression: string, options?: number | ICalculation.EvaluateOptions & Partial<IRange.CellCoords>): Promise<Scalar | IRange>;
+    /** {@inheritDoc ISheet.whenCalculationReady} */
+    whenCalculationReady(): Promise<ICalculation.Status>;
+    /** {@inheritDoc ISheet.getWorkbook} */
+    getWorkbook(): IWorkbook | null;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ISheet.isISheet} */
+    get isISheet(): 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;
+interface NotifierOptions {
+    isDataChange?: boolean;
+    getTransactionId: () => string;
+    isUndo?: boolean;
+    isRestoreOrRevert?: boolean;
+    trigger?: string;
+    from?: ICellRanges;
+    to?: ICellRange;
+    timeStamp?: number;
+}
+interface TableColumnHeaders {
+    table: ITable | null;
+    tableMin: number;
+    tableMax: number;
+    showInHeader: boolean;
+    lastTop: number;
+    lastRowIndex: number;
+    lastColIndex: number;
+}
+interface CommitEvents {
+    address?: Map<string, RangesListener | null>;
+    data?: IRange.Coords[];
+    dataListeners?: Map<string, RangesListener | null>;
+}
+interface CommitView {
+    initial?: boolean;
+    sheet?: ISheet;
+    view?: ISheetView;
+    freezePanes?: Partial<IRange.CellCoords>;
+    selection?: Partial<IRangeSelection.Coords> | null;
+    selectOptions?: boolean | ICellRange.SelectOptions | null;
+    movableSelection?: readonly IMovable[];
+    ranges?: readonly IRange.FixableCoords[];
+    events?: CommitEvents;
+    formulas?: readonly IRange.FixableCoords[];
+    spills?: readonly IRange.FixableCoords[];
+    /**
+     * Special case for range listeners that monitored a remove.
+     */
+    merges?: readonly IRange.FixableCoords[];
+    listeners?: Map<number, BeforeAfterRange>;
+    table?: ITable;
+    /** If `true` then don't do protection check. (For example load or range listeners) */
+    skipProtectionCheck?: boolean;
+    /**
+     * We update values (cache, potentially styling, as a result of calculations)
+     */
+    calculationSideEffect?: boolean;
+}
+export {};
+//# sourceMappingURL=Sheet.d.ts.map