@sheetxl/sdk 0.7.27 → 0.7.28-beta.2

package/types/src/sheet/style/SheetNamedStyle.d.ts

@@ -0,0 +1,47 @@
+import { IRange } from '@sheetxl/primitives';
+import { IProperties } from '../../type';
+import { IStyle, IStyleCollection } from '../../style';
+import { ISpatialMap } from '../../collections/ISpatialMap';
+import { SheetDirectStyle } from './SheetDirectStyle';
+export declare class NamedRangedStyle extends SheetDirectStyle {
+    constructor(styles: IStyleCollection, properties?: IStyle.Properties);
+    isEmpty(): boolean;
+    /** {@inheritDoc IProperties.ICellRanged.getCoords} */
+    getCoords(): Readonly<IRange.Coords>;
+    /** {@inheritDoc IProperties.ICellRanged.cloneWithUpdate} */
+    cloneWithUpdate(updates: IStyle.Properties): this;
+    protected _createShifted(coords: IRange.Coords): this;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getShifted} */
+    getShifted(options: ISpatialMap.ShiftDetails<this>): ISpatialMap.Entry<this> | null;
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getSplit} */
+    getSplit(coords: [IRange.Coords, IRange.Coords], _axis: IRange.Axis): [this, this];
+    /** {@inheritDoc ISpatialMap.IUpdatableValue.getMerged} */
+    getMerged(other: this, coords: IRange.Coords, _axis: IRange.Axis): this | undefined;
+    getPropertiesAt(_rowIndex: number, _colIndex: number): Readonly<IStyle.Properties>;
+    toJSON(): IStyle.JSON;
+}
+export declare class SheetNamedStyle implements IStyle.INamed {
+    private _name;
+    private _properties;
+    private _rangeStyle;
+    private _builtInID;
+    private _doDelete;
+    constructor(style: IStyleCollection, properties: Readonly<IStyle.NamedProperties>, doDelete: (style: IStyle.INamed | string) => void, builtInID?: number | null);
+    /** {@inheritDoc IStyle.INamed.getRanged} */
+    getRanged(): IProperties.ICellRanged<IStyle.Properties>;
+    /** {@inheritDoc IStyle.INamed.getName} */
+    getName(): string;
+    /** {@inheritDoc IStyle.INamed.isHidden} */
+    isHidden(): boolean;
+    /** {@inheritDoc IStyle.INamed.getILevel} */
+    getILevel(): number | null;
+    /** {@inheritDoc IStyle.INamed.getBuiltInID} */
+    getBuiltInID(): number | null;
+    /** {@inheritDoc IStyle.INamed.delete} */
+    delete(): void;
+    /** {@inheritDoc IStyle.INamed.toJSON} */
+    toJSON(): IStyle.NamedJSON;
+    /** {@inheritDoc IStyle.INamed.isINamed} */
+    get isINamed(): true;
+}
+//# sourceMappingURL=SheetNamedStyle.d.ts.map

package/types/src/sheet/style/SheetTableStyle.d.ts

