@sheetxl/sdk 0.8.0-beta.10 → 0.8.0-beta.12

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

@@ -1,40 +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}
+     * @param options {@link IWorksheetCollection.GetItemsOptions}
      */
-    getItems(options?: ISheetCollection.GetItemsOptions): ISheet[];
+    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 isISheetCollection: true;
+    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.
      */
@@ -64,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

@@ -2,7 +2,7 @@ import { ICellRanges } from '../cellRange';
 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
@@ -28,7 +28,7 @@ import { SheetRangeOptions } from './SheetRange';
 export declare class NamedCellRange extends NamedRange {
     private readonly _info;
     private readonly _namedFormulas;
-    constructor(info: NamedNodeInfo, namedFormulas: INamedFormulasCollection | null, internal: ISheetInternal, options: SheetRangeOptions | null);
+    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;
     /**

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

@@ -1,14 +1,14 @@
 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}
      *

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,7 +3,8 @@ 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 { IRichDataKind } from '../richData/IRichDataKind';
 import { ITable } from '../table';
 import { IDataValidation } from '../dataValidation';
 import { IHyperlink } from '../hyperlink';
@@ -12,14 +13,15 @@ import { IComment } from '../comment';
 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';
 import { ICalcGrid } from '../calculation/grid';
 import { IConditionalFormat } from '../conditionalFormat';
+import { ICellControl } from '../cellControl/ICellControl';
 /**
  * CellModifiers with all functions removed and all properties set and a type.
  */
@@ -53,7 +55,7 @@ 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, destination?: IRange.CellCoords | null): ResolvedCellModifiers | undefined;
+isParsingCustom?: boolean, destination?: IRange.CellCoords | null, quotePrefixOnly?: boolean, richData?: IRichDataKind.Context | null): ResolvedCellModifiers | undefined;
 /**
  * The decorations (data bar, icon set) a cell's conditional rules draw — the walk behind
  * {@link SheetCell.getConditionalDecorations}, without a cell.
@@ -64,25 +66,6 @@ isParsingCustom?: boolean, destination?: IRange.CellCoords | null): ResolvedCell
  * 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>;
-/**
- * The leading-edge width an icon-set decoration reserves for a cell of this style.
- *
- * @remarks
- * The icon is a square of the font box 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 font-sized: a larger font
- * reserves proportionally more and gets a proportionally larger icon.
- *
- * Both terms 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).
- *
- * Free-standing rather than a `SheetCell` member because measurement reaches it from two directions:
- * a resolved cell ({@link SheetCell.getInsets}), and autoFit's segment scan, which has a style and
- * a decoration but never builds the cell.
- */
 export declare const csIconGutter: (style: ICellStyle) => number;
 export declare function csOverflowable(type: ScalarType, style: ICellStyle, prev?: boolean, next?: boolean): boolean;
 /**
@@ -163,6 +146,10 @@ export interface SheetCellOptions {
      * directly leaks a stableId into an address, where it prints as `#REF!`.
      */
     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
@@ -180,11 +167,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<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>;
@@ -228,10 +215,12 @@ export declare class SheetCell implements ICell {
     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} */
@@ -242,6 +231,8 @@ export declare class SheetCell implements ICell {
     getDataValidation(): IDataValidation | null;
     /** {@inheritDoc ICell.getConditionalDecorations} */
     getConditionalDecorations(): Readonly<IConditionalFormat.Decorations>;
+    /** {@inheritDoc ICell.getControl} */
+    getControl(): ICellControl | null;
     /** {@inheritDoc ICell.getProtection} */
     getProtection(): ICellProtection;
     /** {@inheritDoc ICell.getTextOverflow} */
@@ -314,6 +305,12 @@ export declare class SheetCell implements ICell {
     getValue(): Scalar;
     /** {@inheritDoc ICell.getType} */
     getType(): ScalarType;
+    /**
+     * The type the value lays out as: rich data as what it shows ({@link RichDataRegistry.layoutTypeOf}:
+     * a hyperlink, a rich text or an entity is text, so it aligns left under General and spills into
+     * empty neighbors), everything else as itself.
+     */
+    protected _layoutType(): ScalarType;
     /** {@inheritDoc ICell.getInteropValue} */
     getInteropValue(): InteropScalar;
     /** {@inheritDoc ICell.getInteropType} */
@@ -337,12 +334,28 @@ 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(): 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;
+    /**
+     * The hyperlink set on the cell, never one its value presents: what a move or a copy carries
+     * to another cell (the value carries its own).
+     * @internal
+     */
+    getStoredHyperlink(): IHyperlink.Properties | null;
+    /** {@inheritDoc ICell.getRichText} */
+    getRichText(): IRichText.JSON | null;
     /** {@inheritDoc ICell.getErrors} */
     getErrors(): readonly string[];
     /** {@inheritDoc ICell.getCircularReference} */

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

@@ -9,6 +9,7 @@ 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';
@@ -18,8 +19,11 @@ import { IDataValidation, IDataValidationCollection } from '../dataValidation';
 import { IConditionalFormat } from '../conditionalFormat/IConditionalFormat';
 import { IConditionalFormatCollection } from '../conditionalFormat/IConditionalFormatCollection';
 import { IProtectedRange, IProtectedRangeCollection } from '../protectedRange';
-import { ISheet } from './ISheet';
-import { ISheetInternal } from './Sheet';
+import { ICellControl } from '../cellControl/ICellControl';
+import { ICellControlCollection } from '../cellControl/ICellControlCollection';
+import { IWorksheet } from './IWorksheet';
+import { IWorksheetInternal } from './Worksheet';
+import { WatchAnchor } from './_WatchAnchor';
 import { Outline } from '../outline/Outline';
 import { AutoFillProjection } from './_SheetAutoFillUtils';
 /**
@@ -29,8 +33,8 @@ import { AutoFillProjection } from './_SheetAutoFillUtils';
 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.
+ * notifies its own ranges once the results are in (a `'data'` event with no commit), which is the
+ * moment a watch has something new to report.
  */
 export interface SheetRangeOptions {
     readOnly?: string;
@@ -40,8 +44,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.
      *
@@ -115,7 +119,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} */
@@ -126,14 +130,25 @@ 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} */
@@ -169,7 +184,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 ICellRange.WatchOptions}.
+     * @param options See {@link WatchAnchor.Options}.
      *
      * @remarks
      * The fill lives here rather than on the public method deliberately: silently re-siting whatever
