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

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

@@ -1,1107 +0,0 @@
-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 { 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 { 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;
-        getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
-        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;
-            getBestFit: (range: IRange.Coords, options?: ICellRange.BestFitOptions) => Size;
-            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;
-    /**
-     * 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;
-    /**
-     * 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;
-    /**
-     * 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';
-        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;
-    /** {@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