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

package/types/src/sheet/{ISheetCollection.d.ts → IWorksheetCollection.d.ts}

@@ -1,43 +1,65 @@
 import { ICollection } from '../type';
 import { ITransaction } from '../transaction';
+import { IWorksheet } from './IWorksheet';
 import { ISheet } from './ISheet';
 /**
- * Holds a collection of {@link ISheet}s.
+ * Holds a collection of {@link IWorksheet}s.
  */
-export interface ISheetCollection extends ICollection<ISheet> {
+export interface IWorksheetCollection extends ICollection<IWorksheet> {
     /**
-     * Add an `ISheet` to the collection.
+     * Add an `IWorksheet` to the collection.
      */
-    add(options?: ISheetCollection.AddOptions | string | number): ISheet;
+    add(options?: IWorksheetCollection.AddOptions | string | number): IWorksheet;
     /**
      * Returns sheets that match the filter criteria.
      *
      * If no filter criteria is provided, all sheets will be returned.
      *
-     * @param options {@link ISheetCollection.GetItemsOptions}
-     */
-    getItems(options?: ISheetCollection.GetItemsOptions): ISheet[];
-    /**
-     * Returns the sheet at the given index.
-     * @param index
-     * @returns
+     * @param options {@link IWorksheetCollection.GetItemsOptions}
      */
+    getItems(options?: IWorksheetCollection.GetItemsOptions): IWorksheet[];
     /**
      * Convenience method for filtering by name. This is
      * functionally equivalent to getItems({ name });
      *
      * @param name The name to search for This is case insensitive.
      */
-    getByName(name: string): ISheet | null;
+    getByName(name: string): IWorksheet | null;
+    /**
+     * Exists to have api parity with Office Scripts.
+     *
+     * @deprecated Use `IWorkbook.getSelectedWorksheet`.
+     * @hidden
+     */
+    getActive(): IWorksheet | null;
+    /**
+     * Exists to have api parity with Office Scripts.
+     *
+     * @deprecated Use {@link getItems}`()[index]`.
+     * @hidden
+     */
+    getAt(index: number): IWorksheet | null;
+    /**
+     * @deprecated Use {@link getItems}`()[index]`.
+     * @hidden
+     */
+    getByIndex(index: number): IWorksheet | null;
+    /**
+     * @deprecated Use {@link getItems}.
+     * @hidden
+     */
+    getAll(): IWorksheet[];
+    /** For runtime type checking. */
+    readonly isIWorksheetCollection: true;
 }
 /**
- * {@inheritDoc ISheetCollection}
+ * {@inheritDoc IWorksheetCollection}
  * @see
  * ### **Interface**
  *
- * {@link ISheetCollection}
+ * {@link IWorksheetCollection}
  */
-export declare namespace ISheetCollection {
+export declare namespace IWorksheetCollection {
     /**
      * Options for adding a sheet to the collection.
      */
@@ -67,4 +89,4 @@ export declare namespace ISheetCollection {
         name?: string;
     }
 }
-//# sourceMappingURL=ISheetCollection.d.ts.map
+//# sourceMappingURL=IWorksheetCollection.d.ts.map

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

@@ -1,7 +1,8 @@
 import { ICellRanges } from '../cellRange';
-import { _NamedGraphNode } from '../cellRange/_GraphNode';
+import { NamedNodeInfo } from '../calculation/Types';
+import { INamedFormulasCollection } from '../calculation/INamedFormulasCollection';
 import { NamedRange } from './NamedRange';
-import { ISheetInternal } from './Sheet';
+import { IWorksheetInternal } from './Worksheet';
 import { SheetRangeOptions } from './SheetRange';
 /**
  * A defined name as a NODE in the calculation graph — an `INamedRange` whose coords are the
@@ -18,10 +19,18 @@ import { SheetRangeOptions } from './SheetRange';
  * The anchor matters to precedents (relative references in the body resolve from it) and is only
  * a label for dependents (the symbol index is global). Lead with the name when displaying one —
  * two names authored from the same active cell share an anchor address, and the name is the fact.
+ *
+ * Built from a {@link NamedNodeInfo} — plain data — and answers its five name questions by
+ * resolving the id against the collection when asked. It does NOT capture the name object: a name
+ * can be redefined or deleted while a graph answer is still held, and re-resolving means the
+ * answer follows the definition rather than a snapshot of it. A name that is gone answers `null`.
  */
 export declare class NamedCellRange extends NamedRange {
-    private readonly _node;
-    constructor(node: _NamedGraphNode, internal: ISheetInternal, options: SheetRangeOptions | null);
+    private readonly _info;
+    private readonly _namedFormulas;
+    constructor(info: NamedNodeInfo, namedFormulas: INamedFormulasCollection | null, internal: IWorksheetInternal, options: SheetRangeOptions | null);
+    /** The name this node stands for, or `null` if it no longer exists. @internal */
+    private _named;
     /**
      * {@inheritDoc INamedRange.getRanges}
      *
@@ -33,13 +42,13 @@ export declare class NamedCellRange extends NamedRange {
      */
     getRanges(): ICellRanges | null;
     /** {@inheritDoc ICellRange.getDirectPrecedents} */
-    getDirectPrecedents(): ICellRanges | null;
+    getDirectPrecedents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getPrecedents} */
-    getPrecedents(): ICellRanges | null;
+    getPrecedents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getDirectDependents} */
-    getDirectDependents(): ICellRanges | null;
+    getDirectDependents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getDependents} */
-    getDependents(): ICellRanges | null;
+    getDependents(): Promise<ICellRanges | null>;
     get [Symbol.toStringTag](): string;
 }
 //# sourceMappingURL=NamedCellRange.d.ts.map

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

