@sheetxl/sdk 0.8.0-beta.1 → 0.8.0-beta.2

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

@@ -1,6 +1,6 @@
 import { IRange, Scalar } from '@sheetxl/primitives';
 import { IProperties } from '../../type';
-import { IBorder } from '../../border';
+import { IBorders } from '../../border';
 import { IStyle, IStyleCollection } from '../../style';
 import { ISpatialMap } from '../../collections/ISpatialMap';
 /**
@@ -24,6 +24,8 @@ export declare class SheetDirectStyle implements ISpatialMap.IUpdatableValue, IP
      * that DO have a previous style. See the ranged-style update in Sheet.ts.
      */
     protected _u: IStyle.Properties | undefined;
+    /** Lazily built {@link getMeasureKey}. */
+    protected _mk: string | undefined;
     constructor(styles: IStyleCollection, getEntireRange: (() => IRange.Coords) | null, range: IRange.Coords, properties?: IStyle.Properties | null, tile?: IRange.Coords | null, axes?: IRange.AxisSelection);
     isEmpty(): boolean;
     getProperties(): IStyle.Properties | null;
@@ -34,8 +36,17 @@ export declare class SheetDirectStyle implements ISpatialMap.IUpdatableValue, IP
      * @see {@link _u}
      */
     getUpdateProperties(): IStyle.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
+     * 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).
+     * @internal
+     */
+    getMeasureKey(): string;
     /** Category key partition for {@link splitByFeature} (SHEET-STYLE-SPLIT). Covers every
-     * `IStyle.Properties` key exactly once so the split is lossless. `protection` is future. */
+     * `IStyle.Properties` key exactly once so the split is lossless. */
     static readonly BorderKeys: readonly (keyof IStyle.Properties)[];
     static readonly FillKeys: readonly (keyof IStyle.Properties)[];
     static readonly ContentKeys: readonly (keyof IStyle.Properties)[];
@@ -113,15 +124,15 @@ export declare class SheetDirectStyle implements ISpatialMap.IUpdatableValue, IP
      * exists to prevent.
      * @internal
      */
-    getInnerBorder(range: IRange.Coords): Readonly<Partial<IBorder.Properties>> | null;
-    protected _localizeBorderRange(unscoped: Readonly<IBorder.Properties>, rangeUnscoped: IRange.Coords, range: IRange.Coords): Partial<IBorder.Properties> | null | undefined;
+    getInnerBorder(range: IRange.Coords): Readonly<Partial<IBorders.Properties>> | null;
+    protected _localizeBorderRange(unscoped: Readonly<IBorders.Properties>, rangeUnscoped: IRange.Coords, range: IRange.Coords): Partial<IBorders.Properties> | null | undefined;
     /**
      * Localizes the border to the cell coords.
      * Returns border properties, null, or undefined.
      * * If undefined then there was no border to localize.
      * * `null` is localize to none.
      */
-    protected _localizeBorder(unscoped: IBorder.Properties, range: IRange.Coords, rowIndex: number, colIndex: number): Partial<IBorder.Properties> | null | undefined;
+    protected _localizeBorder(unscoped: IBorders.Properties, range: IRange.Coords, rowIndex: number, colIndex: number): Partial<IBorders.Properties> | null | undefined;
     /** {@inheritDoc IProperties.ICellRanged.getPropertiesAt} */
     getPropertiesAt(rowIndex: number, colIndex: number, value: Scalar): Readonly<IStyle.Properties>;
     /** {@inheritDoc ISpatialMap.IUpdatableValue.toJSON} */

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

@@ -2,12 +2,13 @@ import { TypedObject } from '@sheetxl/utils';
 import { IColor } from '../../color';
 import { IFill } from '../../fill';
 import { ITextFrame, IStyledFont } from '../../text';
-import { IBorder } from '../../border';
+import { IBorders } from '../../border';
+import { ICellProtection } from '../../cell';
 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 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_ALIGNMENT: TypedObject<ITextFrame.IAlignment.Properties, ITextFrame.IAlignment, IStyleCollection>;
