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

package/types/src/sheet/_SheetStateTypes.d.ts

@@ -1,27 +1,25 @@
 import { Scalar, IRange } from '@sheetxl/primitives';
+import { ListenerAnchor } from './_ListenerAnchor';
 import { IProperties } from '../type';
 import { ITable } from '../table';
 import { IComment } from '../comment';
 import { IHyperlink } from '../hyperlink';
 import { IStyle } from '../style';
 import { ICellRange } from '../cellRange';
-import { OverlappingRange, ISparseGrid, ISpatialMap } from '../collections';
+import { OverlappingRange, ISpatialMap } from '../collections';
 import { MergeEntry } from './spatial';
+import { FormulaEntry, ICalcGrid } from '../calculation/grid';
 import { SpillEntry, ContentfulSpatialValue, CircularEntry } from '../calculation/spatial';
 import { IConditionalFormat } from '../conditionalFormat';
 import { IDataValidation } from '../dataValidation';
 import { IProtectedRange } from '../protectedRange';
-import { IFormulaBlock } from '../calculation/formula';
 import { IAnchoredMap } from '../anchored/IAnchoredMap';
 import { Anchored } from '../anchored/Anchored';
-import { ICalcGrid } from '../calculation/grid';
 import { IUsedRangeSpatialMap } from './style/UsedRangeSpatialMap';
 import { SheetDirectStyle } from './style/SheetDirectStyle';
 import { IMovable } from '../movable';
 import { Movable } from '../movable/Movable';
 import { IPicture } from '../picture';
-import { IListener } from '../listener';
-import { RangesListener, RangesListenerEntry } from './listener';
 export declare const BreakTrue: Readonly<{
     break: true;
 }>;