@@ -1,14 +1,22 @@
 import { IRange } from '@sheetxl/primitives';
 import { INamedRange, ICellRanges } from '../cellRange';
 import { SheetRange, SheetRangeOptions } from './SheetRange';
-import { ISheetInternal } from './Sheet';
+import { IWorksheetInternal } from './Worksheet';
 export declare class NamedRange extends SheetRange implements INamedRange {
     readonly isINamedRange: true;
     private _id;
     private _name;
     /** The name's OWN extent resolver — see {@link getRanges}. */
     private _rangesResolver;
-    constructor(id: string, name: string, coords: IRange.FixableCoords, internal: ISheetInternal, options: SheetRangeOptions, getRanges?: (() => ICellRanges | null) | null);
+    constructor(id: string, name: string, coords: IRange.FixableCoords, internal: IWorksheetInternal, options: SheetRangeOptions, getRanges?: (() => ICellRanges | null) | null);
+    /**
+     * {@inheritDoc ICellRange.getCoords}
+     *
+     * @remarks
+     * The coords are the NAME's (its first area, wherever that is) while the bound sheet is the one
+     * that asked, so a scope here is not the bound sheet's name and is handed back as resolved.
+     */
+    getCoords(): Readonly<IRange.FixableCoords>;
     /** {@inheritDoc INamedRange.getId} */
     getId(): string;
     /** {@inheritDoc INamedRange.getName} */

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

@@ -0,0 +1,114 @@
+import { ITypes } from '../type';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { IColor } from '../color';
+import { IWorkbook } from '../workbook';
+import { IStyleCollection } from '../style';
+import { IEmbeddedPart } from '../io/IEmbeddedPart';
+import { ListenerEmitter } from '../listener/ListenerEmitter';
+import { ISheet } from './ISheet';
+import { IOpaqueSheet } from './IOpaqueSheet';
+/**
+ * Implementation of {@link IOpaqueSheet}.
+ *
+ * @remarks
+ * Holds the part as read. Its tab (name, place, visibility) is the workbook's, reached through
+ * {@link OpaqueSheet.Container}; its tab color is its own.
+ *
+ * @internal
+ */
+export declare class OpaqueSheet implements IOpaqueSheet {
+    protected _kind: IOpaqueSheet.Kind;
+    protected _id: string;
+    protected _part: IEmbeddedPart;
+    protected _tabColor: IColor | null;
+    protected _styles: IStyleCollection;
+    protected _transactions: ITransaction.IStore;
+    protected _workbook: IWorkbook | null;
+    protected _container: OpaqueSheet.Container;
+    protected _emitter: ListenerEmitter<ISheet, ISheet.IListeners>;
+    protected _closed: boolean;
+    constructor(options: OpaqueSheet.ConstructorOptions);
+    /** {@inheritDoc IOpaqueSheet.getKind} */
+    getKind(): IOpaqueSheet.Kind;
+    /** {@inheritDoc ISheet.getId} */
+    getId(): string;
+    /** {@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.getIndex} */
+    getIndex(): number;
+    /** {@inheritDoc ISheet.setIndex} */
+    setIndex(index: number, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ISheet.getTabColor} */
+    getTabColor(): IColor;
+    /** {@inheritDoc ISheet.setTabColor} */
+    setTabColor(color: IColor | string | null): this;
+    /** {@inheritDoc ISheet.getWorkbook} */
+    getWorkbook(): IWorkbook | null;
+    /** {@inheritDoc ISheet.select} */
+    select(options?: ITypes.SelectOptions): Promise<this>;
+    /** {@inheritDoc ISheet.delete} */
+    delete(): void;
+    /** {@inheritDoc ISheet.isDeleted} */
+    isDeleted(): boolean;
+    /** {@inheritDoc ISheet.addListeners} */
+    addListeners(listeners: ISheet.IListeners, options?: IListener.Options): IListener.Remove;
+    /** {@inheritDoc ISheet.close} */
+    close(): void;
+    /** {@inheritDoc ISheet.isClosed} */
+    isClosed(): boolean;
+    /**
+     * The sheet's part as read.
+     * @internal
+     */
+    _getPart(): IEmbeddedPart;
+    /**
+     * Announces a change to the sheet's tab that the workbook made.
+     * @internal
+     */
+    _notify(key: keyof ISheet.Events): void;
+    protected _assertOpen(): void;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ISheet.isISheet} */
+    get isISheet(): true;
+    /** {@inheritDoc IOpaqueSheet.isIOpaqueSheet} */
+    get isIOpaqueSheet(): true;
+}
+/**
+ * {@inheritDoc OpaqueSheet}
+ * @internal
+ */
+export declare namespace OpaqueSheet {
+    /**
+     * The workbook side of an opaque sheet's tab.
+     */
+    interface Container {
+        getName(): string;
+        setName(name: string, options?: ITransaction.OperationOptions): void;
+        getVisibility(): ISheet.Visibility;
+        setVisibility(visibility: ISheet.Visibility, options?: ITransaction.OperationOptions): void;
+        getIndex(): number;
+        setIndex(index: number, options?: ITransaction.OperationOptions): void;
+        requestSelect(options?: ITypes.SelectOptions): Promise<boolean>;
+        /** `false` once the workbook no longer lists the sheet. */
+        isAttached(): boolean;
+    }
+    interface ConstructorOptions {
+        kind: IOpaqueSheet.Kind;
+        id: string;
+        part: IEmbeddedPart;
+        tabColor?: string | null;
+        styles: IStyleCollection;
+        transactions: ITransaction.IStore;
+        workbook?: IWorkbook | null;
+        container: Container;
+    }
+}
+//# sourceMappingURL=OpaqueSheet.d.ts.map

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

