@sheetxl/sdk 0.7.21 → 0.7.23-beta.2

package/types/src/cellRange/ICellRange.d.ts

@@ -0,0 +1,2509 @@
+import { FormulaError, IRange, Scalar, InteropScalar, IRangeStats } from '@sheetxl/primitives';
+import { Bounds, ReferenceableClipboard } from '@sheetxl/utils';
+import { ITypes } from '../type';
+import { IListener } from '../listener';
+import { ITransaction } from '../transaction';
+import { IHyperlink } from '../hyperlink';
+import { IComment } from '../comment';
+import { ISort } from '../sort';
+import { ICondition } from '../condition';
+import { IAutoFill } from '../autoFill';
+import { IStyle } from '../style';
+import { ICalculation } from '../calculation';
+import { ITable, ITableCollection } from '../table';
+import { IMovable, IMovableCollection } from '../movable';
+import { IDataValidation, IDataValidationCollection } from '../dataValidation';
+import { IConditionalFormat } from '../conditionalFormat/IConditionalFormat';
+import { IConditionalFormatCollection } from '../conditionalFormat/IConditionalFormatCollection';
+import { ISheet } from '../sheet';
+import { ICell } from '../cell';
+import { ICellRanges } from './ICellRanges';
+import { ICellRegions } from './ICellRegion';
+import { ICellHeaderRange } from './ICellHeaderRange';
+/**
+ * A {@link ICellRange} represents a rectangular collection of {@link ICell} within an {@link ISheet}.
+ *
+ * **Naming Conventions:** Methods usually adhere to the following conventions except
+ * when adhering to a idiomatic existing conventions of Typescript (for example `size` or 'length'):
+ *
+ * - Methods returning information about the range (e.g., width, count) use a `get` prefix.
+ * - Methods that transform the range's data into a different type use a `to` prefix (e.g., `toArray()`).
+ */
+export interface ICellRange {
+    /**
+     * Returns an immutable {@link IRange} snapshot of the cell range's current values.
+     *
+     * @remarks
+     * `IRange` is SheetXL's stateless value computation layer — it has no knowledge of
+     * the sheet, and the same logic runs identically in a browser, Node.js, or a Web Worker.
+     *
+     * This is the bridge between the live sheet (`ICellRange`) and pure value computation (`IRange`):
+     * - Pass the result to {@link setValues} or {@link setComputedValues} to write back to the sheet.
+     * - Use directly with formula functions and UDFs, which only operate on `IRange`.
+     *
+     * @see {@link https://www.sheetxl.com/docs/guides/concepts/two-ranges | ICellRange and IRange} for a full guide.
+     */
+    getValuesRange(): IRange;
+    /**
+     * Applies a transformation to the cell range's values and writes the result back to the sheet.
+     *
+     * @remarks
+     * Convenience wrapper around {@link getValuesRange} and {@link setValues}:
+     * ```ts
+     * setComputedValues(fn) ≡ this.setValues(fn(this.getValuesRange()))
+     * ```
+     * The callback receives the current values as an immutable {@link IRange},
+     * and the returned `IRange` is written back to the sheet.
+     *
+     * @param callback - A pure function that transforms the cell range's `IRange`.
+     *
+     * @see {@link https://www.sheetxl.com/docs/guides/concepts/two-ranges | ICellRange and IRange}
+     */
+    setComputedValues(callback: (range: IRange) => IRange, options?: ITransaction.OperationOptions): this;
+    /**
+     * Return an array of coords for all merges.
+     *
+     * * @returns An array of 'IRange.Coords` that contain merges.
+     */
+    getMerges(): IRange.Coords[];
+    /**
+     * Returns the {@link IConditionalFormat}s that overlap the range.
+     *
+     * @param options The filters of {@link IConditionalFormatCollection.getItems} without `address` —
+     * this range is the address.
+     *
+     * @remarks
+     * **Overlap, not containment.** A format anchored to `A1:D10` is returned for a query on `B2`;
+     * pass `fullyContained` for the stricter question.
+     *
+     * The items are the sheet's — this is a scoped view of
+     * `getSheet().getConditionalFormats()`, not a copy — and each appears **once**, however many of
+     * its ranges the query hit. The range only says *which* items; ask an item where it lives with
+     * {@link IConditionalFormat.getRanges}.
+     */
+    getConditionalFormats(options?: ICellRange.GetItemsOptions<IConditionalFormatCollection.GetItemsOptions>): IConditionalFormat[];
+    /**
+     * Returns the {@link IDataValidation}s that overlap the range.
+     *
+     * @param options The filters of {@link IDataValidationCollection.getItems} without `address` —
+     * this range is the address.
+     *
+     * @remarks
+     * **Plural, unlike Excel.** A cell carries at most one validation there, so Excel's range accessor
+     * is singular; here a range may overlap any number of independently anchored validations.
+     *
+     * See {@link getConditionalFormats} for the overlap and one-entry-per-item rules, which are the
+     * same for every ranged item lookup.
+     */
+    getDataValidations(options?: ICellRange.GetItemsOptions<IDataValidationCollection.GetItemsOptions>): IDataValidation[];
+    /**
+     * Returns the {@link ITable}s that overlap the range.
+     *
+     * @param options The filters of {@link ITableCollection.getItems} without `address` — this range
+     * is the address.
+     *
+     * @remarks
+     * Overlap, not containment — a range clipping one corner of a table returns it. Pass
+     * `fullyContained` to ask only for tables the range wholly encloses.
+     */
+    getTables(options?: ICellRange.GetItemsOptions<ITableCollection.GetItemsOptions>): ITable[];
+    /**
+     * Returns the {@link IMovable}s anchored over the range.
+     *
+     * @param options The filters of {@link IMovableCollection.getItems} without `address` — this
+     * range is the address.
+     *
+     * @remarks
+     * A movable is anchored to cells but sized in pixels, so what it overlaps is its **anchor**, not
+     * the pixels it paints.
+     */
+    getMovables(options?: ICellRange.GetItemsOptions<IMovableCollection.GetItemsOptions>): IMovable[];
+    /**
+     * Returns a cell in the range.
+     *
+     * @param address The address of the cell to retrieve. This must be within the range bounds. Default Value the 'top left'
+     *
+     * @see
+     * {@link ICellRange.getCells}
+     */
+    getCell(address?: ICell.Address): ICell;
+    /**
+     * Return a 2D array of {@link ICell | cells} in the shape of the range.
+     *
+     * @returns A 2D array of {@link ICell}s.
+     *
+     * @remarks
+     * * Empty values will be `null`.
+     * * {@link ICellRange.GetValuesOptions.asInteropValues} is ignored; use {@link ICell.getInteropValue()} when working with {@link ICell}.
+     */
+    getCells(options?: ICellRange.GetValuesOptions): ICell[][];
+    /**
+     * Returns the value for the top left `Scalar`.
+     *
+     * @remarks
+     * The `ignoreHidden` option is ignored.
+     *
+     * @see
+     * {@link ICellRange.getValues}
+     */
+    getValue(): Scalar;
+    /**
+     * Returns the value for the top left `InteropScalar`.
+     *
+     * @remarks
+     * The `ignoreHidden` option is ignored.
+     *
+     * @see
+     * {@link ICellRange.getValues}
+     */
+    getInteropValue(): InteropScalar;
+    /**
+     * Returns the style for the range.
+     *
+     * @remarks
+     * When querying the style the values will always be for the top left. However the
+     * set values work for the entire range.
+     */
+    getStyle(): IStyle;
+    /**
+     * Returns the formula for the range.
+     *
+     * @param address The address of the cell to retrieve the formula for. Default value is the 'top left' cell of the range.
+     *
+     * @remarks
+     * When querying the formula this will always be for the top left. However the
+     * set values work for the entire range.
+     */
+    getFormula(address?: ICell.Address): ICalculation.IFormula;
+    /**
+     * Parses a formula expression and returns a *transient* formula object anchored at this range's
+     * top-left cell.
+     *
+     * @param expression The formula expression to parse.
+     *
+     * @remarks
+     * The anchored convenience form: equivalent to
+     * `getSheet().createFormula(expression, topLeftCoords)`, where the anchor is this
+     * range's top-left cell. Nothing is committed — the formula is not registered in the workbook
+     * or the dependency graph.
+     *
+     * Two behaviors follow from the sheet form (see {@link ISheet.createFormula}):
+     *
+     * - A bare reference (`A2`) resolves against THIS range's sheet, never the selected one.
+     * - Relative references resolve **relative to the anchor cell**, so the expression reads
+     *   exactly as it would if it were authored here.
+     *
+     * @see {@link ISheet.createFormula}
+     * @see {@link ICalculation.createFormula}
+     */
+    createFormula(expression: string): ICalculation.IFormula;
+    /**
+     * Returns the intersection of the current range and the specified range.
+     *
+     * @param address The address of the other range to intersect with..
+     * @returns `ICellRange` at the intersection of the two ranges, or `null` if there's no overlap.
+     */
+    getIntersect(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): this | null;
+    /**
+     * Returns the union of the current range with the specified range.
+     *
+     * @param address The address of the other range to intersect with.
+     * @returns `ICellRange` at the union of the two ranges.
+     */
+    getUnion(address?: ICellRange.Address, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns a set of non-overlapping ranges the represents the difference between the current
+     * range and the specified range.
+     *
+     * @param address The address of the range to subtract from the current range.
+     * @returns `ICellRanges` containing the resulting non-overlapping ranges,
+     * or `null` if:
+     *   - There is no intersection between the current range and the specified address.
+     *   - The specified address is the same as or encompasses the current range.
+     *
+     * @remarks
+     * - The method will always return between 0 and 4 ranges.
+     * - If there's no intersection, it returns an `ICellRanges` containing only the current range.
+     */
+    getDifferences(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): ICellRanges | null;
+    /**
+     * Returns a range that includes the columns for the entire sheet.
+     * For example, if the range is `A1:B2`, this method will return `A:B`.
+     *
+     * @param shift If `true` this will also shift the columns by the width of the range. default `false`.
+     * @returns `ICellRange` at the repositioned range.
+     */
+    getEntireColumns(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns a range that includes the rows for the entire sheet.
+     * For example, if the range is `A1:B2`, this method will return `1:2`.
+     *
+     * @param shift If `true` this will also shift the rows by the height of the range.  default `false`.
+     * @returns `ICellRange` at the repositioned range.
+     */
+    getEntireRows(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns a range that includes the current range up to a content edge boundary.
+     *
+     * @param direction The direction.
+     * @param cell The cell to use as a starting point.
+     *               If not provide the cell closest to the edge will be used.
+     * @returns `ICellRange` extended in the given direction.
+     */
+    getExtended(direction: IRange.Direction, cell?: ICell.Address): this;
+    /**
+     * Returns a range with coordinates adjusted to be fixed (absolute) or flexible (relative).
+     *
+     * @param options Either a {@link ICellRange.GetFixedOptions} object to
+     *                  specify individual coordinate settings, or a `boolean`
+     *                  to adjust all coordinates at once. If a `boolean` is provided:
+     *                  - `true` sets all coordinates to absolute.
+     *                  - `false` sets all coordinates to relative.
+     * @returns `ICellRange` with updated coordinate references types.
+     *
+     * @remarks
+     * If no `options` are provided, this method toggles the fixed flags for the range's coordinates
+     * based on their current settings. Calling this repeatedly will cycle between relative and absolute references.
+     * For example: `A1` → `$A$1` → `A$1` → `$A1` → `A1`
+     */
+    getFixed(options?: ICellRange.GetFixedOptions | boolean): this;
+    /**
+     * Returns a 1×1 cell or an explicit range at the specified **absolute** sheet coordinates.
+     *
+     * @param rowStart The absolute row index (0-based, inclusive). Must be ≥ 0.
+     * @param colStart The absolute column index (0-based, inclusive). Must be ≥ 0.
+     * @param rowEnd The absolute ending row index (inclusive). If not provided, defaults to `rowStart` (1×1 cell).
+     * @param colEnd The absolute ending column index (inclusive). If not provided, defaults to `columnStart` (1×1 cell).
+     * @returns `ICellRange` at the specified coordinates.
+     *
+     * @remarks
+     * All indices are **absolute** — they are used directly as sheet coordinates and are not
+     * relative to the current range. Negative indices are not supported.
+     *
+     * When only `rowStart` and `columnStart` are supplied the result is always a single cell (1×1),
+     * regardless of the current range's shape. Use {@link getOffsetTo} to move the top-left corner
+     * while preserving the original dimensions.
+     */
+    getRangeAt(rowStart: number, colStart: number, rowEnd?: number, colEnd?: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the row at the specified **absolute** row index, retaining the current column span.
+     *
+     * @param rowIndex The absolute row index (0-based). Must be ≥ 0. Not relative to the current range.
+     * @returns `ICellRange` with a row height of 1 and the original column width.
+     */
+    getRowAt(rowIndex: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the row after the current range.
+     *
+     * @returns `ICellRange` with the top-left corner immediately after the current range.
+     *
+     * @remarks
+     * This will return a range with a row height of 1 but the original column width.
+     */
+    getRowAfter(options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the row before the current range.
+     *
+     * @returns `ICellRange` with the top-left corner immediately before the current range.
+     *
+     * @remarks
+     * This will return a range with a row height of 1 but the original column width.
+     */
+    getRowBefore(options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the row at the specified delta relative to the **start** of the current range,
+     * retaining the current column span.
+     *
+     * @param rowDelta Number of rows to move from `rowStart`. Positive moves down; negative moves up.
+     * @returns `ICellRange` with a row height of 1 and the original column width.
+     *
+     * @remarks
+     * `getRowBy(0)` is equivalent to `getRowAt(rowStart)` — the first row of the current range.
+     * To advance past the end of the range, use {@link getRowAfter} instead.
+     */
+    getRowBy(rowDelta: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the header range for the rows.
+     *
+     * @returns `ICellHeaderRange` for the rows.
+     */
+    getRowHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /**
+     * Returns the column at the specified **absolute** column index, retaining the current row span.
+     *
+     * @param columnIndex The absolute column index (0-based). Must be ≥ 0. Not relative to the current range.
+     * @returns `ICellRange` with a column width of 1 and the original row height.
+     */
+    getColumnAt(columnIndex: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the column after the current range.
+     *
+     * @returns `ICellRange` with the top-left corner immediately after the current range.
+     *
+     * @remarks
+     * This will return a range with a column width of 1 but the original row height.
+     */
+    getColumnAfter(options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the column before the current range.
+     *
+     * @returns `ICellRange` with the top-left corner immediately before the current range.
+     *
+     * @remarks
+     * This will return a range with a column width of 1 but the original row height.
+     */
+    getColumnBefore(options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the column at the specified delta relative to the **start** of the current range,
+     * retaining the current row span.
+     *
+     * @param columnDelta Number of columns to move from `columnStart`. Positive moves right; negative moves left.
+     * @returns `ICellRange` with a column width of 1 and the original row height.
+     *
+     * @remarks
+     * `getColumnBy(0)` is equivalent to `getColumnAt(columnStart)` — the first column of the current range.
+     * To advance past the end of the range, use {@link getColumnAfter} instead.
+     */
+    getColumnBy(columnDelta: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the header range for the columns.
+     *
+     * @returns `ICellHeaderRange` for the columns.
+     */
+    getColumnHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /**
+     * Returns the top-left corner of the range.
+     *
+     * @returns 1×1 `ICellRange` at the top-left corner.
+     */
+    getTopLeft(options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns the bottom-right corner of the range.
+     */
+    getBottomRight(options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns a range with the top-left corner moved by the specified row and column offsets.
+     *
+     * @param rowDelta The number of rows to move the top-left corner up (negative) or down (positive).
+     * @param colDelta The number of columns to move the top-left corner left (negative) or right (positive).
+     * @returns `ICellRange` at the repositioned range.
+     */
+    getOffsetBy(rowDelta: number, colDelta: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns a range repositioned to the specified starting row and column indices.
+     *
+     * @param rowStart The new starting row index (inclusive).
+     * @param colStart The new starting column index (inclusive).
+     * @returns `ICellRange` at the repositioned range.
+     */
+    getOffsetTo(rowStart: number, colStart: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns a range with the bottom-right corner moved by the specified row and column offsets.
+     *
+     * @param rowDelta The number of rows to move the bottom-right corner up (negative) or down (positive).
+     * @param colDelta The number of columns to move the bottom-right corner left (negative) or right (positive).
+     * @returns `ICellRange` with the resized range.
+     */
+    getResizeBy(rowDelta: number, colDelta: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Resizes the current range to the specified ending row and column indices.
+     *
+     * @param rowEnd The new ending row index (inclusive).
+     * @param colEnd The new ending column index (inclusive).
+     * @returns `ICellRange` with the resized range.
+     */
+    getResizeTo(rowEnd: number, colEnd: number, options?: ICellRange.GetRangeOptions): this;
+    /**
+     * Returns a range with surrounding data or the entire range if there is no data nearby.
+     *
+     * @returns `ICellRange` containing either nearby content or the entire range.
+     */
+    getSurrounding(options?: ICellRange.GetSurroundingOptions): this;
+    /**
+     * Returns the smallest range within the range that contains any used cells.
+     *
+     * @returns `ICellRange` that contains the smallest range with used cells, or `null` if the range is empty.
+     *
+     * @remarks
+     * This method returns the range of cells that have been "used," which includes cells with data,
+     * as well as certain types of formatting or styling. It focuses on cells that have been interacted with
+     * in some form, whether through data entry or other modifications. Merged cells and overflow values
+     * may not always be included in this range.
+     *
+     * Narrow what counts as used with {@link GetRangeOptions.features}: cells with values always
+     * count, and each listed feature widens the extent beyond them — so `features: []` is the
+     * values-only fast path (no feature index is consulted) and `['merge']` is values plus merged
+     * spans. The selection is sticky: the returned range carries it.
+     */
+    getUsedRange(options?: ICellRange.GetRangeOptions): this | null;
+    /**
+     * Returns a range that excludes any hidden rows or columns.
+     *
+     * @param options Optional parameters that can adjust how visibility is determined (e.g., by ignoring specific visibility rules).
+     * @returns An `ICellRanges` object that contains the visible portions of the range, excluding any hidden rows or columns.
+     *
+     * @remarks
+     * - If all ranges within the original selection are visible, this method returns an `ICellRanges` object with a single range and a length of `1`.
+     * - If the entire range is hidden, the method will return `null`.
+     * - The resulting ranges reflect the currently visible state of the sheet, including hidden rows, columns, or headers.
+     */
+    getVisible(options?: ICellRange.GetVisibleOptions): ICellRanges | null;
+    /**
+     * Returns the default shift {@link IRange.Axis} for {@link insert} and {@link delete}
+     * if no axis is provided.
+     *
+     * @returns Default `IRange.Axis` that will be used to shift the range.
+     *
+     * @remarks
+     * By default the direction of the shift will be the direction that shifts the fewest cells. If
+     * the range is the same size in both directions `IRange.Axis.Row` will be used.
+     *
+     * For example, a range with 5 columns and 1 row will have a default axis of `IRange.Axis.Row`.
+     */
+    getDefaultShiftAxis(): IRange.Axis;
+    /**
+     * Returns a default sort that would be used if no overrides where provided.
+     *
+     * @param axis The axis to sort. Default Value `IRange.Axis.Row`.
+     * @param cell A cell location that can be used to determine the sort column.
+     * @returns Default `ISort.DefaultSortCriteria` or `null` if there is not valid sort criteria.
+     *
+     * @remarks
+     * Useful for displaying options to the ui. The default behavior will look for headers and
+     * merges.
+     */
+    getDefaultSortCriteria(axis?: IRange.Axis, cell?: ICell.Address): ISort.DefaultSortCriteria | null;
+    /**
+     * Returns the ranges immediately referenced by the formulas in this range.
+     *
+     * @remarks
+     * The range form of {@link ICell.getDirectPrecedents}: the union over every cell, one call
+     * rather than a fan-out — the calculation graph is indexed by range, so the cell form is this
+     * one over a 1×1.
+     *
+     * - Returns `null` when there are none.
+     * - **Not filtered against the range itself.** A block containing both a formula and its input
+     *   lists that input; "what does this block read" and "what does it read from outside" are
+     *   different questions, and the second is {@link getDifferences} away.
+     */
+    getDirectPrecedents(): ICellRanges | null;
+    /**
+     * Returns the cells that directly reference any cell in this range.
+     *
+     * @remarks
+     * The range form of {@link ICell.getDirectDependents} — the immediate consumers of anything
+     * this range produces. Returns `null` when there are none.
+     */
+    getDirectDependents(): ICellRanges | null;
+    /**
+     * Returns all ranges contributing to this range's values, through the full calculation chain.
+     *
+     * @remarks
+     * The range form of {@link ICell.getPrecedents}: a recursive walk upstream to the root data
+     * sources. Returns `null` when there are none.
+     *
+     * **Reach for this before editing.** The precedents of a block are what its values depend on,
+     * so they are what a change to it can be wrong about.
+     */
+    getPrecedents(): ICellRanges | null;
+    /**
+     * Returns all cells eventually affected by this range, through the full calculation chain.
+     *
+     * @remarks
+     * The range form of {@link ICell.getDependents}: a recursive walk downstream giving the total
+     * blast radius of a write here. Returns `null` when there are none.
+     */
+    getDependents(): ICellRanges | null;
+    /**
+     * Returns the statistics for the range.
+     *
+     * @param options Iterator options the stats are created with — most usefully
+     * `{ onError: 'ignore' }` so aggregate reads degrade instead of faulting on error values.
+     * The same override is available per-call on {@link IRangeStats.getAggregates}.
+     * `{ ignoreHidden: true }` measures only what the sheet is showing.
+     *
+     * @remarks
+     * **`getStats` answers "what are the values like"; {@link getCounts} answers "how much of
+     * each feature is here".** Value analysis (visits values) vs feature occupancy (reads the
+     * indexes) — they do not overlap.
+     */
+    getStats(options?: ICellRange.GetStatsOptions): IRangeStats;
+    /**
+     * Returns a count for of values.
+     *
+     * @deprecated Use `getStats`.
+     */
+    getCount(): number;
+    /**
+     * Returns per-feature cell counts for the range.
+     *
+     * @param features The features to count. Defaults to **all** public features — counting is
+     * the discovery call.
+     *
+     * @remarks
+     * **`getCounts` answers "how much of each feature is here"; {@link getStats} answers "what
+     * are the values like".** Feature occupancy vs value analysis — they do not overlap.
+     *
+     * - Every public {@link ICellRange.Feature} appears as a key; features not requested, or not
+     *   present, are an explicit `0` — the shape is stable and self-describing, never `null`.
+     * - Each feature is counted **independently**. `getCounts([Fill, Border])` is two numbers,
+     *   not the count of their refined intersection — the refined count *is* `getRegions`.
+     * - Counts are cells, never regions: a region count would either disagree with the partition
+     *   `getRegions` returns or cost as much as computing it.
+     */
+    getCounts(features?: ICellRange.Feature | readonly ICellRange.Feature[]): ICellRange.Counts;
+    /**
+     * Returns the uniform regions for the requested features within the range.
+     *
+     * @param features The features to partition by. Defaults to `['Contentful']` — **never all**;
+     * combining features refines the partition (a cross-product), so all-features is the
+     * maximum-fragmentation call. Query one feature at a time; combine only when the relationship
+     * between features is the question.
+     * @param options {@link ICellRange.GetRegionsOptions}
+     *
+     * @remarks
+     * **A region answers *where*, not *what*.** It carries its address, its shape and the features
+     * it was partitioned by, and it bridges to the objects that answer reads:
+     * {@link ICellRegion.getCell} (the anchor — whose read IS the region's payload, since a region
+     * is uniform by construction) and {@link ICellRegion.getRange} (the block). Reading is a
+     * different verb on a different object, and the hop is the point — it is what keeps a
+     * discovery result from answering a question it was never asked.
+     *
+     * - **`getRegions` combines features into one partition; {@link getCounts} counts each
+     *   feature separately.** The refined count is this method; the cheap discovery is that one.
+     * - **A count is presence; a partition is payload identity.** `getCounts(Fill)` counts the
+     *   cells that have a fill and `getRegions(Fill)` splits them by color; `getCounts(Formula)`
+     *   counts formula cells and `getRegions(Formula)` splits them by authored R1C1 — so a filled
+     *   block is ONE region and the value pasted over the middle of it is a hole. The rule holds
+     *   for every feature.
+     * - Regions are maximal **rectangles**, never runs: a block filled down *and* across is one
+     *   region, not one per column.
+     * - Regions carrying none of the requested features are elided — the yielded regions are the
+     *   feature-bearing side of the partition.
+     * - **Nothing is computed until the result is iterated or counted.** The returned
+     *   {@link ICellRegions} is a lazily backed handle, so building the query costs nothing.
+     * - **`Contentful` regions are maximal rectangles.** Every other feature's stored blocks stand
+     *   for a payload two adjacent blocks can disagree about — a fill's color, a formula's
+     *   expression — so distinct blocks stay distinct or the region stops being uniform. Occupancy
+     *   is a boolean: any two occupied rectangles agree, so its blocks carry no information and are
+     *   coalesced. A solid `A1:D4` is one region, not the four column strips it is stored as.
+     *   Refinement is unaffected — `[Contentful, Fill]` still partitions by fill and still excludes
+     *   unoccupied cells.
+     * - Every {@link Feature} partitions — there is no throwing member left. `DateFormat` splits by
+     *   format string, the same way `Fill` splits by color; `Error` splits by error value, backed
+     *   by the reconciled error index. Scalar kinds (`String`/`Number`/`Boolean`) are not in this
+     *   vocabulary at all — see {@link Feature}'s own remarks for where they went.
+     */
+    getRegions(features?: ICellRange.Feature | readonly ICellRange.Feature[], options?: ICellRange.GetRegionsOptions): ICellRegions;
+    /**
+     * Returns a 2D array of {@link Scalar | values} in the shape of the range.
+     *
+     * @param options -
+     * - `asJSDate` Return dates as Javascript dates instead of SerialDates but is slower due to need to create dates.
+     * - `maxSize` Limit the size of the results. defaultValue `10000`.
+     *
+     * @returns A 2D array of values.
+     *
+     * @remarks
+     * * Empty values will be `null`.
+     */
+    getValues(options?: ICellRange.GetValuesOptions): Scalar[][];
+    /**
+     * Returns a 2D array of {@link InteropScalar | values} in the shape of the range.
+     *
+     * @see {@link ICellRange.getValues} for options and remarks.
+     */
+    getInteropValues(options?: ICellRange.GetValuesOptions): InteropScalar[][];
+    /**
+     * Set the value(s) of one or more cells within a range.
+     *
+     * @param values The value to be set or a callback that will generate a value.
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * - `null` values will clear the corresponding cells.
+     * - `undefined` values will be ignored, leaving the existing cell values unchanged.
+     * - If an array is passed the values will be in row-major order and will repeat if the range is larger than the array
+     * - If a single value is passed in it will repeat the entire range.
+     */
+    setValues(values: ICellRange.ValuesUpdate, options?: ICellRange.SetValuesOptions): this;
+    /**
+     * Provides a convenient method for setting values with a range of calls.
+     *
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * - **Performance** This is will always be significantly slow than setting attributes
+     * use the related range APIs.
+     * - For setting non contiguous values see {@link ICellRange.createSparseBuilder}
+     * @see
+     * * {@link updateStyle}
+     * * {@link setHyperlink}
+     */
+    updateCells(update: ICellRange.Update, options?: ICellRange.UpdateCellsOptions): this;
+    /**
+     * Set a single value to the entire range.
+     *
+     * @see
+     * {@link ICellRange.setValues}
+     */
+    setValue(value: ICellRange.ValuesUpdateOrCallback, options?: ICellRange.SetValuesOptions): this;
+    /**
+     * Set the formula for a range.
+     *
+     * @param value The formula to be set or a callback that will generate a formula.
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * Identical behavior to setValue. Exists for ergonomics
+     * @see
+     * {@link ICellRange.setValue}
+     */
+    setFormula(value: ICellRange.ValuesUpdateOrCallback, options?: ICellRange.SetValuesOptions): this;
+    /**
+     * Re-evaluates and formulas within the range.
+     *
+     * @param full If `true` then all formulas will be recalculated.
+     */
+    calculate(full?: boolean): this;
+    /**
+     * Fill the range to a destination using an array of {@link IAutoFill.Filler}.
+     *
+     * @param destination The range to autoFill including the current range.
+     * @throws `Error` If the destination range does not share 3 edges with the range.
+     * @returns `ICellRange` for the destination.
+     *
+     * @remarks
+     * * The destination must share 3 edges with the range and move exactly one edge.
+     * * An edge moved outward extends the fill; an edge moved inward shrinks it — the vacated
+     *   cells are cleared (mirrors dragging Excel's fill handle back over the source).
+     * * A destination equal to the range is a no-op.
+     * * If the range contains merges then the fill amount must be a multiple of the merge unit on the fill
+     *   axis, otherwise this throws — pass {@link AutoFillOptions.snap} to fill the nearest amount that
+     *   qualifies instead.
+     * * With {@link AutoFillOptions.preview} nothing is committed and the returned range projects the
+     *   result instead: its cells are computed, not read from the sheet, so
+     *   {@link ICell.getValue} / {@link ICell.getText} report what *would* be filled. A projected cell
+     *   also carries the merge the fill would create, so {@link ICell.getRange},
+     *   {@link ICell.getSpans} and {@link ICell.getExtrusions} describe the block rather than a single
+     *   cell — and asking for any coord inside that block returns the block's anchor cell, where the
+     *   value lives. Cells the fill does not touch (the range itself) read straight from the sheet.
+     *
+     * @example
+     * ```typescript
+     * // What would land in the last cell, and how big will that cell be?
+     * const preview = sheet.getRange('A1:B4').autoFill('A1:B8', { preview: true });
+     * const last = preview.getCell({ rowIndex: 7, colIndex: 1 });
+     * last.getText();        // the value the fill would write
+     * last.getExtrusions();  // the merged block it would occupy (null if not merged)
+     * ```
+     */
+    autoFill(destination: ICellRange.Address, options?: ICellRange.AutoFillOptions): this;
+    /**
+     * Adjusts the column widths and rows heights to fit the content.
+     *
+     * @returns The current `ICellRange`.
+     */
+    autoFit(options?: ICellRange.AutoFitOptions): this;
+    /**
+     * Clear the range.
+     *
+     * @param applyTo The type of content to clear. Default `ICell.Content.Values`
+     * @returns The current `ICellRange`.
+     */
+    clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
+    /**
+     * Set the hyperlink for a range of values.
+     *
+     * @param hyperlink A hyperlink update
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * To clear hyperlinks either set to `null` or call `clear(ICell.Content.Hyperlinks)`.
+     */
+    setHyperlink(hyperlink: IHyperlink.Update, options?: ITransaction.OperationOptions): this;
+    /**
+     * Update the comments for the range.
+     *
+     * @param comments Comment properties
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * **NOT FINISHED**
+     */
+    setComments(comments: IComment.Properties, options?: ITransaction.OperationOptions): this;
+    /**
+     * Merges all cells within the selection ranges.
+     *
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * If the ranges overlap then this operation will throw an exception
+     */
+    merge(options?: IRange.AxisSelection | ICellRange.MergeOptions): this;
+    /**
+     * Unmerge all cells within the selection ranges.
+     *
+     * @returns The current `ICellRange`.
+     */
+    unmerge(options?: ITransaction.OperationOptions): this;
+    /**
+     * Returns an iterator of ICells that match the results.
+     *
+     * @param options The text to search for or {@link FindOptions}
+     */
+    find(options: string | ICellRange.FindOptions): Iterator<ICell>;
+    /**
+     * Sort the given range.
+     *
+     * @param options If a boolean then this is sort ascending or descending.
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * The sorting of various data types has a default priority of of boolean > string > number and dates are treated as numbers.
+     * If a boolean is used then this is a 'descending' flag. `true` then the sort is reversed (descending).
+     */
+    sort(options?: boolean | ISort.Options[] | ISort.RangeOptions & ITransaction.OperationOptions): this;
+    /**
+     * Sort the given range by a single column or row.
+     */
+    sortAt(index: number, options?: boolean | (ISort.Criteria & ITransaction.OperationOptions)): this;
+    /**
+     * Parses the text in the selected column into multiple columns based on a delimiter.
+     *
+     * @param options - Delimiter or Configuration for the split operation, including delimiter and handling of existing data.
+     * @returns `ICellRange` containing the the newly split data
+     * @throws Error if the destination cells are not empty and `replaceExisting` is false.
+     *
+     * @remarks
+     * This method mimics the "Delimited" mode of Excel's Text-to-Columns feature.
+     * By default, this operation is non-destructive (it will not overwrite existing data unless `replaceExisting` is true).
+     */
+    textToColumns(options?: ICellRange.TextToColumnsOptions | string): this;
+    /**
+     * Removes duplicate rows based on specified columns.
+     *
+     * @param options - Configuration for the duplicate removal operation, including the columns to consider.
+     * @returns `ICellRange` containing the rows that remain. This is the original range resized by the
+     * number of rows that were removed (the origin and the columns are unchanged).
+     * @throws Error if the range has no data or if a `columns` entry is not within the range.
+     *
+     * @remarks
+     * This method mimics the "Remove Duplicates" feature in Excel.
+     *
+     * The duplicate rows are deleted rather than cleared, so the rows that remain keep their
+     * formatting, hyperlinks and comments. Only the range is compacted - the same number of rows is
+     * given back at the bottom of the range so that the cells below it stay where they are.
+     *
+     * A row with no values is still a row. The first blank row is unique and any that follow are
+     * duplicates of it. Blank rows after the last row with a value are left alone.
+     */
+    removeDuplicates(options?: ICellRange.RemoveDuplicatesOptions): this;
+    /**
+     * Hide the rows that do not meet the condition.
+     *
+     * @remarks
+     * Apply filter to multiple spans in either axis.
+     *
+     * Example – hide rows where column C is >= 3:
+     *
+     * ``` ts
+     * sheet.getRange('A2:E100').filter({
+     *   axis: IRange.Axis.Row, // default but could be column
+     *   conditions: [
+     *     {
+     *       operator: ICondition.BuiltInOperatorNames.GreaterThanEqualTo,
+     *       param: 3,
+     *       // 0-based index of column C within the range (relative to the range, not the sheet)
+     *       index: 2,
+     *     },
+     *   ],
+     * });
+     *
+     * @see
+     * {@link IFilter.IFilterable}
+     */
+    filter(condition: ICondition.Input | ICondition.RangeOptions, options?: ITransaction.OperationOptions): Promise<this>;
+    /**
+     * Insert a new, empty range within the sheet and shifts existing cells to accommodate it.
+     *
+     * @param options The axis or The direction in which to shift existing cells.
+     *   Defaults to the axis where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
+     *   See {@link ICellRange.getDefaultShiftAxis} for details on the default behavior.
+     *   See {@link ITransaction.OperationOptions}
+     * @throws `Error` If the insertion would cause data to exceed the maximum sheet size.
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * By default the values will direction in whichever direction the selection shape is smaller.
+     * For example a selection with a 5 column by 1 row will direction Down (rows).
+     * Note - This will error if direction data will fall outsize of the max sheet size.
+     */
+    insert(options?: IRange.Axis | ICellRange.InsertOptions): this;
+    /**
+     * Delete the cells within the range and shifts the remaining cells to fill the gap.
+     *
+     * @param options The axis or The direction in which to shift existing cells.
+     *   Defaults to the axis where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
+     *   See {@link ICellRange.getDefaultShiftAxis} for details on the default behavior.
+     *   See {@link ITransaction.OperationOptions}
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * This is different from clearing cells, which removes their content but doesn't affect the
+     * overall sheet structure. Deleting cells results in a shift of the remaining data.
+     */
+    delete(options?: IRange.Axis | ICellRange.DeleteOptions): this;
+    /**
+     * Add an `ITable` at the range.
+     *
+     * @param options If a boolean then this indicates if headers are present.
+     *
+     * @remarks
+     * This behaves similarly to {@link ISheet.getTables.add} but uses the current range
+     */
+    addTable(options?: ITableCollection.AddOptions | boolean): ITable;
+    /**
+     * Creates a 'light' table used for stateful filtering and sorting with-in a sheet.
+     *
+     * @see {@link ITable}
+     */
+    addAutoTable(options?: ICellRange.AddAutoTableOptions): ITable;
+    /**
+     * Returns a snapshot of the current range's data and formatting suitable for copying or archiving.
+     *
+     * @param options Default options when apply the snapshot (Usually copy).
+     * @returns A `ISnapshot` object representing the range.
+     *
+     * @remarks
+     * - **Option Merging:** If options are provided on getSnapshot and the copy operation,
+     *   the two will be merged with the copy options taking precedence.
+     * - `getSnapshot` can be called multiple times allowing for multiple snapshots.
+     */
+    getSnapshot(options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
+    /**
+     * Inserts the contents of the `source` into the sheet, shifting existing cells to make space.
+     *
+     * @param source The source of the data and formatting to insert.
+     *   This can be either a range address, another range object, or an `ISnapshot`
+     *   created using the `getSnapshot` method.
+     * @returns A promise that resolve to an `ICellRange` or 'null' when the copy has completed.
+     *
+     * @remarks
+     * * Behaves similarly to {@link insert} and {@link copyFrom}, but instead of inserting empty space at the range
+     * it also inserts the content of the `source`.
+     * * Will return `null` if nothing was inserted or the source doesn't have a range.
+     */
+    insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
+    /**
+     * Copies (or cuts) data and formatting from a specified source to the current range.
+     *
+     * @param source The source of the data and formatting to be copied or cut.
+     *   This can be either a range address, another range object, or an `ISnapshot`
+     *   created using the `getSnapshot` method.
+     * @returns A promise that resolve to an `ICellRange` or 'null' when the copy has completed.
+     *
+     * @remarks
+     * * Will return `null` if nothing was inserted or the source doesn't have a range.
+     * @see
+     *  {@link ICellRange.getSnapshot}
+     */
+    copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
+    /**
+     * Update the protection for the range.
+     *
+     * @returns The current `ICellRange`.
+     *
+     * @remarks
+     * Setting to `null` will remove protections.
+     */
+    /**
+     * Perform a set of operations as a batch.
+     *
+     * @param callback Function to perform the operations.
+     * @param options Description of the operation or additional options. This will be used for tracking undo/redo and history. @defaultValue 'Range Update'
+     * @template R - The callback return type.
+     * @returns The result of the callback.
+     */
+    doBatch<R>(callback: (commit: ITransaction.ICommit) => Promise<R> | R, options?: string | ITransaction.OperationOptions): Promise<R> | R;
+    /**
+     * Creates a `SparseBuilder` for efficiently updating sparsely populated cells in a streaming low memory way.
+     *
+     * For contiguous or mostly contiguous updates, the {@link ICellRange.updateCells} method is simpler
+     * and will use {@link ICellRange.SparseBuilder} internally.
+     *
+     * @remarks
+     * - **Ordering:** By default updates must be added in either row-major or column-major order, as specified
+     * by the `axis` parameter, with major/minor coordinates increasing monotonically. Unless
+     * `allowUnorderedWrites` is set to `true out of order updates will result in an error.
+  
+     * - **Performance:**  Setting `axis` to `IRange.Axis.Column` is generally faster as it aligns with the internal data representation.
+     * - **Performance:**  Setting `allowUnorderedWrites` adds a nominal performance overhead for all updates and will do a full apply when an
+     *      out of order update is detected.
+     *   The default `IRange.Axis.Row` is provided for compatibility with common spreadsheet APIs.
+     * - **Validation:** Data validation (e.g., for protected cells or boundaries) is performed when the `apply` method is called.
+     * - **Transactions:**
+     *    - Adding values to the `SparseBuilder` only builds a temporary representation of the updates.
+     *      No actual changes are made to the sheet until `apply` is called.
+     *    - This allows for safe batching of updates within a single transaction using `doBatch`.
+  
+     * @example
+  ```typescript createSparseBuilder
+    const builder = range.createSparseBuilder()
+      .push('A1', 2)
+      .push('A2', 567)
+      .push('A3', 3)
+      .push('A4', 123)
+      .push('A5', 1)
+      .apply();
+    });
+  ```
+     */
+    createSparseBuilder(options?: ICellRange.SparseBuilderOptions): ICellRange.SparseBuilder;
+    /**
+     * Selects the current range.
+     *
+     * @returns An async `ICellRange`.
+     */
+    select(options?: ICellRange.SelectOptions): Promise<this>;
+    /**
+     * Add a listener to the range.
+     *
+     * @returns A callback to remove. {@link IListener.Remove}
+     *
+     * @remarks
+     * If the range becomes invalid through a delete this will auto remove.
+     */
+    addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
+    /**
+     * Evaluates `formula` across this range and calls `callback` with the results — then again every
+     * time anything the formula reads changes.
+     *
+     * @param formula An expression, compiled at this range's top-left, or an already-compiled formula
+     *                anchored there (see the anchor note below).
+     * @param callback Receives one value per cell of this range, read with local coordinates
+     *                 (`getValueAt(0, 0)` is this range's top-left).
+     *
+     * @returns A callback to remove the watch. {@link IListener.Remove}
+     *
+     * @remarks
+     * The difference from {@link createFormula} is the lifetime: that one compiles and
+     * evaluates once and registers nothing, so its answer silently ages. This one keeps answering.
+     *
+     * Block-shaped, always. A rule's operand is a value *per cell*, not one value for the range: an
+     * absolute reference (`$A$1`) yields the same value in every cell and a relative one (`A1`)
+     * yields each cell's own — the same code path, which is why per-cell semantics cost nothing here.
+     *
+     * The callback fires on the first evaluation as well as on every change, so a caller never has to
+     * evaluate separately and then watch — a sequence with a window in it where a change is lost. An
+     * evaluation superseded by a newer one is dropped rather than delivered late, so the callback
+     * never goes backwards in time.
+     *
+     * **The anchor must be this range's top-left**, and a compiled formula anchored elsewhere throws
+     * rather than being quietly re-sited. A formula means different things read from different cells
+     * ({@link ICalculation.IFormula.shift}), so silently moving one would answer a question the
+     * caller did not ask. To watch a formula belonging to a multi-area rule, fill it first — or use
+     * {@link ICellRanges.addWatch}, which does that for every area.
+     *
+     * Known limits, both from watching the formula's *written* references: a range discovered at
+     * evaluation time (`INDIRECT`, `OFFSET`) is not watched, and a volatile formula (`NOW`, `RAND`)
+     * has nothing to watch at all. Neither re-fires.
+     */
+    addWatch(formula: ICalculation.IFormula | string, callback: ICellRange.WatchCallback): IListener.Remove;
+    /**
+     * Returns an iterator that allows you to iterate over the individual values within the range.
+     *
+     * @remarks
+     * For more advanced iteration, use {@link ICellRange.entries} or {@link ICellRange.forEach}.
+     */
+    [Symbol.iterator](): IterableIterator<Scalar>;
+    /**
+     * Returns an iterator that allows you to iterate over the individual entries within the range,
+     * yielding pairs of `IteratorContext` and a `Value`.
+     *
+     * @returns An iterator that yields `ICellRange.Entry` tuples for each value within the range.
+     */
+    entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
+    /**
+     * Returns the values within the range, yielding each value.
+     *
+     * @returns An iterator that yields `Scalar` each value within the range.
+     */
+    values(options?: ICellRange.IteratorOptions): IterableIterator<Scalar>;
+    /**
+     * Iterates over the cells within the range, applying the provided callback function to each cell.
+     *
+     * This method is a more scalable alternative to `getValues` or `getCells` for large or sparse ranges,
+     * as it:
+     * 1. Skips empty values by default.
+     * 2. Avoids creating large arrays.
+     * 3. Allows for early termination.
+  
+     * @param callback A function that will be called for each non-empty cell in the range. The callback receives:
+     *   - `value`: The `Scalar` at the current cell.
+     *   - `context`: A `IteratorContext` object providing additional information and utilities for the cell.
+     *   - The callback can return `{ break: T }` to stop the iteration early.
+     * @template R - The callback return type.
+     * @returns The value returned by the callback function if it explicitly returned to stop the iteration early; otherwise, `void`.
+     */
+    forEach<B>(callback: ICellRange.ForEachCallback<B>, options?: ICellRange.IteratorOptions): B | void;
+    /**
+     * Returns `true` if there is any content within the range.
+     *
+     * @param features Restrict the check to specific features. Defaults to any content.
+     * @returns 'boolean' indicating if there is content.
+     *
+     * @remarks
+     * Some uses cases for this are checking for data to delete a sheet, checking for multiple values
+     * for merges.
+     */
+    isContentful(features?: ICellRange.Feature | readonly ICellRange.Feature[]): boolean;
+    /**
+     * Returns `true` if the range represents the entire rows.
+     */
+    isEntireRows(): boolean;
+    /**
+     * Returns `true` if the range represents the entire columns.
+     */
+    isEntireColumns(): boolean;
+    /**
+     * Returns `true` if the range represents both entire rows and entire columns.
+     */
+    isEntireRange(): boolean;
+    /**
+     * Returns `true` if the range is a single cell.
+     */
+    isSingleCell(): boolean;
+    /**
+     * Returns `true` if the given address represents the same range as the current range.
+     *
+     * @param address The address to compare against.
+     * @param options Options for getting the range from the address.
+     */
+    isEqual(address: ICellRange.Address, options?: ICellRange.GetRangeOptions): boolean;
+    /**
+     * Returns the size of the range this is the rows * columns.
+     */
+    get size(): number;
+    /**
+     * Returns the absolute bounds for the range.
+     */
+    getBounds(): Bounds;
+    /**
+     * Indicates if the range is readonly only.
+     *
+     * @remarks
+     * Not an indicator of if the range is protected but rather
+     * if the range is being used in a way that doesn't support write operations.
+     * (e.g. the range is being provided as a listener source {@link ICellRange.Event}
+     * or the range belongs to a historical snapshot.)
+     */
+    isReadOnly(): boolean;
+    /**
+     * Returns the `coords` as a string address (e.g., 'A1' or 'A1:E5').
+     *
+     * @param r1c1 If unspecified returns the environment's default.
+     */
+    getAddress(r1c1?: boolean): string;
+    /**
+     * Returns the column start.
+     */
+    getColumnStart(): number;
+    /**
+     * Returns the top of the range.
+     */
+    getRowStart(): number;
+    /**
+     * Returns the right of the range.
+     */
+    getColumnEnd(): number;
+    /**
+     * Returns the bottom of the range.
+     */
+    getRowEnd(): number;
+    /**
+     * Returns the number of columns of the range.
+     */
+    getColumnCount(): number;
+    /**
+     * Returns the number of rows of the range.
+     */
+    getRowCount(): number;
+    /**
+     * Checks if the ranges is empty, meaning it has no values or formatting.
+     *
+     * @remarks
+     * Convenience ```getUsedRange() !== null``` or `getCount() === 0`.
+     *
+     * @see
+     * {@link ICellRange.getUsedRange}
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the Sheet.
+     */
+    getSheet(): ISheet;
+    /**
+     * The IRange.Coords.
+     */
+    getCoords(): Readonly<IRange.FixableCoords>;
+    /**
+     * Returns `true` if the range is invalid.
+     *
+     * @remarks
+     * Ranges can be invalid if a range is removed due to deleting rows or columns or if the
+     * range is created with invalid coordinates.
+     */
+    isInvalid(): boolean;
+    /**
+     * Returns the address as a string.
+     */
+    toString(): string;
+    /**
+     * For runtime type checking.
+     */
+    readonly isICellRange: true;
+}
+/**
+ * An {@link ICellRange} that represents a named range.
+ *
+ * @remarks
+ * Consumers that need the named identity check `isINamedRange` before casting.
+ */
+export interface INamedRange extends ICellRange {
+    /** Returns the user-visible display name. */
+    getName(): string;
+    /** Returns the internal ID of the named range. */
+    getId(): string;
+    /**
+     * EVERY range this name designates, or `null` when it designates none.
+     *
+     * @remarks
+     * A name's refers-to may be a UNION (`Revenue = $A$1:$B$2,$D$3:$E$4`), and an `INamedRange` is
+     * ONE range — its own coords cannot carry two areas. This is the door to the full extent, so a
+     * holder of a branded member never has to re-resolve the name to learn there was more.
+     *
+     * `null` matches `INamed.getRanges`: a name holding an expression (`Doubled = Base*2`)
+     * designates no cells — its coords here are a graph ANCHOR, not a target.
+     */
+    getRanges(): ICellRanges | null;
+    /** For runtime type checking. */
+    readonly isINamedRange: true;
+}
+/**
+ * {@inheritDoc ICellRange}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ICellRange}
+ */
+export declare namespace ICellRange {
+    /**
+     * This is either:
+     * 1. A string that can be parsed into a CellRange (e.g. 'A1:B2') or a named range.
+     * 2. Another ICellRange
+     * 3. An IRange
+     * 4. Partial IRange.FixableCoords
+     */
+    type Address = string | ICellRange | IRange | Readonly<Partial<IRange.FixableCoords>> | ICell.Address | FormulaError.Ref;
+    /**
+     * Represents an update to a cell's value, allowing `null` to clear the cell.
+     *
+     * @remarks
+     * This type is used to update a cell's value. Passing `null` will clear the cell's content.
+     * The value must conform to the native types allowed in a cell (`Scalar`).
+     */
+    type ScalarUpdate = Scalar | null | undefined;
+    /**
+     * Represents an update to a cell's value in JavaScript, allowing `Date` and `null`.
+     *
+     * @remarks
+     * This type allows for updating a cell's value, including `Date` for convenience.
+     * As with `ScalarUpdate`, `null` can be used to clear the cell's value.
+     *
+     * * See {@link InteropScalar} for more details on JavaScript scalar values.
+     */
+    type InteropScalarUpdate = InteropScalar | null | undefined;
+    /**
+     * Single or 2D.
+     */
+    type Update = ICell.Update | readonly ICell.Update[][];
+    /**
+     * A union of either a Scalar and 2D array of Scalars or an IRange.
+     */
+    type ValuesUpdate = InteropScalarUpdate | IRange | readonly InteropScalarUpdate[][];
+    /**
+     * Allows for Values to be set via a callback.
+     */
+    type ValuesUpdateOrCallback<T = Scalar> = ValuesUpdate | ((row: number, column: number) => T | null);
+    /**
+     * The read options a range carries.
+     *
+     * @remarks
+     * **These are sticky.** A range created with them keeps them, and every derivation
+     * (`getOffsetBy`, `getIntersect`, `getUsedRange`, `getRowAt`…) hands them to the range it
+     * returns. That is what keeps the API fluent: if a read is scoped by an option, everything
+     * chained off its result stays scoped the same way, rather than silently widening back out
+     * at the first hop.
+     *
+     * They are defaults, not locks — the same key passed to an individual read wins for that
+     * call, and a derivation that passes new options merges them over the carried ones.
+     */
+    interface GetRangeOptions {
+        /**
+         * Skip cells hidden via headers.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * Honored by every read that walks cells — iteration ({@link ICellRange.forEach},
+         * {@link ICellRange.entries}), the aggregates ({@link ICellRange.getCounts},
+         * {@link ICellRange.getCount}, {@link ICellRange.isContentful}), {@link ICellRange.getMerges}
+         * and {@link ICellRange.getRegions}.
+         *
+         * Optionally an {@link IRange.Axis} to skip on one axis only — sorting skips hidden rows
+         * while leaving hidden columns in place.
+         */
+        ignoreHidden?: boolean | IRange.Axis;
+        /**
+         * The features reads through this range resolve and report.
+         *
+         * @defaultValue all features
+         *
+         * @remarks
+         * The lens for every feature-aware read: iteration visits only cells that exist through a
+         * listed feature, {@link ICellRange.getCounts} / {@link ICellRange.isContentful} /
+         * {@link ICellRange.getRegions} report on that selection, and
+         * {@link ICellRange.getUsedRange} measures its extent.
+         *
+         * An empty list is the raw-value fast path — no feature state is resolved at all.
+         *
+         * {@link ICellRange.getValues} and {@link ICellRange.values} are deliberately exempt — a
+         * value is a value regardless of the lens.
+         */
+        features?: ICellRange.Feature | readonly ICellRange.Feature[];
+    }
+    /**
+     * A sheet collection's own `getItems` filters, without `address`.
+     *
+     * @remarks
+     * The ranged item lookups ({@link ICellRange.getTables}, {@link ICellRange.getConditionalFormats},
+     * {@link ICellRange.getDataValidations}, {@link ICellRange.getMovables}) are scoped views of the
+     * sheet's collections, so each takes exactly the filters its own collection takes. `address` is
+     * dropped because the range **is** the address — a second one would be a contradictory scope.
+     */
+    type GetItemsOptions<T> = Omit<T, 'address'>;
+    /**
+     * Options for adding an auto table to a range.
+     */
+    interface AddAutoTableOptions extends ITransaction.OperationOptions {
+        /**
+         * Include sort options.
+         */
+        sort?: ISort.RangeOptions;
+        /**
+         * Include filter options.
+         */
+        filter?: ICondition.RangeOptions;
+        /**
+         * If `true` then any existing auto table at the range will be replaced.
+         */
+        replaceExisting?: boolean;
+    }
+    /**
+     * Options for `ICellRange.delete`.
+     */
+    interface InsertOptions extends ITransaction.OperationOptions {
+        /**
+         * The direction in which to shift existing cells.
+         *
+         * @remarks
+         * Defaults to the axis where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
+         * See {@link ICellRange.getDefaultShiftAxis}
+         */
+        axis?: IRange.Axis;
+        /**
+         * Expand the shifted range to the enclosing region's full extent across the shift axis before
+         * inserting: within a table, the table's width/height (a **table** row/column insert — column
+         * state, undo labels and validity are owned by the table); otherwise the **entire sheet** (an
+         * entire row/column insert). The range's own extent on the shift axis still supplies the count.
+         *
+         * @remarks
+         * - A range that only *partially* overlaps a table throws (cells cannot shift across a table
+         *   boundary) — select entirely inside or outside the table.
+         * - A table row insert requires the range's rows to lie within the table **body** (not the
+         *   header/totals rows) and throws otherwise.
+         * - Requires a single range at the `ICellRanges` level.
+         *
+         * @defaultValue `false` (classic shift-cells)
+         */
+        span?: boolean;
+    }
+    /**
+     * Options for `ICellRange.delete`.
+     */
+    interface DeleteOptions extends ITransaction.OperationOptions {
+        /**
+         * The direction in which to shift existing cells.
+         *
+         * @remarks
+         * Defaults to the axis where the range's dimension is smaller (e.g., shifts down if the range is wider than it is tall).
+         * See {@link ICellRange.getDefaultShiftAxis}
+         */
+        axis?: IRange.Axis;
+        /**
+         * Expand the shifted range to the enclosing region's full extent across the shift axis before
+         * deleting: within a table, the table's width/height (a **table** row/column delete); otherwise
+         * the **entire sheet** (an entire row/column delete). See {@link InsertOptions.span} for the
+         * boundary and validity rules.
+         *
+         * @defaultValue `false` (classic shift-cells)
+         */
+        span?: boolean;
+    }
+    /**
+     * Options for configuring range coordinate reference types.
+     * Each option allows you to specify whether a coordinate should be fixed
+     * (absolute) or flexible (relative).
+     *
+     * @see
+     * {@link ICellRange.getFixed}
+     */
+    interface GetFixedOptions {
+        /**
+         * If `true`, sets the starting row coordinate as absolute; if `false`,
+         * sets it as relative. Defaults to no change if not provided.
+         */
+        rowStart?: boolean;
+        /**
+         * If `true`, sets the starting column coordinate as absolute; if `false`,
+         * sets it as relative. Defaults to no change if not provided.
+         */
+        colStart?: boolean;
+        /**
+         * If `true`, sets the ending row coordinate as absolute; if `false`,
+         * sets it as relative. Defaults to no change if not provided.
+         */
+        rowEnd?: boolean;
+        /**
+         * If `true`, sets the ending column coordinate as absolute; if `false`,
+         * sets it as relative. Defaults to no change if not provided.
+         */
+        colEnd?: boolean;
+    }
+    /**
+     * Options for {@link ICellRange.getSurrounding}.
+     */
+    interface GetSurroundingOptions {
+        /**
+         * If `true` then only the content will be included.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * If `true` then tables and sheet boundaries will be ignored mimicking the behavior
+         * of 'Ctrl+Shift+*'.
+         */
+        contentOnly?: boolean;
+    }
+    /**
+     * A callback to enabled additional customization during copy.
+     *
+     * @remarks
+     * Return `undefined` will leave the value undefined altered.
+     */
+    interface CopyCellsCallback {
+        (value: Scalar, context: ICell.IteratorContext, to: IRange.CellCoords, options: ICellRange.CopyOptions): ICell.Update;
+    }
+    /**
+     * Options for {@link ICellRange.ISnapshot.copyTo}.
+     */
+    interface CopyOptions extends ITransaction.OperationOptions, ReferenceableClipboard.CopyOptions {
+        /**
+         * When pasting from a smaller range to a larger range copy will repeat or 'wallpaper' the
+         * source values.
+         *
+         * @remarks
+         * Note - If the destination range is only a single cell then fitDestination will always be applied.
+         */
+        fitDestination?: boolean;
+        /**
+         * Have the data transposed for the original axis.
+         *
+         * @defaultValue false
+         */
+        transpose?: boolean;
+        /**
+         * Indicate which items are copied.
+         */
+        type?: ICell.Content;
+        /**
+         * Indicates if the header (size) should be copied.
+         *
+         * @remarks
+         * The default is to only copy the headers if the range is entire header span.
+         */
+        includeHeaders?: boolean;
+        /**
+         * Allows for undo to range selection to be altered.
+         *
+         * @remarks
+         * TODO - API leakage - This is used to during drag.
+         */
+        undoRange?: ICellRange;
+        /**
+         * Callback to allow for additional customizations.
+         */
+        adjustCells?: ICellRange.CopyCellsCallback;
+    }
+    /**
+     * Options for {@link ICellRange.insertFrom}.
+     *
+     * @remarks
+     * This extends {@link ICellRange.CopyOptions} and adds an {@link IRange.Axis}.
+     */
+    interface InsertFromOptions extends ICellRange.CopyOptions {
+        /**
+          * The direction in which to shift existing cells.
+          *   Defaults to the axis where the copied range's dimension is smaller.
+          *   See {@link ICellRange.getDefaultShiftAxis} for details on the default behavior.
+         */
+        axis?: IRange.Axis;
+    }
+    /**
+     * Options for {@link ICellRange.setValues}.
+     */
+    interface SetValuesOptions extends ITransaction.OperationOptions {
+        /**
+         * By default setValue will attempt to parse text values into a native type.
+         * This can be disabled or customized using the parseText flag.
+         * Setting this to false will use the raw text value.
+         */
+        textParser?: boolean | ICell.ModifiersFromStringOptions;
+        /**
+         * Specifies the direction for iterating over the range (row-major or column-major).
+         *
+         * @defaultValue `IRange.Axis.Row`
+         *
+         * @remarks
+         * Both {@link SetValuesOptions} and {@link GetValuesOptions} allow for {@link IRange.Axis}s.
+         */
+        axis?: IRange.Axis;
+        /**
+         * Convenience method that calls autoFit after the setValues.
+         * @defaultValue `none` - No autofit.
+         *
+         * @remarks
+         * If set to `true` then autoFit will mimic the UI with the following options:
+    ```
+    {
+      skipCustomSize: true,
+      expandOnly: true,
+      minContent: true
+    }
+    ```
+         */
+        autoFit?: boolean | ICellRange.AutoFitOptions;
+        /**
+         * Skip the bounds check when setting values.
+         *
+         * @remarks
+         * When set to `true`, this option allows value arrays to exceed the
+         * dimensions of the range. This is useful for setting values in a table
+         * where the range is smaller than the data, but determining the exact
+         * size requires processing the entire dataset.
+         */
+        skipBoundsCheck?: boolean;
+    }
+    /**
+     * Options for {@link ICellRange.getValues}.
+     */
+    interface GetValuesOptions {
+        /**
+         * Limits the maximum number of values returned. An error will be thrown if results contain more values than `maxSize`.
+         *
+         * @defaultValue 10000
+         */
+        maxSize?: number;
+        /**
+         * Specifies the primary direction for iterating over the range (row-major or column-major).
+         *
+         * @defaultValue IRange.Axis.Row
+         *
+         * @remarks
+         * Both {@link SetValuesOptions} and {@link GetValuesOptions} allow for {@link IRange.Axis}s.
+         */
+        axis?: IRange.Axis;
+        /**
+         * Reverses the iteration order (e.g., from bottom to top for rows, or from right to left for columns).
+         *
+         * @defaultValue false
+         */
+        reverse?: boolean;
+        /**
+         * Excludes hidden cells from the returned values.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * - When enabled, the number of returned rows or columns might be less than the range size.
+         * - If the entire range is hidden, the result will be empty and empty Array (`[]`).
+         * - Optionally, you can specify a `IRange.Axis` to indicate the header axis for skipping cases.
+         *   For example, in sorting, you might want to skip hidden rows but not hidden columns.
+         */
+        ignoreHidden?: boolean | IRange.Axis;
+        /** {@inheritDoc ICellRange.IteratorOptions.includeMergeOverflow} */
+        includeMergeOverflow?: boolean;
+    }
+    /**
+     * Options for {@link ICellRange.autoFit}.
+     */
+    interface AutoFitOptions extends ITransaction.OperationOptions {
+        /**
+         * Best fit using the minimum amount of space required.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * When `true` the numbers will include as few decimals as allowed overflow into the next cell.
+         * For example allowing numbers to round or use scientific notation.
+         */
+        minContent?: boolean;
+        /**
+         * Restricts autoFit to only grow, never shrink.
+         *
+         * @defaultValue false - adjust in both directions.
+         *
+         * @remarks
+         * This is useful when adjusting fonts and wan the columns to resize but not the rows.
+         */
+        expandOnly?: boolean | IRange.Axis;
+        /**
+         * If this is set to `true` then any headers that have custom sizes will be ignored.
+         *
+         * @defaultValue false
+         */
+        skipCustomSize?: boolean;
+        /**
+         * The axes to autoFit.
+         *
+         * @defaultValue IRange.AxisSelection.Both
+         */
+        axes?: IRange.AxisSelection;
+        /**
+         * Fit to what **formula view** displays rather than to the rendered values.
+         *
+         * @defaultValue the sheet view's {@link ISheetView.isShowFormulas}
+         *
+         * @remarks
+         * In formula view a cell with a formula shows `=` + its formula text, and every other cell
+         * shows its raw value with no number format. Both are usually much wider than the formatted
+         * value, which is why Excel also renders columns at twice their stored width while it is on.
+         *
+         * Normally left unset — autoFit follows the view. Pass it explicitly to fit for a view other
+         * than the current one (or, in tests, without a view at all).
+         */
+        formulaView?: boolean;
+    }
+    /**
+     * Options for {@link ICellRanges.getFlattened}.
+     */
+    interface GetFlattenOptions extends GetRangeOptions {
+        /**
+         * Returns a set of ranges with overlaps removed and attempts to merge adjacent ranges into larger ranges.
+         *
+         * @param axes The overlap detection and initial merge axis.
+         * @returns A new `ICellRanges` object with non-overlapping, and where possible, merged ranges.
+         *
+         * @defaultValue `IRange.AxisSelection.Both`.
+         */
+        axes?: IRange.AxisSelection;
+    }
+    /**
+     * Options for {@link ICellRange.getStats}.
+     */
+    interface GetStatsOptions extends IRange.IteratorOptions {
+        /**
+         * Measure only the rows/columns the sheet is showing.
+         *
+         * @defaultValue `false`
+         *
+         * @remarks
+         * The same lens {@link ICellRange.getCounts} and {@link ICellRange.getRegions} take, and it
+         * costs no extra scan: the range is split at the hidden runs first (off the header run
+         * structure, no per-cell probe) and the resulting pieces are measured as ONE population.
+         *
+         * Optionally an {@link IRange.Axis} to skip on one axis only.
+         */
+        ignoreHidden?: boolean | IRange.Axis;
+    }
+    /**
+     * Options for {@link ICellRange.getVisible}.
+     */
+    interface GetVisibleOptions extends GetRangeOptions {
+        /**
+         * The visible axes.
+         *
+         * @defaultValue `IRange.AxisSelection.Both`
+         */
+        axes?: IRange.AxisSelection;
+    }
+    /**
+     * Options for {@link ICellRange.autoFill}.
+     */
+    interface AutoFillOptions extends ITransaction.OperationOptions {
+        /**
+         * Provide custom fillers.
+         *
+         * @defaultValue `AutoFill.Types.Series`
+         */
+        filler?: IAutoFill.Filler;
+        /**
+         * Options to pass to the `IAutoFill.Filler`.
+         * @remarks
+         * These will also be passed if a custom filler is used.
+         */
+        fillerOptions?: IAutoFill.Options;
+        /**
+         * If `true` then will only copy values and not formatting.
+         *
+         * @defaultValue false (unless starting within a table)
+         */
+        contentsOnly?: boolean;
+        /**
+         * Compute the fill but commit nothing — the returned range is a projection of the result.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * * The sheet is untouched and no undo entry is created.
+         * * The returned range covers the destination and is read-only; writes to it throw.
+         * * Its cells are derived, not read from the sheet — see {@link ICellRange.autoFill}.
+         * * Cells are computed on demand, so previewing one cell of a large fill costs one cell.
+         */
+        preview?: boolean;
+        /**
+         * Fill the nearest destination that is legal instead of throwing when the given one is not.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * * Only merges make a destination illegal, so with none on the fill axis this changes nothing.
+         * * The fill amount is rounded **outward** to the merge unit (drag one row into a merge and the
+         *   whole merge is covered, Excel-style), then clamped **inward** to the sheet. If not even one
+         *   merge unit fits, the fill becomes a no-op.
+         * * Shrinking destinations are always legal and are never moved.
+         * * Opt-in by design: a caller that named an exact destination gets an error rather than a silently
+         *   different fill. Turn it on for pointer-driven input, where the raw destination is a guess.
+         * * The returned range reports where the fill actually landed — so a drag can snap, preview and
+         *   commit through one call and they can never disagree.
+         */
+        snap?: boolean;
+    }
+    /**
+     * Options for {@link ICellRange.updateCells}.
+     */
+    interface UpdateCellsOptions extends SetValuesOptions {
+    }
+    /**
+     * Provides an API for efficiently performing incremental updates to specific cells within a range.
+     *
+     * Unless {@link ICellRange.SparseBuilderOptions.allowUnorderedWrites} is `true` the updates must be written
+     * in row-major or column-major order as determined by {@link IRange.Axis}, with major/minor
+     * coordinates increasing on each update, otherwise an error will be thrown.
+     *
+     * @example
+     * ```typescript
+     * const builder = range.createSparseBuilder();
+     * builder.pushAt(1, 1, "Hello"); // as row, column, primitive - fastest
+     * builder.push({ rowIndex: 2, colIndex: 1 }, { value: "Beautiful" }); // as coordinate and json object
+     * builder.push('A3', { value: "World" });  // as a1 string and json
+     * builder.apply();
+     * ```
+     * @template S - The return type of {@link apply}, typically the source range (`ICellRange`).
+     * @see {@link ICellRange.createSparseBuilder}
+     */
+    interface SparseBuilder<S = ICellRange> {
+        /**
+         * Adds an update at a specific cell address.
+         *
+         * @param address The cell address to update. See {@link ICell.Address}.
+         * @param update The update to apply. See {@link ICell.Update}.
+         * @throws `Error` If the coordinates are out of order compared to previously added coordinates.
+         * @returns The current `SparseBuilder` instance for chaining.
+         */
+        push(address: ICell.Address, update: ICell.Update): this;
+        /**
+         * Adds an update at a specific major (row) and minor (column) index.
+         *
+         * This method is slightly faster than {@link push} as it bypasses address parsing.
+         *
+         * @param row The row index of the cell to update.
+         * @param col The column index of the cell to update.
+         * @param update The update to apply. See {@link ICell.Update}.
+         * @throws `Error` If the coordinates are out of order compared to previously added coordinates.
+         * @returns The current `SparseBuilder` instance for chaining.
+         */
+        pushAt(row: number, col: number, update: ICell.Update): this;
+        /**
+         * Adds multiple updates for contiguous cells along the minor axis (columns), starting at the specified indices.
+         *
+         * @param row The row index of the starting cell.
+         * @param col The column index of the starting cell.
+         * @param updates An array of updates to apply to contiguous cells.
+         * @throws `Error` If the coordinates are out of order compared to previously added coordinates.
+         * @returns The current `SparseBuilder` instance for chaining.
+         */
+        pushMultipleAt(row: number, col: number, updates: ICell.Update[]): this;
+        /**
+         * Finalizes and applies all queued updates to the range.
+         *
+         * This method commits the changes added via {@link push}, {@link pushAt}, or {@link pushMultipleAt}.
+         *
+         * @returns The source object, typically the range (`ICellRange`).
+         */
+        apply(options?: ICellRange.UpdateCellsOptions): S;
+    }
+    interface SparseBuilderOptions {
+        /**
+         * The axis to write.
+         */
+        axis?: IRange.Axis;
+        /**
+         * Allowing unordered writes is slower but relaxes the rule that the updates must be written in order.
+         *
+         * @defaultValue false
+         */
+        allowUnorderedWrites?: boolean | ICellRange.UpdateCellsOptions;
+    }
+    /**
+     * Options for {@link ICellRange.merge}.
+     */
+    interface MergeOptions extends SetValuesOptions {
+        /**
+         * The axes of the merge.
+         *
+         * @defaultValue IRange.AxisSelection.Both
+         */
+        axes?: IRange.AxisSelection;
+        /**
+         * If `true` then merge will merge even if there is more than one value.
+         *
+         * @defaultValue false
+         */
+        discardMultipleValues?: boolean;
+    }
+    /**
+     * Options for {@link ICellRange.textToColumns}.
+     */
+    interface TextToColumnsOptions extends ITransaction.OperationOptions {
+        /**
+         * The character used to split the text.
+         *
+         * @defaultValue System looks for string with one of the following.
+         *
+         * @remarks
+         * Common delimiters include `,` (comma), `;` (semicolon), `\t` (tab), or ` ` (space).
+         */
+        delimiter?: string;
+        /**
+         * The character used to enclose text strings that may contain the delimiter.
+         *
+         * @defaultValue `"` (double quote)
+         *
+         * @remarks
+         * Characters found inside the qualifier are treated as literal text rather than delimiters.
+         * For example, if the delimiter is a comma, `"Doe, John"` will remain one cell rather than splitting into two.
+         * Set this to an empty string to disable text qualification.
+         */
+        textQualifier?: string;
+        /**
+         * Determines how empty fields are split.
+         *
+         * @defaultValue false
+         *
+         * * - If `false` (default): Consecutive delimiters are treated as a single break.
+         * Empty fields between delimiters are ignored/merged.
+         * - If `true`: Every delimiter creates a new column.
+         * Consecutive delimiters will result in empty strings ("") in the output.
+         *
+         * * @remarks
+         * This is the inverse of Excel's "Treat consecutive delimiters as one" option.
+         * * @example
+         * // Input string: "Apple,,Banana" (Delimiter is comma)
+         * * // When preserveEmptyFields is false (Default):
+         * // Result: ["Apple", "Banana"]
+         * * // When preserveEmptyFields is true:
+         * // Result: ["Apple", "", "Banana"]
+         */
+        preserveEmptyFields?: boolean;
+        /**
+         * The destination range where the split columns will be placed.
+         *
+         * @remarks
+         * If not specified, the operation will start at the the original range top left.
+          * If the destination range overlaps with the source range, the behavior will depend on the `replaceExisting` option:
+          * - If `replaceExisting` is `true`, the operation will proceed, and any existing data in the destination range will be overwritten.
+          * - If `replaceExisting` is `false` (default), and there is an overlap with non-empty cells, the operation will throw an error to prevent data loss.
+         */
+        destination?: ICellRange.Address;
+        /**
+         * If `true`, the operation will overwrite existing data in the destination columns without warning.
+         *
+         * @defaultValue `false`
+         *
+         * @remarks
+         * * The source row will be split..
+         * * If this is `false` (default) and non-empty cells exist in the output range,
+         * the operation will throw an error to prevent data loss.
+         */
+        replaceExisting?: boolean;
+    }
+    /**
+     * Options for {@link ICellRange.removeDuplicates}.
+     */
+    interface RemoveDuplicatesOptions extends ITransaction.OperationOptions {
+        /**
+         * Indicates if the range has a header row.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * If `true`, the first row of the range will be treated as a header and excluded from duplicate removal.
+         */
+        hasHeader?: boolean;
+        /**
+         * A list of columns to consider for duplicate removal.
+         *
+         * @defaultValue all columns
+         *
+         * @remarks
+         * If this is a number it will be a number relative to the range if a string it will be a column
+         * identifier that is resolved.
+         */
+        columns?: (number | string)[];
+    }
+    /**
+     * Options use for filtering elements during a find.
+     */
+    interface FindCriteria {
+        /**
+         * If `true` then the text search is case sensitive.
+         *
+         * @defaultValue false
+         */
+        matchCase?: boolean;
+        /**
+         * If `true` the text must match the entire cell to be true.
+         *
+         * @defaultValue false
+         */
+        matchEntireCell?: boolean;
+        /**
+         * Determines whether the find operation should treat the search text as a regular expression (RegEx).
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * When `true`, the search text will be interpreted as a regular expression (RegEx), allowing for
+         * advanced pattern matching.
+         *
+         * If `false`, the find operation will not use RegEx but will support three wildcard characters
+         * for flexible searching:
+         *
+         * - `?` (question mark): Matches any single character.
+         * - `*` (asterisk): Matches any number of characters, including zero.
+         * - `~` (tilde followed by `?`, `*`, or `~`): Escapes the wildcard characters (`?` or `*`) to allow
+         *   searching for these literal characters in the text.
+         *
+         * Example usage:
+         * ``` ts
+         * // Search for text matching a RegEx pattern
+         * const results: Iterator<ICell> = range.find({ text: "\\d+", useRegex: true }); // Finds numeric values
+         *
+         * // Search for text using wildcards
+         * const results: Iterator<ICell> = range.find({ text: "abc*", useRegex: false }); // Finds text starting with "abc"
+         * ```
+         */
+        useRegex?: boolean;
+        /**
+         * An enum of the types of values to search within each field.
+         *
+         * @defaultValue `[FindField.Formulas]`
+         */
+        fields?: ICell.Content[];
+    }
+    /**
+     * Options for {@link ICellRange.find}.
+     */
+    interface FindOptions extends FindCriteria {
+        /**
+         * The text to search for.
+         */
+        text: string;
+        /**
+         * Provides custom logic for matching values during the find operation.
+         *
+         * @param value The current cell value being checked against the `criteria`.
+         * @param matchDefault A default implementation of the find operation's matching logic.
+         *   You can call this in your custom logic to fall back to the default behavior if needed.
+         * @param criteria The criteria that the find operation is trying to match.
+         *   This is typically defined by the user and passed to the find method.
+         * @param context Contextual information about the cell, such as its address or value-related utilities.
+         *   See {@link ICell.IteratorContext} for more details.
+         * @returns A boolean indicating if the `value` satisfies the `criteria`.
+         *
+         * @remarks
+         * If `matchCustom` is provided, this function will override the default matching logic for the find operation.
+         * Use it to implement custom search rules, while the `matchDefault` can be used as a fallback for standard criteria.
+         *
+         * Example usage:
+         * ``` ts
+         * const options = {
+         *   matchCustom: (value, matchDefault, criteria, context) => {
+         *     // Custom match logic
+         *     if (typeof value === 'string' && value.includes('important')) {
+         *       return true;
+         *     }
+         *     // Fallback to default match
+         *     return matchDefault();
+         *   }
+         * };
+         * ```
+         */
+        matchCustom?: (value: Scalar, matchDefault: () => boolean, criteria: FindCriteria, context: ICell.IteratorContext) => boolean;
+        /**
+         * Specifies the direction of the search.
+         *
+         * @defaultValue IRange.Axis.Row
+         */
+        axis?: IRange.Axis;
+        /**
+         * If `true`, the search will proceed in reverse order.
+         *
+         *
+         * @defaultValue false
+         */
+        reverse?: boolean;
+        /**
+         * The starting point for the search. If not provided, the search will start
+         * from the top left corner of the range, or from the bottom right if `reverse` is true.
+         *
+         * @defaultValue top left corner or bottom right if reverse
+         */
+        from?: ICell.Address;
+        /**
+         * If `true`, the search will not wrap around to the beginning of the range after reaching
+         * the end. By default, the search will wrap.
+         *
+         * @defaultValue false
+         */
+        disableWrap?: boolean;
+    }
+    /**
+     * Represents an immutable reference to an `ICellRange`, capturing its content and metadata.
+     * It may include complex objects such as tables, movables, images, listeners, or other items.
+     *
+     * `ISnapshot` can be provided to `ICellRange.copyFrom``.
+     */
+    interface ISnapshot<T = any, J = any> {
+        /**
+         * Copies the snapshot to the specified range.
+         *
+         * @param destination The destination `ICellRange` where the snapshot will be copied.
+         *
+         * @returns A promise that resolves when the copy is complete, or `void` if no asynchronous operation is required.
+         */
+        copyTo(destination: ICellRange, options?: ICellRange.CopyOptions): Promise<IRange.Coords | null> | IRange.Coords | null;
+        /**
+         * Return the options used when creating.
+         * @remarks
+         * This is done so that we can create a copy.
+         */
+        getMarkOptions(): ICellRange.CopyOptions;
+        /**
+         * Retrieves the coordinates that bound the current snapshot.
+         *
+         * @returns The `IRange.Coords` defining the bounds of the snapshot.
+         */
+        getCoords?(): Readonly<IRange.Coords>;
+        /**
+         * Converts the snapshot to a plain text representation.
+         *
+         * @returns A string or promise resolving to the text representation of the snapshot.
+         */
+        toText?(): Promise<string> | string;
+        /**
+         * Converts the snapshot to an HTML representation.
+         *
+         * @returns A string or promise resolving to the HTML representation of the snapshot.
+         */
+        toHtml?(): Promise<string> | string;
+        /**
+         * Converts the snapshot to an image blob.
+         *
+         * @returns A `Blob` or promise resolving to the image representation of the snapshot.
+         */
+        toImage?(): Promise<Blob> | Blob;
+        /**
+         * Converts the snapshot to a JSON object.
+         *
+         * @returns A JSON object or promise resolving to the JSON representation of the snapshot.
+         */
+        toJSON?(): Promise<J> | J;
+        /**
+         * The source that created the snapshot.
+         * This is used by copy to quickly do comparisons.
+         */
+        getSource(): T;
+        /**
+         * A user friendly name of a the snapshot item.
+         */
+        getName?(): string;
+        /**
+         * For runtime type checking.
+         */
+        readonly isISnapshot: true;
+    }
+    /**
+     * Callback used for visiting a collection of cells. If break is returned the visiting will stop with the
+     * break value returned.
+     *
+     * The context allows for the retrieval of additional information associated with the Cell include the
+     * {@link ICell} object.
+     */
+    interface ForEachCallback<T = any> {
+        (value: Scalar, context: ICell.IteratorContext): {
+            break: T;
+        } | void;
+    }
+    /**
+     * The public feature vocabulary — what a cell or range *carries*, as a queryable dimension.
+     *
+     * @remarks
+     * This is the agent-facing read vocabulary: `getCounts`, `getRegions` and `isContentful`
+     * select by it, and the agent read tools (grep, the regions read) use the same words. It is deliberately distinct
+     * from {@link ICell.Content}, the *transfer* vocabulary (`clear`, `copyFrom`) — "paste formats" is a
+     * coarse transfer bucket, while querying wants the split parts (`Fill`, `Border`,
+     * `NumberFormat`…). One enum serving both jobs is how the vocabulary got muddy the first time.
+     *
+     * Members map onto the engine's per-feature spatial indexes. The mapping is internal and not
+     * one-to-one: several features may project from one index (`NumberFormat`/`Alignment`/`Font`
+     * over the content-style map). `Notes` joins when the backing is implemented; a feature that
+     * silently reports nothing is worse than a missing one.
+     *
+     * `String`/`Number`/`Boolean` are deliberately absent, even though they are real `ScalarType`
+     * values. This vocabulary is for things with a spatial identity — a fill, a formula, an
+     * occupied cell — and a scalar kind has none: it is read straight off the value, which is
+     * exactly the one pass `IRangeStats.getTypedCounts()` already makes, richer (it composes with
+     * aggregates and frequencies for free, in the same call). `getCounts`/`getRegions`/
+     * `isContentful` were never the right vocabulary for "how many numbers" — `range.getStats()` is.
+     *
+     * `Error` stays, for a reason unrelated to the above: it has real spatial identity of its own
+     * (the reconciled error view) and partitions like any stored feature — it was never in the same
+     * boat as the other three. `DateFormat` stays too, but as exactly what its name says: a
+     * formatting predicate, the same tier as `NumberFormat`/`Alignment`/`Font`, not a value kind — it
+     * answers *"does this cell carry a date-category number format"*, nothing about what the value
+     * underneath actually is. A caller after "how many cells are genuinely dates" (numeric value AND
+     * that format) composes it: `DateFormat` regions intersected with `getStats().getTypedCounts()`'s
+     * `Number` — there is deliberately no single feature that already does that intersection, because
+     * "is this a date" is a computed fact about a cell's *value*, read through `getInteropType()`, not
+     * a thing this vocabulary partitions on.
+     */
+    const Feature: {
+        /**
+         * Occupancy — splits on blank/non-blank, Excel `CurrentRegion` semantics.
+         */
+        readonly Contentful: "contentful";
+        /**
+         * Direct date-category number format — `yyyy-mm-dd`, `mm/dd/yyyy`, and the like.
+         *
+         * @remarks
+         * A formatting predicate, not a value kind: a blank cell or a text cell formatted this way
+         * carries `DateFormat` too, the same way a blank cell can carry `Fill`. It says nothing about
+         * whether the cell holds a genuine date — that is a question about the VALUE (numeric value
+         * under this format), answered by `getInteropType()` on the cell, not by this feature. See
+         * this enum's own remarks for why the two are kept apart rather than fused into one "Date"
+         * concept.
+         */
+        readonly DateFormat: "dateFormat";
+        /** Scalar kind: error values (`#DIV/0!`, `#N/A`, …), literal or calculated. */
+        readonly Error: "error";
+        /** Has a formula. Regions group by canonical R1C1 — a shared formula block is one region. */
+        readonly Formula: "formula";
+        /** Cells inside a dynamic-array spill zone. Writing into one is a real failure mode. */
+        readonly Spills: "spills";
+        /**
+         * Evaluated state: cells whose calculation itself failed — mostly circular references.
+         * Distinct from {@link Feature.Error}: `#DIV/0!` is a successfully calculated error VALUE
+         * (the `Error` kind); `CalcError` is the engine failing to evaluate at all.
+         */
+        readonly CalcError: "calcError";
+        /** Direct fill. */
+        readonly Fill: "fill";
+        /** Direct borders. */
+        readonly Border: "border";
+        /** Direct number format. Region payloads carry the format string and its category. */
+        readonly NumberFormat: "numberFormat";
+        /** Direct alignment. */
+        readonly Alignment: "alignment";
+        /** Direct font. */
+        readonly Font: "font";
+        /** Merged spans. */
+        readonly Merge: "merge";
+        /** Table membership. */
+        readonly Table: "table";
+        /** Auto-table membership. */
+        readonly AutoTable: "autoTable";
+        /** Has a hyperlink. */
+        readonly Hyperlink: "hyperlink";
+        /** Has comments. */
+        readonly Comments: "comments";
+        /** Explicitly unlocked cells — *can I write here* is a precondition, not a detail. */
+        readonly Unlock: "unlock";
+        /** Cells under conditional-format rules. */
+        readonly Conditionals: "conditionals";
+        /** Cells under data-validation rules. */
+        readonly DataValidations: "dataValidations";
+    };
+    type Feature = typeof Feature[keyof typeof Feature];
+    /**
+     * Per-feature cell counts.
+     *
+     * @remarks
+     * Total, not partial — every public {@link ICellRange.Feature} is present, absent features
+     * as explicit zeros. A zero is a fact about the range; a missing key would be ambiguous.
+     *
+     * The brand is non-enumerable: `Object.keys`/`entries` yield exactly the feature keys.
+     */
+    interface Counts extends Readonly<Record<ICellRange.Feature, number>> {
+        /**
+         * For runtime type checking.
+         */
+        readonly isICellRangeCounts: true;
+    }
+    /**
+     * Options for {@link ICellRange.getRegions}.
+     *
+     * @remarks
+     * The traversal keys are the standard {@link ICellRange.IteratorOptions} ones, meaning what
+     * they mean everywhere else. `features` is the same list as the positional argument — for a
+     * partition, the features resolved and the features partitioned on are necessarily one list —
+     * so the argument is simply its shorthand.
+     *
+     * **`Pick`, not `Omit`, and deliberately.** A partition is not a cell visitation, so the rest
+     * of `IteratorOptions` has nothing to act on: `includeEmpty` (regions come from the feature
+     * indexes, and the blank side of the partition is not yielded at all), `reuseContext` and
+     * `includeMergeOverflow` (there is no per-cell `IteratorContext` to reuse or overflow into),
+     * `injectReferences` (which ignores features by its own contract), and `address` (the queried
+     * range IS the bounds — a second one would be ambiguous). Widening to `Omit` would advertise
+     * five options that silently do nothing, and a feature that silently reports nothing is worse
+     * than a missing one.
+     */
+    interface GetRegionsOptions extends Pick<ICellRange.IteratorOptions, 'features' | 'axis' | 'reverse' | 'ignoreHidden'> {
+        /**
+         * How a stored feature block must relate to the queried range to be included.
+         *
+         * @defaultValue 'intersects' — blocks straddling the boundary are included, clipped to the
+         * range. `'fullyContained'` yields only blocks entirely inside it.
+         */
+        containment?: 'intersects' | 'fullyContained';
+    }
+    interface ScrollIntoViewOptions extends globalThis.ScrollIntoViewOptions {
+        /**
+         * If provided then will only scroll in the provided axis.
+         *
+         * @remarks
+         * This is useful for only scrolling vertically or horizontally for insert/deleteCells
+         */
+        axis?: IRange.Axis;
+    }
+    /**
+     * Extends SelectionOptions to include the option to adjust the anchor cell.
+     */
+    interface SelectOptions extends ITypes.SelectOptions {
+        /**
+         * If `true` then the anchor cell will be adjusted to the top-left cell of the range.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * If the current anchor is not within the current range this will be forced to `true`.
+         */
+        anchor?: boolean | Partial<IRange.CellCoords>;
+        /**
+         * If `true` or if a valid `ScrollIntoViewOptions` object is provided,
+         * the selected element will be scrolled into view.
+         *
+         * @remarks
+         * - If a `ScrollIntoViewOptions` object is provided, it will control the exact scrolling behavior.
+         * - If `false` (or omitted), the selected element will not be scrolled into view.
+         *
+         * @defaultValue false
+         */
+        scrollIntoView?: boolean | ICellRange.ScrollIntoViewOptions;
+        /**
+         * If `true`, the currently selected sheet will not change as part of the selection.
+         * By default, selecting a range will also select its parent sheet, matching Excel behavior.
+         *
+         * @defaultValue false
+         */
+        preserveSelectedSheet?: boolean;
+    }
+    /**
+     * Options for customizing how values are retrieved from a range and returned as a 2D array.
+     */
+    interface IteratorOptions<T = ICellRange.Address> {
+        /**
+         * The containing range coords for the scan.
+         *
+         * @remarks
+         * If not specified will scan all of the data.
+         */
+        address?: T;
+        /**
+         * If `true` will visit empty cells.
+         * This is a potentially huge performance improvement if set to `false`.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * If includeEmpty is `true` this will always return rectangular results.
+         * If bounds are provided it will provide empty spaces before and after.
+         * If passing a large bound care must be taken.
+         */
+        includeEmpty?: boolean;
+        /**
+         * When scanning skip cells that are hidden via headers.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * Optionally a header axis for skipping case be passed in.
+         * An example of this is for sorting where the sort direction (row) skips hidden rows but the column direction does not.
+         */
+        ignoreHidden?: boolean | IRange.Axis;
+        /**
+         * The features the iteration resolves and visits.
+         *
+         * @defaultValue all features
+         *
+         * @remarks
+         * Two effects, both wins for a caller that does not need everything:
+         * - The iterator only materializes the requested features' state onto the context — an
+         *   excluded feature is never even looked up.
+         * - **Cells that exist only through an excluded feature are not visited at all.** A
+         *   fill-only cell does not appear in a `features` scan that excludes `Fill` — the render
+         *   path that only paints content stops receiving cells with nothing to paint.
+         *
+         * An empty list is the raw-value fast path — no feature state is resolved at all.
+         */
+        features?: ICellRange.Feature | readonly ICellRange.Feature[];
+        /**
+         * Includes any merge overflow in first element visited.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * If `true` any merges that fall outside of the range will be include in the top/left most cell that the
+         * merge intersects. Useful for rendering merged cells when the top/left is outside the viewport.
+         */
+        includeMergeOverflow?: boolean;
+        /**
+         * The direction of the scan.
+         * @defaultValue `IRange.Axis.Row`
+         */
+        axis?: IRange.Axis;
+        /**
+         * Iterate in reverse order.
+         *
+         * @defaultValue false
+         */
+        reverse?: boolean;
+        /**
+         * If set to `true` a single `IteratorContext` is reused for every visited cell instead of
+         * allocating a new one per cell.
+         *
+         * @defaultValue false
+         *
+         * @remarks
+         * This is a performance optimization for hot read paths (e.g. rendering).
+         * **UNSAFE** for consumers that retain the `context` (or the `Entry`) past the next `next()`
+         * call - the retained reference will reflect the most recently visited cell, not the one it was
+         * captured at. Only enable this when the context is consumed inline within the visitor/loop body
+         * (e.g. by calling `getCell()`, which snapshots the state).
+         */
+        reuseContext?: boolean;
+        /**
+         * Inject custom references for the iterator.
+         *
+         * @remarks
+         * This is used to allow for iterators to inject custom references.
+         *
+         * * Ignores Features
+         * * These will get available in the {@link ICell.IteratorContext.getInjectedReference}.
+         * * Used when wanting to iterate over externally managed references
+         * * **NOTE** - This is a 2D array.
+         * * **NOTE** - The iterator treats values as read-only but the visitors may modify the references.
+         */
+        injectReferences?: IRange.JSONReference<any>[][];
+    }
+    interface Event {
+        /**
+         * The source of the event. This will be a readonly range.
+         *
+         * @remarks
+         * This may change shape due to insert/delete/move of cells or sheets.
+         */
+        getSource<T = ICellRange | ICellRanges>(): T;
+        /**
+         * This is the range of data that has been changed.
+         *
+         * @remarks
+         * This is different than the source range as that is the entire range area that was listened to.
+         */
+        getFrom(): ICellRanges;
+        /**
+         * Used for moves. Represents the new location of the data that has changed.
+         */
+        getTo?(): ICellRange;
+        /**
+         * Returns a list of updates that occurred during the event. This is only available for data change events and will be `null` for address or restore events.
+         */
+        /**
+         * Indicates the type of change that triggered the event.
+         *
+         * @remarks
+         * * `'data'`: Data within the range has changed.
+         *   The range's address and dimensions remain the same.
+         * * `'address'`: The range's *address* or *dimensions* have changed. This
+         *   occurs due to row/column insertions, deletions, or move operations.
+         * * `'restore'`: The range has been restored to a different revision
+         *   (undo/redo). The 'restore' trigger is not available for transactional listeners.
+         */
+        readonly trigger2?: 'data' | 'address' | 'restore';
+        readonly trigger: string;
+        /**
+         * Indicates if the event is being fired from an undo event.
+         */
+        readonly isUndo?: boolean;
+        /**
+         * Returns the transaction Id if the event is occurring in a transaction otherwise `null`.
+         *
+         * @see
+         * {@link ListenerOptions.getTransactionId}
+         */
+        getTransactionId(): string | null;
+        /**
+         * Indicates if the event is being fired due to a cell value change.
+         *
+         * @see
+         * {@link ListenerOptions.ignoreDataChanges}
+         */
+        readonly isDataChange?: boolean;
+        /**
+         * To string the event.
+         */
+        toString(): string;
+        /**
+         * The timestamp of the event.
+         */
+        readonly timeStamp: number;
+    }
+    /**
+     * Represents a listen for a range. The listener will be called when the range's
+     * data, address, or restore state changes, subject to the provided options.
+     *
+     * @remarks
+     * If the range is deleted (rows/columns removed), the trigger will be `'address'`
+     * `trigger` of `'address'` and `getRange().getError()`
+     * returning `"#REF!"`.
+     *
+     * If the ranges is restored to a revision *before* the listener was
+     * added, the listener will receive event with a `trigger` of `'restore'`
+     * and `getRange().getError()` returning `"#N/A"`.
+     */
+    interface Listener {
+        (event: ICellRange.Event): void;
+    }
+    /**
+     * Receives a watch's results — one value per cell of the watched range, read with LOCAL
+     * coordinates (`getValueAt(0, 0)` is the range's top-left).
+     *
+     * @see {@link ICellRange.addWatch}
+     *
+     * @remarks
+     * A cell whose evaluation errored carries the error as its value, the same as any block
+     * evaluation; the watch does not fail as a whole because one cell did.
+     */
+    interface WatchCallback {
+        (values: IRange): void;
+    }
+    /**
+     * Options to control which events trigger a listener. By default, all
+     * event types will trigger the listener. Setting any of these options to
+     * `true` will *prevent* the listener from being called for that event type.
+     */
+    interface ListenerOptions {
+        /**
+         * The actual range can also change due to insert/removes or delete of a sheet.
+         * Setting absoluteCoords to `true` will ignore shifts in the range.
+         *
+         * @defaultValue false
+         */
+        ignoreShifts?: boolean;
+        /**
+         * If `true`, the listener will *not* be called when the range's
+         * address changes (due to row/column insert/delete, or moves)
+         *
+         * @defaultValue false
+         */
+        ignoreAddressChanges?: boolean;
+        /**
+        * If `true`, the listener will be treated as *transactional*. This has
+        * a few implications:
+        *
+        * 1. **Synchronous Execution:** The listener will be called *synchronously*
+        *    as part of the same transaction that triggered the event.  Any
+        *    side-effects of the listener will be included in the transaction's
+        *    commit history.
+        * 2. **No 'restore' Events:** Transactional listeners will *never* receive
+        *    'restore' events. They are only concerned with changes within the
+        *    current transaction.
+        *
+        * If `false` (the default), the listener will be called *asynchronously*
+        * after the transaction is complete. The listener's side-effects will
+        * *not* be part of the transaction's commit history.
+        *
+        * @defaultValue false
+        */
+        transactional?: boolean;
+        /**
+         * If `true`, the listener will *not* be called when the data
+         * within the range changes.
+         *
+         * @defaultValue false
+         */
+        ignoreDataChanges?: boolean;
+        /**
+         * If `true` then the listener will be weakly and will be auto removed it the listener is gc'ed.
+         *
+         * @defaultValue false
+         */
+        weakly?: boolean;
+        /**
+         * If `true` then will auto deregister once fired.
+         */
+        once?: boolean;
+    }
+    /**
+     * Entry for ICellRange when iterator or visiting.
+     */
+    interface Entry<T = Scalar> {
+        /** {@inheritDoc Scalar} */
+        value: T;
+        /** {@inheritDoc ICell.IteratorContext} */
+        context: ICell.IteratorContext;
+    }
+}
+//# sourceMappingURL=ICellRange.d.ts.map