@@ -123,7 +121,7 @@ export declare namespace RangeState {
     /**
      * Shorthand type.
      */
-    type Iterator = WellKnownIterator<RangeState.Entry, RangeState.Entry, IRange.Coords>;
+    type Iterator = WellKnownIterator<RangeState.Entry, RangeState.Entry, IRange.CellCoords>;
     /**
      * Dynamic state. These are values associated to a range of cells that
      * get realized at time of cell iterator.
@@ -152,8 +150,9 @@ export declare namespace RangeState {
         conditionals?: IConditionalFormat | IConditionalFormat[];
         /**
          * The per-feature direct styles for a collection of cells (SHEET-STYLE-SPLIT). These are the
-         * user-authored style, kept DISCRETE — `borderStyle` carries `border`, `fillStyle` carries `fill`,
-         * `contentStyle` carries font / numberFormat / alignment / quotePrefix / named / insets.
+         * user-authored style, kept DISCRETE — `borderStyle` carries `borders`, `fillStyle` carries `fill`,
+         * `contentStyle` carries font / numberFormat / alignment / quotePrefix / protection / named /
+         * insets.
          * `CompositeRangedStyle` bag-merges the three; single-category consumers read just one.
          * Public API should use IStyle.
          */
@@ -191,16 +190,17 @@ export declare namespace RangeState {
          */
         continuous?: IProperties.ICellRanged<IStyle.Properties>;
         /**
-         * The comments.
+         * The comment on the cell.
          *
          * @remarks
-         * A block of comments for the range.
+         * The model that owns the cell, the way the other anchored entries answer.
          */
-        comments?: IComment.Properties;
+        comments?: IComment;
         /**
-         * A block of R1C1 formulas.
+         * The formula run this cell belongs to: the sheet's entry, which answers as a block over its
+         * own text whether or not the engine has vended one (see {@link FormulaEntry}).
          */
-        formula?: IFormulaBlock;
+        formula?: FormulaEntry;
         /**
          * Spills.
          *
@@ -273,7 +273,7 @@ export declare namespace RangeState {
         readonly Circular: "circular";
         /**
          * Error VALUES (the `Error` scalar kind). Backed by the RECONCILED view
-         * (`SheetReadContext.getErrorSpatial`), not `state.errorSpatial` directly — resolving it may
+         * (`ICalcGrid.getErrorValues`), not the grid's write-path index directly — resolving it may
          * lazily build (a value scan, cached per state version), so it is opt-in only: never part of
          * {@link AllRangeTypes} / the all-types sweep.
          */
@@ -332,7 +332,7 @@ export declare function cellFeaturesToSearchTypes(features?: ICellRange.Feature
  * themselves.
  * @internal
  */
-export declare function featureToUsedCoords(state: State, feature: ICellRange.Feature): IRange.Coords | null;
+export declare function featureToUsedCoords(state: State, calcGrid: ICalcGrid, feature: ICellRange.Feature): IRange.Coords | null;
 export declare const AllRangeTypes: RangeState.SearchTypes;
 export declare const CellStateRangeTypes: RangeState.SearchTypes;
 /**
@@ -359,25 +359,6 @@ export interface MovableEntry extends Anchored.Entry<IMovable> {
     callbacks: Movable.ContainerCallbacks;
     zIndex: number;
 }
-/** @internal */
-export interface ICellRangeListenerEntry {
-    id: number;
-    offset: number;
-    options: ICellRange.ListenerOptions;
-}
-/** @internal */
-export interface ICellRangesListenerEntry {
-    id: number;
-    /**
-     * We have to track the range because we can't use the node coords
-     * as shift/split can change the coords. and our range has fixed dimensions.
-     */
-    ranges: (Readonly<IRange.FixableCoords> | null)[];
-    handler: ICellRange.Listener | null;
-    handlerW: WeakRef<ICellRange.Listener> | null;
-    removeListener: IListener.Remove;
-    options: ICellRange.ListenerOptions;
-}
 /**
  * The versioned per-sheet state record held in the transaction store (see `Sheet._getState`).
  * A pure data record: sparse grids, spatial maps, and anchored maps. Behaviour lives beside it in
@@ -385,30 +366,6 @@ export interface ICellRangesListenerEntry {
  * @internal
  */
 export interface State {
-    cellValuesGrid: ISparseGrid<Scalar>;
-    contentfulSpatial: ISpatialMap<ContentfulSpatialValue>;
-    calcGrid: ICalcGrid;
-    spillSpatial: ISpatialMap<SpillEntry>;
-    pendingSpatial: ISpatialMap<boolean>;
-    calcErrorsSpatial: ISpatialMap<string>;
-    /**
-     * Cells in a reference cycle or downstream of one, by cycle (DESIGN-CIRCULAR-CALC.md §7.2).
-     * Maintained by calc realize from the executor's deltas, like {@link pendingSpatial}.
-     */
-    circularSpatial: ISpatialMap<CircularEntry>;
-    /**
-     * Error VALUES (`#DIV/0!`, `#N/A`, …) — the `Error` scalar kind, NOT engine failures
-     * (those are {@link calcErrorsSpatial} / `CalcError`). Deliberately not per-type: `true`
-     * means "an error value lives here".
-     *
-     * WRITE-PATH ONLY (merge-on-READ): maintained on load, `updateTuples`, content clears and
-     * structural shifts — calc realize NEVER touches it, so it is STALE for formula cells after
-     * a recalc (a fixed formula stays flagged; a new computed error is absent). Do not query it
-     * directly — the reconciled, state-version-cached view (`Sheet._getErrorSpatialReconciled`)
-     * is the only reader. It becomes fully fresh (and the reconcile scan retires) when the calc
-     * executor emits error deltas for realize to apply, O(errors) like `calcErrorsSpatial`.
-     */
-    errorSpatial: ISpatialMap<boolean>;
     borderSpatial: IUsedRangeSpatialMap<SheetDirectStyle>;
     fillSpatial: IUsedRangeSpatialMap<SheetDirectStyle>;
     contentSpatial: IUsedRangeSpatialMap<SheetDirectStyle>;
@@ -416,7 +373,6 @@ export interface State {
     continuousFillSpatial: ISpatialMap<SheetDirectStyle>;
     dateFormatSpatial: ISpatialMap<string>;
     hyperlinkSpatial: ISpatialMap<IHyperlink.Properties>;
-    commentsSpatial: ISpatialMap<IComment.Properties>;
     movableSpatial: ISpatialMap<MovableEntry>;
     movableMapModel: Map<IMovable, ISpatialMap.Entry<MovableEntry>>;
     picture?: IPicture | null;
@@ -431,29 +387,57 @@ export interface State {
      * Read through `RangeState.Type.Unlock` — see {@link RangeState.Intersection.unlock}.
      */
     protectedRanges: IAnchoredMap<IProtectedRange, IProtectedRange.JSON>;
-    rangesListenerSpatial2: ISpatialMap<RangesListenerEntry>;
-    rangesListenerMap2: Map<string, RangesListener>;
-    rangeListenerSpatial: ISpatialMap<ICellRangeListenerEntry>;
-    rangesListenerMap: Map<number, ICellRangesListenerEntry>;
+    /**
+     * The comments and notes, one per cell.
+     *
+     * @remarks
+     * Read through `RangeState.Type.Comments` — see {@link RangeState.Intersection.comments}.
+     */
+    comments: IAnchoredMap<IComment, IComment.JSON>;
+    /**
+     * The reference each range listener watches.
+     *
+     * @remarks
+     * Beside the other anchored maps, and versioned like them: a listener's reference shifts, splits
+     * and goes `#REF!` with the cells it watches, and comes back on undo. A snapshot from before a
+     * listener registered simply holds no entry for it, which is what reports `#N/A`.
+     *
+     * The callbacks are NOT here - they live on the sheet instance, keyed by node id.
+     */
+    listeners: IAnchoredMap<ListenerAnchor, never>;
+    /**
+     * The grid's inputs this record pairs with, as the grid named them when the model last wrote
+     * this sheet's cells (`ICalcGrid.Events.onInputsWritten`); `null` before any write.
+     *
+     * @remarks
+     * The cells are the grid's record, so a write of cell content alone writes nothing else of the
+     * sheet's; this is the sheet's own record of it, and what brings the sheet's state listener to
+     * the commit. What the engine calculates never changes it. Two records with the same id hold
+     * the same cell content.
+     */
+    inputsCommitId: string | null;
     entireCoords: IRange.Coords;
     deleted: boolean;
 }
-/**
- * Tracks a range listener's before/after state for the undo stack when the change is not part of the
- * transaction (non-transactional listeners).
- * @internal
- */
-export interface BeforeAfterRange {
-    beforeState: ICellRangesListenerEntry;
-    afterState: ICellRangesListenerEntry | null;
-}
 /**
  * Internal flags threaded through the cell-update path (`updateTuples` / `createSparseBuilder`) to
- * mark the origin of the update (a full cell paste, or a hyperlink display-text write).
+ * mark the origin of the update (a full cell paste, a hyperlink display-text write, one value
+ * broadcast over a range).
  * @internal
  */
 export interface InternalTupleUpdate {
     isCell?: boolean;
     isHyperlink?: boolean;
+    /**
+     * The tuples repeat ONE value over the whole range (`setValue`/`setFormula` on a multi-cell
+     * range). A formula is then that formula FILLED — one block anchored at the top-left, its
+     * references relative from there — not the same text entered in every cell.
+     */
+    isBroadcast?: boolean;
+    /**
+     * The tuples array-enter ONE formula over this extent (`setFormula` with `arrayFixed`): the
+     * formula at the top-left, every other cell cleared. The calc node is minted fixed to it.
+     */
+    arrayFixed?: IRange.Coords;
 }
 //# sourceMappingURL=_SheetStateTypes.d.ts.map

package/types/src/sheet/_SheetUtils.d.ts

@@ -9,9 +9,8 @@ import { ICellRange, ICellRanges } from '../cellRange';
 import { ISheetHeader } from '../sheetHeader';
 import { ISheet } from './ISheet';
 import { ISheetInternal } from './Sheet';
-import { Tuple, ISpatialMap, IListLike, ISpatialQuery } from '../collections';
+import { ISpatialMap, ISpatialQuery } from '../collections';
 import { MergeEntry } from './spatial';
-import { ContentfulSpatialValue } from '../calculation/spatial';
 import { RangeState, CellState } from './_SheetStateTypes';
 import { SheetDirectStyle } from './style/SheetDirectStyle';
 import { SheetCellOptions } from './SheetCell';
@@ -99,7 +98,7 @@ export declare function createCellModifiersFromString(runtime: IRuntime, strValu
  */
 export declare function calcAccountingBottomInset(style: IStyle): number;
 /** @internal */
-export declare function getHiddenRuns(header: ISheetHeader): RunCoords[];
+export declare function getHiddenRuns(header: ISheetHeader): readonly RunCoords[];
 /**
  * Merges an array of rangeStateIntersections into a single RangeStateIntersection.
  *
@@ -174,21 +173,6 @@ export declare function getDefaultSortCriteria(sheet: ISheet, rangeCoords: IRang
 export declare function findSurroundingRegion(range: IRange.Coords, spatials: ISpatialQuery[], maxIterations?: number): IRange.Coords | null;
 export declare function findExtendedRegion(direction: IRange.Direction, coords: IRange.CellCoords, asRange: IRange.Coords, // TODO - merge this into coords?
 searchSpatials: (range: IRange.Coords) => IRange.Coords[], entireCoords: IRange.Coords): IRange.Coords;
-/**
- * Internal representation of a Scalar.
- */
-export type TypeAndValue = [v: Scalar, t: string];
-/**
- * Converts TypeAndValue to a value appropriate for storing in the grid.
- *
- * @param values an array of Scalar.
- * @returns An `IListLike` of values
- */
-export declare function toListLike(values: Scalar[], strings: IStringCollection, internal?: TypeAndValue[] | null): IListLike<Scalar>;
-/**
- * Wraps each value in a ContentfulSpatialValue
- */
-export declare function tuplesToContentfulEntries(gridTuple: Tuple.GridTuple<Scalar>, isColumn: boolean): ISpatialMap.Entry<ContentfulSpatialValue>[];
 /**
  * Expands ranges to include merges.
  */

package/types/src/sheet/_WatchAnchor.d.ts

@@ -0,0 +1,93 @@
+import { Scalar } from '@sheetxl/primitives';
+import { ISparseGrid } from '../collections';
+import { ICellRange } from '../cellRange';
+import { ICalcGrid, FormulaHost } from '../calculation/grid';
+import { FormulaSpatialValue } from '../calculation/spatial';
+import { ListenerAnchor } from './_ListenerAnchor';
+/**
+ * A listener node that owns a formula: the location of a watch.
+ *
+ * @remarks
+ * A watch is a range listener that fires on formula evaluation. Its LOCATION has the semantics of
+ * a reference - it grows when a row is inserted inside it, travels with a cut that encloses it,
+ * goes `#REF!` when its cells are deleted and comes back on undo - which is exactly what a node in
+ * the sheet's anchored `listeners` map gets, so that is what this is. Its BODY is one formula block
+ * in a grid of its own that shadows the sheet (see {@link FormulaHost}), written at the watched
+ * cells as if it had been typed there, and from then on the graph does for it everything a cell
+ * formula gets: precedents, dirty marking, the reference rewrite a structural change does, `#REF!`.
+ *
+ * The body FOLLOWS the node, by one rule ({@link reconcile}): whenever the node's address changes,
+ * the body is re-imaged at the node's coords; when the node has no coords, the body is cleared.
+ * The body's grid is never shifted geometrically.
+ *
+ * The node is shared by every snapshot that holds it (as a listener node is: `delete`/`undelete`
+ * mark the instance), so what is here is what is true of the watch regardless of snapshot: the
+ * host, a handle that resolves its grid by id, and what was last delivered. The callbacks are NOT
+ * here - they live on the sheet instance keyed by node id, as every listener's do, and an entry
+ * that is gone is what makes a node left behind in an older snapshot inert.
+ *
+ * @internal
+ */
+export declare class WatchAnchor extends ListenerAnchor {
+    /** Holds the body. */
+    readonly host: FormulaHost;
+    /** The grid's values as of the last delivery, so a pass that changed nothing is not re-delivered. */
+    protected _lastValues: ISparseGrid<Scalar> | null;
+    /** The body's blank region as of the last delivery - the part of the answer the grid does not hold. */
+    protected _lastBlank: FormulaSpatialValue.BlankRegion | null;
+    constructor(options: WatchAnchor.ConstructorOptions);
+    /**
+     * Hand the body's values to the watch after a pass, when something inside the location changed.
+     *
+     * @remarks
+     * The values go out as a VIEW over the grid's own sparse values at the location, `(0, 0)` at its
+     * top-left - nothing is materialized, however large the body; the caller reads what it reads.
+     *
+     * Delivered only when something inside the location is different from the last delivery: a
+     * restore runs more than one pass today and every pass reports the body, and a pass that
+     * recomputed a cell to the value it already had is not a change the caller was promised. The
+     * previous values are gone by the time the pass reports, so the compare is against a
+     * copy-on-write clone of the values taken at the last delivery (`SparseGrid.clone` shares its
+     * storage until the grid writes), and it is bounded by what the pass WROTE (`results.bounds`)
+     * intersected with the location. It walks what either grid STORES there rather than every cell
+     * of the window: the body's blank region is not stored at all (its one answer is on the block,
+     * compared as one value), so a rule over an entire sheet compares its touched cells and a value.
+     *
+     * @param results What the pass wrote to the body's grid.
+     * @param handlers Where to deliver; `onChange` alone is told of every pass that wrote the body.
+     */
+    deliver(results: ICalcGrid.Results, handlers: WatchAnchor.Handlers): void;
+    /**
+     * Bring the body to the location.
+     *
+     * @remarks
+     * Read against the map the sheet is currently at, so a split or a drop the map did is covered
+     * by the same rule as a move. The body is re-imaged from its OWN top-left: the engine's shift of
+     * the sheet has already rewritten the body's references to follow the cells they name (the body
+     * is a formula on another grid to that shift), so the text at the block's top-left already reads
+     * the right cells, and writing that text at the new location keeps it on them - which is
+     * Excel's rule for a cut formula, and for an insert it is the same rule with the references
+     * having moved by the same amount as the location.
+     *
+     * An insert INSIDE the location is the case a formula block does not handle on its own (a cell
+     * formula does not fill a new row): the node grew, the block did not, and the re-image over the
+     * node's extent is what fills the new cells.
+     */
+    reconcile(): void;
+}
+/** @internal */
+export declare namespace WatchAnchor {
+    interface ConstructorOptions extends ListenerAnchor.ConstructorOptions {
+        host: FormulaHost;
+    }
+    /** What a watch is told. Held by the sheet, never by the node. */
+    interface Handlers {
+        /** The body's values after every pass that changed them. */
+        onValues?: ICellRange.WatchCallback;
+        /** That a pass evaluated the body, without the values. */
+        onChange?: () => void;
+        /** The body's host, once registered — for an owner that reads the body back. */
+        onRegistered?: (host: FormulaHost) => void;
+    }
+}
+//# sourceMappingURL=_WatchAnchor.d.ts.map

package/types/src/sheet/spatial/HeldFormulaEntry.d.ts

@@ -0,0 +1,36 @@
+import { IRange, FormulaError } from '@sheetxl/primitives';
+import { ICalculation } from '../../calculation/ICalculation';
+import { FormulaEntry } from '../../calculation/grid/FormulaEntry';
+/**
+ * The entry a formula write that has not been made yet reads as: pending, its run's text imaged
+ * at the cell.
+ *
+ * @remarks
+ * A cell read while its write is held (`CellBuffer`) answers from this, the way a cell reads a
+ * pending entry when the engine has not compiled it. It is not the entry the write puts in the
+ * sheet's map, so once the write is made it answers from that one - a formula handle taken
+ * before then is as functional after it as one taken from the map.
+ * @internal
+ */
+export declare class HeldFormulaEntry extends FormulaEntry {
+    private _made;
+    private _isResolved;
+    private readonly _resolve;
+    /**
+     * @param resolve The entry the write put in the map: `undefined` while the write is held,
+     * `null` if the map holds none for the cell (the write was dropped, or written over).
+     */
+    constructor(a1: string, ref: IRange.Coords, resolve: () => FormulaEntry | null | undefined);
+    private _view;
+    /** {@inheritDoc FormulaEntry.isCompiled} */
+    isCompiled(): boolean;
+    /** {@inheritDoc IFormulaBlockView.getTextAt} */
+    getTextAt(row: number, column: number, r1c1?: boolean, evalIndex?: number, target?: ICalculation.FormulaTarget): string;
+    /** {@inheritDoc IFormulaBlockView.getTokensAt} */
+    getTokensAt(row: number, column: number, evalIndex?: number): ICalculation.FormulaToken[];
+    /** {@inheritDoc IFormulaBlockView.isReferenceOnly} */
+    isReferenceOnly(): boolean;
+    /** {@inheritDoc IFormulaBlockView.getError} */
+    getError(): FormulaError.Parse | null;
+}
+//# sourceMappingURL=HeldFormulaEntry.d.ts.map

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

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

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

@@ -6,7 +6,8 @@ import { IColor } from '../../color';
 import { IFill } from '../../fill';
 import { IFont } from '../../font';
 import { ITextFrame, IStyledFont } from '../../text';
-import { IBorder } from '../../border';
+import { IBorders } from '../../border';
+import { ICellProtection } from '../../cell';
 import { IStyle, IStyleCollection } from '../../style';
 export interface CreateCellStyleOptions {
     styles: IStyleCollection;
@@ -89,54 +90,54 @@ declare class Inheritable<P, J> {
     getProperties(): P;
     toJSON(): J;
 }
-export declare class CellBorderStroke extends Inheritable<IBorder.StrokeProperties, IBorder.StrokeJSON> implements IBorder.IStroke {
-    protected _edge: IBorder.Edge;
-    constructor(edge: IBorder.Edge, options: CreateCellStyleOptions, properties: IBorder.StrokeProperties[]);
-    /** {@inheritDoc IBorder.IStroke.getStyle} */
-    getStyle(): IBorder.StrokeStyle;
-    /** {@inheritDoc IBorder.IStroke.setStyle} */
-    setStyle(style: IBorder.StrokeStyle | string | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
-    /** {@inheritDoc IBorder.IStroke.getColor} */
+export declare class CellBorderStroke extends Inheritable<IBorders.StrokeProperties, IBorders.StrokeJSON> implements IBorders.IStroke {
+    protected _edge: IBorders.Edge;
+    constructor(edge: IBorders.Edge, options: CreateCellStyleOptions, properties: IBorders.StrokeProperties[]);
+    /** {@inheritDoc IBorders.IStroke.getStyle} */
+    getStyle(): IBorders.StrokeStyle;
+    /** {@inheritDoc IBorders.IStroke.setStyle} */
+    setStyle(style: IBorders.StrokeStyle | string | null, options?: IStyle.UpdateOptions): IBorders.IStroke;
+    /** {@inheritDoc IBorders.IStroke.getColor} */
     getColor(): IColor;
-    /** {@inheritDoc IBorder.IStroke.setColor} */
-    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IBorder.IStroke;
-    /** {@inheritDoc IBorder.IStroke.isNone} */
+    /** {@inheritDoc IBorders.IStroke.setColor} */
+    setColor(color: IColor.Serializable | null, options?: IStyle.UpdateOptions): IBorders.IStroke;
+    /** {@inheritDoc IBorders.IStroke.isNone} */
     isNone(): boolean;
-    /** {@inheritDoc IBorder.IStroke.toCSS} */
+    /** {@inheritDoc IBorders.IStroke.toCSS} */
     toCSS(): Partial<CSSStyleDeclaration>;
     get [Symbol.toStringTag](): string;
     toString(): string;
-    /** {@inheritDoc IBorder.IStroke.isIStroke} */
+    /** {@inheritDoc IBorders.IStroke.isIStroke} */
     get isIStroke(): true;
 }
-export declare class CellBorder extends Inheritable<IBorder.Properties, IBorder.JSON> implements IBorder {
-    protected _left: IBorder.IStroke | undefined;
-    protected _right: IBorder.IStroke | undefined;
-    protected _top: IBorder.IStroke | undefined;
-    protected _bottom: IBorder.IStroke | undefined;
-    protected _diagUp: IBorder.IStroke | undefined;
-    protected _diagDown: IBorder.IStroke | undefined;
+export declare class CellBorder extends Inheritable<IBorders.Properties, IBorders.JSON> implements IBorders {
+    protected _left: IBorders.IStroke | undefined;
+    protected _right: IBorders.IStroke | undefined;
+    protected _top: IBorders.IStroke | undefined;
+    protected _bottom: IBorders.IStroke | undefined;
+    protected _diagUp: IBorders.IStroke | undefined;
+    protected _diagDown: IBorders.IStroke | undefined;
     protected _isEmpty: boolean | undefined;
-    /** {@inheritDoc IBorder.getLeft} */
-    getLeft(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setLeft} */
-    setLeft(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getRight} */
-    getRight(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setRight} */
-    setRight(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getTop} */
-    getTop(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setTop} */
-    setTop(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.IStroke.getBottom} */
-    getBottom(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setBottom} */
-    setBottom(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getHorizontal} */
-    getHorizontal(): IBorder.IStroke | null;
-    /** {@inheritDoc IBorder.getVertical} */
-    getVertical(): IBorder.IStroke | null;
+    /** {@inheritDoc IBorders.getLeft} */
+    getLeft(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setLeft} */
+    setLeft(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getRight} */
+    getRight(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setRight} */
+    setRight(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getTop} */
+    getTop(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setTop} */
+    setTop(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.IStroke.getBottom} */
+    getBottom(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setBottom} */
+    setBottom(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getHorizontal} */
+    getHorizontal(): IBorders.IStroke | null;
+    /** {@inheritDoc IBorders.getVertical} */
+    getVertical(): IBorders.IStroke | null;
     /**
      * The inner rule for an axis, read from the authored block rather than the cell.
      *
@@ -147,32 +148,32 @@ export declare class CellBorder extends Inheritable<IBorder.Properties, IBorder.
      * @internal
      */
     private _inner;
-    /** {@inheritDoc IBorder.IStroke.getDiagonalUp} */
-    getDiagonalUp(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setDiagonalUp} */
-    setDiagonalUp(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.getDiagonalDown} */
-    getDiagonalDown(): IBorder.IStroke;
-    /** {@inheritDoc IBorder.setDiagonalDown} */
-    setDiagonalDown(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.setVertical} */
-    setVertical(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.setHorizontal} */
-    setHorizontal(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
-    /** {@inheritDoc IBorder.setHorizontal} */
-    setOutline(stroke: IBorder.IStroke | IProperties.ResolvableProperties<IBorder.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorder;
+    /** {@inheritDoc IBorders.IStroke.getDiagonalUp} */
+    getDiagonalUp(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setDiagonalUp} */
+    setDiagonalUp(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.getDiagonalDown} */
+    getDiagonalDown(): IBorders.IStroke;
+    /** {@inheritDoc IBorders.setDiagonalDown} */
+    setDiagonalDown(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.setVertical} */
+    setVertical(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.setHorizontal} */
+    setHorizontal(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
+    /** {@inheritDoc IBorders.setHorizontal} */
+    setOutline(stroke: IBorders.IStroke | IProperties.ResolvableProperties<IBorders.StrokeProperties> | string | null, options?: IStyle.UpdateOptions): IBorders;
     /**
      * Resolves whether an edge's effective stroke style is `None` without allocating a
      * `CellBorderStroke`. Mirrors `CellBorderStroke.getStyle()` (last-defined `style` across layers,
      * honoring per-property inheritance).
      */
-    protected _edgeStyleIsNone(edge: IBorder.Edge): boolean;
-    /** {@inheritDoc IBorder.IStroke.isEmpty} */
+    protected _edgeStyleIsNone(edge: IBorders.Edge): boolean;
+    /** {@inheritDoc IBorders.IStroke.isEmpty} */
     isEmpty(): boolean;
     get [Symbol.toStringTag](): string;
     toString(): string;
-    /** {@inheritDoc IBorder.IStroke.isIBorder} */
-    get isIBorder(): true;
+    /** {@inheritDoc IBorders.isIBorders} */
+    get isIBorders(): true;
 }
 export declare class CellAlignment extends Inheritable<ITextFrame.IAlignment.Properties, ITextFrame.IAlignment.JSON> implements ITextFrame.IAlignment {
     /** {@inheritDoc ITextBoxAlignment.getHorizontal} */
@@ -216,6 +217,20 @@ export declare class CellAlignment extends Inheritable<ITextFrame.IAlignment.Pro
     /** {@inheritDoc ITextBoxAlignment.isITextBoxAlignment} */
     get isITextBoxAlignment(): true;
 }
+export declare class CellProtection extends Inheritable<ICellProtection.Properties, ICellProtection.JSON> implements ICellProtection {
+    /** {@inheritDoc ICellProtection.isAlwaysUnlocked} */
+    isAlwaysUnlocked(): boolean;
+    /** {@inheritDoc ICellProtection.setAlwaysUnlocked} */
+    setAlwaysUnlocked(alwaysUnlocked: boolean | null, options?: IStyle.UpdateOptions): ICellProtection;
+    /** {@inheritDoc ICellProtection.isShowFormulas} */
+    isShowFormulas(): boolean;
+    /** {@inheritDoc ICellProtection.setShowFormulas} */
+    setShowFormulas(showFormulas: boolean | null, options?: IStyle.UpdateOptions): ICellProtection;
+    get [Symbol.toStringTag](): string;
+    toString(): string;
+    /** {@inheritDoc ICellProtection.isICellProtection} */
+    get isICellProtection(): true;
+}
 export declare class CellFont extends Inheritable<IStyledFont.Properties, IStyledFont.JSON> implements IStyledFont {
     /** {@inheritDoc IStyle.isEqualMeasure} */
     isEqualMeasure(other: IStyledFont): boolean;
@@ -441,8 +456,9 @@ export declare class SheetCellStyle implements IStyle {
     protected _hasVisibleStyling: boolean | undefined;
     protected _font: IStyledFont | undefined;
     protected _alignment: ITextFrame.IAlignment | undefined;
-    protected _border: IBorder | undefined;
+    protected _border: IBorders | undefined;
     protected _fill: IFill.ISolid | IFill.IGradient | IFill.IPattern | IFill.INone | undefined;
+    protected _protection: ICellProtection | undefined;
     constructor(options: CreateCellStyleOptions);
     /** {@inheritDoc IStyle.toJSON} */
     toJSON(): IStyle.JSON;
@@ -471,10 +487,10 @@ export declare class SheetCellStyle implements IStyle {
     getBestFit(): Partial<Size> | null;
     /** {@inheritDoc IStyle.getInsets} */
     getInsets(): Rectangle;
-    /** {@inheritDoc IStyle.getBorder} */
-    getBorder(): IBorder;
-    /** {@inheritDoc IStyle.setBorder} */
-    setBorder(border: IBorder.Update, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.getBorders} */
+    getBorders(): IBorders;
+    /** {@inheritDoc IStyle.setBorders} */
+    setBorders(borders: IBorders.Update, options?: IStyle.UpdateOptions): IStyle;
     /** {@inheritDoc IStyle.getFont} */
     getFont(): IStyledFont;
     /** {@inheritDoc IStyle.setFont} */
@@ -497,12 +513,23 @@ export declare class SheetCellStyle implements IStyle {
     setAlignment(alignment: ITextFrame.IAlignment.Update | string | null, options?: IStyle.UpdateOptions): IStyle;
     /** {@inheritDoc IStyle.getNumberFormat} */
     getNumberFormat(): string;
+    /**
+     * The number format as stored: a built-in id or a format code. {@link getNumberFormat} resolves
+     * an id to its code.
+     *
+     * @internal
+     */
+    getNumberFormatRef(): string | number;
     /** {@inheritDoc IStyle.setNumberFormat} */
     setNumberFormat(numFmt: string | null, options?: IStyle.UpdateOptions): IStyle;
     /** {@inheritDoc IStyle.getQuotePrefix} */
     getQuotePrefix(): boolean;
     /** {@inheritDoc IStyle.setQuotePrefix} */
     setQuotePrefix(quotePrefix: boolean | null, options?: IStyle.UpdateOptions): IStyle;
+    /** {@inheritDoc IStyle.getProtection} */
+    getProtection(): ICellProtection;
+    /** {@inheritDoc IStyle.setProtection} */
+    setProtection(protection: ICellProtection.Update, options?: IStyle.UpdateOptions): IStyle;
     /** {@inheritDoc IStyle.getNamed} */
     getNamed(): IStyle.INamed;
     /** {@inheritDoc IStyle.setNamed} */