@@ -3,18 +3,18 @@ import { Size, Rectangle } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { IProperties, ITypes } from '../type';
 import { NumberFormat } from '../numFmt';
-import { ITextFrame } from '../text';
+import { ITextFrame, IRichText } from '../text';
 import { ITable } from '../table';
 import { IDataValidation } from '../dataValidation';
 import { IHyperlink } from '../hyperlink';
 import { ICalculation } from '../calculation';
 import { IComment } from '../comment';
-import { IStyle, IStyleCollection } from '../style';
+import { ICellStyle, IStyleCollection } from '../style';
 import { ICell, ICellProtection } from '../cell';
 import { ICellRanges, ICellRange } from '../cellRange';
-import { ISheetProtection } from '../sheetProtection';
+import { IWorksheetProtection } from '../sheetProtection';
 import { ISheetHeader } from '../sheetHeader';
-import { ISheet } from './ISheet';
+import { IWorksheet } from './IWorksheet';
 import { RangeState } from './_SheetStateTypes';
 import { SpillEntry } from '../calculation/spatial';
 import { CellStyleUpdater } from './style/SheetCellStyle';
@@ -26,8 +26,10 @@ import { IConditionalFormat } from '../conditionalFormat';
 export interface ResolvedCellModifiers {
     type: ScalarType | undefined;
     value: Scalar | null | undefined;
-    style: IStyle.Update | null | undefined;
+    style: ICellStyle.Update | null | undefined;
+    impliedStyle: ICellStyle.Update | undefined;
     hyperlink: IHyperlink.Update | undefined;
+    comments: IComment.Update | undefined;
     formula: string | null | undefined;
     stringToParse: string | null | undefined;
 }