@@ -0,0 +1,47 @@
+import { IRange } from '@sheetxl/primitives';
+import { IProperties } from '../../type';
+import { IStyle, IStyleCollection } from '../../style';
+import { ITableStyle, ITable } from '../../table';
+export declare class TableRangedStyle implements IProperties.ICellRanged<IStyle.Properties> {
+    protected _styles: IStyleCollection;
+    protected _properties: ITableStyle.Properties;
+    protected _table: ITable;
+    /**
+     * Memoized merged styles keyed by cell 'permutation'. A table style resolves to a small
+     * bounded set of distinct cell styles (header/total membership, edge flags, stripe phase, ...)
+     * rather than one per cell. Every live table-state value that feeds the merge folds into the
+     * key, so entries never go stale; the instance itself is dropped with the table's
+     * `_stylePropsCache` on any table or table-styles change (see `ITable.getRangedStyle`).
+     */
+    protected _permCache: Map<string, Readonly<IStyle.Properties>> | null;
+    constructor(table: ITable, styles: IStyleCollection, properties: ITableStyle.Properties);
+    protected _resolveProperties(properties: ITableStyle.Properties): ITableStyle.Properties;
+    getCoords(): IRange.Coords;
+    getPropertiesAt(rowIndex: number, colIndex: number): Readonly<IStyle.Properties>;
+}
+export declare class SheetTableStyle implements ITableStyle {
+    protected _styles: IStyleCollection;
+    protected _properties: Readonly<ITableStyle.Properties>;
+    protected _isBuiltIn: boolean;
+    protected _doDelete: ((styleName: string) => void) | undefined;
+    constructor(styles: IStyleCollection, properties: ITableStyle.Properties, isBuiltIn: boolean, _doDelete?: (styleName: string) => void);
+    protected _resolveProperties(properties: ITableStyle.Properties): ITableStyle.Properties;
+    /** {@inheritDoc ITableStyle.delete} */
+    delete(): void;
+    /** {@inheritDoc ITableStyle.getRanged} */
+    getRanged(table: ITable): IProperties.ICellRanged<IStyle.Properties>;
+    /** {@inheritDoc ITableStyle.getProperties} */
+    getProperties(): Readonly<ITableStyle.Properties>;
+    /** {@inheritDoc ITableStyle.getName} */
+    getName(): string;
+    /** {@inheritDoc ITableStyle.isShownInTableStyles} */
+    isShownInTableStyles(): boolean;
+    /** {@inheritDoc ITableStyle.isShownInPivotStyles} */
+    isShownInPivotStyles(): boolean;
+    /** {@inheritDoc ITableStyle.isBuiltIn} */
+    isBuiltIn(): boolean;
+    /** {@inheritDoc ITableStyle.toJSON} */
+    toJSON(): ITableStyle.JSON;
+    get isITableStyle(): true;
+}
+//# sourceMappingURL=SheetTableStyle.d.ts.map

package/types/src/sheet/style/UsedRangeSpatialMap.d.ts

@@ -0,0 +1,80 @@
+import { RangeCoords } from '@sheetxl/utils';
+import { SpatialMap, ISpatialMap } from '../../collections';
+/**
+ * Spatial map with logical boundary awareness that distinguishes between virtual extent and actual content.
+ *
+ * @remarks
+ *
+ * **Purpose**: Tracks ranges within a logical boundary (`entireCoords`) while treating ranges adjacent
+ * to trailing edges as "header-like" - they contribute content only in the opposite dimension.
+ *
+ * **Use Case**: Excel-style row/column headers where trailing styles (e.g., column header spanning
+ * to max column, or row header spanning to max row) shouldn't expand the contentful bounds in that dimension.
+ *
+ * **Behavior**:
+ * - Ranges with `colEnd >= entireCoords.colEnd` are collapsed to their leftmost column for content calculation
+ * - Ranges with `rowEnd >= entireCoords.rowEnd` are collapsed to their topmost row for content calculation
+ * - This prevents trailing headers from artificially expanding the "used range" in their spanning dimension
+ *
+ * @example
+ * ```typescript
+ * const map = new UsedRangeSpatialMap({ entireCoords: { colStart: 0, rowStart: 0, colEnd: 100, rowEnd: 100 } });
+ * map.add({ colStart: 0, rowStart: 0, colEnd: 100, rowEnd: 0 }); // Column header (full width)
+ * map.add({ colStart: 0, rowStart: 5, colEnd: 10, rowEnd: 10 }); // Actual content
+ *
+ * // Contentful coords excludes the full-width header's horizontal span
+ * const content = map.getContentfulCoords(); // { colStart: 0, rowStart: 0, colEnd: 10, rowEnd: 10 }
+ * ```
+ */
+export interface IUsedRangeSpatialMap<T = any> extends ISpatialMap<T> {
+    /**
+     * Returns the smallest range containing all "contentful" ranges, treating trailing-edge ranges specially.
+     *
+     * @remarks
+     * Ranges extending to `entireCoords` boundaries are collapsed in that dimension:
+     * - Column-spanning ranges (colEnd >= entireCoords.colEnd) contribute only their top-left column
+     * - Row-spanning ranges (rowEnd >= entireCoords.rowEnd) contribute only their top-left row
+     *
+     * @returns The bounding rectangle of actual content, or `null` if empty or only trailing-edge ranges exist
+     */
+    getContentfulCoords(): RangeCoords | null;
+    /**
+     * Sets the logical boundary for the map, defining what constitutes a "trailing edge".
+     *
+     * @param coords - The maximum logical extent; ranges reaching these boundaries are treated as headers
+     */
+    setEntireCoords(coords: RangeCoords): void;
+    /**
+     * Returns the logical boundary coordinates.
+     *
+     * @returns The entire coords, or `null` if not set
+     */
+    getEntireCoords(): RangeCoords | null;
+}
+export declare namespace IUsedRangeSpatialMap {
+    interface ConstructorOptions<T = any> extends ISpatialMap.ConstructorOptions<T> {
+        /**
+         * Specifies the logical maximum range that the map covers.
+         */
+        entireCoords: RangeCoords;
+    }
+}
+/**
+ * Implementation of `IUsedRangeSpatialMap`.
+ */
+export declare class UsedRangeSpatialMap<T = any> extends SpatialMap<T> implements IUsedRangeSpatialMap<T> {
+    protected _entireCoords: RangeCoords | undefined;
+    protected _contentfulCoords: RangeCoords | null | undefined;
+    constructor(options?: IUsedRangeSpatialMap.ConstructorOptions<T>);
+    /** {@inheritDoc IUsedRangeSpatialMap.getContentfulCoords} */
+    getContentfulCoords(): RangeCoords | null;
+    /** {@inheritDoc IUsedRangeSpatialMap.setEntireCoords} */
+    setEntireCoords(coords: RangeCoords): void;
+    /** {@inheritDoc IUsedRangeSpatialMap.getEntireCoords} */
+    getEntireCoords(): RangeCoords | null;
+    /** {@inheritDoc ISpatialMap.clone} */
+    clone(cloneKey?: any): this;
+    protected _onModified(): void;
+    protected _createClone(options: IUsedRangeSpatialMap.ConstructorOptions<T>): this;
+}
+//# sourceMappingURL=UsedRangeSpatialMap.d.ts.map

