@sheetxl/sdk 0.7.12 → 0.7.13

package/types/scripting.d.ts

@@ -14236,6 +14236,15 @@ declare module "address/AddressUtils" {
      * If we used the from/to range type we wouldn't have to.
      */
     export const sheetRangeToString: RangeToString<IRange.FixableCoords, IRange.FixableCellCoords>;
+    /**
+     * Convert a fixable cell to A1 format.
+     *
+     * @param fixable
+     * @param defaultRange
+     * @param toRangeString
+     * @returns a string
+     */
+    export const sheetRangesToString: (fixable: readonly Partial<Readonly<IRange.FixableCoords>>[], defaultRange?: Readonly<IRange.Coords>, toRangeString?: RangeToString<IRange.FixableCoords, IRange.FixableCellCoords>) => string;
     /**
      * Workbook range still used IRange.FixableCellCoords.
      */
@@ -14455,6 +14464,14 @@ declare module "selection/IRangeSelection" {
          * @returns The selection coordinates.
          */
         getCoords(): IRangeSelection.Coords;
+        /**
+         * Returns the selection as an array of IRange.Coords.
+         *
+         * @param coords Optional coordinates to convert. If not provided, uses the current selection.
+         * @remarks
+         * The first element is always the active range.
+         */
+        getRangesCoords(coord?: Partial<IRangeSelection.Coords>): IRange.Coords[];
         /**
          * Updates the selection coordinates.
          * @param coords The new coordinates.
@@ -18982,6 +18999,13 @@ declare module "selection/_RangeSelectionUtils" {
         (coords: IRange.CellCoords): boolean;
     }
     export type CellFinder = (activeCoords: IRange.CellCoords, isContentfulCell: IsContentfulCell | undefined, hiddenAt: HiddenHeadersAt | undefined, direction: IRange.Direction, first: boolean, limit: number) => number;
+    /**
+     * Returns the cells as an ordered list of ranges.  The first range is the active range.
+     * If there are no ranges then the active coord will be returns as a range.
+     * @remarks
+     * * Always return at least 1 range unless the selection is null.
+     */
+    export const selectionToRanges: (selection: Partial<IRangeSelection.Coords>) => IRange.Coords[];
 }
 declare module "selection/RangeSelection" {
     import { IRange } from '@sheetxl/primitives';
@@ -19012,6 +19036,8 @@ declare module "selection/RangeSelection" {
         navigate(direction: IRange.Direction, select?: boolean, contentful?: boolean, incrementAmount?: number): this;
         /** {@inheritDoc IRangeSelection.getCoords} */
         getCoords(): IRangeSelection.Coords;
+        /** {@inheritDoc IRangeSelection.getRangesCoords} */
+        getRangesCoords(coord?: Partial<IRangeSelection.Coords>): IRange.Coords[];
         /** {@inheritDoc IRangeSelection.updateCoords} */
         updateCoords(coords: IRangeSelection.Coords): this;
         /** {@inheritDoc IRangeSelection.isEntire} */
@@ -19745,7 +19771,7 @@ declare module "sheet/header/_HeaderUtils" {
     import { IRange } from '@sheetxl/primitives';
     import { ITypes } from "type/index";
     import { IStyle } from "style/index";
-    import { ICellHeaderRange } from "cellRange/index";
+    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
     import { IRangeSelection } from "selection/index";
     import { ISheetHeader } from "sheet/header/ISheetHeader";
     /**
@@ -19830,6 +19856,8 @@ declare module "sheet/header/_HeaderUtils" {
      */
     export function setOrClear<T = any>(container: Record<string, any>, key: string, newValue: T | null | undefined): void;
     /** @internal */
+    export const parseHeaderRangesAddress: (address: ICellHeaderRanges.Address, isColumn: boolean, defaultRange?: IRange.FixableCoords) => RunCoords[];
+    /** @internal */
     export const parseHeaderRangeAddress: (address: ICellHeaderRange.Address, isColumn: boolean, defaultRange?: IRange.FixableCoords) => RunCoords;
     /**
      * Create an invalid range.
@@ -19844,6 +19872,14 @@ declare module "sheet/header/_HeaderUtils" {
      * Create runs from selection.
      */
     export const createRunsFromSelection: (header: ISheetHeader, selection: IRangeSelection.Coords, maxRange: IRange.Coords) => ITypes.RunCoordValue<ISheetHeader.SelectedRun>[];
+    /**
+     * Converts a set of RunCoords into a set of Ranges.
+     */
+    export const runCoordsToRangeCoords: (runs: readonly Readonly<Partial<RunCoords>>[], entireRange: IRange.Coords, isColumn: boolean) => Partial<IRange.FixableCoords>[];
+    /**
+     * Returns a list of merged and non-overlapping run coordinates.
+     */
+    export const removeOverlappingRuns: (runs: readonly Readonly<Partial<RunCoords>>[], merge?: boolean) => RunCoords[];
 }
 declare module "sheet/header/SheetCellHeader" {
     import { IRange } from '@sheetxl/primitives';
@@ -19943,6 +19979,8 @@ declare module "sheet/header/SheetCellHeaderRange" {
         getUsedRange(options?: ICellHeaderRange.GetRangeOptions): this;
         /** {@inheritDoc ICellHeaderRange.getCount} */
         getCount(): number;
+        /** {@inheritDoc ICellHeaderRange.getHeaderCount} */
+        getHeaderCount(): number;
         /** {@inheritDoc ICellHeaderRange.getVisibleCount} */
         getVisibleCount(): number;
         /** {@inheritDoc ICellHeaderRange.isEntireHeaders} */
@@ -19969,6 +20007,53 @@ declare module "sheet/header/SheetCellHeaderRange" {
         get isICellHeaderRange(): true;
     }
 }
+declare module "sheet/header/SheetCellHeaderRanges" {
+    import { IRange } from '@sheetxl/primitives';
+    import { RunCoords } from '@sheetxl/utils';
+    import { ITransaction } from "transaction/index";
+    import { ICellHeader } from "cell/index";
+    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
+    import { SheetHeader } from "sheet/header/SheetHeader";
+    export class SheetCellHeaderRanges implements ICellHeaderRanges {
+        protected _header: any;
+        protected _coords: RunCoords[];
+        constructor(header: SheetHeader, coords: RunCoords[]);
+        /** {@inheritDoc ICellHeaderRanges.updateHeaders} */
+        updateHeaders(update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
+        /** {@inheritDoc ICellHeaderRanges.getCoords} */
+        getCoords(): RunCoords[];
+        /** {@inheritDoc ICellHeaderRanges.setHidden} */
+        setHidden(hidden?: boolean): this;
+        /** {@inheritDoc ICellHeaderRanges.getCount} */
+        getCount(): number;
+        /** {@inheritDoc ICellHeaderRanges.getHeaderCount} */
+        getHeaderCount(): number;
+        /** {@inheritDoc ICellHeaderRanges.getVisibleCount} */
+        getVisibleCount(): number;
+        /** {@inheritDoc ICellHeaderRanges.isEntireHeaders} */
+        isEntireHeaders(): boolean;
+        /** {@inheritDoc ICellHeaderRanges.isEntireHeaders} */
+        isEntireHeadersAny(): boolean;
+        /** {@inheritDoc ICellHeaderRanges.clear} */
+        clear(): this;
+        /** {@inheritDoc ICellHeaderRanges.setSize} */
+        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
+        /** {@inheritDoc ICellHeaderRanges.at} */
+        at(index: number): ICellHeaderRange;
+        /** {@inheritDoc ICellHeaderRanges.getOrientation} */
+        getOrientation(): IRange.Orientation;
+        /** {@inheritDoc ICellHeaderRanges.doBatch} */
+        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
+        /** {@inheritDoc ICellHeaderRanges.getSheetHeader} */
+        getSheetHeader<S>(): S;
+        /** {@inheritDoc ICellHeaderRanges.getA1} */
+        getA1(): string;
+        get [Symbol.toStringTag](): string;
+        toString(): string;
+        /** {@inheritDoc ICellHeaderRanges.isICellHeaderRanges} */
+        get isICellHeaderRanges(): true;
+    }
+}
 declare module "sheet/header/SheetHeader" {
     import { IRange } from '@sheetxl/primitives';
     import { RunCoords } from '@sheetxl/utils';
@@ -19976,7 +20061,7 @@ declare module "sheet/header/SheetHeader" {
     import { ITransaction } from "transaction/index";
     import { IListener } from "listener/index";
     import { ICellHeader } from "cell/index";
-    import { ICellHeaderRange } from "cellRange/index";
+    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
     import { IRangeSelection } from "selection/index";
     import { ISheet } from "sheet/index";
     import { ISheetHeader } from "sheet/header/ISheetHeader";
@@ -20042,8 +20127,12 @@ declare module "sheet/header/SheetHeader" {
         } | void;
         /** {@inheritDoc ISheetHeader.getRange} */
         getRange(address: ICellHeaderRange.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+        /** {@inheritDoc ISheetHeader.getRanges} */
+        getRanges(address: ICellHeaderRanges.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
         /** {@inheritDoc ISheetHeader.getSelectedRange} */
         getSelectedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+        /** {@inheritDoc ISheetHeader.getSelectedRanges} */
+        getSelectedRanges(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
         /** {@inheritDoc ISheetHeader.getUsedRange} */
         getUsedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
         /** {@inheritDoc ISheetHeader.getEntireRange} */
@@ -20053,9 +20142,9 @@ declare module "sheet/header/SheetHeader" {
         /** {@inheritDoc ISheetHeader.updateHeaderPairs} */
         updateHeaderPairs(pairs: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
         protected _parseHeaderRangeAddress(address: ICellHeaderRange.Address): RunCoords;
-        update(addresses: ICellHeaderRange.Address | ICellHeaderRange.Address[], update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
-        setSize(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
-        setHidden(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], hidden?: boolean): this;
+        protected _update(addresses: ICellHeaderRange.Address | ICellHeaderRange.Address[], update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
+        protected _setSize(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
+        protected _setHidden(address: ICellHeaderRange.Address | ICellHeaderRange.Address[], hidden?: boolean): this;
         protected _clear(coords: RunCoords, options?: ICellHeaderRange.UpdateHeadersOptions): void;
         protected _getSnapshot(coordsFrom?: RunCoords, optionsMark?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
         /** {@inheritDoc ISheetHeader.isProtected} */
@@ -21726,7 +21815,7 @@ declare module "sheet/SheetRanges" {
     import type { ITransaction } from "transaction/index";
     import type { IListener } from "listener/index";
     import type { ICell } from "cell/index";
-    import type { ICellRanges, ICellRange } from "cellRange/index";
+    import type { ICellRanges, ICellRange, ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
     import type { IStyle } from "style/index";
     import type { ISheet } from "sheet/index";
     export interface SheetRangesOptions {
@@ -21793,6 +21882,10 @@ declare module "sheet/SheetRanges" {
         getEntireRows(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
         /** {@inheritDoc ICellRanges.getEntireColumns} */
         getEntireColumns(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
+        /** {@inheritDoc ICellRange.getRowHeaders} */
+        getRowHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
+        /** {@inheritDoc ICellRange.getColumnHeaders}*/
+        getColumnHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
         /** {@inheritDoc ICellRanges.getDefaultShiftOrientation} */
         getDefaultShiftOrientation(): IRange.Orientation;
         /** {@inheritDoc ICellRanges.getCount} */
@@ -22403,7 +22496,7 @@ declare module "sheet/Sheet" {
         /** @internal */
         protected _commitAndAutoSelect(trans: ITransaction, selection: Partial<IRangeSelection.Coords>, selectOptions?: boolean | ICellRange.SelectOptions, commitOptions?: ITransaction.StoreOperationOptions<CommitView>, orientation?: IRange.Orientation): Promise<IRange.Coords[]>;
         /** @internal */
-        protected _autoSelect(options?: boolean | ICellRange.SelectOptions, selection?: Partial<IRangeSelection.Coords>, orientation?: IRange.Orientation): Promise<IRange.Coords[]>;
+        protected _autoSelect(options?: boolean | ICellRange.SelectOptions, selectionOverride?: Partial<IRangeSelection.Coords>, orientation?: IRange.Orientation): Promise<IRange.Coords[]>;
         /** {@inheritDoc ISheet.getSelection} */
         getSelection(): IRangeSelection;
         /** {@inheritDoc ISheet.getView} */
@@ -24160,24 +24253,48 @@ declare module "sheet/header/ISheetHeader" {
     import { ITransaction } from "transaction/index";
     import { IListener } from "listener/index";
     import { ICellHeader } from "cell/index";
-    import { ICellHeaderRange } from "cellRange/index";
+    import { ICellHeaderRange, ICellHeaderRanges } from "cellRange/index";
     import { ISheet } from "sheet/ISheet";
     /**
      * Provides a programmatic interface for interacting with and modifying entire rows or columns in a spreadsheet,
      * allowing for actions such as inserting, deleting, resizing, and applying formatting changes.
      */
     export interface ISheetHeader extends ITransaction.ITransactional, IListener.ISource<ISheetHeader> {
+        /**
+         * Returns the header at a given offset. Will only return null for invalid header offset. To get a list of headers use {@link getRange}.
+         *
+         * @param index 0-based absolute index.
+         */
+        at(index: number): ICellHeader;
+        /**
+         * Returns a displayable title for the given index.
+         * @param index 0-based absolute index.
+         */
+        getTextAt(index: number): string;
         /**
          * Returns a range of cells for the specified range.
          *
+         * @param address The address or addresses of the header range to retrieve.
+         * @param options Options for retrieving the header ranges.
          * @see
          * {@link ICellHeaderRange}
          */
         getRange(address: ICellHeaderRange.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
         /**
-         * Returns the actives that are used in the selection.
+         * Returns a collection of header ranges for the specified ranges.
+         *
+         * @param address The address or addresses of the header ranges to retrieve.
+         * @param options Options for retrieving the header ranges.
+         */
+        getRanges(address: ICellHeaderRanges.Address, options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
+        /**
+         * Returns the active header range that is used in the selection.
          */
         getSelectedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+        /**
+         * Returns the active header ranges that are used in the selection.
+         */
+        getSelectedRanges(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
         /**
          * Returns the data ranges for headers that contain information.
          *
@@ -24196,46 +24313,6 @@ declare module "sheet/header/ISheetHeader" {
          * The orientation the headers manage.
          */
         getOrientation(): IRange.Orientation;
-        /**
-         * @see
-         * {@link ICellHeaderRange.setSize}
-         */
-        setSize(address: ICellHeaderRange.Address | readonly ICellHeaderRange.Address[], size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
-        /**
-         * @see
-         * {@link ICellHeaderRange.setHidden}
-         */
-        setHidden(address: ICellHeaderRange.Address | readonly ICellHeaderRange.Address[], hidden?: boolean): this;
-        /**
-         * Bulk update api.
-         * @remarks
-         * This only supports one range at a time but offers a few flavors
-         * * update(5, { size: '100px' }); // 0-based index
-         * * update({ min: 3, max: 4 }, { size: '100px' }); // 0-based index
-         * * update('e:f', { size: '100px' }); // 1-based a1 style
-         * * update({ colStart: 3, colEnd: 4 }, { size: '100px' }); // 0-based index
-         * * update('5:7', { size: '100px' }); // 1-based a1 style
-         * * update({ rowStart: 3, rowEnd: 4 }, { size: '100px' }); // 0-based index
-         */
-        update(address: ICellHeaderRange.Address | readonly ICellHeaderRange.Address[], update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
-        /**
-         * Sets the headers. This supports setting values as a batch.
-         * @remarks
-         * When setting headers the cells references by this sheet will not update.
-         * To ensure they are updated on the sheet call updateHeaderPairs with the range from the header.
-         */
-        updateHeaderPairs(pairs: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
-        /**
-         * Returns the header at a given offset. Will only return null for invalid header offset. To get a list of headers use {@link getRange}.
-         *
-         * @param index 0-based absolute index.
-         */
-        at(index: number): ICellHeader;
-        /**
-         * Returns a displayable title for the given index.
-         * @param index 0-based absolute index.
-         */
-        getTextAt(index: number): string;
         /**
          * Returns a flag indicating if the headers are protected by the sheet.
          */
@@ -24318,6 +24395,14 @@ declare module "sheet/header/ISheetHeader" {
          * Returns a list of SelectedRuns.
          */
         getSelectedRuns(): readonly ITypes.RunCoordValue<ISheetHeader.SelectedRun>[];
+        /**
+         * Sets the headers. This supports setting values as a batch.
+         *
+         * @remarks
+         * When setting headers the cells references by this sheet will not update.
+         * To ensure they are updated on the sheet call updateHeaderPairs with the range from the header.
+         */
+        updateHeaderPairs(pairs: ICellHeaderRange.AddressUpdatePair[], options?: ICellHeaderRange.UpdateHeadersOptions): RunCoords[] | null;
         /**
          * Returns the sheet model used for the header.
          */
@@ -24531,6 +24616,10 @@ declare module "sheet/_SheetUtils" {
      * Wraps each value in a ContentfulEntry
      */
     export const tuplesToContentfulEntries: (gridTuple: Tuple.GridTuple<Scalar>, isColumn: boolean) => ISpatialMap.Entry<ContentfulEntry>[];
+    /**
+     * Expands ranges to include merges.
+     */
+    export const expandToIncludeMerges: (ranges: readonly IRange.Coords[], mergeSpatial: ISpatialMap<MergeEntry>, entireCoords: IRange.Coords) => IRange.Coords[];
     /**
      * Creates a IRangeSelection.Coords from an array of ranges.
      *
@@ -24538,23 +24627,13 @@ declare module "sheet/_SheetUtils" {
      * @param cell if provided will try to fit within the cell
      * @param rangeIndex *default* `ranges.length 1 unless this is a single cell then -1`.
      */
-    export const toSelection: (ranges: readonly IRange.Coords[], cell?: IRange.CellCoords, rangeIndex?: number) => IRangeSelection.Coords;
-    /**
-     * Expands ranges to include merges.
-     */
-    export const expandToIncludeMerges: (ranges: readonly IRange.Coords[], mergeSpatial: ISpatialMap<MergeEntry>, entireCoords: IRange.Coords) => IRange.Coords[];
-    /**
-     * Returns the cells as an ordered list of ranges.  The first range is the active range.
-     * If there are no ranges then the active coord will be returns as a range.
-     * @remarks
-     * * Always return at least 1 range unless the selection is null.
-     */
-    export const selectionToRanges: (selection: Partial<IRangeSelection.Coords>) => IRange.Coords[];
+    export const toRangeSelectionCoords: (ranges: readonly IRange.Coords[], cell?: IRange.CellCoords, rangeIndex?: number) => IRangeSelection.Coords;
     /**
      * Creates a IRangeSelection.Coords from an array of ranges.
      *
      * @param ranges
      * @param rangeIndex @defaultValue ranges.length 1 unless this is a single cell then -1
+     * @deprecated use toRangeSelectionCoords
      */
     export const rangesToSelection: (ranges: readonly IRange.Coords[], rangeIndex?: number) => IRangeSelection.Coords;
     export type OrientedStyled = {
@@ -31565,7 +31644,7 @@ declare module "sort/ISort" {
         interface DefaultSortCriteria {
             /**
              * The cords that will be sorted.
-             * This may ignore the header.
+             * This will include headers even if the are ignored.
              */
             coords: IRange.Coords;
             /**
@@ -31579,6 +31658,10 @@ declare module "sort/ISort" {
              * If no headers are found this will be empty.
              */
             headers: Map<number, string>;
+            /**
+             * The coords without any headers.
+             */
+            sortCoords: IRange.Coords;
         }
         /**
          * Extends sort options to include options for sorting a range.
@@ -31659,399 +31742,125 @@ declare module "sort/index" {
     export * from "sort/IAutoSort";
     export * from "sort/Sort";
 }
-declare module "cellRange/ICellRanges" {
-    import type { Scalar, IRange } from '@sheetxl/primitives';
-    import type { IListener } from "listener/index";
+declare module "cellRange/ICellHeaderRange" {
+    import type { IRange } from '@sheetxl/primitives';
+    import type { RunCoords, ReferenceableClipboard } from '@sheetxl/utils';
     import type { ITransaction } from "transaction/index";
-    import type { IStyle } from "style/index";
-    import type { ICell } from "cell/index";
-    import type { ISheet } from "sheet/index";
+    import type { ICellHeader } from "cell/index";
     import type { ICellRange } from "cellRange/ICellRange";
     /**
-     * An `ICellRanges` is a collection of {@link ICellRange}s.
-     *
-     * Useful when working with a discontinuous set of ranges.
+     * Represents a collection of ICellHeaders.
      */
-    export interface ICellRanges {
-        /**
-         * {@inheritDoc ICellRange.getMerges}
-         */
-        getMerges(): IRange.Coords[];
+    export interface ICellHeaderRange {
         /**
-         * {@inheritDoc ICellRange.getSheet}
+         * The RunCoords for the range.
          */
-        getSheet(): ISheet;
+        getCoords(): ICellHeaderRange.Coords;
         /**
-         * Returns the style for the range.
+         * Iterate over cells headers.
          *
          * @remarks
-         * When querying the style the values will always be for the top left. However the
-         * set values work for the entire range.
+         * * Callbacks can return a 'break' value to stop the visit.
          */
-        getStyle(): IStyle;
+        forEach<T = any>(callback: ICellHeaderRange.ForEachCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
         /**
-         * {@inheritDoc ICellRange.find}
+         * Returns the header at a location relative to the range.
+         *
+         * @param index
          */
-        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
+        at(index: number): ICellHeader;
         /**
-         * Iterates over the values, yielding each values in the collection.
+         * Set the size of the headers.
          *
-         * @remarks
-         * This does not iterate over the ranges but rather the individual cells within the ranges.
-         * @see {@link ICellRanges.entries()}
+         * @param size This can be a number of a string with units
+         * @param options {@link ICellHeaderRange.SetSizeOptions}
          */
-        [Symbol.iterator](): IterableIterator<Scalar>;
+        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
         /**
-         * Returns an iterator that allows you to iterate over the individual cells within the ranges,
-         * yielding pairs of `IteratorContext` and a `Value`.
-         *
-         * @param options Configuration options for the iterator, such as filtering or sorting.
-         * @returns An iterator that yields `[ICell.IteratorContext, Value]` tuples for each value within the range.
+         * Hides or show the columns for the given range.
          *
-         * @remarks
-         * If the ranges overlap this will return the same value multiple times. If each cell
-         * should only be visited once, use {@link ICellRanges.getFlattened} to remove overlaps.
+         * @defaultValue false
          */
-        entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
+        setHidden(hidden?: boolean): this;
         /**
-         * {@inheritDoc ICellRange.autoFit}
+         * Provides a convenient method for setting values with a range of calls.
+         *
+         * @remarks
+         * If an array is provided then values will be in row-major order and will
+         * repeat if the range is larger than the array
          */
-        autoFit(options?: ICellRange.AutoFitOptions): this;
+        updateHeaders(values: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
         /**
-         * {@inheritDoc ICellRange.calculate}
+         * Returns the data ranges for headers that contain information.
+         *
+         * @remarks
+         * * This is NOT the last cell that may have data or has been resized.
+         * * This also has nothing to do with the selection bounds.
          */
-        calculate(fullRecalc?: boolean): this;
+        getUsedRange(options?: ICellHeaderRange.GetRangeOptions): this;
         /**
-         * {@inheritDoc ICellRange.clear}
+         * Clear the header format. Specially this will clear the sizes.
          */
-        clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
+        clear(): this;
         /**
-         * {@inheritDoc ICellRange.merge}
+         * Returns the number of headers included in the range.
          */
-        merge(options?: IRange.Orientations | ICellRange.MergeOptions): this;
+        getCount(): number;
         /**
-         * {@inheritDoc ICellRange.unmerge}
+         * Returns the number of headers.
          */
-        unmerge(options?: ITransaction.OperationOptions): this;
+        getHeaderCount(): number;
         /**
-         * {@inheritDoc ICellRange.insert}
+         * Returns the number of visible headers in the range.
          */
-        insert(options?: IRange.Orientation | ICellRange.InsertOptions): this;
+        getVisibleCount(): number;
         /**
-         * {@inheritDoc ICellRange.delete}
+         * Returns true if the range represents all headers.
          */
-        delete(options?: IRange.Orientation | ICellRange.DeleteOptions): this;
+        isEntireHeaders(): boolean;
         /**
-         * {@inheritDoc ICellRange.insertFrom}
+         * Returns the header orientation.
          */
-        insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
+        getOrientation(): IRange.Orientation;
         /**
-         * Returns a `ICellRange.ISnapshot` for all of the ranges.
+         * Similar to {@link forEach} but only spans that are different.
          *
          * @remarks
-         * * This will fail if the ranges are not 'aligned'.
-         * @see
-         * {@link ICellRange.getSnapshot}
-         */
-        getSnapshot(options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
-        /**
-         * {@inheritDoc ICellRange.copyFrom}
-         */
-        copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
-        /**
-         * {@inheritDoc ICellRange.getEntireRows}
+         * * Callbacks can return a 'break' value to stop the visit.
          */
-        getEntireRows(shiftColumns?: boolean, options?: ICellRange.GetRangeOptions): this;
+        forEachSpan<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
         /**
-         * {@inheritDoc ICellRange.getEntireColumns}
+         * Visits visible spans.
+         *
+         * @remarks
+         * * If there are no hidden headers this will still be called once.
          */
-        getEntireColumns(shiftRows?: boolean, options?: ICellRange.GetRangeOptions): this;
+        forEachVisibleSpan<T = any>(callback: ICellHeaderRange.ForEachVisibleSpanCallback<T>, options?: ICellHeaderRange.ForEachVisibleSpanOptions): T | void;
         /**
-         * {@inheritDoc ICellRange.getDefaultShiftOrientation}
+         * {@inheritDoc ICellRange.getSnapshot}
          */
-        getDefaultShiftOrientation(): IRange.Orientation;
+        getSnapshot(options?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
         /**
-         * Returns a set of ranges with overlaps removed and attempts to merge adjacent ranges into larger ranges.
+         * Perform operation on all ranges.
          *
-         * @remarks
-         * By default, ranges will also be merged into larger ranges where possible, but this behavior can be customized using the `mergeOrientation` parameter.
-         * This method will not modify the original ranges.
          * @see
-         * {@link isOverlapping}
+         * {@link ICellRange.doBatch}
          */
-        getFlattened(options?: ICellRange.GetFlattenOptions): this;
+        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
         /**
-         * {@inheritDoc ICellRange.getVisible}
+         * Returns the SheetHeader.
          */
-        getVisible(options?: ICellRange.GetVisibleOptions): this | null;
+        getSheetHeader<S>(): S;
         /**
          * {@inheritDoc ICellRange.getA1}
          */
         getA1(): string;
         /**
-         * {@inheritDoc ICellRange.getCounts}
-         */
-        getCounts(types?: Partial<Record<ICell.Content, number | boolean>>): ICellRange.Counts | null;
-        /**
-         * {@inheritDoc ICellRange.isContentful}
+         * Returns the address as a string.
          */
-        isContentful(types?: ICell.Content | ICell.Content[]): boolean;
+        toString(): string;
         /**
-         * Returns the count for all rows in the ranges. This will ensure rows that are included in multiples ranges are
-         * not double counted.
-         */
-        getRowCount(): number;
-        /**
-         * Returns the count for all columns in the ranges. This will ensure columns that are included in multiples ranges are
-         * not double counted.
-         */
-        getColumnCount(): number;
-        /**
-         * {@inheritDoc ICellRange.isReadOnly}
-         */
-        isReadOnly(): boolean;
-        /**
-         * Returns a flag indicating if any of the ranges are overlapping.
-         *
-         * @remarks
-         * To get a range with no overlaps {@link ICellRanges.getFlattened} can be used.
-         */
-        isOverlapping(): boolean;
-        /**
-         * Returns `true` if all of the the ranges have selected all of the rows.
-         *
-         * @remarks
-         * This is different from `isEntireRowsAny` in that it will return `true` if 'ALL' of the
-         * ranges have isEntireRows `true`.
-         */
-        isEntireRows(): boolean;
-        /**
-         * Returns `true` if any of the ranges have selected all of the rows.
-         *
-         * @remarks
-         * This is different from `isEntireRows` in that it it will return true if 'ANY' of the
-         * ranges have isEntireRows `true`.
-         */
-        isEntireRowsAny(): boolean;
-        /**
-         * Returns `true` if all of the the ranges have selected all of the columns.
-         *
-         * @remarks
-         * This is different from `isEntireColumnsAny` in that it will return `true` if 'ALL' of the
-         * ranges have isEntireColumns `true`.
-         */
-        isEntireColumns(): boolean;
-        /**
-         * Returns `true` if any of the ranges have selected all of the columns.
-         *
-         * @remarks
-         * This is different from `isEntireColumns` in that it will return `true` if 'ANY' of the
-         * ranges have isEntireColumns `true`.
-         */
-        isEntireColumnsAny(): boolean;
-        /**
-         * Returns `true` if any of the ranges are invalid.
-         */
-        isInvalidAny(): boolean;
-        /**
-         * Returns a ranges with coordinates adjusted to be fixed (absolute) or flexible (relative).
-         *
-         * @see
-         * {@link ICellRange.getFixed}
-         */
-        getFixed(options: ICellRange.GetFixedOptions | boolean): this;
-        /**
-         * Returns the total number of contiguous ranges in this collection.
-         */
-        getCount(): number;
-        /**
-         * Returns the range at a specific index.
-         *
-         * @param index
-         */
-        at(index: number): ICellRange;
-        /**
-         * {@inheritDoc ICellRange.doBatch}
-         */
-        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
-        /**
-         * The RangeCoords.
-         */
-        getCoords(): readonly Readonly<IRange.FixableCoords>[];
-        /**
-         * Returns the total number of contiguous ranges in this collection.
-         */
-        getCount(): number;
-        /**
-         * Returns the range at a specific index.
-         * @param index
-         */
-        at(index: number): ICellRange;
-        /**
-         * Returns true if the range is invalid.
-         * This can occur if a range is removed or created with invalid coordinates.
-         */
-        isInvalid(): boolean;
-        /**
-         * Returns the address as a string.
-         */
-        toString(): string;
-        /**
-         * {@inheritDoc ICellRange.select}
-         */
-        select(options?: ICellRange.SelectOptions): Promise<this>;
-        /**
-         * {@inheritDoc ICellRange.addListener}
-         */
-        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
-        /**
-         * Returns an iterator that allows you to iterate over the individual values within the range.
-         *
-         * @param options Configuration options for the iterator, such as filtering or sorting.
-         * @returns An iterator that yields `Scalar` value, each representing a single cell within the range.
-         */
-        [Symbol.iterator](options?: ICellRange.IteratorOptions<any>): Iterator<Scalar>;
-        /**
-         * For runtime type checking.
-         */
-        readonly isICellRanges: true;
-    }
-    /**
-     * {@inheritDoc ICellRanges}
-     * @see
-     * ### **Interface**
-     *
-     * {@link ICellRanges}
-     */
-    export namespace ICellRanges {
-        /**
-         * The coord type for a ranges.
-         */
-        type Coords = IRange.Coords[];
-        /**
-         * Address for multiple {@link ICellRange}s.
-         */
-        type Address = ICellRanges | string | ICellRange.Address | readonly ICellRange.Address[];
-        /**
-         * Options when visiting a ICellRanges.
-         */
-        interface IteratorOptions<T = ICellRanges.Address> extends ICellRange.IteratorOptions<T> {
-        }
-        /**
-         * Shorthand for persisting.
-         */
-        type RefJSON = IRange.Coords[] | IRange.Coords | string;
-    }
-}
-declare module "cellRange/ICellHeaderRange" {
-    import type { IRange } from '@sheetxl/primitives';
-    import type { RunCoords, ReferenceableClipboard } from '@sheetxl/utils';
-    import type { ITransaction } from "transaction/index";
-    import type { ICellHeader } from "cell/index";
-    import type { ICellRange } from "cellRange/ICellRange";
-    /**
-     * Represents a collection of ICellHeaders.
-     */
-    export interface ICellHeaderRange {
-        /**
-         * The RunCoords for the range.
-         */
-        getCoords(): RunCoords;
-        /**
-         * Iterate over cells headers.
-         * @remarks
-         * * Callbacks can return a 'break' value to stop the visit.
-         */
-        forEach<T = any>(callback: ICellHeaderRange.ForEachCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
-        /**
-         * Returns the header at a location relative to the range.
-         * @param index
-         */
-        at(index: number): ICellHeader;
-        /**
-           * Set the size of the headers.
-           * @param size
-           * @param options {@link ICellHeaderRange.SetSizeOptions}
-           */
-        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
-        /**
-         * Hides or show the columns for the given range.
-         * @defaultValue false
-         */
-        setHidden(hidden?: boolean): this;
-        /**
-         * Returns the data ranges for headers that contain information.
-         *
-         * @remarks
-         * * This is NOT the last cell that may have data or has been resized.
-         * * This also has nothing to do with the selection bounds.
-         */
-        getUsedRange(options?: ICellHeaderRange.GetRangeOptions): this;
-        /**
-         * Clear the header format. Specially this will clear the sizes.
-         */
-        clear(): this;
-        /**
-         * Returns the number of headers included in the range.
-         */
-        getCount(): number;
-        /**
-         * Returns the number of visible headers in the range.
-         */
-        getVisibleCount(): number;
-        /**
-         * Returns true if the range represents all headers.
-         */
-        isEntireHeaders(): boolean;
-        /**
-         * Returns the header orientation.
-         */
-        getOrientation(): IRange.Orientation;
-        /**
-         * Similar to {@link forEach} but only spans that are different.
-         * @remarks
-         * * Callbacks can return a 'break' value to stop the visit.
-         */
-        forEachSpan<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
-        /**
-         * Visits visible spans.
-         *
-         * @remarks
-         * * If there are no hidden headers this will still be called once.
-         */
-        forEachVisibleSpan<T = any>(callback: ICellHeaderRange.ForEachVisibleSpanCallback<T>, options?: ICellHeaderRange.ForEachVisibleSpanOptions): T | void;
-        /**
-         * Provides a convenient method for setting values with a range of calls.
-         *
-         * @remarks
-         * If an array is provided then values will be in row-major order and will
-         * repeat if the range is larger than the array
-         */
-        updateHeaders(values: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
-        /**
-         * {@inheritDoc ICellRange.getSnapshot}
-         */
-        getSnapshot(options?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
-        /**
-         * Perform operation on all ranges.
-         * @see
-         * {@link ICellRange.doBatch}
-         */
-        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
-        /**
-         * Returns the SheetHeader.
-         */
-        getSheetHeader<S>(): S;
-        /**
-         * {@inheritDoc ICellRange.getA1}
-         */
-        getA1(): string;
-        /**
-         * Returns the address as a string.
-         */
-        toString(): string;
-        /**
-         * For runtime type checking.
+         * For runtime type checking.
          */
         readonly isICellHeaderRange: true;
     }
@@ -32063,6 +31872,10 @@ declare module "cellRange/ICellHeaderRange" {
      * {@link ICellHeaderRange}
      */
     export namespace ICellHeaderRange {
+        /**
+         * The coord type for a header range.
+         */
+        type Coords = RunCoords;
         /**
          * Specify either a range a run or a string.
          * @remarks
@@ -32200,11 +32013,13 @@ declare module "cellRange/ICellHeaderRange" {
             relativeSize?: boolean;
             /**
              * If this is set to `true` then the value will not be an autoSize value.
+             *
              * @defaultValue false
              */
             autoSize?: boolean;
             /**
              * If this is set to `true` then any headers that have custom sizes will be ignored.
+             *
              * @defaultValue false
              */
             skipCustomSize?: boolean;
@@ -32249,6 +32064,399 @@ declare module "cellRange/ICellHeaderRange" {
         }
     }
 }
+declare module "cellRange/ICellHeaderRanges" {
+    import type { IRange } from '@sheetxl/primitives';
+    import type { RunCoords } from '@sheetxl/utils';
+    import type { ITransaction } from "transaction/index";
+    import type { ICellHeader } from "cell/index";
+    import type { ICellHeaderRange } from "cellRange/ICellHeaderRange";
+    /**
+     * An `ICellHeaderRanges` is a collection of {@link ICellHeaderRange}s.
+     *
+     * Useful when working with a discontinuous set of ranges.
+     */
+    export interface ICellHeaderRanges {
+        /**
+         * The RunCoords for the range.
+         */
+        getCoords(): Readonly<ICellHeaderRanges.Coords>;
+        /**
+         * Returns the header range at a location relative to the range.
+         *
+         * @param index
+         */
+        at(index: number): ICellHeaderRange;
+        /**
+         * Returns the number of headers ranges.
+         */
+        getCount(): number;
+        /**
+         * {@inheritDoc ICellHeaderRange.setSize}
+         */
+        setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
+        /**
+         * {@inheritDoc ICellHeaderRange.setHidden}
+         */
+        setHidden(hidden?: boolean): this;
+        /**
+         * {@inheritDoc ICellHeaderRange.clear}
+         */
+        clear(): this;
+        /**
+         * Returns the number of headers.
+         *
+         * @remarks
+         * This will remove overlaps.
+         */
+        getHeaderCount(): number;
+        /**
+         * {@inheritDoc ICellHeaderRange.getVisibleCount}
+         */
+        getVisibleCount(): number;
+        /**
+         * Returns true if all of the ranges cover the entire headers.
+         */
+        isEntireHeaders(): boolean;
+        /**
+         * Returns true if any of the ranges cover entire headers.
+         */
+        isEntireHeadersAny(): boolean;
+        /**
+         * {@inheritDoc ICellHeaderRange.getOrientation}
+         */
+        getOrientation(): IRange.Orientation;
+        /**
+         * {@inheritDoc ICellHeaderRange.updateHeaders}
+         */
+        updateHeaders(values: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
+        /**
+         * {@inheritDoc ICellHeaderRange.doBatch}
+         */
+        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ICellHeaderRange.UpdateHeadersOptions): R | Promise<R>;
+        /**
+         * {@inheritDoc ICellHeaderRange.getSheetHeader}
+         */
+        getSheetHeader<S>(): S;
+        /**
+         * {@inheritDoc ICellHeaderRange.getA1}
+         */
+        getA1(): string;
+        /**
+         * {@inheritDoc ICellHeaderRange.toString}
+         */
+        toString(): string;
+        /**
+         * For runtime type checking.
+         */
+        readonly isICellHeaderRanges: true;
+    }
+    /**
+     * {@inheritDoc ICellHeaderRanges}
+     * @see
+     * ### **Interface**
+     *
+     * {@link ICellHeaderRanges}
+     */
+    export namespace ICellHeaderRanges {
+        /**
+         * The coord type for a header ranges.
+         */
+        type Coords = RunCoords[];
+        /**
+         * Address for multiple {@link ICellHeaderRange}s.
+         */
+        type Address = ICellHeaderRanges | string | ICellHeaderRange.Address | readonly ICellHeaderRange.Address[];
+        /**
+         * Shorthand for persisting.
+         */
+        type RefJSON = RunCoords[] | RunCoords | string;
+    }
+}
+declare module "cellRange/ICellRanges" {
+    import type { Scalar, IRange } from '@sheetxl/primitives';
+    import type { IListener } from "listener/index";
+    import type { ITransaction } from "transaction/index";
+    import type { IStyle } from "style/index";
+    import type { ICell } from "cell/index";
+    import type { ISheet } from "sheet/index";
+    import type { ICellRange } from "cellRange/ICellRange";
+    import type { ICellHeaderRange } from "cellRange/ICellHeaderRange";
+    import type { ICellHeaderRanges } from "cellRange/ICellHeaderRanges";
+    /**
+     * An `ICellRanges` is a collection of {@link ICellRange}s.
+     *
+     * Useful when working with a discontinuous set of ranges.
+     */
+    export interface ICellRanges {
+        /**
+         * {@inheritDoc ICellRange.getMerges}
+         */
+        getMerges(): IRange.Coords[];
+        /**
+         * {@inheritDoc ICellRange.getSheet}
+         */
+        getSheet(): ISheet;
+        /**
+         * 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;
+        /**
+         * {@inheritDoc ICellRange.find}
+         */
+        find(options: string | ICellRange.FindOptions): Iterator<ICell>;
+        /**
+         * Iterates over the values, yielding each values in the collection.
+         *
+         * @remarks
+         * This does not iterate over the ranges but rather the individual cells within the ranges.
+         * @see {@link ICellRanges.entries()}
+         */
+        [Symbol.iterator](): IterableIterator<Scalar>;
+        /**
+         * Returns an iterator that allows you to iterate over the individual cells within the ranges,
+         * yielding pairs of `IteratorContext` and a `Value`.
+         *
+         * @param options Configuration options for the iterator, such as filtering or sorting.
+         * @returns An iterator that yields `[ICell.IteratorContext, Value]` tuples for each value within the range.
+         *
+         * @remarks
+         * If the ranges overlap this will return the same value multiple times. If each cell
+         * should only be visited once, use {@link ICellRanges.getFlattened} to remove overlaps.
+         */
+        entries(options?: ICellRange.IteratorOptions): IterableIterator<ICellRange.Entry>;
+        /**
+         * {@inheritDoc ICellRange.autoFit}
+         */
+        autoFit(options?: ICellRange.AutoFitOptions): this;
+        /**
+         * {@inheritDoc ICellRange.calculate}
+         */
+        calculate(fullRecalc?: boolean): this;
+        /**
+         * {@inheritDoc ICellRange.clear}
+         */
+        clear(applyTo?: ICell.Content, options?: ITransaction.OperationOptions): this;
+        /**
+         * {@inheritDoc ICellRange.merge}
+         */
+        merge(options?: IRange.Orientations | ICellRange.MergeOptions): this;
+        /**
+         * {@inheritDoc ICellRange.unmerge}
+         */
+        unmerge(options?: ITransaction.OperationOptions): this;
+        /**
+         * {@inheritDoc ICellRange.insert}
+         */
+        insert(options?: IRange.Orientation | ICellRange.InsertOptions): this;
+        /**
+         * {@inheritDoc ICellRange.delete}
+         */
+        delete(options?: IRange.Orientation | ICellRange.DeleteOptions): this;
+        /**
+         * {@inheritDoc ICellRange.insertFrom}
+         */
+        insertFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.InsertFromOptions): Promise<this | null>;
+        /**
+         * Returns a `ICellRange.ISnapshot` for all of the ranges.
+         *
+         * @remarks
+         * * This will fail if the ranges are not 'aligned'.
+         * @see
+         * {@link ICellRange.getSnapshot}
+         */
+        getSnapshot(options?: ICellRange.CopyOptions): ICellRange.ISnapshot;
+        /**
+         * {@inheritDoc ICellRange.copyFrom}
+         */
+        copyFrom(source: ICellRange.Address | ICellRange.ISnapshot, options?: ICellRange.CopyOptions): Promise<this | null>;
+        /**
+         * {@inheritDoc ICellRange.getEntireRows}
+         */
+        getEntireRows(shiftColumns?: boolean, options?: ICellRange.GetRangeOptions): this;
+        /**
+         * {@inheritDoc ICellRange.getEntireColumns}
+         */
+        getEntireColumns(shiftRows?: boolean, options?: ICellRange.GetRangeOptions): this;
+        /**
+         * {@inheritDoc ICellRange.getRowHeaders}
+         */
+        getRowHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
+        /**
+         * {@inheritDoc ICellRange.getColumnHeaders}
+         */
+        getColumnHeaders(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRanges;
+        /**
+         * {@inheritDoc ICellRange.getDefaultShiftOrientation}
+         */
+        getDefaultShiftOrientation(): IRange.Orientation;
+        /**
+         * Returns a set of ranges with overlaps removed and attempts to merge adjacent ranges into larger ranges.
+         *
+         * @remarks
+         * By default, ranges will also be merged into larger ranges where possible, but this behavior can be customized using the `mergeOrientation` parameter.
+         * This method will not modify the original ranges.
+         * @see
+         * {@link isOverlapping}
+         */
+        getFlattened(options?: ICellRange.GetFlattenOptions): this;
+        /**
+         * {@inheritDoc ICellRange.getVisible}
+         */
+        getVisible(options?: ICellRange.GetVisibleOptions): this | null;
+        /**
+         * {@inheritDoc ICellRange.getA1}
+         */
+        getA1(): string;
+        /**
+         * {@inheritDoc ICellRange.getCounts}
+         */
+        getCounts(types?: Partial<Record<ICell.Content, number | boolean>>): ICellRange.Counts | null;
+        /**
+         * {@inheritDoc ICellRange.isContentful}
+         */
+        isContentful(types?: ICell.Content | ICell.Content[]): boolean;
+        /**
+         * Returns the count for all rows in the ranges. This will ensure rows that are included in multiples ranges are
+         * not double counted.
+         */
+        getRowCount(): number;
+        /**
+         * Returns the count for all columns in the ranges. This will ensure columns that are included in multiples ranges are
+         * not double counted.
+         */
+        getColumnCount(): number;
+        /**
+         * {@inheritDoc ICellRange.isReadOnly}
+         */
+        isReadOnly(): boolean;
+        /**
+         * Returns a flag indicating if any of the ranges are overlapping.
+         *
+         * @remarks
+         * To get a range with no overlaps {@link ICellRanges.getFlattened} can be used.
+         */
+        isOverlapping(): boolean;
+        /**
+         * Returns `true` if all of the the ranges have selected all of the rows.
+         *
+         * @remarks
+         * This is different from `isEntireRowsAny` in that it will return `true` if 'ALL' of the
+         * ranges have isEntireRows `true`.
+         */
+        isEntireRows(): boolean;
+        /**
+         * Returns `true` if any of the ranges have selected all of the rows.
+         *
+         * @remarks
+         * This is different from `isEntireRows` in that it it will return true if 'ANY' of the
+         * ranges have isEntireRows `true`.
+         */
+        isEntireRowsAny(): boolean;
+        /**
+         * Returns `true` if all of the the ranges have selected all of the columns.
+         *
+         * @remarks
+         * This is different from `isEntireColumnsAny` in that it will return `true` if 'ALL' of the
+         * ranges have isEntireColumns `true`.
+         */
+        isEntireColumns(): boolean;
+        /**
+         * Returns `true` if any of the ranges have selected all of the columns.
+         *
+         * @remarks
+         * This is different from `isEntireColumns` in that it will return `true` if 'ANY' of the
+         * ranges have isEntireColumns `true`.
+         */
+        isEntireColumnsAny(): boolean;
+        /**
+         * Returns `true` if any of the ranges are invalid.
+         */
+        isInvalidAny(): boolean;
+        /**
+         * Returns a ranges with coordinates adjusted to be fixed (absolute) or flexible (relative).
+         *
+         * @see
+         * {@link ICellRange.getFixed}
+         */
+        getFixed(options: ICellRange.GetFixedOptions | boolean): this;
+        /**
+         * Returns the total number of contiguous ranges in this collection.
+         */
+        getCount(): number;
+        /**
+         * Returns the range at a specific index.
+         *
+         * @param index
+         */
+        at(index: number): ICellRange;
+        /**
+         * {@inheritDoc ICellRange.doBatch}
+         */
+        doBatch<R>(callback: (commit: ITransaction.ICommit) => R | Promise<R>, options?: string | ITransaction.OperationOptions): R | Promise<R>;
+        /**
+         * The RangeCoords.
+         */
+        getCoords(): readonly Readonly<IRange.FixableCoords>[];
+        /**
+         * Returns true if the range is invalid.
+         * This can occur if a range is removed or created with invalid coordinates.
+         */
+        isInvalid(): boolean;
+        /**
+         * Returns the address as a string.
+         */
+        toString(): string;
+        /**
+         * {@inheritDoc ICellRange.select}
+         */
+        select(options?: ICellRange.SelectOptions): Promise<this>;
+        /**
+         * {@inheritDoc ICellRange.addListener}
+         */
+        addListener(listener: ICellRange.Listener, options?: ICellRange.ListenerOptions): IListener.Remove;
+        /**
+         * Returns an iterator that allows you to iterate over the individual values within the range.
+         *
+         * @param options Configuration options for the iterator, such as filtering or sorting.
+         * @returns An iterator that yields `Scalar` value, each representing a single cell within the range.
+         */
+        [Symbol.iterator](options?: ICellRange.IteratorOptions<any>): Iterator<Scalar>;
+        /**
+         * For runtime type checking.
+         */
+        readonly isICellRanges: true;
+    }
+    /**
+     * {@inheritDoc ICellRanges}
+     * @see
+     * ### **Interface**
+     *
+     * {@link ICellRanges}
+     */
+    export namespace ICellRanges {
+        /**
+         * The coord type for a ranges.
+         */
+        type Coords = IRange.Coords[];
+        /**
+         * Address for multiple {@link ICellRange}s.
+         */
+        type Address = ICellRanges | string | ICellRange.Address | readonly ICellRange.Address[];
+        /**
+         * Options when visiting a ICellRanges.
+         */
+        interface IteratorOptions<T = ICellRanges.Address> extends ICellRange.IteratorOptions<T> {
+        }
+        /**
+         * Shorthand for persisting.
+         */
+        type RefJSON = IRange.Coords[] | IRange.Coords | string;
+    }
+}
 declare module "cellRange/ICellRange" {
     import { type Scalar, type JSScalar, type JSScalarUpdate, IRange } from '@sheetxl/primitives';
     import type { Bounds, ReferenceableClipboard } from '@sheetxl/utils';
@@ -33860,6 +34068,7 @@ declare module "cellRange/index" {
     export * from "cellRange/ICellRange";
     export * from "cellRange/ICellRanges";
     export * from "cellRange/ICellHeaderRange";
+    export * from "cellRange/ICellHeaderRanges";
 }
 declare module "anchored/IAnchored" {
     import type { IRange } from '@sheetxl/primitives';