@@ -181,7 +196,7 @@ export declare class SheetRange implements ICellRange {
         onValues?: ICellRange.WatchCallback;
         onChange?: () => void;
         onRegistered?: (host: FormulaHost) => void;
-    }, origin?: IRange.CellCoords, options?: ICellRange.WatchOptions): IListener.Remove;
+    }, origin?: IRange.CellCoords, options?: WatchAnchor.Options): IListener.Remove;
     /** {@inheritDoc ICellRange.select} */
     select(options?: ICellRange.SelectOptions): Promise<this>;
     /** {@inheritDoc ICellRange.find} */
@@ -227,6 +242,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} */
@@ -281,6 +300,8 @@ export declare class SheetRange implements ICellRange {
     getDependents(): Promise<ICellRanges | null>;
     /** {@inheritDoc ICellRange.getRegions} */
     getRegions(features?: ICellRange.Feature | readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): ICellRegions;
+    /** {@inheritDoc ICellRange.getAnomalies} */
+    getAnomalies(options?: ICellRange.GetAnomaliesOptions): ICellRegions;
     /** {@inheritDoc ICellRange.isEntireRows} */
     isEntireRows(): boolean;
     /** {@inheritDoc ICellRange.isEntireColumns} */
@@ -322,6 +343,10 @@ export declare class SheetRange implements ICellRange {
     getUnlocked(options?: ICellRange.GetItemsOptions<IProtectedRangeCollection.GetItemsOptions>): IProtectedRange[];
     /** {@inheritDoc ICellRange.getConditionalFormats} */
     getConditionalFormats(options?: ICellRange.GetItemsOptions<IConditionalFormatCollection.GetItemsOptions>): IConditionalFormat[];
+    /** {@inheritDoc ICellRange.getControls} */
+    getControls(options?: ICellRange.GetItemsOptions<ICellControlCollection.GetItemsOptions>): ICellControl[];
+    /** {@inheritDoc ICellRange.setControl} */
+    setControl(control: ICellControl.JSON | null, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc ICellRange.getDataValidations} */
     getDataValidations(options?: ICellRange.GetItemsOptions<IDataValidationCollection.GetItemsOptions>): IDataValidation[];
     /** {@inheritDoc ICellRange.getComments} */
@@ -336,8 +361,8 @@ export declare class SheetRange implements ICellRange {
     isReadOnly(): boolean;
     /** {@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} */
@@ -360,10 +385,18 @@ export declare class SheetRange implements ICellRange {
     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.Update, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc ICellRange.getStyle} */
     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} */
@@ -400,9 +433,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} */
@@ -423,9 +458,11 @@ 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} */

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

@@ -5,8 +5,8 @@ import { ICell } from '../cell';
 import { ICellRanges, ICellRange, ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
 import { ICalculation } from '../calculation';
 import { ICellStyle } from '../style';
-import { ISheet } from '../sheet';
-import { ISheetInternal } from './Sheet';
+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,15 +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[];
     /**
      * 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 (ISheet | null)[] | null;
-    constructor(coords: readonly (IRange.FixableCoords | string | ICellRange)[], internal: ISheetInternal, options?: SheetRangesOptions);
+    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
@@ -67,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.
      *
@@ -76,7 +76,7 @@ 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[];
+    protected _readCoordsByScope(op: (internal: IWorksheetInternal, coords: IRange.FixableCoords[]) => readonly IRange.Coords[]): readonly IRange.Coords[];
     /**
      * {@inheritDoc ICellRanges.getCoords}
      *
@@ -98,7 +98,7 @@ export declare class SheetRanges implements ICellRanges {
     /** {@inheritDoc ICellRange.calculate} */
     calculate(): this;
     /** {@inheritDoc ICellRanges.addListener} */
-    addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
+    addListener(listener: ICellRange.Listener<ICellRanges>, options?: ICellRange.ListenerOptions): IListener.Remove;
     /** {@inheritDoc ICellRanges.addWatch} */
     addWatch(formula: ICalculation.IFormula | string, callback: ICellRanges.WatchCallback, options?: ICellRange.WatchOptions): IListener.Remove;
     /**
@@ -155,7 +155,7 @@ export declare class SheetRanges implements ICellRanges {
     /** {@inheritDoc ICellRanges.clear} */
     clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
     /** {@inheritDoc ICellRanges.setValue} */
-    setValue(value: ICellRange.ScalarUpdate, options?: ICellRange.SetValuesOptions): this;
+    setValue(value: ICellRange.InteropScalarUpdate, options?: ICellRange.SetValuesOptions): this;
     /** {@inheritDoc ICellRanges.getStyle} */
     getStyle(): ICellStyle;
     /** {@inheritDoc ICellRanges.merge} */
@@ -222,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;