package/types/src/sheet/style/_Resolvers.d.ts

@@ -0,0 +1,41 @@
+import { TypedObject } from '@sheetxl/utils';
+import { IColor } from '../../color';
+import { IFill } from '../../fill';
+import { ITextFrame, IStyledFont } from '../../text';
+import { IBorder } from '../../border';
+import { NumberFormat } from '../../numFmt';
+import { IStyle, IStyleCollection } from '../../style';
+export declare const COLOR: TypedObject<IColor.Serializable, IColor, IStyleCollection>;
+export declare const BORDER_STROKE: TypedObject<IBorder.StrokeProperties<IColor.Serializable>, IBorder.IStroke, IStyleCollection>;
+export declare const CELL_BORDER: TypedObject<IBorder.Properties, IBorder, IStyleCollection>;
+export declare const CELL_NUM_FMT: TypedObject<string | NumberFormat.Type | number, any, IStyleCollection>;
+export declare const CELL_FONT: TypedObject<IStyledFont.Properties, IStyledFont, IStyleCollection>;
+export declare const CELL_ALIGNMENT: TypedObject<ITextFrame.IAlignment.Properties, ITextFrame.IAlignment, IStyleCollection>;
+export declare const FILL_NONE: TypedObject<IFill.NoneProperties, IFill.INone, IStyleCollection>;
+export declare const FILL_SOLID: TypedObject<IFill.SolidProperties, IFill.ISolid, IStyleCollection>;
+export declare const GRADIENT_STOP: TypedObject<IFill.GradientStopProperties, IFill.IGradientStop, IStyleCollection>;
+export declare const GRADIENT_STOPS: TypedObject<(IFill.GradientStopProperties | IColor.Serializable)[], (IFill.IGradientStop | IColor.Serializable)[], IStyleCollection>;
+export declare const FILL_GRADIENT: TypedObject<IFill.GradientProperties, IFill.IGradient, IStyleCollection>;
+export declare const FILL_PATTERN: TypedObject<IFill.PatternProperties, IFill.IPattern, IStyleCollection>;
+export declare const FILL: TypedObject<IFill.Properties | IFill.SolidProperties | IFill.GradientProperties | IFill.PatternProperties | IFill.NoneProperties, IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone, IStyleCollection>;
+export declare const CELL_STYLE: TypedObject<IStyle.Properties, IStyle, IStyleCollection>;
+/**
+ * The APPLY-direction cell style. Shares {@link CELL_STYLE}'s property tree but adds a `shorthand`
+ * that expands a `named` update: applying a named style covers the categories its definition
+ * declares (the definition's keys are the implicit 'style includes' mask - Excel's Style dialog
+ * checkboxes / OOXML apply flags), so the update gains explicit `null` clears (clear-and-inherit)
+ * for each covered category it doesn't itself set. The generic machinery does the rest (tombstone
+ * templates, splits, intersect merges); direct formatting the style does NOT cover cascades through.
+ *
+ * Deliberately a SEPARATE type from {@link CELL_STYLE}: the same property tree also powers the
+ * read-direction cascade (see SheetCell.getPropertiesAt), where the direct layer - which carries
+ * the `named` reference - merges OVER the named style's resolved base; expanding there would clear
+ * the very values being inherited.
+ *
+ * * `named: null` clears only the reference.
+ * * `Normal` covers every category (the reset style).
+ * * An {@link IStyle.INamed} value is normalized to its name (resolver-level `INamed` support).
+ */
+export declare const CELL_STYLE_APPLY: TypedObject<IStyle.Properties, IStyle, IStyleCollection>;
+export declare const NAMED_CELL_STYLE: TypedObject<IStyle.NamedProperties, IStyle.INamed, IStyleCollection>;
+//# sourceMappingURL=_Resolvers.d.ts.map

