@ex-grid/sheet-engine 0.0.0-stage → 0.2.0-beta.3

package/dist/index.d.ts

@@ -0,0 +1,3250 @@
+/**
+ * ExSheet's formula engine in TypeScript (ADR-0370, section 2): a Workbook of Sheets of Entries, Excel's formula
+ * syntax, a declared set of functions that answer as Excel does or refuse, incremental recalculation, number
+ * formats, Cell Formats, the edits a Sheet takes with their undo steps, and the documents that carry a Sheet and a
+ * Workbook. It is held to the same cases as ExSheet.Engine.
+ *
+ * @packageDocumentation
+ */
+
+/** A cell's address with its state. @internal */
+declare interface AddressedState {
+    readonly address: CellAddress;
+    readonly state: CellState;
+}
+
+/** An inclusive rectangle of cells, zero-based. */
+declare class Area {
+    readonly row1: number;
+    readonly column1: number;
+    readonly row2: number;
+    readonly column2: number;
+    constructor(row1: number, column1: number, row2: number, column2: number);
+    get isSingleCell(): boolean;
+    get cellCount(): number;
+    get rows(): number;
+    get columns(): number;
+    contains(address: CellAddress): boolean;
+    equals(other: Area): boolean;
+}
+
+/** The argument hint (ADR-0051): the function whose argument list holds the caret, and which argument it is in. */
+export declare interface ArgumentHint {
+    /** The declared function. */
+    readonly function: DeclaredFunction;
+    /** Which argument the caret is in, from 0. */
+    readonly argumentIndex: number;
+    /**
+     * That argument's name as `DeclaredFunction.arguments` lists it — for an open-ended function past its named
+     * arguments, the one that repeats — or `undefined` when the caret is past the last argument the function takes.
+     */
+    readonly currentArgument: string | undefined;
+}
+
+/** One of a fixed list of values an argument takes, as completion lists it (ADR-0058): the value, and Excel's text for it. */
+export declare interface ArgumentValue {
+    /** What choosing it writes into the Formula: `-1`. */
+    readonly value: string;
+    /** The text the list shows, Excel's: `-1 - Exact match or next smaller item`. */
+    readonly text: string;
+}
+
+/** The parts of a Cell Format recorded on a whole row or a whole column: `undefined` where that level records nothing. @internal */
+declare class AxisFormat {
+    readonly numberFormat: NumberFormat | undefined;
+    readonly alignment: HorizontalAlignment | undefined;
+    readonly font: CellFont | undefined;
+    readonly fill: CellFill | undefined;
+    readonly borders: CellBorders | undefined;
+    constructor(numberFormat: NumberFormat | undefined, alignment: HorizontalAlignment | undefined, font: CellFont | undefined, fill: CellFill | undefined, borders: CellBorders | undefined);
+    /** The level that records nothing. */
+    static readonly empty: AxisFormat;
+    get isEmpty(): boolean;
+    /** What the level shows over `under`: each part it records, else `under`'s. */
+    over(under: CellFormat): CellFormat;
+    /** The level with each part `change` sets taken from `next`, and recorded as nothing where it equals what shows under the level anyway. */
+    with(change: CellFormatChange, next: CellFormat, under: CellFormat): AxisFormat;
+    /** This level with the parts given replaced; a part given as `undefined` records nothing. */
+    replacing(parts: {
+        numberFormat?: NumberFormat | undefined;
+        alignment?: HorizontalAlignment | undefined;
+        fill?: CellFill | undefined;
+        borders?: CellBorders | undefined;
+    }): AxisFormat;
+    /** A key two equal levels share and two different ones do not. */
+    get key(): string;
+    equals(other: AxisFormat): boolean;
+}
+
+/**
+ * A binary operator. Excel's operators associate to the left, so `=1+1+…+1` is a chain of these down their
+ * left operands, as long as the Formula: a walk over one loops along that chain (`spine`, `operands`) and
+ * descends only into the right operands, so a chain of thousands of operators never deepens the stack.
+ */
+declare class BinaryNode extends NodeBase {
+    #private;
+    readonly kind = "binary";
+    readonly operator: string;
+    readonly left: Node_2;
+    readonly right: Node_2;
+    constructor(operator: string, left: Node_2, right: Node_2);
+    get depth(): number;
+    references(): Generator<Reference>;
+    structuredReferences(): Generator<StructuredReferenceNode>;
+    calls(): Generator<FunctionNode>;
+    /**
+     * This operator and those down its left operands, innermost (the first applied) first: the chain `1+2-3`
+     * is the `+`, then the `-`. The innermost's left operand is `leftmost`.
+     */
+    get spine(): BinaryNode[];
+    /** The first operand of the chain: the left operand of its innermost operator, which is no operator. */
+    get leftmost(): Node_2;
+    /** The chain's operands in the text's order: `leftmost`, then each operator's right operand. */
+    operands(): Generator<Node_2>;
+}
+
+declare class BooleanNode extends NodeBase {
+    readonly kind = "boolean";
+    readonly value: boolean;
+    constructor(value: boolean);
+}
+
+/**
+ * The Borders a change sets, relative to each range it is set on (ADR-0071), as Excel's Format Cells sets them:
+ * each edge given is set — to a line, or to `BorderLine.none` to take the line away — and every other edge is left
+ * as each cell has it. `outline`, `inside` and `none` are Excel's presets. As Excel keeps the line between two
+ * cells (the twelfth Windows run): an outer edge is recorded on the range's own cells, and the cells beside it lose
+ * their record of the same edge.
+ */
+export declare class BorderChange implements BorderChangeParts {
+    #private;
+    /** {@inheritDoc BorderChangeParts.top} */
+    readonly top: BorderLine | undefined;
+    /** {@inheritDoc BorderChangeParts.bottom} */
+    readonly bottom: BorderLine | undefined;
+    /** {@inheritDoc BorderChangeParts.left} */
+    readonly left: BorderLine | undefined;
+    /** {@inheritDoc BorderChangeParts.right} */
+    readonly right: BorderLine | undefined;
+    /** {@inheritDoc BorderChangeParts.insideHorizontal} */
+    readonly insideHorizontal: BorderLine | undefined;
+    /** {@inheritDoc BorderChangeParts.insideVertical} */
+    readonly insideVertical: BorderLine | undefined;
+    constructor(parts: BorderChangeParts);
+    /** Excel's Outline: `line` on the range's four outer edges. */
+    static outline(line: BorderLine): BorderChange;
+    /** Excel's Inside: `line` on every edge inside the range. */
+    static inside(line: BorderLine): BorderChange;
+    /** Excel's None: every edge of the range, outer and inner, without a line. */
+    static readonly none: BorderChange;
+    /** Whether the change sets no edge. @internal */
+    get isEmpty(): boolean;
+    /** The four sides a cell at `place` in its range shows once the change is set, from `borders`. @internal */
+    applyTo(borders: CellBorders, place: PlaceInRange): CellBorders;
+    /**
+     * The change as it is set on `range`. Over whole rows short of the whole Sheet, the left of column A is the
+     * range's left edge, and where the change sets no left edge of its own it takes the inside vertical line (the
+     * fourteenth Windows run, case 14). Over any other range the change is as it is. @internal
+     */
+    on(range: CellRange): BorderChange;
+    /**
+     * The cells beside `range` across each outer edge the change sets, with the change that clears their record of
+     * it (the twelfth Windows run). An edge on the Sheet's outer edge has none. @internal
+     */
+    beside(range: CellRange): Generator<{
+        range: CellRange;
+        borders: BorderChange;
+    }>;
+}
+
+/** The edges a Border change may set. */
+export declare interface BorderChangeParts {
+    /** The range's top edge: the top side of its first row's cells. The cells above them lose their record of it. */
+    readonly top?: BorderLine | undefined;
+    /** The range's bottom edge: the bottom side of its last row's cells. The cells below them lose their record of it. */
+    readonly bottom?: BorderLine | undefined;
+    /** The range's left edge: the left side of its first column's cells. The cells to their left lose their record of it. */
+    readonly left?: BorderLine | undefined;
+    /** The range's right edge: the right side of its last column's cells. The cells to their right lose their record of it. */
+    readonly right?: BorderLine | undefined;
+    /** Every edge between two of the range's rows: the bottom side of the upper cell and the top side of the lower. */
+    readonly insideHorizontal?: BorderLine | undefined;
+    /** Every edge between two of the range's columns: the right side of the left cell and the left side of the right. */
+    readonly insideVertical?: BorderLine | undefined;
+}
+
+/** A Border (CONTEXT.md; ADR-0071): the line on one side of a cell, in one of Excel's thirteen line styles and a colour, or `none`. */
+export declare class BorderLine {
+    /** The line style; `none` for no line. */
+    readonly style: BorderLineStyle;
+    /** The line's colour; Automatic for no line. */
+    readonly colour: CellColour;
+    /** A line in `style` and `colour`. `none` is no line, and has no colour. Throws a RangeError for a style that is not one. */
+    constructor(style: BorderLineStyle, colour?: CellColour);
+    /** No line. */
+    static readonly none: BorderLine;
+    /** Whether this is no line. */
+    get isNone(): boolean;
+    /** A value equal ones share, to key a map by. @internal */
+    get key(): string;
+    /** Whether `other` is the same line. */
+    equals(other: BorderLine): boolean;
+}
+
+/** Excel's thirteen line styles for a Border (ADR-0071), and `none`. No diagonals. */
+export declare type BorderLineStyle = 'none' | 'hair' | 'thin' | 'medium' | 'thick' | 'double' | 'dotted' | 'dashed' | 'dashDot' | 'dashDotDot' | 'mediumDashed' | 'mediumDashDot' | 'mediumDashDotDot' | 'slantedDashDot';
+
+/** One cell the Sheet holds. @internal */
+declare class Cell {
+    entry: Entry | undefined;
+    value: Value | undefined;
+    /** The cell's own Number Format; `undefined` when it takes its row's or column's (ADR-0047). */
+    numberFormat: NumberFormat | undefined;
+    alignment: HorizontalAlignment | undefined;
+    font: CellFont | undefined;
+    fill: CellFill | undefined;
+    borders: CellBorders | undefined;
+    /** For an Anchor, the array its Formula computed (ADR-0125); `undefined` for a result of one Value. */
+    array: ValueArray | undefined;
+    /** For an Anchor: whether the last layout found its Spill Range in the way, so that it shows `#SPILL!`. */
+    spillBlocked: boolean;
+    /** For a cell of a Spill Range, the Anchor whose array gives its Value; it holds no Entry of its own. */
+    spilledFrom: CellAddress | undefined;
+    readonly address: CellAddress;
+    constructor(address: CellAddress);
+    /** Whether the cell records any part of a Cell Format of its own. */
+    get isFormatted(): boolean;
+    get isEmpty(): boolean;
+    /** What the cell shows over `inherited`: each part its own, else the level's. */
+    over(inherited: CellFormat): CellFormat;
+    /** Records the Cell Format `other` records of its own, and nothing else of it. */
+    takeFormatOf(other: Cell): void;
+    /** Records each part `change` sets as `shown` has it, and nothing where `inherited` gives the same; whether anything changed. */
+    take(change: CellFormatChange, shown: CellFormat, inherited: CellFormat): boolean;
+}
+
+/**
+ * Where a cell is on a Sheet: a zero-based row and column inside Excel's extent. Written in A1 form (`A1` is
+ * row 0, column 0; `XFD1048576` is the last cell). An address is where a cell is; a Reference is how a
+ * Formula names it (CONTEXT.md).
+ */
+export declare class CellAddress {
+    #private;
+    /** An address; one outside the Sheet's extent is refused with a `RangeError`, never clamped. */
+    constructor(row: number, column: number);
+    /** The zero-based row, 0 to 1,048,575. */
+    get row(): number;
+    /** The zero-based column, 0 to 16,383. */
+    get column(): number;
+    /** A number that names the address alone, row-major: two addresses are equal exactly where their keys are. */
+    get key(): number;
+    /** The address a key names. */
+    static fromKey(key: number): CellAddress;
+    /** Whether the two name the same cell. */
+    equals(other: CellAddress): boolean;
+    /** Row-major order: by row, then by column. */
+    compareTo(other: CellAddress): number;
+    /** Parses an address in A1 form, such as `B7` or `xfd1048576`; anything else is refused with a `FormatError`. */
+    static parse(text: string): CellAddress;
+    /**
+     * Parses an address in A1 form, or `undefined`. Letters may be in either case; `$` markers are not part
+     * of an address (they belong to a Reference) and are refused here.
+     */
+    static tryParse(text: string): CellAddress | undefined;
+    /** The column's letters: 0 is `A`, 25 is `Z`, 26 is `AA`, 16,383 is `XFD`. */
+    static columnName(column: number): string;
+    /** Parses column letters (`A` to `XFD`, either case) to a zero-based column, or `undefined`. */
+    static tryParseColumn(letters: string): number | undefined;
+    /** The address in A1 form, such as `C12`. */
+    toString(): string;
+}
+
+/**
+ * A cell's Borders (ADR-0071): the line on each of its four sides. Each cell records its own four sides, as Excel's
+ * files do, and the edge two cells share shows one line from either side: the upper cell's, or the left cell's for
+ * a vertical edge, where both record one, and otherwise whichever does (the twelfth Windows run). A border command
+ * records the edge on the cells it sets and clears the neighbour's record of it, so the later setting wins from
+ * either side (the eleventh run, case 7).
+ */
+export declare class CellBorders {
+    /** The line on the cell's top side. */
+    readonly top: BorderLine;
+    /** The line on the cell's bottom side. */
+    readonly bottom: BorderLine;
+    /** The line on the cell's left side. */
+    readonly left: BorderLine;
+    /** The line on the cell's right side. */
+    readonly right: BorderLine;
+    constructor(sides?: {
+        top?: BorderLine;
+        bottom?: BorderLine;
+        left?: BorderLine;
+        right?: BorderLine;
+    });
+    /** No line on any side. */
+    static readonly none: CellBorders;
+    /** These Borders with the sides given replaced. */
+    with(sides: {
+        top?: BorderLine;
+        bottom?: BorderLine;
+        left?: BorderLine;
+        right?: BorderLine;
+    }): CellBorders;
+    /** A value equal ones share, to key a map by. @internal */
+    get key(): string;
+    /** Whether `other` is the same Borders. */
+    equals(other: CellBorders): boolean;
+}
+
+/**
+ * A colour a Cell Format records (ADR-0071): `automatic`, or an RGB value. A colour picked from the theme part of a
+ * palette is recorded as its RGB value. Automatic is not a recorded colour: a Font's Automatic is the Ink.
+ */
+export declare class CellColour {
+    #private;
+    private constructor();
+    /** Automatic: no colour recorded, so what is painted is decided where it is painted. */
+    static readonly automatic: CellColour;
+    /** An RGB colour, as `0xRRGGBB`. Throws a RangeError for a value outside `0x000000` to `0xFFFFFF`. */
+    static fromRgb(rgb: number): CellColour;
+    /** An RGB colour, from its red, green and blue, each 0 to 255. */
+    static fromParts(red: number, green: number, blue: number): CellColour;
+    /** A colour written `#RRGGBB`, in either case, or `undefined` for any other text. @internal */
+    static fromHex(text: string | undefined): CellColour | undefined;
+    /** Whether the colour is Automatic. */
+    get isAutomatic(): boolean;
+    /** The RGB value, as `0xRRGGBB`. Throws for Automatic, which records no RGB value. */
+    get rgb(): number;
+    /** A value equal ones share, to key a map by. @internal */
+    get key(): number;
+    /** Whether `other` is the same colour. */
+    equals(other: CellColour): boolean;
+    /** `Automatic`, or the RGB value as `#RRGGBB`. */
+    toString(): string;
+}
+
+/**
+ * What a cell shows: its Value formatted by the cell's number format under the Sheet's culture, and where it sits.
+ * Whether it fits its column is the grid's to decide (ADR-0016): a number that does not fit becomes `####`, never a
+ * shorter number.
+ */
+export declare interface CellDisplay {
+    /** The formatted text; empty for a blank cell, and empty when `cannotShow` is set. */
+    readonly text: string;
+    /** The alignment resolved from the cell's setting: never `general`. */
+    readonly alignment: Exclude<HorizontalAlignment, 'general'>;
+    /** Whether the Value is a number (a date included). A number too wide for its column is shown as `####`; text is not (ADR-0016). */
+    readonly isNumber: boolean;
+    /**
+     * The number cannot be shown in its format at any width — a negative date, or a date after 31 December 9999 —
+     * or, from `Sheet.getDisplay` with a width, not in the width asked, and the cell shows `####`, as Excel's does.
+     */
+    readonly cannotShow: boolean;
+    /**
+     * The colour the Number Format names for the section that showed the Value, kept where the number cannot be
+     * shown; `undefined` where that section names none, or where no section showed it (ADR-0071, SH-40). It takes
+     * precedence over the cell's Font colour, as Excel's does.
+     */
+    readonly colour: NumberFormatColour | undefined;
+}
+
+/**
+ * A cell's Fill (CONTEXT.md; ADR-0071): the one solid colour behind its text, or `none`, where the Paper shows. No
+ * patterns and no gradients.
+ */
+export declare class CellFill {
+    /** The Fill's colour, always an RGB value; `undefined` for `none`. */
+    readonly colour: CellColour | undefined;
+    private constructor();
+    /** No Fill: the Paper shows. Recorded on a cell, it hides a Fill its row or column records. */
+    static readonly none: CellFill;
+    /**
+     * A solid Fill in `colour`. Throws for Automatic: Excel's Fill offers No Color and colours, never Automatic, so
+     * there is nothing an Automatic Fill would mean.
+     */
+    static solid(colour: CellColour): CellFill;
+    /** Whether this is `none`. */
+    get isNone(): boolean;
+    /** A value equal ones share, to key a map by. @internal */
+    get key(): number;
+    /** Whether `other` is the same Fill. */
+    equals(other: CellFill): boolean;
+}
+
+/**
+ * A cell's Font (CONTEXT.md; ADR-0071): the colour and emphasis of its text. Not its size or typeface: every row
+ * has one height, and one digit width decides what fits.
+ */
+export declare class CellFont {
+    /** The text's colour; Automatic is the Ink. */
+    readonly colour: CellColour;
+    /** Bold. */
+    readonly bold: boolean;
+    /** Italic. */
+    readonly italic: boolean;
+    /** A single underline. */
+    readonly underline: boolean;
+    /** Strikethrough. */
+    readonly strikethrough: boolean;
+    constructor(parts?: {
+        colour?: CellColour;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        strikethrough?: boolean;
+    });
+    /** What a cell's text shows where no level records a Font: Automatic, with no emphasis. */
+    static readonly default: CellFont;
+    /** This Font with the parts given replaced. */
+    with(parts: {
+        colour?: CellColour;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        strikethrough?: boolean;
+    }): CellFont;
+    /** A value equal ones share, to key a map by. @internal */
+    get key(): string;
+    /** Whether `other` is the same Font. */
+    equals(other: CellFont): boolean;
+}
+
+/**
+ * A cell's Cell Format as it shows (CONTEXT.md; ADR-0047, ADR-0071): each part from the level that records it, cell
+ * over row over column, and the part's default where no level does.
+ */
+export declare class CellFormat {
+    /** The Number Format. */
+    readonly numberFormat: NumberFormat;
+    /** The horizontal alignment. */
+    readonly alignment: HorizontalAlignment;
+    /** The Font. */
+    readonly font: CellFont;
+    /** The Fill. */
+    readonly fill: CellFill;
+    /** The Borders. */
+    readonly borders: CellBorders;
+    constructor(numberFormat: NumberFormat, alignment: HorizontalAlignment, font: CellFont, fill: CellFill, borders: CellBorders);
+    /** A value equal ones share, to key a map by. @internal */
+    get key(): string;
+    /** Whether `other` is the same Cell Format. */
+    equals(other: CellFormat): boolean;
+}
+
+/**
+ * What a formatting command sets on the Cell Format of ranges (ADR-0071): every part that is given, each Font
+ * emphasis on its own, and every other part left as each cell has it. Its `borders` are relative to each range it
+ * is set on, so several ranges each get their own outline, as in Excel.
+ */
+export declare class CellFormatChange implements CellFormatChangeParts {
+    #private;
+    /** {@inheritDoc CellFormatChangeParts.numberFormat} */
+    readonly numberFormat: NumberFormat | undefined;
+    /** {@inheritDoc CellFormatChangeParts.alignment} */
+    readonly alignment: HorizontalAlignment | undefined;
+    /** {@inheritDoc CellFormatChangeParts.fontColour} */
+    readonly fontColour: CellColour | undefined;
+    /** {@inheritDoc CellFormatChangeParts.bold} */
+    readonly bold: boolean | undefined;
+    /** {@inheritDoc CellFormatChangeParts.italic} */
+    readonly italic: boolean | undefined;
+    /** {@inheritDoc CellFormatChangeParts.underline} */
+    readonly underline: boolean | undefined;
+    /** {@inheritDoc CellFormatChangeParts.strikethrough} */
+    readonly strikethrough: boolean | undefined;
+    /** {@inheritDoc CellFormatChangeParts.fill} */
+    readonly fill: CellFill | undefined;
+    /** {@inheritDoc CellFormatChangeParts.borders} */
+    readonly borders: BorderChange | undefined;
+    constructor(parts: CellFormatChangeParts);
+    /** This change with its Borders replaced. @internal */
+    withBorders(borders: BorderChange): CellFormatChange;
+    /** Whether the change sets no part at all. */
+    get isEmpty(): boolean;
+    /** Whether the change sets any part of the Font. @internal */
+    get setsFont(): boolean;
+    /** Whether the change sets any side. @internal */
+    get setsBorders(): boolean;
+    /** Whether the change sets a part that `level` records. @internal */
+    touches(level: AxisFormat): boolean;
+    /** What a cell that showed `shown` shows once the change is set on it, at `place` in its range. @internal */
+    applyTo(shown: CellFormat, place: PlaceInRange): CellFormat;
+    /** `font` with the emphases and the colour the change sets. @internal */
+    applyToFont(font: CellFont): CellFont;
+}
+
+/** The parts a Cell Format change may set. */
+export declare interface CellFormatChangeParts {
+    /** The Number Format to set; `NumberFormat.general` sets General. */
+    readonly numberFormat?: NumberFormat | undefined;
+    /** The horizontal alignment to set; `general` sets General. */
+    readonly alignment?: HorizontalAlignment | undefined;
+    /** The Font colour to set; Automatic sets the Ink. */
+    readonly fontColour?: CellColour | undefined;
+    /** Bold set on, or off. */
+    readonly bold?: boolean | undefined;
+    /** Italic set on, or off. */
+    readonly italic?: boolean | undefined;
+    /** A single underline set on, or off. */
+    readonly underline?: boolean | undefined;
+    /** Strikethrough set on, or off. */
+    readonly strikethrough?: boolean | undefined;
+    /** The Fill to set; `CellFill.none` takes it away. */
+    readonly fill?: CellFill | undefined;
+    /** The Borders to set, relative to each range the change is set on. */
+    readonly borders?: BorderChange | undefined;
+}
+
+/** What a formatting command did, and what undoing it puts back. @internal */
+declare interface CellFormatOutcome {
+    readonly change: SheetChange;
+    readonly before: readonly AddressedState[];
+    readonly rowsBefore: ReadonlyMap<number, AxisFormat>;
+    readonly columnsBefore: ReadonlyMap<number, AxisFormat>;
+}
+
+/** What a change set on several ranges did: each range's outcome, in the order they were set. @internal */
+declare interface CellFormatsOutcome {
+    readonly change: SheetChange;
+    readonly parts: readonly CellFormatOutcome[];
+}
+
+/**
+ * A rectangle of cells on a Sheet, inclusive at both corners, held from its top-left corner (`first`) to its
+ * bottom-right one (`last`) whichever corners it was made from. Written `A1` for one cell and `A1:B2`
+ * otherwise.
+ */
+export declare class CellRange {
+    #private;
+    /** The rectangle spanned by two corners, in either order; one corner alone is that one cell. */
+    constructor(corner1: CellAddress, corner2?: CellAddress);
+    /** The top-left cell. */
+    get first(): CellAddress;
+    /** The bottom-right cell. */
+    get last(): CellAddress;
+    /** How many rows it spans. */
+    get rowCount(): number;
+    /** How many columns it spans. */
+    get columnCount(): number;
+    /** How many cells it holds. */
+    get cellCount(): number;
+    /** Whether `address` lies inside it. */
+    contains(address: CellAddress): boolean;
+    /** Whether it spans every row: whole columns, such as `B:D` (ADR-0047). */
+    get isWholeColumns(): boolean;
+    /** Whether it spans every column: whole rows, such as `2:4` (ADR-0047). */
+    get isWholeRows(): boolean;
+    /** Whether the two are the same rectangle. */
+    equals(other: CellRange): boolean;
+    /** Whole columns `first` to `last` (0 is `A`), as `A:A` names one. */
+    static wholeColumns(first: number, last: number): CellRange;
+    /** Whole rows `first` to `last` (0 is row `1`), as `1:1` names one. */
+    static wholeRows(first: number, last: number): CellRange;
+    /** Its cells in row-major order. */
+    cells(): IterableIterator<CellAddress>;
+    /** Parses `B7`, `B7:C9` (corners in either order, letters in either case), whole columns `B:D` or whole rows `2:4`; no `$`. Anything else is a `FormatError`. */
+    static parse(text: string): CellRange;
+    /** Parses as `parse` does, or `undefined`. */
+    static tryParse(text: string): CellRange | undefined;
+    /** `A1` for one cell, `A1:B2` otherwise. */
+    toString(): string;
+}
+
+/** What the evaluator reads cells through: the Values of one recalculation, blank as `undefined`. */
+declare interface CellReader {
+    read(address: CellAddress): Value | undefined;
+    /** The addresses inside `area` that are not blank, in row-major order. */
+    nonBlankIn(area: Area): Iterable<CellAddress>;
+    /**
+     * A Linked Table's column (ADR-0049): the column's Values, or `#NAME?` for a table never declared, `#REF!`
+     * for a column it does not have, and `#GETTING_DATA` before its first snapshot.
+     */
+    tableColumn(table: string, column: string): Operand;
+    /** Whether a Linked Table of this name is declared, the name read without regard to case (ADR-0049). */
+    isLinkedTable(name: string): boolean;
+    /** The Sheet Day `TODAY` answers (ADR-0121), or `undefined` while it is not known. */
+    readonly today: SheetDay | undefined;
+    /** The moment `NOW` answers, read once for the recalculation (ADR-0124); `undefined` while it is not known. */
+    readonly now: SheetMoment | undefined;
+    /**
+     * The cells of the Sheet a Reference's qualifier names, as this recalculation reads them: this Sheet's for
+     * no qualifier, another Sheet's of the Workbook for its name, without regard to case; `undefined` for a
+     * name no Sheet of the Workbook has, which is `#REF!` (ADR-0331).
+     */
+    resolve(sheetName: string | undefined): CellReader | undefined;
+    /**
+     * The cells of every Sheet a 3D Reference spans (ADR-0331 §7), in tab order; `undefined` when the Workbook
+     * has no Sheet of one of the names, which is `#NAME?`, as Excel's.
+     */
+    resolveSpan(first: string, last: string): readonly CellReader[] | undefined;
+    /**
+     * The draw of the `RAND` or `RANDBETWEEN` call at `place` in the Formula of `cell` (ADR-0180), from the
+     * Sheet Seed and the count of changes; `undefined` while the Sheet has no seed.
+     */
+    draw(cell: CellAddress, place: number): bigint | undefined;
+    /** `A1#` (ADR-0125): the array the Anchor at `anchor` spills, as this recalculation leaves it; `#REF!` when it does not spill. */
+    spill(anchor: CellAddress): Operand;
+    /**
+     * The Formula whose result a cell shows: its own, or for a cell of a Spill Range its Anchor's (ADR-0125);
+     * `undefined` for a constant or a blank.
+     */
+    formulaAt(address: CellAddress): Node_2 | undefined;
+}
+
+/**
+ * What one cell holds and shows, compared before and after an operation. The parts of its Cell Format are the
+ * cell's own; `undefined` takes the row's or the column's (ADR-0047, ADR-0071). @internal
+ */
+declare class CellState {
+    readonly entry: Entry | undefined;
+    readonly value: Value | undefined;
+    readonly numberFormat: NumberFormat | undefined;
+    readonly alignment: HorizontalAlignment | undefined;
+    readonly font: CellFont | undefined;
+    readonly fill: CellFill | undefined;
+    readonly borders: CellBorders | undefined;
+    constructor(entry: Entry | undefined, value: Value | undefined, numberFormat: NumberFormat | undefined, alignment: HorizontalAlignment | undefined, font: CellFont | undefined, fill: CellFill | undefined, borders: CellBorders | undefined);
+    static readonly blank: CellState;
+    /** The same cell as recorded: Entry and Cell Format, the Value left out. */
+    get recorded(): CellState;
+    /** This state with its Entry replaced. */
+    withEntry(entry: Entry | undefined): CellState;
+    /** This state with its Cell Format replaced, part by part. */
+    withFormat(format: {
+        numberFormat: NumberFormat | undefined;
+        alignment: HorizontalAlignment | undefined;
+        font: CellFont | undefined;
+        fill: CellFill | undefined;
+        borders: CellBorders | undefined;
+    }): CellState;
+    sameRecord(other: CellState): boolean;
+    /** Whether the two record the same Cell Format of their own. */
+    sameFormat(other: {
+        numberFormat: NumberFormat | undefined;
+        alignment: HorizontalAlignment | undefined;
+        font: CellFont | undefined;
+        fill: CellFill | undefined;
+        borders: CellBorders | undefined;
+    }): boolean;
+    /** The Cell Format the state shows, where it records nothing of a part, the part's default. */
+    get cellFormat(): CellFormat;
+}
+
+/** Excel's extent: how many columns a Sheet has, 16,384 (`A` to `XFD`). */
+export declare const columnCount = 16384;
+
+/**
+ * What completion offers at the caret, following Excel's triggers (ADR-0051, ADR-0058):
+ *
+ * - at the end of a name standing where an operand can start, the declared functions and `linkedTables`
+ *   beginning with it, without regard to case;
+ *
+ * - inside the brackets of `Table[`, the columns of that table beginning with the column typed so far, in the
+ *   table's order, and nothing else: not `@` or `#All`, which the grammar refuses (ADR-0047). The brackets are
+ *   a context of their own, so at an argument whose values are a fixed list they list the columns too;
+ *
+ * - at an argument that takes one of a fixed list of values (`DeclaredFunction.valuesOf`), those values, in
+ *   Excel's order, and nothing else. They are listed before anything is typed, and only while nothing of the
+ *   argument stands after the caret, white space included. A number lists the value it is alone (`0` lists
+ *   `0 - Exact match`) and nothing when it is no value (`4`); any other text lists every value.
+ *
+ * `undefined` anywhere else — after `=`, an operator, `(` or `,` at any other argument or inside a grouping
+ * parenthesis, inside text in quotes, a Reference, a number — and when nothing matches.
+ *
+ * @param text - The text being edited.
+ * @param caret - Where the caret stands in it. Throws a RangeError outside 0 to the text's length.
+ * @param linkedTables - The Linked Tables' names.
+ * @param columnsOf - The columns of the Linked Table a name names, found without regard to case, in the
+ * table's order; `undefined` for a name no table has. Left out, no table's columns are known, and nothing is
+ * listed after `Table[`.
+ */
+export declare function completeFormula(text: string, caret: number, linkedTables: Iterable<string>, columnsOf?: (name: string) => readonly string[] | undefined): FormulaCompletion | undefined;
+
+/** One candidate completion offers (ADR-0051, ADR-0058). */
+export declare interface CompletionCandidate {
+    /** What the list shows: the name as declared, or for an argument's value, Excel's text for it (`0 - Exact match`). */
+    readonly name: string;
+    /** What it names. */
+    readonly kind: CompletionKind;
+    /**
+     * What accepting it writes in place of what was typed: a function's name and its `(`, a table's name, a
+     * column's name with any character the grammar reads specially escaped by `'`, an argument's value (`0`).
+     */
+    readonly insertText: string;
+    /** One sentence for a function; `undefined` for the others. */
+    readonly description: string | undefined;
+}
+
+/**
+ * What a completion candidate names: a function of the declared set (`DeclaredFunction`), a Linked Table
+ * declared on the Workbook (ADR-0049), a column of the Linked Table named before `[` (ADR-0058), or one of the
+ * values an argument takes from a fixed list (ADR-0058).
+ */
+export declare type CompletionKind = 'function' | 'linkedTable' | 'linkedTableColumn' | 'argumentValue';
+
+/**
+ * A Value written as a Formula writes a constant of its kind (ADR-0058): text in double quotes, with any `"`
+ * in it doubled (`"R-4471"`); a number in the invariant form the engine writes a number constant in (`1250`,
+ * `-0.5`); a boolean as `TRUE` or `FALSE`. `undefined` for an Error Value: a lookup by one finds nothing, so
+ * nothing is written for it.
+ */
+export declare function constantText(value: Value): string | undefined;
+
+/**
+ * A Sheet's culture, read from its locale: a BCP 47 tag, or `"invariant"` for .NET's invariant culture
+ * (ADR-0370, section 10). Only the locales whose data the engine is held to are known; any other is
+ * refused by name, never read as some other culture's.
+ */
+export declare class Culture {
+    #private;
+    private constructor();
+    /** The invariant culture, which reads as .NET's `InvariantCulture` does. */
+    static readonly invariant: Culture;
+    /**
+     * The culture of a locale: `"invariant"`, or one of `en-US`, `en-GB`, `de-DE`, `ja-JP` and `fr-FR`, in
+     * any case. Another tag is refused with a `RangeError`: the engine holds no data for it that it has
+     * checked against .NET's.
+     */
+    static of(locale: string): Culture;
+    /** `CultureInfo.Name`: the BCP 47 tag; empty for the invariant culture, as .NET writes it in a Sheet Document. */
+    get name(): string;
+    /** The locale the culture was asked for by, `"invariant"` for the invariant culture. */
+    get locale(): string;
+    /** The culture's data: its separators, names and patterns, as .NET's culture records them. @internal */
+    get data(): CultureData;
+}
+
+/** The parts of a culture the engine reads: `CultureInfo`'s number and date formats, for one locale. */
+declare interface CultureData {
+    /** The locale's BCP 47 tag, as `CultureInfo.Name`; empty for the invariant culture. */
+    readonly name: string;
+    /** `TwoLetterISOLanguageName`: `en`, `de`, `ja`; `iv` for the invariant culture. */
+    readonly twoLetterLanguage: string;
+    readonly numberDecimalSeparator: string;
+    readonly numberGroupSeparator: string;
+    /** `NumberFormatInfo.NumberGroupSizes`: the digits in each group, the units' group first. */
+    readonly numberGroupSizes: readonly number[];
+    readonly negativeSign: string;
+    readonly currencySymbol: string;
+    /** `NumberFormatInfo.CurrencyPositivePattern`: 0 is `$n`, 1 `n$`, 2 `$ n`, 3 `n $`. */
+    readonly currencyPositivePattern: number;
+    /** `NumberFormatInfo.CurrencyNegativePattern`, 0 to 16. */
+    readonly currencyNegativePattern: number;
+    readonly currencyDecimalDigits: number;
+    readonly shortDatePattern: string;
+    readonly longTimePattern: string;
+    readonly shortTimePattern: string;
+    readonly dateSeparator: string;
+    /** The twelve months' names, January first. */
+    readonly monthNames: readonly string[];
+    readonly abbreviatedMonthNames: readonly string[];
+    /** The seven days' names, Sunday first. */
+    readonly dayNames: readonly string[];
+    readonly abbreviatedDayNames: readonly string[];
+}
+
+/**
+ * F4 (ADR-0051, 2026-09-29; as Excel does it, the seventeenth Windows run): the Reference at the caret cycled
+ * to its next form — `A1` → `$A$1` → `A$1` → `$A1` → `A1` — answered with the span of what was rewritten. The
+ * Reference at the caret is the one the caret is inside or touching, on either side; the two ends of a cell
+ * range are References of their own, so only the end at the caret cycles, from its own form. With a
+ * selection, every end it covers, overlaps or touches cycles, each to the next form of the first one. Whole
+ * columns and whole rows are one Reference of two forms (`A:A` ↔ `$A:$A`); a Sheet qualifier is kept, before
+ * the first end, and only the cell part cycles. The rewritten parts' column letters are written in upper
+ * case; every other character stays as it was typed. The span answered runs from the first Reference
+ * rewritten, after its Sheet qualifier, to the end of the last. `undefined` — nothing changes — for text that
+ * is not a Formula, and where no Reference is at the caret or in the selection.
+ *
+ * @param text - The text being edited.
+ * @param selectionStart - Where the selection starts, or the caret.
+ * @param selectionEnd - Where the selection ends; `selectionStart` for a caret. Throws a RangeError when the
+ * selection does not lie inside the text.
+ */
+export declare function cycleReference(text: string, selectionStart: number, selectionEnd: number): ReferenceCycle | undefined;
+
+/**
+ * A function of the declared set (ADR-0047): each gives Excel's result, and a name outside the set is `#NAME?`.
+ * What completion offers and what the argument hint shows (ADR-0051).
+ */
+export declare class DeclaredFunction {
+    #private;
+    /** The name in upper case, such as `SUM`. */
+    readonly name: string;
+    /** The argument list as Excel documents it, optional ones in brackets: `number1, [number2], ...`. */
+    readonly arguments: string;
+    /** One sentence saying what it returns. */
+    readonly description: string;
+    private constructor();
+    /** Every function the engine declares, in alphabetical order. */
+    static get all(): readonly DeclaredFunction[];
+    /** The signature a hint shows: `SUM(number1, [number2], ...)`. */
+    get signature(): string;
+    /** The declared function of that name, in any case, or `undefined` when the name is not declared. */
+    static find(name: string): DeclaredFunction | undefined;
+    /**
+     * The values argument `index` (from 0) takes when it takes one of a fixed list, in Excel's order and with
+     * Excel's texts, such as `XLOOKUP`'s `match_mode`: what completion lists there (ADR-0058). Empty for an
+     * argument that takes any value.
+     */
+    valuesOf(index: number): readonly ArgumentValue[];
+}
+
+/**
+ * Writes each Workbook Document raised as what changed since the one it wrote before: an object of three keys,
+ * `"number"`, counting the documents written from 1, `"workbook"`, a Workbook Document recording every part whole but
+ * the cells, and `"emptied"`, one entry per Sheet in the same order. A Sheet whose entry is `null` holds all its cells;
+ * any other holds only the cells that changed since the Sheet of its name was written, in the document numbered one
+ * less, and its entry lists the addresses of the cells emptied since. The first document, and the first after
+ * `forget`, are written whole.
+ */
+export declare class DocumentChanges {
+    #private;
+    /** Forgets what was written, as when its reader stops reading: the next document is written whole. */
+    forget(): void;
+    /** `document` as what changed since the document written before it, as JSON. */
+    write(document: WorkbookDocument): string;
+}
+
+/**
+ * What a user put into a cell: a constant or a Formula (CONTEXT.md). An Entry is what a Sheet Document records,
+ * and what the user sees again when editing the cell. A constant is held already parsed, never as the text that
+ * was typed (ADR-0048); a Formula is held in Excel's invariant syntax (ADR-0047). Immutable.
+ */
+export declare class Entry {
+    /** The constant, or `undefined` when this Entry is a Formula. */
+    readonly constant: Value | undefined;
+    /**
+     * The Formula in invariant syntax, beginning with `=`: the whitespace as it was typed where Excel keeps it
+     * (not at the end, nor before a `,`), and each token as the engine writes it (function names and References
+     * in upper case, `,` between arguments, `.` as the decimal separator) (ADR-0047); `undefined` when this Entry
+     * is a constant.
+     */
+    readonly formula: string | undefined;
+    /** The parsed Formula. @internal */
+    readonly parsed: Node_2 | undefined;
+    private constructor();
+    /** Whether this Entry is a Formula. */
+    get isFormula(): boolean;
+    /**
+     * The functions the Formula calls that are outside ExSheet's declared set, in the text's order, each once
+     * without regard to case: each gives `#NAME?` (ADR-0047). Empty for a constant, and for a Formula that calls
+     * only declared functions. A reader of another program's workbook lists them before the user meets them
+     * (ADR-0330 §4).
+     */
+    get undeclaredFunctions(): readonly string[];
+    /**
+     * The names the Formula reads that nothing in it binds — not a function's, not a `LET`'s, not a `LAMBDA`'s
+     * parameter, not `TRUE` or `FALSE` — in the text's order, each once without regard to case. ExSheet defines
+     * no names, so each gives `#NAME?`; in Excel each is a defined name, or an Excel Table's, where the workbook
+     * has one (ADR-0047, ADR-0330 §4). Empty for a constant.
+     */
+    get unboundNames(): readonly string[];
+    /**
+     * The Entry as a copy writes it `rows` down and `columns` across from where it stands, as Excel writes a
+     * copied Formula and a shared formula's cells (ADR-0048, ADR-0330 §4): each relative part of a Reference
+     * moves by that distance, each absolute part (`$`) stays, a whole column or row spans every row or column
+     * still, and a Reference moved off the Sheet is written `#REF!`. A constant, or a move of nothing, is this
+     * Entry. Negative distances move up and left.
+     */
+    movedBy(rows: number, columns: number): Entry;
+    /**
+     * The Entry with its References mapped (`rewriteReferences`); the same instance when nothing changed.
+     * @internal
+     */
+    static rewrite(entry: Entry, map: (reference: Reference) => Reference | undefined, requalify?: (sheet: string) => string | undefined): Entry;
+    /**
+     * The constant Entry of an Error Value written exactly as Excel writes one in a file, case and all (`#N/A`,
+     * `#DIV/0!`, `#SPILL!`), or `undefined` when the text is no Error Value a cell can hold: `#GETTING_DATA` and
+     * `#CIRC!` are not one, and nothing else is read as a Formula or a number. A reader of another program's
+     * workbook takes an error cell through it (ADR-0330 §4).
+     */
+    static fromErrorText(text: string): Entry | undefined;
+    /**
+     * A constant Entry. `#GETTING_DATA` and `#CIRC!` are states of a computation and cannot be one, and neither
+     * can the `#VALUE!` of a cell whose Formula ExSheet refuses, read from it: held as a constant it would be an
+     * Error Value a Formula can catch (ADR-0047; 2026-10-12, decided with the user: a refusal is never caught,
+     * anywhere). Throws a `RangeError` for one of those.
+     */
+    static fromValue(constant: Value): Entry;
+    /**
+     * A Formula Entry from its invariant text, which begins with `=`; `Entry.parse` reads the same text as the
+     * same Formula. Throws a `FormulaSyntaxError` when the Formula cannot be read. @internal
+     */
+    static fromFormula(formula: string): Entry;
+    /**
+     * Reads text as a user typed it into a cell: text beginning with `=` is a Formula in invariant syntax;
+     * anything else is a constant read under `culture` and recorded parsed (ADR-0048). Empty text is no Entry,
+     * and gives `undefined`. Throws a `FormulaSyntaxError` when the text is a Formula that cannot be read, or
+     * text with a leading `+` or `-` that Excel reads as a Formula using syntax the engine does not implement
+     * (`-B2 C2`) or nested past the limits the engine reads.
+     */
+    static parse(typed: string, culture: Culture): Entry | undefined;
+    /**
+     * Text typed with a leading `+` or `-` that is not a constant is the Formula it spells after an `=`, as
+     * Excel's cell editor reads it: `+A1` is `=+A1` and `-A1` is `=-A1` (observed with real keys). Text that does
+     * not read as a Formula that way stays text: `undefined`. Throws where Excel reads the text as a Formula whose
+     * syntax the engine does not implement (`-B2 C2`, TYPED-054; ADR-0047, third run), or one refused for its
+     * size alone: kept as text it would quietly be another Entry than the one typed. @internal
+     */
+    static signedFormula(typed: string): Entry | undefined;
+    /** Whether typed text would not be kept as text because of its leading sign: `signedFormula` reads it as a Formula, or refuses it. @internal */
+    static isSignedFormula(typed: string): boolean;
+    /** Two Entries are equal when they hold the same constant (exactly) or the same Formula text. */
+    equals(other: Entry | undefined): boolean;
+    /** Whether two Entries that may be absent are equal: both absent, or equal. */
+    static same(a: Entry | undefined, b: Entry | undefined): boolean;
+    /** The Formula text, or the constant's invariant diagnostic form. */
+    toString(): string;
+}
+
+/** An Entry set on a cell, or cleared (`undefined`). */
+export declare type EntryOfCell = readonly [CellAddress, Entry | undefined];
+
+declare class ErrorNode extends NodeBase {
+    readonly kind = "error";
+    readonly error: ErrorValue;
+    constructor(error: ErrorValue);
+}
+
+/**
+ * An Error Value, written as a cell shows it: Excel's set, `#GETTING_DATA` with the stricter meaning
+ * ADR-0049 gives it, and `#CIRC!`, the one Error Value ExSheet adds (ADR-0047). Error Values are data; they
+ * propagate through every Formula that uses them.
+ */
+export declare type ErrorValue = '#NULL!' | '#DIV/0!' | '#VALUE!' | '#REF!' | '#NAME?' | '#NUM!' | '#N/A' | '#GETTING_DATA' | '#CIRC!' | '#SPILL!' | '#CALC!' | '#FIELD!' | '#BLOCKED!' | '#CONNECT!' | '#UNKNOWN!';
+
+/**
+ * Evaluates a parsed Formula to a Value, as Excel does: IEEE doubles, a blank read as 0, Error Values carried
+ * through, left to right (ADR-0047).
+ */
+declare class Evaluator {
+    #private;
+    readonly culture: Culture;
+    readonly cells: CellReader;
+    /** The cell whose Formula is being evaluated, which `ROW()` and `COLUMN()` read; `undefined` for a Formula evaluated in no cell. */
+    self: CellAddress | undefined;
+    constructor(cells: CellReader, culture: Culture);
+    /**
+     * A Formula's result. It is never blank: a Formula that reads an empty cell shows 0. When the Formula's last
+     * operation is an addition or a subtraction whose result nearly cancels, the result is 0, as Excel's is.
+     */
+    evaluate(node: Node_2): Value;
+    /**
+     * A Formula's result as it spills (ADR-0125): a range or an array of more than one Value is returned as it
+     * is, for the Sheet to spill; anything else is one Value, never blank. A Formula a call or an operator
+     * refused is the refusal, `#VALUE!`, whatever the rest of it made of it.
+     */
+    evaluateResult(node: Node_2): Operand;
+    /**
+     * Refuses the Formula being evaluated: its result is the refusal, `#VALUE!` (`Value.refusal`), whatever the
+     * functions and operators around it make of the Error Value returned here, so `IFERROR` cannot catch it
+     * (ADR-0047; 2026-10-12, decided with the user: a refusal is never caught, anywhere).
+     */
+    refuse(): Operand;
+    /**
+     * Refuses the Formula being evaluated with `#NAME?` (`Value.refusedName`): a call of a function Excel has and
+     * ExSheet does not declare, or a declared Linked Table's bare name (2026-10-13, decided with the user). A
+     * refusal by `refuse` in the same Formula comes before it.
+     */
+    refuseName(): Operand;
+    /** `refuse`, for a function that answers with a Value: the Formula is refused, and the refusal is returned to stand where the Value would. */
+    refused(): Value;
+    /** An operand read whole, as an array: a range's cells, a Linked Table's column, or one Value. */
+    toArray(operand: Operand): ValueArray;
+    /**
+     * What a node evaluates to. Operators, parentheses and the `LET` names read are computed in a loop with a
+     * stack of their own (`#operator`), so the evaluator's recursion goes only through calls and `LET`s, which
+     * the parser bounds.
+     */
+    operand(node: Node_2): Operand;
+    /**
+     * An operand used as one Value: a single cell is read; a rectangle of more than one cell refuses the Formula
+     * (`refused`), because Excel 365 applies what wants one Value to each Value of it, which ExSheet does not yet
+     * (ADR-0125). An empty argument is blank. A 3D Reference is `#REF!` where it is written, and `#VALUE!` where a
+     * function handed it on, as Excel answered (ADR-0331 §7).
+     */
+    scalarOf(operand: Operand): Value | undefined;
+    /** The Values of a range that are not blank, in order: row-major for cells, top to bottom for a Linked Table's column. */
+    rangeValues(range: Operand): Generator<Value>;
+    scalar(node: Node_2): Value | undefined;
+    /**
+     * Excel's coercion of an operand to a number: a blank is 0, a boolean 1 or 0, text that reads as a typed
+     * number would under the Sheet's culture is that number, other text is `#VALUE!`.
+     */
+    toNumber(value: Value | undefined): NumberOrError;
+    /** Excel's coercion to text: a blank is empty, a number is written as Excel writes one into text under the Sheet's culture. */
+    toText(value: Value | undefined): string;
+}
+
+/** Which way a fill extends its source (ADR-0050): along one axis, away from the source. */
+export declare type FillDirection = 'down' | 'right' | 'up' | 'left';
+
+/** The formats a fill from whole columns (`columns`) or whole rows writes on its target's columns (rows), by index. @internal */
+declare interface FillLevels {
+    readonly columns: boolean;
+    readonly levels: readonly {
+        readonly index: number;
+        readonly level: AxisFormat;
+    }[];
+}
+
+/** What a fill writes, or why it is refused, and then nothing. @internal */
+declare interface FillPlan {
+    readonly refusal: SheetRefusal | undefined;
+    readonly states: readonly AddressedState[];
+    readonly levels: FillLevels | undefined;
+}
+
+/**
+ * A text the engine reads that is not in the form it reads: a cell address, a cell range or a number format
+ * code. It is a `TypeError`, so code that catches one still catches it.
+ */
+export declare class FormatError extends TypeError {
+    /** Refuses a text, saying why in `message`. */
+    constructor(message: string);
+}
+
+/** A Value as a format shows it: the text, whether it cannot be shown (`####`), and the section's colour. */
+declare interface FormattedValue {
+    readonly text: string;
+    readonly cannotShow: boolean;
+    readonly colour: NumberFormatColour | undefined;
+}
+
+/**
+ * The candidates for what is being typed at the caret (ADR-0051): accepting one replaces the `length` characters
+ * from `start` with its `insertText`.
+ */
+export declare interface FormulaCompletion {
+    /** Where what is being typed starts in the text: a name, a column after `[`, an argument's value. */
+    readonly start: number;
+    /** How long it is, including any part of it after the caret. */
+    readonly length: number;
+    /**
+     * The candidates, in the order to list them; never empty. Names are in alphabetical order, a table's columns
+     * in the table's order, and an argument's values in Excel's.
+     */
+    readonly candidates: readonly CompletionCandidate[];
+}
+
+/**
+ * The hint for the innermost function call whose argument list holds the caret, counting arguments by the
+ * commas at its own depth; grouping parentheses inside it belong to it, and text in quotes is one argument
+ * whatever it holds. `undefined` outside any call, or when that function is not declared. Throws a RangeError
+ * when the caret lies outside 0 to the text's length.
+ */
+export declare function formulaHintAt(text: string, caret: number): ArgumentHint | undefined;
+
+/**
+ * Whether a Reference can be written at the caret (ADR-0051's Point predicate): the Formula stands after its
+ * `=`, an operator (not `%`), `(` or `,`, with nothing after the caret that the Reference would run into.
+ * `undefined` when it cannot. Throws a RangeError when the caret lies outside 0 to the text's length.
+ */
+export declare function formulaPointAt(text: string, caret: number): PointSite | undefined;
+
+/**
+ * A Reference in the text of a Formula being edited (ADR-0057): where it is written, and what it names — cells on
+ * this Sheet, or a Linked Table's column. Exactly one of `cells` and `linkedColumn` is set.
+ */
+export declare interface FormulaReference {
+    /** Where it starts in the text, whose `=` is at 0. */
+    readonly start: number;
+    /** How many characters it spans, its Sheet qualifier included. */
+    readonly length: number;
+    /**
+     * The cells it names, held from their top-left corner however it was written (`B2:A1` names A1:B2), whole
+     * columns for `A:A` and whole rows for `1:1`; `undefined` for a structured reference.
+     */
+    readonly cells: CellRange | undefined;
+    /** The Linked Table column a structured reference reads; `undefined` for cells. */
+    readonly linkedColumn: LinkedTableColumn | undefined;
+}
+
+/**
+ * Every Reference in the text of a Formula being edited, in the order written (ADR-0057): its span, and the
+ * cells it names or, for a structured reference, the Linked Table column it reads. A Reference is what the
+ * formula grammar reads as one over the whole of an operand, as for F4. The text need not parse: an unfinished
+ * Formula (`=SUM(A1,`) is answered as far as it goes, and an unclosed string, quoted Sheet name or bracket
+ * hides only what follows it. Nothing inside a string is a Reference, nor is a function name (`LOG10(`), nor
+ * one qualified with another Sheet's name, which names no cells. A range typed as far as its colon
+ * (`=SUM(A1:`) answers its first corner, the colon left out. Text beginning with `+` or `-` is answered as a
+ * Formula is, as Excel colours it and ExSheet enters it (`=+A1`); other text is answered with nothing (the
+ * eighth Windows run, cases 24–26).
+ *
+ * @param text - The text being edited.
+ * @param sheetName - This Sheet's name: a Reference qualified with it, without regard to case, names this Sheet's cells.
+ */
+export declare function formulaReferences(text: string, sheetName: string): readonly FormulaReference[];
+
+/**
+ * A Formula that cannot be read. Excel refuses to accept such a Formula into a cell, and so does a Sheet:
+ * nothing is recorded and no Value changes.
+ */
+export declare class FormulaSyntaxError extends SyntaxError {
+    /** The Formula text as given. */
+    readonly formula: string;
+    /** The zero-based position in `formula` where reading stopped. */
+    readonly position: number;
+    /** Why, in words. */
+    readonly reason: string;
+    /**
+     * Whether the Formula is one Excel reads, using syntax the engine does not implement (the intersection of
+     * two References): typed without `=`, such text is refused by name rather than kept as text, since Excel
+     * makes it a Formula (ADR-0047, third run). @internal
+     */
+    readonly isUnimplemented: boolean;
+    /**
+     * Whether the Formula is refused for its size alone: functions nested past Excel's 64 levels, or a
+     * Formula nested past the engine's 256 levels (ADR-0047). Such text is still a Formula. @internal
+     */
+    readonly isBeyondLimit: boolean;
+    /** The refusal of `formula` at `position`, for `reason`. */
+    constructor(formula: string, position: number, reason: string, flags?: {
+        readonly isUnimplemented?: boolean;
+        readonly isBeyondLimit?: boolean;
+    });
+}
+
+/** One call of a function: its argument nodes, evaluated only when the function asks (so `IF` is lazy, as in Excel). */
+declare class FunctionCall {
+    #private;
+    readonly evaluator: Evaluator;
+    /** For `RAND` and `RANDBETWEEN`: which of the Formula's draws this call is, counted in its text (ADR-0180). */
+    readonly place: number;
+    /** What a 3D Reference is to the function called, by argument. */
+    readonly threeD: ((index: number, count: number) => ThreeDArgument) | undefined;
+    constructor(evaluator: Evaluator, args: readonly Node_2[], place?: number, threeD?: (index: number, count: number) => ThreeDArgument);
+    get count(): number;
+    /**
+     * Argument `index`, evaluated. One that holds a kept blank refuses the Formula (`Evaluator.refuse`): what
+     * this function reads it as is a reading no run has settled (ADR-0125).
+     */
+    operand(index: number): Operand;
+    /** Argument `index`, evaluated, a kept blank included (ADR-0125), for the functions that read it the one way. */
+    keepingBlanks(index: number): Operand;
+    /**
+     * Argument `index`, evaluated, for a function that reads one Value of it. A kept blank given as that one
+     * Value is read as a blank cell's (ADR-0125). An array that holds one refuses the Formula.
+     */
+    oneValue(index: number): Operand;
+    /** The argument's syntax, when a function must distinguish a literal Reference from a computed one. */
+    argument(index: number): Node_2;
+    /**
+     * The argument evaluated for its extent alone, as `ROWS` and `COLUMNS` read it: no Value of it is read, so a
+     * kept blank is counted in the extent, never refused.
+     */
+    measured(index: number): Operand;
+    /** Whether argument `index` was given and not left empty (`MissingNode.isEmpty`). */
+    has(index: number): boolean;
+}
+
+/** A function of the declared set (ADR-0047): its name, how many arguments it takes, and how it evaluates. */
+declare class FunctionDefinition {
+    #private;
+    readonly name: string;
+    readonly minimumArguments: number;
+    /** The most arguments it takes; Excel's limit of 255 for the open-ended ones. */
+    readonly maximumArguments: number;
+    /** The argument list as a hint shows it, such as `number1, [number2], ...`. */
+    readonly arguments: string;
+    readonly description: string;
+    readonly values: Readonly<Record<number, readonly ArgumentValue[]>>;
+    readonly inPairs: boolean;
+    readonly pairOffset: number;
+    readonly referenceOnly: {
+        readonly first: number;
+        readonly last: number;
+    } | undefined;
+    readonly returnsReference: boolean;
+    readonly threeD: ((index: number, count: number) => ThreeDArgument) | undefined;
+    constructor(name: string, minimum: number, maximum: number, args: string, description: string, invoke: (call: FunctionCall) => Operand, traits?: FunctionTraits);
+    invoke(call: FunctionCall): Operand;
+}
+
+declare class FunctionNode extends NodeBase {
+    #private;
+    readonly kind = "function";
+    /** The name: upper case for a declared function, as typed otherwise. */
+    readonly name: string;
+    readonly arguments: readonly Node_2[];
+    /** The declared function, or `undefined` for a name outside the set (`#NAME?`). */
+    readonly function: FunctionDefinition | undefined;
+    /**
+     * For `RAND` and `RANDBETWEEN`: which of the Formula's draws this call is, counted in the Formula's text
+     * from 0 (ADR-0180). Two calls are two draws; one call read twice, as a `LET` binding is, is one.
+     */
+    readonly place: number;
+    constructor(name: string, args: readonly Node_2[], definition: FunctionDefinition | undefined, place?: number);
+    references(): Generator<Reference>;
+    structuredReferences(): Generator<StructuredReferenceNode>;
+    calls(): Generator<FunctionNode>;
+    get depth(): number;
+}
+
+/** What a function's declaration says beyond its name, arguments and evaluation. */
+declare interface FunctionTraits {
+    /** The arguments that take one of a fixed list of values, by index, each list in Excel's order with Excel's texts (ADR-0058). */
+    readonly values?: Readonly<Record<number, readonly ArgumentValue[]>>;
+    /** Whether arguments after `pairOffset` come in pairs: an incomplete pair is refused on entry. */
+    readonly inPairs?: boolean;
+    /** Arguments before the repeating pairs: one for the result range of SUMIFS and its partners. */
+    readonly pairOffset?: number;
+    /** The arguments, by index from `first` to `last`, that Excel takes only as a Reference (ADR-0047). */
+    readonly referenceOnly?: {
+        readonly first: number;
+        readonly last: number;
+    };
+    /** Whether a call of it can give a Reference (`INDIRECT`, `OFFSET`, `INDEX`, `CHOOSE`, `IF` and their kin). */
+    readonly returnsReference?: boolean;
+    /** What a 3D Reference given as each argument is to it, by the argument's index and the count of arguments (ADR-0331 §7). */
+    readonly threeD?: (index: number, count: number) => ThreeDArgument;
+}
+
+/** A cell's horizontal alignment, settable per cell as in Excel (ADR-0046). `general` is Excel's default: numbers to the right, text to the left, booleans and Error Values centred. */
+export declare type HorizontalAlignment = 'general' | 'left' | 'center' | 'right';
+
+/**
+ * The intersection of two operands written with whitespace between them, one of them a name (`item one`):
+ * ExSheet defines no names, so it is `#NAME?` (ADR-0047). The parser refuses an intersection of two References.
+ */
+declare class IntersectionNode extends NodeBase {
+    #private;
+    readonly kind = "intersection";
+    readonly left: Node_2;
+    readonly right: Node_2;
+    constructor(left: Node_2, right: Node_2);
+    references(): Generator<Reference>;
+    calls(): Generator<FunctionNode>;
+    get depth(): number;
+}
+
+/** A JSON value as JsonDocument holds it: an object's properties in order, two of one name both kept, and a number's text. @internal */
+declare type JsonElement = {
+    readonly kind: 'object';
+    readonly properties: readonly (readonly [string, JsonElement])[];
+    readonly raw: string;
+} | {
+    readonly kind: 'array';
+    readonly items: readonly JsonElement[];
+    readonly raw: string;
+} | {
+    readonly kind: 'string';
+    readonly value: string;
+} | {
+    readonly kind: 'number';
+    readonly raw: string;
+} | {
+    readonly kind: 'true';
+} | {
+    readonly kind: 'false';
+} | {
+    readonly kind: 'null';
+};
+
+/** Writes JSON as Utf8JsonWriter does without indenting: properties in the order written, numbers as .NET writes a double. @internal */
+declare class JsonWriter {
+    #private;
+    startObject(name?: string): void;
+    endObject(): void;
+    startArray(name?: string): void;
+    endArray(): void;
+    string(name: string | undefined, value: string): void;
+    number(name: string | undefined, value: number): void;
+    boolean(name: string | undefined, value: boolean): void;
+    toString(): string;
+}
+
+/** One name a `LET` binds, and the value it is bound to (ADR-0181). */
+declare class LetBinding {
+    /** The name as typed; names compare without regard to case. */
+    readonly name: string;
+    /** The value's syntax, computed when the name is first read, and at most once (ADR-0181); set by the parser once read. */
+    value: Node_2;
+    constructor(name: string);
+}
+
+/**
+ * `LET(name1, value1, …, calculation)` (ADR-0181): names bound inside one Formula, each seen by the values
+ * after it and by the calculation. Its References, Linked Tables and calls are every one its text names, the
+ * bindings' whether they are read or not.
+ */
+declare class LetNode extends NodeBase {
+    #private;
+    readonly kind = "let";
+    readonly bindings: readonly LetBinding[];
+    readonly calculation: Node_2;
+    constructor(bindings: readonly LetBinding[], calculation: Node_2);
+    references(): Generator<Reference>;
+    structuredReferences(): Generator<StructuredReferenceNode>;
+    calls(): Generator<FunctionNode>;
+    get depth(): number;
+}
+
+/** A Linked Table as a Sheet knows it (CONTEXT.md, ADR-0049): its name, its columns, its key, and whether its data has arrived. */
+export declare class LinkedTable {
+    /** The name Formulas use, as declared; matched without regard to case. */
+    readonly name: string;
+    /** The column names, in order, as declared; matched without regard to case. */
+    readonly columns: readonly string[];
+    /** Whether no snapshot is held: none has arrived yet, or the last was refused because a key repeated in it. */
+    readonly isWaiting: boolean;
+    /** How many rows the current snapshot holds; 0 while waiting. */
+    readonly rowCount: number;
+    /** The key's columns, as declared there: one, several, or none for a table declared without a key (ADR-0058). */
+    readonly keyColumns: readonly string[];
+    constructor(name: string, columns: readonly string[], isWaiting: boolean, rows: number, keyColumns?: readonly string[]);
+    /** The key column when the key is one column; `undefined` for none, and for a key of several columns. */
+    get key(): string | undefined;
+}
+
+/**
+ * A Linked Table's column, as a structured reference names it (`Positions[PV]`): the key a Reference Outline is
+ * told by (ADR-0057). Two are equal when they name the same table and the same column without regard to case, as
+ * the Sheet finds a table and its column (ADR-0049).
+ */
+export declare class LinkedTableColumn {
+    /** The table's name, as written. */
+    readonly table: string;
+    /** The column's name, as written, with its `'` escapes read. */
+    readonly column: string;
+    /** The column of `table` named `column`. */
+    constructor(table: string, column: string);
+    /** Whether `other` names the same table and column, without regard to case. */
+    equals(other: LinkedTableColumn): boolean;
+    /** A string two equal columns share, for keying a `Map` as `equals` compares. */
+    get key(): string;
+}
+
+/** What a structural edit asks of the Sheet it rewrites: whether a Reference names a cell of that Sheet. */
+declare interface LocalReferences {
+    isLocal(reference: Reference): boolean;
+}
+
+/**
+ * Whether the lookup `lookupText` writes for `key` finds a row whose key is `candidate`: `XLOOKUP`'s exact
+ * match, which tells a number from text and text apart without regard to case, and never matches a blank
+ * (`undefined`) or an Error Value. A Pointing Scope finds the row a press was written for by it, wherever the
+ * grid that shows the table has sorted that row to (ADR-0058, "What is drawn").
+ *
+ * For a key of several columns, `key` and `candidate` are lists, one Value per key column: every part equal as
+ * the `=` operator finds it — of one kind, text without regard to case, numbers at Excel's fifteen digits —
+ * and none blank or an Error Value.
+ */
+export declare function lookupFinds(key: Value, candidate: Value | undefined): boolean;
+
+/**
+ * Whether the lookup `lookupText` writes for `key` finds a row whose key is `candidate`: `XLOOKUP`'s exact
+ * match, which tells a number from text and text apart without regard to case, and never matches a blank
+ * (`undefined`) or an Error Value. A Pointing Scope finds the row a press was written for by it, wherever the
+ * grid that shows the table has sorted that row to (ADR-0058, "What is drawn").
+ *
+ * For a key of several columns, `key` and `candidate` are lists, one Value per key column: every part equal as
+ * the `=` operator finds it — of one kind, text without regard to case, numbers at Excel's fifteen digits —
+ * and none blank or an Error Value.
+ */
+export declare function lookupFinds(keys: readonly Value[], candidates: readonly (Value | undefined)[]): boolean;
+
+/**
+ * What Point writes for a pressed cell of a Linked Table, through a Pointing Scope (ADR-0058): the lookup that
+ * reads the cell by its row's key, `XLOOKUP("R-4471", Positions[Id], Positions[PV])` — the key as a constant
+ * of its kind (`constantText`), then the key column and the pressed column as structured references
+ * (`structuredReferenceText`). It names no position, so the Formula reads the same row after the grid that
+ * showed it is sorted (ADR-0049, rule 2).
+ *
+ * For a key of several columns (ADR-0058, amended 2026-10-03), `keyColumns` and `keys` are lists, one Value
+ * per key column, and the lookup reads the cell by every part of its row's key:
+ * `XLOOKUP(1, (Cds[Entity]="ACME")*(Cds[Tenor]="5Y"), Cds[Spread])`. Each part is compared as the `=`
+ * operator compares, and the row whose parts all match is the one read.
+ *
+ * Throws a RangeError when a name is empty, the key has not one Value per key column, or a part of it is an
+ * Error Value, which no lookup finds.
+ */
+export declare function lookupText(table: string, keyColumn: string, key: Value, column: string): string;
+
+/**
+ * What Point writes for a pressed cell of a Linked Table, through a Pointing Scope (ADR-0058): the lookup that
+ * reads the cell by its row's key, `XLOOKUP("R-4471", Positions[Id], Positions[PV])` — the key as a constant
+ * of its kind (`constantText`), then the key column and the pressed column as structured references
+ * (`structuredReferenceText`). It names no position, so the Formula reads the same row after the grid that
+ * showed it is sorted (ADR-0049, rule 2).
+ *
+ * For a key of several columns (ADR-0058, amended 2026-10-03), `keyColumns` and `keys` are lists, one Value
+ * per key column, and the lookup reads the cell by every part of its row's key:
+ * `XLOOKUP(1, (Cds[Entity]="ACME")*(Cds[Tenor]="5Y"), Cds[Spread])`. Each part is compared as the `=`
+ * operator compares, and the row whose parts all match is the one read.
+ *
+ * Throws a RangeError when a name is empty, the key has not one Value per key column, or a part of it is an
+ * Error Value, which no lookup finds.
+ */
+export declare function lookupText(table: string, keyColumns: readonly string[], keys: readonly Value[], column: string): string;
+
+/** An argument left empty, as in `IF(A1,,1)`. */
+declare class MissingNode extends NodeBase {
+    readonly kind = "missing";
+    static readonly instance: MissingNode;
+    private constructor();
+    /**
+     * Whether an argument is left empty: written empty, or a `LET` name bound to a value left empty, as in
+     * `LET(x,,IF(A1,x,1))`. Such a name reads as the empty argument it is bound to would read in its place
+     * (ADR-0181; LET-107, run 17).
+     */
+    static isEmpty(argument: Node_2): boolean;
+}
+
+/**
+ * A name that is not a function call, a Reference or a boolean. ExSheet defines no names of its own, so it is
+ * `#NAME?` — unless a `LET` around it binds it (ADR-0181).
+ */
+declare class NameNode extends NodeBase {
+    #private;
+    readonly kind = "name";
+    readonly name: string;
+    /** Where the name stands in the Formula's text. */
+    readonly position: number;
+    /** The `LET` binding the name reads, as the text's scopes resolve it; `undefined` for none (`#NAME?`). */
+    readonly binding: LetBinding | undefined;
+    constructor(name: string, position: number, binding: LetBinding | undefined);
+    get depth(): number;
+}
+
+/** A node of a parsed Formula. */
+declare type Node_2 = NumberNode | TextNode | BooleanNode | ErrorNode | MissingNode | ReferenceNode | StructuredReferenceNode | NameNode | LetNode | IntersectionNode | FunctionNode | ParenthesesNode | UnaryNode | PercentNode | BinaryNode;
+
+/** What every node can say of itself, statically. */
+declare abstract class NodeBase {
+    /** Every Reference this node reads, statically: the dependency graph's edges. */
+    references(): Generator<Reference>;
+    /** Every structured reference this node reads, statically: a Linked Table's readers (ADR-0049). */
+    structuredReferences(): Generator<StructuredReferenceNode>;
+    /** Every function call this node makes, statically, its arguments' calls included: `TODAY`'s readers (ADR-0121). */
+    calls(): Generator<FunctionNode>;
+    /**
+     * How deep a walk of this node goes, counted in nodes, where a walk that reads an operator's chain loops
+     * along it rather than descending: a leaf is 1, a node one more than its deepest child, except a
+     * `BinaryNode`'s left operand, which stands at the operator's own depth; and a name a `LET` binds one more
+     * than its value. The parser refuses a Formula deeper than its `mostNesting`.
+     */
+    get depth(): number;
+}
+
+/**
+ * An Excel number format code, such as `#,##0.00`, `0%` or `yyyy-mm-dd` (ADR-0046). The code is written in
+ * Excel's stored, invariant form — `,` groups thousands and `.` marks decimals — and shown with the Sheet's
+ * culture's separators and month and day names. A code outside the subset the engine shows as Excel does —
+ * conditions, locales and elapsed time in brackets, fractions, fractional seconds, `*` fill, era codes,
+ * unquoted letters, a numbered colour — is refused rather than shown some other way.
+ */
+export declare class NumberFormat {
+    #private;
+    private constructor();
+    /** Excel's `General`: at most 15 significant digits, the culture's decimal separator. */
+    static readonly general: NumberFormat;
+    /** The code as given, such as `#,##0.00`. */
+    get code(): string;
+    /** Whether this is `General`. */
+    get isGeneral(): boolean;
+    /** Whether a number shows as a date or time: its first section holds date or time codes. */
+    get isDate(): boolean;
+    /** Whether a number shows as a date with no time of day. @internal */
+    get isDateOnly(): boolean;
+    /** Whether a number shows as a percentage: its first section holds `%`. */
+    get isPercent(): boolean;
+    /** Reads a format code; one outside the subset is refused with a `FormatError` that says why. */
+    static parse(code: string): NumberFormat;
+    /** Reads a format code, saying why when it cannot. */
+    static tryParse(given: string): NumberFormatReading;
+    /** Whether a number shows in Excel's General form: the format is General, or holds only a text section. @internal */
+    get showsNumbersAsGeneral(): boolean;
+    /**
+     * A Value as this format shows it in a column `characters` wide, each character charged one digit width
+     * (ADR-0047): a number in General is fitted to the width as Excel's General fits it, and any other number
+     * whose text is longer than the width cannot be shown (`####`, ADR-0016). Text, booleans and Error Values
+     * are never fitted. @internal
+     */
+    formatIn(value: Value, culture: Culture, characters: number): FormattedValue;
+    /**
+     * A Value as this format shows it under a culture, and the colour of the section that showed it
+     * (ADR-0071), `undefined` where it names none or no section showed the Value. @internal
+     */
+    format(value: Value, culture: Culture): FormattedValue;
+    /** Two formats are equal when their codes are (ordinal). */
+    equals(other: NumberFormat): boolean;
+    /** The code. */
+    toString(): string;
+    /**
+     * Excel's built-in short date, `m/d/yyyy` in the invariant codes: what a typed date records under every
+     * culture. It shows a date in the Sheet culture's own short-date pattern, as Excel's built-in format 14
+     * shows in the system's pattern. @internal
+     */
+    static readonly shortDate: NumberFormat;
+    /** Excel's built-in short date with a time (`m/d/yyyy h:mm`, format 22). @internal */
+    static readonly shortDateTime: NumberFormat;
+    /**
+     * Excel's built-in currency format under a culture: what Ctrl+Shift+$ records (ADR-0071). It is format 8,
+     * `$#,##0.00_);[Red]($#,##0.00)`, or format 6, `$#,##0_);[Red]($#,##0)`, where the culture's currency has
+     * no decimals; recorded in those codes, it shows in the culture's own currency.
+     */
+    static builtInCurrency(culture: Culture): NumberFormat;
+    /**
+     * The code as Format Cells' Custom box spells it under a culture, as Excel's local code does (ADR-0071).
+     * A built-in shown in the culture's own form is spelled in that form; a code of its own that spells such
+     * a built-in's code is spelled as it was typed, and any other code as it is.
+     */
+    localCode(culture: Culture): string;
+    /**
+     * Reads a code typed into Format Cells' Custom box under a culture (ADR-0071). A code is a built-in only
+     * when it spells that built-in's code under the culture (`localCode`), in any case; a code of its own that
+     * spells a built-in's invariant code is recorded with its separators escaped, `d\-mmm\-yy`.
+     */
+    static tryParseLocal(code: string, culture: Culture): NumberFormatReading;
+    /**
+     * This format as a Sheet Document opened under a culture holds it (ADR-0071, ticket 103): a code of its
+     * own that spells a localised built-in's code as the culture spells that built-in is the built-in. @internal
+     */
+    openedIn(culture: Culture): NumberFormat;
+    /**
+     * Reads a code a file stores as a format of its own, as `TEXT` reads a code (ADR-0120, ADR-0330): the
+     * invariant spelling, as written. A code that spells a built-in shown in the culture's own form is a code
+     * of its own, recorded with its separators escaped.
+     */
+    static tryParseAsWritten(code: string): NumberFormatReading;
+}
+
+/**
+ * A colour a Number Format names at the start of a section — `[Red]` and the seven others, in any case
+ * (ADR-0047). The text of a Value that section shows is painted in it, over the cell's Font colour (ADR-0071).
+ * A numbered colour (`[Color10]`) is not one of these: it is refused, as Excel refused it.
+ */
+export declare type NumberFormatColour = 'black' | 'blue' | 'cyan' | 'green' | 'magenta' | 'red' | 'white' | 'yellow';
+
+/** The RGB Excel paints a Number Format's colour in, as `0xRRGGBB`: Excel's legacy palette (ADR-0071). */
+export declare function numberFormatColourRgb(colour: NumberFormatColour): number;
+
+/** A format code read, or why it could not be. */
+export declare type NumberFormatReading = {
+    readonly format: NumberFormat;
+    readonly reason?: undefined;
+} | {
+    readonly format?: undefined;
+    readonly reason: string;
+};
+
+declare class NumberNode extends NodeBase {
+    readonly kind = "number";
+    readonly number: number;
+    constructor(number: number);
+}
+
+/** A number, or the Error Value met where one was wanted (C#'s `out ErrorValue? error`). */
+declare type NumberOrError = number | ErrorValue;
+
+/**
+ * What a node evaluates to before it is used: a Value (or blank), or a rectangle of cells that a function reads
+ * as a range. Excel's functions tell the two apart — `SUM` ignores text in a range but not text typed as an
+ * argument.
+ */
+declare class Operand {
+    readonly kind: OperandKind;
+    /** For `scalar`: the Value, or `undefined` for a blank. */
+    readonly scalar: Value | undefined;
+    readonly area: Area;
+    /** For `area`: the Sheet its cells are on, as the recalculation reads it (ADR-0331). */
+    readonly cells: CellReader | undefined;
+    /** For `threeD`: the Sheets of the span, in tab order (ADR-0331 §7). */
+    readonly sheets: readonly CellReader[] | undefined;
+    /**
+     * For `threeD`: whether a function handed it on (`IF`, `CHOOSE`, a `LET` name), rather than its Reference
+     * standing where it is read. Read as one Value, one written there is `#REF!` and one handed on `#VALUE!`.
+     */
+    readonly handedOn: boolean;
+    /** For `column`: the column's Values top to bottom, blank as `undefined`. */
+    readonly column: readonly (Value | undefined)[] | undefined;
+    /** For `array`: the computed Values. */
+    readonly array: ValueArray | undefined;
+    /** For `array`: whether the Values are a Spill Range's, read through `A1#` (ADR-0125): a Reference to cells in Excel. */
+    readonly isSpillRange: boolean;
+    /**
+     * Whether this holds a kept blank: a blank that `UNIQUE`, `SORT`, `SORTBY`, `FILTER` or `TRANSPOSE` kept
+     * from its array (ADR-0125), as one of its Values or as the one Value `INDEX` picked from it. A function
+     * reads such an operand only through `FunctionCall.keepingBlanks` or `FunctionCall.oneValue`; anywhere else
+     * the Formula is refused.
+     */
+    readonly keptBlank: boolean;
+    private constructor();
+    /** Whether this is a Reference of cells: a rectangle, or a Spill Range read through `A1#`. */
+    get isReference(): boolean;
+    /** Whether this is a range a function reads cell by cell: a rectangle of cells, a Linked Table's column, an array or a 3D Reference. */
+    get isRange(): boolean;
+    static readonly missing: Operand;
+    static readonly blank: Operand;
+    /** One Value. */
+    static of(value: Value): Operand;
+    /** One Error Value. */
+    static ofError(error: ErrorValue): Operand;
+    /** One Value, or a blank. */
+    static ofScalar(value: Value | undefined): Operand;
+    /** A rectangle of the Sheet `cells` reads (ADR-0331). */
+    static ofArea(area: Area, cells: CellReader): Operand;
+    /** A 3D Reference's rectangle on each Sheet of its span, `sheets` in tab order (ADR-0331 §7). */
+    static ofThreeD(area: Area, sheets: readonly CellReader[]): Operand;
+    /** This operand as a function hands it on (`handedOn`): a 3D Reference marked so, anything else as it is. */
+    handOn(): Operand;
+    /** Another rectangle of the same Sheet as this one, which must be a rectangle. */
+    sameSheet(area: Area): Operand;
+    /** A Linked Table's column (ADR-0049). */
+    static ofColumn(column: readonly (Value | undefined)[]): Operand;
+    /** A computed array; one of a single Value is that Value. */
+    static ofArray(array: ValueArray): Operand;
+    /** A Spill Range's Values, read through `A1#`: an array that is a Reference (`isSpillRange`). */
+    static ofSpillRange(array: ValueArray): Operand;
+    /** One Value as an array of one, for a function that takes an array and is given what a computation reduced to one Value (ADR-0125). */
+    static asArray(value: Value | undefined): Operand;
+    get isError(): boolean;
+    /** Whether this is a blank, or an array that holds one. */
+    get holdsBlank(): boolean;
+    /** This operand marked as holding a kept blank (`keptBlank`), when it holds a blank at all; as it is otherwise. */
+    withKeptBlank(): Operand;
+    /** The array of an `array` operand. */
+    arrayOf(): ValueArray;
+    /** The column of a `column` operand. */
+    columnOf(): readonly (Value | undefined)[];
+    /** The Sheet of an `area` operand. */
+    cellsOf(): CellReader;
+    /** The Sheets of a `threeD` operand. */
+    sheetsOf(): readonly CellReader[];
+}
+
+/**
+ * What an operand is: a Value (or a blank read from one cell); a rectangle of cells not yet read; an argument
+ * left empty; a Linked Table's column (ADR-0049); an array a Formula computed (ADR-0125); or a 3D Reference,
+ * one rectangle on each Sheet of a span (ADR-0331 §7).
+ */
+declare type OperandKind = 'scalar' | 'area' | 'missing' | 'column' | 'array' | 'threeD';
+
+declare class ParenthesesNode extends NodeBase {
+    #private;
+    readonly kind = "parentheses";
+    readonly inner: Node_2;
+    constructor(inner: Node_2);
+    references(): Generator<Reference>;
+    structuredReferences(): Generator<StructuredReferenceNode>;
+    calls(): Generator<FunctionNode>;
+    get depth(): number;
+}
+
+declare class PercentNode extends NodeBase {
+    #private;
+    readonly kind = "percent";
+    readonly operand: Node_2;
+    constructor(operand: Node_2);
+    references(): Generator<Reference>;
+    structuredReferences(): Generator<StructuredReferenceNode>;
+    calls(): Generator<FunctionNode>;
+    get depth(): number;
+}
+
+/** Where a cell lies in a range a change is set on: which of the range's outer edges its sides are. @internal */
+declare class PlaceInRange {
+    readonly firstRow: boolean;
+    readonly lastRow: boolean;
+    readonly firstColumn: boolean;
+    readonly lastColumn: boolean;
+    constructor(firstRow: boolean, lastRow: boolean, firstColumn: boolean, lastColumn: boolean);
+    /** A cell set on its own: all four sides are outer edges. */
+    static readonly alone: PlaceInRange;
+    /** A cell none of whose sides is an outer edge. */
+    static readonly inside: PlaceInRange;
+    /**
+     * Where `at` lies in `range`, as Excel places an outline: whole columns have no top or bottom edge, whole rows
+     * no right edge, and the whole Sheet no outer edge (the eleventh and twelfth Windows runs).
+     */
+    static of(range: CellRange, at: CellAddress): PlaceInRange;
+}
+
+/** Where Point mode writes a Reference: the `length` characters from `start` are replaced (none, for an insertion at the caret). */
+export declare interface PointSite {
+    /** Where the Reference goes in the text. */
+    readonly start: number;
+    /** How many characters it replaces. */
+    readonly length: number;
+}
+
+/**
+ * The lines drawn along a range's four outer edges, each line once per edge (`Sheet.getEdgeLines`): what Format
+ * Cells shows on a range's outline (ADR-0071; the fourteenth Windows run, case 13). Each list holds distinct lines,
+ * in the order met.
+ */
+export declare interface RangeEdgeLines {
+    /** The lines along the range's top edge. */
+    readonly top: readonly BorderLine[];
+    /** The lines along the range's bottom edge. */
+    readonly bottom: readonly BorderLine[];
+    /** The lines along the range's left edge. */
+    readonly left: readonly BorderLine[];
+    /** The lines along the range's right edge. */
+    readonly right: readonly BorderLine[];
+}
+
+/** A Cell Format change read from its JSON: each part it sets, by its name. */
+export declare function readCellFormatChange(json: string): CellFormatChange;
+
+/** A Linked Table's snapshot read from its JSON: rows of Values, a blank as `null`. */
+export declare function readLinkedRows(json: string): (Value | undefined)[][];
+
+/**
+ * A Sheet Edit read from its JSON: an object of one key, the factory, and its arguments as the factory takes them
+ * (ADR-0370 section 1). The factory checks them as it checks any caller's; what is not an edit so written is refused
+ * with a `FormatError`.
+ */
+export declare function readSheetEdit(json: string): SheetEdit;
+
+/**
+ * A Reference as a Formula records it. The target positions are held absolutely, with a flag per axis saying
+ * whether the text wrote `$`; a relative Reference shifts when its Formula is copied (ADR-0048), and every form
+ * survives a structural edit by rewriting the positions. The Sheet qualifier is recorded as written.
+ */
+declare class Reference implements ReferenceParts {
+    #private;
+    readonly sheetName: string | undefined;
+    readonly shape: ReferenceShape;
+    readonly row1: number;
+    readonly column1: number;
+    readonly row2: number;
+    readonly column2: number;
+    readonly row1Absolute: boolean;
+    readonly column1Absolute: boolean;
+    readonly row2Absolute: boolean;
+    readonly column2Absolute: boolean;
+    readonly spilled: boolean;
+    readonly lastSheetName: string | undefined;
+    constructor(parts: ReferenceParts);
+    /** One cell's Reference. */
+    static cell(sheet: string | undefined, atRow: number, atColumn: number, rowAbsolute: boolean, columnAbsolute: boolean): Reference;
+    /** This Reference with some of its parts changed. */
+    with(changes: Partial<ReferenceParts>): Reference;
+    /** A C# record's equality: every part the same. */
+    equals(other: Reference): boolean;
+    /** Whether this is a 3D Reference, reading one range on every Sheet of a span (ADR-0331 §7). */
+    get isThreeD(): boolean;
+    /** The rectangle the Reference covers. */
+    get area(): Area;
+    /**
+     * A Reference to a rectangle, in the shape Excel writes it: one spanning every column is whole rows
+     * (`A1:XFD3` is `1:3`, `A:XFD` is `$1:$1048576`), one spanning every row is whole columns (`A1:A1048576`
+     * is `A:A`), and any other is an area. The axis a whole form drops is held absolute, as Excel holds it.
+     */
+    static rectangle(sheet: string | undefined, row1: number, column1: number, row2: number, column2: number, row1Absolute: boolean, column1Absolute: boolean, row2Absolute: boolean, column2Absolute: boolean): Reference;
+    /** The Reference as Excel writes it: a rectangle in the shape `rectangle` gives it. */
+    write(): string;
+}
+
+/**
+ * What F4 makes of the text being edited (ADR-0051): the new text, and the span in it of what was rewritten,
+ * which a grid selects or collapses to a caret at its end as the edit stands.
+ */
+export declare interface ReferenceCycle {
+    /** The text with the Reference or References cycled. */
+    readonly text: string;
+    /** Where what was rewritten starts in `text`: at its first column or row part, after any Sheet qualifier before it. */
+    readonly selectionStart: number;
+    /** Where it ends. */
+    readonly selectionEnd: number;
+}
+
+declare class ReferenceNode extends NodeBase {
+    readonly kind = "reference";
+    readonly reference: Reference;
+    constructor(reference: Reference);
+    references(): Generator<Reference>;
+}
+
+/** The parts of a Reference, for making one with some of them changed (a C# record's `with`). */
+declare interface ReferenceParts {
+    readonly sheetName: string | undefined;
+    readonly shape: ReferenceShape;
+    readonly row1: number;
+    readonly column1: number;
+    readonly row2: number;
+    readonly column2: number;
+    readonly row1Absolute: boolean;
+    readonly column1Absolute: boolean;
+    readonly row2Absolute: boolean;
+    readonly column2Absolute: boolean;
+    /** `A1#`: the Spill Range of the Formula in this one cell (ADR-0125). */
+    readonly spilled: boolean;
+    /** For a 3D Reference (`Sheet1:Sheet3!B2`, ADR-0331 §7): the name of the Sheet that ends the span, as written. */
+    readonly lastSheetName: string | undefined;
+}
+
+/** What a Reference names: one cell, a rectangle, whole columns or whole rows. */
+declare type ReferenceShape = 'cell' | 'area' | 'columns' | 'rows';
+
+/**
+ * The Reference Point mode writes for a pointed range: `B7` for one cell, `B7:C9` from its top-left
+ * otherwise. With `sheet`, the name of the Sheet the range was pointed at when that is not the one the
+ * Formula is typed on (ADR-0331 §5), the range qualified with it, quoted where a Reference must quote it —
+ * `Sheet2!B7`, `'Q1 Sales'!B7:C9`. Throws a RangeError when `sheet` is empty.
+ */
+export declare function referenceText(range: CellRange, sheet?: string): string;
+
+/**
+ * Thrown when a snapshot of a Linked Table declared with a key is refused because a key repeats in it (ADR-0049,
+ * 2026-09-30): two rows whose keys `XLOOKUP`'s exact match cannot tell apart. Case does not tell keys apart, and a
+ * blank key is not a key. The snapshot is not taken, and the previous one is not kept: the table waits again, and
+ * every Formula that reads it shows `#GETTING_DATA` until a snapshot in which no key repeats is pushed.
+ */
+export declare class RepeatedKeyError extends Error {
+    /** The table's name, as declared. */
+    readonly table: string;
+    /** The key column's name, as declared; for a key of several columns, their names joined by `, `. */
+    readonly keyColumn: string;
+    /** The key that repeats, as the first of its rows holds it; for a key of several columns, its first column's Value. */
+    readonly key: Value;
+    /** The key's columns, as declared (ADR-0058, amended 2026-10-03). */
+    readonly keyColumns: readonly string[];
+    /** The key that repeats, one Value per key column, as the first of its rows holds it. */
+    readonly keys: readonly Value[];
+    /** The first row of the snapshot, from 0, that holds the key. */
+    readonly firstRow: number;
+    /** The row of the snapshot, from 0, that holds it again. */
+    readonly secondRow: number;
+    /** What the table's going back to waiting changed: its readers, and what depends on them, now show `#GETTING_DATA`. */
+    readonly change: SheetChange;
+    /** The key as the second of its rows holds it, one Value per key column, which the message names. @internal */
+    readonly repeats: readonly Value[];
+    /** @internal */
+    constructor(table: string, keyColumns: readonly string[], keys: readonly Value[], firstRow: number, repeats: readonly Value[], secondRow: number, change: SheetChange);
+}
+
+/** A Formula rewritten on a Sheet, as it was before. @internal */
+declare interface RewrittenEntry {
+    readonly sheet: Sheet;
+    readonly address: CellAddress;
+    readonly entry: Entry;
+}
+
+/** Excel's extent: how many rows a Sheet has, 1,048,576. */
+export declare const rowCount = 1048576;
+
+/** The serial of a calendar day, or `undefined` outside 1900-01-01 … 9999-12-31. 1900-02-29 is 60. */
+export declare function serialFromDate(year: number, month: number, day: number): number | undefined;
+
+/**
+ * The grid of cells ExSheet holds: Excel's extent, held sparsely. Not shared between threads of work: one Sheet is
+ * changed and read by one caller at a time. A Sheet belongs to a Workbook (ADR-0331); change it through its
+ * Workbook's `do`.
+ */
+export declare class Sheet {
+    #private;
+    /** Excel's row count: 1,048,576 (ADR-0046). */
+    static readonly rowCount = 1048576;
+    /** Excel's column count: 16,384, `A` to `XFD` (ADR-0046). */
+    static readonly columnCount = 16384;
+    /** The name a new Sheet has, as Excel's first sheet does (ADR-0046). */
+    static readonly defaultName = "Sheet1";
+    /** The longest name a Sheet can have: 31 characters, as in Excel. */
+    static readonly maximumNameLength = 31;
+    /** The widest a column can be, in characters: 255, Excel's limit. */
+    static readonly maxColumnWidth = 255;
+    /** Excel's default column width, in characters: 8.43 (ADR-0047). */
+    static readonly defaultColumnWidth = 8.43;
+    /** A number unique to this Sheet in this process, which keys its cells across a Workbook. @internal */
+    readonly id: number;
+    /** The Workbook the Sheet belongs to: one of its own, of this Sheet alone, for a Sheet created on its own (ADR-0331). */
+    readonly workbook: Workbook;
+    /** The Sheet's declared culture (ADR-0048). Formulas are in invariant syntax whatever it is (ADR-0047). */
+    readonly culture: Culture;
+    /** How many passes the last recalculation made (ADR-0124). Layer 1 reads it. @internal */
+    recalculationPasses: number;
+    /** A Sheet named `name` in `workbook`, under its culture (ADR-0331). Throws for a name a Sheet cannot have. @internal */
+    constructor(workbook: Workbook, name: string);
+    /** Records what a document records on this Sheet's columns, rows and cells besides Entries. @internal */
+    openFormats(document: SheetDocument): void;
+    /** Takes a document's Entries, computing every Value again. Opening is no change (ADR-0180). @internal */
+    openEntries(document: SheetDocument): void;
+    /** The Sheet as a Sheet Document declaring `tables` (ADR-0046, ADR-0047, ADR-0048, ADR-0049, ADR-0071). @internal */
+    toDocumentParts(): {
+        cells: SheetDocumentCell[];
+        columns: SheetDocumentAxisFormat[];
+        rows: SheetDocumentAxisFormat[];
+        columnWidths: SheetDocumentColumnWidth[];
+    };
+    /** The cells of this Sheet whose Formula gives an array, spilled or `#SPILL!`: what a new size lays out again (ADR-0460). @internal */
+    get anchors(): SheetCell[];
+    /** The addresses of every cell holding an Entry, in row-major order. */
+    get entryAddresses(): CellAddress[];
+    /**
+     * The text `number` would show in the cell at `address`, under the cell's Number Format and the Sheet's culture
+     * (ADR-0130). `undefined` where the format cannot show it.
+     */
+    formatAs(address: CellAddress, number: number): string | undefined;
+    /** The addresses of every cell holding a Value — an Entry's, or an array's spilled into it (ADR-0125) — in no particular order. */
+    get valueAddresses(): CellAddress[];
+    /** The cell's Value, or `undefined` for a blank cell. */
+    getValue(address: CellAddress): Value | undefined;
+    /** The cell's Entry, or `undefined` for a blank cell. */
+    getEntry(address: CellAddress): Entry | undefined;
+    /** The text the Cell Editor opens with: the Formula for a Formula, the constant written under the Sheet's culture otherwise. Empty for a blank cell. */
+    getEntryText(address: CellAddress): string;
+    /**
+     * What the cell shows: its Value formatted by its number format under the Sheet's culture, with its alignment
+     * resolved (ADR-0046/0047). Without a width, at no particular width — a number in General in full, at fifteen
+     * significant digits. With a width, in a column `width` characters wide (ADR-0047, ADR-0016): General is fitted
+     * as Excel's General fits it, and a number in any other format whose text is longer cannot be shown.
+     */
+    getDisplay(address: CellAddress, width?: number): CellDisplay;
+    /** Takes text as the user typed it into a cell, read under the Sheet's culture, and recalculates. @internal */
+    enter(address: CellAddress, typed: string): SheetChange;
+    /**
+     * Takes several typed texts as one change, with one recalculation. If any text is a Formula that cannot be
+     * read, nothing changes. `pasted`: the texts were pasted from another program, and a text beginning with `=`
+     * that cannot be read as a Formula is taken as text (ADR-0048). @internal
+     */
+    enterMany(typed: Iterable<TypedCell>, pasted?: boolean): SheetChange;
+    /** Excel's Ctrl+Enter (ADR-0050 item 5): `typed` read as entered in `enteredAt`, written into every cell of `cells`. @internal */
+    enterInto(cells: readonly CellAddress[], enteredAt: CellAddress, typed: string): SheetChange;
+    /** Sets or clears one cell's Entry, and recalculates. @internal */
+    setEntry(address: CellAddress, entry: Entry | undefined): SheetChange;
+    /** Sets or clears several cells' Entries as one change, with one recalculation. A later pair for the same cell wins. @internal */
+    setEntries(entries: Iterable<EntryOfCell>): SheetChange;
+    /** The addresses inside `area` that hold something, in no particular order. @internal */
+    cellsIn(area: Area): Generator<CellAddress>;
+    /** The cell held at `address`. @internal */
+    cellAt(address: CellAddress): Cell | undefined;
+    /** The Formula whose result a cell shows: its own, or for a cell of a Spill Range its Anchor's (ADR-0125). @internal */
+    formulaShownAt(address: CellAddress): Node_2 | undefined;
+    /** Every held cell's state, keyed by address. @internal */
+    snapshot(): Map<number, CellState>;
+    /** States about to be written whole, each part kept only where it differs from what its row or column gives it. @internal */
+    settle(states: Iterable<AddressedState>): AddressedState[];
+    /** The change between `before` and now, address by address. @internal */
+    diff(before: ReadonlyMap<number, CellState>, recalculated: Iterable<CellAddress>, shownBefore?: ReadonlyMap<number, CellFormat>): SheetChange;
+    /** Forgets and rebuilds the dependency graph from every Formula held. @internal */
+    rebuildDependencies(): void;
+    /** The cell's Cell Format as it shows: each part the cell's own, else its row's, else its column's, else the part's default (ADR-0047, ADR-0071, SH-38). */
+    getCellFormat(address: CellAddress): CellFormat;
+    /** The cell's Number Format, as it takes effect: cell over row over column, else General (ADR-0047). */
+    getNumberFormat(address: CellAddress): NumberFormat;
+    /** The cell's horizontal alignment setting, as it takes effect: cell over row over column (ADR-0047). */
+    getAlignment(address: CellAddress): HorizontalAlignment;
+    /** The cell's Font, as it takes effect: cell over row over column (ADR-0071, SH-38). */
+    getFont(address: CellAddress): CellFont;
+    /** The cell's Fill, as it takes effect: cell over row over column (ADR-0071, SH-38). */
+    getFill(address: CellAddress): CellFill;
+    /**
+     * The line on each of the cell's four sides as it shows, which is the line on the edge it shares with the cell
+     * beside it, read the same from either cell (ADR-0071; the twelfth Windows run): the upper cell's, or the left
+     * cell's, where both record one; where only one does, that one.
+     */
+    getBorders(address: CellAddress): CellBorders;
+    /** The Number Format recorded on the whole row, or `undefined` when none is (ADR-0047). */
+    getRowNumberFormat(row: number): NumberFormat | undefined;
+    /** The Number Format recorded on the whole column, or `undefined` when none is (ADR-0047). */
+    getColumnNumberFormat(column: number): NumberFormat | undefined;
+    /** The alignment recorded on the whole row, or `undefined` when none is (ADR-0047). */
+    getRowAlignment(row: number): HorizontalAlignment | undefined;
+    /** The alignment recorded on the whole column, or `undefined` when none is (ADR-0047). */
+    getColumnAlignment(column: number): HorizontalAlignment | undefined;
+    /** Sets the Number Format of cells; `undefined` is General. No Value changes. @internal */
+    setNumberFormatOf(addresses: Iterable<CellAddress>, format: NumberFormat | undefined): SheetChange;
+    /** Sets the Number Format of a range; `undefined` is General. Whole columns and whole rows record one entry each (ADR-0047). @internal */
+    setNumberFormat(range: CellRange, format: NumberFormat | undefined): SheetChange;
+    /** Sets the horizontal alignment of cells. No Value changes. @internal */
+    setAlignmentOf(addresses: Iterable<CellAddress>, alignment: HorizontalAlignment): SheetChange;
+    /** Sets the horizontal alignment of a range, recording whole columns and whole rows as one entry each. @internal */
+    setAlignment(range: CellRange, alignment: HorizontalAlignment): SheetChange;
+    /** Sets the parts `change` names on several ranges at once (ADR-0046, ADR-0071). @internal */
+    setCellFormat(ranges: Iterable<CellRange>, change: CellFormatChange): SheetChange;
+    /** The ranges a change is set on, checked with the change. Throws for no range, a change that sets nothing, or an alignment that is not one. @internal */
+    static checkCellFormat(ranges: Iterable<CellRange>, change: CellFormatChange): CellRange[];
+    /** Sets `change` on each range in turn, as one change. @internal */
+    applyCellFormats(ranges: readonly CellRange[], change: CellFormatChange): CellFormatsOutcome;
+    /** Undoes a change set on several ranges, each range's part in the reverse of the order it was set. @internal */
+    undoCellFormats(outcome: CellFormatsOutcome): SheetChange;
+    /**
+     * A change set on a range, as Excel sets it (ADR-0047, ADR-0071): on the range, and, across each outer edge
+     * the change sets, on the cells beside it, whose record of that edge it clears. Undoing it puts back both. @internal
+     */
+    applyCellFormat(range: CellRange, change: CellFormatChange): CellFormatOutcome;
+    /** Undoes a formatting command: the row and column levels, then the cells, exactly as they were. @internal */
+    undoCellFormat(outcome: CellFormatOutcome): SheetChange;
+    /**
+     * The Cell Formats the cells of `range` show, each once (ADR-0071): what Format Cells reads to show a part that
+     * differs across the Selection. Its Borders are each cell's own four sides. Read from what the Sheet records,
+     * never cell by cell (principle 5).
+     */
+    getCellFormats(range: CellRange): CellFormat[];
+    /** The lines drawn along each outer edge of `range`, each once per edge (ADR-0071; the fourteenth Windows run, case 13). */
+    getEdgeLines(range: CellRange): RangeEdgeLines;
+    /** The Formula cells, on any Sheet of the Workbook, that read `address` of this Sheet directly. @internal */
+    dependentsInWorkbook(address: CellAddress): Generator<SheetCell>;
+    /** The Sheet a Reference's qualifier names: this one for none or its own name, another of the Workbook for its name; `undefined` for a name no Sheet has. @internal */
+    sheetNamed(qualifier: string | undefined): Sheet | undefined;
+    /**
+     * One recalculation: what `changed` reaches and every volatile Formula of the Workbook, the moment read once
+     * (ADR-0124); then the spills laid out, Sheet by Sheet, and what their layout changed recalculated with every
+     * volatile Formula, until a layout changes nothing. What it changed on each Sheet it reached; `initiator`'s
+     * always. @internal
+     */
+    static recalculateWorkbook(workbook: Workbook, changed: SheetCellSet, initiator: Sheet, initiatorRows: Set<number>): Map<Sheet, SheetChange>;
+    /** The Anchor whose array gives a cell its Value, or `undefined` for a cell no array spills into (ADR-0125). */
+    spilledFrom(address: CellAddress): CellAddress | undefined;
+    /** The moment read at the start of the recalculation under way. @internal */
+    get moment(): SheetMoment | undefined;
+    /** Whether any Formula of this Sheet calls a volatile function. @internal */
+    get hasVolatileFormulas(): boolean;
+    /** One recalculation of `cells`, on any Sheet of the Workbook, started from this Sheet, with every volatile Formula: what it changed here. @internal */
+    recalculateCells(cells: SheetCellSet): SheetChange;
+    /** The Formula cells of this Sheet that call `TODAY`. @internal */
+    get todayReaders(): SheetCell[];
+    /** The Formula cells of this Sheet that call `RAND` or `RANDBETWEEN`. @internal */
+    get randomReaders(): SheetCell[];
+    /** Does `operation` as one operation of the Workbook. @internal */
+    asOneChange<T>(operation: () => T): T;
+    /** Counts a change of the Workbook. @internal */
+    countChange(): void;
+    /** The draw for the call at `place` in the Formula of `cell`, or `undefined` without a seed (ADR-0180). @internal */
+    draw(cell: CellAddress, place: number): bigint | undefined;
+    /**
+     * Completion for the Formula being typed (ADR-0051, ADR-0058): the declared functions and the Workbook's Linked
+     * Tables whose names begin with the name at the caret, the columns of one of its tables after `Table[`, and an
+     * argument's values where it takes one of a fixed list (`completeFormula`).
+     */
+    complete(text: string, caret: number): FormulaCompletion | undefined;
+    /**
+     * The References in the Formula being edited (ADR-0057), a qualifier naming this Sheet by its name as it is now
+     * (`formulaReferences`). A structured reference is kept only when its Linked Table is declared with that
+     * column: one naming a table or a column that is not names nothing, as a Reference to another Sheet does not. A
+     * declared table still waiting for its data is kept.
+     */
+    references(text: string): readonly FormulaReference[];
+    /** The Linked Tables declared on the Sheet's Workbook, in the order they were declared. @internal */
+    get linkedTables(): LinkedTable[];
+    /** Declares a Linked Table on the Workbook: what it changed on this Sheet. @internal */
+    declareLinkedTable(name: string, columns: readonly string[], key?: readonly string[]): SheetChange;
+    /** Records a Linked Table's declaration on the Workbook, checked already. @internal */
+    declare(name: string, columns: readonly string[], key: readonly string[], order?: number): void;
+    /** Why a name and columns cannot be declared as a Linked Table, or `undefined` when they can. @internal */
+    static whyNotALinkedTable(name: string, columns: readonly string[]): string | undefined;
+    /** Why a key cannot be declared with a table's columns, or `undefined` when it can (ADR-0049, 2026-09-30). @internal */
+    static whyNotAKey(name: string, columns: readonly string[], key: readonly string[]): string | undefined;
+    /** The declarations, as a Sheet Document records them (ADR-0049). @internal */
+    get tableDeclarations(): SheetDocumentTable[];
+    /** Takes a Linked Table's snapshot: what it changed on this Sheet. @internal */
+    pushLinkedTable(name: string, rows: Iterable<readonly (Value | undefined)[]>): SheetChange;
+    /** What a structured reference reads (ADR-0049). @internal */
+    tableColumn(name: string, column: string): Operand;
+    /** Whether a Linked Table's column holds a refusal (ADR-0047; 2026-10-12, decided with the user). @internal */
+    columnHoldsRefusal(name: string, column: string): boolean;
+    /**
+     * The Sheet's name (ADR-0046). A Reference qualified with it (`Sheet1!A1`, matched without regard to case) names
+     * this Sheet's cells.
+     */
+    get name(): string;
+    /** Gives the Sheet a new name; the Workbook checks it and rewrites the References that name the Sheet. @internal */
+    setName(name: string): void;
+    /**
+     * Why `name` is not a name a Sheet can have, as Excel decides one — 1 to 31 characters, none of `: \ / ? * [ ]`,
+     * not beginning or ending with `'`, and not `History` — or `undefined` when it is one.
+     */
+    static whyNotAName(name: string): string | undefined;
+    /** Whether `name` is a name a Sheet can have (`whyNotAName`). */
+    static isValidName(name: string): boolean;
+    /** `name`, checked: throws a RangeError for a name a Sheet cannot have. @internal */
+    static checkName(name: string): string;
+    /** Renames the Sheet (ADR-0046) through its Workbook. @internal */
+    rename(name: string): SheetChange;
+    /** Whether `qualifier`, a Reference's Sheet name, names this Sheet: no qualifier, or this Sheet's name without regard to case. @internal */
+    isThisSheet(qualifier: string | undefined): boolean;
+    /** Whether `qualifier` names the Sheet called `name`: no qualifier, or that name without regard to case. @internal */
+    static names(qualifier: string | undefined, name: string): boolean;
+    /** Whether a Reference names this Sheet's cells alone: a 3D Reference never does (ADR-0331 §7). @internal */
+    isLocal(reference: Reference): boolean;
+    /** A typed Formula with every qualifier that names this Sheet written in the Sheet's own name (TEXT-083). The same instance when nothing changes. @internal */
+    inOwnName(entry: Entry): Entry;
+    /** A typed Formula with every structured reference to a declared Linked Table written in the declared case (ticket 180). The same instance when nothing changes. @internal */
+    inDeclaredCase(entry: Entry): Entry;
+    /** Renames the Sheet through its Workbook, which rewrites every Sheet's References to it (ADR-0331). @internal */
+    applyRename(name: string): SheetRename;
+    /** Undoes a rename. @internal */
+    undoRename(rename: SheetRename): SheetChange;
+    /** Every Formula cell and its Entry. @internal */
+    formulaEntries(): {
+        address: CellAddress;
+        entry: Entry;
+    }[];
+    /** The Formula cells with a qualified Reference. @internal */
+    qualifiedFormulas(): CellAddress[];
+    /** Puts an Entry in a cell without recalculating or registering it. @internal */
+    replaceEntry(address: CellAddress, entry: Entry): void;
+    /** Forgets every Reference this Sheet's Formulas make to another Sheet, on the Sheets they name. @internal */
+    unregisterAllRemote(): void;
+    /** The width recorded on the column, and its kind, or `undefined` when none is (ADR-0046). Throws for a column outside `A` to `XFD`. */
+    getColumnWidth(column: number): SheetColumnWidth | undefined;
+    /** Sets the width of every column `columns` spans, as a width the user set; `undefined` puts them back at the default width (ADR-0046). @internal */
+    setColumnWidth(columns: CellRange, width: number | undefined): SheetChange;
+    /** Sets the width of every column `columns` spans, as a width an entry widened them to (ADR-0046, 2026-09-28). @internal */
+    setAutomaticColumnWidth(columns: CellRange, width: number): SheetChange;
+    /** `width`, checked: more than 0 and at most `maxColumnWidth`, or `undefined`. @internal */
+    static checkColumnWidth(width: number | undefined): number | undefined;
+    /** A width set on columns, and the widths before it for undoing it. @internal */
+    applyColumnWidth(columns: CellRange, width: SheetColumnWidth | undefined): {
+        change: SheetChange;
+        before: Map<number, SheetColumnWidth>;
+    };
+    /** Puts every column's width back to `widths`, and says which columns that changed. @internal */
+    restoreColumnWidths(widths: ReadonlyMap<number, SheetColumnWidth>): SheetChange;
+    /** A copy of the widths recorded now. @internal */
+    columnWidthsNow(): Map<number, SheetColumnWidth>;
+    /**
+     * The width, in characters, that the number typed into this cell needs, for widening a column whose width the
+     * user has not set when the number is typed, as Excel does (ADR-0047); `undefined` when what the cell holds never
+     * widens a column.
+     */
+    getWidthOnEntry(address: CellAddress): number | undefined;
+    /** The cells in `range` that hold an Entry, in no particular order (ADR-0071, case 17). */
+    entryAddressesIn(range: CellRange): CellAddress[];
+    /** Inserts `count` rows at `row` (ADR-0046/0047). @internal */
+    insertRows(row: number, count?: number): SheetChange;
+    /** Deletes `count` rows from `row` (ADR-0047). @internal */
+    deleteRows(row: number, count?: number): SheetChange;
+    /** Inserts columns, as `insertRows` does rows (ADR-0046, ADR-0047, ADR-0071). @internal */
+    insertColumns(column: number, count?: number): SheetChange;
+    /** Deletes columns, as `deleteRows` does rows (ADR-0046). @internal */
+    deleteColumns(column: number, count?: number): SheetChange;
+    /** Whether `edit` would be refused, and why; nothing changes either way. @internal */
+    checkStructural(edit: StructuralEdit): SheetRefusal | undefined;
+    /** An insertion or deletion. `formatInserted`: whether inserted rows or columns take the Cell Format of the one before them (ADR-0046). @internal */
+    restructure(edit: StructuralEdit, formatInserted?: boolean): StructuralOutcome;
+    /** Does `edit` as one operation and returns the step that undoes it (ADR-0048). @internal */
+    do(edit: SheetEdit): SheetStep;
+    /** Whether `do` would refuse `edit` as the Sheet stands, and why. @internal */
+    check(edit: SheetEdit): SheetRefusal | undefined;
+    /** What each of `addresses` records: Entry and Cell Format, never a Value. @internal */
+    record(addresses: Iterable<CellAddress>): AddressedState[];
+    /** Puts cells back to what they recorded, as one change with one recalculation. A changed top or bottom side names the row across it too. @internal */
+    restore(states: Iterable<AddressedState>): SheetChange;
+    /** Undoes a structural edit: the inverse edit, then the rewritten Formulas and the dropped cells put back. @internal */
+    unrestructure(edit: StructuralEdit, outcome: StructuralOutcome): SheetChange;
+    /** Copies a rectangle (ADR-0048): its Entries for a paste inside ExSheet, and its Values for anywhere else. A rectangle holding a `#GETTING_DATA` Value is refused whole (ADR-0049). */
+    copy(range: CellRange): SheetCopy;
+    /** The states a block pasted at `origin` writes; a blank cell of the block clears the cell it lands on. @internal */
+    static place(block: SheetBlock, origin: CellAddress): Generator<AddressedState>;
+    /** A block of `rows` × `columns` at `origin` that would run past the Sheet's edge: Excel's, or the Workbook's size (ADR-0460). @internal */
+    offSheet(origin: CellAddress, rows: number, columns: number): SheetRefusal | undefined;
+    /** The first of `ranges` that runs past the Workbook's size, refused by name (ADR-0460). @internal */
+    pastSize(ranges: Iterable<CellRange>): SheetRefusal | undefined;
+    /** What a Fill Intent writes, as Excel fills (ADR-0050, item 5), or why it is refused. `copyOnly`: Excel's fill keys. @internal */
+    planFill(source: CellRange, target: CellRange, direction: FillDirection, copyOnly?: boolean): FillPlan;
+    /** Does a fill planned with levels: the target columns' (rows') formats first, then each cell's state settled against them, as one step. @internal */
+    doFillWithLevels(plan: FillPlan): SheetStep;
+}
+
+/** Which of a Sheet's two axes an insertion or deletion runs along. */
+declare type SheetAxis = 'rows' | 'columns';
+
+/**
+ * A rectangle of cells copied inside ExSheet: each cell's Entry and the Cell Format it showed, as they were at the
+ * copy, and where they came from (ADR-0048, ADR-0071). Pasting it writes the Entries with their relative References
+ * shifted by the distance pasted, as Excel does, and the Cell Formats with them. Immutable.
+ */
+export declare class SheetBlock {
+    #private;
+    /** The range the block was copied from. */
+    readonly source: CellRange;
+    /** @internal */
+    constructor(source: CellRange, cells: readonly CellState[]);
+    /** How many rows the block holds. */
+    get rowCount(): number;
+    /** How many columns the block holds. */
+    get columnCount(): number;
+    /** The Entry at a position inside the block, as copied; `undefined` for a blank cell. */
+    entryAt(row: number, column: number): Entry | undefined;
+    /** The Cell Format at a position inside the block: what the cell showed at the copy, its Borders its own four sides. */
+    cellFormatAt(row: number, column: number): CellFormat;
+    /** The cell at a position inside the block, as copied: its Entry and the Cell Format it showed. @internal */
+    at(row: number, column: number): CellState;
+}
+
+/** A cell of one Sheet of a Workbook. @internal */
+declare class SheetCell {
+    readonly sheet: Sheet;
+    readonly address: CellAddress;
+    constructor(sheet: Sheet, address: CellAddress);
+    /** A key two SheetCells naming the same cell share. */
+    get key(): string;
+}
+
+/** A set of SheetCells, compared by the cell they name, in the order first added. @internal */
+declare class SheetCellSet implements Iterable<SheetCell> {
+    #private;
+    constructor(cells?: Iterable<SheetCell>);
+    /** Adds `cell`; whether it was not there yet. */
+    add(cell: SheetCell): boolean;
+    addAll(cells: Iterable<SheetCell>): void;
+    has(cell: SheetCell): boolean;
+    delete(cell: SheetCell): boolean;
+    get size(): number;
+    [Symbol.iterator](): Iterator<SheetCell>;
+}
+
+/**
+ * What one change to a Sheet did, reported after its recalculation has completed. Every Value it names is already
+ * published, and all of them come from that one recalculation (ADR-0047).
+ */
+export declare class SheetChange {
+    /** The cells whose Value changed (a cell becoming blank included), in row-major order. */
+    readonly valueChanges: readonly CellAddress[];
+    /** The Formula cells this change recomputed, in row-major order: the changed cells and the cells that depend on them, and no other (ADR-0047). */
+    readonly recalculated: readonly CellAddress[];
+    /** The rows whose painted content may differ — a Value, an Entry or a cell's formatting changed — in ascending order, each once. */
+    readonly rows: readonly number[];
+    /** The columns whose recorded width changed (ADR-0046) — set, cleared back to the default, or moved by an insertion or deletion — in ascending order, each once. */
+    readonly columns: readonly number[];
+    /**
+     * Whether the Cell Format shown in rows `rows` does not name may have changed (ADR-0071): after a whole row's or
+     * column's Cell Format set, cleared or moved, or rows or columns inserted or deleted. A component that paints a
+     * Cell Format then reads again what each row it paints shows.
+     */
+    readonly reformatsUnnamedRows: boolean;
+    /** @internal */
+    constructor(valueChanges: readonly CellAddress[], recalculated: readonly CellAddress[], rows: readonly number[], columns?: readonly number[], reformatsUnnamedRows?: boolean);
+    /** A change that changed nothing. @internal */
+    static readonly none: SheetChange;
+    /** This change, also reporting that it may have reformatted rows it does not name. @internal */
+    reformattingUnnamedRows(): SheetChange;
+    /** Several changes made as one, such as the parts of one step. @internal */
+    static merge(changes: Iterable<SheetChange>): SheetChange;
+}
+
+/**
+ * A width recorded on a column (ADR-0046): how wide it is, in characters of the default font (Excel's unit,
+ * ADR-0047), and what recorded it. Both kinds are marked custom, as Excel's file marks a column an entry widened as
+ * well as one the user set (`customWidth`; CW-018, CW-027..029).
+ */
+export declare class SheetColumnWidth {
+    /** How wide the column is, in characters of the default font. */
+    readonly width: number;
+    /** What recorded it. */
+    readonly kind: SheetColumnWidthKind;
+    constructor(width: number, kind: SheetColumnWidthKind);
+    /** Whether Excel's file marks the width custom (`customWidth`): every recorded width is, whichever its kind. */
+    get isCustom(): boolean;
+    /** Whether the user set the width, so an entry never widens the column. */
+    get isSetByUser(): boolean;
+    /** Whether `other` is the same width, recorded the same way. */
+    equals(other: SheetColumnWidth): boolean;
+}
+
+/**
+ * What recorded a column's width (ADR-0046, 2026-09-28; SH-26). `widenedByEntry`: an entry that widened the column,
+ * which a longer entry widens again (CW-028, third run). `setByUser`: a drag, a size to fit, a command, or a column
+ * inserted to the right of a recorded width; an entry never widens it.
+ */
+export declare type SheetColumnWidthKind = 'widenedByEntry' | 'setByUser';
+
+/**
+ * A copy of a rectangle of cells, or its refusal (ADR-0048, ADR-0049): the Entries for a paste inside ExSheet, and
+ * the Values for anywhere else in the two flavours ExGrid puts on the clipboard (ADR-0005).
+ */
+export declare class SheetCopy {
+    /** Why the copy is refused — a cell in it is `#GETTING_DATA` (ADR-0049) — or `undefined`. A refused copy carries nothing. */
+    readonly refusal: SheetRefusal | undefined;
+    /** The Entries, for a paste inside ExSheet. */
+    readonly block: SheetBlock | undefined;
+    /** The `text/plain` flavour: each Value as the cell shows it, tab-separated, one line per row ending in CR LF. */
+    readonly text: string | undefined;
+    /** The `text/html` flavour: a table of the unformatted Values, invariant, in Excel's markup. */
+    readonly html: string | undefined;
+    /** @internal */
+    constructor(refusal: SheetRefusal | undefined, block: SheetBlock | undefined, text: string | undefined, html: string | undefined);
+    /** Whether the copy is refused (`refusal`). */
+    get isRefused(): boolean;
+}
+
+/** A calendar day: the Sheet Day `TODAY` answers (ADR-0121). */
+export declare interface SheetDay {
+    /** The year, 1900 to 9999. */
+    readonly year: number;
+    /** 1 to 12. */
+    readonly month: number;
+    /** 1 to 31. */
+    readonly day: number;
+}
+
+/**
+ * The serialisable form of a Sheet (CONTEXT.md, ADR-0048): its culture, its name (ADR-0046), the Linked Tables declared
+ * on it — names, columns and keys, never rows (ADR-0049) — its Entries, the Cell Formats recorded on its columns, rows
+ * and cells (ADR-0047, ADR-0071) and the widths set on its columns (ADR-0046), and never a Value: opening one computes
+ * every Value again. The Consumer persists it; ExSheet never does.
+ *
+ * The document is a format with a version. A reader meeting a version it does not know refuses the document rather
+ * than guess at it (ADR-0048); so does a reader meeting anything it does not understand. This engine writes version 9
+ * and reads versions 1 to 9, each as the C# engine's remarks on SheetDocument describe.
+ */
+export declare class SheetDocument {
+    /** The version this engine writes. */
+    static readonly currentVersion = 9;
+    /** The oldest version this engine reads. */
+    static readonly oldestReadableVersion = 1;
+    /** The cells that hold something, in row-major order. */
+    readonly cells: readonly SheetDocumentCell[];
+    /** The Cell Formats recorded on whole columns, in column order. Empty for a document read from version 1 or 2. */
+    readonly columns: readonly SheetDocumentAxisFormat[];
+    /** The Cell Formats recorded on whole rows, in row order. Empty for a document read from version 1 or 2. */
+    readonly rows: readonly SheetDocumentAxisFormat[];
+    /** The widths recorded on columns, in column order. Empty for a document read from versions 1 to 3. */
+    readonly columnWidths: readonly SheetDocumentColumnWidth[];
+    /** The name of the Sheet's declared culture, such as `en-US`; empty for the invariant culture, as .NET names it. */
+    readonly culture: string;
+    /** The Sheet's name (ADR-0046); `Sheet1` for a document read from version 1. */
+    readonly name: string;
+    /** The Linked Tables declared on the Sheet, in the order they were declared (ADR-0049). */
+    readonly linkedTables: readonly SheetDocumentTable[];
+    /** @internal */
+    constructor(culture: string, name: string, linkedTables: readonly SheetDocumentTable[], cells: readonly SheetDocumentCell[], layout?: SheetDocumentLayout);
+    /**
+     * A Sheet Document built from its parts, as a reader of another format builds one (ADR-0330): a Sheet named `name`
+     * holding `cells` under `culture`, declaring no Linked Table. The cells are recorded in row-major order whatever
+     * order they come in. Throws a RangeError for a culture this engine does not know, a name a Sheet cannot have, or a
+     * cell that appears twice. Nothing is guessed.
+     */
+    static of(culture: Culture, name: string, cells: Iterable<SheetDocumentCell>, layout?: SheetDocumentLayout): SheetDocument;
+    /** The format version the document is written in: `currentVersion`, whatever version it was read from. */
+    get version(): number;
+    /** Writes the document as JSON, as the C# engine writes it. */
+    toJson(): string;
+    /** The Linked Tables' declarations, as a Sheet Document and a Workbook Document both write them; nothing for none. @internal */
+    static writeTables(json: JsonWriter, tables: readonly SheetDocumentTable[]): void;
+    /** What a Sheet records of its own: the formats on its columns and rows, its column widths and its cells. @internal */
+    writeBody(json: JsonWriter): void;
+    /** A cell as the document records it, as JSON: two cells record the same exactly when their texts are equal. @internal */
+    static cellJson(cell: SheetDocumentCell): string;
+    /**
+     * Reads a document written by `toJson`, or by the C# engine. Throws a SheetDocumentError when the version is not
+     * one this engine reads (`oldestReadableVersion` to `currentVersion`), or the document holds anything its version
+     * does not define. Nothing is guessed.
+     */
+    static fromJson(text: string): SheetDocument;
+    /**
+     * Reads one Sheet of a Workbook Document (ADR-0331): its name and what it records of its own, in the current
+     * version, under the Workbook's culture. The version, the culture and the Linked Tables are the Workbook's, and are
+     * refused here. @internal
+     */
+    static readSheetOfWorkbook(element: JsonElement, culture: string): SheetDocument;
+    /** The Linked Tables' declarations, as a Sheet Document and a Workbook Document both read them; none declared twice. @internal */
+    static readTables(array: JsonElement, version: number): SheetDocumentTable[];
+    /** The culture a document names: `''` is the invariant culture, as .NET names it. Throws a SheetDocumentError for one this engine does not know. @internal */
+    static resolveCulture(name: string): Culture;
+}
+
+/**
+ * A Cell Format recorded on whole columns or whole rows, as a Sheet Document records it: one entry for a run of
+ * adjacent columns (rows) recorded alike, never one per cell (ADR-0047, ADR-0071).
+ */
+export declare class SheetDocumentAxisFormat {
+    /** The first column (row) of the run, from 0. */
+    readonly first: number;
+    /** The last column (row) of the run. */
+    readonly last: number;
+    /** The Number Format the run records; `undefined` for none. */
+    readonly numberFormat: NumberFormat | undefined;
+    /** The horizontal alignment the run records; `undefined` for none. */
+    readonly alignment: HorizontalAlignment | undefined;
+    /** The Font the run records; `undefined` for none. */
+    readonly font: CellFont | undefined;
+    /** The Fill the run records; `undefined` for none. */
+    readonly fill: CellFill | undefined;
+    /** The Borders the run records; `undefined` for none. */
+    readonly borders: CellBorders | undefined;
+    constructor(first: number, last: number, numberFormat: NumberFormat | undefined, alignment: HorizontalAlignment | undefined, font: CellFont | undefined, fill: CellFill | undefined, borders: CellBorders | undefined);
+    /** The level each row (column) of the run records. @internal */
+    get level(): AxisFormat;
+}
+
+/** One cell of a Sheet Document: where it is, its Entry and its own Cell Format. Never its Value (ADR-0048). */
+export declare class SheetDocumentCell {
+    /** Where the cell is. */
+    readonly address: CellAddress;
+    /** What the user put into it; `undefined` for a cell that holds only a Cell Format. */
+    readonly entry: Entry | undefined;
+    /** The Number Format the cell records itself; `undefined` when it takes its row's or column's (ADR-0047). */
+    readonly numberFormat: NumberFormat | undefined;
+    /** The horizontal alignment the cell records itself; `undefined` when it takes its row's or column's. */
+    readonly alignment: HorizontalAlignment | undefined;
+    /** The Font the cell records itself; `undefined` when it takes its row's or column's (ADR-0071). */
+    readonly font: CellFont | undefined;
+    /** The Fill the cell records itself; `undefined` when it takes its row's or column's (ADR-0071). */
+    readonly fill: CellFill | undefined;
+    /** The Borders the cell records itself; `undefined` for none (ADR-0071). */
+    readonly borders: CellBorders | undefined;
+    constructor(address: CellAddress, entry: Entry | undefined, numberFormat?: NumberFormat, alignment?: HorizontalAlignment, font?: CellFont, fill?: CellFill, borders?: CellBorders);
+}
+
+/** A width recorded on columns, as a Sheet Document records it: one entry for a run of adjacent columns of one width and one kind (ADR-0046). */
+export declare class SheetDocumentColumnWidth {
+    /** The first column of the run, from 0. */
+    readonly first: number;
+    /** The last column of the run. */
+    readonly last: number;
+    /** The width, in characters of the default font (Excel's unit, ADR-0047). */
+    readonly width: number;
+    /** What recorded the width. */
+    readonly kind: SheetColumnWidthKind;
+    constructor(first: number, last: number, width: number, kind?: SheetColumnWidthKind);
+    /** Whether Excel's file marks the width custom: every recorded width is. */
+    get isCustom(): boolean;
+}
+
+/** A Sheet Document that cannot be read: an unknown version, or anything the version does not define (ADR-0048). */
+export declare class SheetDocumentError extends Error {
+    /** The version the document declared, when that is why it was refused. */
+    readonly documentVersion: number | undefined;
+    constructor(message: string, options?: {
+        cause?: unknown;
+        documentVersion?: number;
+    });
+}
+
+/** The parts of a Sheet Document besides its culture, name, Linked Tables and cells. */
+export declare interface SheetDocumentLayout {
+    /** The Cell Formats recorded on whole columns, in column order, adjacent columns recorded alike as one run (ADR-0047, ADR-0071). */
+    readonly columns?: readonly SheetDocumentAxisFormat[];
+    /** The Cell Formats recorded on whole rows, in row order, adjacent rows recorded alike as one run. */
+    readonly rows?: readonly SheetDocumentAxisFormat[];
+    /** The widths recorded on columns, in column order, adjacent columns of one width and one kind as one run (ADR-0046). */
+    readonly columnWidths?: readonly SheetDocumentColumnWidth[];
+}
+
+/** A Linked Table's declaration as a Sheet Document records it: its name, its column names and its key, never its rows (ADR-0049). */
+export declare class SheetDocumentTable {
+    /** The key's columns: one, several for a key of several columns (version 9; ADR-0058), or none. */
+    readonly keyColumns: readonly string[];
+    /** The table's name, as declared. */
+    readonly name: string;
+    /** Its column names, in the declared order. */
+    readonly columns: readonly string[];
+    constructor(name: string, columns: readonly string[], keyColumns?: readonly string[]);
+    /** The key column when the key is one column; `undefined` for none, and for a key of several columns. */
+    get key(): string | undefined;
+}
+
+/**
+ * One user operation on a Sheet, described before it is done: an edit, a paste, a Cell Format, an insertion or
+ * deletion, a fill, or an operation on the Workbook's Sheets. `Workbook.do` does it and returns the one step that
+ * undoes it (ADR-0048): a paste over a thousand cells is one step.
+ */
+export declare abstract class SheetEdit {
+    /** @internal */
+    protected constructor();
+    /** Text typed into one cell, read under the Sheet's culture (`Sheet.enter`). */
+    static enter(address: CellAddress, typed: string): SheetEdit;
+    /** Several typed texts as one operation, such as a paste from another program. */
+    static enterMany(typed: Iterable<TypedCell>): SheetEdit;
+    /** Entries set or cleared (`undefined`) as one operation. */
+    static setEntries(entries: Iterable<EntryOfCell>): SheetEdit;
+    /** A Number Format set on cells; `undefined` is General. */
+    static setNumberFormatOf(addresses: Iterable<CellAddress>, format: NumberFormat | undefined): SheetEdit;
+    /** A horizontal alignment set on cells. */
+    static setAlignmentOf(addresses: Iterable<CellAddress>, alignment: HorizontalAlignment): SheetEdit;
+    /**
+     * A Number Format set on a range (`Sheet.setNumberFormat`); `undefined` is General. Whole columns and whole rows
+     * are recorded as one entry each, and undoing the step puts back every level exactly (ADR-0047).
+     */
+    static setNumberFormat(range: CellRange, format: NumberFormat | undefined): SheetEdit;
+    /** A horizontal alignment set on a range, recorded as `setNumberFormat` records a Number Format. Throws a RangeError for one that is not an alignment. */
+    static setAlignment(range: CellRange, alignment: HorizontalAlignment): SheetEdit;
+    /**
+     * The parts `change` names set on several ranges as one step (ADR-0046, ADR-0071), such as a selection of several
+     * rectangles, whole columns and whole rows among them. The change's Borders are relative to each range, so each
+     * range gets its own outline. Undoing the step puts back every level exactly. Throws when there is no range, or the
+     * change sets nothing.
+     */
+    static setCellFormat(ranges: Iterable<CellRange>, change: CellFormatChange): SheetEdit;
+    /**
+     * A width the user set on every column `columns` spans, in characters (`Sheet.setColumnWidth`): set by the user, so
+     * an entry never widens them; `undefined` puts them back at the default width. Undoing the step puts back every
+     * column's width, and its kind, exactly (ADR-0046). Throws a RangeError for a width not more than 0 and at most 255.
+     */
+    static setColumnWidth(columns: CellRange, width: number | undefined): SheetEdit;
+    /**
+     * A width an entry widened every column `columns` spans to, in characters (`Sheet.setAutomaticColumnWidth`):
+     * widened by entry, and widened again by a longer entry (ADR-0046, 2026-09-28; CW-028). Undoing the step puts back
+     * every column's width, and its kind, exactly.
+     */
+    static setAutomaticColumnWidth(columns: CellRange, width: number): SheetEdit;
+    /** Rows inserted (`Sheet.insertRows`). */
+    static insertRows(row: number, count?: number): SheetEdit;
+    /** Rows deleted (`Sheet.deleteRows`). */
+    static deleteRows(row: number, count?: number): SheetEdit;
+    /** Columns inserted (`Sheet.insertColumns`). */
+    static insertColumns(column: number, count?: number): SheetEdit;
+    /** Columns deleted (`Sheet.deleteColumns`). */
+    static deleteColumns(column: number, count?: number): SheetEdit;
+    /**
+     * A block copied inside ExSheet, pasted (ADR-0048, ADR-0071): Entries with their relative References shifted by the
+     * distance pasted (a Reference shifted off the Sheet is `#REF!`, as in Excel), Cell Formats with them.
+     *
+     * - At a cell, its top-left cell lands there. A block that would run past the Sheet's edge is refused by name (ADR-0050).
+     * - Over a range, it is repeated to fill it, as Excel repeats a paste over a selection that is a whole multiple of
+     *   the block's size.
+     * - Over several ranges, it is pasted over each as one operation (ADR-0014, ADR-0180); a cell two ranges share is
+     *   written once, with what the later range gives it.
+     *
+     * Throws when there is no range, or a range is not a whole multiple of the block in both directions.
+     */
+    static paste(block: SheetBlock, at: CellAddress | CellRange | Iterable<CellRange>): SheetEdit;
+    /**
+     * Text pasted from another program, each field taken as if the user had typed it into its cell under the Sheet's
+     * culture: `=A1+1` becomes a Formula and `1,234` a number under `en-US` (ADR-0048). A field beginning with `=` that
+     * cannot be read as a Formula is taken as text, as Excel takes a pasted `=1+`. `fields` is rectangular, rows of
+     * columns, with the top-left field at `origin`; an empty field clears its cell. A block that would run past the
+     * Sheet's edge is refused by name (ADR-0050). Throws when the rows are not all the same length, or there are none.
+     */
+    static pasteText(fields: readonly (readonly string[])[], origin: CellAddress): SheetEdit;
+    /**
+     * Text pasted from another program, given field by field, each taken as `pasteText` takes it; with `entries`,
+     * some cells carry their exact Value, set as they are, such as an invariant number with every digit its double
+     * holds (ADR-0048, ADR-0050 item 10). The fields are read first, so a format typing gives a cell is given before
+     * the Entries are set; a cell named in both takes its Entry. One operation: one step, and one change (ADR-0180).
+     */
+    static pasteFields(fields: Iterable<TypedCell>, entries?: Iterable<EntryOfCell>): SheetEdit;
+    /**
+     * A Fill Intent resolved as Excel fills (ADR-0050, item 5): `target` extends `source` in `direction`, given as the
+     * new cells alone or as the whole extended range. Formulas are copied with their References shifted, two or more
+     * numbers continue as Excel's linear trend, a single date goes on by day, a single number in a line of a fill from
+     * whole columns or whole rows goes on by one, and any other single number, text without a pattern, booleans, Error
+     * Values and blanks are copied. Any other pattern is refused (`fillPatternNotSupported`), never filled with copies;
+     * `Workbook.check` says so before anything is written.
+     */
+    static fill(source: CellRange, target: CellRange, direction: FillDirection): SheetEdit;
+    /**
+     * Excel's fill keys, Ctrl+D and Ctrl+R (ADR-0035; ADR-0050, item 5, 2026-09-28): `target` extends `source` in
+     * `direction` as a copy of it, repeated, and never as a series. Only a target that does not extend the source along
+     * one axis is refused.
+     */
+    static fillCopy(source: CellRange, target: CellRange, direction: FillDirection): SheetEdit;
+    /**
+     * Excel's Ctrl+Enter (ADR-0050, item 5, 2026-09-28): `typed`, read under the Sheet's culture as entered in
+     * `enteredAt`, written into every cell of `targets` as one operation. A Formula is written as entered in
+     * `enteredAt`, and into every other cell with its relative References shifted by that cell's offset from it, by the
+     * rule `fillCopy` shifts them. Anything else is entered into every cell as typed. Overlapping ranges write their
+     * shared cells once. Throws when there is no target, or `enteredAt` lies outside every target; doing it throws a
+     * FormulaSyntaxError for a Formula that cannot be read, and nothing changes.
+     */
+    static enterInto(targets: Iterable<CellRange>, enteredAt: CellAddress, typed: string): SheetEdit;
+    /**
+     * The Sheet renamed (ADR-0046, ADR-0331): every Reference on every Sheet qualified with the old name is rewritten to
+     * the new one, as Excel rewrites them. A rename is a change, so `RAND` and `RANDBETWEEN` draw again (ADR-0180); a
+     * rename to the name the Sheet already has changes nothing. A name another Sheet has, without regard to case, is
+     * refused (`sheetNameTaken`). Throws a RangeError for a name a Sheet cannot have.
+     */
+    static rename(name: string): SheetEdit;
+    /**
+     * A new, empty Sheet inserted beside the Sheet the edit is done on — after it, as Excel's `+` button adds one, or
+     * before it, as Shift+F11 does — named `name`, or `Sheet` and the next number of the Workbook's count of the Sheets
+     * it has made, as Excel numbers one (ADR-0331). Undoing it takes the Sheet out again, and gives its number back. The
+     * step's Sheet is the new Sheet.
+     */
+    static insertSheet(name?: string, before?: boolean): SheetEdit;
+    /**
+     * The Sheet deleted (ADR-0331): every Reference on another Sheet qualified with its name becomes `#REF!`. Undoing it
+     * gives back the Sheet and those Formulas exactly. The Workbook's last Sheet is not deleted (`lastSheet`).
+     */
+    static deleteSheet(): SheetEdit;
+    /** The Sheet moved to `index` in the order of the Sheets after the move (ADR-0331). Throws a RangeError for a negative index. */
+    static moveSheet(index: number): SheetEdit;
+    /**
+     * A copy of the Sheet — its Entries, Cell Formats and column widths — named as Excel names one, `Name (2)`, placed at
+     * `index` in the order after the copy, or just after the Sheet (ADR-0331). A Reference in it qualified with the
+     * Sheet's name names the copy. The step's Sheet is the copy.
+     */
+    static copySheet(index?: number): SheetEdit;
+    /** Whether the Sheet would refuse this operation as it stands, and why. Changes nothing. @internal */
+    check(_sheet: Sheet): SheetRefusal | undefined;
+    /** Does the operation on `sheet`, checked already, and answers the step that undoes it. @internal */
+    abstract apply(sheet: Sheet): SheetStep;
+    /** The ranges the operation changes on its Sheet: what an undo or a redo of it selects (ADR-0331 §3). None for an operation on the Sheets. @internal */
+    get ranges(): readonly CellRange[];
+    /** The smallest range holding every one of `cells`; none for no cells. @internal */
+    static bounding(cells: Iterable<CellAddress>): CellRange[];
+}
+
+/** A moment in the Workbook's zone: the date and the time of day `NOW` answers (ADR-0124). */
+export declare interface SheetMoment extends SheetDay {
+    /** 0 to 23. */
+    readonly hour: number;
+    /** 0 to 59. */
+    readonly minute: number;
+    /** 0 to 59. */
+    readonly second: number;
+    /** 0 to 999. */
+    readonly millisecond: number;
+}
+
+/** An operation a Sheet refused, and why, with the refusal in words naming what caused it. Nothing was changed. */
+export declare class SheetRefusal {
+    /** Why it was refused. */
+    readonly reason: SheetRefusalReason;
+    /** The refusal in words, naming what caused it. */
+    readonly message: string;
+    constructor(reason: SheetRefusalReason, message: string);
+    /** Whether `other` is the same refusal, for the same reason and in the same words. */
+    equals(other: SheetRefusal): boolean;
+}
+
+/**
+ * Why a Sheet refused an operation. A refusal changes nothing: the engine says an operation cannot be done rather
+ * than do something close to it (ADR-0047, ADR-0050).
+ *
+ * - `entriesWouldLeaveSheet`: an insertion would push a cell holding an Entry off the Sheet's edge.
+ * - `blockWouldLeaveSheet`: a block written at a place would run past the Sheet's edge (ADR-0050).
+ * - `waitingForData`: a copy reaches a cell whose Value is `#GETTING_DATA` (ADR-0049).
+ * - `fillPatternNotSupported`: a fill whose source is a pattern ExSheet does not continue (ADR-0050).
+ * - `fillShapeNotSupported`: a fill whose target does not extend its source along one axis (ADR-0050).
+ * - `editIsOpen`: a command that changes the Sheet, given while an edit is open (ADR-0048, ADR-0049).
+ * - `sheetNameTaken`: a Sheet would be given a name another Sheet of the Workbook has, without regard to case (ADR-0331).
+ * - `lastSheet`: the Workbook's last Sheet would be deleted (ADR-0331).
+ * - `sheetNotNamed`: a command or an address that names no Sheet, given while the Workbook holds several (ADR-0331 §6).
+ * - `selectionMoved`: a change made from the Focus cell's Cell Format away from the Sheet, set once the Selection, or the
+ *   Sheet shown, is no longer the one it was read from (ADR-0100).
+ * - `focusFormatChanged`: such a change, set once the Focus cell's Cell Format is no longer the one it was made from
+ *   (ADR-0100).
+ */
+export declare type SheetRefusalReason = 'entriesWouldLeaveSheet' | 'blockWouldLeaveSheet' | 'waitingForData' | 'fillPatternNotSupported' | 'fillShapeNotSupported' | 'editIsOpen' | 'sheetNameTaken' | 'lastSheet' | 'sheetNotNamed' | 'selectionMoved' | 'focusFormatChanged';
+
+/** Thrown when an operation the caller asked for is refused. Nothing was changed. */
+export declare class SheetRefusedError extends Error {
+    /** The refusal. */
+    readonly refusal: SheetRefusal;
+    constructor(refusal: SheetRefusal);
+}
+
+/** What a rename did, and the Formulas it rewrote on every Sheet, as they were, for undoing it. @internal */
+declare interface SheetRename {
+    readonly change: SheetChange;
+    readonly oldName: string;
+    readonly rewritten: readonly RewrittenEntry[];
+}
+
+/**
+ * How many rows and columns the Sheets of a Workbook hold (ADR-0460): Excel's 1,048,576 × 16,384 unless a Consumer
+ * gives fewer. It bounds where a cell may hold an Entry and what the user reaches, not the address space: a Reference
+ * past it is still a Reference, to a cell that is empty and can hold nothing.
+ */
+export declare class SheetSize {
+    /** Excel's full size, 1,048,576 rows by 16,384 columns (`A1` to `XFD1048576`): what a Sheet holds unless given another. */
+    static readonly excel: SheetSize;
+    /** How many rows, from 1 to 1,048,576. */
+    readonly rows: number;
+    /** How many columns, from 1 to 16,384. */
+    readonly columns: number;
+    /** A size of `rows` by `columns`; one of no rows or no columns, or larger than Excel's, is refused with a `RangeError`. */
+    constructor(rows: number, columns: number);
+    /** The last cell inside the size: `XFD1048576` for Excel's, `J10` for ten by ten. */
+    get lastCell(): CellAddress;
+    /** Whether `address` lies inside the size. */
+    contains(address: CellAddress): boolean;
+    /** Whether a block of `rows` × `columns` with its top-left cell at `origin` lies wholly inside the size. */
+    holds(origin: CellAddress, rows: number, columns: number): boolean;
+    /**
+     * `range` as it stands inside the size, or `undefined` when it runs past it. Whole columns and whole rows are
+     * Excel's lines, inside when their columns or rows are, and are answered as long as the size's: `B:B` of ten rows
+     * is `B1:B10`.
+     */
+    fit(range: CellRange): CellRange | undefined;
+    /** Whether the two are the same size. */
+    equals(other: SheetSize): boolean;
+}
+
+/**
+ * One operation a Sheet has done, as one step of ExSheet's one undo stack (ADR-0048): undoing it restores every
+ * Entry, format and Reference it changed exactly, with one recalculation; redoing it does it again. Steps are
+ * undone in the reverse of the order they were done, and redone in the order they were undone.
+ */
+export declare class SheetStep {
+    #private;
+    /** The Sheet the operation was done on. */
+    readonly sheet: Sheet;
+    /** What doing the operation changed. */
+    readonly change: SheetChange;
+    /** @internal */
+    constructor(sheet: Sheet, change: SheetChange, undo: (sheet: Sheet) => SheetChange, redo: (sheet: Sheet) => SheetChange);
+    /** Whether the step is currently undone. */
+    get isUndone(): boolean;
+    /** Undoes the operation, and says what that changed. Throws when the step is already undone. */
+    undo(): SheetChange;
+    /** Does the operation again after `undo`, and says what that changed. Throws when the step is not undone. */
+    redo(): SheetChange;
+}
+
+/** One insertion or deletion of whole rows or columns. */
+declare class StructuralEdit {
+    #private;
+    readonly axis: SheetAxis;
+    readonly start: number;
+    readonly count: number;
+    readonly isInsert: boolean;
+    constructor(axis: SheetAxis, start: number, count: number, isInsert: boolean);
+    get size(): number;
+    /** The edit that undoes this one. */
+    get inverse(): StructuralEdit;
+    equals(other: StructuralEdit): boolean;
+    describe(): string;
+    /** Throws a `RangeError` for a start or count outside the Sheet. */
+    validate(): void;
+    /** Where a cell goes: its new address, or `undefined` when it is deleted or pushed off the edge. */
+    move(address: CellAddress): CellAddress | undefined;
+    /**
+     * A Reference rewritten as Excel rewrites it: an insertion at or before a range's first cell moves it, one
+     * inside it grows it; a deletion shrinks it, moves it, or — when it takes every cell it named — makes it
+     * `#REF!` (`undefined`). A Reference that spans the whole axis (`A:A` for rows) is untouched, as is one
+     * qualified with another Sheet's name (ADR-0046); one qualified with the Sheet's own name is rewritten like
+     * any other. An insertion that pushes the cells a Reference names off the edge does not stop the insertion,
+     * as it does not in Excel (observed, verification/2026-09-27-windows-excel): a range pushed partly off is cut
+     * at the edge (`A2:A1048576`, a row inserted at 1, is `A3:A1048576`), and a Reference pushed wholly off is
+     * `#REF!`.
+     */
+    map(reference: Reference, sheet: LocalReferences): Reference | undefined;
+    /** Whether a Reference covers any place at or beyond the edit along its axis. */
+    reaches(reference: Reference, sheet: LocalReferences): boolean;
+}
+
+/** What a structural edit did, and what undoing it needs besides the inverse edit. @internal */
+declare interface StructuralOutcome {
+    readonly change: SheetChange;
+    readonly dropped: readonly AddressedState[];
+    readonly rewritten: readonly {
+        readonly address: CellAddress;
+        readonly entry: Entry;
+    }[];
+    readonly rowsBefore: ReadonlyMap<number, AxisFormat>;
+    readonly columnsBefore: ReadonlyMap<number, AxisFormat>;
+    readonly widthsBefore: ReadonlyMap<number, SheetColumnWidth>;
+    readonly rewrittenElsewhere: readonly RewrittenEntry[];
+}
+
+/** A structured reference into a Linked Table, `Table[Column]` (ADR-0049). */
+declare class StructuredReferenceNode extends NodeBase {
+    readonly kind = "structuredReference";
+    readonly table: string;
+    readonly column: string;
+    constructor(table: string, column: string);
+    structuredReferences(): Generator<StructuredReferenceNode>;
+}
+
+/**
+ * What Point writes for a pressed column of a Linked Table, through a Pointing Scope (ADR-0058): Excel's
+ * structured reference, `Positions[PV]`, written as the engine writes one back — single brackets, with `'`
+ * before each of `[ ] # ' @` in the column's name. Throws a RangeError when either name is empty.
+ */
+export declare function structuredReferenceText(table: string, column: string): string;
+
+/** A Linked Table's state, which every Sheet of the Workbook reads (ADR-0331). @internal */
+declare class TableState {
+    /** The current snapshot, column by column; `undefined` until the first arrives, and after one is refused. */
+    data: readonly (readonly (Value | undefined)[])[] | undefined;
+    /** For each column of `data`, whether it holds a refusal. */
+    refusing: readonly boolean[];
+    rowCount: number;
+    readonly name: string;
+    readonly columns: readonly string[];
+    /** Each column's index, by its name read without regard to case. */
+    readonly columnIndex: ReadonlyMap<string, number>;
+    /** The key's columns, as `columns` spells them; empty for none. */
+    readonly key: readonly string[];
+    readonly order: number;
+    constructor(name: string, columns: readonly string[], columnIndex: ReadonlyMap<string, number>, key: readonly string[], order: number);
+}
+
+declare class TextNode extends NodeBase {
+    readonly kind = "text";
+    readonly text: string;
+    constructor(text: string);
+}
+
+/**
+ * What a function makes of a 3D Reference given as one of its arguments (ADR-0331 §7), as Excel answered for
+ * each function ExSheet declares: read as one Value (`#REF!`, or `#VALUE!` handed on); read as one range across
+ * its span, Sheet by Sheet in tab order (`SUM` and its kin); handed on as it is (`IF`'s and `CHOOSE`'s values);
+ * `#VALUE!` where the function reads it (`IFS`'s and `SWITCH`'s values); or `#VALUE!` before anything of the
+ * call is read, where the function asks for a range of one Sheet.
+ */
+declare type ThreeDArgument = 'value' | 'range' | 'handOn' | 'valueError' | 'oneSheet';
+
+/** A typed text for a cell. */
+export declare type TypedCell = readonly [CellAddress, string];
+
+declare class UnaryNode extends NodeBase {
+    #private;
+    readonly kind = "unary";
+    readonly operator: '+' | '-';
+    readonly operand: Node_2;
+    constructor(operator: '+' | '-', operand: Node_2);
+    references(): Generator<Reference>;
+    structuredReferences(): Generator<StructuredReferenceNode>;
+    calls(): Generator<FunctionNode>;
+    get depth(): number;
+}
+
+/**
+ * What a cell evaluates to: a number, text, a boolean or an Error Value (CONTEXT.md). A constant Entry is
+ * its own Value; a Formula's Value is its result. Values are never recorded in a Sheet Document (ADR-0048).
+ * A blank is no Value: where one may stand, the engine says `undefined`.
+ */
+export declare class Value {
+    #private;
+    private constructor();
+    /** A number. NaN and the infinities are not numbers a cell can hold; Excel's answer to them is `#NUM!`. */
+    static fromNumber(number: number): Value;
+    /** Text, possibly empty. */
+    static fromText(text: string): Value;
+    /** `TRUE` or `FALSE`. */
+    static fromBoolean(value: boolean): Value;
+    /** An Error Value. */
+    static fromError(error: ErrorValue): Value;
+    /**
+     * A refusal (ADR-0047; 2026-10-12, decided with the user: a refusal is never caught, anywhere): the Error
+     * Value `#VALUE!` where ExSheet cannot answer as Excel. It is `#VALUE!` to everything outside the engine,
+     * and the engine carries it as `#CIRC!` is carried. Internal to the engine.
+     */
+    static readonly refusal: Value;
+    /** A refusal shown as `#NAME?`: a call of a function Excel has and ExSheet does not declare, or a declared Linked Table's bare name. Internal. */
+    static readonly refusedName: Value;
+    /** Which of the four kinds this Value is. */
+    get kind(): ValueKind;
+    /**
+     * Whether this Error Value is a Refused Formula's: `#VALUE!`, or `#NAME?` for a function Excel has and
+     * ExSheet does not declare, which no Formula can catch, in its own cell or in any cell that reads it
+     * (ADR-0047). It is equal to the Error Value it shows.
+     */
+    get isRefused(): boolean;
+    /** Whether this Value is an Error Value. */
+    get isError(): boolean;
+    /** The number; throws unless the kind is `number`. */
+    get number(): number;
+    /** The text; throws unless the kind is `text`. */
+    get text(): string;
+    /** The boolean; throws unless the kind is `boolean`. */
+    get boolean(): boolean;
+    /** The Error Value; throws unless the kind is `error`. */
+    get error(): ErrorValue;
+    /**
+     * Exact equality: the same kind and the same number, text (ordinal, case-sensitive), boolean or Error
+     * Value. This is "did the Value change", not Excel's `=`, which ignores case. A refusal equals the Error
+     * Value it shows.
+     */
+    equals(other: Value): boolean;
+    /**
+     * Whether a cell's Value did not change: equal and both refused or neither, or both absent. A `#VALUE!`
+     * that turns from Excel's own into a refusal changes what every Formula reading the cell answers.
+     */
+    static unchanged(before: Value | undefined, after: Value | undefined): boolean;
+    /** Whether two Values that may be blank are equal: both blank, or equal (`Nullable.Equals`). */
+    static same(a: Value | undefined, b: Value | undefined): boolean;
+    /** A diagnostic form, culture-invariant: a number round-trips, text is as held. What a cell shows is the Sheet's display, not this. */
+    toString(): string;
+}
+
+/**
+ * A rectangle of Values a Formula computes (ADR-0125): an operator applied to a range, a function built for
+ * arrays, or a range read whole. Row by row; a blank is `undefined`.
+ */
+declare class ValueArray {
+    #private;
+    /**
+     * The most Values one array holds: 2^24, sixteen whole columns. A larger array is not computed, as Excel
+     * runs out of resources before it (ADR-0125: a cap belongs on what cannot be executed); whatever would
+     * build one is `#NUM!`.
+     */
+    static readonly mostCells: number;
+    readonly rows: number;
+    readonly columns: number;
+    constructor(rows: number, columns: number);
+    /** Whether the array is one Value, which is no array at all to whoever reads it. */
+    get isSingle(): boolean;
+    at(row: number, column: number): Value | undefined;
+    set(row: number, column: number, value: Value | undefined): void;
+    /** Every Value row by row, blanks included as `undefined`. */
+    all(): readonly (Value | undefined)[];
+    /** The Values row by row, blanks left out, as a range's are read. */
+    nonBlank(): Generator<Value>;
+    /**
+     * The element at `row`, `column` as Excel's broadcasting reads it: a single row or column is repeated along
+     * the other array, and past its size an array of more than one row or column is `#N/A`.
+     */
+    broadcast(row: number, column: number): Value | undefined;
+    static single(value: Value | undefined): ValueArray;
+}
+
+/** The four kinds of Value, as in Excel (ADR-0047). A blank cell is not a fifth kind: it has no Value. */
+export declare type ValueKind = 'number' | 'text' | 'boolean' | 'error';
+
+/**
+ * The Sheets ExSheet holds, in order, under one culture, with one dependency graph across them (CONTEXT.md, ADR-0331).
+ * A Formula on one Sheet reads another's cells by qualifying a Reference with its name (`=Sheet2!A1`), and a change on
+ * any Sheet recalculates what depends on it on every Sheet, publishing the new Values only when that whole
+ * recalculation has completed (ADR-0047). Linked Tables are declared on the Workbook, and read from any of its Sheets.
+ * Changed and read by one caller at a time.
+ */
+export declare class Workbook {
+    #private;
+    /** The Workbook's declared culture, which every one of its Sheets reads and shows under (ADR-0048, ADR-0331). */
+    readonly culture: Culture;
+    /** The Linked Tables' state, which every Sheet of the Workbook reads, by name read without regard to case (ADR-0331). @internal */
+    readonly tables: Map<string, TableState>;
+    /**
+     * Where the engine reads the current moment for `NOW`: the date and time of day in the Workbook's zone, or
+     * `undefined` while it is not known, when `NOW` is `#GETTING_DATA` (ADR-0124). The engine reads no clock itself; it
+     * calls this once at the start of each recalculation, so every `NOW` on every Sheet in one recalculation answers the
+     * same moment. Unset, the default, leaves `NOW` waiting.
+     */
+    nowSource: (() => SheetMoment | undefined) | undefined;
+    /**
+     * A Workbook of empty Sheets named `sheetNames`, in that order — one, `Sheet1`, when none are given — whose constants
+     * are read and whose Values are shown under `culture` (ADR-0048). Throws a RangeError when no name is given, a name
+     * is not one a Sheet can have (`Sheet.isValidName`), or two names are the same without regard to case. Every Sheet
+     * holds `size`, Excel's unless given (ADR-0460).
+     */
+    constructor(culture: Culture, sheetNames?: Iterable<string>, size?: SheetSize);
+    /**
+     * Opens a Workbook Document: a Workbook in the document's culture, with its Sheets in order, the Sheet it shows
+     * shown, its Linked Tables declared and waiting for their first snapshot, and each Sheet's Entries, Cell Formats and
+     * column widths, with every Value computed again (ADR-0048, ADR-0049, ADR-0331). A Sheet Document opens as a
+     * Workbook of that one Sheet. The culture of the caller plays no part. Every Sheet holds `size`, Excel's unless given,
+     * and a document with an Entry past it is refused with a `RangeError` naming the first such cell, never opened
+     * without it (ADR-0460).
+     */
+    static open(document: WorkbookDocument | SheetDocument, size?: SheetSize): Workbook;
+    /** How many rows and columns every Sheet of the Workbook holds (ADR-0460): Excel's unless one was given. */
+    get size(): SheetSize;
+    /**
+     * Gives every Sheet another size (ADR-0460). A size that would leave an Entry past it is refused with a `RangeError`
+     * naming the first such cell, and the Workbook keeps the size it had. Every spilled array is laid out again against
+     * the new edge: one that no longer fits shows `#SPILL!`, and one that now fits spills. It is not an operation a user
+     * undoes.
+     */
+    resize(size: SheetSize): WorkbookChange;
+    /**
+     * The Sheet named `sheet` as a Sheet Document: the Workbook's culture, the Sheet's name, the Linked Tables'
+     * declarations, its Entries, Cell Formats and column widths — never its Values, nor a table's rows. A Reference to
+     * another Sheet is kept as it is written, so opened on its own it reads `#REF!`. Throws a RangeError when no Sheet
+     * is named so.
+     */
+    toSheetDocument(sheet: string): SheetDocument;
+    /**
+     * The Workbook as a Workbook Document: its culture, the Sheet shown, its Linked Tables' declarations, and each Sheet
+     * as a Sheet Document records one, in order — never a Value, nor a table's rows (ADR-0331).
+     */
+    toDocument(): WorkbookDocument;
+    /**
+     * The Sheet shown: the one whose tab is selected (ADR-0331). Showing another Sheet changes nothing a step records.
+     * Setting a Sheet that is not one of this Workbook's throws a RangeError.
+     */
+    get shown(): Sheet;
+    set shown(sheet: Sheet);
+    /** The Sheets, in the order their tabs stand. Change one through `do`. */
+    get sheets(): readonly Sheet[];
+    /** The Sheet named `name`, without regard to case, as a Reference's qualifier names one; `undefined` when none is. */
+    find(name: string): Sheet | undefined;
+    /** The Linked Tables declared, in the order they were first declared (ADR-0049). */
+    get linkedTables(): LinkedTable[];
+    /**
+     * The current snapshot of the Linked Table named `name`, without regard to case, column by column in the order the
+     * columns are declared, each holding one Value per row (`undefined` for a blank); `undefined` while it waits. A later
+     * snapshot replaces it whole. Throws when no table of that name is declared.
+     */
+    linkedTableColumns(name: string): readonly (readonly (Value | undefined)[])[] | undefined;
+    /**
+     * Does `edit` on the Sheet named `sheet` as one operation, and returns the step that undoes it (ADR-0048, ADR-0331).
+     * A refused or unreadable operation changes nothing and returns no step. Throws a RangeError when no Sheet is named
+     * so, a SheetRefusedError when the Sheet refuses the operation (`check` says why), and a FormulaSyntaxError when a
+     * typed Formula cannot be read.
+     */
+    do(sheet: string, edit: SheetEdit): WorkbookStep;
+    /**
+     * Does several edits, each on the Sheet it names, as one operation, and returns the one step that undoes them all
+     * (ADR-0048, ADR-0331 §3): a Replace All over the Workbook (ADR-0332 §5) is one step and one change (ADR-0180). The
+     * edits are done in the order given and undone in the reverse. Every edit is checked before any is done, and one
+     * that cannot be done leaves the Workbook as it was: the edits done before it are put back, and the count of changes
+     * with them. A Sheet operation is done alone, with `do`.
+     *
+     * Each edit is recalculated across the Workbook as it is done, before the next: the operation is one recalculation
+     * per edit, its change reporting them together once the last has completed.
+     */
+    doAll(edits: readonly (readonly [string, SheetEdit])[]): WorkbookStep;
+    /** Whether `do` would refuse `edit` on the Sheet named `sheet` as it stands, and why; `undefined` when it would not. */
+    check(sheet: string, edit: SheetEdit): SheetRefusal | undefined;
+    /**
+     * Declares a Linked Table by name and columns (ADR-0049), before any of its rows arrive. Formulas that read it stop
+     * being `#NAME?` and show `#GETTING_DATA` until the first snapshot is pushed, on every Sheet. The declaration is
+     * recorded in the document; a table is never undeclared. Declaring it again with the same columns, in the same
+     * order, with the same key, changes nothing; other columns or another key replace the declaration and drop the rows
+     * held so far.
+     *
+     * `key` is the key column, or the key's columns for a table whose rows are told apart by several columns together
+     * (ADR-0058), each one of `columns` named without regard to case; none declares no key. Throws a RangeError when the
+     * name or the columns are not ones a structured reference can name, or a key column is not one of the columns, or is
+     * named twice.
+     */
+    declareLinkedTable(name: string, columns: readonly string[], key?: string | readonly string[]): WorkbookChange;
+    /**
+     * Replaces a Linked Table's data with a whole snapshot, in one step (ADR-0049): no recalculation sees part of one
+     * snapshot and part of another, and only the Formulas that read the table — and what depends on them — recalculate.
+     * A snapshot of a keyed table in which a key repeats is refused with a RepeatedKeyError, and the table waits again.
+     * Throws when no table of that name is declared, and a RangeError when a row does not have one Value per column or
+     * holds `#GETTING_DATA` or `#CIRC!`.
+     */
+    pushLinkedTable(name: string, rows: Iterable<readonly (Value | undefined)[]>): WorkbookChange;
+    /** Runs an operation on `sheet`, and reports what it changed there with what its recalculation changed on every other Sheet. @internal */
+    collectOn(sheet: Sheet, operation: () => SheetChange): WorkbookChange;
+    /**
+     * Runs an operation, and reports what it changed on the Sheet it names together with what its recalculation changed
+     * on every other Sheet, and whether it changed which Sheets the Workbook holds. @internal
+     */
+    collecting(operation: () => {
+        sheet: Sheet;
+        change: SheetChange;
+    }): WorkbookChange;
+    /** Records what a recalculation changed on `sheet`, which the operation under way did not start on. @internal */
+    collect(sheet: Sheet, change: SheetChange): void;
+    /**
+     * The Sheet Day: the calendar day `TODAY()` answers on every Sheet, or `undefined` while it is not known, when every
+     * Formula that calls `TODAY` is `#GETTING_DATA` (ADR-0121). The engine never reads a clock; whoever runs it says
+     * which day it is. It is not part of a document.
+     */
+    get today(): SheetDay | undefined;
+    /**
+     * The moment `NOW` answers on every Sheet: the one the last recalculation read from `nowSource`, or `undefined`
+     * while none was read (ADR-0124). A copy of the Workbook made in the other engine is given it as its own moment,
+     * so that its `NOW` answers what this one shows.
+     */
+    get moment(): SheetMoment | undefined;
+    /** Whether any Formula on any Sheet calls a volatile function, so that moving the clock on can change a Value. */
+    get hasVolatileFormulas(): boolean;
+    /**
+     * Sets the Sheet Day, and recalculates only the Formulas that call `TODAY`, on every Sheet, and what reads them, in
+     * one recalculation. Setting the day the Workbook already has changes nothing. It is not an operation a user undoes.
+     * Throws a RangeError for a day that is not a calendar day from 1 January 1900, where Excel's dates begin (ADR-0047).
+     */
+    setToday(today: SheetDay | undefined): WorkbookChange;
+    /**
+     * Recalculates the Formulas that call a volatile function, on every Sheet, and what reads them, reading the moment
+     * again: what ExSheet does as the minute turns (ADR-0124). It is not an operation a user undoes.
+     */
+    recalculateVolatile(): WorkbookChange;
+    /**
+     * The seed every draw of `RAND` and `RANDBETWEEN` on every Sheet is made from, with the Sheet's name, the cell, the
+     * call's place in its Formula and `changes` (ADR-0180); `undefined` while it is not set, when every Formula that
+     * calls either is `#GETTING_DATA`. The engine never chooses a random number of its own. It is not part of a document.
+     */
+    get seed(): bigint | undefined;
+    /**
+     * How many changes the Workbook has had since it was made or opened (ADR-0180): each draws again, on every Sheet. An
+     * edit of an Entry, an insertion or a deletion, a Sheet added, deleted, renamed, moved or copied, the undo or redo of
+     * one of those, a Linked Table's snapshot, and a declaration that declares or replaces one, each count once.
+     */
+    get changes(): number;
+    /**
+     * Sets the seed — an unsigned 64-bit integer, or `undefined` to make the draws wait again — and with `changes` the
+     * count of changes too, and recalculates only the Formulas that draw, on every Sheet, and what reads them. The same
+     * Entries, seed and count give the same draws (SH-17). Setting what the Workbook already has changes nothing. It is
+     * not a change, and not an operation a user undoes. Throws a RangeError for a seed outside 0 to 2^64 - 1 or a count
+     * below 0.
+     */
+    setSeed(seed: bigint | undefined, changes?: number): WorkbookChange;
+    /** Does `operation` as one operation: whatever steps it takes, on whichever Sheets, it counts as one change at most. @internal */
+    asOneChange<T>(operation: () => T): T;
+    /** Counts a change (ADR-0180), before the recalculation it brings draws: once for the operation under way, or once on its own. @internal */
+    countChange(): void;
+    /** Opening is no change: the count starts from 0 (ADR-0180). @internal */
+    forgetChanges(): void;
+    /** Where `sheet` stands in the order; -1 for a Sheet the Workbook does not hold. @internal */
+    indexOf(sheet: Sheet): number;
+    /**
+     * The Sheets a 3D Reference from `first` to `last` spans (ADR-0331 §7): those from one to the other in tab order,
+     * both included, whichever stands first; the names are read without regard to case. `undefined` when no Sheet has
+     * one of the names. @internal
+     */
+    span(first: string, last: string): Sheet[] | undefined;
+    /**
+     * Renames `sheet`: every Reference on every Sheet qualified with its old name is rewritten to the new one, as Excel
+     * rewrites them (ADR-0046, ADR-0331). A rename to the name the Sheet already has changes nothing. Throws a
+     * SheetRefusedError when another Sheet of the Workbook has the name, without regard to case. @internal
+     */
+    renameSheet(sheet: Sheet, name: string): SheetRename;
+    /** Undoes a rename: the old name back, and the Formulas it rewrote exactly as they were. @internal */
+    undoRename(sheet: Sheet, rename: SheetRename): SheetChange;
+    /** Why `name` cannot be given to `sheet`: another Sheet has it, without regard to case; `undefined` when none does. @internal */
+    nameTaken(name: string, sheet: Sheet | undefined): SheetRefusal | undefined;
+    /**
+     * The name a new Sheet takes, as Excel names one (exsheet-workbook ticket 12, answer 13): `Sheet` and the next number
+     * of the Workbook's count of the Sheets it has made, passing over a name a Sheet has. @internal
+     */
+    nextSheetName(): string;
+    /** The number `nextSheetName` gives the next new Sheet. @internal */
+    nextSheetNumber(): number;
+    /** `Sheet` and `number`: the name a new Sheet numbered so takes. @internal */
+    sheetName(number: number): string;
+    /** A Workbook just opened from a document: it has made no Sheet yet, as Excel's opened workbook has not. @internal */
+    opened(): void;
+    /**
+     * Counts a new Sheet as made, as Excel counts it: one numbered by the count takes the count to its number, past the
+     * names it passed over; any other counts one. The count before is returned, for `uncountSheetMade`. @internal
+     */
+    countSheetMade(numbered: number | undefined): number;
+    /** Puts back the count of Sheets made as it stood before an insertion or a copy, when the step is undone. @internal */
+    uncountSheetMade(before: number): void;
+    /** The name a copy of the Sheet named `name` takes, as Excel names one: `Name (2)`, or the next number free, the name cut to fit 31 characters. @internal */
+    copyName(name: string): string;
+    /** Inserts a new, empty Sheet at `index`. @internal */
+    insertSheet(index: number, name: string): {
+        sheet: Sheet;
+        change: SheetChange;
+    };
+    /** Puts back a Sheet taken out, at `index`, with what it held. @internal */
+    putBack(sheet: Sheet, index: number, rewritten: readonly RewrittenEntry[], shown: boolean): SheetChange;
+    /**
+     * Takes `sheet` out of the Workbook. Deleted, every Reference on another Sheet qualified with its name becomes
+     * `#REF!` (ADR-0331), and a 3D Reference it ends hands that end to the Sheet next to it inward; taken out to undo its
+     * insertion or copy, nothing is rewritten. The Sheet shown, if it was this one, becomes the one that takes its place.
+     * @internal
+     */
+    takeOut(sheet: Sheet, deleting: boolean, rewritten: RewrittenEntry[]): SheetChange;
+    /**
+     * Moves `sheet` to `index` in the order. A 3D Reference whose end it is, moved past the other end, hands that end to
+     * the Sheet next to it inward; each Formula so rewritten is added to `rewritten` as it was, for undoing the move.
+     * @internal
+     */
+    move(sheet: Sheet, index: number, rewritten: RewrittenEntry[]): SheetChange;
+    /** Undoes a move: `sheet` back at `index`, and the Formulas it rewrote exactly as they were. @internal */
+    moveBack(sheet: Sheet, index: number, rewritten: readonly RewrittenEntry[]): SheetChange;
+    /**
+     * A copy of `source` named `name` at `index`: its Entries, Cell Formats and column widths. A Reference in it
+     * qualified with the source's name names the copy, as Excel's copy does (ADR-0331); a 3D Reference the source ends is
+     * `#REF!` in the copy, and any other is copied as it is (ADR-0331 §7). @internal
+     */
+    copy(source: Sheet, index: number, name: string): {
+        sheet: Sheet;
+        change: SheetChange;
+    };
+    /** Puts back a copy, or an inserted Sheet, taken out by an undo. @internal */
+    reinsert(sheet: Sheet, index: number): SheetChange;
+    /**
+     * A 3D Reference as a Formula is entered with it (ADR-0331 §7): its ends in tab order, each written in its Sheet's
+     * own name, and a span of one Sheet written as a Reference to that Sheet. One naming a Sheet the Workbook lacks is
+     * left as typed: it is `#NAME?`. @internal
+     */
+    inTabOrder(reference: Reference): Reference;
+    /** An Entry with every 3D Reference in it written as `inTabOrder` writes one; the same instance when it holds none, or nothing changes. @internal */
+    entryInTabOrder(entry: Entry): Entry;
+    /** Whether `reference` is a 3D Reference whose span holds `sheet`, as the Workbook stands. @internal */
+    spans(reference: Reference, sheet: Sheet): boolean;
+}
+
+/**
+ * What one change to a Workbook did, Sheet by Sheet, reported after its recalculation has completed: every Value it
+ * names is already published, and all of them come from that one recalculation (ADR-0047, ADR-0331) — or, for an
+ * operation of several edits, from the last of the recalculations its edits were done with.
+ */
+export declare class WorkbookChange {
+    #private;
+    /** @internal */
+    constructor(changes: readonly {
+        readonly sheet: Sheet;
+        readonly change: SheetChange;
+    }[], changesSheets: boolean);
+    /** Whether the change added, deleted, renamed, moved or copied a Sheet, so that the Sheets and their tabs may differ (ADR-0331). */
+    readonly changesSheets: boolean;
+    /** The Sheets the change reached, in the Workbook's order: the one it was made on, and every other whose Values or formats it changed. */
+    get sheets(): Sheet[];
+    /** What the change did on `sheet`; a change that changed nothing for a Sheet it did not reach. */
+    for(sheet: Sheet): SheetChange;
+}
+
+/**
+ * The serialisable form of a Workbook (CONTEXT.md, ADR-0331): its Sheets in order, the Sheet shown, its culture and its
+ * Linked Tables' declarations, and for each Sheet what a Sheet Document records of it — never a Value: opening one
+ * computes every Value again. The Consumer persists it; ExSheet never does.
+ *
+ * The document is a format with a version, beside the Sheet Document's. A reader meeting a version it does not know
+ * refuses the document rather than guess at it, and so does a reader meeting anything it does not understand
+ * (ADR-0048). This engine writes version 1, whose Sheets are recorded as a Sheet Document of the current version
+ * records a Sheet. `fromJson` also reads a Sheet Document of every version `SheetDocument.fromJson` reads, as a
+ * Workbook of that one Sheet.
+ */
+export declare class WorkbookDocument {
+    /** The version this engine writes. */
+    static readonly currentVersion = 1;
+    /** The oldest version this engine reads. */
+    static readonly oldestReadableVersion = 1;
+    /** The name of the Workbook's declared culture, such as `en-US`; empty for the invariant culture, as .NET names it. */
+    readonly culture: string;
+    /** The name of the Sheet shown, one of `sheets`. */
+    readonly shown: string;
+    /** The Linked Tables declared on the Workbook, in the order they were declared: names, columns and keys only (ADR-0049). */
+    readonly linkedTables: readonly SheetDocumentTable[];
+    /** The Sheets, in the order their tabs stand, each under the Workbook's culture and declaring no Linked Table of its own. */
+    readonly sheets: readonly SheetDocument[];
+    /** @internal */
+    constructor(culture: string, shown: string, linkedTables: readonly SheetDocumentTable[], sheets: readonly SheetDocument[]);
+    /**
+     * A Workbook Document built from its Sheets, as a reader of another format builds one (ADR-0330 §3): `sheets` in the
+     * order their tabs stand, the one named `shown` shown, under `culture`, declaring no Linked Table. Throws a
+     * RangeError when there is no Sheet, two share a name, a Sheet records another culture or declares a Linked Table,
+     * or no Sheet is named `shown`. Nothing is guessed.
+     */
+    static of(culture: Culture, shown: string, sheets: Iterable<SheetDocument>): WorkbookDocument;
+    /** The format version the document is written in: `currentVersion`, whatever it was read from. */
+    get version(): number;
+    /** Writes the document as JSON, as the C# engine writes it. */
+    toJson(): string;
+    /**
+     * Reads a document written by `toJson`, or by the C# engine, or a Sheet Document of any version
+     * `SheetDocument.fromJson` reads, as a Workbook of that one Sheet, shown, with its Linked Tables declared on the
+     * Workbook (ADR-0331). Throws a SheetDocumentError when the version is not one this engine reads, the document holds
+     * anything its version does not define, it holds no Sheet or two of one name, or the Sheet it shows is not one of
+     * them. Nothing is guessed.
+     */
+    static fromJson(text: string): WorkbookDocument;
+}
+
+/**
+ * One operation a Workbook has done on one of its Sheets, or on several (`doAll`), as one step of ExSheet's one undo
+ * stack (ADR-0048, ADR-0331): undoing it restores what it changed exactly; redoing it does it again.
+ */
+export declare class WorkbookStep {
+    #private;
+    /** The ranges the operation changed on `sheet`: what an undo or a redo of it selects, as Excel's do (ADR-0331 §3). None for an operation on the Sheets. */
+    readonly ranges: readonly CellRange[];
+    /** The Sheet the operation was done on: for a Sheet added or copied, the new Sheet. */
+    readonly sheet: Sheet;
+    /** What doing the operation changed. */
+    readonly change: WorkbookChange;
+    /** @internal */
+    constructor(sheet: Sheet, change: WorkbookChange, undo: () => WorkbookChange, redo: () => WorkbookChange, ranges: readonly CellRange[]);
+    /** Whether the step is currently undone. */
+    get isUndone(): boolean;
+    /** Undoes the operation, and says what that changed. Throws when the step is already undone. */
+    undo(): WorkbookChange;
+    /** Does the operation again after `undo`, and says what that changed. Throws when the step is not undone. */
+    redo(): WorkbookChange;
+}
+
+/** A Cell Format as JSON: its Number Format's code, its alignment, its whole Font, its Fill and its four Borders. */
+export declare function writeCellFormat(format: CellFormat): string;
+
+/**
+ * A Linked Table's snapshot as JSON, rows of Values, a blank as `null` and a refusal as one, as `readLinkedRows` and
+ * .NET's `SheetWire.ReadRows` read it.
+ */
+export declare function writeLinkedRows(rows: Iterable<readonly (Value | undefined)[]>): string;
+
+/**
+ * A refused snapshot as JSON (ADR-0049): the table, its key's columns, the key as its first and its second row hold
+ * it, the two rows, and what the table's going back to waiting changed, so that .NET raises the refusal as the C#
+ * Sheet raises it.
+ */
+export declare function writeRepeatedKey(error: RepeatedKeyError): string;
+
+export { }