@@ -51,20 +53,31 @@ interface Cache<K, V> {
  * // TODO - remove style dependency and see if we can remove it.
  */
 export declare function resolveCellModifiers(runtime: IRuntime, update: ICell.Update, optionsFromString?: ICell.ModifiersFromStringOptions | null, resolvedStringCache?: Map<string, ICell.Modifiers> | null, // assumes the same fromStringOptions is used
-isParsingCustom?: boolean): ResolvedCellModifiers | undefined;
-export declare function csOverflowable(type: ScalarType, style: IStyle, prev?: boolean, next?: boolean): boolean;
+isParsingCustom?: boolean, destination?: IRange.CellCoords | null, quotePrefixOnly?: boolean): ResolvedCellModifiers | undefined;
+/**
+ * The decorations (data bar, icon set) a cell's conditional rules draw — the walk behind
+ * {@link SheetCell.getConditionalDecorations}, without a cell.
+ *
+ * @remarks
+ * `getStyle` is a thunk, not a style: only a matched icon set consults it (to drop the icon for
+ * rotated/stacked text), and resolving a style eagerly for every cell of a rule's range is exactly
+ * what the callers — the cell's own lazy resolution, and autoFit's per-cell scan — must not pay.
+ */
+export declare function csConditionalDecorations(conditionals: IConditionalFormat | IConditionalFormat[] | null | undefined, rowIndex: number, colIndex: number, value: Scalar, getStyle: () => ICellStyle): Readonly<IConditionalFormat.Decorations>;
+export declare const csIconGutter: (style: ICellStyle) => number;
+export declare function csOverflowable(type: ScalarType, style: ICellStyle, prev?: boolean, next?: boolean): boolean;
 /**
  * Updates the overflow calc and returns a range if overflowed
  * @internal
  */
-export declare function calcTextOverflow(rowIndex: number, colIndex: number, type: ScalarType, style: IStyle, value: Scalar, prev: IRange.CellCoords | null, next: IRange.CellCoords | null, continuousCoords: IRange.Coords | null, cellOptions: SheetCellOptions): ICell.HorizontalOverflow | null;
+export declare function calcTextOverflow(rowIndex: number, colIndex: number, type: ScalarType, style: ICellStyle, value: Scalar, prev: IRange.CellCoords | null, next: IRange.CellCoords | null, continuousCoords: IRange.Coords | null, cellOptions: SheetCellOptions): ICell.HorizontalOverflow | null;
 /** Guaranteed to never return null */
 export declare function csStyle(value: Scalar, range: IRange.Coords | null, intersection: RangeState.Intersection | null, options: SheetCellOptions, direct: boolean, 
 /**
  * The range the style was QUERIED for, when wider than `range` (which is the cell it
  * materializes at). Only the inner border rules read it — see `CreateCellStyleOptions.extent`.
  */
-extent?: IRange.Coords): IStyle;
+extent?: IRange.Coords): ICellStyle;
 /**
  * Is `coords` spilled INTO — covered by a spill but not the ANCHOR that owns it?
  *
@@ -101,8 +114,8 @@ export interface BestFitViewOptions {
      */
     formulaText?: string;
 }