package/types/src/sheet/style/_StyleUtils.d.ts

@@ -0,0 +1,69 @@
+import { IRange } from '@sheetxl/primitives';
+import { ITypes } from '../../type';
+import { ICellHeader } from '../../cell';
+import { IStyle } from '../../style';
+import { IBorder } from '../../border';
+import { ISpatialMap } from '../../collections';
+/**
+ * @internal
+ */
+export declare function isEqualStrokeProperties(a: IBorder.StrokeProperties | undefined, b: IBorder.StrokeProperties | undefined): boolean;
+/**
+ * Splits a border range into a new range with adjusted border properties.
+ *
+ * @param border The original border properties.
+ * @param rangeFrom The original range coordinates.
+ * @param rangeTo The new range coordinates.
+ * @param isColumn Whether the split is for a column (true) or a row (false).
+ * @returns The adjusted border properties for the new range, or null if no borders remain.
+ *
+ * @remarks
+ * Edges are tested with `!== undefined` (not truthiness) on purpose: an update template's border may
+ * carry explicit `null` clears (see SheetDirectStyle update form), and those must localize to the
+ * same pieces a real stroke would.
+ */
+export declare function splitBorderRange(border: IBorder.Properties, rangeFrom: IRange.Coords, rangeTo: IRange.Coords, isColumn: boolean): Partial<IBorder.Properties> | null | undefined;
+/**
+ * Takes a range with a border and breaks it into range parts that can be used without
+ * any coordinates.
+ *
+ * @remarks
+ * * This allows for each cell style to know how to render it's borders without dereferencing from a range.
+ * * This was designed for Excel export compatibility.
+ * * We don't use in internally as we want the original 'border' intent to be maintained for
+ *   easy .toJSON and AI inference.
+ * * A range that reaches the grid's terminal row/column (Excel's `<col style>` reads back as a
+ *   full-height range) has no closing border at the boundary, so no end sliver is split off
+ *   there — a style-only piece at the last row/column materializes real `<c>` records and
+ *   Excel treats the whole grid as the used range.
+ */
+export declare function splitStyleBordersIntoSame(coords: IRange.Coords, json: IStyle.JSON, entireCoords?: IRange.Coords): IRange.JSONReferenceTuple<IStyle.JSON>[];
+export interface StyleRangesJSON {
+    cols: ITypes.RunCoordValue<ICellHeader.JSON>[];
+    rows: ITypes.RunCoordValue<ICellHeader.JSON>[];
+    cells: [coords: IRange.Coords, styleId: number][];
+}
+/**
+ * Creates style header from ranges styles.
+ *
+ * @remarks
+ * This is used to create an Excel compatible style header from ranged styles.
+ *
+ * This algo works by.
+ *
+ * 1. Identifying the total style count for rows and columns if > than 50% then it converts
+ *    the styles into a style header.
+ * 2. If then uses overlap CellRangeIterator to find any intersections.
+ */
+export declare function promoteStylesToHeaders(styles: StyleRangesJSON, entireCoords: IRange.Coords): StyleRangesJSON;
+/**
+ * Performs a shift but uses the entire range to ensure edge styles.
+ *
+ * @param options
+ * @param entireRange
+ *
+ * @remarks
+ * Returns an entry but requires the value be set/cloned.
+ */
+export declare function getEdgeAwareShifted<T = any>(options: ISpatialMap.ShiftDetails<T>, entireRange?: IRange.Coords): ISpatialMap.Entry<T> | null;
+//# sourceMappingURL=_StyleUtils.d.ts.map

