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

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

@@ -4,8 +4,8 @@ import { Size, Rectangle } from '@sheetxl/utils';
 import { IProperties } from '../../type';
 import { IColor } from '../../color';
 import { IFill } from '../../fill';
-import { IFont } from '../../font';
-import { ITextFrame, IStyledFont } from '../../text';
+import { IFont, IFontStyle } from '../../font';
+import { ITextFrame } from '../../text';
 import { IBorders } from '../../border';
 import { ICellProtection } from '../../cell';
 import { ICellStyle, IStyleCollection } from '../../style';
@@ -231,108 +231,81 @@ export declare class CellProtection extends Inheritable<ICellProtection.Properti
     /** {@inheritDoc ICellProtection.isICellProtection} */
     get isICellProtection(): true;
 }
-export declare class CellFont extends Inheritable<IStyledFont.Properties, IStyledFont.JSON> implements IStyledFont {
-    /** {@inheritDoc ICellStyle.isEqualMeasure} */
-    isEqualMeasure(other: IStyledFont): boolean;
-    /** {@inheritDoc ICellStyle.toCSS} */
+export declare class CellFont extends Inheritable<IFontStyle.Properties, IFontStyle.JSON> implements IFontStyle {
+    private _set;
+    /** {@inheritDoc IFontStyle.isEqualMeasure} */
+    isEqualMeasure(other: IFontStyle): boolean;
+    /** {@inheritDoc IFontStyle.toCSS} */
     toCSS(mode?: IColor.CSSMode, zoom?: number, ignoreNormal?: boolean): CSSProperties;
-    /** {@inheritDoc ICellStyle.isSuperSub} */
-    isSuperSub(): boolean;
-    /** {@inheritDoc ICellStyle.isSuperSub} */
-    isSuperScript(): boolean;
-    /** {@inheritDoc ICellStyle.getSuperSubScale} */
-    getSuperSubScale(): number;
-    /** {@inheritDoc ICellStyle.getSuperSubShift} */
-    getSuperSubShift(): number;
-    /**
-     * The theme font this font is a reference to, or `undefined` if it names its own family.
-     *
-     * A scheme font is the LIVE theme font: `family` is only a cached resolution of it (Excel writes
-     * the face for the authoring locale's script, so a workbook saved in Chinese caches `宋体`
-     * where an English one caches `Calibri`), and the scheme is what the reference actually is.
-     */
-    private _schemeFamily;
-    /** {@inheritDoc ICellStyle.getFamily} */
+    /** {@inheritDoc IFontStyle.getFamily} */
     getFamily(): string;
-    /** {@inheritDoc ICellStyle.setFamily} */
-    setFamily(family: string | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getFallbacks} */
+    /** {@inheritDoc IFontStyle.setFamily} */
+    setFamily(family: string | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getName} */
+    getName(): string;
+    /** {@inheritDoc IFontStyle.setName} */
+    setName(name: string | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getThemeFamily} */
+    getThemeFamily(): IFontStyle.ThemeFamily | null;
+    /** {@inheritDoc IFontStyle.getFallbacks} */
     getFallbacks(): string[];
-    /** {@inheritDoc ICellStyle.setFamily} */
-    setFallbacks(fallbacks: string[] | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getSize} */
+    /** {@inheritDoc IFontStyle.setFallbacks} */
+    setFallbacks(fallbacks: string[] | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getSize} */
     getSize(): number;
-    /** {@inheritDoc ICellStyle.setSize} */
-    setSize(size: number | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getWeight} */
+    /** {@inheritDoc IFontStyle.setSize} */
+    setSize(size: number | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getWeight} */
     getWeight(): number;
-    /** {@inheritDoc ICellStyle.setWeight} */
-    setWeight(weight: number | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyledFont.getBold} */
+    /** {@inheritDoc IFontStyle.setWeight} */
+    setWeight(weight: number | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getBold} */
     getBold(): boolean;
-    /** {@inheritDoc IStyledFont.setBold} */
-    setBold(bold: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getStyle} */
-    getStyle(): IFont.Style;
-    /** {@inheritDoc ICellStyle.setStyle} */
-    setStyle(style: IFont.Style | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyledFont.getItalic} */
+    /** {@inheritDoc IFontStyle.setBold} */
+    setBold(bold: boolean | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getItalic} */
     getItalic(): boolean;
-    /** {@inheritDoc IStyledFont.setItalic} */
-    setItalic(italic: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getColor} */
+    /** {@inheritDoc IFontStyle.setItalic} */
+    setItalic(italic: boolean | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getColor} */
     getColor(): IColor;
-    /** {@inheritDoc ICellStyle.setColor} */
-    setColor(color: IColor | string | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getLetterSpacing} */
+    /** {@inheritDoc IFontStyle.setColor} */
+    setColor(color: IColor | string | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getLetterSpacing} */
     getLetterSpacing(): number;
-    /** {@inheritDoc ICellStyle.setLetterSpacing} */
-    setLetterSpacing(letterSpacing: number | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getUnderline} */
+    /** {@inheritDoc IFontStyle.setLetterSpacing} */
+    setLetterSpacing(letterSpacing: number | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getUnderline} */
     getUnderline(): IFont.UnderlineStyle;
-    /** {@inheritDoc ICellStyle.setUnderline} */
-    setUnderline(underline: IFont.UnderlineStyle | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getStrike} */
-    getStrike(): boolean;
-    /** {@inheritDoc ICellStyle.setStrike} */
-    setStrike(strike: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getScheme} */
-    getScheme(): IFont.Scheme;
-    /** {@inheritdoc ICellStyle.setScheme} */
-    setScheme(scheme: IFont.Scheme | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getVerticalAlignment} */
-    getVerticalAlignment(): IFont.VerticalAlignment;
-    /** {@inheritDoc ICellStyle.setVerticalAlignment} */
-    setVerticalAlignment(verticalAlign: IFont.VerticalAlignment | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getShadow} */
-    getShadow(): boolean;
-    /** {@inheritDoc ICellStyle.setShadow} */
-    setShadow(shadow: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getOutline} */
-    getOutline(): boolean;
-    /** {@inheritDoc ICellStyle.setOutline} */
-    setOutline(outline: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc ICellStyle.getExtend} */
-    getExtend(): boolean;
-    /** {@inheritDoc ICellStyle.setExtend} */
-    setExtend(extend: boolean | null, options?: ICellStyle.UpdateOptions): IStyledFont;
-    /** {@inheritDoc IStyledFont.getCharset} */
-    getCharset(): IFont.Charset | null;
-    /** {@inheritDoc IStyledFont.setCharset} */
-    setCharset(charset: IFont.Charset | null, options?: ICellStyle.UpdateOptions): IStyledFont;
+    /** {@inheritDoc IFontStyle.setUnderline} */
+    setUnderline(underline: IFont.UnderlineStyle | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getStrike} */
+    getStrike(): IFont.StrikeStyle;
+    /** {@inheritDoc IFontStyle.setStrike} */
+    setStrike(strike: IFont.StrikeStyle | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.getBaseline} */
+    getBaseline(): number;
+    /** {@inheritDoc IFontStyle.setBaseline} */
+    setBaseline(baseline: number | null, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.update} */
+    update(update: IFontStyle.Update, options?: ICellStyle.UpdateOptions): IFontStyle;
+    /** {@inheritDoc IFontStyle.toJSON} */
+    toJSON(): IFontStyle.JSON;
     get [Symbol.toStringTag](): string;
     /** {@inheritDoc ICellRanges.toString} */
     toString(): string;
-    /** {@inheritDoc ICellStyle.isIStyledFont} */
-    get isIStyledFont(): true;
+    /** {@inheritDoc IFontStyle.isIFontStyle} */
+    get isIFontStyle(): true;
 }
 export declare class SheetCellStyle implements ICellStyle {
     protected _o: CreateCellStyleOptions;
     protected _p: InheritableProperties<ICellStyle.Properties, ICellStyle.JSON>;
     protected _bestFit: Partial<Size> | undefined;
+    protected _bestFitFonts: number;
     protected _insets: Rectangle | undefined;
+    protected _insetsFonts: number;
     protected _hasVisibleStyling: boolean | undefined;
-    protected _font: IStyledFont | undefined;
+    protected _font: IFontStyle | undefined;
     protected _alignment: ITextFrame.IAlignment | undefined;
     protected _border: IBorders | undefined;
     protected _fill: IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone | undefined;
@@ -370,9 +343,9 @@ export declare class SheetCellStyle implements ICellStyle {
     /** {@inheritDoc ICellStyle.setBorders} */
     setBorders(borders: IBorders.Update, options?: ICellStyle.UpdateOptions): ICellStyle;
     /** {@inheritDoc ICellStyle.getFont} */
-    getFont(): IStyledFont;
+    getFont(): IFontStyle;
     /** {@inheritDoc ICellStyle.setFont} */
-    setFont(font: IStyledFont.Update, options?: ICellStyle.UpdateOptions): ICellStyle;
+    setFont(font: IFontStyle | IFontStyle.Update | string | null, options?: ICellStyle.UpdateOptions): ICellStyle;
     /** {@inheritDoc ICellStyle.getFill} */
     getFill(): IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone;
     /** {@inheritDoc ICellStyle.setFill} */
@@ -389,6 +362,14 @@ export declare class SheetCellStyle implements ICellStyle {
     getAlignment(): ITextFrame.IAlignment;
     /** {@inheritDoc ICellStyle.setAlignment} */
     setAlignment(alignment: ITextFrame.IAlignment.Update | string | null, options?: ICellStyle.UpdateOptions): ICellStyle;
+    /** {@inheritDoc ICellStyle.getHorizontalAlignment} */
+    getHorizontalAlignment(): ITextFrame.HorizontalAlignment;
+    /** {@inheritDoc ICellStyle.getVerticalAlignment} */
+    getVerticalAlignment(): ITextFrame.VerticalAlignment;
+    /** {@inheritDoc ICellStyle.setHorizontalAlignment} */
+    setHorizontalAlignment(horizontal: ITextFrame.HorizontalAlignment | string): ICellStyle;
+    /** {@inheritDoc ICellStyle.setVerticalAlignment} */
+    setVerticalAlignment(vertical: ITextFrame.VerticalAlignment | string): ICellStyle;
     /** {@inheritDoc ICellStyle.getNumberFormat} */
     getNumberFormat(): string;
     /**

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

@@ -15,7 +15,6 @@ export declare class SheetDirectStyle implements ISpatialMap.IUpdatableValue, IP
     protected _p: ICellStyle.Properties | null;
     protected _t: IRange.Coords | null;
     protected _e: boolean;
-    protected _o: IRange.AxisSelection;
     /**
      * The 'update form': the resolved update INCLUDING explicit `null` clears (tombstones). Only
      * present on update templates built via {@link cloneWithUpdate} with `keepNulls` (and their
@@ -26,7 +25,7 @@ export declare class SheetDirectStyle implements ISpatialMap.IUpdatableValue, IP
     protected _u: ICellStyle.Properties | undefined;
     /** Lazily built {@link getMeasureKey}. */
     protected _mk: string | undefined;
-    constructor(styles: IStyleCollection, getEntireRange: (() => IRange.Coords) | null, range: IRange.Coords, properties?: ICellStyle.Properties | null, tile?: IRange.Coords | null, axes?: IRange.AxisSelection);
+    constructor(styles: IStyleCollection, getEntireRange: (() => IRange.Coords) | null, range: IRange.Coords, properties?: ICellStyle.Properties | null, tile?: IRange.Coords | null);
     isEmpty(): boolean;
     getProperties(): ICellStyle.Properties | null;
     /** {@inheritDoc IProperties.ICellRanged.getCoords} */
@@ -38,7 +37,8 @@ export declare class SheetDirectStyle implements ISpatialMap.IUpdatableValue, IP
     getUpdateProperties(): ICellStyle.Properties | undefined;
     /**
      * A compare key over the properties that can change a MEASURED size: the named base, number
-     * format, font, the metric alignment properties (overflow / rotation / indent) and insets. Two
+     * format, font, the metric alignment properties (overflow / rotation / indent / stacked, and
+     * vertical, whose justify and distributed wrap) and insets. Two
      * direct styles with equal keys resolve to the same metrics for the same value, so a scan can
      * treat distinct instances (every spatial fragment is one) as a single style run. `''` for no
      * properties — the same key as no direct style at all. Built once per instance (immutable).

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

@@ -37,6 +37,8 @@ export declare class SheetNamedStyle implements ICellStyle.INamed {
     getILevel(): number | null;
     /** {@inheritDoc ICellStyle.INamed.getBuiltInID} */
     getBuiltInID(): number | null;
+    /** {@inheritDoc ICellStyle.INamed.isCustomized} */
+    isCustomized(): boolean;
     /** {@inheritDoc ICellStyle.INamed.delete} */
     delete(): void;
     /** {@inheritDoc ICellStyle.INamed.toJSON} */

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

@@ -0,0 +1,7 @@
+import { ICellStyle } from '../../style/ICellStyle';
+/**
+ * The widest digit of `style`'s font in whole px, the unit Excel pads and fits columns by: with a
+ * hinted table it is GDI's. Cached per style until a font arrives.
+ */
+export declare function maxDigitWidth(style: ICellStyle): number;
+//# sourceMappingURL=_DigitWidth.d.ts.map

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

@@ -1,7 +1,8 @@
 import { TypedObject } from '@sheetxl/utils';
 import { IColor } from '../../color';
 import { IFill } from '../../fill';
-import { ITextFrame, IStyledFont } from '../../text';
+import { IFontStyle } from '../../font';
+import { ITextFrame } from '../../text';
 import { IBorders } from '../../border';
 import { ICellProtection } from '../../cell';
 import { NumberFormat } from '../../numFmt';
@@ -10,7 +11,7 @@ export declare const COLOR: TypedObject<IColor.Serializable, IColor, IStyleColle
 export declare const BORDER_STROKE: TypedObject<IBorders.StrokeProperties<IColor.Serializable>, IBorders.IStroke, IStyleCollection>;
 export declare const CELL_BORDER: TypedObject<IBorders.Properties, IBorders, 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_FONT: TypedObject<IFontStyle.Properties, IFontStyle, 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>;

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

@@ -1,9 +1,7 @@
 import { IRange } from '@sheetxl/primitives';
-import { ITypes } from '../../type';
-import { ICellHeader } from '../../cell';
 import { ICellStyle, IStyleCollection } from '../../style';
 import { IBorders } from '../../border';
-import { ISheetProtection } from '../../sheetProtection';
+import { IWorksheetProtection } from '../../sheetProtection';
 import { ISpatialMap, ISpatialQuery } from '../../collections';
 /**
  * `alwaysUnlocked` as a cell with these direct content properties resolves it: its own, then its
@@ -27,7 +25,7 @@ export declare function resolveShowFormulas(styles: IStyleCollection, direct: Re
  * grants `showFormulas`.
  * @internal
  */
-export declare function searchVisibleFormulas(formulaSpatial: ISpatialQuery<any>, contentSpatial: ISpatialQuery<any>, bounds: IRange.Coords, protection: ISheetProtection | null | undefined, styles: IStyleCollection): ISpatialMap.Entry<any>[];
+export declare function searchVisibleFormulas(formulaSpatial: ISpatialQuery<any>, contentSpatial: ISpatialQuery<any>, bounds: IRange.Coords, protection: IWorksheetProtection | null | undefined, styles: IStyleCollection): ISpatialMap.Entry<any>[];
 /**
  * @internal
  */
@@ -47,45 +45,6 @@ export declare function isEqualStrokeProperties(a: IBorders.StrokeProperties | u
  * same pieces a real stroke would.
  */
 export declare function splitBorderRange(border: IBorders.Properties, rangeFrom: IRange.Coords, rangeTo: IRange.Coords, isColumn: boolean): Partial<IBorders.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 'borders' 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: ICellStyle.JSON, entireCoords?: IRange.Coords): IRange.JSONReferenceTuple<ICellStyle.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.
- *
- * A style's border is relative to the range it is stored with (a row or column style's range is
- * the whole row or column), so the ids are not position-independent: wherever a range is written
- * smaller than the entry it came from, its id is re-derived from the style's JSON through `ids`,
- * and two entries sharing an id agree on a crossing only if they draw the same edges there.
- * Styles without a border take none of this.
- */
-export declare function promoteStylesToHeaders(styles: StyleRangesJSON, entireCoords: IRange.Coords, ids: Pick<IStyleCollection.IPersistScope, 'getElementJSON' | 'getElementID'>): StyleRangesJSON;
 /**
  * Performs a shift but uses the entire range to ensure edge styles.
  *
@@ -94,6 +53,11 @@ export declare function promoteStylesToHeaders(styles: StyleRangesJSON, entireCo
  *
  * @remarks
  * Returns an entry but requires the value be set/cloned.
+ *
+ * An entry that reaches the sheet's far edge is a header's: it keeps reaching it. An entry that
+ * only starts at the near edge is an ordinary block, and moves or grows as the shift says: an
+ * insert at its first row or column moves it whole, one strictly inside grows it (Excel-probed
+ * 2026-10-18 for a fill and a merge: `A1:A3` + insert rows 1:2 is `A3:A5`, + insert row 2 is `A1:A4`).
  */
 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/sheetHeader/ISheetHeader.d.ts

@@ -5,7 +5,7 @@ import { ITransaction } from '../transaction';
 import { IListener } from '../listener';
 import { ICellHeader } from '../cell';
 import { ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
-import { ISheet } from '../sheet';
+import { IWorksheet } 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.
@@ -134,7 +134,7 @@ export interface ISheetHeader extends ITransaction.ITransactional, IListener.ISo
     /**
      * Returns the sheet model used for the header.
      */
-    getSheet(): ISheet;
+    getWorksheet(): IWorksheet;
     /**
      * Save the header state to a JSON object.
      *

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

@@ -18,6 +18,8 @@ export declare class SheetCellHeader implements ICellHeader {
     getSize(): number;
     /** {@inheritDoc ICellHeader.getText} */
     getText(): string;
+    /** {@inheritDoc ICellHeader.isBestFit} */
+    isBestFit(): boolean;
     /** {@inheritDoc ICellHeader.getAxis} */
     getAxis(): IRange.Axis;
     /** {@inheritDoc ICellHeader.isHidden} */

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

@@ -44,6 +44,8 @@ export declare class SheetCellHeaderRange implements ICellHeaderRange {
     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.getAddress} */
     getAddress(r1c1?: boolean): string;
     get [Symbol.toStringTag](): string;

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

@@ -36,6 +36,8 @@ export declare class SheetCellHeaderRanges implements ICellHeaderRanges {
     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;
     /** {@inheritDoc ICellHeaderRanges.getAddress} */
     getAddress(r1c1?: boolean): string;
     get [Symbol.toStringTag](): string;

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

@@ -7,7 +7,7 @@ import { ICellHeader } from '../cell';
 import { ITable } from '../table';
 import { ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
 import { IRangeSelection } from '../selection';
-import { ISheet } from '../sheet';
+import { IWorksheet } from '../sheet';
 import { ISheetHeader } from './ISheetHeader';
 import { ListenerEmitter } from '../listener/ListenerEmitter';
 import { CreateCellHeaderCallback } from './SheetCellHeader';
@@ -60,7 +60,8 @@ export declare class SheetHeader implements ISheetHeader {
      * The `onViewChange` listener above does this when it hears the sheet's extent change. An
      * operation that changes the extent and then writes against it - `Sheet.setEntireSize` grows
      * the sheet and then inserts into the new band, which is bounds-checked against the maximum
-     * index - cannot wait to be told, so it calls this.
+     * index - cannot wait to be told, so it calls this. What changed is announced here, because the
+     * listener will then find nothing left to change.
      *
      * @internal
      */
@@ -79,8 +80,8 @@ export declare class SheetHeader implements ISheetHeader {
      */
     invalidate(): void;
     protected _onHeaderChange(sizeUpdate: boolean): void;
-    /** {@inheritDoc ISheetHeader.getSheet} */
-    getSheet(): ISheet;
+    /** {@inheritDoc ISheetHeader.getWorksheet} */
+    getWorksheet(): IWorksheet;
     /** {@inheritDoc ISheetHeader.getAxis} */
     getAxis(): IRange.Axis;
     /** {@inheritDoc ISheetHeader.getTextAt} */
@@ -181,9 +182,9 @@ export declare namespace SheetHeader {
      */
     interface ConstructorOptions {
         /**
-         * The {@link ISheet} containing the Headers.
+         * The {@link IWorksheet} containing the Headers.
          */
-        sheet: ISheet;
+        sheet: IWorksheet;
         /**
          * The axis of the data.
          *

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

@@ -2,7 +2,6 @@ import { RunCoords } from '@sheetxl/utils';
 import { IRange } from '@sheetxl/primitives';
 import { ITypes } from '../type';
 import { CacheSearchRunData } from '../collections/_RunUtils';
-import { ICellStyle } from '../style';
 import { ICellHeaderRange, ICellHeaderRanges } from '../cellRange';
 /**
  * Note - By using optional keys as a way to detect default values we are creating mono polymorphic objects. (perform issue in V8).
@@ -14,12 +13,12 @@ export interface CellHeaderState {
     sz?: number;
     csz?: boolean;
     h?: boolean;
-    s?: ICellStyle;
-    cs?: boolean;
     /** outline level, 1-7; absent when not grouped */
     l?: number;
     /** collapsed; set on a group's summary header */
     cl?: boolean;
+    /** best fit (columns) */
+    bf?: boolean;
 }
 /**
  * Use for tracking the accumulated sizes from the beginning of the headers.

package/types/src/sheetProtection/{ISheetProtection.d.ts → IWorksheetProtection.d.ts}

@@ -3,14 +3,14 @@ import { IProtection } from '../protection/IProtection';
  * Interface representing the protection settings for a sheet.
  * Extends the base `IProtection` interface with additional sheet-specific protection options.
  */
-export interface ISheetProtection extends IProtection<ISheetProtection, ISheetProtection.Properties, ISheetProtection.JSON> {
+export interface IWorksheetProtection extends IProtection<IWorksheetProtection, IWorksheetProtection.Properties, IWorksheetProtection.JSON> {
     /**
      * Retrieves the protection properties for the sheet.
      *
-     * @returns The {@link ISheetProtection.Properties} the sheet protects with, kept while it is
+     * @returns The {@link IWorksheetProtection.Properties} the sheet protects with, kept while it is
      * unprotected, or `null` when it has none.
      */
-    getProperties(): Partial<ISheetProtection.Properties> | null;
+    getProperties(): Partial<IWorksheetProtection.Properties> | null;
     /**
      * Checks if the AutoTable functionality is protected on the sheet.
      *
@@ -119,57 +119,57 @@ export interface ISheetProtection extends IProtection<ISheetProtection, ISheetPr
      */
     isSelectUnlockedCellsAllowed(): boolean;
     /** For runtime type checking. */
-    readonly isISheetProtection: true;
+    readonly isIWorksheetProtection: true;
 }
 /**
- * {@inheritDoc ISheetProtection}
+ * {@inheritDoc IWorksheetProtection}
  * @see
  * ### **Interface**
  *
- * {@link ISheetProtection}
+ * {@link IWorksheetProtection}
  */
-export declare namespace ISheetProtection {
+export declare namespace IWorksheetProtection {
     /**
      * @remarks
      * There is no whole-sheet flag here: changing it is {@link IProtection.lock} and
-     * {@link IProtection.unlock}, reading it {@link ISheetProtection.isLocked}. It is saved as
-     * {@link ISheetProtection.JSON.sheet}.
+     * {@link IProtection.unlock}, reading it {@link IWorksheetProtection.isLocked}. It is saved as
+     * {@link IWorksheetProtection.JSON.sheet}.
      */
     interface Properties extends IProtection.Properties {
-        /** {@inheritDoc ISheetProtection.isAutoTableAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isAutoTableAllowed} */
         autoTable?: boolean;
-        /** {@inheritDoc ISheetProtection.isDeleteColumnsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isDeleteColumnsAllowed} */
         deleteColumns?: boolean;
-        /** {@inheritDoc ISheetProtection.isDeleteRowsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isDeleteRowsAllowed} */
         deleteRows?: boolean;
-        /** {@inheritDoc ISheetProtection.isFormatCellsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isFormatCellsAllowed} */
         formatCells?: boolean;
-        /** {@inheritDoc ISheetProtection.isFormatColumnsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isFormatColumnsAllowed} */
         formatColumns?: boolean;
-        /** {@inheritDoc ISheetProtection.isFormatRowsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isFormatRowsAllowed} */
         formatRows?: boolean;
-        /** {@inheritDoc ISheetProtection.isInsertColumnsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isInsertColumnsAllowed} */
         insertColumns?: boolean;
-        /** {@inheritDoc ISheetProtection.isInsertHyperlinksAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isInsertHyperlinksAllowed} */
         insertHyperlinks?: boolean;
-        /** {@inheritDoc ISheetProtection.isInsertRowsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isInsertRowsAllowed} */
         insertRows?: boolean;
-        /** {@inheritDoc ISheetProtection.isObjectsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isObjectsAllowed} */
         objects?: boolean;
-        /** {@inheritDoc ISheetProtection.isPivotTablesAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isPivotTablesAllowed} */
         pivotTables?: boolean;
-        /** {@inheritDoc ISheetProtection.isScenariosAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isScenariosAllowed} */
         scenarios?: boolean;
-        /** {@inheritDoc ISheetProtection.isSelectLockedCellsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isSelectLockedCellsAllowed} */
         selectLockedCells?: boolean;
-        /** {@inheritDoc ISheetProtection.isSelectUnlockedCellsAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isSelectUnlockedCellsAllowed} */
         selectUnlockedCells?: boolean;
-        /** {@inheritDoc ISheetProtection.isSortAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isSortAllowed} */
         sort?: boolean;
-        /** {@inheritDoc ISheetProtection.isShowFormulasAllowed} */
+        /** {@inheritDoc IWorksheetProtection.isShowFormulasAllowed} */
         showFormulas?: boolean;
     }
-    interface JSON extends ISheetProtection.Properties, IProtection.JSON {
+    interface JSON extends IWorksheetProtection.Properties, IProtection.JSON {
         /**
          * `true` when the whole sheet stays allowed: it is not protected, and keeps its options for the
          * next lock. Absent, the sheet is protected.
@@ -179,6 +179,6 @@ export declare namespace ISheetProtection {
          */
         sheet?: boolean;
     }
-    type PropertyKeys = (keyof ISheetProtection.Properties);
+    type PropertyKeys = (keyof IWorksheetProtection.Properties);
 }
-//# sourceMappingURL=ISheetProtection.d.ts.map
+//# sourceMappingURL=IWorksheetProtection.d.ts.map

package/types/src/sheetProtection/WorksheetProtection.d.ts

@@ -0,0 +1,51 @@
+import { DefaultProtection } from '../protection/DefaultProtection';
+import { IWorksheetProtection } from './IWorksheetProtection';
+export declare class WorksheetProtection extends DefaultProtection<IWorksheetProtection, IWorksheetProtection.Properties, IWorksheetProtection.JSON> implements IWorksheetProtection {
+    /** {@inheritDoc IWorksheetProtection.isAutoTableAllowed} */
+    isAutoTableAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isDeleteColumnsAllowed} */
+    isDeleteColumnsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isDeleteRowsAllowed} */
+    isDeleteRowsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isFormatCellsAllowed} */
+    isFormatCellsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isFormatColumnsAllowed} */
+    isFormatColumnsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isFormatRowsAllowed} */
+    isFormatRowsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isInsertColumnsAllowed} */
+    isInsertColumnsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isInsertHyperlinksAllowed} */
+    isInsertHyperlinksAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isInsertRowsAllowed} */
+    isInsertRowsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isObjectsAllowed} */
+    isObjectsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isPivotTablesAllowed} */
+    isPivotTablesAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isScenariosAllowed} */
+    isScenariosAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isSortAllowed} */
+    isSortAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isShowFormulasAllowed} */
+    isShowFormulasAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isSelectLockedCellsAllowed} */
+    isSelectLockedCellsAllowed(): boolean;
+    /** {@inheritDoc IWorksheetProtection.isSelectUnlockedCellsAllowed} */
+    isSelectUnlockedCellsAllowed(): boolean;
+    /**
+     * A property that a locked sheet must deny explicitly: unset is allowed, and read-only does not
+     * deny it. The opposite of {@link _isPropertyAllowed}, which a locked sheet must grant explicitly.
+     */
+    protected _isPropertyAllowedByDefault(property: IWorksheetProtection.PropertyKeys): boolean;
+    protected _getAllowedKey(): string;
+    protected _updateProperties(properties: IWorksheetProtection.Properties | null): void;
+    protected _clearProperties(): void;
+    protected _fromJSON(json: IWorksheetProtection.JSON | null): void;
+    protected _toJSON(json: IWorksheetProtection.JSON): IWorksheetProtection.JSON;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc IWorksheetProtection.isIWorksheetProtection} */
+    get isIWorksheetProtection(): true;
+}
+//# sourceMappingURL=WorksheetProtection.d.ts.map

package/types/src/sheetProtection/index.d.ts

@@ -1,2 +1,2 @@
-export * from './ISheetProtection';
+export * from './IWorksheetProtection';
 //# sourceMappingURL=index.d.ts.map