-export declare function csBestFit(type: ScalarType, style: IStyle, value: Scalar, options: SheetCellOptions, colWidth: number, isMinContent: boolean, isRowOnly: boolean, // if true we only measure the height
-customHash?: string | null, cache?: Cache<string, Readonly<Partial<Size>>>, view?: BestFitViewOptions): Readonly<Partial<Size>> | null;
+export declare function csBestFit(type: ScalarType, style: ICellStyle, value: Scalar, options: SheetCellOptions, colWidth: number, isMinContent: boolean, isRowOnly: boolean, // if true we only measure the height
+iconGutter?: number, customHash?: string | null, cache?: Cache<string, Readonly<Partial<Size>>>, view?: BestFitViewOptions): Readonly<Partial<Size>> | null;
 /**
  * A coords-keyed cache of resolved `ICell`s for hot read paths (rendering).
  *
@@ -111,6 +124,8 @@ customHash?: string | null, cache?: Cache<string, Readonly<Partial<Size>>>, view
  * (see `invalidateCaches` in `Sheet`). `LRUCache` satisfies this shape.
  */
 export interface RenderCellCache {
+    /** The number of cells cached. */
+    readonly size: number;
     get(key: number): ICell | undefined;
     set(key: number, value: ICell): void;
     clear(): void;
@@ -120,14 +135,20 @@ export interface SheetCellOptions {
     getRange(address: ICellRange.Address): ICellRange | null;
     getRanges: (address: ICellRanges.Address) => ICellRanges | null;
     getCalcGrid?(): ICalcGrid;
+    /** The engine's status; see `Formula.ConstructorOptions.getCalculationStatus`. */
+    getCalculationStatus?(): ICalculation.Status;
     /**
      * Calculation-graph neighbors — the same engine `ICellRange` uses, which is the point: the calc
      * grid answers in calc currency (grid stableIds, and virtual grids for named formulas) and it is
      * this seam that translates them to sheet names and drops what is not a sheet. Going at the grid
      * directly leaks a stableId into an address, where it prints as `#REF!`.
      */
-    dependencyRanges?(coords: IRange.Coords, kind: 'precedents' | 'dependents', direct: boolean): ICellRanges | null;
-    doBatchCalcGrid?(callback: (calcGrid: ICalcGrid) => IRange.Coords, options?: string | ITransaction.OperationOptions): void;
+    dependencyRanges?(coords: IRange.Coords, kind: 'precedents' | 'dependents', direct: boolean): Promise<ICellRanges | null>;
+    /** The error checks that fire at a cell, from the sheet's anomalies map. */
+    getAnomalies?(coords: IRange.CellCoords): readonly ICell.Anomaly[];
+    /** The cell's role, from the sheet's role map. */
+    getRole?(coords: IRange.CellCoords): ICell.Role | null;
+    doBatchCalcGrid?(callback: (calcGrid: ICalcGrid) => Promise<IRange.Coords | null>, options?: string | ITransaction.OperationOptions): Promise<void>;
     /**
      * Resolve a sheet's internal stableId (rename-safe) to its display name, or `null`. Threaded into
      * {@link Formula.ConstructorOptions} so a committed formula's cross-sheet references resolve at the
@@ -144,11 +165,11 @@ export interface SheetCellOptions {
      * into {@link Formula.ConstructorOptions.createAt}, whose contract this must match.
      */
     createAt?(text: string, coords: IRange.CellCoords): ICalculation.IFormula | null;
-    sheet: ISheet;
+    sheet: IWorksheet;
     styles: IStyleCollection;
-    normalStyleRanged: IProperties.ICellRanged<IStyle.Properties>;
+    normalStyleRanged: IProperties.ICellRanged<ICellStyle.Properties>;
     nextContentful(cell: IRange.CellCoords, limit: number, isLeft?: boolean): number;
-    getProtection(): ISheetProtection;
+    getProtection(): IWorksheetProtection;
     colHeaders?: ISheetHeader;
     styleUpdater?: CellStyleUpdater;
     opener(url: string, options?: ICellRange.SelectOptions | null, target?: string, features?: string): Promise<boolean>;
@@ -169,22 +190,35 @@ export declare class SheetCell implements ICell {
     protected _t: ScalarType;
     protected _v: Scalar;
     protected _d: Date | null | undefined;
+    protected _dfmt: string | null;
     protected _column: ITable.IColumn | null | undefined;
     protected _cd: Readonly<IConditionalFormat.Decorations> | undefined;
-    protected _s: IStyle | undefined;
-    protected _sd: IStyle | undefined;
+    protected _s: ICellStyle | undefined;
+    protected _sd: ICellStyle | undefined;
     constructor(options: SheetCellOptions, coords: IRange.CellCoords | null, type?: ScalarType, value?: Scalar, intersection?: RangeState.Intersection | null, p?: IRange.CellCoords | null, // prev
     n?: IRange.CellCoords | null);
+    /**
+     * The interop date, resolved on first ask. `null` when this cell isn't a date.
+     *
+     * @remarks
+     * The serial converted, gated on the format's category — which is all `NumberFormat.Parsed.asDate`
+     * is. Going through `getNumberFormat` would also resolve the cell's style and render its display
+     * text and runs, none of which the date is read from, and this is on `getInteropType`'s path: an
+     * interop scan pays it per cell.
+     */
+    protected _getDate(): Date | null;
     /** {@inheritDoc ICell.getRange} */
     getRange(): ICellRange;
     /** {@inheritDoc ICell.isEqual} */
     isEqual(other: ICell): boolean;
     /** {@inheritDoc ICell.getCoords} */
     getCoords(): IRange.CellCoords;
+    /** {@inheritDoc ICell.getA1} */
+    getA1(): string;
     /** {@inheritDoc ICell.getAddress} */
     getAddress(r1c1?: boolean): string;
-    /** {@inheritDoc ICell.getSheet} */
-    getSheet(): ISheet;
+    /** {@inheritDoc ICell.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc ICell.select} */
     select(options?: ITypes.SelectOptions): Promise<boolean>;
     /** {@inheritDoc ICell.getColumn} */
@@ -216,29 +250,35 @@ export declare class SheetCell implements ICell {
     /** {@inheritDoc ICell.getInsets} */
     getInsets(): Rectangle;
     /**
-     * The leading-edge width an icon-set decoration reserves, or `0` for a cell without one.
+     * The leading-edge width this cell's icon-set decoration reserves, or `0` for a cell without one.
      *
      * @remarks
-     * The icon is a square of the cell's LINE HEIGHT drawn at the leading inset — where the first
-     * glyph of left-aligned text would start — and the text resumes one leading inset after it. So
-     * the reservation is the icon plus that second inset, and both terms are already font-sized: a
-     * larger font reserves proportionally more and gets a proportionally larger icon.
-     *
-     * Both are properties of the STYLE, never of the value, so the gutter cannot shift as the cell is
-     * edited — which is what lets whatever draws the icon place it from the same two numbers instead
-     * of being told where the gutter ended. Measured on the empty string because the measurer keeps
-     * THAT one globally, keyed by font: the line height is a font metric, and reading it this way
-     * outlives the styles it is read through (see {@link calcAccountingBottomInset}, same idiom).
+     * See {@link csIconGutter} for what the reservation is made of. Every measurement of the cell —
+     * insets, best-fit, the editor's caret — reads it from here, so they cannot disagree with the
+     * icon layer, which places the icon from the same two style numbers.
      */
     protected _iconGutter(): number;
     /** {@inheritDoc ICell.getTextFrame} */
     getTextFrame(showFormula?: boolean): ITextFrame | null;
     /** {@inheritDoc ICell.getTextPlacement} */
     getTextPlacement(size: Size, useFormula?: boolean): ICell.TextPlacement | null;
-    /** {@inheritDoc ICell.getFormula} */
+    /**
+     * {@inheritDoc ICell.getFormula}
+     *
+     * @remarks
+     * Answered from the sheet's own formula entry, in every engine state: the text is there the
+     * moment it is set, the compiled block when the engine vends it. The handle reads the entry, so
+     * one taken before the vend is fully functional after it (`IFormula.isCompiled`).
+     */
     getFormula(): ICalculation.IFormula | null;
     /** {@inheritDoc ICell.getFormulaText} */
     getFormulaText(options?: ICalculation.FormulaTextOptions): string | null;
+    /**
+     * The formula's stored text, without the leading `=` — {@link ICalculation.IFormula.getExpression}
+     * without building the formula.
+     * @internal
+     */
+    getExpressionText(options?: ICalculation.FormulaTextOptions): string | null;
     /** {@inheritDoc ICell.getCalculationStatus} */
     getCalculationStatus(): ICalculation.ResultStatus;
     /**
@@ -250,13 +290,13 @@ export declare class SheetCell implements ICell {
      */
     private _dependencyRanges;
     /** {@inheritDoc ICell.getDirectDependents} */
-    getDirectDependents(): ICellRanges;
+    getDirectDependents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICell.getDirectPrecedents} */
-    getDirectPrecedents(): ICellRanges;
+    getDirectPrecedents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICell.getDependents} */
-    getDependents(): ICellRanges;
+    getDependents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICell.getPrecedents} */
-    getPrecedents(): ICellRanges;
+    getPrecedents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICell.getValue} */
     getValue(): Scalar;
     /** {@inheritDoc ICell.getType} */