package/types/src/sheet/style/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/types/src/sheetHeader/ISheetHeader.d.ts

@@ -0,0 +1,217 @@
+import { IRange } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
+import { ITypes } from '../type';
+import { ITransaction } from '../transaction';
+import { IListener } from '../listener';
+import { ICellHeader } from '../cell';
+import { ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
+import { ISheet } from '../sheet';
+/**
+ * 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 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.
+     *
+     * @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.
+     * @see
+     * {@link ICellRange.getUsedRange}
+     */
+    getUsedRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /**
+     * The entire range for the header.
+     */
+    getEntireRange(options?: ICellHeaderRange.GetRangeOptions): ICellHeaderRange;
+    /**
+     * The axis the headers manage.
+     */
+    getAxis(): IRange.Axis;
+    /**
+     * Returns a flag indicating if the headers are protected by the sheet.
+     */
+    isProtected(): boolean;
+    /**
+     * All header sizes are returned in pixels. This is done
+     * by multiplying the scaleFactor by the size on the cellHeader.
+     */
+    getScaleFactor(): number;
+    /**
+     * Returns the offset in pixels for the given header index.
+     * @param index 0-based absolute index.
+     */
+    getOffset(index: number): number;
+    /**
+     * Returns the index for the given header offset in pixels.
+     * @param offset 0-based pixels.
+     */
+    getIndex(offset: number): number;
+    /**
+     * Returns the visibleIndex for a given absolute index.
+     * * If it's hidden it will return a range of 1 with a value before the offset and after.
+     * * If it's visible then it will return a range of 0 with the min and max that exactly match the offset.
+     *
+     * @param index 0-based absolute index.
+     * @returns A {@link RunCoords} that  can be used to determine if an index is hidden.
+  
+     * @remarks
+     * If this is on the edge of the bounds this will return a +/- 1 the max bounds.
+     */
+    getVisibleIndex(index: number): Readonly<RunCoords>;
+    /**
+     * Returns the number of indices visible. Between to indices.
+     * @param indexFrom
+     * @param indexTo
+     */
+    getVisibleCount(indexFrom: number, indexTo: number): number;
+    /**
+     * Returns the size of the header in pixels. If a second argument is passed it
+     * will be the size of all the headers within the range.
+     * Note - It is expected that indexFrom will always be less than or equal to indexTo
+     */
+    getSpanSize(indexFrom: number, indexTo?: number): number;
+    /**
+     * The default header size if not adjusted.
+     */
+    getDefaultSize(): number;
+    /**
+     * The default header size in native units.
+     */
+    getDefaultSizeNative(): number;
+    /**
+     * The maximum size of the header in native units.
+     */
+    getMaxSize(): number;
+    /**
+     * The minimum size of the header in native units.
+     */
+    getMinSize(): number;
+    /**
+     * This is a very specific optimization function. When
+     * hiding many headers instead of scanning we can just skip.
+     * If `0` is returned then there are no hidden headers immediately
+     * following this one. If `1` is returned then only this header is hidden.
+     *
+     * @param index The location to start the search.
+     * @param reverse Indicates if search should scan in reverse. defaults to `false`.
+     * @returns The number of headers following the index.
+     */
+    hiddenHeadersAt(index: number, reverse?: boolean): number;
+    /**
+     * Returns true if any of the headers have the isHidden flag set to true or if any sizes are 0.
+     */
+    hasHidden(): boolean;
+    /**
+     * Returns true if header has a max selection at the given index.
+     */
+    isSelectedAll(index: number): boolean;
+    /**
+     * Returns true if header has a selection at the given index.
+     */
+    isSelected(index: number): boolean;
+    /**
+     * Returns the selected headers as contiguous runs; each run's `value` is `isSelectedAll` (whether
+     * that span is an entire-row/column selection).
+     *
+     * @see {@link IRangeSelection.getSelectedRuns} — the projection this reflects for the primary selection.
+     */
+    getSelectedRuns(): readonly ITypes.RunCoordValue<boolean>[];
+    /**
+     * 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.
+     */
+    getSheet(): ISheet;
+    /**
+     * Save the header state to a JSON object.
+     *
+     * @remarks
+     * Returns `null` if there is nothing to persist.
+     */
+    toJSON(): ISheetHeader.JSON | null;
+    /**
+     * Add Listeners.
+     *
+     * @see
+     * {@link IListener.ISource.addListeners}
+     */
+    addListeners(listeners: ISheetHeader.IListeners, options?: IListener.Options): IListener.Remove;
+    close(): void;
+}
+/**
+ * {@inheritDoc ISheetHeader}
+ * @see
+ * ### **Interface**
+ *
+ * {@link ISheetHeader}
+ */
+export declare namespace ISheetHeader {
+    /**
+     * Headers as runs, each addressed as an entire column or row (`'E:H'`, `'5:12'`).
+     *
+     * @remarks
+     * The address carries the orientation, so a row address is read by a column header collection
+     * and the reverse.
+     */
+    interface JSON {
+        headers: IRange.JSONReference<ICellHeader.JSON>[];
+        defaultSize?: number;
+    }
+    interface Events {
+        /**
+         * Called when headers sizes have changed.
+         */
+        onSizesChange?(source: ISheetHeader): void;
+        /**
+         * Called when headers visibility (hidden) has changed.
+         */
+        onHiddenChange?(source: ISheetHeader): void;
+    }
+    interface IListeners extends IListener.Callbacks<ISheetHeader, ISheetHeader.Events> {
+    }
+}
+//# sourceMappingURL=ISheetHeader.d.ts.map

