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

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

@@ -1,28 +1,39 @@
 import { IRange, Scalar, IRangeStats, InteropScalar } from '@sheetxl/primitives';
-import { Size } from '@sheetxl/utils';
+import { Size, RunCoords } from '@sheetxl/utils';
 import { ITransaction } from '../transaction';
 import { IListener } from '../listener';
 import { ICell } from '../cell';
 import { ICellRange, ICellRegions, ICellRanges, ICellHeaderRange } from '../cellRange';
-import { IComment } from '../comment';
-import { IStyle } from '../style';
+import { IComment, ICommentCollection } from '../comment';
+import { ICellStyle } from '../style';
 import { ITable, ITableCollection } from '../table';
 import { IMovable, IMovableCollection } from '../movable';
 import { IHyperlink } from '../hyperlink';
+import { IRichText } from '../text';
 import { ICondition } from '../condition';
 import { ISort } from '../sort';
+import { IAutoFill } from '../autoFill';
 import { ICalculation } from '../calculation';
+import { FormulaHost } from '../calculation/grid';
 import { IDataValidation, IDataValidationCollection } from '../dataValidation';
 import { IConditionalFormat } from '../conditionalFormat/IConditionalFormat';
 import { IConditionalFormatCollection } from '../conditionalFormat/IConditionalFormatCollection';
-import { ISheet } from './ISheet';
-import { ISheetInternal } from './Sheet';
-import { AutoFillProjection } from './_SheetMutations';
+import { IProtectedRange, IProtectedRangeCollection } from '../protectedRange';
+import { IWorksheet } from './IWorksheet';
+import { IWorksheetInternal } from './Worksheet';
+import { WatchAnchor } from './_WatchAnchor';
+import { Outline } from '../outline/Outline';
+import { AutoFillProjection } from './_SheetAutoFillUtils';
 /**
  * The empty feature selection — the raw-value fast path.
  * @internal
  */
 export declare const _NoFeatures: readonly ICellRange.Feature[];