@@ -266,9 +306,9 @@ export declare class SheetCell implements ICell {
     /** {@inheritDoc ICell.getInteropType} */
     getInteropType(): InteropScalarType;
     /** {@inheritDoc ICell.getStyle} */
-    getStyle(direct?: boolean): IStyle;
+    getStyle(direct?: boolean): ICellStyle;
     /** {@inheritDoc ICell.createCell} */
-    createCell(update: ICell.Update): ICell;
+    createCell(update: ICell.Update, options?: ICell.CreateCellOptions): ICell;
     /**
      * A copy of this cell that reports `coords` as its merge.
      *
@@ -284,12 +324,22 @@ export declare class SheetCell implements ICell {
     getNumberFormat(numberFormat?: string): NumberFormat.Parsed;
     /** {@inheritDoc ICell.getDate} */
     getDate(): Date | null;
+    /** {@inheritDoc ICell.getFormattedValue} */
+    getFormattedValue(): string;
     /** {@inheritDoc ICell.getText} */
     getText(options?: ICell.GetTextOptions): string;
     /** {@inheritDoc ICell.getComments} */
-    getComments(): Readonly<IComment.Properties>;
+    getComments(): IComment | null;
+    /** {@inheritDoc ICell.isErrorIgnored} */
+    isErrorIgnored(check: ICell.ErrorCheck): boolean;
+    /** {@inheritDoc ICell.getAnomalies} */
+    getAnomalies(): readonly ICell.Anomaly[];
+    /** {@inheritDoc ICell.getRole} */
+    getRole(): ICell.Role | null;
     /** {@inheritDoc ICell.getHyperlink} */
     getHyperlink(): IHyperlink | null;
+    /** {@inheritDoc ICell.getRichText} */
+    getRichText(): IRichText.JSON | null;
     /** {@inheritDoc ICell.getErrors} */
     getErrors(): readonly string[];
     /** {@inheritDoc ICell.getCircularReference} */
@@ -302,6 +352,13 @@ export declare class SheetCell implements ICell {
     isTopLeft(): boolean;
     /** {@inheritDoc ICell.getSpill} */
     getSpill(): ICellRange | null;
+    /** {@inheritDoc ICell.getSpillKind} */
+    getSpillKind(): ITypes.FormulaArrayKind | null;
+    /**
+     * The spill entry this cell answers for: the first live one, else a blocked one so the UI can
+     * still show the range it would have taken.
+     */
+    protected _getSpillEntry(): SpillEntry | null;
     /** {@inheritDoc ICell.isSpillOverflow} */
     isSpillOverflow(): boolean;
     get [Symbol.toStringTag](): string;