package/types/src/sheetHeader/SheetCellHeader.d.ts

@@ -0,0 +1,61 @@
+import { IRange } from '@sheetxl/primitives';
+import { IStyleCollection } from '../style';
+import { ITable } from '../table';
+import { ICell, ICellHeader } from '../cell';
+import { ISheetHeader } from './ISheetHeader';
+import type * as _Utils from './_HeaderUtils';
+export declare class SheetCellHeader implements ICellHeader {
+    protected _sheetHeader: ISheetHeader;
+    protected _index: number;
+    protected _headerState: _Utils.CellHeaderState | null | undefined;
+    protected _template: ICell.Modifiers | null | undefined;
+    private _cellTemplate;
+    private _getColumnAt;
+    constructor(index: number, sheetHeader: ISheetHeader, headerState: _Utils.CellHeaderState | null | undefined, template: ICell.Modifiers | null | undefined, getColumnAt: ((index: number) => ITable.IColumn | null) | undefined);
+    /** {@inheritDoc ICellHeader.getSize} */
+    getSize(): number;
+    /** {@inheritDoc ICellHeader.getText} */
+    getText(): string;
+    /** {@inheritDoc ICellHeader.getAxis} */
+    getAxis(): IRange.Axis;
+    /** {@inheritDoc ICellHeader.isHidden} */
+    isHidden(): boolean;
+    /** {@inheritDoc ICellHeader.isCustomSize} */
+    isCustomSize(): boolean;
+    /** {@inheritDoc ICellHeader.getSheetHeader} */
+    getSheetHeader(): ISheetHeader;
+    /** {@inheritDoc ICell.getColumn} */
+    getColumn(): ITable.IColumn | null;
+    /** {@inheritDoc ICellHeader.asCell} */
+    asCell(): ICell;
+    /** {@inheritDoc ICellHeader.getSizeRelative} */
+    getSizeRelative(): number;
+    /** {@inheritDoc ICellHeader.createCellHeader} */
+    createCellHeader(update: ICellHeader.Modifiers): ICellHeader;
+    /** {@inheritDoc ICellHeader.isEqual} */
+    isEqual(other: ICellHeader): boolean;
+    /** {@inheritDoc ICellHeader.isEmpty} */
+    isEmpty(): boolean;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ICellHeader.isICellHeader} */
+    get isICellHeader(): true;
+}
+/**
+ * Callback for creating custom headers.
+ * Note - Not currently used. Formalize and make public or remove.
+ * @internal
+ */
+export interface CreateCellHeaderCallback {
+    (index: number, headers: ISheetHeader, hs: _Utils.CellHeaderState | null | undefined, template?: ICell.Modifiers | null): ICellHeader;
+}
+/**
+ * Note - Unlike SheetCell.resolveCellModifiers this does not return a ICellHeader.Modifiers.
+ *
+ * It returns a partial State with only the changed values (or null for clear).
+ * This is due to refactoring. Rationalize later.
+ *
+ * @internal
+ */
+export declare function resolveCellHeaderModifiers(sheetHeader: ISheetHeader, styles: IStyleCollection, prevHs: _Utils.CellHeaderState | null | undefined, update: ICellHeader.Update | undefined): _Utils.CellHeaderState | null | undefined;
+//# sourceMappingURL=SheetCellHeader.d.ts.map