+/**
+ * A watch listens for the VALUE landing, not for the transaction that caused it — a recalculation
+ * notifies its own ranges once the results are in (`trigger: 'calc'`), which is the moment a watch
+ * has something new to report.
+ */
 export interface SheetRangeOptions {
     readOnly?: string;
     getOptions: ICellRange.GetRangeOptions;
@@ -31,8 +42,8 @@ export declare class SheetRange implements ICellRange {
     protected _coords: Readonly<IRange.FixableCoords>;
     protected _readOnly: string | null;
     protected _options: SheetRangeOptions | undefined;
-    protected _internal: ISheetInternal;
-    constructor(coords: IRange.FixableCoords, internal: ISheetInternal, options?: SheetRangeOptions);
+    protected _internal: IWorksheetInternal;
+    constructor(coords: IRange.FixableCoords, internal: IWorksheetInternal, options?: SheetRangeOptions);
     /**
      * The read options this range carries — set at creation and merged through every derivation.
      *
@@ -42,7 +53,16 @@ export declare class SheetRange implements ICellRange {
      * @internal
      */
     protected _getStickyOptions(): ICellRange.GetRangeOptions | undefined;
-    /** {@inheritDoc ICellRange.getCoords} */
+    /**
+     * {@inheritDoc ICellRange.getCoords}
+     *
+     * @remarks
+     * A `scope` is the sheet's display name, and a range that carries one is bound to the sheet
+     * INSTANCE it names, so the name is read from the sheet rather than from the address the range
+     * was parsed from. A rename leaves the cells where they are; only the qualifier changes, and it
+     * changes here, the same as a formula that references the sheet re-images with the new name. A
+     * bare range has no qualifier and nothing to re-read.
+     */
     getCoords(): Readonly<IRange.FixableCoords>;
     /** @internal */
     protected _createRange(coords: Readonly<IRange.FixableCoords>, getOptions?: ICellRange.GetRangeOptions): this;
@@ -70,6 +90,14 @@ export declare class SheetRange implements ICellRange {
     protected _deriveRange(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions, callback?: (newCoords: IRange.Coords, origCoords: IRange.Coords) => IRange.Coords | null): this | null;
     /** @internal */
     protected _validateMaxSize(maxSize?: number): void;
+    /**
+     * The read of a one-cell range, answered from the cell the way `getValue()` / `getCell()` answer
+     * it: no used range and no iterator, so a read made while writes are held does not make them.
+     *
+     * @returns `undefined` if the range is more than one cell or an option can change the answer.
+     * @internal
+     */
+    protected _readSingleCell<T>(options: ICellRange.GetValuesOptions | undefined, read: (rowIndex: number, colIndex: number) => T): T[][] | undefined;
     /** {@inheritDoc ICellRange.entries} */
     entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
     /** {@inheritDoc ICellRange[Symbol.iterator]} */
@@ -89,7 +117,7 @@ export declare class SheetRange implements ICellRange {
     /** {@inheritDoc ICellRange.setFormula} */
     setFormula(value: ICellRange.ScalarUpdate, options?: ICellRange.SetValuesOptions): this;
     /** @internal */
-    protected _setValueOrValues(value: ICellRange.ValuesUpdate, options?: ICellRange.SetValuesOptions): this;
+    protected _setValueOrValues(value: ICellRange.ValuesUpdate | ICellRange.ScalarUpdate, options?: ICellRange.SetValuesOptions): this;
     /** {@inheritDoc ICellRange.getValues} */
     getValues(options?: ICellRange.GetValuesOptions): Scalar[][];
     /** {@inheritDoc ICellRange.getValuesRange} */
@@ -100,20 +128,53 @@ export declare class SheetRange implements ICellRange {
     getInteropValues(options?: ICellRange.GetValuesOptions): InteropScalar[][];
     /** {@inheritDoc ICellRange.getValue} */
     getValue(): Scalar;
+    /** {@inheritDoc ICellRange.getText} */
+    getText(options?: ICell.GetTextOptions): string;
+    /** {@inheritDoc ICellRange.getTexts} */
+    getTexts(): string[][];
     /** {@inheritDoc ICellRange.getInteropValue} */
     getInteropValue(): InteropScalar;
     /** {@inheritDoc ICellRange.calculate} */
     calculate(full: boolean): this;
     /** {@inheritDoc ICellRange.getCells} */
     getCells(options?: ICellRange.GetValuesOptions): ICell[][];
+    /**
+     * The address `getCell` was given, with Office Scripts' `(row, column)` offsets from the top left
+     * turned into sheet coordinates.
+     */
+    protected _getCellAddress(address?: ICell.Address | number, column?: number): ICell.Address | undefined;
     /** {@inheritDoc ICellRange.getCell} */
     getCell(address?: ICell.Address): ICell;
+    /** @deprecated */
+    getCell(row: number, column: number): ICell;
     /** {@inheritDoc ICellRange.getFormula} */
     getFormula(address?: ICell.Address): ICalculation.IFormula;
+    /** {@inheritDoc ICellRange.getFormulas} */
+    getFormulas(): string[][];
+    /** {@inheritDoc ICellRange.setFormulas} */
+    setFormulas(formulas: readonly string[][], options?: ICellRange.SetValuesOptions): this;
+    /** {@inheritDoc ICellRange.getNumberFormat} */
+    getNumberFormat(): string;
+    /** {@inheritDoc ICellRange.getNumberFormats} */
+    getNumberFormats(): string[][];
+    /** {@inheritDoc ICellRange.setNumberFormat} */
+    setNumberFormat(numFmt: string | null, options?: ICellStyle.UpdateOptions): this;
+    /** {@inheritDoc ICellRange.setNumberFormats} */
+    setNumberFormats(formats: readonly string[][], options?: ICellRange.UpdateCellsOptions): this;
+    /**
+     * Throws if the whole range is larger than a dense read allows.
+     * @internal
+     */
+    protected _validateDenseSize(): void;
+    /**
+     * A row-major array in the shape of the range with every cell set to `fill`.
+     * @internal
+     */
+    protected _createDense<T>(fill: T): T[][];
     /** {@inheritDoc ICellRange.createFormula} */
-    createFormula(expression: string): ICalculation.IFormula;
+    createFormula(expression: string, options?: ICalculation.CreateFormulaOptions): ICalculation.IFormula;
     /** {@inheritDoc ICellRange.addWatch} */
-    addWatch(formula: ICalculation.IFormula | string, callback: ICellRange.WatchCallback): IListener.Remove;
+    addWatch(formula: ICalculation.IFormula | string, callback: ICellRange.WatchCallback, options?: ICellRange.WatchOptions): IListener.Remove;
     /**
      * {@link addWatch}, plus the origin an area of a multi-area watch shares with its siblings.
      *
@@ -121,6 +182,7 @@ export declare class SheetRange implements ICellRange {
      *               range's own top-left, and a formula anchored anywhere else is an error. Supplied
      *               by {@link ICellRanges.addWatch}, it is the shared origin, and the formula is
      *               FILLED from there to this range instead.
+     * @param options See {@link WatchAnchor.Options}.
      *
      * @remarks
      * The fill lives here rather than on the public method deliberately: silently re-siting whatever
@@ -131,7 +193,8 @@ export declare class SheetRange implements ICellRange {
     _addWatch(formula: ICalculation.IFormula | string, handlers: {
         onValues?: ICellRange.WatchCallback;
         onChange?: () => void;
-    }, origin?: IRange.CellCoords): IListener.Remove;
+        onRegistered?: (host: FormulaHost) => void;
+    }, origin?: IRange.CellCoords, options?: WatchAnchor.Options): IListener.Remove;
     /** {@inheritDoc ICellRange.select} */
     select(options?: ICellRange.SelectOptions): Promise<this>;
     /** {@inheritDoc ICellRange.find} */
@@ -177,6 +240,10 @@ export declare class SheetRange implements ICellRange {
     private _extendedAdjacent;
     /** {@inheritDoc ICellRange.getEntireRows} */
     getEntireRows(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
+    /** {@inheritDoc ICellRange.getEntireRow} */
+    getEntireRow(): this;
+    /** {@inheritDoc ICellRange.getEntireColumn} */
+    getEntireColumn(): this;
     /** {@inheritDoc ICellRange.getEntireColumns} */
     getEntireColumns(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
     /** {@inheritDoc ICellRange.getRowHeaders} */
@@ -222,17 +289,17 @@ export declare class SheetRange implements ICellRange {
     /** {@inheritDoc ICellRange.getCounts} */
     getCounts(features?: ICellRange.Feature | readonly ICellRange.Feature[]): ICellRange.Counts;
     /** {@inheritDoc ICellRange.getDirectPrecedents} */
-    getDirectPrecedents(): ICellRanges | null;
+    getDirectPrecedents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getDirectDependents} */
-    getDirectDependents(): ICellRanges | null;
+    getDirectDependents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getPrecedents} */
-    getPrecedents(): ICellRanges | null;
+    getPrecedents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getDependents} */
-    getDependents(): ICellRanges | null;
+    getDependents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getRegions} */
     getRegions(features?: ICellRange.Feature | readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): ICellRegions;
-    /** {@inheritDoc ICellRange.getCount} */
-    getCount(type?: ICell.Content): number;
+    /** {@inheritDoc ICellRange.getAnomalies} */
+    getAnomalies(options?: ICellRange.GetAnomaliesOptions): ICellRegions;
     /** {@inheritDoc ICellRange.isEntireRows} */
     isEntireRows(): boolean;
     /** {@inheritDoc ICellRange.isEntireColumns} */
@@ -255,6 +322,8 @@ export declare class SheetRange implements ICellRange {
     getDefaultShiftAxis(): IRange.Axis;
     /** {@inheritDoc ICellRange.getDefaultSortCriteria} */
     getDefaultSortCriteria(axis?: IRange.Axis, cell?: ICell.Address): ISort.DefaultSortCriteria | null;
+    /** {@inheritDoc ICellRange.getDefaultAutoFillCriteria} */
+    getDefaultAutoFillCriteria(direction?: IRange.Direction, destination?: ICellRange.Address): IAutoFill.DefaultCriteria | null;
     /** {@inheritDoc ICellRange.getMerges} */
     getMerges(): IRange.Coords[];
     /**
@@ -268,10 +337,14 @@ export declare class SheetRange implements ICellRange {
     protected _itemQuery<T extends {
         ignoreHidden?: boolean;
     }>(options?: T): T;
+    /** {@inheritDoc ICellRange.getUnlocked} */
+    getUnlocked(options?: ICellRange.GetItemsOptions<IProtectedRangeCollection.GetItemsOptions>): IProtectedRange[];
     /** {@inheritDoc ICellRange.getConditionalFormats} */
     getConditionalFormats(options?: ICellRange.GetItemsOptions<IConditionalFormatCollection.GetItemsOptions>): IConditionalFormat[];
     /** {@inheritDoc ICellRange.getDataValidations} */
     getDataValidations(options?: ICellRange.GetItemsOptions<IDataValidationCollection.GetItemsOptions>): IDataValidation[];
+    /** {@inheritDoc ICellRange.getComments} */
+    getComments(options?: ICellRange.GetItemsOptions<ICommentCollection.GetItemsOptions>): IComment[];
     /** {@inheritDoc ICellRange.getTables} */
     getTables(options?: ICellRange.GetItemsOptions<ITableCollection.GetItemsOptions>): ITable[];
     /** {@inheritDoc ICellRange.getMovables} */
@@ -281,23 +354,43 @@ export declare class SheetRange implements ICellRange {
     /** {@inheritDoc ICellRange.isReadOnly} */
     isReadOnly(): boolean;
     /** {@inheritDoc ICellRange.addListener} */
-    addListener2(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
-    /** {@inheritDoc ICellRange.addListener} */
     addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
-    /** {@inheritDoc ICellRange.getSheet} */
-    getSheet(): ISheet;
+    /** {@inheritDoc ICellRange.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc ICellRange.autoFill} */
     autoFill(destination: ICellRange.Address, options?: ICellRange.AutoFillOptions): this;
     /** {@inheritDoc ICellRange.autoFit} */
     autoFit(options?: ICellRange.AutoFitOptions): this;
+    /** {@inheritDoc ICellRange.group} */
+    group(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICellRange.ungroup} */
+    ungroup(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    protected _changeOutlineLevels(axis: IRange.Axis | undefined, delta: 1 | -1, options?: ITransaction.OperationOptions): void;
+    /** {@inheritDoc ICellRange.showGroupDetails} */
+    showGroupDetails(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICellRange.hideGroupDetails} */
+    hideGroupDetails(axis?: IRange.Axis, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICellRange.clearGroups} */
+    clearGroups(axes?: IRange.AxisSelection, options?: ITransaction.OperationOptions): this;
+    protected _getOutline(): Outline;
+    protected _getRun(axis: IRange.Axis): RunCoords;
+    protected _resolveOutlineAxis(axis: IRange.Axis | undefined): IRange.Axis;
     /** {@inheritDoc ICellRange.clear} */
     clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc ICellRange.setHyperlink} */
     setHyperlink(hyperlink: IHyperlink.Update, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICellRange.setRichText} */
+    setRichText(runs: IRichText.Update, options?: ITransaction.OperationOptions): this;
+    /** {@inheritDoc ICellRange.setErrorIgnored} */
+    setErrorIgnored(check: ICell.ErrorCheck, ignored?: boolean, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc ICellRange.setComments} */
-    setComments(comments: IComment.Properties, options?: ITransaction.OperationOptions): this;
+    setComments(comments: IComment.Update, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc ICellRange.getStyle} */
-    getStyle(): IStyle;
+    getStyle(): ICellStyle;
+    /** {@inheritDoc ICellRange.getFormat} */
+    getFormat(): ICellStyle;
+    /** {@inheritDoc ICellRange.setStyle} */
+    setStyle(style: ICellStyle.Update, options?: ICellStyle.UpdateOptions): this;
     /** {@inheritDoc ICellRange.merge} */
     merge(options?: IRange.AxisSelection | ICellRange.MergeOptions): this;
     /** {@inheritDoc ICellRange.unmerge} */
@@ -321,6 +414,8 @@ export declare class SheetRange implements ICellRange {
     addTable(options?: ITableCollection.AddOptions | boolean): ITable;
     /** {@inheritDoc ICellRange.insertFrom} */
     insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
+    /** {@inheritDoc ICellRange.canInsertFrom} */
+    canInsertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): boolean;
     /** {@inheritDoc ICellRange.copyFrom} */
     copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
     /** {@inheritDoc ICellRange.delete} */
@@ -332,9 +427,11 @@ export declare class SheetRange implements ICellRange {
     /** {@inheritDoc ICellRange.filter} */
     filter(condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): Promise<this>;
     /** {@inheritDoc ICellRange.doBatch} */
-    doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): Promise<R> | R;
+    doBatch<R>(callback: (commit: ITransaction.ICommit, range: this) => R | Promise<R>, options?: string | ITransaction.OperationOptions): Promise<R> | R;
     /** {@inheritDoc ICellRange.createSparseBuilder} */
     createSparseBuilder(options?: ICellRange.SparseBuilderOptions): ICellRange.SparseBuilder;
+    /** {@inheritDoc ICellRange.getA1} */
+    getA1(): string;
     /** {@inheritDoc ICellRange.getAddress} */
     getAddress(r1c1?: boolean): string;
     /** {@inheritDoc ICellRange.toString} */
@@ -355,15 +452,21 @@ export declare class SheetRange implements ICellRange {
  */
 export declare class PreviewSheetRange extends SheetRange {
     private readonly _projection;
-    constructor(coords: IRange.FixableCoords, internal: ISheetInternal, projection: AutoFillProjection, getOptions?: ICellRange.GetRangeOptions);
+    constructor(coords: IRange.FixableCoords, internal: IWorksheetInternal, projection: AutoFillProjection, getOptions?: ICellRange.GetRangeOptions);
     /** {@inheritDoc ICellRange.getCell} */
     getCell(address?: ICell.Address): ICell;
+    /** @deprecated */
+    getCell(row: number, column: number): ICell;
     /** {@inheritDoc ICellRange.getCells} */
     getCells(options?: ICellRange.GetValuesOptions): ICell[][];
     /** {@inheritDoc ICellRange.getValues} */
     getValues(options?: ICellRange.GetValuesOptions): Scalar[][];
     /** {@inheritDoc ICellRange.getInteropValues} */
     getInteropValues(options?: ICellRange.GetValuesOptions): InteropScalar[][];
+    /** {@inheritDoc ICellRange.getFormulas} */
+    getFormulas(): string[][];
+    /** {@inheritDoc ICellRange.getNumberFormats} */
+    getNumberFormats(): string[][];
     /**
      * A `getValuesRange` on a projection would have to materialize every cell, defeating the point of
      * computing on demand — and it vends a live grid view, which a hypothetical has none of.

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

@@ -4,9 +4,9 @@ import { IListener } from '../listener';
 import { ICell } from '../cell';
 import { ICellRanges, ICellRange, ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
 import { ICalculation } from '../calculation';
-import { IStyle } from '../style';
-import { ISheet } from '../sheet';
-import { ISheetInternal } from './Sheet';
+import { ICellStyle } from '../style';
+import { IWorksheet } from '../sheet';
+import { IWorksheetInternal } from './Worksheet';
 import { SheetRange } from './SheetRange';
 export interface SheetRangesOptions {
     readOnly?: string;
@@ -17,7 +17,7 @@ export interface SheetRangesOptions {
  * @internal
  */
 interface ScopeGroup {
-    internal: ISheetInternal;
+    internal: IWorksheetInternal;
     /** The group's coords, scope STRIPPED — bare is the group's own sheet, as everywhere else. */
     coords: IRange.FixableCoords[];
 }
@@ -25,9 +25,15 @@ export declare class SheetRanges implements ICellRanges {
     protected _coords: readonly (IRange.FixableCoords | string | ICellRange)[];
     protected _readOnly: string | null;
     protected _options: SheetRangesOptions | undefined;
-    protected _internal: ISheetInternal;
+    protected _internal: IWorksheetInternal;
     protected _cacheRanges: ICellRange[];
-    constructor(coords: readonly (IRange.FixableCoords | string | ICellRange)[], internal: ISheetInternal, options?: SheetRangesOptions);
+    /**
+     * The sheet each scoped coord named when this set was built, by member index; `null` when no
+     * member is scoped. A string member or a range instance answers live on its own, and a bare
+     * coord is the anchor's.
+     */
+    protected _memberSheets: readonly (IWorksheet | null)[] | null;
+    constructor(coords: readonly (IRange.FixableCoords | string | ICellRange)[], internal: IWorksheetInternal, options?: SheetRangesOptions);
     /**
      * The read options these ranges carry — set at creation and merged through every derivation.
      * @internal
@@ -61,7 +67,7 @@ export declare class SheetRanges implements ICellRanges {
      * not the sheet's), which is what lets the fan-out stay one operation from the user's side.
      * @internal
      */
-    protected _writeByScope(op: (internal: ISheetInternal, coords: IRange.FixableCoords[]) => void, options?: ITransaction.OperationOptions): void;
+    protected _writeByScope(op: (internal: IWorksheetInternal, coords: IRange.FixableCoords[]) => void, options?: ITransaction.OperationOptions): void;
     /**
      * Runs a bulk read once per sheet and concatenates the coords, re-qualified against the anchor.
      *
@@ -70,9 +76,18 @@ export declare class SheetRanges implements ICellRanges {
      * say which sheet it is on, by the same rule the inputs follow.
      * @internal
      */
-    protected _readCoordsByScope(op: (internal: ISheetInternal, coords: IRange.FixableCoords[]) => readonly IRange.Coords[]): readonly IRange.Coords[];
-    /** {@inheritDoc ICellRanges.getCoords} */
+    protected _readCoordsByScope(op: (internal: IWorksheetInternal, coords: IRange.FixableCoords[]) => readonly IRange.Coords[]): readonly IRange.Coords[];
+    /**
+     * {@inheritDoc ICellRanges.getCoords}
+     *
+     * @remarks
+     * A member's `scope` is its sheet's display name, read from the sheet the member was bound to
+     * when the set was built, so a renamed sheet is spelled by its current name — see
+     * {@link SheetRange.getCoords}.
+     */
     getCoords(): readonly IRange.FixableCoords[];
+    /** Re-stamps every bound member whose sheet no longer goes by the name the coord carries. */
+    private _refreshScopes;
     private _resolveCoords;
     /** {@inheritDoc ICellRange[Symbol.iterator]} */
     [Symbol.iterator](): IterableIterator<Scalar>;
@@ -82,12 +97,10 @@ export declare class SheetRanges implements ICellRanges {
     select(options?: ICellRange.SelectOptions): Promise<this>;
     /** {@inheritDoc ICellRange.calculate} */
     calculate(): this;
-    /** {@inheritDoc ICellRange.addListener} */
-    addListener2(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
     /** {@inheritDoc ICellRanges.addListener} */
     addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
     /** {@inheritDoc ICellRanges.addWatch} */
-    addWatch(formula: ICalculation.IFormula | string, callback: ICellRanges.WatchCallback): IListener.Remove;
+    addWatch(formula: ICalculation.IFormula | string, callback: ICellRanges.WatchCallback, options?: ICellRange.WatchOptions): IListener.Remove;
     /**
      * Registers one per-area watch of some kind, all sharing this set's origin.
      * @internal
@@ -107,9 +120,9 @@ export declare class SheetRanges implements ICellRanges {
     /** {@inheritDoc ICellRanges.getFlattened} */
     getFlattened(options?: ICellRange.GetFlattenOptions): this;
     /** {@inheritDoc ICellRanges.getPrecedents} */
-    getPrecedents(entireSet?: boolean): ICellRanges | null;
+    getPrecedents(entireSet?: boolean): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRanges.getDependents} */
-    getDependents(entireSet?: boolean): ICellRanges | null;
+    getDependents(entireSet?: boolean): Promise<ICellRanges | null>;
     /**
      * Shared walk for {@link getPrecedents} / {@link getDependents}: ask each contiguous range for
      * its own neighbors and flatten the union (the grid dedupes within a single query; across
@@ -122,7 +135,7 @@ export declare class SheetRanges implements ICellRanges {
      * currency, which a direct `calcGrid` call does not do (a stableId reaching the address layer
      * prints as `#REF!`).
      */
-    protected _trace(dependents: boolean, entireSet: boolean): ICellRanges | null;
+    protected _trace(dependents: boolean, entireSet: boolean): Promise<ICellRanges | null>;
     /**
      * Re-expresses another collection's coords against THIS anchor.
      *
@@ -144,7 +157,7 @@ export declare class SheetRanges implements ICellRanges {
     /** {@inheritDoc ICellRanges.setValue} */
     setValue(value: ICellRange.ScalarUpdate, options?: ICellRange.SetValuesOptions): this;
     /** {@inheritDoc ICellRanges.getStyle} */
-    getStyle(): IStyle;
+    getStyle(): ICellStyle;
     /** {@inheritDoc ICellRanges.merge} */
     merge(options?: IRange.AxisSelection | ICellRange.MergeOptions): this;
     /** {@inheritDoc ICellRanges.unmerge} */
@@ -209,10 +222,12 @@ export declare class SheetRanges implements ICellRanges {
     isReadOnly(): boolean;
     /** {@inheritDoc ICellRanges.isInvalid} */
     isInvalid(): boolean;
+    /** {@inheritDoc ICellRanges.getA1} */
+    getA1(): string;
     /** {@inheritDoc ICellRanges.getAddress} */
     getAddress(r1c1?: boolean): string;
-    /** {@inheritDoc ICellRanges.getSheet} */
-    getSheet(): ISheet;
+    /** {@inheritDoc ICellRanges.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc ICellRanges.doBatch} */
     doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
     get [Symbol.toStringTag](): string;