@@ -18,6 +19,7 @@ export declare const GRADIENT_STOPS: TypedObject<(IFill.GradientStopProperties |
 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_PROTECTION: TypedObject<ICellProtection.Properties, ICellProtection, 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`

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

@@ -1,13 +1,37 @@
 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';
+import { IStyle, IStyleCollection } from '../../style';
+import { IBorders } from '../../border';
+import { ISheetProtection } from '../../sheetProtection';
+import { ISpatialMap, ISpatialQuery } from '../../collections';
 /**
+ * `alwaysUnlocked` as a cell with these direct content properties resolves it: its own, then its
+ * named style's, then Normal's.
  * @internal
  */
-export declare function isEqualStrokeProperties(a: IBorder.StrokeProperties | undefined, b: IBorder.StrokeProperties | undefined): boolean;
+export declare function resolveAlwaysUnlocked(styles: IStyleCollection, direct: Readonly<IStyle.Properties> | null | undefined): boolean;
+/**
+ * `showFormulas` as a cell with these direct content properties resolves it: its own, then its
+ * named style's, then Normal's.
+ * @internal
+ */
+export declare function resolveShowFormulas(styles: IStyleCollection, direct: Readonly<IStyle.Properties> | null | undefined): boolean;
+/**
+ * The formula entries over `bounds` that protection lets a reader see.
+ *
+ * @remarks
+ * Every range-state read takes its formulas from here, so a hidden formula is not there for cells,
+ * regions, counts or copies alike. Saving, undo, writes and calculation read the formula map
+ * directly. Only a sheet that hides its formulas pays: each run is cut to the cells whose style
+ * 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>[];
+/**
+ * @internal
+ */
+export declare function isEqualStrokeProperties(a: IBorders.StrokeProperties | undefined, b: IBorders.StrokeProperties | undefined): boolean;
 /**
  * Splits a border range into a new range with adjusted border properties.
  *
@@ -22,7 +46,7 @@ export declare function isEqualStrokeProperties(a: IBorder.StrokeProperties | un
  * 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;
+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.
@@ -30,7 +54,7 @@ export declare function splitBorderRange(border: IBorder.Properties, rangeFrom:
  * @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
+ * * 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
@@ -54,8 +78,14 @@ export interface StyleRangesJSON {
  * 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): StyleRangesJSON;
+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.
  *

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

@@ -181,6 +181,8 @@ export interface ISheetHeader extends ITransaction.ITransactional, IListener.ISo
      */
     addListeners(listeners: ISheetHeader.IListeners, options?: IListener.Options): IListener.Remove;
     close(): void;
+    /** For runtime type checking. */
+    readonly isISheetHeader: true;
 }
 /**
  * {@inheritDoc ISheetHeader}

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

@@ -53,6 +53,18 @@ export declare class SheetHeader implements ISheetHeader {
     constructor(options: SheetHeader.ConstructorOptions);
     /** {@inheritDoc IListener.ISource.addListeners} */
     addListeners(listeners: ISheetHeader.IListeners, options?: IListener.Options): IListener.Remove;
+    /**
+     * Re-derive what is cached from the sheet's extent: the indexed sizes and the maximum index.
+     *
+     * @remarks
+     * 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.
+     *
+     * @internal
+     */
+    _invalidateExtent(): void;
     protected _invalidateMaxIndex(): void;
     protected _invalidSizes(force?: boolean): void;
     /**
@@ -153,6 +165,8 @@ export declare class SheetHeader implements ISheetHeader {
     toJSON(): ISheetHeader.JSON | null;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /** {@inheritDoc ISheetHeader.isISheetHeader} */
+    get isISheetHeader(): true;
 }
 /**
  * {@inheritDoc SheetHeader}

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

@@ -7,8 +7,8 @@ export interface ISheetProtection extends IProtection<ISheetProtection, ISheetPr
     /**
      * Retrieves the protection properties for the sheet.
      *
-     * @returns The {@link ISheetProtection.Properties} object representing the current protection settings,
-     * or `null` if the sheet is not locked.
+     * @returns The {@link ISheetProtection.Properties} the sheet protects with, kept while it is
+     * unprotected, or `null` when it has none.
      */
     getProperties(): Partial<ISheetProtection.Properties> | null;
     /**
@@ -90,17 +90,36 @@ export interface ISheetProtection extends IProtection<ISheetProtection, ISheetPr
      */
     isSortAllowed(): boolean;
     /**
-     * Checks if selecting locked cells is protected on the sheet.
+     * Checks if formulas may be shown on the protected sheet.
      *
-     * @returns `true` if selecting locked cells is locked, `false` otherwise.
+     * @returns `false` if the sheet hides its formulas while protected.
+     *
+     * @remarks
+     * * While this is `false`, a cell's formula shows only when its style grants it
+     *   (`ICellProtection.isShowFormulas`) — an exception, the way an always-unlocked cell is one.
+     * * Defaults to `true`, and is always `true` while the sheet is not locked (including paused).
+     */
+    isShowFormulasAllowed(): boolean;
+    /**
+     * Checks if locked cells may be selected on the protected sheet.
+     *
+     * @returns `false` if the sheet refuses selection of its locked cells while protected.
+     *
+     * @remarks
+     * Defaults to `true`, and is always `true` while the sheet is not locked (including paused).
      */
     isSelectLockedCellsAllowed(): boolean;
     /**
-     * Checks if selecting unlocked cells is protected on the sheet.
+     * Checks if unlocked cells may be selected on the protected sheet.
      *
-     * @returns `true` if selecting unlocked cells is locked, `false` otherwise.
+     * @returns `false` if the sheet refuses selection of its unlocked cells while protected.
+     *
+     * @remarks
+     * Defaults to `true`, and is always `true` while the sheet is not locked (including paused).
      */
     isSelectUnlockedCellsAllowed(): boolean;
+    /** For runtime type checking. */
+    readonly isISheetProtection: true;
 }
 /**
  * {@inheritDoc ISheetProtection}
@@ -110,6 +129,12 @@ export interface ISheetProtection extends IProtection<ISheetProtection, ISheetPr
  * {@link ISheetProtection}
  */
 export declare namespace ISheetProtection {
+    /**
+     * @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}.
+     */
     interface Properties extends IProtection.Properties {
         /** {@inheritDoc ISheetProtection.isAutoTableAllowed} */
         autoTable?: boolean;
@@ -141,9 +166,18 @@ export declare namespace ISheetProtection {
         selectUnlockedCells?: boolean;
         /** {@inheritDoc ISheetProtection.isSortAllowed} */
         sort?: boolean;
-        sheet?: boolean;
+        /** {@inheritDoc ISheetProtection.isShowFormulasAllowed} */
+        showFormulas?: boolean;
     }
     interface JSON extends ISheetProtection.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.
+         *
+         * @remarks
+         * Like every allowance here, the inverse of its OOXML attribute (`sheet="1"` is protected).
+         */
+        sheet?: boolean;
     }
     type PropertyKeys = (keyof ISheetProtection.Properties);
 }

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

@@ -27,13 +27,25 @@ export declare class SheetProtection extends DefaultProtection<ISheetProtection,
     isScenariosAllowed(): boolean;
     /** {@inheritDoc ISheetProtection.isSortAllowed} */
     isSortAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isShowFormulasAllowed} */
+    isShowFormulasAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.isSelectLockedCellsAllowed} */
     isSelectLockedCellsAllowed(): boolean;
+    /** {@inheritDoc ISheetProtection.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: ISheetProtection.PropertyKeys): boolean;
+    protected _getAllowedKey(): string;
     protected _updateProperties(properties: ISheetProtection.Properties | null): void;
     protected _clearProperties(): void;
     protected _fromJSON(json: ISheetProtection.JSON | null): void;
     protected _toJSON(json: ISheetProtection.JSON): ISheetProtection.JSON;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /** {@inheritDoc ISheetProtection.isISheetProtection} */
+    get isISheetProtection(): true;
 }
 //# sourceMappingURL=SheetProtection.d.ts.map

package/types/src/sheetView/ISheetView.d.ts

@@ -17,6 +17,15 @@ import { ISheet } from '../sheet';
  * * Multiple views can be associated to the same collection of data, each providing a different way of viewing and interacting.
  */
 export interface ISheetView extends IMovableSelection, IListener.ISource<IMovableSelection> {
+    /**
+     * Identifies this view.
+     *
+     * @remarks
+     * Stable for the life of the view. A sheet can be shown through more than one view — each user
+     * in a shared workbook has their own — so anything recorded against a view (a restored
+     * selection, for example) names it by this id rather than holding the view itself.
+     */
+    getId(): string;
     /**
      * The top left scroll position of the (main) pane.
      *
@@ -31,7 +40,7 @@ export interface ISheetView extends IMovableSelection, IListener.ISource<IMovabl
     getTopLeft(): TopLeft;
     /**
      * The first VISIBLE cell — the cell sitting at the grid's top-left corner right now. `A1` when
-     * unscrolled.
+     * un-scrolled.
      *
      * @remarks
      * The cell-coordinate reading of {@link getTopLeft} (which is base px), resolved against the row /
@@ -157,6 +166,37 @@ export interface ISheetView extends IMovableSelection, IListener.ISource<IMovabl
      * @see {@link setShowFormulas}
      */
     isShowFormulas(): boolean;
+    /**
+     * Indicate whether the cells that sheet protection locks are shaded, leaving the ranges that stay
+     * editable clear.
+     *
+     * @defaultValue `false`
+     *
+     * @remarks
+     * Only meaningful while the sheet is protected: it shades what protection is actually holding
+     * shut, so an unprotected sheet has nothing to shade.
+     */
+    setShowLockedShading(showLockedShading: boolean): this;
+    /**
+     * @see {@link setShowLockedShading}
+     */
+    isShowLockedShading(): boolean;
+    /**
+     * Indicate whether cells whose value fails a data validation are marked.
+     *
+     * @defaultValue `false`
+     *
+     * @remarks
+     * The sheet's counterpart of Excel's *Circle Invalid Data*, except that the marks follow the
+     * values as they change. A cell is marked when its value fails any data validation covering it;
+     * a list cell is marked only when its value is not on the list. Not written to xlsx, where Excel
+     * keeps no such setting.
+     */
+    setShowInvalid(showInvalid: boolean): this;
+    /**
+     * @see {@link setShowInvalid}
+     */
+    isShowInvalid(): boolean;
     /**
      * Indicate whether the sheet is displayed right-to-left (the leftmost column on
      * the right). Persisted per sheet; round-trips through xlsx `sheetView@rightToLeft`.
@@ -329,6 +369,10 @@ export declare namespace ISheetView {
         zoomScale: number;
         /** {@inheritDoc ISheetView.setShowFormulas} */
         showFormulas: boolean;
+        /** {@inheritDoc ISheetView.setShowLockedShading} */
+        showLockedShading: boolean;
+        /** {@inheritDoc ISheetView.setShowInvalid} */
+        showInvalid: boolean;
         /** {@inheritDoc ISheetView.setShowZeros} */
         showZeros: boolean;
         /** {@inheritDoc ISheetView.setRightToLeft} */

package/types/src/sheetView/SheetView.d.ts

@@ -17,7 +17,10 @@ export declare class SheetView implements ISheetView, IMovableSelection {
     protected _rangeSelectionRemoveListener: IListener.Remove;
     protected _emitter: ListenerEmitter<ISheetView, ISheetView.IListeners>;
     protected _movableSelection: readonly IMovable[];
+    protected _id: string;
     constructor(options: ISheetView.ConstructorOptions);
+    /** {@inheritDoc ISheetView.getId} */
+    getId(): string;
     /** {@inheritDoc ISheetView.addListeners} */
     addListeners(listeners: ISheetView.IListeners, options?: IListener.Options): IListener.Remove;
     /** {@inheritDoc ISheetView.setTopLeft} */
@@ -74,6 +77,14 @@ export declare class SheetView implements ISheetView, IMovableSelection {
     isShowFormulas(): boolean;
     /** {@inheritDoc ISheetView.setShowFormulas} */
     setShowFormulas(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowLockedShading} */
+    isShowLockedShading(): boolean;
+    /** {@inheritDoc ISheetView.setShowLockedShading} */
+    setShowLockedShading(newValue: boolean): this;
+    /** {@inheritDoc ISheetView.isShowInvalid} */
+    isShowInvalid(): boolean;
+    /** {@inheritDoc ISheetView.setShowInvalid} */
+    setShowInvalid(newValue: boolean): this;
     /** {@inheritDoc ISheetView.isRightToLeft} */
     isRightToLeft(): boolean;
     /** {@inheritDoc ISheetView.setRightToLeft} */

package/types/src/slicer/ISlicer.d.ts

@@ -12,6 +12,8 @@ import { IModel } from '../model';
 export interface ISlicer extends IModel {
     toJSON(toResourceId?: (resource: IResource) => number | null): ISlicer.JSON | null;
     getDescription(): string;
+    /** For runtime type checking. */
+    readonly isISlicer: true;
 }
 export declare namespace ISlicer {
     /**

package/types/src/slicer/Slicer.d.ts

@@ -16,6 +16,8 @@ export declare class Slicer extends AbstractModel<State, ISlicer.JSON> implement
     getTypeDescription(): string;
     get [Symbol.toStringTag](): string;
     toString(): string;
+    /** {@inheritDoc ISlicer.isISlicer} */
+    get isISlicer(): true;
 }
 /**
  * Interfaces for creating `Slicer` items.

package/types/src/sort/ISort.d.ts

@@ -64,6 +64,8 @@ export interface ISort {
      * Clears the sort criteria and removes from sort levels.
      */
     delete(): void;
+    /** For runtime type checking. */
+    readonly isISort: true;
 }
 /**
  * Types used for sorting.

package/types/src/string/IStringCollection.d.ts

@@ -1,6 +1,9 @@
 import { ICollection } from '../type';
 /**
  * Contains a collection of interned strings.
+ *
+ * @remarks
+ * Keyed by the string's id, not ordered: iteration order is unspecified.
  */
 export interface IStringCollection extends ICollection<string>, ICollection.IPersistable {
     /**
@@ -30,6 +33,8 @@ export interface IStringCollection extends ICollection<string>, ICollection.IPer
     getById(id: number): string | null;
     /** {@inheritDoc ICollection.IPersistScope} */
     beginPersist(): ICollection.IPersistScope<IStringCollection.JSON>;
+    /** For runtime type checking. */
+    readonly isIStringCollection: true;
 }
 /**
  * {@inheritDoc IStringCollection}

package/types/src/string/StringCollection.d.ts

@@ -1,6 +1,6 @@
-import { ICollection } from '../type';
+import { ICollection, AbstractCollection } from '../type';
 import { IStringCollection } from './IStringCollection';
-export declare class StringCollection implements IStringCollection {
+export declare class StringCollection extends AbstractCollection<string, IStringCollection.GetItemsOptions> implements IStringCollection {
     private _persistOpen;
     private _stringsByText;
     private _stringsById;
@@ -12,15 +12,15 @@ export declare class StringCollection implements IStringCollection {
     addMultiple(shared: string[], conflateDuplicates?: boolean): void;
     /** {@inheritDoc IStringCollection.add} */
     add(shared: string): number;
-    /** {@inheritDoc ICollection.[Symbol.iterator]} */
-    [Symbol.iterator](): IterableIterator<string>;
-    /** {@inheritDoc IStringCollection.getItems} */
-    getItems(options?: IStringCollection.GetItemsOptions): string[];
+    /** {@inheritDoc AbstractCollection._getItems} */
+    protected _getItems(options?: IStringCollection.GetItemsOptions): string[];
     /** {@inheritDoc IStringCollection.getById} */
     getById(id: number): string | null;
     /** {@inheritDoc ICollection.getCount} */
     getCount(): number;
     /** {@inheritDoc ICollection.IPersistable.beginPersist} */
     beginPersist(): ICollection.IPersistScope<IStringCollection.JSON>;
+    /** {@inheritDoc IStringCollection.isIStringCollection} */
+    get isIStringCollection(): true;
 }
 //# sourceMappingURL=StringCollection.d.ts.map

package/types/src/style/INamedStyleCollection.d.ts

@@ -0,0 +1,72 @@
+import { ICollection } from '../type';
+import { IThemeCollection } from '../theme';
+import { IStyle } from './IStyle';
+/**
+ * The named cell styles of a workbook — the built-ins (`Normal`, `Heading 1`, `Good`, ...) and
+ * the ones the document defines.
+ *
+ * @remarks
+ * Office Scripts calls these predefined cell styles (`Workbook.getPredefinedCellStyles()`).
+ *
+ * Order is the gallery's: the built-ins in their definition order, each replaced in place by a
+ * custom style of the same name, then the document's own styles by name. A hidden style is
+ * left out unless asked for — see {@link INamedStyleCollection.GetItemsOptions.includeHidden}.
+ *
+ * Reached from {@link IStyleCollection.getNamedStyles}.
+ */
+export interface INamedStyleCollection extends ICollection<IStyle.INamed> {
+    /**
+     * Returns the style with the given name, or `null` if there is none.
+     *
+     * @param name The name, compared case-insensitively.
+     *
+     * @remarks
+     * A custom style of a built-in's name replaces the built-in, and is what is returned.
+     */
+    getByName(name: string): IStyle.INamed | null;
+    /**
+     * Adds or updates a style.
+     *
+     * @param update The name, the style, and any of the other {@link IStyle.NamedProperties}.
+     * @param mergeIfExists If `true` the style is merged over the existing one of that name;
+     * otherwise it replaces it. @defaultValue `false`
+     * @returns The style as stored.
+     *
+     * @remarks
+     * Names are case-insensitive. Setting a built-in's name customizes the built-in.
+     */
+    set(update: IStyle.NamedUpdate, mergeIfExists?: boolean): IStyle.INamed;
+    /**
+     * Returns the styles that match the filter, in gallery order.
+     *
+     * @param options {@link INamedStyleCollection.GetItemsOptions}
+     */
+    getItems(options?: INamedStyleCollection.GetItemsOptions): IStyle.INamed[];
+    /** For runtime type checking. */
+    readonly isINamedStyleCollection: true;
+}
+/**
+ * {@inheritDoc INamedStyleCollection}
+ * @see
+ * ### **Interface**
+ *
+ * {@link INamedStyleCollection}
+ */
+export declare namespace INamedStyleCollection {
+    interface GetItemsOptions extends ICollection.GetItemsOptions {
+        /**
+         * Which styles: the built-ins, the document's own (a customized built-in is one of the
+         * document's own), or every style.
+         *
+         * @defaultValue `IThemeCollection.BuiltInFilterType.All`
+         */
+        type?: IThemeCollection.BuiltInFilterType;
+        /**
+         * Include styles marked hidden — a deleted built-in is a hidden one.
+         *
+         * @defaultValue `false`
+         */
+        includeHidden?: boolean;
+    }
+}
+//# sourceMappingURL=INamedStyleCollection.d.ts.map

package/types/src/style/IStyle.d.ts

@@ -6,7 +6,8 @@ import { IColor } from '../color';
 import { IFill } from '../fill';
 import { ITextFrame, IStyledFont } from '../text';
 import { IFont } from '../font';
-import { IBorder } from '../border';
+import { IBorders } from '../border';
+import { ICellProtection } from '../cell';
 import { NumberFormat } from '../numFmt';
 /**
  * The `IStyle` interface combines user-applied styles with dynamic styles, such as those from tables or conditional
@@ -37,19 +38,31 @@ export interface IStyle {
      */
     setQuotePrefix(quotePrefix: boolean | null, options?: IStyle.UpdateOptions): IStyle;
     /**
-     * Returns the border style.
+     * Returns the protection format: whether the cell stays editable, and whether it shows its
+     * formula, while its sheet is protected.
      */
-    getBorder(): IBorder;
+    getProtection(): ICellProtection;
     /**
-     * Sets the border style.
+     * Sets the protection format.
      *
-     * This method allows updating borders using an {@link IBorder} or a shorthand property object.
+     * @param protection The protection or a partial property object to apply. Pass `null` to clear.
+     * @param options Optional configuration for the update.
+     */
+    setProtection(protection: ICellProtection.Update, options?: IStyle.UpdateOptions): IStyle;
+    /**
+     * Returns the borders.
+     */
+    getBorders(): IBorders;
+    /**
+     * Sets the borders.
      *
-     * @param border The border object or a shorthand property object to apply. Pass `null` to clear.
+     * This method allows updating borders using an {@link IBorders} or a shorthand property object.
+     *
+     * @param borders The borders object or a shorthand property object to apply. Pass `null` to clear.
      * @param options Optional configuration for the update.
-     * @returns The `IBorder` object for further modifications.
+     * @returns The `IBorders` object for further modifications.
      */
-    setBorder(border: IBorder.Update, options?: IStyle.UpdateOptions): IStyle;
+    setBorders(borders: IBorders.Update, options?: IStyle.UpdateOptions): IStyle;
     /**
      * Fill properties for the background.
      */
@@ -225,9 +238,9 @@ export declare namespace IStyle {
          * Border properties.
          *
          * @see
-         * {@link IStyle.getBorder}
+         * {@link IStyle.getBorders}
          */
-        border?: IBorder.Properties;
+        borders?: IBorders.Properties;
         /**
          * Quote Prefix property.
          *
@@ -235,6 +248,13 @@ export declare namespace IStyle {
          * {@link IStyle.getQuotePrefix}
          */
         quotePrefix?: boolean;
+        /**
+         * Protection properties.
+         *
+         * @see
+         * {@link IStyle.getProtection}
+         */
+        protection?: ICellProtection.Properties;
         /**
          * Named style property.
          *