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

package/dist/index.d.ts

@@ -0,0 +1,1637 @@
+/**
+ * ExSheet's Script Core (ADR-0370, section 1): a general-purpose Excel-like sheet drawn by ExGrid as that grid's
+ * Consumer (ADR-0046), over `@ex-grid/sheet-engine`, free of any UI framework — `createSheet`, and what the Sheet
+ * decides beside its engine: the words it shows, by id, in English and Japanese; Format Cells' offer and draft; the
+ * Name Box; Excel's keys; where Ctrl+arrow stops; the Selection Summary's cells; what a change widens; and Pointing
+ * at a Linked Table's grid. A Framework Adapter mounts it, as `@ex-grid/sheet-react` does.
+ *
+ * @packageDocumentation
+ */
+
+import { BorderLine } from '@ex-grid/sheet-engine';
+import { BorderLineStyle } from '@ex-grid/sheet-engine';
+import { CellAddress } from '@ex-grid/sheet-engine';
+import { CellColour } from '@ex-grid/sheet-engine';
+import { CellFill } from '@ex-grid/sheet-engine';
+import { CellFormat } from '@ex-grid/sheet-engine';
+import { CellFormatChange } from '@ex-grid/sheet-engine';
+import { CellRange } from '@ex-grid/sheet-engine';
+import type { CommitRefusalReason } from '@ex-grid/core';
+import type { CopyRefusalReason } from '@ex-grid/core';
+import { Culture } from '@ex-grid/sheet-engine';
+import type { EditDiscardReason } from '@ex-grid/core';
+import { FormulaSyntaxError } from '@ex-grid/sheet-engine';
+import { GridChrome } from '@ex-grid/core';
+import { GridDensity } from '@ex-grid/core';
+import type { GridDirection } from '@ex-grid/core';
+import type { GridExtent } from '@ex-grid/core';
+import type { GridOutlinedColumn } from '@ex-grid/core';
+import type { GridPointArrow } from '@ex-grid/core';
+import type { GridPointDashes } from '@ex-grid/core';
+import { GridPointedAt } from '@ex-grid/core';
+import type { GridPointedPress } from '@ex-grid/core';
+import type { GridPointedPressKind } from '@ex-grid/core';
+import type { GridPointedStep } from '@ex-grid/core';
+import type { GridPointedStepKind } from '@ex-grid/core';
+import type { GridPointState } from '@ex-grid/core';
+import { GridPresentationDefaults } from '@ex-grid/core';
+import { GridSelection } from '@ex-grid/core';
+import type { GridSummaryRequest } from '@ex-grid/core';
+import type { GridSummaryResult } from '@ex-grid/core';
+import { HorizontalAlignment } from '@ex-grid/sheet-engine';
+import type { LinkedTable } from '@ex-grid/sheet-engine';
+import type { LinkedTableColumn } from '@ex-grid/sheet-engine';
+import { NumberFormat } from '@ex-grid/sheet-engine';
+import type { PasteRefusalReason } from '@ex-grid/core';
+import type { PlacementRefusalReason } from '@ex-grid/core';
+import type { PointedAtGrid } from '@ex-grid/core';
+import type { ReferenceColour } from '@ex-grid/core';
+import { SelectionSummary } from '@ex-grid/core';
+import { Sheet } from '@ex-grid/sheet-engine';
+import { SheetChange } from '@ex-grid/sheet-engine';
+import { SheetDay } from '@ex-grid/sheet-engine';
+import { SheetDocument } from '@ex-grid/sheet-engine';
+import { SheetEdit } from '@ex-grid/sheet-engine';
+import { SheetRefusal } from '@ex-grid/sheet-engine';
+import { SheetSize } from '@ex-grid/sheet-engine';
+import { SummaryFigure } from '@ex-grid/core';
+import { Value } from '@ex-grid/sheet-engine';
+import { ViewportSize } from '@ex-grid/core';
+import { Workbook } from '@ex-grid/sheet-engine';
+import { WorkbookDocument } from '@ex-grid/sheet-engine';
+
+/** An edge the Border tab sets, relative to each selected range, as Excel's dialog sets it (ADR-0071). The
+ * inside edges are Excel's Horizontal and Vertical. */
+export declare type BorderEdge = 'top' | 'insideHorizontal' | 'bottom' | 'left' | 'insideVertical' | 'right';
+
+/** The Border tab's presets, as Excel's dialog offers them (the eleventh Windows run, case 22). */
+export declare type BorderPreset = 'none' | 'outline' | 'inside';
+
+/** Which colour a More Colours entry is for: the Font's, the Fill, or the Border's line. */
+export declare type ColourTarget = 'font' | 'fill' | 'border';
+
+/** Draws a Sheet into `element`, which it owns from now on. */
+export declare function createSheet(element: HTMLElement, options?: SheetOptions): SheetHandle;
+
+/** The Currency category's code, with the culture's symbol on the side and at the distance the culture puts it. */
+export declare function currencyCode(places: number, negative: number, culture: Culture): string;
+
+/** How many ways a negative amount shows under Currency: with a minus, in red, in red with a minus, in brackets,
+ * in red brackets. */
+export declare const currencyNegativeStyles = 5;
+
+/** The codes Custom lists to start from. */
+export declare const customTypes: readonly string[];
+
+/**
+ * The codes Custom lists to start from, as the culture spells them (`NumberFormat.localCode`), each once: under
+ * en-GB the built-in short date is listed as `dd/mm/yyyy`, so that the one picked from the list is the built-in,
+ * as one typed is.
+ */
+export declare function customTypesIn(culture: Culture): readonly string[];
+
+/** The Date category's formats: Excel's built-in short date first, shown in the culture's own pattern. */
+export declare const dateTypes: readonly string[];
+
+/** The culture's default decimal places for a category, as Excel offers them. */
+export declare function defaultPlaces(category: NumberFormatCategory, culture: Culture): number;
+
+/**
+ * The categories Format Cells shows disabled, each with its reason: Accounting pads with `*`, Fraction is not
+ * among the codes ExSheet reads, and Special's formats depend on the locale (ADR-0071).
+ */
+export declare type DisabledNumberFormatCategory = 'accounting' | 'fraction' | 'special';
+
+/**
+ * The Focus cell's Cell Format, as `SheetHandle.readFocusFormat` read it: a change is made from it away from the Sheet,
+ * and set with `SheetHandle.setCellFormatFrom`, which knows what it was read against (ADR-0100).
+ */
+export declare interface FocusFormatReading {
+    /** The Focus cell's Cell Format as it showed. */
+    readonly format: CellFormat;
+}
+
+/** The Font tab's styles, as Excel lists them: emphasis as one choice of four. */
+export declare type FontStyle = 'regular' | 'italic' | 'bold' | 'boldItalic';
+
+/**
+ * What Format Cells opens on, and what the user has touched since (ADR-0071, SH-45).
+ *
+ * It opens on the Focus cell's Cell Format. A part that differs across the Selection is shown as Excel shows it
+ * (the eleventh Windows run, case 24): the Font style empty (`fontStyle` is `undefined`), a Fill as No Colour,
+ * and an edge as a grey dotted line (`edgeLine` is `undefined`). Every other part shows the Focus cell's. A
+ * range's outer edges show as they are drawn, a neighbour's line where the cell records none (the fourteenth run,
+ * case 13); an edge inside a range shows the cells' own sides.
+ *
+ * `change` names only the parts the user touched, so OK leaves every other part as each cell has it; with
+ * nothing touched it is empty, and OK sets nothing. An edge shown from a neighbour and left alone writes nothing;
+ * taken away, it is cleared on both sides, as clearing an edge is (SH-45; the seventeenth Windows run, h10). A
+ * choice that cannot be set — a Custom code ExSheet does not read, More Colours text that is not a colour — is
+ * held as `refusal`, by name, and OK sets nothing until it is put right.
+ */
+export declare class FormatCellsDraft {
+    #private;
+    /** The Focus cell's Cell Format, which Format Cells opens on. */
+    readonly opening: CellFormat;
+    /** Whether a selected range spans more than one row, so that it has an edge inside it between rows. */
+    readonly hasInsideHorizontal: boolean;
+    /** Whether a selected range spans more than one column, so that it has an edge inside it between columns. */
+    readonly hasInsideVertical: boolean;
+    private constructor();
+    /**
+     * Format Cells' draft over the ranges, opening on the Focus cell (ADR-0071): what differs across the ranges is
+     * read from what the Sheet records (`Sheet.getCellFormats`), so a Selection of whole columns opens as quickly
+     * as one cell.
+     */
+    static open(sheet: Sheet, focus: CellAddress, ranges: readonly CellRange[]): FormatCellsDraft;
+    /** The Number Format category chosen. */
+    get category(): NumberFormatCategory;
+    /** The decimal places, under Number, Currency, Percentage and Scientific. */
+    get decimalPlaces(): number;
+    /** Whether Number groups thousands. */
+    get thousandsSeparator(): boolean;
+    /** Which of `negativeNumbers` is chosen. */
+    get negativeNumber(): number;
+    /** The Date or Time format chosen, or the Custom code as typed; empty under any other category. */
+    get typeCode(): string;
+    /** The ways a negative number shows under the chosen category, each as its code. */
+    get negativeNumbers(): readonly string[];
+    /** The formats the chosen category lists: Date's, Time's, or the codes Custom starts from. */
+    get types(): readonly string[];
+    /** The Sheet culture's currency symbol, which Currency writes. */
+    get currencySymbol(): string;
+    /** Whether the chosen category takes decimal places. */
+    get takesDecimalPlaces(): boolean;
+    /**
+     * The code the Number tab shows now. Under Custom it is the code as typed, which is read as the Sheet's culture
+     * spells codes (`NumberFormat.tryParseLocal`): a built-in only where it spells that built-in's code under the
+     * culture (the fourteenth Windows run, case 11).
+     */
+    get numberFormatCode(): string;
+    /** Why the Number tab's code cannot be set, or `undefined` when it can. */
+    get numberFormatRefusal(): FormatCellsRefusal | undefined;
+    /**
+     * Chooses a category, with its options as they opened when it is the one the Focus cell's code is, and the
+     * category's defaults otherwise. A category shown disabled is refused, with its reason.
+     */
+    selectCategory(category: NumberFormatCategory): void;
+    /** Sets the decimal places, 0 to 30. */
+    setDecimalPlaces(places: number): void;
+    /** Sets whether Number groups thousands. */
+    setThousandsSeparator(separator: boolean): void;
+    /** Chooses one of `negativeNumbers`. */
+    setNegativeNumber(index: number): void;
+    /** Chooses a Date or Time format, or types the Custom code. */
+    setType(code: string): void;
+    /** The horizontal alignment. */
+    get alignment(): HorizontalAlignment;
+    /** Sets the horizontal alignment. */
+    setAlignment(alignment: HorizontalAlignment): void;
+    /** The Font style; `undefined`, shown empty, while bold or italic differs across the Selection. */
+    get fontStyle(): FontStyle | undefined;
+    /** Whether the text is underlined. */
+    get underline(): boolean;
+    /** Whether the text is struck through. */
+    get strikethrough(): boolean;
+    /** The Font's colour; Automatic is the Ink. */
+    get fontColour(): CellColour;
+    /** Sets the Font style: bold and italic together. */
+    setFontStyle(style: FontStyle): void;
+    /** Sets the single underline on or off. */
+    setUnderline(underline: boolean): void;
+    /** Sets strikethrough on or off. */
+    setStrikethrough(strikethrough: boolean): void;
+    /** Sets the Font's colour: Automatic, or a colour of the palette or More Colours. */
+    setFontColour(colour: CellColour): void;
+    /**
+     * Whether the Font is Excel's Normal font as ExSheet has it — the colour Automatic, and neither bold, italic,
+     * underline nor strikethrough — which the Font tab's Normal font box shows checked (ADR-0071, 2026-10-02).
+     * False while bold or italic differs across the Selection.
+     */
+    get isNormalFont(): boolean;
+    /**
+     * The Font tab's Normal font box, checked (ADR-0071, 2026-10-02): every part of the Font set to its default and
+     * touched, so OK records them on each selected cell over a row's or a column's Font, as Excel writes its Normal
+     * style's font. ExSheet has no Normal style: a typeface and a size stay out.
+     */
+    setNormalFont(): void;
+    /** The Fill; No Colour while the Fill differs across the Selection. */
+    get fill(): CellFill;
+    /** Sets the Fill: No Colour, or a colour of the palette or More Colours. */
+    setFill(fill: CellFill): void;
+    /**
+     * The line style an edge or a preset sets. Format Cells opens on the line an outer edge shows, and on Thin
+     * where none shows one (`openingPen`).
+     */
+    get lineStyle(): BorderLineStyle;
+    /** The line colour an edge or a preset sets: the colour of the line the style opens on, else Automatic. */
+    get lineColour(): CellColour;
+    /** Chooses the line style. */
+    setLineStyle(style: BorderLineStyle): void;
+    /** Chooses the line colour. */
+    setLineColour(colour: CellColour): void;
+    /** The line on an edge; `undefined`, drawn as a grey dotted line, while it differs across the Selection. */
+    edgeLine(edge: BorderEdge): BorderLine | undefined;
+    /** Whether an edge can be set: an edge inside the range only where a range has more than one row or column. */
+    canSet(edge: BorderEdge): boolean;
+    /** Whether a preset is offered: Inside only where a range has an edge inside it. */
+    canApply(preset: BorderPreset): boolean;
+    /**
+     * An edge's button, as Excel's: an edge that shows the chosen line loses it, and any other takes it. A line
+     * style of None takes the line away. An edge that cannot be set for this Selection is refused.
+     */
+    toggleEdge(edge: BorderEdge): void;
+    /** A preset: None takes every line of the range away; Outline and Inside set the chosen line there. Inside,
+     * where no selected range has an edge inside it, is refused. */
+    applyPreset(preset: BorderPreset): void;
+    /** The colour a palette shows chosen for a target: the Font's or the Border's, Automatic among them, or the Fill's,
+     * `undefined` for No Colour. */
+    colourOf(target: ColourTarget): CellColour | undefined;
+    /** Chooses a palette's colour for a target: `undefined` is a palette's first choice, Automatic for the Font and the
+     * Border, and No Colour for the Fill. */
+    setColour(target: ColourTarget, colour: CellColour | undefined): void;
+    /** The text typed under More Colours for a colour, or empty. */
+    colourText(target: ColourTarget): string;
+    /**
+     * Reads text typed under More Colours: `#` and six hex digits, such as `#1F4E79`, sets the colour for the
+     * target. Any other text stands as a `refusal` until it is corrected, cleared, or a colour is chosen from the
+     * palette.
+     */
+    setColourText(target: ColourTarget, text: string): void;
+    /** A colour written `#RRGGBB`, or `RRGGBB`, in either case; `undefined` for any other text. */
+    static tryReadHex(text: string): CellColour | undefined;
+    /**
+     * Why OK cannot set what Format Cells shows, by name, or `undefined` when it can: a Custom code ExSheet does
+     * not read, or More Colours text that is not a colour. `SheetWords.formatCellsRefusal` words it.
+     */
+    get refusal(): FormatCellsRefusal | undefined;
+    /** Whether the user has touched anything that OK would set. */
+    get isTouched(): boolean;
+    /** The parts the user touched, as one change; empty when nothing was. */
+    get change(): CellFormatChange;
+}
+
+/**
+ * A label of Format Cells' own under the built-in Chrome (ADR-0071): its legends, fields and buttons, worded by
+ * {@link SheetWords.formatCellsLabel}.
+ */
+export declare type FormatCellsLabel = 'tabs' | 'category' | 'generalHint' | 'textHint' | 'decimalPlaces' | 'thousandsSeparator' | 'negativeNumbers' | 'type' | 'codes' | 'horizontal' | 'fontStyle' | 'underline' | 'underlineNone' | 'underlineSingle' | 'strikethrough' | 'normalFont' | 'colour' | 'lineStyle' | 'presets' | 'border' | 'preview' | 'backgroundColour' | 'automatic' | 'noColour' | 'moreColours' | 'ok' | 'cancel';
+
+/**
+ * A line style's stroke width and dashes, as Format Cells' Border tab pictures it in an SVG (ADR-0071): only a picture
+ * of the style, which a Chrome's Format Cells draws too; how a Border is painted on the Sheet is the grid's. `double`
+ * is two strokes of the width given, and `none` is none.
+ */
+export declare function formatCellsLineStroke(style: BorderLineStyle): {
+    readonly width: string;
+    readonly dashes: string | undefined;
+};
+
+/** What Format Cells offers, in Excel's order (ADR-0071; the eleventh Windows run, cases 22 and 23). */
+export declare const formatCellsOffer: Readonly<{
+    /** The tabs, in Excel's order. */
+    tabs: readonly FormatCellsTab[];
+    /** The Number tab's categories, in Excel's order, each available or disabled. */
+    categories: readonly NumberFormatCategoryOffer[];
+    /** The Alignment tab's horizontal alignments, as Excel lists them. */
+    alignments: readonly HorizontalAlignment[];
+    /** The Font tab's styles, as Excel lists them. */
+    fontStyles: readonly FontStyle[];
+    /**
+     * The Border tab's line styles in Excel's two columns, each from the top: None, Hair, Dotted, Dash-dot-dot,
+     * Dash-dot, Dashed and Thin; then Medium Dash-dot-dot, Slanted Dash-dot, Medium Dash-dot, Medium Dashed,
+     * Medium, Thick and Double (case 22).
+     */
+    lineStyleColumns: readonly (readonly BorderLineStyle[])[];
+    /** The Border tab's presets, in Excel's order. */
+    presets: readonly BorderPreset[];
+    /** The Border tab's edges, in Excel's order, without its diagonals (ADR-0071). */
+    edges: readonly BorderEdge[];
+    /**
+     * The Office theme's colours (case 23): ten across, in six rows — the theme colours, then five rows of their
+     * tints and shades. Each records the RGB value Excel names it with in Format Cells' Fill tab; the two named
+     * "Grey" are `#7F7F7F`.
+     */
+    themeColours: readonly (readonly PaletteSwatch[])[];
+    /** Excel's ten standard colours (case 23). */
+    standardColours: readonly PaletteSwatch[];
+}>;
+
+/** Why Format Cells' OK cannot set what it shows, by name (ADR-0071), worded by {@link SheetWords.formatCellsRefusal}. */
+export declare type FormatCellsRefusal = {
+    readonly kind: 'noNumberFormatCode';
+} | {
+    readonly kind: 'numberFormatNotRead';
+    readonly code: string;
+    readonly reason: string;
+} | {
+    readonly kind: 'notAColour';
+    readonly target: ColourTarget;
+    readonly text: string;
+};
+
+/** Format Cells' tabs, in Excel's order: five of Excel's six, Protection left out (ADR-0071). */
+export declare type FormatCellsTab = 'number' | 'alignment' | 'font' | 'border' | 'fill';
+
+export { GridPointArrow }
+
+export { GridPointDashes }
+
+export { GridPointedAt }
+
+export { GridPointedPress }
+
+export { GridPointedPressKind }
+
+export { GridPointedStep }
+
+export { GridPointedStepKind }
+
+/** Whether a category is one Format Cells shows disabled. */
+export declare function isDisabledCategory(category: NumberFormatCategory): category is DisabledNumberFormatCategory;
+
+/** A Linked Table column a Formula edited in a Sheet reads, and the colour its References wear (ADR-0057). */
+export declare interface LinkedColumnColour {
+    /** The table and column. */
+    readonly column: LinkedTableColumn;
+    /** The colour. */
+    readonly colour: ReferenceColour;
+}
+
+/** The most decimal places Excel's spinner offers. */
+export declare const mostDecimalPlaces = 30;
+
+/** A place the Name Box reads: a range, and the name of the Sheet it is on when one was typed before it. */
+export declare interface NameBoxPlace {
+    /** The Sheet's name as typed, a quoted one unquoted; `undefined` when none was typed, and the range is then
+     * on the Sheet shown. */
+    readonly sheet: string | undefined;
+    /** The range. */
+    readonly range: CellRange;
+}
+
+/** The Number category's code. */
+export declare function numberCode(places: number, separator: boolean, negative: number): string;
+
+/**
+ * The Number tab's categories, in Excel's order (ADR-0071; the eleventh Windows run, case 22). Accounting,
+ * Fraction and Special are offered disabled ({@link DisabledNumberFormatCategory}).
+ */
+export declare type NumberFormatCategory = 'general' | 'number' | 'currency' | 'accounting' | 'date' | 'time' | 'percentage' | 'fraction' | 'scientific' | 'text' | 'special' | 'custom';
+
+/** A Number Format category as Format Cells offers it: available, or shown disabled with its reason. */
+export declare interface NumberFormatCategoryOffer {
+    /** The category. */
+    readonly category: NumberFormatCategory;
+    /** Whether it can be chosen; one that cannot is shown with {@link SheetWords.categoryDisabled}'s reason. */
+    readonly enabled: boolean;
+}
+
+/** How many ways a negative number shows under Number: `-1234.10`, in red, in brackets, in red brackets. */
+export declare const numberNegativeStyles = 4;
+
+/** A grid column outlined in a Reference colour while a Formula reads it (ADR-0057): the grid's own
+ * `outlinedColumns` entry. */
+export declare type OutlinedColumn = GridOutlinedColumn;
+
+/**
+ * One colour of the palette, with what Excel names it (ADR-0071; the eleventh Windows run, case 23): a theme
+ * colour, with its step for a tint or a shade, or a standard colour. Its words are
+ * {@link SheetWords.swatchName}'s.
+ */
+export declare interface PaletteSwatch {
+    /** The RGB value Excel names it with in Format Cells' Fill tab, not the colour sampled from the screen. */
+    readonly colour: CellColour;
+    /** The colour's name: a theme colour's column, or a standard colour. */
+    readonly name: ThemeColourName | StandardColourName;
+    /** The tint or the shade of a theme colour, or `undefined` for the colour itself and a standard colour. */
+    readonly step: SwatchStep | undefined;
+}
+
+/** The Percentage category's code. */
+export declare function percentageCode(places: number): string;
+
+export { PointedAtGrid }
+
+/** A press on a grid of a Pointing Scope that wrote nothing, and why (ADR-0058). The text of the Formula being
+ * edited is as it was before the press. */
+export declare interface PointingRefusal {
+    /** Which refusal. */
+    readonly reason: PointingRefusalReason;
+    /** The refusal in words, for the user, naming the table and the column where they are known. */
+    readonly message: string;
+}
+
+/**
+ * Why a press on a grid of a Pointing Scope, or an arrow key after one, wrote nothing into the Formula being
+ * edited (ADR-0058):
+ *
+ * - `severalCells`: more than one cell — a Shift+press, a press on a Row Heading or on the corner, a drag that
+ *   reached another cell, or Shift and an arrow key after a press. A drag takes back what its press wrote.
+ * - `severalColumns`: more than one column — a Shift+press on a header, or a drag across headers. A drag takes
+ *   back what its press wrote.
+ * - `headerGroup`: a Header Group's rectangle, which stands over several columns (ADR-0032).
+ * - `columnNotInTable`: a column the Linked Table does not have.
+ * - `noKey`: a cell of a table declared without a key, whose row no Formula can name.
+ * - `blankKey`: a cell whose row has a blank key.
+ * - `keyIsAnError`: a cell whose row holds an Error Value as its key, which no lookup finds.
+ * - `rowNotArrived`: a cell whose row has not arrived yet; an arrow key that reaches one moves nothing.
+ * - `tableNotDeclared`: the Sheet that points declares no Linked Table by the grid's table's name.
+ * - `notPointing`: the press arrived after the Sheet stopped pointing.
+ * - `dataEdge`: Ctrl+arrow after a press; where the data ends is not known to a grid that holds only the rows
+ *   near those it shows (ADR-0058, "The keyboard").
+ * - `cellNotHeld`: an arrow key after a press, when the grid no longer holds the cell, or shows the column,
+ *   pointed at.
+ */
+export declare type PointingRefusalReason = 'severalCells' | 'severalColumns' | 'headerGroup' | 'columnNotInTable' | 'noKey' | 'blankKey' | 'keyIsAnError' | 'rowNotArrived' | 'tableNotDeclared' | 'notPointing' | 'dataEdge' | 'cellNotHeld';
+
+/** Where a refused press on a grid of a Pointing Scope is worded otherwise than by its reason alone: a drag
+ * that took back what its press wrote, and a column the grid no longer shows (ADR-0058). */
+export declare type PointingRefusalWordCase = PointingRefusalReason | 'severalCellsTakenBack' | 'severalColumnsTakenBack' | 'columnNotHeld';
+
+/**
+ * A Pointing Scope (ADR-0058): the Sheets and the grids a Consumer groups so that a Formula edited in one of the
+ * Sheets can point at the grids' cells. Pointing at a grid of the Scope writes what reads the pressed cell by its
+ * row's key, `XLOOKUP("R-4471", Positions[Id], Positions[PV])`, or the pressed column's structured reference,
+ * `Positions[PV]` — never a position, so the Formula reads the same row after the grid is sorted (ADR-0049,
+ * rule 2).
+ *
+ * The Consumer makes one per group and registers each grid that shows a Linked Table with
+ * {@link PointingScope.registerGrid}. A Sheet of the Scope joins it, says whether it points, tells the columns
+ * its Formula reads and where its edit stands with respect to Point, and hands over its arrow keys; the Scope
+ * writes into the Sheet that points, or tells it why a press wrote nothing. Only the Sheet that holds the
+ * keyboard points, and a Sheet is never pointed at.
+ */
+export declare class PointingScope {
+    #private;
+    /** A Scope whose refusals are worded by `words`: ExSheet's English unless a Consumer's words are given. */
+    constructor(words?: SheetWords);
+    /**
+     * Registers a grid that shows a Linked Table, and gives back the declaration to pass it (ADR-0058).
+     *
+     * @param table - The Linked Table's name, as the Sheets declare it; matched without regard to case.
+     * @param tableRow - A grid row as the table's row: one Value per declared column, in the declared order, a
+     *   blank as `undefined`. Asked for a pressed cell's row and, while that cell is dashed, for the rows the grid
+     *   paints: it must be cheap and must not throw.
+     * @param tableColumns - Which table column each grid column is, by the grid column's name, for the grid
+     *   columns named otherwise than their table column. A grid column with no entry is the table column of its
+     *   own name, if the table has one.
+     * @throws RangeError when the table's name is empty, or an entry of `tableColumns` names no column.
+     */
+    registerGrid<TRow>(table: string, tableRow: (row: TRow) => TableRow, tableColumns?: Readonly<Record<string, string>>): GridPointedAt<TRow>;
+    /** A Sheet given this Scope joins it. */
+    join(sheet: PointingSheet): void;
+    /** A Sheet no longer given this Scope, or disposed, leaves it; if it pointed, no grid is pointed at. */
+    leave(sheet: PointingSheet): void;
+    /** A Sheet of the Scope says whether it points: it holds the keyboard, has an edit open, and is in Point. A
+     * Sheet that stops pointing after another started changes nothing. */
+    points(sheet: PointingSheet, points: boolean): void;
+    /** A Sheet of the Scope tells the Linked Table columns the Formula it edits reads, and their colours, or none
+     * once the edit ends (ADR-0057); each registered grid outlines those of its table, whether or not the Sheet
+     * points. */
+    outlineLinkedColumns(sheet: PointingSheet, columns: readonly LinkedColumnColour[]): void;
+    /** A Sheet of the Scope tells where its edit stands with respect to Point. Anything but `writtenFromOutside`
+     * means Point over what a press wrote has ended, and its dashes go (ADR-0058, "What is drawn"). */
+    pointStateChanged(sheet: PointingSheet, state: PointState): void;
+    /**
+     * An arrow key in a Sheet of the Scope while what a press on a registered grid wrote stands in its edit
+     * (ADR-0058, "The keyboard"): the cell or the column that press wrote for moves one step inside that grid,
+     * and the text is rewritten for what it reached. At an edge nothing moves; a row that has not arrived, Shift
+     * and an arrow, and the Primary Modifier and an arrow write nothing, and the reason is told.
+     */
+    pointArrow(sheet: PointingSheet, arrow: GridPointArrow): Promise<void>;
+}
+
+/** What a Pointing Scope asks of a Sheet in it (ADR-0058): its own declarations, to read a table's columns and
+ * key from, and its edit, to write into. */
+export declare interface PointingSheet {
+    /** The Linked Tables the Sheet declares, keys included. */
+    readonly linkedTables: readonly LinkedTable[];
+    /** The id of the root of the Sheet's grid; `undefined` before it is rendered. */
+    readonly rootId: string | undefined;
+    /** Writes text into the Sheet's open edit where Point writes; false when it is no longer in Point. */
+    writePointedText(text: string): Promise<boolean>;
+    /** Takes back what the last write put there, while it stands. */
+    takeBackPointedText(): Promise<boolean>;
+    /** Tells the Sheet's Consumer why a press wrote nothing. */
+    tellPointingRefused(refusal: PointingRefusal): Promise<void>;
+}
+
+/**
+ * Where an open edit stands with respect to Point (ADR-0051, ADR-0058): `none`, no Reference can go at the
+ * caret; `inPoint`, one can; `writtenFromOutside`, what stands at the caret was written by a press outside the
+ * grid.
+ */
+export declare type PointState = GridPointState;
+
+/**
+ * Reads what was typed as a range, with the name of the Sheet it is on when one is typed before it; `undefined`
+ * when it is not a place. A name in quotes doubles a quote inside it, as a Reference writes one.
+ */
+export declare function readNameBoxPlace(typed: string): NameBoxPlace | undefined;
+
+/** Reads what was typed as a range of the Sheet, or `undefined` when it is not one. */
+export declare function readNameBoxRange(typed: string): CellRange | undefined;
+
+/** What a category shows a code as when Format Cells opens on it. */
+export declare interface RecognisedNumberFormat {
+    /** The category that writes the code. */
+    readonly category: NumberFormatCategory;
+    /** Its decimal places, 2 where the category takes none. */
+    readonly places: number;
+    /** Whether Number groups thousands. */
+    readonly separator: boolean;
+    /** Which negative style. */
+    readonly negative: number;
+    /** The code as the category shows it: a Date's or a Time's as listed, a Custom code as the culture spells
+     * it, any other as written. */
+    readonly type: string;
+}
+
+/**
+ * The category, and its options, that writes the format's code exactly; Custom when none does, with the code as
+ * the culture spells it (`NumberFormat.localCode`), which the Custom box reads back as the same format (the
+ * fourteenth Windows run, case 11).
+ */
+export declare function recogniseNumberFormat(format: NumberFormat, culture: Culture): RecognisedNumberFormat;
+
+export { ReferenceColour }
+
+/** The Scientific category's code. */
+export declare function scientificCode(places: number): string;
+
+/**
+ * The Sheet's Chrome slots (ADR-0390), the C# `ISheetChrome`'s, each a mount function the Sheet calls with the slot's
+ * element and what the slot is handed. A slot not given is drawn by the built-in Chrome. As `ISheetChrome` extends
+ * `IGridChrome`, the grid's own slots are among them, and the Sheet hands those to its grid: the Cell Editor, the
+ * Formula Bar's fields, the completion list, the find panel, the Context Menu, a cell's message and the Selection
+ * Summary. The column menu and the filter panel are taken too, and never shown, since a Sheet's columns have no menu.
+ */
+export declare interface SheetChrome extends GridChrome<unknown> {
+    /** Each Toolbar Item of the Sheet Toolbar (ADR-0100): a mount that answers `undefined` leaves the item to the
+     * built-in Chrome, as the C# Chrome's `ToolbarItem` answering null does. */
+    readonly toolbarItem?: SheetToolbarItemSlot;
+    /** Format Cells' contents (ADR-0071), in the grid's popover frame. */
+    readonly formatCells?: SheetFormatCellsSlot;
+    /** Each Sheet Tab's face (ADR-0331 §4). */
+    readonly sheetTab?: SheetTabSlot;
+    /** The face of the button that adds a Sheet (ADR-0331 §4). */
+    readonly sheetTabAdd?: SheetTabAddSlot;
+}
+
+/** The ids of the commands ExSheet adds to the grid's Context Menu, as C#'s SheetCommandIds spells them. */
+export declare const sheetCommandIds: Readonly<Record<SheetContextCommand, string>>;
+
+/** One of ExSheet's own Context Menu commands (ADR-0036). */
+export declare type SheetContextCommand = 'insertRows' | 'deleteRows' | 'insertColumns' | 'deleteColumns' | 'formatCells';
+
+/** The index of a Sheet's filled cells, which answers where Ctrl+arrow stops (ADR-0050, item 2). */
+export declare class SheetEdges {
+    #private;
+    /** The index of every filled cell of the Sheet. */
+    static of(sheet: Sheet): SheetEdges;
+    /**
+     * Brings the index up to date after a change the Sheet reported. Every cell that became filled or blank is
+     * among the change's Value changes: a blank cell has no Value and a filled one has one.
+     */
+    update(sheet: Sheet, change: SheetChange): void;
+    /** The cell Ctrl+arrow reaches from `from` in the direction, on a Sheet of `size`, whose edge it stops at (ADR-0460). */
+    find(from: CellAddress, direction: GridDirection, size?: SheetSize): CellAddress;
+}
+
+/** The ids of the words the Sheet's find panel adds to the grid's, as C#'s SheetFindLabelIds spells them: a
+ * Consumer's `commandLabel` answers them as it answers the grid's. */
+export declare const sheetFindLabelIds: Readonly<{
+    /** The label of the Within choice. */
+    readonly within: 'exsheet.find-within';
+    /** Within: the Sheet shown. */
+    readonly withinSheet: 'exsheet.find-within-sheet';
+    /** Within: the Workbook. */
+    readonly withinWorkbook: 'exsheet.find-within-workbook';
+}>;
+
+/** Where the Sheet's find panel searches (ADR-0332 §5): the Sheet shown, or every Sheet of the Workbook. */
+export declare type SheetFindWithin = 'sheet' | 'workbook';
+
+/** The words the Sheet's find panel adds to the grid's (ADR-0332 §5): the Within choice and its two answers. */
+export declare type SheetFindWithinWord = 'within' | 'withinSheet' | 'withinWorkbook';
+
+/**
+ * Format Cells' slot (ADR-0390): mounts the contents into `slot`, which stands in the grid's popover frame, and
+ * answers the function that takes them away, called however Format Cells closes. Asked once per opening.
+ */
+export declare type SheetFormatCellsSlot = (slot: HTMLElement, context: SheetFormatCellsSlotContext) => () => void;
+
+/**
+ * What Format Cells' contents are handed (ADR-0071, ADR-0390), once per opening. The contents stand in the grid's
+ * popover frame, as the built-in Format Cells does: where it stands, Escape, a press elsewhere, Tab wrapping inside
+ * it and the keyboard back on the grid as it closes are the grid's (ADR-0050 item 16), so the frame is never the
+ * Chrome's own dialog under TypeScript. The contents draw the tabs and their controls from `formatCellsOffer` and
+ * `draft`, set every choice through `draft`, and call `ok` or `cancel`.
+ */
+export declare interface SheetFormatCellsSlotContext {
+    /** What Format Cells opens on, the Focus cell's Cell Format with the parts that differ across the Selection shown
+     * as Excel shows them, and what the user has touched. Every control is set through it, so what a choice means is
+     * the Sheet's under every Chrome. */
+    readonly draft: FormatCellsDraft;
+    /** The tab to open on: the one shown last in this Sheet. */
+    readonly tab: FormatCellsTab;
+    /** Hears each tab the contents show, so the next opening shows it again, as Excel's does. */
+    readonly tabShown: (tab: FormatCellsTab) => void;
+    /** Sets the parts the user touched on the Selection Format Cells was opened over, as one undo step, and closes it:
+     * `true`. `false` while the draft holds a refusal, which the contents show in the Sheet's words
+     * (`words.formatCellsRefusal(draft.refusal)`), and Format Cells stays open. */
+    readonly ok: () => boolean;
+    /** Sets nothing, and closes Format Cells. */
+    readonly cancel: () => void;
+    /** The Sheet's words, its Japanese or its English and the Consumer's label over either: the tabs' names, the
+     * fields' labels, OK and Cancel, a refusal. */
+    readonly words: SheetWords;
+    /** Gives the keyboard, which the frame holds while the contents are being drawn, to a control they drew: the tab
+     * shown, as the opening asks. Granted only while the keyboard is still the grid's, so a press the user made
+     * meanwhile keeps it where it put it. */
+    readonly takeKeyboard: (control: HTMLElement) => void;
+    /** The contents report a popup of their own opening (`true`) and closing (`false`): while one is open, Escape is
+     * the popup's, not the frame's (ADR-0039). */
+    readonly innerPopupChanged: (open: boolean) => void;
+}
+
+/**
+ * What a key sets on the Selection, under the Sheet's culture (cases 16 to 20). A toggle's direction is the
+ * Focus cell's (case 17): over a Focus that is bold, Ctrl+B takes bold off every cell, and otherwise puts it on
+ * every cell. The Number Formats are the ones Excel applied under en-GB, en-US and ja-JP alike, but for two: the
+ * time is 12-hour where the culture's own time is (`h:mm AM/PM` under en-US, `h:mm` under en-GB and ja-JP), and
+ * the currency is Excel's built-in, shown in the culture's own currency (`NumberFormat.builtInCurrency`). The
+ * date and the time are Excel's built-ins 15 and 20 (or the AM/PM one), recorded in their codes and shown in the
+ * culture's own form, as Excel shows them (the twelfth run, case 19). A Number Format widens the columns it no
+ * longer fits, as every Number Format set on the Selection does (case 17), and so do strikethrough and underline
+ * (`widensAsAKeyDoes`). The outline is thin and Automatic on each range's four edges; no borders clears every
+ * edge of each range. Ctrl+1 sets nothing, and is refused here.
+ */
+export declare function sheetFormatChangeFor(kind: SheetFormatKey, focus: CellFormat, culture: Culture): CellFormatChange;
+
+/** What a formatting key does. Ctrl+1 opens Format Cells (ticket 52) and sets nothing itself. */
+export declare type SheetFormatKey = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'general' | 'number' | 'time' | 'date' | 'currency' | 'percent' | 'scientific' | 'outline' | 'noBorders' | 'formatCells';
+
+/** What a declared key does; `undefined` for a key that is not one of these. */
+export declare function sheetFormatKeyOf(key: string): SheetFormatKey | undefined;
+
+/** The formatting keys ExSheet declares to its grid, in the grid's canonical form. */
+export declare function sheetFormatKeysDeclared(): readonly string[];
+
+/** A Sheet drawn into an element, handed back by {@link createSheet}. */
+export declare interface SheetHandle {
+    /** The Workbook the Sheet edits. Change it only through the Sheet, or what is shown falls behind it. */
+    readonly workbook: Workbook;
+    /** Takes the options again, whole. */
+    update(options: SheetOptions): void;
+    /** Whether there is a step to undo. */
+    readonly canUndo: boolean;
+    /** Whether there is an undone step to redo. */
+    readonly canRedo: boolean;
+    /**
+     * Whether an edit is open in the grid, from the moment a cell or the Formula Bar is typed in until the edit is
+     * committed, cancelled or discarded (ADR-0048). While it is, `do`, `undo`, `redo`, `setCellFormat` and
+     * `openFormatCells` are refused with a `SheetRefusedError`; `cellFormatAt` is a read, and answers.
+     */
+    readonly isEditing: boolean;
+    /**
+     * A Consumer command: does `edit` as one operation on the user's undo stack (ADR-0048), and raises
+     * `onWorkbookChanged`. It names no Sheet, so it is taken only while the Workbook holds one; with several it is
+     * refused, and the Sheet is named with the other form (ADR-0331 §6). It does the edit exactly as it is written, and
+     * widens no column.
+     *
+     * @throws SheetRefusedError The Sheet refuses the edit, an edit is open, or the Workbook holds several Sheets;
+     * nothing changed.
+     * @throws FormulaSyntaxError A typed Formula cannot be read; nothing changed.
+     */
+    do(edit: SheetEdit): void;
+    /**
+     * A Consumer command: does `edit` on the Sheet named `sheet`, shown or not, as one operation on the user's undo
+     * stack (ADR-0048, ADR-0331 §6). A Sheet operation — `insertSheet`, `rename`, `moveSheet`, `copySheet`,
+     * `deleteSheet` — acts on that Sheet and raises `onSheetsChanged`; the Sheet shown stays shown unless it is the one
+     * deleted, and then the Sheet that takes its place is.
+     *
+     * @throws RangeError No Sheet of the Workbook is named `sheet`; nothing changed.
+     * @throws SheetRefusedError The Sheet refuses the edit, or an edit is open; nothing changed.
+     * @throws FormulaSyntaxError A typed Formula cannot be read; nothing changed.
+     */
+    do(sheet: string, edit: SheetEdit): void;
+    /**
+     * Sets the parts of a Cell Format that `change` names on the Selection the grid holds now, as one operation on the
+     * undo stack (ADR-0071, ADR-0048): every part it does not name stays as each cell has it. A Selection of whole
+     * columns or rows sets it on the columns or rows, and the change's Borders are relative to each range. It widens
+     * as the formatting keys do: a Number Format, underline or strikethrough widens each column whose numbers it no
+     * longer fits and the user has not sized, in the same operation. Answers false when nothing is selected.
+     *
+     * @throws RangeError The change sets no part of a Cell Format.
+     * @throws SheetRefusedError An edit is open; nothing changed.
+     */
+    setCellFormat(change: CellFormatChange): boolean;
+    /**
+     * Sets on the Selection a change made from the Focus cell's Cell Format as it shows now, as a toggle key reads it
+     * (ADR-0071, ADR-0100): Bold on over a Focus cell that is not bold, off over one that is. It widens as Excel's Home
+     * tab buttons do: as the formatting keys do, and for a Font colour too. Otherwise it acts, refuses and answers as
+     * `setCellFormat`; false when nothing is selected, and then `changeOf` is not called.
+     *
+     * @throws RangeError The change it makes sets no part of a Cell Format.
+     * @throws SheetRefusedError An edit is open; nothing changed.
+     */
+    setCellFormatFromFocus(changeOf: (focus: CellFormat) => CellFormatChange): boolean;
+    /**
+     * The Focus cell's Cell Format as it shows now, read for a change made from it away from the Sheet, over a round
+     * trip, and set with `setCellFormatFrom` (ADR-0100); undefined when nothing is selected. It is read for a change,
+     * so it is refused while an edit is open, before the change is made.
+     *
+     * @throws SheetRefusedError An edit is open.
+     */
+    readFocusFormat(): FocusFormatReading | undefined;
+    /**
+     * Sets `change`, made from `reading`, on the Selection, as `setCellFormatFromFocus` sets the change it makes: only
+     * while the Selection, the Sheet shown and the Focus cell's Cell Format are what `reading` was read from.
+     * Otherwise the change would be set on cells it was not made for, or undo what it was made to do, so it is refused,
+     * and the notice says so (ADR-0100, decided 2026-10-28). A reading is taken by its set, whatever comes of it.
+     *
+     * @throws TypeError `reading` was not read from this Sheet, or was set already.
+     * @throws RangeError The change sets no part of a Cell Format.
+     * @throws SheetRefusedError An edit is open; the Selection or the Sheet shown moved (`selectionMoved`); the Focus
+     * cell's Cell Format changed (`focusFormatChanged`). Nothing changed.
+     */
+    setCellFormatFrom(reading: FocusFormatReading, change: CellFormatChange): boolean;
+    /**
+     * Opens Format Cells over the Selection the grid holds now, from the Consumer's own button (ADR-0071): on the Focus
+     * cell's Cell Format, and on the tab shown last. OK sets the parts the user touched as one undo step; Cancel or
+     * Escape sets nothing. Opening it again while it stands opens it afresh. Answers false when nothing is selected.
+     *
+     * @throws SheetRefusedError An edit is open; nothing opened.
+     */
+    openFormatCells(): boolean;
+    /**
+     * The Cell Format of the cell at `address` as it shows (ADR-0071): each part the cell's own, else its row's, else
+     * its column's, else the default. It names no Sheet, so it is read only while the Workbook holds one; with several,
+     * name the Sheet with the other form (ADR-0331 §6).
+     *
+     * @throws SheetRefusedError The Workbook holds several Sheets.
+     */
+    cellFormatAt(address: CellAddress): CellFormat;
+    /**
+     * The Cell Format of the cell at `address` on the Sheet named `sheet`, shown or not, as it shows.
+     *
+     * @throws RangeError No Sheet of the Workbook is named `sheet`.
+     */
+    cellFormatAt(sheet: string, address: CellAddress): CellFormat;
+    /** Undoes the latest operation; false when there is none, which the notice says. */
+    undo(): boolean;
+    /** Redoes the latest operation undone; false when there is none, which the notice says. */
+    redo(): boolean;
+    /**
+     * Declares a Linked Table Formulas read by name, as `ExSheet.DeclareLinkedTableAsync` does (ADR-0049): its readers
+     * show `#GETTING_DATA` until a snapshot is pushed. The declaration is recorded in the document, so
+     * `onWorkbookChanged` hears it when it changes what was declared; declaring the same table again changes nothing.
+     * It is the Consumer's data, not a user's operation, so it is no step on the undo stack. `key` names the column, or
+     * the columns, a row is read by.
+     */
+    declareLinkedTable(name: string, columns: readonly string[], key?: string | readonly string[]): void;
+    /**
+     * Replaces a Linked Table's rows with a whole snapshot, in one step, as `ExSheet.PushLinkedTableAsync` does
+     * (ADR-0049): only the Formulas that read it, and what depends on them, recalculate, and only the rows whose
+     * Values changed repaint. The document never holds a table's rows, so `onWorkbookChanged` hears nothing, and
+     * nothing goes on the undo stack. A snapshot of a keyed table in which a key repeats is refused with the engine's
+     * `RepeatedKeyError`, after the table's readers show `#GETTING_DATA` again.
+     */
+    pushLinkedTable(name: string, rows: Iterable<readonly (Value | undefined)[]>): void;
+    /**
+     * Replaces the Workbook with the Workbook Document `read` answers, taken at this call's place in the Input Order
+     * (ADR-0330 §10), as `ExSheet.OpenAsync` does: the inputs made before it are taken against the Workbook they were
+     * made on, and those made after it wait until the document arrives and are then taken against the new one, or
+     * refused aloud when what they were taken against no longer holds (ADR-0142). Call it from the handler that hears
+     * the user's choice of a file, with the read still to do, such as
+     * `signal => openXlsxWorkbook(file, 'en-US', { signal }).then(read => read.document)` from `@ex-grid/sheet-xlsx`.
+     *
+     * In its turn, an edit still open refuses it by name, as a save is refused, and nothing is read: what is being typed
+     * would be thrown away. From this call until the opening ends the Sheet's grid names it in its Settled Stamp, and a
+     * plain Escape typed in the grid while it is placed aborts `read`'s signal: the Workbook stays as it was, and the
+     * notice says so; an opening cancelled before its turn ends cancelled. While the read is under way the notice says
+     * so, and the grid is busy and painted as a paste under way is. A read that fails leaves the Workbook as it was too,
+     * says so with the failure's message, and the failure is this method's. When the document arrives it replaces the
+     * whole Workbook, as a new `document` does (ADR-0048): the undo stack is cleared, the Linked Tables declared are gone
+     * with the Workbook that held them, and `onWorkbookChanged` is raised with the Workbook opened. An Escape that comes
+     * once it has landed changes nothing, and the Sheet says it came too late; one that finds the opening over otherwise
+     * says there was nothing to cancel.
+     *
+     * Only the grid's inputs wait behind it. A method the Consumer calls meanwhile is not an input and is not held:
+     * what it changes is replaced when the file lands. Once the Sheet is destroyed the signal is aborted, and nothing
+     * lands.
+     *
+     * @param read - Reads the document, looking at the signal as it goes; a read that sees it aborted rejects with the
+     *   signal's reason.
+     * @returns True once the document opened; false when Escape cancelled the read, or the Sheet was destroyed first.
+     * @throws SheetRefusedError An edit is open in the opening's turn; nothing was read.
+     * @throws Error Whatever `read` failed with, such as `XlsxOpenError`, or the engine's refusal of the document;
+     *   nothing opened. Or whatever `onWorkbookChanged` or `onSheetsChanged` failed with, once the file opened.
+     */
+    open(read: (signal: AbortSignal) => PromiseLike<WorkbookDocument>): Promise<boolean>;
+    /**
+     * Saves the Workbook at this call's place in the Input Order (ADR-0330 §10), as `ExSheet.SaveAsync` does: `write` is
+     * handed the Workbook as the inputs made before the call left it — every Sheet with its Values, its Cell Formats and
+     * widths, and the rows each Linked Table holds — such as `workbook => saveXlsxWorkbook(workbook)` from
+     * `@ex-grid/sheet-xlsx`. The Workbook is lent for that call only: read it before the call's first `await`, as
+     * `saveXlsxWorkbook` does, and never change it. The inputs made after the save are taken once `write` has returned,
+     * not once its promise settles, so a slow write holds nobody up.
+     *
+     * @returns A promise that settles once `write`'s has.
+     * @throws SheetRefusedError An edit is open: the file would quietly lack what is being typed. The Sheet says so, and
+     *   nothing was written.
+     * @throws Error Whatever `write` failed with, such as `XlsxSaveError`.
+     */
+    save(write: (workbook: Workbook) => void | PromiseLike<void>): Promise<void>;
+    /** Hands the keyboard to the Sheet's grid: to the field an open edit is typed in, else to where the grid takes keys
+     * (ADR-0080), as the grid's own `focus` does. A Consumer's control beside the Sheet gives the keyboard back with
+     * this. Throws once the Sheet is destroyed, as `holdSettled` and `inOrder` do. */
+    focus(): void;
+    /**
+     * Holds the Settled Mark of the Sheet's grid (ADR-0220) until the function it answers is called, as the grid's own
+     * `holdSettled` does: for a Framework Adapter whose Chrome's contents arrive after their slot, a round trip later on
+     * a circuit (ADR-0410 section 5), so that nothing reads the part before it stands. Each hold is let go once.
+     */
+    holdSettled(): () => void;
+    /**
+     * Runs `handling` in its place in the Input Order of the Sheet's grid (ADR-0240 section 6), as the grid's own
+     * `inOrder` does: after every input made so far, and before any made after it, which wait until the promise it
+     * answers settles. A Sheet destroyed before its turn runs nothing; one already destroyed throws. `handling` is handed
+     * its turn, through which a file is opened or saved as part of it, as the grid's turn places work.
+     */
+    inOrder(handling: (turn: SheetTurn) => void | PromiseLike<void>): Promise<void>;
+    /**
+     * Says `sentence` in the Sheet's notice, where the Sheet says its own refusals (ADR-0100): for a Framework Adapter
+     * whose Consumer's Toolbar button ran a command a round trip later that was refused, as the C# toolbar says one.
+     * Throws once the Sheet is destroyed, as `inOrder` does.
+     */
+    tell(sentence: string): void;
+    /** Stops the Sheet and empties its element. */
+    destroy(): void;
+}
+
+/** Whether there is a step to undo and one to redo, as `onHistoryChanged` hears it. */
+export declare interface SheetHistoryState {
+    /** Whether there is a step to undo. */
+    readonly canUndo: boolean;
+    /** Whether there is an undone step to redo. */
+    readonly canRedo: boolean;
+}
+
+/**
+ * A Consumer's word for an id, or `undefined` to keep ExSheet's own (its Japanese where that was chosen, else
+ * its English). `english` is the id's English as a template: where it has `{0}` (and `{1}`, `{2}`), the word
+ * answered is a template too, its arguments put in where it names them, so a language that orders them
+ * otherwise moves them.
+ */
+export declare type SheetLabel = (id: SheetWordId, english: string) => string | undefined;
+
+/** What a Sheet is drawn with. */
+export declare interface SheetOptions {
+    /** The Workbook or Sheet to open; a new Workbook of one empty Sheet unless given. A new document object opens
+     * it in place of what is shown, with nothing to undo, and `undefined` given in place of one opens an empty Sheet
+     * in `locale`; one `onWorkbookChanged` handed out, handed back as a controlled component's state is, is the
+     * Sheet's own and changes nothing. */
+    readonly document?: SheetDocument | WorkbookDocument | undefined;
+    /** The culture of a Sheet started empty: how typed constants are read and Values shown (ADR-0048). A document
+     * carries its own. The browser's language unless given; one the engine holds no data for is refused by name. */
+    readonly locale?: string;
+    /** Shows the Formula Bar and its Name Box above the columns (ADR-0051); shown unless `false`. */
+    readonly showFormulaBar?: boolean;
+    /** How many leading columns are pinned — the Sheet's frozen panes, columns only (ADR-0046). */
+    readonly pinnedColumnCount?: number;
+    /** Shows the Row Headings, the row numbers, beside the rows (ADR-0050); shown unless `false`. The Sheet still
+     * addresses `A1` without them. */
+    readonly showRowHeadings?: boolean;
+    /** Shows the Column Headings, the column letters, above the rows (ADR-0050); shown unless `false`. The Sheet
+     * still addresses `A1` without them. */
+    readonly showColumnHeadings?: boolean;
+    /** Shows the Sheet Tabs at the Sheet's foot, one per Sheet of the Workbook, as Excel does (ADR-0331); shown unless
+     * `false`. Their band, as tall as the Formula Bar, comes off `viewportHeight`. */
+    readonly showSheetTabs?: boolean;
+    /** Shows the Sheet Toolbar above the Formula Bar (ADR-0100): Excel's Home tab formatting commands, acting on this
+     * Sheet's Selection. Off unless `true`. Its band, a row as tall as the Formula Bar, comes off `viewportHeight`. */
+    readonly showToolbar?: boolean;
+    /**
+     * The Sheet Toolbar's rows, top to bottom (ADR-0100). `'default'` is ExSheet's own row, Excel's Home tab's commands,
+     * whose KeyTip is H; a row of the Consumer's holds ExSheet's items by their commands, separators and the Consumer's
+     * own buttons, in the order given. Without it the toolbar is the default row alone. Every row is as tall as the
+     * Formula Bar and comes off `viewportHeight`; what a row holds is fitted to it and clipped. KeyTips that would be
+     * taken for one another at one level, two rows' or two items' of one row, are refused.
+     */
+    readonly toolbar?: readonly (SheetToolbarRowOptions | 'default')[] | undefined;
+    /**
+     * Hears the other value of `showToolbar` when the user asks to hide or show the Sheet Toolbar with Ctrl+F1, Excel's
+     * key for the ribbon (ADR-0100). The Sheet holds nothing: whether the toolbar is shown is View State, the
+     * Consumer's, so handing the value back as `showToolbar` is what lets the key work. Without it, Ctrl+F1 is not
+     * claimed and stays the browser's.
+     */
+    readonly onShowToolbarChanged?: (shown: boolean) => void;
+    /** The parts of the Sheet a Chrome of the Consumer's, or a Wrapper's, draws in place of the built-in ones (ADR-0390). */
+    readonly chrome?: SheetChrome;
+    /** ExSheet's Japanese words in place of its English (ADR-0370, section 10), chosen in one line, never by the
+     * locale. */
+    readonly japanese?: boolean;
+    /** The Consumer's word for any id, which wins over ExSheet's own (ADR-0370, section 10). */
+    readonly label?: SheetLabel;
+    /**
+     * The Consumer's word for each of the grid's own ids, its commands and its refusals (ADR-0036, ADR-0203), handed to
+     * the Sheet's grid as its `commandLabel`: `undefined` keeps the grid's English, and the empty string silences the
+     * announcement of a refusal. The Sheet's own ids are worded through `label`.
+     */
+    readonly commandLabel?: (id: string) => string | undefined;
+    /** Shows the Selection Summary under the Sheet, as Excel's status bar does (ADR-0130); shown unless `false`.
+     * `onSelectionSummaryChanged` still hears it while hidden. */
+    readonly showSelectionSummary?: boolean;
+    /** The Selection Summary's figures, Excel's Average, Count and Sum unless given (ADR-0130). The Sheet holds the
+     * choice made in the figures menu from then on, and tells it through `onSummaryFiguresChanged`; figures handed here
+     * that differ from the ones given before replace it. */
+    readonly summaryFigures?: readonly SummaryFigure[];
+    /** Hears the figures the user chose in the figures menu, a right-click on the summary (ADR-0130). The Sheet already
+     * shows them. */
+    readonly onSummaryFiguresChanged?: (figures: readonly SummaryFigure[]) => void;
+    /** Hears the Selection Summary as it now stands (ADR-0130), for an application that shows the figures elsewhere. */
+    readonly onSelectionSummaryChanged?: (summary: SelectionSummary) => void;
+    /**
+     * Offers copy with headers in the Context Menu and by Ctrl+Shift+C, which copies the Values with the column letters
+     * as the first row (ADR-0048, ADR-0005). Off unless `true`: a Sheet's column letters are addresses, not headers, and
+     * Excel has no such command (ADR-0050 item 13), so the key is left to the page.
+     */
+    readonly allowCopyWithHeaders?: boolean;
+    /**
+     * Hears that one of Excel's formatting keys was pressed while an edit is open (ADR-0071): the key changed nothing,
+     * and the Sheet's notice says why. In that state Excel formats the selected characters, and a Cell Format is per
+     * cell. The key is still claimed, so the browser's own meaning does not run either: Ctrl+U opens no page source.
+     */
+    readonly onFormatKeyRefused?: (refusal: SheetRefusal) => void;
+    /** The grid's density (ADR-0028); a Wrapper's, then `compact`, unless given. Column widths in characters follow it. */
+    readonly density?: GridDensity;
+    /**
+     * A Wrapper's widths and Density (ADR-0030), as the grid takes them: the cells are painted in the Wrapper's font, so
+     * the Sheet's columns are measured in its characters, and the Sheet decides what fits by them (ADR-0016, ADR-0071).
+     */
+    readonly presentationDefaults?: GridPresentationDefaults;
+    /** The height of a row in pixels (ADR-0013). */
+    readonly rowHeight?: number;
+    /**
+     * How many rows and columns every Sheet holds (ADR-0460): `{ rows: 10, columns: 10 }` draws `A1:J10` and nothing
+     * past it, and `{ rows: 10 }` holds ten rows of Excel's 16,384 columns. Excel's 1,048,576 × 16,384 unless given.
+     * Every move stops at the edge, and a paste, a fill or an insertion that would put an Entry past it is refused by
+     * name, never cut; a spilled array that would pass it is `#SPILL!`. A Reference past it still reads the empty cell
+     * it names, so a Formula means what it means in Excel. A document with an Entry past it is refused when it is
+     * opened, and a smaller size handed in later that would leave one outside, or while a cell is being edited, is
+     * refused, the Sheet keeping the size it had; a smaller size taken empties the undo stack, whose steps could put an
+     * Entry back past it. The size is the screen's, not the document's: it is not saved.
+     */
+    readonly sheetSize?: SheetSizeOptions;
+    /** The grid's width: pixels, or `stretch` to fill the element's box. */
+    readonly viewportWidth?: ViewportSize;
+    /** The grid's height: pixels, or `stretch` to fill the element's box. */
+    readonly viewportHeight?: ViewportSize;
+    /** Hears the Workbook as it stands after each operation: an edit, an undo, a redo, a width. */
+    readonly onWorkbookChanged?: (document: WorkbookDocument) => void;
+    /**
+     * Hears a Sheet added, deleted, renamed, moved or copied — by a command, by the user, or by an undo or redo of
+     * one — after `onWorkbookChanged`, with the Sheets' names before and after (ADR-0331 §6). Showing another Sheet
+     * changes no Sheet, and is not heard; neither is a new document opened.
+     */
+    readonly onSheetsChanged?: (change: SheetsChange) => void;
+    /**
+     * Hears whether there is a step to undo and one to redo, each time either changes: as the operation that changed it
+     * ends, before `onWorkbookChanged` hears its document, and when a document opened empties the undo stack (ADR-0048). This is
+     * where an application greys out its own Undo and Redo, as `canUndo` and `canRedo` read the same at any time.
+     */
+    readonly onHistoryChanged?: (history: SheetHistoryState) => void;
+    /**
+     * Hears whether an edit is open, each time that changes: `true` when a cell or the Formula Bar is typed in, or
+     * opened with F2 or a double click, `false` when the edit is committed, cancelled or discarded (ADR-0048). While
+     * one is open the commands that change the Sheet are refused, so this is where an application greys out its own
+     * buttons for them, as Excel greys out its ribbon.
+     */
+    readonly onEditingChanged?: (open: boolean) => void;
+    /**
+     * Hears each Linked Table column the Formula being edited reads, and the colour its References wear in the
+     * editor (ADR-0057, ADR-0049): each column once, in order of first appearance, under the table's and the
+     * column's names as the Consumer declared them. Told once whenever that list changes and never when it does
+     * not, and with an empty list when the edit ends. A table or column not declared names nothing and is not
+     * told. The Sheet does not know where, or whether, the table is on screen, and outlines none of it itself: the
+     * Consumer hands each entry to the grid that shows the table as one of its `outlinedColumns`, the grid column
+     * that shows `column` with the same `colour`, and only it can vouch that that grid shows the rows the Formula
+     * reads.
+     */
+    readonly onLinkedColumnColoursChanged?: (columns: readonly LinkedColumnColour[]) => void;
+    /**
+     * The Pointing Scope this Sheet belongs to (ADR-0058), or none. While this Sheet holds the keyboard, has an edit
+     * open and is in Point, its caret standing where a Reference can go or what Point wrote there still standing, the
+     * grids registered in the Scope are pointed at: a press on a cell writes
+     * `XLOOKUP("R-4471", Positions[Id], Positions[PV])`, reading the cell by its row's key, where Point writes, and a
+     * press on a column header `Positions[PV]`, in the table's column names as this Sheet declares them. A further press, on a registered grid or on this Sheet, replaces what this Point
+     * wrote. A press that stands for anything else writes nothing, and is told through `onPointingRefused`. When the
+     * keyboard leaves this Sheet, no grid is pointed at, and the edit stands.
+     *
+     * After such a press F4 changes nothing, and the arrow keys point inside the grid pressed: ↑ and ↓ one row further
+     * in its current order, ← and → to the next column its table has, rewriting what this Point wrote, and the grid
+     * scrolls the cell into view. After a press on a column header, ↓ points at the column's first row, and ← and → at
+     * the next column its table has, as a column; ↑ moves nothing. The Scope also outlines, in the grids registered
+     * for their table, the Linked Table columns the Formula edited here reads, and dashes the cell or column a press
+     * wrote for until Point over what it wrote ends.
+     */
+    readonly pointingScope?: PointingScope | undefined;
+    /**
+     * Hears that a press on a grid of `pointingScope`, or an arrow key after one, wrote nothing into the Formula being
+     * edited, and why (ADR-0058): more than one cell or column, a Header Group, a column the table does not have, a
+     * table declared without a key, a blank key, a row not yet arrived. A drag that reached another cell took back
+     * what its press wrote. The Formula's text is as it was before the press or the key. The Sheet shows nothing of
+     * it itself: show the refusal's `message` where the page tells its user things.
+     */
+    readonly onPointingRefused?: (refusal: PointingRefusal) => void;
+    /** Hears the grid's Selection each time it changes, as ExGrid reports it (ADR-0011/0014): what a status line
+     * counts. The formatting commands do not wait for it: they act on the Selection the grid holds when they run. */
+    readonly onSelectionChanged?: (selection: GridSelection) => void;
+    /**
+     * A fixed Sheet Seed (ADR-0180): what `RAND()` and `RANDBETWEEN` draw from, with the Sheet, the cell, the call's
+     * place in its Formula and the count of changes since the document was opened — for a sheet that must show the
+     * same draws whenever it is opened, such as a simulation someone else reviews. The draws still change at each
+     * change of the Workbook, and never on the clock. Unless given, the Sheet chooses a seed whenever it opens a
+     * document, so a reopened sheet draws again, as Excel's reopened workbook does. An unsigned 64-bit integer; the
+     * seed is not recorded in the document.
+     */
+    readonly seed?: bigint;
+    /**
+     * A fixed Sheet Day: what `TODAY()` answers whatever the clock says (ADR-0121), for a report that must show the same
+     * day whenever it is opened. It goes before `timeZone`. Unless given, the day is the clock's in the zone, read again
+     * at midnight there, and at least once an hour.
+     */
+    readonly today?: SheetDay | undefined;
+    /**
+     * The IANA time zone whose day `TODAY()` and whose time of day `NOW()` answer (ADR-0121, ADR-0124), such as head
+     * office's for a site that keeps one business day for every user. The browser's zone unless given, as Excel takes the
+     * day on the user's own device; one the browser does not know is refused by name. A fixed `today` goes before it for
+     * `TODAY()`, not for `NOW()`, which moves on as each minute turns.
+     */
+    readonly timeZone?: string | undefined;
+}
+
+/** The Sheets' names before and after a change to the Sheets (ADR-0331 §6), in the Workbook's order. */
+export declare interface SheetsChange {
+    /** The names as they were. */
+    readonly before: readonly string[];
+    /** The names as they are now. */
+    readonly after: readonly string[];
+    /** The name of the Sheet shown after the change. */
+    readonly shown: string;
+}
+
+/** How many rows and columns every Sheet holds (ADR-0460), each from 1 to Excel's 1,048,576 rows and 16,384 columns. */
+export declare interface SheetSizeOptions {
+    /** How many rows, from 1 to 1,048,576; Excel's 1,048,576 unless given, so `{ columns: 10 }` narrows only the
+     * columns. */
+    readonly rows?: number;
+    /** How many columns, from 1 to 16,384 (`A` to `XFD`); Excel's 16,384 unless given, so `{ rows: 10 }` shortens only
+     * the rows. */
+    readonly columns?: number;
+}
+
+/**
+ * What the key does to the Selection on a Sheet of the extent: the rows a Selection of whole rows spans, or the
+ * columns a Selection of whole columns spans, inserted above or to the left, or deleted, as the Context Menu's
+ * commands do. `undefined` for every other Selection — several ranges, every cell at once, or a range that is
+ * not whole rows or whole columns — which the key refuses: Excel opens a dialog there that shifts cells, and
+ * ExSheet shifts no cells (ADR-0050 item 14).
+ */
+export declare function sheetStructureEditFor(kind: SheetStructureKey, selection: GridSelection, extent: GridExtent): SheetEdit | undefined;
+
+/** What an insert or delete key does. */
+export declare type SheetStructureKey = 'insert' | 'delete';
+
+/** What a declared key does; `undefined` for a key that is not one of these. */
+export declare function sheetStructureKeyOf(key: string): SheetStructureKey | undefined;
+
+/** The keys ExSheet declares to its grid for inserting and deleting, in the grid's canonical form. */
+export declare function sheetStructureKeysDeclared(): readonly string[];
+
+/**
+ * The selected cells of a Sheet as a Selection Summary reads them: the first refused cell in reading order and
+ * what it shows, or the cells sorted by what they are, with the Focus cell whose Number Format the figures are
+ * shown in (Excel's status bar shows them in the active cell's, read in the Windows run of 2026-10-11).
+ */
+export declare type SheetSummaryCells = {
+    readonly kind: 'refused';
+    readonly at: CellAddress;
+    readonly shown: string;
+} | {
+    readonly kind: 'cells';
+    /** Each number, a date's serial number among them, in Excel's double. */
+    readonly numbers: readonly number[];
+    /** How many cells hold an Error Value. */
+    readonly errors: number;
+    /** How many cells hold text or a Boolean. */
+    readonly others: number;
+    /** The Focus cell on the Sheet, or `undefined` where the request has none. */
+    readonly focus: CellAddress | undefined;
+};
+
+/** The cells a request names over a Sheet, as a Selection Summary reads them (ADR-0130). */
+export declare function sheetSummaryCells(sheet: Sheet, request: GridSummaryRequest): SheetSummaryCells;
+
+/** The Selection Summary declined over a refused cell, with the reason in the Sheet's words (2026-10-13,
+ * decided with the user). */
+export declare function sheetSummaryDeclined(refused: {
+    readonly at: CellAddress;
+    readonly shown: string;
+}, words: SheetWords): GridSummaryResult;
+
+/** The face of the button that adds a Sheet (ADR-0331 §4, ADR-0390), inside the button the Sheet keeps, which is
+ * named and hears the press; the face takes no keyboard and hears nothing. Mounted once. */
+export declare type SheetTabAddSlot = (slot: HTMLElement) => () => void;
+
+/** One of the commands of a Sheet Tab's menu (ADR-0331 §4), in the order the menu offers them. */
+export declare type SheetTabCommand = 'rename' | 'delete' | 'moveLeft' | 'moveRight' | 'copy';
+
+/** Excel's keys for the Sheet Tabs, in the grid's canonical form. */
+export declare const sheetTabKeys: Readonly<{
+    /** Shows the Sheet before the one shown. */
+    readonly previous: 'Control+PageUp';
+    /** Shows the Sheet after the one shown. */
+    readonly next: 'Control+PageDown';
+    /** Adds a Sheet before the one shown. */
+    readonly insert: 'Shift+F11';
+}>;
+
+/** The keys ExSheet declares to its grid for the Sheet Tabs. */
+export declare function sheetTabKeysDeclared(): readonly string[];
+
+/**
+ * A Sheet Tab's face (ADR-0331 §4, ADR-0390): mounts what stands inside the tab the Sheet keeps, which takes the
+ * keyboard, is a tab to assistive technology and hears the press. The face takes no keyboard and hears nothing. It is
+ * mounted again, on the same slot, whenever the name or `selected` changes, and answers the function that takes it
+ * away.
+ */
+export declare type SheetTabSlot = (slot: HTMLElement, context: SheetTabSlotContext) => () => void;
+
+/** What a Sheet Tab's face shows (ADR-0331 §4): the C# `SheetTabContext`. */
+export declare interface SheetTabSlotContext {
+    /** The Sheet's name, which the face shows as its only text. */
+    readonly name: string;
+    /** Whether the Sheet is the one shown. */
+    readonly selected: boolean;
+}
+
+/** How far the key moves among the Sheets: -1 or 1, or `undefined` for a key that is not one of these. */
+export declare function sheetTabStepOf(key: string): -1 | 1 | undefined;
+
+/** A preset of the Sheet Toolbar's Borders list (ADR-0100), in Excel's order. */
+export declare type SheetToolbarBorder = 'bottom' | 'top' | 'left' | 'right' | 'none' | 'all' | 'outside' | 'thickOutside';
+
+/**
+ * A Consumer's own action on the Sheet Toolbar (ADR-0100), a Toolbar Item like ExSheet's: it stands in a row of its own
+ * or among the formatting items, and while an edit is open it cannot be pressed. It carries a KeyTip only where one is
+ * given.
+ */
+export declare interface SheetToolbarButton {
+    /** Its name: the text it shows, its accessible name and its tooltip. */
+    readonly text: string;
+    /** What pressing it does. A press from the keys gives the keyboard back to the Sheet first, so what the press opens
+     * may take it. */
+    readonly onPress: () => void;
+    /** Its KeyTip letters among its row's items. */
+    readonly keyTip?: string | undefined;
+    /** Why it cannot be pressed now, shown in its tooltip; `undefined` where it can. */
+    readonly disabledReason?: string | undefined;
+    /** Its own content, such as an icon, drawn in place of its text, which still names it. Hand the same function on
+     * every update: a new one draws the content again. */
+    readonly content?: SheetToolbarContent | undefined;
+}
+
+/** A command of the Sheet Toolbar's default row (ADR-0100), in Excel's Home tab order. */
+export declare type SheetToolbarCommand = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'fontColour' | 'fill' | 'borders' | 'alignLeft' | 'alignCenter' | 'alignRight' | 'numberFormat' | 'percent' | 'comma' | 'formatCells';
+
+/**
+ * A Consumer's own content for a Toolbar Item (ADR-0100), such as an icon, drawn in place of its text: mounted into
+ * `element`, it answers the function that takes it away. The item's text still names it, as its accessible name and its
+ * tooltip. The C# `ToolbarButton`'s `ChildContent`.
+ */
+export declare type SheetToolbarContent = (element: HTMLElement) => () => void;
+
+/** One element of a Toolbar Row: one of ExSheet's own items, named by its command and carrying Excel's KeyTip; a
+ * separator between groups; or the Consumer's own button. */
+export declare type SheetToolbarEntry = SheetToolbarCommand | 'separator' | SheetToolbarButton;
+
+/** A picture the built-in Chrome draws for a Toolbar Item. */
+export declare type SheetToolbarIcon = 'bold' | 'italic' | 'underline' | 'strikethrough' | 'alignLeft' | 'alignCenter' | 'alignRight' | 'percent' | 'comma' | 'formatCells' | 'fontColour' | 'fill' | 'borders';
+
+/** One choice of a Toolbar Item's list, as the item's contents are handed it. */
+export declare interface SheetToolbarItemChoice {
+    /** Its words: a colour's name, a Number Format's category, a border preset's name. */
+    readonly label: string;
+    /** For a colour, the colour as CSS paints it: the label is its name. */
+    readonly swatch: string | undefined;
+    /** Whether it is what the Focus cell has. */
+    readonly selected: boolean;
+    /** Why it cannot be chosen, or `undefined` where it can. */
+    readonly disabledReason: string | undefined;
+}
+
+/** What a Toolbar Item is: a split control's face does what it shows and its arrow opens its list; a menu opens its
+ * list. */
+export declare type SheetToolbarItemKind = 'toggle' | 'button' | 'split' | 'menu';
+
+/**
+ * A Toolbar Item's slot (ADR-0390): mounts the item's contents in `slot` and answers the function that takes them
+ * away, or answers `undefined` and draws nothing, for the built-in Chrome to draw the item, as the C# Chrome's
+ * `ToolbarItem` answers null. Asked once per item, again only when the item's kind or the slot changes.
+ */
+export declare type SheetToolbarItemSlot = (slot: HTMLElement, context: SheetToolbarItemSlotContext) => (() => void) | undefined;
+
+/**
+ * What a Toolbar Item's contents are handed (ADR-0100, ADR-0390), once per mount: what the item is, and how it shows
+ * now through `view` and `subscribe`, as the Cell Editor's slot is. The contents draw a control in the slot that keeps
+ * the keyboard where it is on a pointer press (its `mousedown` default prevented), as the built-in items do. A control
+ * marked `data-ex-claims="click"`, as the built-in items are, has its press wait behind a commit or an opening and taken
+ * in its turn (ADR-0240); the keys typed on the toolbar wait whatever the contents are.
+ */
+export declare interface SheetToolbarItemSlotContext {
+    /** Stable for the item's place in the toolbar. */
+    readonly id: string;
+    /** What the item is, which decides whether it has a list. */
+    readonly kind: SheetToolbarItemKind;
+    /** What the item shows now. */
+    readonly view: () => SheetToolbarItemView;
+    /** Hears each change to the view; answers the function that stops hearing it. */
+    readonly subscribe: (listener: () => void) => () => void;
+    /** Presses the item as the built-in Chrome's does: a toggle or a button, a split control's face, or a menu's,
+     * which opens the built-in list. An item that cannot be pressed now does nothing. */
+    readonly invoke: () => void;
+    /**
+     * The contents' own list has closed: with the index of the choice made, or `undefined` for none, and whether
+     * Escape closed it. The keyboard goes back to the Sheet, or to the KeyTips where Escape closes a list a KeyTip
+     * opened, and the choice is then made, as the built-in list makes it. A choice that is not the list's, or one that
+     * cannot be chosen, is refused by name.
+     */
+    readonly choicesClosed: (choice: number | undefined, escaped: boolean) => void;
+}
+
+/** What a Toolbar Item shows now: read through {@link SheetToolbarItemSlotContext.view}, the same object until
+ * something in it changes. */
+export declare interface SheetToolbarItemView {
+    /** The item's name, the built-in Chrome's `aria-label`: `Fill Colour`. */
+    readonly name: string;
+    /** The name with its key, for the tooltip: `Bold (Ctrl+B)`. */
+    readonly tooltip: string;
+    /** The built-in Chrome's picture for it, or `undefined` for an item that shows its text. */
+    readonly icon: SheetToolbarIcon | undefined;
+    /** For a menu, the text its face shows: the Number Format's category; for a Consumer's button, its text, unless it
+     * has `content`. */
+    readonly text: string | undefined;
+    /** For a Consumer's button, its own content, drawn in place of its text: the contents mount it into an element of
+     * theirs, and call what it answers when they take that element away. */
+    readonly content: SheetToolbarContent | undefined;
+    /** For a colour control, the colour its face sets, as CSS paints it. */
+    readonly swatch: string | undefined;
+    /** For a split control, its arrow's name: `Borders, more`. */
+    readonly moreName: string | undefined;
+    /** For a toggle: whether the Focus cell has what it sets. */
+    readonly pressed: boolean;
+    /** Why it cannot be pressed now, or `undefined` where it can: while an edit is open, every item says so. */
+    readonly disabledReason: string | undefined;
+    /** Whether the toolbar's keyboard is on it, as the built-in Chrome outlines the item. */
+    readonly active: boolean;
+    /** For a menu or a split control, its list's choices, the Focus cell's marked; none otherwise. */
+    readonly choices: readonly SheetToolbarItemChoice[];
+    /** The count of the toolbar's requests for the list: ↓, Enter or Space on a menu, or a KeyTip. Whenever it
+     * differs from the one the contents last answered, they open their list and give it the keyboard; one they
+     * cannot open is closed at once through `choicesClosed`, choosing nothing. It starts at 0, a request not yet
+     * made. */
+    readonly openRequest: number;
+    /** Set to `openRequest` when the toolbar asks the list to close: it gives the keyboard back while the list it
+     * asked for may still be opening, or what the list was opened over has changed — the Selection moved, another
+     * Sheet shown, an operation run, the toolbar hidden — as each ends the built-in list. Where no request stood, both
+     * move on together, so a list opened by a press closes too. The contents close their list, telling nothing, and
+     * answer no `openRequest` that `closeRequest` has reached. */
+    readonly closeRequest: number;
+}
+
+/**
+ * The built-in Chrome's pictures for the Toolbar Items (ADR-0100), the C# Chrome's: each the inside of an SVG of view
+ * box `0 0 16 16`, drawn with `fill="none"` and `stroke="currentColor"`, round caps and joins, so the colour is the
+ * text's. A Chrome without pictures of its own draws these.
+ */
+export declare const sheetToolbarPictures: Readonly<Record<SheetToolbarIcon, string>>;
+
+/** A Toolbar Row of the Consumer's (ADR-0100): one band of the Sheet Toolbar, as tall as the Formula Bar. */
+export declare interface SheetToolbarRowOptions {
+    /** The row's accessible name. */
+    readonly label: string;
+    /** The row's KeyTip letters, as a ribbon tab's; a row without one is reached by Tab and the arrows only. */
+    readonly keyTip?: string | undefined;
+    /** What the row holds, in order. */
+    readonly items: readonly SheetToolbarEntry[];
+}
+
+/**
+ * The turn of work the Sheet runs in its Input Order, handed to that work (ADR-0240 section 6). A file opened or saved
+ * through it is opened or saved at once, inside the turn, as `open` and `save` do in their own place: for a Framework
+ * Adapter whose Consumer's handler runs in another runtime while the turn is held, as a Toolbar button's press holds
+ * it, where `open` and `save` would wait for the turn they belong to. The inputs made meanwhile wait behind both. Once
+ * the turn's work has ended, each throws.
+ */
+export declare interface SheetTurn {
+    /** Opens a file at once, inside this turn, as `SheetHandle.open` does in its place. */
+    open(read: (signal: AbortSignal) => PromiseLike<WorkbookDocument>): Promise<boolean>;
+    /** Saves the Workbook at once, inside this turn, as `SheetHandle.save` does in its place. */
+    save(write: (workbook: Workbook) => void | PromiseLike<void>): Promise<void>;
+}
+
+/**
+ * The id of every word ExSheet shows: stable, so a Consumer's label function can answer it. An id with a
+ * reason or a name in it takes the reason or the name as the union beside it spells it.
+ */
+export declare type SheetWordId = 'formulaUnreadable' | 'addressUnreadable' | 'addressPastEdge' | 'sheetNotNamed' | 'editIsOpen' | 'selectionMoved' | 'focusFormatChanged' | 'saveWhileEditing' | 'opening' | 'openWhileEditing' | 'opened' | 'openingCancelled' | 'openingRefused' | 'openingAlreadyLanded' | 'openingNothingToCancel' | 'editDiscardedByOpening' | 'formatKeyWhileEditing' | 'structureKeyWhileEditing.insert' | 'structureKeyWhileEditing.delete' | 'structureKeyNeedsWholeRowsOrColumns.insert' | 'structureKeyNeedsWholeRowsOrColumns.delete' | 'toolbarName' | 'toolbarWhileEditing' | 'toolbar.row.home' | 'toolbar.withShortcut' | `toolbar.item.${SheetToolbarCommand}` | 'toolbar.more' | 'toolbar.automatic' | 'toolbar.noFill' | `toolbar.border.${SheetToolbarBorder}` | 'toolbar.moreNumberFormats' | 'sheetTabsName' | 'editSheetGone' | 'sheetSwitchWhileEditing' | 'sheetOperationWhileEditing' | 'sheetAdded' | 'sheetRenamed' | 'sheetDeleted' | 'sheetMoved' | 'sheetCopied' | 'sheetNotRenamed' | 'newSheetName' | 'sheetNameField' | 'sheetMenuName' | `tabCommand.${SheetTabCommand}` | 'onlySheet' | 'sheetGone' | 'sheetNotChanged' | 'firstSheet' | 'lastSheet' | 'commaStyleUnread' | 'editDiscardedByNewDocument' | `editDiscarded.${EditDiscardReason}` | 'pasteReadsDifferently' | 'pasteRefusedFormula' | 'summaryRefused' | 'pasteTooNarrowToShow' | `pasteRefused.${PasteRefusalReason}` | `commitRefused.${CommitRefusalReason}` | `placementRefused.${PlacementRefusalReason}` | 'overwritten' | `copyRefused.${CopyRefusalReason}` | `pointingRefused.${PointingRefusalWordCase}` | 'pointingExtendedByKey' | 'nothingToUndo' | 'nothingToRedo' | `command.${SheetContextCommand}` | `find.${SheetFindWithinWord}` | 'formatCellsTitle' | `formatCells.tab.${FormatCellsTab}` | `formatCells.category.${NumberFormatCategory}` | `formatCells.disabled.${DisabledNumberFormatCategory}` | 'formatCells.noNumberFormatCode' | 'formatCells.numberFormatNotRead' | 'formatCells.notAColour' | `formatCells.alignment.${HorizontalAlignment}` | `formatCells.fontStyle.${FontStyle}` | `formatCells.edge.${BorderEdge}` | `formatCells.preset.${BorderPreset}` | `formatCells.lineStyle.${BorderLineStyle}` | `formatCells.colour.${ThemeColourName | StandardColourName}` | 'formatCells.colourDarker' | 'formatCells.colourLighter' | 'formatCells.colourStep' | `formatCells.label.${FormatCellsLabel}` | 'formatCells.symbol';
+
+/** Every id ExSheet has a word for: what a Consumer replaces to give ExSheet another language. */
+export declare function sheetWordIdList(): readonly SheetWordId[];
+
+/**
+ * The words ExSheet shows, each through the Consumer's label function, else ExSheet's own (ADR-0370,
+ * section 10). Its members are named as the C# package's SheetWords names them: a sentence that says something
+ * of the moment is a function of what it names, and its arguments are put into the template its id answers.
+ */
+export declare class SheetWords {
+    #private;
+    /** The words as `choice` chooses them; none is ExSheet's English throughout. */
+    constructor(choice?: SheetWordsChoice);
+    /** The word for an id: the label's, else ExSheet's own. A template is returned as it is. */
+    word(id: SheetWordId): string;
+    /** A Formula the engine could not read, with where and why: `This Formula cannot be read at character 4: …`. */
+    formulaUnreadable(error: FormulaSyntaxError): string;
+    /** What was typed into the Name Box is not a place on the Sheet (ADR-0051). */
+    addressUnreadable(typed: string): string;
+    /** What was typed into the Name Box is a place past the Sheet Size, whose last cell is `edge` (ADR-0460). */
+    addressPastEdge(typed: string, edge: CellAddress): string;
+    /** A refusal of the engine's, in its own words: the engine's refusals carry no id yet. */
+    refused(refusal: SheetRefusal): string;
+    /** A command over a Workbook of several Sheets that names none (ADR-0331 §6): taken against the Sheet
+     * shown, its outcome would depend on whether a press on a tab reached the instance first. */
+    sheetNotNamed(sheets: number): string;
+    /** A change refused while a cell is being edited. */
+    get editIsOpen(): string;
+    /** A change made from the Focus cell's format away from the Sheet, refused because the Selection moved before it
+     * was set (ADR-0100). */
+    get selectionMoved(): string;
+    /** Such a change, refused because the Focus cell's format changed before it was set (ADR-0100). */
+    get focusFormatChanged(): string;
+    /** A save refused while a cell is being edited (ADR-0330 §10): it would quietly lack what is being typed. */
+    get saveWhileEditing(): string;
+    /** An opening under way, said once as it starts (ADR-0330 §10, ADR-0240 §12). */
+    get opening(): string;
+    /** An opening refused while a cell is being edited (ADR-0330 §10, ADR-0048). */
+    get openWhileEditing(): string;
+    /** A file opened. */
+    get opened(): string;
+    /** An opening cancelled. */
+    get openingCancelled(): string;
+    /** An opening refused, with the reason the file was refused for. */
+    openingRefused(reason: string): string;
+    /** The Escape that found the opening landed (ADR-0240 §12). */
+    get openingAlreadyLanded(): string;
+    /** An Escape that found the opening over, refused or cancelled already: said, never swallowed (ADR-0240 §12). */
+    get openingNothingToCancel(): string;
+    /** What was typed, thrown away by a file opened during the edit. */
+    get editDiscardedByOpening(): string;
+    /** A formatting key while an edit is open (ADR-0071): Excel formats the selected characters there, and a
+     * Cell Format is per cell. */
+    get formatKeyWhileEditing(): string;
+    /** An insert or delete key while an edit is open (ADR-0050 item 14, 2026-10-02). */
+    structureKeyWhileEditing(insert: boolean): string;
+    /** An insert or delete key over a Selection of neither whole rows nor whole columns (ADR-0050 item 14,
+     * 2026-10-02): Excel shifts cells there, and ExSheet shifts none. */
+    structureKeyNeedsWholeRowsOrColumns(insert: boolean): string;
+    /** The Sheet Toolbar's accessible name (ADR-0100). */
+    get toolbarName(): string;
+    /** The Sheet Toolbar's default row, Excel's Home tab (ADR-0100). */
+    get toolbarHomeRow(): string;
+    /** A Toolbar Item's name (ADR-0100): `Bold`. */
+    toolbarItem(command: SheetToolbarCommand): string;
+    /** A Toolbar Item's tooltip, its name with its key (ADR-0100): `Bold (Ctrl+B)`. */
+    toolbarItemWithShortcut(name: string, shortcut: string): string;
+    /** A split control's arrow, which opens its list: `Borders, more`. */
+    toolbarMore(name: string): string;
+    /** The Font Colour list's first choice, which takes the colour away: Excel's Automatic. */
+    get toolbarAutomatic(): string;
+    /** The Fill Colour list's first choice, which takes the fill away: Excel's No Fill. */
+    get toolbarNoFill(): string;
+    /** A preset of the Borders list: `Bottom Border`. */
+    toolbarBorder(preset: SheetToolbarBorder): string;
+    /** The Number Format list's last choice, which opens Format Cells: Excel's More Number Formats…. */
+    get toolbarMoreNumberFormats(): string;
+    /** Why the Sheet Toolbar's items cannot be pressed while an edit is open (ADR-0100). */
+    get toolbarWhileEditing(): string;
+    /** The Sheet Tabs' accessible name (ADR-0331). */
+    get sheetTabsName(): string;
+    /** An edit whose Sheet left the Workbook before it was committed. */
+    get editSheetGone(): string;
+    /** Another Sheet not shown while a constant is being edited; a Formula shows one to point at its cells
+     * (ADR-0331 §5). */
+    get sheetSwitchWhileEditing(): string;
+    /** A Sheet Tab operation refused while an edit is open (ADR-0331 §4). */
+    get sheetOperationWhileEditing(): string;
+    /** A Sheet added, said in the Sheet's live region (ADR-0331 §4). */
+    sheetAdded(name: string): string;
+    /** A Sheet renamed. */
+    sheetRenamed(from: string, to: string): string;
+    /** A Sheet deleted, and how to give it back. */
+    sheetDeleted(name: string): string;
+    /** A Sheet moved to `position`, from 1, of `count` Sheets. */
+    sheetMoved(name: string, position: number, count: number): string;
+    /** A Sheet copied, and the copy's name. */
+    sheetCopied(name: string, copy: string): string;
+    /** A rename refused, with the reason. */
+    sheetNotRenamed(reason: string): string;
+    /** The name a Sheet added is offered under, before it is numbered. */
+    get newSheetName(): string;
+    /** The accessible name of the field a Sheet is renamed in. */
+    get sheetNameField(): string;
+    /** The accessible name of a Sheet Tab's menu. */
+    sheetMenuName(sheet: string): string;
+    /** Why the only Sheet cannot be deleted. */
+    get onlySheet(): string;
+    /** A Sheet that left the Workbook. */
+    get sheetGone(): string;
+    /** A Sheet Tab operation refused, with the reason. */
+    sheetNotChanged(reason: string): string;
+    /** Why the first Sheet does not move before itself. */
+    get firstSheet(): string;
+    /** Why the last Sheet does not move after itself. */
+    get lastSheet(): string;
+    /** Why the Sheet Toolbar has no Comma Style (ADR-0100): it pads with `*`, as Accounting does. */
+    get commaStyleUnread(): string;
+    /** What was typed, thrown away by another Sheet Document opened during the edit. */
+    get editDiscardedByNewDocument(): string;
+    /** What was typed, thrown away by the grid, and why (ADR-0142). */
+    editDiscarded(reason: EditDiscardReason): string;
+    /** A pasted field that came as an invariant value and would read differently typed under the Sheet's
+     * culture, which the sentence names. */
+    pasteReadsDifferently(field: string, culture: Culture): string;
+    /**
+     * A paste of a Sheet's copy that holds a cell ExSheet refused, other than this Sheet's own copy of one range
+     * (ADR-0047; 2026-10-12, decided with the user: a refusal is never caught, anywhere): pasted as a value, the
+     * refusal would become an Error Value a Formula can catch. `refused` is the cell it was copied from.
+     */
+    pasteRefusedFormula(refused: CellAddress): string;
+    /**
+     * Why the Selection Summary shows no figure over a refused cell (2026-10-13, decided with the user): the
+     * first refused cell in reading order, and what it shows, `#VALUE!` or `#NAME?`.
+     */
+    summaryRefused(refused: CellAddress, shown: string): string;
+    /** A pasted field that is how its source shows a value too wide for its column (`####`). */
+    pasteTooNarrowToShow(field: string, at: CellAddress): string;
+    /** A paste, a fill or an entry the grid refused, in the Sheet's terms; `edge` is the Sheet's last cell, which a
+     * block refused for running past it names: `XFD1048576` unless a Sheet Size is smaller (ADR-0460). */
+    pasteRefused(reason: PasteRefusalReason, edge?: CellAddress): string;
+    /** A commit refused because the row it was opened on can no longer be found (ADR-0142, LV-20): the editor
+     * stands with the typing, and only Escape leaves it. */
+    commitRefused(address: string, reason: CommitRefusalReason): string;
+    /** A selection the Consumer asked the grid to place, refused because the rows or columns it was taken
+     * against have moved since (ADR-0005): the Selection stands where it was. */
+    placementRefused(reason: PlacementRefusalReason): string;
+    /** A commit that landed over a cell changed while it was being edited (ADR-0142, LV-11): what it showed when
+     * editing began, and just before. */
+    overwritten(address: string, seen: string, replaced: string): string;
+    /** A copy the grid refused, in the Sheet's terms. */
+    copyRefused(reason: CopyRefusalReason): string;
+    /** What the Context Menu calls one of ExSheet's own commands (ADR-0036). */
+    command(command: SheetContextCommand): string;
+    /** What a Sheet Tab's menu calls one of its commands (ADR-0331 §4). */
+    tabCommand(command: SheetTabCommand): string;
+    /** What the find panel calls Within and its two choices (ADR-0332 §5). */
+    findWithin(word: SheetFindWithinWord): string;
+    /** Format Cells' title. */
+    get formatCellsTitle(): string;
+    /**
+     * What a press on a grid of a Pointing Scope, or an arrow key after one, that wrote nothing tells (ADR-0058):
+     * the table, the column where one is named, and whether a drag took back what its press wrote.
+     */
+    pointingRefused(reason: PointingRefusalReason, table: string, column: string | undefined, tookBack: boolean): string;
+    /** What Shift and an arrow key tell after a press on a grid of a Pointing Scope (ADR-0058): refused as a
+     * range is. */
+    pointingExtendedByKey(table: string): string;
+    /** Ctrl+Z with nothing to undo. */
+    get nothingToUndo(): string;
+    /** Ctrl+Y with nothing to redo. */
+    get nothingToRedo(): string;
+    /** A Format Cells tab's name. */
+    tabName(tab: FormatCellsTab): string;
+    /** A Number Format category's name. */
+    categoryName(category: NumberFormatCategory): string;
+    /** Why a category is shown disabled (ADR-0071). */
+    categoryDisabled(category: DisabledNumberFormatCategory): string;
+    /** A horizontal alignment's name, as the Alignment tab lists it. */
+    alignmentName(alignment: HorizontalAlignment): string;
+    /** A font style's name, as the Font tab lists it. */
+    fontStyleName(style: FontStyle): string;
+    /** An edge's name, as the Border tab's buttons are named. */
+    edgeName(edge: BorderEdge): string;
+    /** A preset's name, as the Border tab lists it. */
+    presetName(preset: BorderPreset): string;
+    /** A line style's name. */
+    lineStyleName(style: BorderLineStyle): string;
+    /** A palette colour's name, as Excel's tooltip gives it: `Dark Blue, Text 2, Lighter 90%`. */
+    swatchName(swatch: PaletteSwatch): string;
+    /** A label of Format Cells' own under the built-in Chrome: a legend, a field or a button (ADR-0071). */
+    formatCellsLabel(label: FormatCellsLabel): string;
+    /** The Currency category's symbol, as the Number tab shows it: `Symbol: $`. */
+    currencySymbolShown(symbol: string): string;
+    /** Why Format Cells' OK cannot set what it shows (ADR-0071). */
+    formatCellsRefusal(refusal: FormatCellsRefusal): string;
+    /** ExSheet's English, through no label. */
+    static readonly english: SheetWords;
+    /** ExSheet's English for the Selection Summary's refusal, a template: `{0}` the cell, `{1}` what it shows. */
+    static readonly summaryRefusedEnglish: string;
+}
+
+/** A Sheet's words, chosen once: ExSheet's English, or its Japanese, with the Consumer's label over either
+ * (ADR-0370, section 10). */
+export declare function sheetWords(choice?: SheetWordsChoice): SheetWords;
+
+/** How a Sheet's words are chosen (ADR-0370, section 10): ExSheet's English, or its Japanese in one line, and
+ * the Consumer's label over either. */
+export declare interface SheetWordsChoice {
+    /** ExSheet's Japanese in place of its English: Excel Japanese edition's words where Excel shows the same
+     * thing (`セルの書式設定`, `表示形式`, `ユーザー定義`), and the family's own elsewhere. Never chosen by the
+     * locale or the browser's language. */
+    readonly japanese?: boolean | undefined;
+    /** The Consumer's word for any id, which wins over ExSheet's. */
+    readonly label?: SheetLabel | undefined;
+}
+
+/** Excel's ten standard colours (case 23), by name. */
+export declare type StandardColourName = 'darkRed' | 'red' | 'orange' | 'yellow' | 'lightGreen' | 'green' | 'lightBlue' | 'blue' | 'darkBlue' | 'purple';
+
+/** A tint or a shade of a theme colour, as Excel's tooltip names it: `Darker 5%`, `Lighter 80%`. */
+export declare interface SwatchStep {
+    /** Whether the theme colour is darkened or lightened. */
+    readonly shade: 'darker' | 'lighter';
+    /** By how much, in percent. */
+    readonly percent: number;
+}
+
+/** A row of a registered grid read as the table's row: one Value per declared column, `undefined` for a blank. */
+export declare type TableRow = readonly (Value | undefined)[];
+
+/** The Office theme's ten colours (case 23), by the name of their column. */
+export declare type ThemeColourName = 'background1' | 'text1' | 'background2' | 'text2' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6';
+
+/** The Time category's formats. */
+export declare const timeTypes: readonly string[];
+
+/** The index the list's `key` moves the keyboard to from the choice at `at` (-1 for none), or `undefined` where it
+ * stays. */
+export declare function toolbarChoiceMovedTo(key: string, at: number, choices: readonly SheetToolbarItemChoice[]): number | undefined;
+
+/** One row of a list, in the Sheet's order: the index of a choice drawn on a row of its own, or the indices of the
+ * swatches drawn together, ten across, as the list's keys move among them. */
+export declare type ToolbarChoiceRow = number | readonly number[];
+
+/** The list's rows: a run of swatches is cut ten across, and every other choice stands on a row of its own. */
+export declare function toolbarChoiceRows(choices: readonly SheetToolbarItemChoice[]): readonly ToolbarChoiceRow[];
+
+/** The choice the list's keyboard starts on: the one the Focus cell has, else the first that can be made. */
+export declare function toolbarChoiceStart(choices: readonly SheetToolbarItemChoice[]): number | undefined;
+
+/** Swatches to a row, as Excel's palette lays them out and as the built-in list moves among them. */
+export declare const toolbarSwatchesAcross = 10;
+
+/**
+ * Whether a change a Sheet Toolbar item sets widens the columns whose numbers no longer fit, as Excel's Home tab
+ * buttons do (ADR-0071, ADR-0100): as a key does, and for a Font colour too. Excel's Bold and Italic buttons did
+ * not widen and its Underline button did (R6, case (3)); its Fill Color button did not (the fourteenth Windows
+ * run, case 7); and its Font Color button widened, where `Font.Color` set through COM did not (run 18a, widening
+ * case 5; decided with the user, 2026-10-14).
+ */
+export declare function widensAsAHomeTabButtonDoes(change: CellFormatChange): boolean;
+
+/**
+ * Whether a change a formatting key sets widens the columns whose numbers no longer fit (ADR-0071; ticket 58's
+ * rule): a Number Format key widens (case 17), and so do Ctrl+5 and Ctrl+U, setting strikethrough or underline
+ * or taking it off, though they set no Number Format. Excel's Ctrl+5 widened column A for `1234567.50` (the
+ * fourteenth Windows run, case 7) and from 8.09 to 11.73 for `123456789.12` in `0.00` (the seventeenth's h8),
+ * and Ctrl+U the same column the same way (h7). Ctrl+B and the Fill did not (case 7), nor did Ctrl+I (h7). That
+ * Ctrl+4 widens as Ctrl+U does, that the Border keys widen nothing, and that taking strikethrough or underline
+ * off widens are readings. `SetCellFormatAsync` widens by this rule too (decided 2026-10-12), as Excel's
+ * `Range.Font` set through COM did (the readings of 2026-10-12 (R6), case (5); of 2026-10-14, run 18a, widening
+ * cases 2 and 6).
+ */
+export declare function widensAsAKeyDoes(change: CellFormatChange): boolean;
+
+/**
+ * Whether a change Format Cells' OK sets widens the columns whose numbers no longer fit, in OK's one undo step
+ * (ADR-0071; decided 2026-10-12): one that sets a Number Format (case 17; the fourteenth Windows run, case 8),
+ * and one that sets any part of the Font, though Ctrl+B and Ctrl+I widen nothing (the seventeenth run, h7; R6,
+ * case (1)). A Fill, Borders or an alignment widens nothing (R6, case (2); case 9); Borders over #### and the
+ * horizontal alignment are readings.
+ */
+export declare function widensAsFormatCellsOkDoes(change: CellFormatChange): boolean;
+
+export { }