package/types/src/sheetHeader/SheetCellHeaderRange.d.ts

@@ -0,0 +1,54 @@
+import { IRange } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { ICellHeader } from '../cell';
+import { ICellHeaderRange } from '../cellRange';
+import { CreateCellHeaderCallback } from './SheetCellHeader';
+import { SheetHeader } from './SheetHeader';
+export declare class SheetCellHeaderRange implements ICellHeaderRange {
+    protected _header: any;
+    protected _coords: RunCoords;
+    constructor(header: SheetHeader, coords: RunCoords);
+    protected _forEachSpan<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, optionsVisitor?: ICellHeaderRange.IteratorOptions, createCellHeader?: CreateCellHeaderCallback): T | void;
+    /** {@inheritDoc ICellHeaderRange.forEachSpan} */
+    forEachSpan<T = any>(callback: ICellHeaderRange.ForEachSpanCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
+    /** {@inheritDoc ICellHeaderRange.forEach} */
+    forEach<T>(callback: ICellHeaderRange.ForEachCallback<T>, options?: ICellHeaderRange.IteratorOptions): T | void;
+    /** {@inheritDoc ICellHeaderRange.updateHeaders} */
+    updateHeaders(update: ICellHeader.Update, options?: ICellHeaderRange.UpdateHeadersOptions): this;
+    /** {@inheritDoc ICellHeaderRange.getCoords} */
+    getCoords(): RunCoords;
+    /** {@inheritDoc ICellHeaderRange.getUsedRange} */
+    getUsedRange(options?: ICellHeaderRange.GetRangeOptions): this;
+    /** {@inheritDoc ICellHeaderRange.getCount} */
+    getCount(): number;
+    /** {@inheritDoc ICellHeaderRange.getHeaderCount} */
+    getHeaderCount(): number;
+    /** {@inheritDoc ICellHeaderRange.getVisibleCount} */
+    getVisibleCount(): number;
+    /** {@inheritDoc ICellHeaderRange.isEntireHeaders} */
+    isEntireHeaders(): boolean;
+    /** {@inheritDoc ICellHeaderRange.getSnapshot} */
+    getSnapshot(options?: ICellHeaderRange.CopyOptions): ICellHeaderRange.ISnapshot;
+    /** {@inheritDoc ICellHeaderRange.setSize} */
+    setSize(size?: number | string, options?: ICellHeaderRange.SetSizeOptions): this;
+    /** {@inheritDoc ICellHeaderRange.setHidden} */
+    setHidden(hidden?: boolean, options?: ICellHeaderRange.UpdateHeadersOptions): this;
+    /** {@inheritDoc ICellHeaderRange.clear} */
+    clear(): this;
+    /** {@inheritDoc ICellHeaderRange.at} */
+    at(index: number): ICellHeader;
+    /** {@inheritDoc ICellHeaderRange.getAxis} */
+    getAxis(): IRange.Axis;
+    /** {@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.getAddress} */
+    getAddress(r1c1?: boolean): string;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ICellHeaderRange.isICellHeaderRange} */
+    get isICellHeaderRange(): true;
+}
+//# sourceMappingURL=SheetCellHeaderRange.d.ts.map

package/types/src/sheetHeader/SheetCellHeaderRanges.d.ts

@@ -0,0 +1,46 @@
+import { IRange } from '@sheetxl/primitives';
+import { RunCoords } from '@sheetxl/utils';
+import { ITransaction } from '../transaction';
+import { ICellHeader } from '../cell';
+import { ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
+import { SheetHeader } from './SheetHeader';
+export declare 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, options?: ICellHeaderRange.UpdateHeadersOptions): this;
+    /** {@inheritDoc ICellHeaderRanges.setSize} */
+    setSize(size: number | string, options?: ICellHeaderRange.SetSizeOptions): 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.at} */
+    at(index: number): ICellHeaderRange;
+    /** {@inheritDoc ICellHeaderRanges.getAxis} */
+    getAxis(): IRange.Axis;
+    /** {@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.getAddress} */
+    getAddress(r1c1?: boolean): string;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ICellHeaderRanges.isICellHeaderRanges} */
+    get isICellHeaderRanges(): true;
+}
+//# sourceMappingURL=SheetCellHeaderRanges.d.ts.map