@ex-grid/pivot-engine 0.0.0-stage → 0.2.0-rc.1

package/dist/index.d.ts

@@ -0,0 +1,2206 @@
+/**
+ * ExPivot's engine in TypeScript (ADR-0370, section 2): Excel's PivotTable over a Snapshot or records in
+ * memory. A Pivot Source answers a question with the Leaf Aggregates; the engine builds from them the row
+ * and column trees and every total, exactly where the numbers are exact (ADR-0060), and lays them out into
+ * a Pivot Report in the Compact, Outline or Tabular form. It is the C# engine's port, held to it by shared
+ * cases and a differential run.
+ *
+ * @packageDocumentation
+ */
+
+import { ChangeBatch } from '@ex-grid/data';
+import { Snapshot } from '@ex-grid/data';
+import { SnapshotChange } from '@ex-grid/data';
+import type { SnapshotColumn } from '@ex-grid/data';
+import { SnapshotDecimal } from '@ex-grid/data';
+
+/**
+ * The cube of a layout over records in memory, on the calling thread: the bundled source answers the
+ * layout's question with no cap on leaves, and the cube is built from its leaves. Refuses by name what
+ * {@link validateLayout} refuses, and a field list that declares a name twice.
+ */
+export declare function aggregatePivot<TRecord>(records: readonly TRecord[], fields: readonly PivotRecordField<TRecord>[], layout: PivotLayout): PivotCube;
+
+/** The C# engine's name of an Aggregation, as its messages write it: `Sum`, `CountNumbers`, `StdDevp`. */
+export declare function aggregationTitle(aggregation: PivotAggregation): string;
+
+/** The Item `(blank)`. */
+export declare const blankItemKey: PivotItemKey;
+
+/** The key of a Boolean Item. */
+export declare function booleanItemKey(value: boolean): PivotItemKey;
+
+/**
+ * A Layout menu choice applied (ADR-0061), as Excel's Design tab applies it. The Subtotals choices set
+ * every field in Rows and Columns — Automatic, or None — and, for the two that show them, where they stand;
+ * the Grand Totals choices set the two switches; the Report Layout choices set the form, or whether the
+ * Outline and Tabular forms repeat their outer Items' labels. Everything else in the layout is kept, and a
+ * choice that changes nothing returns the layout it was given.
+ */
+export declare function chooseLayout(layout: PivotLayout, choice: PivotLayoutChoice): PivotLayout;
+
+/** Aggregates and lays out in one step: {@link aggregatePivot} then {@link pivotReport}. */
+export declare function computePivot<TRecord>(records: readonly TRecord[], fields: readonly PivotRecordField<TRecord>[], layout: PivotLayout, options?: PivotOptions): PivotReport;
+
+/** A placement of the field, its settings checked and frozen. */
+export declare function createPivotFieldPlacement(input: string | PivotFieldPlacementInput): PivotFieldPlacement;
+
+/** A layout, every setting left out taking its default, and every placement and Value Field made by
+ * {@link createPivotFieldPlacement} and {@link createPivotValueField}. */
+export declare function createPivotLayout({ filters, rows, columns, values, valuesAxis, form, subtotalsAtTop, grandTotalRow, grandTotalColumn, repeatItemLabels, }?: PivotLayoutInput): PivotLayout;
+
+/** A Value Field of the field, its settings checked and frozen. */
+export declare function createPivotValueField(input: string | PivotValueFieldInput): PivotValueField;
+
+/** The key of a date Item, by its clock value in DateTime ticks. */
+export declare function dateItemKey(ticks: bigint): PivotItemKey;
+
+/** A field that is a part of a Date column (ADR-0060): its year, quarter or month, labelled `2026`, `Qtr3`,
+ * `Sep` in the report's words and ordered by the calendar. */
+export declare function datePartField(name: string, column: string, part: PivotDatePart, caption?: string): PivotField;
+
+/** The Aggregation a new Value Field of a field takes: Sum for a field declared Number, Count for any
+ * other (ADR-0060). */
+export declare function defaultAggregation(field: PivotFieldInfo): PivotAggregation;
+
+/** The default most Items a page lists. */
+export declare const defaultMaxItems = 10000;
+
+/** The default cap on leaves: "this layout needs more than 200,000 cells". */
+export declare const defaultMaxLeaves = 200000;
+
+/** No field anywhere: the report is empty and asks for fields. */
+export declare const emptyPivotLayout: PivotLayout;
+
+/** The Item `#NUM!`. */
+export declare const errorItemKey: PivotItemKey;
+
+/** A label's text estimated under the geometry, both sides' padding included, without reading a browser's
+ * layout. A lone surrogate is a character of the other class, as .NET reads it. */
+export declare function estimateLabelPx(metrics: PivotLabelMetrics, text: string): number;
+
+/**
+ * A source whose answers a Consumer fetches from a server (ADR-0066). The engine refuses what every source
+ * refuses before asking, and holds what comes back to the question: an answer to another question, more
+ * Items or records than were asked for, or records of other fields fail by name.
+ *
+ * **Live data** (ADR-0370 section 3): the Consumer's transport, started by {@link PivotFetchers.subscribe},
+ * tells the source that the server's data moved on, or hands it a Change Batch of the records the data lost
+ * and gained. Each listener {@link FetchingPivotSource.subscribe}d is told the new Source Version. Asked the
+ * question it answered last again, the source answers from the Leaf Aggregates it holds with the batches
+ * folded in, where subtraction and addition keep every part they touch exactly; otherwise — a notice, a batch
+ * out of chain, a sum that is a double, a product, a variance, an extreme a number left, Level Aggregates — it
+ * asks the server again. An answer fetched while a notice or a batch arrived is not held.
+ */
+export declare class FetchingPivotSource implements PivotSource {
+    #private;
+    /** The fields the server has. */
+    readonly fields: readonly PivotField[];
+    /** The Aggregations the server answers. */
+    readonly features: PivotSourceFeatures;
+    /** A source of the server's fields and Aggregations, asked through the fetchers; the features declare
+     * that it counts Items exactly when a fetcher counts them. */
+    constructor(fields: readonly PivotField[], features: PivotSourceFeatures, fetch: PivotFetchers);
+    /** The server's Leaf Aggregates, held to the question; for the question answered last, the answer held
+     * with the batches heard since folded in, where they fold. */
+    aggregate(query: PivotQuery, signal?: AbortSignal): Promise<PivotAnswer>;
+    /** Tells `listener` each new Source Version the Consumer's transport reports, after the source has moved on
+     * to it; the function returned stops telling it. The transport runs while a listener is subscribed. */
+    subscribe(listener: (changed: PivotSourceChanged) => void): () => void;
+    /** Refresh: lets go of the answer held, so the next question is asked of the server. */
+    refresh(): void;
+    /** The server's page of Items, held to the most asked for. */
+    items(query: PivotItemsQuery, signal?: AbortSignal): Promise<PivotItemPage>;
+    /** The server's count of each field's Items (ADR-0370 section 3). Counts naming a field the source does
+     * not declare are refused by name. */
+    itemCounts(signal?: AbortSignal): Promise<PivotItemCounts>;
+    /** The server's page of records, held to the fields and the page asked for. */
+    details(query: PivotDetailsQuery, signal?: AbortSignal): Promise<PivotDetailPage>;
+}
+
+/** A template word with its arguments put in, as .NET's `string.Format` puts them in under the invariant
+ * culture: `{n}`, `{n,width}`, `{n:format}` (a text takes no format), and `{{` and `}}` for a brace. A
+ * template .NET refuses throws a PivotFormatError. */
+export declare function fillPivotWord(template: string, ...args: readonly string[]): string;
+
+/**
+ * A count written as the report writes a whole number in `locale`, a BCP 47 tag or `invariant`, with its
+ * group separators: `1,020,000` in en-US, `1.020.000` in de-DE, as C#'s `count.ToString("N0", culture)`
+ * writes it. The Field List writes a field's count of Items with it, and the leaf cap's refusal its figures
+ * (ADR-0370 section 3). A count that is not a whole number of at least 0 is refused.
+ */
+export declare function formatPivotCount(count: number, locale: string): string;
+
+/**
+ * A value of a record behind a cell, `value`, written as Show Details shows it in its field's column: in `format`,
+ * the field's own format, where it is a number or a date, under `locale`, a BCP 47 tag or `invariant`. A Blank is
+ * written as nothing.
+ */
+export declare function formatPivotDetailValue(value: PivotDetailValue, format: string | undefined, locale: string): string;
+
+/**
+ * A figure written in a number format in `locale`, as C#'s `ToString(format, culture)` writes the decimal or the
+ * double it is: a Selection Summary's figure in the Focus value's format, as the report shows that value (ADR-0130).
+ * A format .NET cannot format a number with throws a `PivotFormatError`.
+ */
+export declare function formatPivotFigure(value: PivotNumber, format: string, locale: string): string;
+
+/**
+ * A number written in a number format in `locale`, as C#'s `value.ToString(format, culture)` writes it: what a
+ * Value Field's number format makes of a figure, which Value Field Settings… shows as its sample (ADR-0061).
+ * A format .NET cannot format a number with throws a `PivotFormatError`; `pivotNumberFormatProblem` says so
+ * first.
+ */
+export declare function formatPivotNumber(value: number, format: string, locale: string): string;
+
+/** Whether the layout places no field at all. */
+export declare function isEmptyLayout(layout: PivotLayout): boolean;
+
+/** Whether the placement's Item is collapsed. */
+export declare function isItemCollapsed(placement: PivotFieldPlacement, item: PivotItemKey): boolean;
+
+/**
+ * Whether a choice is what the report shows now — the Layout menu marks it (ADR-0061). Read from what is
+ * painted: in the Tabular form, which puts every subtotal at the bottom, Show at Bottom is the current
+ * Subtotals choice whatever the layout's setting; in the Compact form, which has no outer label columns,
+ * neither label choice is. With no field in Rows or Columns no Subtotals choice is current, and with fields
+ * that disagree, none is.
+ */
+export declare function isLayoutChosen(layout: PivotLayout, choice: PivotLayoutChoice): boolean;
+
+/** Whether the groups below `item` are shown under `rule`. */
+export declare function isLevelExpanded(rule: PivotLevelRule, item: PivotItemKey): boolean;
+
+/** Whether an entry is Σ Values. */
+export declare function isValuesPseudoField(entry: PivotEntry): boolean;
+
+/** Whether two keys name one Item: the same kind and text, text compared ignoring case. */
+export declare function itemKeysEqual(a: PivotItemKey, b: PivotItemKey): boolean;
+
+/**
+ * Every Item of a placed field over all the records, in the field's order — what Filter… lists (ADR-0061)
+ * — each with its label and whether it is hidden now. For a cube built by {@link aggregatePivot}; a cube
+ * built from a source's answer asks the source for a page and lays it out with {@link itemsOfPage}.
+ */
+export declare function itemsOfCube(cube: PivotCube, layout: PivotLayout, field: string, options?: PivotOptions): readonly PivotItemInfo[];
+
+/**
+ * A page of a field's Items as Filter… and the report filter band list them (ADR-0061): in the field's
+ * order under the layout — its declared Items first, then by kind and label under the report's locale,
+ * descending when the field is — each with its label and whether the layout hides it now.
+ */
+export declare function itemsOfPage(page: PivotItemPage, layout: PivotLayout, field: PivotField, options?: PivotOptions): readonly PivotItemInfo[];
+
+/** The words of Excel's Japanese edition: `行ラベル`, `総計`, `合計 / 金額`, `(空白)`, a date part's
+ * `2026年`, `第3四半期`, `9月`. A {@link PivotLabel} to hand to a report's options in one line. */
+export declare const japanesePivotWords: PivotLabel;
+
+/**
+ * Whether a choice would change what the report shows (ADR-0061): the Layout menu disables one that would
+ * not. The current choice never would. Nor would a Subtotals choice with no field in Rows or Columns, Show
+ * at Top in the Tabular form, nor a label choice in the Compact form.
+ */
+export declare function layoutChoiceChanges(layout: PivotLayout, choice: PivotLayoutChoice): boolean;
+
+/** The question {@link queryForLayout} asks, with the groups the layout shows (ADR-0370 section 3): what
+ * ExPivot asks a source that answers Level Aggregates. With a `window`, each row field whose Items show no groups
+ * below them — the innermost, or one collapsed with none toggled — and that the layout sorts by a value shown as it
+ * is computed carries that order, so a set of it too large to answer whole is answered as a Sibling Window; a value
+ * shown as a percentage, a sort by label, or a field with groups shown below it carries none. */
+export declare function levelQueryForLayout(layout: PivotLayout, maxLeaves?: number, window?: PivotLevelWindowInput): PivotQuery;
+
+/** The groups a layout shows: each row and column field's collapse state. */
+export declare function levelsOfLayout(layout: PivotLayout): PivotLevels;
+
+/**
+ * A report source over a Pivot Source in memory — a Snapshot's, records', or a server's behind a fetching
+ * source (ADR-0151). Each request lays the report out afresh where its question, layout or data changed,
+ * answers the Window asked for with every row projected from the newest report, and holds the last
+ * `versionsKept` Report Versions for the operations that name one. A row the held Window shows alike is the
+ * very row it holds. A cell whose shown text a change of the data moved is marked with the version that
+ * published the change, for as long as the settings' highlight lasts (ADR-0068, ADR-0153).
+ *
+ * Requests are answered one at a time, in the order made. Each runs its pass, cube, report and label widths
+ * on one Slicer (PV-40), and a cancelled one rejects with its signal's reason, leaving the versions held as
+ * they were. A versioned operation reads the version it names and never waits on a newer computation.
+ */
+export declare class LocalPivotReportSource implements PivotReportSource {
+    #private;
+    /** A report source over `source`, which it does not own. Refuses, with a RangeError, a `versionsKept` that
+     * is not a whole number of at least 1. */
+    constructor(source: PivotSource, options?: LocalPivotReportSourceOptions);
+    /** The Pivot Source's fields. */
+    get fields(): readonly PivotField[];
+    /** The Pivot Source's Aggregations. */
+    get features(): PivotSourceFeatures;
+    /** `incremental` over a Snapshot, whose Change Batches name what changed; `fullRefresh` otherwise. */
+    get updateMode(): PivotReportUpdateMode;
+    /** Tells `listener` each new Source Version the Pivot Source reports — over a Snapshot, or from a server's
+     * transport (ADR-0370 section 3); the function returned stops telling it. */
+    subscribe(listener: (changed: PivotSourceChanged) => void): () => void;
+    /**
+     * A Window of the report the request's layout makes from the newest data — or, for a layout gesture that
+     * names the Window it holds, from the data that Window shows — or a refusal by name: of the Pivot Source,
+     * of an Order Key policy not registered, or of an Order Key that failed on an Item. Rejects with what a
+     * layout the source cannot lay out throws, and with the signal's reason once it is aborted.
+     */
+    window(request: PivotReportRequest, signal?: AbortSignal): Promise<PivotReportUpdate>;
+    /** A field's Items as the Pivot Source lists them, under a Source Version. */
+    rawItems(query: PivotItemsQuery, signal?: AbortSignal): Promise<PivotItemPage>;
+    /** A field's Items labelled and ordered as a held Report Version shows them, under its Source Version; refused
+     * by name for a version not held, a field not declared, the Pivot Source's refusal, and an Order Key that
+     * fails on an Item. */
+    items(query: PivotReportItemsQuery, signal?: AbortSignal): Promise<PivotReportItemsResult>;
+    /** A page of the records behind a cell under the Source Version its question names (ADR-0151): answered while
+     * the Pivot Source holds that version, however many layouts came since, and refused by it once it does not. */
+    details(query: PivotDetailsQuery, signal?: AbortSignal): Promise<PivotDetailPage>;
+    /** Every selected cell of a held Report Version, each rectangle whole, in the order asked; refused by name for
+     * a version not held, a column not the report's or named twice, a rectangle outside the report, and a copy
+     * past `maxCells` — never cut short (spine 1). */
+    copy(query: PivotReportCopyQuery, signal?: AbortSignal): Promise<PivotReportCopyResult>;
+    /** The Selection Summary of a held Report Version: Count, Numerical Count, Sum, Min and Max, a cell under two
+     * rectangles counted once, shown in the Focus value's format (ADR-0130). */
+    summary(query: PivotReportSummaryQuery, signal?: AbortSignal): Promise<PivotReportSummaryResult>;
+    /** Releases the report's state and stops hearing the Pivot Source, which it does not own: every later call
+     * throws. */
+    dispose(): void;
+}
+
+/** What a local report source is made with. */
+export declare interface LocalPivotReportSourceOptions {
+    /** The Order Keys a request's settings may name for a field, by name (ADR-0152). */
+    readonly orderKeys?: Readonly<Record<string, PivotOrderKey>>;
+    /** How many Report Versions are held for the versioned operations; 2 when left out. The reports the
+     * Change Highlight compares are held as well, for as long as they are marked (ADR-0153). */
+    readonly versionsKept?: number;
+    /** The clock that times how long a change stays marked, in milliseconds; `Date.now` when left out. It
+     * only bounds what is kept: when a highlight starts is the Consumer's ({@link PivotChangeTimes}). */
+    readonly now?: () => number;
+    /** How the work shares the thread (PV-40). */
+    readonly slicing?: PivotSlicing;
+}
+
+/**
+ * A placed entry dropped on an Area at `index` (ADR-0061). Within its own Area it is a reorder. A field
+ * moving between Filters, Rows and Columns keeps its settings; one moving to Values leaves its Area and
+ * becomes a Value Field; a Value Field moving to another Area leaves Values and its field is placed there.
+ * Σ Values moves between Rows and Columns only — anywhere else it stays — and always stands last. `field`
+ * is the dragged entry's field, whose declared type decides a new Value Field's Aggregation; it is not read
+ * for Σ Values.
+ */
+export declare function moveEntry(layout: PivotLayout, entry: PivotEntry, area: PivotArea, index: number, field: PivotFieldInfo | undefined): PivotLayout;
+
+/** The key of a number Item; a number that is not finite is `#NUM!`, and -0 is 0. */
+export declare function numberItemKey(number: number): PivotItemKey;
+
+/** How a Value Field summarises the records at a cell: Excel's "Summarize Values By" (ADR-0060). */
+export declare type PivotAggregation = 'sum' | 'count' | 'average' | 'max' | 'min' | 'product' | 'countNumbers' | 'stdDev' | 'stdDevp' | 'var' | 'varp';
+
+/** The id of an Aggregation's name: `aggregation-sum` is `Sum`. */
+export declare function pivotAggregationNameId(aggregation: PivotAggregation): string;
+
+/** Every Aggregation, in the C# engine's order. */
+export declare const pivotAggregations: readonly PivotAggregation[];
+
+/** A Pivot Source's answer: the Leaf Aggregates under a Source Version, or a refusal. */
+export declare class PivotAnswer {
+    #private;
+    /** The refusal, when the source refused. */
+    readonly refusal: PivotSourceRefusal | undefined;
+    /** How many leaves the answer has. */
+    readonly leafCount: number;
+    /** Whether the answer holds the cells of the groups shown — Level Aggregates — rather than the leaves
+     * (ADR-0370 section 3). */
+    readonly isLevels: boolean;
+    private constructor();
+    /** A refusal, as an answer. */
+    static refused(refusal: PivotSourceRefusal): PivotAnswer;
+    /** Whether the source refused. */
+    get isRefused(): boolean;
+    /** The Source Version the answer was computed at. A refusal has none, and throws. */
+    get sourceVersion(): string;
+    /** The row fields, in the question's order. */
+    get rows(): readonly PivotAnswerAxis[];
+    /** The column fields, in the question's order. */
+    get columns(): readonly PivotAnswerAxis[];
+    /** Each field in Values, in the question's order. */
+    get values(): readonly PivotAnswerValues[];
+    /** The included records at a leaf. */
+    recordsAt(leaf: number): number;
+    /** The sibling sets answered as windows (ADR-0370 section 3); none in an answer of leaves. */
+    get windows(): readonly PivotAnswerWindow[];
+    /** The window and side a rest cell merges, or `undefined` for a cell of a group. */
+    restAt(cell: number): PivotAnswerRest | undefined;
+    /** What does not answer the question, in words, or `undefined` when the answer answers it. */
+    mismatch(query: PivotQuery): string | undefined;
+}
+
+/** One row or column field of an answer: its Items, and each leaf's Item among them. */
+export declare class PivotAnswerAxis {
+    #private;
+    /** The field. */
+    readonly field: string;
+    /** Its Items that some leaf carries. */
+    readonly items: readonly PivotItemKey[];
+    /** @internal */
+    constructor(field: string, items: readonly PivotItemKey[], itemOfLeaf: readonly number[]);
+    /** The index among {@link PivotAnswerAxis.items} of a leaf's Item; in a level answer, −1 for a cell above
+     * this field, which stands for every Item of it. */
+    itemAt(leaf: number): number;
+}
+
+/**
+ * Builds an answer a leaf at a time, as a server's rows arrive (ADR-0066): each leaf named by its Items, one
+ * per row and column field, with its record count, and the parts asked for of each field in Values set on
+ * it. Two leaves for one combination of Items are refused, and so is a part the question did not ask for.
+ *
+ * A server that answers Level Aggregates (ADR-0370 section 3) adds the cells of the groups shown with
+ * {@link PivotAnswerBuilder.addCell} instead, from `GROUPING SETS` for instance, and gives a sum that is a
+ * double with the sum of its magnitudes; an answer holds leaves or cells, never both.
+ */
+export declare class PivotAnswerBuilder {
+    #private;
+    /** A builder for the answer to `query`, under `sourceVersion`. */
+    constructor(query: PivotQuery, sourceVersion: string);
+    /** How many leaves have been added. */
+    get leafCount(): number;
+    /** Adds a leaf of `records` records (at least 1) at one Item per row and column field, outermost row
+     * field first; its index. */
+    addLeaf(items: readonly PivotItemKey[], records: number): number;
+    /**
+     * Adds the cell of a shown row group crossed with a shown column group, and returns its index (ADR-0370
+     * section 3): an answer of Level Aggregates, to a question carrying levels. Each group is named by its
+     * Items, outermost first, down to its depth — none for a grand total. Refuses a cell of no records, more
+     * Items than an axis has fields, and a second cell for the same Items. Which cells are shown, and that each
+     * has its parent, is checked when the answer is read against the question.
+     */
+    addCell(rowItems: readonly PivotItemKey[], columnItems: readonly PivotItemKey[], records: number): number;
+    /**
+     * Adds a sibling set answered as a window, and returns its index (ADR-0370 section 3): the children of the
+     * row group `parentRows` names, of which `before` come before the first one shown and `after` after the
+     * last, each count taking in its margin. The margins and the siblings shown are added as cells; the siblings
+     * beyond each margin as rest cells with {@link PivotAnswerBuilder.addRest}. Refuses a second window for one
+     * parent; whether the window answers the question is checked when the answer is read against it.
+     */
+    addWindow(parentRows: readonly PivotItemKey[], before: number, after: number): number;
+    /**
+     * Adds a rest cell of a window, and returns its index (ADR-0370 section 3): the siblings on one side beyond
+     * its margin, merged, crossed with the shown column group `columnItems` names. Its parts are set as a cell's.
+     * Refuses one of no records and a second one for the same side and column group.
+     */
+    addRest(window: number, side: PivotRestSide, columnItems: readonly PivotItemKey[], records: number): number;
+    /** Sets a leaf's counts for a field in Values. */
+    setCounts(leaf: number, value: number, values: number, numbers: number, nonFinite?: boolean): void;
+    /** Sets a leaf's sum for a field in Values. */
+    setSum(leaf: number, value: number, sum: PivotNumber): void;
+    /** Sets a cell's sum of Level Aggregates with the sum of its numbers' magnitudes, which a sum that is a
+     * double carries (ADR-0370 section 3): what bounds its rounding when the cell is checked against its
+     * parent. */
+    setLevelSum(leaf: number, value: number, sum: PivotNumber, absoluteSum: number): void;
+    /** Sets a leaf's extremes for a field in Values: both exact or both doubles. */
+    setExtremes(leaf: number, value: number, min: PivotNumber, max: PivotNumber): void;
+    /** Sets a leaf's product for a field in Values. */
+    setProduct(leaf: number, value: number, product: number): void;
+    /** Sets a leaf's running variance for a field in Values. */
+    setVariance(leaf: number, value: number, mean: number, m2: number): void;
+    /** The answer, once: one with more leaves than the question allows is refused. */
+    build(): PivotAnswer;
+}
+
+/** A rest cell's window, by its place among the answer's windows, and its side. */
+export declare interface PivotAnswerRest {
+    /** The window, by its place among {@link PivotAnswer.windows}. */
+    readonly window: number;
+    /** The side whose siblings beyond the margin it merges. */
+    readonly side: PivotRestSide;
+}
+
+/** One field in Values of an answer: the parts at each leaf. */
+export declare class PivotAnswerValues {
+    #private;
+    /** The field. */
+    readonly field: string;
+    private constructor();
+    /** The parts carried beyond the counts. */
+    get parts(): readonly PivotPart[];
+    /** The values at a leaf that are not Blank. */
+    valuesAt(leaf: number): number;
+    /** The numbers at a leaf, non-finite ones included. */
+    numbersAt(leaf: number): number;
+    /** Whether a non-finite number is among a leaf's values. */
+    nonFiniteAt(leaf: number): boolean;
+    /** The sum of a leaf's numbers. */
+    sumAt(leaf: number): PivotNumber;
+    /** The smallest of a leaf's numbers. */
+    minAt(leaf: number): PivotNumber;
+    /** The largest of a leaf's numbers. */
+    maxAt(leaf: number): PivotNumber;
+    /** The sum of the magnitudes of a cell's numbers, which a level answer carries beside a sum that is a
+     * double: what bounds its rounding when it is checked against its parent (ADR-0370 section 3).
+     * `undefined` for an exact sum, and in an answer of leaves. */
+    absoluteSumAt(leaf: number): number | undefined;
+    /** The product of a leaf's numbers. */
+    productAt(leaf: number): number;
+    /** The running mean of a leaf's numbers. */
+    meanAt(leaf: number): number;
+    /** The running sum of squared deviations of a leaf's numbers. */
+    m2At(leaf: number): number;
+}
+
+/**
+ * A sibling set answered as a window (ADR-0370 section 3): its parent row group, and how many of its siblings
+ * come before the first one shown and after the last. Each count, when above 0, takes in a margin — the
+ * nearest sibling on that side, answered as any shown group is and not shown — and the siblings beyond it,
+ * merged into the window's rest cells on that side.
+ */
+export declare interface PivotAnswerWindow {
+    /** The parent's Item at each row field above the set, as an index among that axis's Items: none for the
+     * grand total. */
+    readonly parent: readonly number[];
+    /** The siblings before the first one shown, its margin among them. */
+    readonly before: number;
+    /** The siblings after the last one shown, its margin among them. */
+    readonly after: number;
+}
+
+/** The four places a Pivot Field stands, in Excel's words (ADR-0061). */
+export declare type PivotArea = 'filters' | 'columns' | 'rows' | 'values';
+
+/** Where Σ Values stands, when there are two or more Value Fields: innermost in Columns, Excel's default,
+ * or in Rows (ADR-0060). */
+export declare type PivotAxis = 'columns' | 'rows';
+
+/** The id of a Value Field's default caption: `caption-sum` is `Sum of {0}`, `{0}` the field's caption. */
+export declare function pivotCaptionId(aggregation: PivotAggregation): string;
+
+/**
+ * When this Consumer first showed each change a report source marks. A source marks each changed cell with
+ * the Report Version whose data changed it ({@link PivotDisplayRow.changedIn}) and lists the changes it still
+ * marks ({@link PivotReportMetadata.changeMarks}). A listed change is stamped the first time a Window of a
+ * report listing it is adopted — whether or not that Window holds one of its cells — so a row first asked for
+ * later, by a scroll, shows it as of that first time, and its highlight ends with the others of the change. A
+ * change no longer listed is never stamped; a stamp is kept while the source lists its change or its highlight
+ * has not ended, and once forgotten the change is never listed again, so none is stamped twice. One instance
+ * serves a view for its lifetime, across new sources.
+ */
+export declare class PivotChangeTimes {
+    #private;
+    /** Takes a Window up as it is shown at `now`, on the Consumer's clock in milliseconds: each change its
+     * report lists that is not stamped yet is stamped `now`, and each stamp whose change is no longer listed
+     * and whose highlight of `highlightMs` has ended is forgotten. */
+    adopt(state: PivotReportState, now: number, highlightMs: number): void;
+    /** When the change `mark` names was first shown, or `undefined` for no mark or one not stamped. */
+    at(mark: string | undefined): number | undefined;
+    /** When the shown text of a row's value cell last changed with the data, as this Consumer first showed
+     * it; `undefined` when it did not change recently. */
+    changedAt(row: PivotDisplayRow, valueColumn: number): number | undefined;
+}
+
+/** What a value column of a report stands for (ADR-0060). */
+export declare type PivotColumnRole = 'item' | 'subtotal' | 'grandTotal';
+
+/** The cube a report is laid out from (ADR-0060/0066): the answer's leaves, each axis's tree of Items, and
+ * every total merged from the leaves beneath it. Made by {@link pivotCube} or {@link aggregatePivot}. */
+export declare class PivotCube {
+    #private;
+    /** The question the cube answers. */
+    readonly query: PivotQuery;
+    /** The Source Version its answer was computed at. */
+    readonly sourceVersion: string;
+    /** How many records its leaves hold: those no Hidden Item left out. */
+    readonly includedRecordCount: number;
+    /** Whether it was made from Level Aggregates (ADR-0370 section 3): it holds the groups the question's levels
+     * show and no others, so a layout that shows others is asked again. */
+    readonly isLevels: boolean;
+    private constructor();
+    /** Whether the cube was aggregated under the layout's placed fields, Hidden Items and Value Fields, with
+     * the parts each of its Aggregations reads; one made from Level Aggregates, also under the groups the layout
+     * shows, and one that answered Sibling Windows, also under the orders and collapse the layout asks them by. */
+    holds(layout: PivotLayout): boolean;
+}
+
+/**
+ * The cube of a Pivot Source's answer (ADR-0066): the row and column trees its leaves form, and every
+ * subtotal and grand total merged from the leaves' parts — each total from its records, never from the
+ * totals below it (ADR-0060). Refuses by name an answer to another question, a refusal, and a field
+ * neither declared nor named by the question.
+ */
+export declare function pivotCube(query: PivotQuery, answer: PivotAnswer, fields: readonly PivotField[]): PivotCube;
+
+/**
+ * {@link pivotCube} in slices (PV-40): the same steps over the answer's leaves and cells, a piece at a time,
+ * yielding between slices as `slicing` paces them, so that a large answer's cube leaves the page painting. It
+ * gives the cube {@link pivotCube} gives, and rejects with what it throws. Once `signal` is aborted, it stops at
+ * the next slice and rejects with the signal's reason. A call begins a slice of its own, and its last slice ends
+ * without a yield, as a source's question does: a caller that asks, makes the cube and lays out the report one
+ * after another yields between them where the page must paint.
+ */
+export declare function pivotCubeAsync(query: PivotQuery, answer: PivotAnswer, fields: readonly PivotField[], slicing?: PivotSlicing, signal?: AbortSignal): Promise<PivotCube>;
+
+/** A part of a Date column a Pivot Field can be declared as: its year, quarter or month (ADR-0060). */
+export declare type PivotDatePart = 'year' | 'quarter' | 'month';
+
+/** A page of the records behind a cell (ADR-0063/0066), or a refusal. */
+export declare class PivotDetailPage {
+    #private;
+    /** The refusal, when the source refused. */
+    readonly refusal: PivotSourceRefusal | undefined;
+    private constructor();
+    /** A page: the fields, where it starts, how many records there are in all, and the records. */
+    static of(sourceVersion: string, fields: readonly PivotField[], start: number, total: number, records: readonly PivotDetailRecord[]): PivotDetailPage;
+    /** The source's refusal to show the records. */
+    static refused(refusal: PivotSourceRefusal): PivotDetailPage;
+    /** Whether the source refused. */
+    get isRefused(): boolean;
+    /** The Source Version the records were read at. */
+    get sourceVersion(): string;
+    /** The fields each record carries a value of, in order. */
+    get fields(): readonly PivotField[];
+    /** The place of the page's first record among all of them. */
+    get start(): number;
+    /** How many records are behind the cell in all. */
+    get total(): number;
+    /** The page's records. */
+    get records(): readonly PivotDetailRecord[];
+}
+
+/** One record behind a cell: each field's value, in the page's field order, and the Consumer's record where
+ * the source holds one. */
+export declare interface PivotDetailRecord {
+    /** Each field's value, in the page's field order. */
+    readonly values: readonly PivotDetailValue[];
+    /** The Consumer's record, where the source holds one. */
+    readonly record?: unknown;
+}
+
+/** One page of the records behind a cell (ADR-0063/0066): those carrying every Item of its paths and no
+ * Hidden Item of any placed field, under a Source Version. */
+export declare interface PivotDetailsQuery {
+    /** The Source Version the records are asked for under. */
+    readonly sourceVersion: string;
+    /** The row's Items, outermost first. */
+    readonly rowItems: readonly PivotFieldItem[];
+    /** The column's Items, outermost first. */
+    readonly columnItems: readonly PivotFieldItem[];
+    /** Every placed field's Hidden Items. */
+    readonly hiddenItems: readonly PivotQueryField[];
+    /** The place of the page's first record. */
+    readonly start: number;
+    /** The most records the page holds; every one, 2^31 − 1 as the C# engine's `int.MaxValue`, when the
+     * question was made without one, so that it crosses to a C# server as it is. */
+    readonly count: number;
+}
+
+/** A question for the records behind a cell, checked: a path naming a field twice, or Hidden Items given
+ * twice for one field, are refused by name. */
+export declare function pivotDetailsQuery({ sourceVersion, rowItems, columnItems, hiddenItems, start, count }: {
+    readonly sourceVersion: string;
+    readonly rowItems?: readonly PivotFieldItem[];
+    readonly columnItems?: readonly PivotFieldItem[];
+    readonly hiddenItems?: readonly PivotQueryField[];
+    readonly start?: number;
+    readonly count?: number;
+}): PivotDetailsQuery;
+
+/** A value a record behind a cell carries: text, an exact number, a double, a date by its clock ticks, a
+ * Boolean, or `null` for a Blank. A date part is the part's number. */
+export declare type PivotDetailValue = string | SnapshotDecimal | number | bigint | boolean | null;
+
+/** A value column of a report, with its Items. */
+export declare interface PivotDisplayColumn {
+    /** Its stable name. */
+    readonly name: string;
+    /** Its leaf header. */
+    readonly header: string;
+    /** An Item's column, a subtotal's, or the grand total's. */
+    readonly role: PivotColumnRole;
+    /** The Value Field it shows, or −1 when its rows say. */
+    readonly valueField: number;
+    /** The column's Items, each with its field. */
+    readonly columnPath: readonly PivotFieldItem[];
+}
+
+/** A row of a Window, detached from the report, the cube and the source. */
+export declare interface PivotDisplayRow {
+    /** What the row stands for. */
+    readonly role: PivotRowRole;
+    /** The Value Field the row shows, or −1 when its columns say. */
+    readonly valueField: number;
+    /** The row's Items, outermost first: with its role and Value Field, what it stands for across reports. */
+    readonly items: readonly PivotItemKey[];
+    /** Whether the row carries values: a group row whose subtotal stands at the bottom carries none. */
+    readonly carriesValues: boolean;
+    /** Its label in each label column. */
+    readonly labels: readonly PivotRowLabel[];
+    /** Its value in each value column, `undefined` for an empty cell. */
+    readonly values: readonly (PivotValue | undefined)[];
+    /** The row's Items, each with its field. */
+    readonly rowPath: readonly PivotFieldItem[];
+    /**
+     * Per value cell, the change that last moved its shown text: the Report Version whose data changed it,
+     * or `undefined` for a cell with no recent change and for every cell a layout gesture laid out. A cell keeps
+     * its mark while its text does not change, after the source stops listing the change, so that its row
+     * stays the same row. It says which change, never when: when a Change Highlight starts is the Consumer's,
+     * on its own clock ({@link PivotChangeTimes}, ADR-0068).
+     */
+    readonly changedIn: readonly (string | undefined)[];
+}
+
+/** An edit that may be refused: the layout it produced, or the unchanged layout and why not. */
+export declare interface PivotEditResult {
+    /** The new layout, or the one given when refused. */
+    readonly layout: PivotLayout;
+    /** Why the edit was refused. */
+    readonly refusal?: PivotRefusal;
+}
+
+/** A placed entry of an Area, as the Field List shows it (ADR-0061): a field in Filters, Rows or Columns,
+ * a Value Field, or Σ Values, whose index is −1 and which stands last in its Area. */
+export declare interface PivotEntry {
+    /** The Area it stands in. */
+    readonly area: PivotArea;
+    /** Its index in that Area's list; −1 for Σ Values. */
+    readonly index: number;
+}
+
+/** The text of `#NUM!`, the Item of a number no one can hold. */
+export declare const pivotErrorText = "#NUM!";
+
+/** How a fetching source asks its server. */
+export declare interface PivotFetchers {
+    /** Asks the server for the Leaf Aggregates of a question. */
+    readonly aggregate: (query: PivotQuery, signal?: AbortSignal) => Promise<PivotAnswer>;
+    /** Asks the server for a page of a field's Items. */
+    readonly items: (query: PivotItemsQuery, signal?: AbortSignal) => Promise<PivotItemPage>;
+    /** Asks the server for a page of the records behind a cell. */
+    readonly details: (query: PivotDetailsQuery, signal?: AbortSignal) => Promise<PivotDetailPage>;
+    /** Asks the server for each field's count of Items, when the features declare that it counts them. */
+    readonly itemCounts?: (signal?: AbortSignal) => Promise<PivotItemCounts>;
+    /**
+     * Starts the Consumer's transport telling the source that the server's data moved on (ADR-0370 section 3):
+     * WebSocket, server-sent events, SignalR or polling, the Consumer's own. The source calls it when its first
+     * listener subscribes, with the function the transport calls for each notice or Change Batch, and calls the
+     * function it returns when its last listener leaves.
+     */
+    readonly subscribe?: (notify: (notice: PivotServerNotice) => void) => () => void;
+}
+
+/** A Pivot Field as a source offers it: everything but how it is read from a record. */
+export declare interface PivotField {
+    /** What a Pivot Layout addresses it by; unique among the fields. */
+    readonly name: string;
+    /** What the Field List and the report call it. */
+    readonly caption: string;
+    /** The declared type, which decides the defaults (ADR-0060). */
+    readonly type: PivotFieldType;
+    /** A .NET format string an Item's number or date is labelled with, under the report's locale; absent for
+     * the value's own text. */
+    readonly format?: string;
+    /** Values whose Items come first, in this order, when the field is sorted by label. */
+    readonly itemOrder: readonly unknown[];
+    /** The Snapshot column the field reads, when it is not the column of its own name. */
+    readonly column?: string;
+    /** The part of a Date column the field is: its year, quarter or month. */
+    readonly datePart?: PivotDatePart;
+    /** The field's Order Key. */
+    readonly orderKey?: PivotOrderKey;
+}
+
+/** A field, its declaration checked and frozen. Refuses, with a TypeError, an empty name, an empty caption,
+ * an empty column, a format that cannot format the field's values and a date part of a field not declared
+ * Date; with a RangeError an unknown type or date part. */
+export declare function pivotField(input: PivotFieldInput): PivotField;
+
+/** What the Field List reads of a field: its name, caption and declared type. */
+export declare type PivotFieldInfo = Pick<PivotField, 'name' | 'caption' | 'type'>;
+
+/** A field's declaration, each setting left out taking its default: the name for the caption, no format,
+ * no declared order, the column of its own name, no Order Key. */
+export declare interface PivotFieldInput {
+    /** What a Pivot Layout addresses it by. */
+    readonly name: string;
+    /** The declared type. */
+    readonly type: PivotFieldType;
+    /** What the Field List and the report call it; its name when left out. */
+    readonly caption?: string;
+    /** A .NET format string its Items are labelled with. */
+    readonly format?: string;
+    /** Values whose Items come first, in this order. */
+    readonly itemOrder?: readonly unknown[];
+    /** The Snapshot column it reads; the column of its own name when left out. */
+    readonly column?: string;
+    /** The part of a Date column it is. */
+    readonly datePart?: PivotDatePart;
+    /** Its Order Key. */
+    readonly orderKey?: PivotOrderKey;
+}
+
+/** An Item of a field, as a cell's path names it. */
+export declare interface PivotFieldItem {
+    /** The field's name. */
+    readonly field: string;
+    /** The Item. */
+    readonly item: PivotItemKey;
+}
+
+/** A Pivot Field standing in Filters, Rows or Columns, with its settings, which travel with it when it
+ * moves between those Areas (ADR-0060/0061). */
+export declare interface PivotFieldPlacement {
+    /** The Pivot Field's name. */
+    readonly field: string;
+    /** The Item order. */
+    readonly sort: PivotSort;
+    /** The Items the user unticked: every record carrying one is left out of the report, totals included. */
+    readonly hiddenItems: readonly PivotItemKey[];
+    /** Whether an outer Item of this field has a subtotal (Excel's Automatic) or none. */
+    readonly subtotals: boolean;
+    /** The field-wide collapse state: true when every Item is collapsed but the toggled ones. */
+    readonly collapsed: boolean;
+    /** The Items whose collapse state is the opposite of `collapsed`. */
+    readonly toggledItems: readonly PivotItemKey[];
+}
+
+/** A placement's settings, each its default when left out: by label ascending, nothing hidden, subtotals
+ * Automatic, expanded. */
+export declare interface PivotFieldPlacementInput {
+    /** The Pivot Field's name. */
+    readonly field: string;
+    /** The Item order. */
+    readonly sort?: PivotSort;
+    /** The Items unticked. */
+    readonly hiddenItems?: readonly PivotItemKey[];
+    /** Whether an outer Item has a subtotal. */
+    readonly subtotals?: boolean;
+    /** The field-wide collapse state. */
+    readonly collapsed?: boolean;
+    /** The Items whose collapse state is the opposite of `collapsed`. */
+    readonly toggledItems?: readonly PivotItemKey[];
+}
+
+/** The type a Consumer declares for a Pivot Field (ADR-0060). It decides the defaults only: where a
+ * ticked field goes, which Aggregation a new Value Field takes. Each Item's kind comes from the data. */
+export declare type PivotFieldType = 'text' | 'number' | 'date' | 'boolean';
+
+/** Text that is not in the form it must be: a .NET format string .NET does not read, a word's template
+ * with a brace out of place, a Pivot Layout's JSON that is not one. The C# engine's FormatException. */
+export declare class PivotFormatError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+
+/** A Header Group span: a label over `columnCount` value columns from `firstColumn`, at a tier of the
+ * header, `tierSpan` tiers tall. */
+export declare interface PivotHeaderSpan {
+    /** The text over the span. */
+    readonly label: string;
+    /** The first value column under it. */
+    readonly firstColumn: number;
+    /** How many value columns it spans. */
+    readonly columnCount: number;
+    /** Its tier, from 0 at the top. */
+    readonly tier: number;
+    /** How many tiers tall it is. */
+    readonly tierSpan: number;
+}
+
+/**
+ * Each field's count of Items, under the Source Version it was counted at (ADR-0370 section 3): what a
+ * server's source answers when its features declare {@link PivotSourceFeatures.countsItems}, so that the
+ * Field List shows the count beside a field and a layout's leaves are bounded before it is asked
+ * ({@link pivotLeafBound}). A field the source did not count is absent, never zero.
+ */
+export declare class PivotItemCounts {
+    /** The Source Version the Items were counted at. */
+    readonly sourceVersion: string;
+    /** Each counted field's count of Items, by the field's name. */
+    readonly counts: ReadonlyMap<string, number>;
+    /** The counts of a Source Version, refusing a count that is not a whole number of at least 0. */
+    constructor(sourceVersion: string, counts: Iterable<readonly [string, number]>);
+    /** The field's count of Items, or `undefined` when the source did not count it. */
+    countOf(field: string): number | undefined;
+}
+
+/** One Item as Filter… lists it (ADR-0061): its key as a layout writes it, what it is painted as, and
+ * whether the layout hides it now. */
+export declare interface PivotItemInfo {
+    /** The Item's key, as a layout writes it. */
+    readonly key: PivotItemKey;
+    /** What it is painted as. */
+    readonly label: string;
+    /** Whether the layout hides it now. */
+    readonly isHidden: boolean;
+}
+
+/** An Item as a Pivot Layout writes it: its kind and its invariant text, which a Blank has none of. */
+export declare interface PivotItemKey {
+    /** The Item's kind. */
+    readonly kind: PivotItemKind;
+    /** Its invariant text; absent only for a Blank. */
+    readonly value?: string;
+}
+
+/**
+ * Names one Item, refusing a value that is not the invariant text of its kind: a key that could not name
+ * any Item is a mapping bug, not an Item nobody has. A number's text is read as .NET reads a float (spaces,
+ * a sign, a point and an exponent), and a date's as `yyyy-MM-ddTHH:mm:ss` with up to seven digits of a
+ * second; the text is kept as it was given.
+ */
+export declare function pivotItemKey(kind: PivotItemKind, value?: string): PivotItemKey;
+
+/** The Item the value of `column` at `row` belongs to, as the engine groups a field over that column: a number
+ * by its double, a Decimal by the double C# converts it to, a date by its clock value, and a Blank as Blank. */
+export declare function pivotItemKeyAt(column: SnapshotColumn, row: number): PivotItemKey;
+
+/** What a public key compares as, as a Map key: its kind, and its text folded where text is compared
+ * ignoring case. Two keys equal by {@link itemKeysEqual} have one. */
+export declare function pivotItemKeyId(key: PivotItemKey): string;
+
+/** The kind of an Item, which comes from its value (ADR-0060). {@link pivotItemKinds} is the ascending
+ * order across kinds. */
+export declare type PivotItemKind = 'number' | 'date' | 'text' | 'boolean' | 'error' | 'blank';
+
+/** Every Item kind, in the ascending order across kinds: numbers, dates, text, Booleans, `#NUM!`, then
+ * `(blank)`. */
+export declare const pivotItemKinds: readonly PivotItemKind[];
+
+/** A page of a field's Items (ADR-0066), under the Source Version they were listed at, or a refusal. */
+export declare class PivotItemPage {
+    #private;
+    /** The refusal, when the source refused. */
+    readonly refusal: PivotSourceRefusal | undefined;
+    private constructor();
+    /** A page: the Items listed, and how many match in all. */
+    static of(sourceVersion: string, items: readonly PivotItemKey[], total: number): PivotItemPage;
+    /** The source's refusal to list the Items. */
+    static refused(refusal: PivotSourceRefusal): PivotItemPage;
+    /** Whether the source refused. */
+    get isRefused(): boolean;
+    /** The Source Version the Items were listed at. */
+    get sourceVersion(): string;
+    /** The Items listed. */
+    get items(): readonly PivotItemKey[];
+    /** How many Items match in all, the listed ones included. */
+    get total(): number;
+}
+
+/** A field's Items over all the data, under a Source Version (ADR-0066). */
+export declare interface PivotItemsQuery {
+    /** The field whose Items are asked for. */
+    readonly field: string;
+    /** The Source Version they are asked for under. */
+    readonly sourceVersion: string;
+    /** Only the Items whose invariant text holds this, ignoring case. */
+    readonly search?: string;
+    /** The most Items the page lists. */
+    readonly max: number;
+}
+
+/** A question for a field's Items, checked: an empty search is no search. */
+export declare function pivotItemsQuery(input: {
+    readonly field: string;
+    readonly sourceVersion: string;
+    readonly search?: string;
+    readonly max?: number;
+}): PivotItemsQuery;
+
+/** The value the Item `key` names hands an Order Key (ADR-0060): a text Item's text, a number's number, a date's
+ * clock ticks, a Boolean's Boolean; `undefined` for a Blank and for #NUM!. A source that answers an Order Key's
+ * keys for the Items it names files them under this. */
+export declare function pivotItemValue(key: PivotItemKey): string | number | bigint | boolean | undefined;
+
+/**
+ * Every Pivot Source question and answer as JSON (ADR-0066), so it crosses to a server unchanged — the C#
+ * engine's `PivotJson`, which writes each document as the same text. Each document names its format's
+ * `version` and its `type`; a reader refuses, with a {@link PivotVersionError}, a version it does not know
+ * rather than half-read it, and, with a {@link PivotFormatError}, a document of another type or one that
+ * cannot be, naming what is wrong. An exact decimal crosses as its digits and a double as its shortest
+ * round-trip text, a non-finite one by name (`"NaN"`, `"Infinity"`, `"-Infinity"`); a part that is exact or
+ * not, a sum or an extreme, is a JSON number when it is exact and a JSON string when it is a double. An
+ * answer's leaves are written column by column: one array per level and per part, never an object per leaf.
+ */
+export declare const PivotJson: Readonly<{
+    /** The format version this writer writes and the only one this reader reads. */
+    version: 1;
+    /** A question for the Leaf Aggregates, as JSON. */
+    writeQuery(query: PivotQuery): string;
+    /** The Leaf Aggregates, or a refusal, as JSON: the leaves column by column. */
+    writeAnswer(answer: PivotAnswer): string;
+    /** A question for a field's Items, as JSON. */
+    writeItemsQuery(query: PivotItemsQuery): string;
+    /** A page of Items, or a refusal, as JSON. */
+    writeItemPage(page: PivotItemPage): string;
+    /** A question for the records behind a cell, as JSON. */
+    writeDetailsQuery(query: PivotDetailsQuery): string;
+    /** A page of the records behind a cell, or a refusal, as JSON. Each value is written by its field's
+     * declared type, and one of another type tagged with its own; the Consumer's own record objects are not
+     * written. */
+    writeDetailPage(page: PivotDetailPage): string;
+    /** A source's notice that its data moved on, as JSON. */
+    writeSourceChanged(change: PivotSourceChanged): string;
+    /**
+     * A server's Change Batch (ADR-0370 section 3), as JSON: the records its data lost and gained between two
+     * Source Versions, each value by its field's declared type, under the names and types of the fields they
+     * are in, so a reader whose fields differ refuses the batch rather than place its values in the wrong ones.
+     */
+    writeChangeBatch(batch: PivotServerChangeBatch, fields: readonly PivotField[]): string;
+    /** Each field's count of Items (ADR-0370 section 3), as JSON: `counts` holds a member per counted field. */
+    writeItemCounts(counts: PivotItemCounts): string;
+    /** A question read back from {@link PivotJson.writeQuery}'s JSON. */
+    readQuery(json: string): PivotQuery;
+    /**
+     * An answer read back from {@link PivotJson.writeAnswer}'s JSON. Refuses by name a leaf array of the wrong
+     * length, an Item index out of range, two Items of one field that are one Item, counts that cannot be —
+     * more numbers than values, more values than records — and a part in a form it cannot be: an exact
+     * number no decimal holds exactly among them, which is refused rather than rounded.
+     */
+    readAnswer(json: string): PivotAnswer;
+    /** A question for a field's Items read back from {@link PivotJson.writeItemsQuery}'s JSON. */
+    readItemsQuery(json: string): PivotItemsQuery;
+    /** A page of Items read back from {@link PivotJson.writeItemPage}'s JSON. */
+    readItemPage(json: string): PivotItemPage;
+    /** A question for the records behind a cell read back from {@link PivotJson.writeDetailsQuery}'s JSON. */
+    readDetailsQuery(json: string): PivotDetailsQuery;
+    /** A page of the records behind a cell read back from {@link PivotJson.writeDetailPage}'s JSON, each value
+     * read by its field's declared type. The records carry no object of the Consumer's: those never left the
+     * process. */
+    readDetailPage(json: string): PivotDetailPage;
+    /** A source's notice read back from {@link PivotJson.writeSourceChanged}'s JSON. */
+    readSourceChanged(json: string): PivotSourceChanged;
+    /**
+     * A notice a server sent a fetching source (ADR-0370 section 3), read back from
+     * {@link PivotJson.writeSourceChanged}'s or {@link PivotJson.writeChangeBatch}'s JSON, to hand to the fetchers'
+     * `notify`. A batch is read against the source's `fields`: one written under other names or types, or in
+     * another order, is refused by name.
+     */
+    readServerNotice(json: string, fields: readonly PivotField[]): PivotServerNotice;
+    /** Each field's count of Items read back from {@link PivotJson.writeItemCounts}'s JSON; a field named twice
+     * is refused. */
+    readItemCounts(json: string): PivotItemCounts;
+}>;
+
+/** The Consumer's word for an id, or `undefined` to keep the English. */
+export declare type PivotLabel = (id: string) => string | undefined;
+
+/** A label column: `row-labels` in the Compact form, `row:<field>` a field in the others. */
+export declare interface PivotLabelColumn {
+    /** Its name, stable across reports, so a width survives. */
+    readonly name: string;
+    /** Its header's text. */
+    readonly header: string;
+    /** The row field it labels, or `undefined` for Compact's one column and for Σ Values's. */
+    readonly field: string | undefined;
+}
+
+/** The widths of the grid's character classes and of single glyphs, in pixels. Plain data, so it crosses
+ * to a Worker as it is. */
+export declare interface PivotLabelMetrics {
+    /** `%`, `€`, `−`, `+`, `#`. */
+    readonly wideWidthPx: number;
+    /** Digits, currency signs, `E`, `-`, the apostrophes and spaces numbers are grouped with, and the marks of
+     * direction. */
+    readonly digitWidthPx: number;
+    /** `.`, `,`, `(`, `)`, `/`, `:` and the space. */
+    readonly narrowWidthPx: number;
+    /** A full-width character: CJK, kana, Hangul, full-width forms. */
+    readonly fullWidthPx: number;
+    /** Any other character. */
+    readonly otherWidthPx: number;
+    /** The padding on one side of a cell. */
+    readonly cellHorizontalPaddingPx: number;
+    /** The width of single glyphs outside the classes, by code point. */
+    readonly glyphWidths?: Readonly<Record<number, number>>;
+}
+
+/** Which Pivot Fields stand in which Areas, and the report's form and totals (ADR-0059). */
+export declare interface PivotLayout {
+    /** The report filter's fields, in order. */
+    readonly filters: readonly PivotFieldPlacement[];
+    /** The row fields, outermost first. */
+    readonly rows: readonly PivotFieldPlacement[];
+    /** The column fields, outermost first. */
+    readonly columns: readonly PivotFieldPlacement[];
+    /** The Value Fields, in order. */
+    readonly values: readonly PivotValueField[];
+    /** Where Σ Values stands when there are two or more Value Fields. */
+    readonly valuesAxis: PivotAxis;
+    /** How the row labels are set out. */
+    readonly form: PivotReportForm;
+    /** Whether a subtotal is carried on its group row (Excel's default) or has a row of its own at the
+     * bottom. The Tabular form always puts it at the bottom. */
+    readonly subtotalsAtTop: boolean;
+    /** Whether the `Grand Total` row is painted at the bottom: Excel's "grand totals for columns". */
+    readonly grandTotalRow: boolean;
+    /** Whether the `Grand Total` column is painted at the right: Excel's "grand totals for rows". */
+    readonly grandTotalColumn: boolean;
+    /** Whether every row of the Outline and Tabular forms repeats its outer Items' labels. */
+    readonly repeatItemLabels: boolean;
+}
+
+/**
+ * One choice of the Layout menu on the Pivot Toolbar (ADR-0061): Excel's Design tab settings, under
+ * Excel's names, in Excel's order — Subtotals, Grand Totals, then Report Layout. Excel's Blank Rows is left
+ * out: the engine has no blank row.
+ */
+export declare type PivotLayoutChoice = 'doNotShowSubtotals' | 'showSubtotalsAtBottom' | 'showSubtotalsAtTop' | 'grandTotalsOff' | 'grandTotalsOn' | 'grandTotalsOnRowsOnly' | 'grandTotalsOnColumnsOnly' | 'compactForm' | 'outlineForm' | 'tabularForm' | 'repeatItemLabels' | 'doNotRepeatItemLabels';
+
+/** The Layout menu's choices, in Excel's order. */
+export declare const pivotLayoutChoices: readonly PivotLayoutChoice[];
+
+/** A layout's settings, each its default when left out: no field anywhere, Σ Values in Columns, the
+ * Compact form, subtotals at the top, both grand totals, labels not repeated. A placement or a Value Field
+ * may be given by its field's name alone. */
+export declare interface PivotLayoutInput {
+    /** The report filter's fields. */
+    readonly filters?: readonly (string | PivotFieldPlacementInput)[];
+    /** The row fields, outermost first. */
+    readonly rows?: readonly (string | PivotFieldPlacementInput)[];
+    /** The column fields, outermost first. */
+    readonly columns?: readonly (string | PivotFieldPlacementInput)[];
+    /** The Value Fields. */
+    readonly values?: readonly (string | PivotValueFieldInput)[];
+    /** Where Σ Values stands. */
+    readonly valuesAxis?: PivotAxis;
+    /** How the row labels are set out. */
+    readonly form?: PivotReportForm;
+    /** Whether a subtotal is carried on its group row. */
+    readonly subtotalsAtTop?: boolean;
+    /** Whether the `Grand Total` row is painted. */
+    readonly grandTotalRow?: boolean;
+    /** Whether the `Grand Total` column is painted. */
+    readonly grandTotalColumn?: boolean;
+    /** Whether the Outline and Tabular forms repeat outer labels. */
+    readonly repeatItemLabels?: boolean;
+}
+
+/** The version this writer writes and the only one this reader reads. */
+export declare const pivotLayoutJsonVersion = 1;
+
+/**
+ * The most leaves `layout` can make, at most {@link pivotLeafBoundMost}: the product, over the fields in
+ * Rows and Columns, of each field's count less the Items the layout hides of it. The leaves are the
+ * combinations of those Items that some record carries, so they are never more while the counts are the
+ * data's and every Hidden Item is among them; Filters and the Values add none. `undefined` when a field the
+ * layout places in Rows or Columns was not counted. The bound is a hint for the drop target's mark only: a
+ * count gone stale, or a Hidden Item the data no longer holds, moves the mark, never the answer, and the
+ * question is asked with its `maxLeaves` all the same.
+ */
+export declare function pivotLeafBound(layout: PivotLayout, counts: PivotItemCounts): number | undefined;
+
+/** Where a bound stops growing: 2^53 − 1, the largest whole number held exactly, as the C# engine stops. */
+export declare const pivotLeafBoundMost: number;
+
+/**
+ * How a row field's Items are ordered among their siblings (ADR-0370 section 3): by a field in Values under an
+ * Aggregation, read at the grand total of the columns, as the report sorts them. A sibling whose value is not
+ * a number follows every number, in either direction. What a window of a sibling set is cut from.
+ */
+export declare interface PivotLevelOrder {
+    /** The field in Values, by its place in the question's `values`. */
+    readonly value: number;
+    /** The Aggregation read of it. */
+    readonly aggregation: PivotAggregation;
+    /** Whether the largest comes first. */
+    readonly descending: boolean;
+}
+
+/**
+ * One field's rule of a question's levels (ADR-0370 section 3): whether its Items are collapsed, and the
+ * Items whose state is the other. Item `x` is expanded when `collapsed` is not `x ∈ toggledItems`; the Items
+ * of the innermost field have nothing below them, and their rule changes nothing.
+ */
+export declare interface PivotLevelRule {
+    /** Whether its Items are collapsed, but for the toggled ones. */
+    readonly collapsed: boolean;
+    /** The Items whose state is the other of `collapsed`. */
+    readonly toggledItems: readonly PivotItemKey[];
+    /** How a row field's Items are ordered by a value, for a question with a window; none for a field
+     * ordered by label, and for a column field. */
+    readonly order?: PivotLevelOrder;
+}
+
+/** A rule, checked and frozen. */
+export declare function pivotLevelRule(input?: PivotLevelRuleInput): PivotLevelRule;
+
+/** A rule's settings, each left out taking its default: every Item expanded, ordered by label. */
+export declare interface PivotLevelRuleInput {
+    /** Whether the Items are collapsed, but for the toggled ones. */
+    readonly collapsed?: boolean;
+    /** The Items whose state is the other. */
+    readonly toggledItems?: readonly PivotItemKey[];
+    /** How the Items are ordered by a value. */
+    readonly order?: PivotLevelOrder;
+}
+
+/**
+ * Which groups a report shows, as a question for Level Aggregates carries them (ADR-0370 section 3): one
+ * rule a row field and one a column field. A group is shown when every Item above it is expanded, and the
+ * grand total always is; a cell is a shown row group crossed with a shown column group. A server can turn
+ * them into `GROUPING SETS` without knowing the report.
+ */
+export declare interface PivotLevels {
+    /** The row fields' rules, outermost first. */
+    readonly rows: readonly PivotLevelRule[];
+    /** The column fields' rules, outermost first. */
+    readonly columns: readonly PivotLevelRule[];
+    /** The window of the sets ordered by a value; none, and every set is answered whole. */
+    readonly window?: PivotLevelWindow;
+}
+
+/**
+ * The window of a question's levels (ADR-0370 section 3): a sibling set ordered by a value with more than
+ * `limit` siblings is answered as a window of them, starting where `starts` says for its parent, or at the
+ * first, and no further than `limit` from the end; with what lies on either side merged.
+ */
+export declare interface PivotLevelWindow {
+    /** The most siblings a set ordered by a value is answered with whole. */
+    readonly limit: number;
+    /** Where the windows start, one a parent at most. */
+    readonly starts: readonly PivotWindowStart[];
+}
+
+/** A window's settings: its limit, and where its windows start, none by default. */
+export declare interface PivotLevelWindowInput {
+    /** The most siblings a set ordered by a value is answered with whole. */
+    readonly limit: number;
+    /** Where the windows start. */
+    readonly starts?: readonly PivotWindowStart[];
+}
+
+/** The locales the engine formats in, by their .NET names. */
+export declare function pivotLocales(): readonly string[];
+
+/** A number a part carries: exact while every number it was made of was, a double otherwise. */
+export declare type PivotNumber = {
+    readonly kind: 'exact';
+    readonly value: SnapshotDecimal;
+} | {
+    readonly kind: 'double';
+    readonly value: number;
+};
+
+/** The Average of `count` numbers whose sum is `sum`: exact where the sum is, divided as C#'s decimal divides by a
+ * whole count, and a double otherwise, as a Selection Summary's Average over the report reads it (ADR-0130). */
+export declare function pivotNumberAverage(sum: PivotNumber, count: number): PivotNumber;
+
+/** The number without trailing zeros where it is exact, as C#'s accumulator finishes a figure (`AggregateArithmetic.Canonical`). */
+export declare function pivotNumberCanonical(number: PivotNumber): PivotNumber;
+
+/**
+ * What is wrong with a number format, or `undefined` when nothing is (PivotNumberFormat.Check): empty,
+ * longer than 64 characters, a standard format asking for more than 30 digits, or one .NET cannot format
+ * a number with.
+ */
+export declare function pivotNumberFormatProblem(format: string): string | undefined;
+
+/** The number as a double: the exact one converted as C# converts a decimal. */
+export declare function pivotNumberValue(number: PivotNumber): number;
+
+/** What a report is laid out in: a locale — a BCP 47 tag or `invariant` — and the words it is written in. */
+export declare interface PivotOptions {
+    /** The locale numbers and dates are written in and text is ordered by (ADR-0370 §10); the browser's
+     * language when left out. */
+    readonly locale?: string;
+    /** The report's words by id, for those the Consumer translates; English for the rest. */
+    readonly label?: PivotLabel;
+}
+
+/**
+ * A field's Order Key (ADR-0060): from an Item's value — the text of a text Item (its first spelling), the
+ * number of a number Item, the clock ticks of a date, the Boolean of a Boolean — to what the Items are
+ * ordered by. Called once per Item where the report is laid out; one that throws is refused, naming the
+ * field and the Item.
+ */
+export declare type PivotOrderKey = (value: string | number | bigint | boolean) => PivotOrderKeyValue | null | undefined;
+
+/** A field's Order Key failed on an Item, or gave its Items keys of two types (ADR-0060): the order is
+ * refused, naming the field and the value, rather than fall back to the labels. */
+export declare class PivotOrderKeyError extends Error {
+    /** The name of the field whose Order Key failed. */
+    readonly field: string;
+    constructor(field: string, message: string, options?: ErrorOptions);
+}
+
+/** What an Order Key gives an Item: a value Items are ordered by, ascending; one field's keys are all of
+ * one type. `null` or `undefined` gives the Item no key. */
+export declare type PivotOrderKeyValue = string | number | bigint | boolean;
+
+/** A part of a Leaf Aggregate beyond the counts, which always travel (ADR-0066). */
+export declare type PivotPart = 'sum' | 'extremes' | 'product' | 'variance';
+
+/** The parts in their order. */
+export declare const pivotParts: readonly PivotPart[];
+
+/** The question for a report's Leaf Aggregates. */
+export declare interface PivotQuery {
+    /** The row fields, outermost first. */
+    readonly rows: readonly PivotQueryField[];
+    /** The column fields, outermost first. */
+    readonly columns: readonly PivotQueryField[];
+    /** The Filters that hide something; one that hides nothing leaves every record in. */
+    readonly filters: readonly PivotQueryField[];
+    /** Each field in Values, once, with the parts its Value Fields read. */
+    readonly values: readonly PivotQueryValue[];
+    /** The most leaves the answer may have; one more refuses the question. */
+    readonly maxLeaves: number;
+    /**
+     * Which groups the report shows, for a source that answers Level Aggregates (ADR-0370 section 3): it may
+     * then answer, when the leaves would pass the cap, with the cells of the groups shown instead
+     * (an answer's `isLevels`). Left out, the question asks for the leaves alone.
+     */
+    readonly levels?: PivotLevels;
+}
+
+/**
+ * A question, checked and frozen: a field placed twice among Filters, Rows and Columns, or asked for twice in
+ * Values, is refused with a TypeError naming it; a cap below 1 with a RangeError.
+ */
+export declare function pivotQuery(input?: PivotQueryInput): PivotQuery;
+
+/** A field placed in Rows, Columns or Filters, with the Items it hides. */
+export declare interface PivotQueryField {
+    /** The field's name. */
+    readonly field: string;
+    /** The Items whose records are left out. */
+    readonly hiddenItems: readonly PivotItemKey[];
+}
+
+/** A question's settings, each left out taking its default: no field anywhere and the default cap. */
+export declare interface PivotQueryInput {
+    /** The row fields, by name or with their Hidden Items. */
+    readonly rows?: readonly (string | {
+        readonly field: string;
+        readonly hiddenItems?: readonly PivotItemKey[];
+    })[];
+    /** The column fields. */
+    readonly columns?: readonly (string | {
+        readonly field: string;
+        readonly hiddenItems?: readonly PivotItemKey[];
+    })[];
+    /** The Filters that hide something. */
+    readonly filters?: readonly (string | {
+        readonly field: string;
+        readonly hiddenItems?: readonly PivotItemKey[];
+    })[];
+    /** The fields in Values, by name or with their parts. */
+    readonly values?: readonly (string | {
+        readonly field: string;
+        readonly parts?: readonly PivotPart[];
+    })[];
+    /** The cap on leaves; {@link defaultMaxLeaves} when left out. */
+    readonly maxLeaves?: number;
+    /** Which groups the report shows, one rule a row and a column field, and the window of the sets ordered by a
+     * value; none when left out. */
+    readonly levels?: {
+        readonly rows?: readonly PivotLevelRuleInput[];
+        readonly columns?: readonly PivotLevelRuleInput[];
+        readonly window?: PivotLevelWindowInput;
+    };
+}
+
+/** A field in Values, and the parts its Value Fields' Aggregations read. */
+export declare interface PivotQueryValue {
+    /** The field's name. */
+    readonly field: string;
+    /** The parts asked for beyond the counts. */
+    readonly parts: readonly PivotPart[];
+}
+
+/** A Pivot Field over records in memory: a field and how it is read from one record. */
+export declare interface PivotRecordField<TRecord> extends PivotField {
+    /** Reads the field from a record; `null` or `undefined` is a Blank. */
+    readonly value: (record: TRecord) => unknown;
+}
+
+/** A record field, its declaration checked as {@link pivotField} checks it, and its accessor a function. */
+export declare function pivotRecordField<TRecord>(input: PivotRecordFieldInput<TRecord>): PivotRecordField<TRecord>;
+
+/** A record field's declaration. */
+export declare interface PivotRecordFieldInput<TRecord> extends PivotFieldInput {
+    /** Reads the field from a record; `null` or `undefined` is a Blank. */
+    readonly value: (record: TRecord) => unknown;
+}
+
+/** Why the Field List refused an edit (ADR-0060/0061). */
+export declare type PivotRefusal = 'hidesEveryItem' | 'captionTaken' | 'captionEmpty' | 'numberFormatInvalid';
+
+/** The refusals, worded as the C# engine words them. */
+export declare const PivotRefusals: Readonly<{
+    /** "This layout needs more than 200,000 cells." */
+    tooManyLeaves: (maxLeaves: number) => PivotSourceRefusal;
+    /** A field the source does not have. */
+    unknownField: (field: string) => PivotSourceRefusal;
+    /** A part that only Aggregations the source does not offer read. */
+    aggregationNotOffered: (field: string, aggregations: readonly PivotAggregation[]) => PivotSourceRefusal;
+    /** A question asked under a Source Version the source no longer holds. */
+    sourceVersionNotHeld: (sourceVersion: string) => PivotSourceRefusal;
+}>;
+
+/** A report: its columns, its rows, and the value at each row and column. */
+export declare class PivotReport {
+    #private;
+    /** The layout it was laid out under. */
+    readonly layout: PivotLayout;
+    /** The label columns, left to right. */
+    readonly labelColumns: readonly PivotLabelColumn[];
+    /** The value columns, left to right. */
+    readonly valueColumns: readonly PivotReportColumn[];
+    /** The Header Group spans over the value columns. */
+    readonly headerSpans: readonly PivotHeaderSpan[];
+    /** How many tiers the column header has above the leaf headers. */
+    readonly headerTierCount: number;
+    /** The rows, top to bottom. */
+    readonly rows: readonly PivotReportRow[];
+    /** Each Value Field's caption. */
+    readonly valueCaptions: readonly string[];
+    /** The cube it was laid out from. */
+    readonly cube: PivotCube;
+    private constructor();
+    /** The locale the report is written in. */
+    get locale(): string;
+    /** Whether the layout places no field at all. */
+    get isEmpty(): boolean;
+    /** Whether the other report's rows stand, one for one, for what this one's do. */
+    hasSameRowsAs(other: PivotReport | undefined): boolean;
+    /**
+     * {@link PivotReport.hasSameRowsAs} in slices (ADR-0066, PV-40): the rows compared a piece at a time, yielding
+     * between slices as `slicing` paces them — a refresh of a large report compares every row. Once `signal` is
+     * aborted, it stops at the next slice and rejects with the signal's reason.
+     */
+    hasSameRowsAsAsync(other: PivotReport | undefined, slicing?: PivotSlicing, signal?: AbortSignal): Promise<boolean>;
+    /** The row's Items, outermost first, each with its field. */
+    rowPath(row: PivotReportRow): readonly PivotFieldItem[];
+    /** The value column's Items, outermost first, each with its field. */
+    columnPath(valueColumn: number): readonly PivotFieldItem[];
+    /** The question for the records behind a cell (ADR-0063): its row's and its column's Items, and every
+     * placed field's Hidden Items, under the cube's Source Version. A column of −1 asks for the row's. */
+    detailsQuery(row: PivotReportRow, valueColumn: number, start?: number, count?: number): PivotDetailsQuery;
+    /** The Value Field a cell shows: its row's, its column's, the one Value Field, or −1 for none. */
+    valueFieldAt(row: PivotReportRow, valueColumn: number): number;
+    /** The value at a row and a value column as the report shows it, or `undefined` for an empty cell. */
+    valueAt(row: PivotReportRow, valueColumn: number): PivotValue | undefined;
+}
+
+/**
+ * Lays a cube out under a layout (ADR-0060): the rows, the label columns, the value columns and their
+ * Header Group spans. Cheap — nothing is asked of the source. Refuses a layout the cube does not hold.
+ */
+export declare function pivotReport(cube: PivotCube, layout: PivotLayout, options?: PivotOptions): PivotReport;
+
+/** A Window answered. */
+export declare interface PivotReportAnswer extends PivotReportState {
+    /** The request answered. */
+    readonly requestId: string;
+    /** None: the Window was answered. */
+    readonly refusal?: undefined;
+}
+
+/**
+ * {@link pivotReport} in slices (PV-40): each tree walked a node at a time and thousands of siblings ordered
+ * a piece at a time, yielding between slices as `slicing` paces them. It gives the report {@link pivotReport}
+ * gives, and rejects with what it throws, an Order Key that fails included. Once `signal` is aborted, it stops at
+ * the next slice and rejects with the signal's reason.
+ */
+export declare function pivotReportAsync(cube: PivotCube, layout: PivotLayout, options?: PivotOptions, slicing?: PivotSlicing, signal?: AbortSignal): Promise<PivotReport>;
+
+/** A value column of a report. */
+export declare class PivotReportColumn {
+    #private;
+    /** Its role, its Items and its Value Field's caption: stable across reports, so a width survives. */
+    readonly name: string;
+    /** Its leaf header's text. */
+    readonly header: string;
+    /** An Item's column, a subtotal's, or the grand total's. */
+    readonly role: PivotColumnRole;
+    /** The Value Field it shows, or −1 when its rows say. */
+    readonly valueField: number;
+    /** The number a number column Item's leaf header shows, in full, for its copy. */
+    readonly headerNumber: number | undefined;
+    private constructor();
+}
+
+/** One copied rectangle, with its headers. */
+export declare interface PivotReportCopyBlock {
+    /** The headers, in the rectangle's column order. */
+    readonly headers: readonly string[];
+    /** Each header's raw form for a copy's HTML flavour: a number column Item's header carries its number in
+     * full (ADR-0005's note of 2026-10-13), any other `undefined`. Absent when no header has one. */
+    readonly headerRaws?: readonly (string | undefined)[];
+    /** Every cell of its rows. */
+    readonly rows: readonly (readonly PivotReportCopyCell[])[];
+}
+
+/** A copied cell: its text, and its locale-free form. */
+export declare interface PivotReportCopyCell {
+    /** The shown text. */
+    readonly text: string;
+    /** The raw, locale-free text — a number in full — or absent for a blank. */
+    readonly raw?: string;
+    /** Whether the raw text is a number. */
+    readonly isNumber: boolean;
+}
+
+/** A versioned Copy: each rectangle copied whole, in the order given. */
+export declare interface PivotReportCopyQuery {
+    /** The report the selection was made on. */
+    readonly version: string;
+    /** The columns' names, in the Consumer's order. */
+    readonly columns: readonly string[];
+    /** The selected rectangles. */
+    readonly ranges: readonly PivotReportRange[];
+    /** The most cells copied; 1,000,000 when left out. A copy past it is refused, never cut short (spine 1). */
+    readonly maxCells?: number;
+}
+
+/** A Copy, or a refusal. */
+export declare interface PivotReportCopyResult {
+    /** The report answered. */
+    readonly version: string;
+    /** One block per rectangle asked for. */
+    readonly blocks: readonly PivotReportCopyBlock[];
+    /** Why it was not copied. */
+    readonly refusal?: PivotReportRefusal;
+}
+
+/**
+ * The question for the records behind a cell of a report — Show Details (ADR-0063, ADR-0151) — from a row of
+ * its Window and the report's own layout and columns: the row's Items, the value column's (none for a label
+ * cell, column −1), the Hidden Items the report was computed under, the page, and its Source Version. Made of
+ * values, it stays the same question after any later layout, and is answered while the Pivot Source holds that
+ * Source Version.
+ */
+export declare function pivotReportDetailsQuery(metadata: PivotReportMetadata, row: PivotDisplayRow, valueColumn: number, start?: number, count?: number): PivotDetailsQuery;
+
+/** How a report sets out its row labels: Excel's "Report Layout" (ADR-0060). */
+export declare type PivotReportForm = 'compact' | 'outline' | 'tabular';
+
+/** A field's Items as the report labels and orders them, under a Report Version. */
+export declare interface PivotReportItemsQuery {
+    /** The report the Items are listed for. */
+    readonly version: string;
+    /** The field. */
+    readonly field: string;
+    /** What the Items' text holds, where the source searches. */
+    readonly search?: string;
+    /** The most Items listed; 10,000 when left out. */
+    readonly max?: number;
+}
+
+/** A field's Items in the report's order, or a refusal. */
+export declare interface PivotReportItemsResult {
+    /** The report answered. */
+    readonly version: string;
+    /** Its Source Version, or `''` where the version is not held. */
+    readonly sourceVersion: string;
+    /** The Items, labelled, in the field's order. */
+    readonly items: readonly PivotItemInfo[];
+    /** How many Items matched before the cap. */
+    readonly total: number;
+    /** Why they were not listed. */
+    readonly refusal?: PivotReportRefusal;
+}
+
+/** The whole report's extent and columns, without its rows or its data. */
+export declare interface PivotReportMetadata {
+    /** The Report Version: one report, immutable, under its layout and settings. */
+    readonly version: string;
+    /** The Source Version the report was computed from. */
+    readonly sourceVersion: string;
+    /** Changes when the ordered sequence of the rows' identities changes. */
+    readonly rowSequenceVersion: string;
+    /** The layout it was laid out under. */
+    readonly layout: PivotLayout;
+    /** The settings it was laid out under. */
+    readonly settings: PivotReportSettings;
+    /** The whole report's row count, rows outside the Window included. */
+    readonly rowCount: number;
+    /** The label columns. */
+    readonly labelColumns: readonly PivotLabelColumn[];
+    /** The value columns. */
+    readonly valueColumns: readonly PivotDisplayColumn[];
+    /** The Header Group spans. */
+    readonly headerSpans: readonly PivotHeaderSpan[];
+    /** How many tiers the column header has above the leaf headers. */
+    readonly headerTierCount: number;
+    /** Each Value Field's caption. */
+    readonly valueCaptions: readonly string[];
+    /** The widest label of each label column under the settings' label geometry, in pixels; none without it. */
+    readonly labelWidths: readonly number[];
+    /** The changes the source still marks, newest first: a cell marked with one changed recently, and a
+     * Consumer stamps each the first time it shows a Window listing it ({@link PivotChangeTimes}). A change
+     * leaves the list once it is older than the settings' highlight duration, and never comes back. */
+    readonly changeMarks: readonly string[];
+}
+
+/** A rectangle of a selection, its edges included: rows of the report, columns among the query's columns. */
+export declare interface PivotReportRange {
+    /** The first row. */
+    readonly top: number;
+    /** The first column. */
+    readonly left: number;
+    /** The last row. */
+    readonly bottom: number;
+    /** The last column. */
+    readonly right: number;
+}
+
+/** A refusal by name; an empty answer is never given in its place. */
+export declare interface PivotReportRefusal {
+    /** Why. */
+    readonly kind: PivotReportRefusalKind;
+    /** A sentence a person can read. */
+    readonly message: string;
+    /** The field it concerns, where one does. */
+    readonly field?: string;
+    /** The Pivot Source's own refusal, when it refused the question. */
+    readonly sourceRefusal?: PivotSourceRefusal;
+}
+
+/** Why a report source did not answer: `rowsNotAnswered` is a Copy or a Selection Summary that reaches Pending
+ * Rows, the siblings a Pivot Source answered a Sibling Window beside (ADR-0370 section 3). */
+export declare type PivotReportRefusalKind = 'reportVersionNotHeld' | 'unknownOrderKeyPolicy' | 'sourceRefused' | 'invalidRequest' | 'orderKeyFailed' | 'rowsNotAnswered';
+
+/** A Window refused. */
+export declare interface PivotReportRefused {
+    /** The request refused. */
+    readonly requestId: string;
+    /** The Window asked for. */
+    readonly window: PivotReportWindow;
+    /** Why. */
+    readonly refusal: PivotReportRefusal;
+}
+
+/** What a report source is asked: a Window of the report a layout makes, under display settings. */
+export declare interface PivotReportRequest {
+    /** The request's identity, which its answer names back. */
+    readonly requestId: string;
+    /** The report's View State. */
+    readonly layout: PivotLayout;
+    /** Its locale, words, label geometry and Order Key policies. */
+    readonly settings: PivotReportSettings;
+    /** The rows wanted. */
+    readonly window: PivotReportWindow;
+    /** The Report Version of the Window the Consumer holds — the data it shows — or none. A request that
+     * marks no changes (a layout gesture) lays out the data of that version, while the source holds it, and
+     * not newer data the Consumer has not been shown; a row of the answer that the held Window shows alike is
+     * the very row it holds (ADR-0152, ADR-0153). */
+    readonly baseline?: string;
+    /** The cap on the answer's leaves; 200,000 when left out (ADR-0066). */
+    readonly maxLeaves?: number;
+    /** Whether this gesture can mark changes of the data; a layout or display-setting gesture cannot. True
+     * when left out. */
+    readonly markChanges?: boolean;
+    /** Asks a source that cannot tell its data changed again, though it said nothing: an explicit Refresh or
+     * Retry (ADR-0153). */
+    readonly refreshData?: boolean;
+}
+
+/** A row of a report. */
+export declare class PivotReportRow {
+    #private;
+    /** A group row, an Item's, a subtotal's or the grand total's. */
+    readonly role: PivotRowRole;
+    /** The Value Field the row shows, or −1 when its columns say. */
+    readonly valueField: number;
+    /** Its label in each label column. */
+    readonly labels: readonly PivotRowLabel[];
+    /** Whether the row carries values: a group row whose subtotal stands at the bottom carries none. */
+    readonly carriesValues: boolean;
+    private constructor();
+    /** What the row stands for, across reports. */
+    get key(): PivotRowKey;
+}
+
+/** A report's display settings, chosen explicitly: a locale never chooses the words (ADR-0151). */
+export declare interface PivotReportSettings {
+    /** The locale numbers and dates are written in and text is ordered by; the browser's language when left
+     * out (ADR-0370 section 10). */
+    readonly locale?: string;
+    /** The report's words by id, for those the Consumer translates; English for the rest. */
+    readonly words?: Readonly<Record<string, string>>;
+    /** How long a change of the data stays marked for a cell first asked for after it, in milliseconds;
+     * 1,000 when left out (ADR-0068). */
+    readonly changeHighlightMs?: number;
+    /** The label geometry the label columns' widths are estimated under, or none when no widths are wanted. */
+    readonly labelMetrics?: PivotLabelMetrics;
+    /** The Order Key a field's Items are ordered by, by the field's name: one of those the report source was
+     * given, by its name (ADR-0152). */
+    readonly orderKeyPolicies?: Readonly<Record<string, string>>;
+}
+
+/** The report boundary a Script Core asks (ADR-0151, ADR-0370 section 4): a Window of the report, and the
+ * operations a Report Version names. An Engine Host that runs the engine in a Worker answers it across. */
+export declare interface PivotReportSource {
+    /** The fields offered to the Field List. */
+    readonly fields: readonly PivotField[];
+    /** The Aggregations offered. */
+    readonly features: PivotSourceFeatures;
+    /** How the source learns its data changed. */
+    readonly updateMode: PivotReportUpdateMode;
+    /** A Window of the report a request's layout makes, or a refusal by name. */
+    window(request: PivotReportRequest, signal?: AbortSignal): Promise<PivotReportUpdate>;
+    /** A field's Items, labelled and ordered as a held Report Version shows them. */
+    items(query: PivotReportItemsQuery, signal?: AbortSignal): Promise<PivotReportItemsResult>;
+    /** A field's Items as the Pivot Source lists them, under a Source Version. */
+    rawItems(query: PivotItemsQuery, signal?: AbortSignal): Promise<PivotItemPage>;
+    /** Every selected cell of a held Report Version, off-screen cells included. */
+    copy(query: PivotReportCopyQuery, signal?: AbortSignal): Promise<PivotReportCopyResult>;
+    /** The Selection Summary of a held Report Version. */
+    summary(query: PivotReportSummaryQuery, signal?: AbortSignal): Promise<PivotReportSummaryResult>;
+    /** A page of the records behind a cell, under the Source Version its question names (ADR-0151). */
+    details(query: PivotDetailsQuery, signal?: AbortSignal): Promise<PivotDetailPage>;
+    /** Tells `listener` each time the Pivot Source's data moves on; the function returned stops it. */
+    subscribe(listener: (changed: PivotSourceChanged) => void): () => void;
+    /** Releases the report's state; the Pivot Source is not its to release. */
+    dispose(): void;
+}
+
+/** A Window as the Consumer holds it: the report's metadata, the Window answered, and its rows. */
+export declare interface PivotReportState {
+    /** The whole report's metadata. */
+    readonly metadata: PivotReportMetadata;
+    /** The Window answered. */
+    readonly window: PivotReportWindow;
+    /** Its rows, in order. */
+    readonly rows: readonly PivotDisplayRow[];
+}
+
+/** A versioned Selection Summary; a cell under two rectangles is counted once. */
+export declare interface PivotReportSummaryQuery {
+    /** The report the selection was made on. */
+    readonly version: string;
+    /** The columns' names, in the Consumer's order. */
+    readonly columns: readonly string[];
+    /** The selected rectangles. */
+    readonly ranges: readonly PivotReportRange[];
+    /** The Focus row, whose number format the figures are shown in. */
+    readonly focusRow?: number;
+    /** The Focus column among the columns. */
+    readonly focusColumn?: number;
+}
+
+/** The figures of a Selection Summary, or a refusal (ADR-0130). */
+export declare interface PivotReportSummaryResult {
+    /** The report answered. */
+    readonly version: string;
+    /** The cells that are not blank: Count. */
+    readonly values: number;
+    /** The cells that are numbers: Numerical Count. An error is not one. */
+    readonly numbers: number;
+    /** The sum, exact wherever every number was; absent with no number. */
+    readonly sum?: PivotNumber;
+    /** The smallest number; absent with no number. */
+    readonly min?: PivotNumber;
+    /** The largest number; absent with no number. */
+    readonly max?: PivotNumber;
+    /** An error was selected: Average, Min, Max and Sum are not shown, and Count and Numerical Count are. */
+    readonly hasError: boolean;
+    /** The Focus value's number format, where it has one. */
+    readonly numberFormat?: string;
+    /** The report's locale. */
+    readonly locale: string;
+    /** Why it was not summed. */
+    readonly refusal?: PivotReportRefusal;
+}
+
+/** A Window answered, or refused by name. */
+export declare type PivotReportUpdate = PivotReportAnswer | PivotReportRefused;
+
+/** How a report source learns that its data changed (ADR-0153), declared: `incremental` when the Pivot
+ * Source names its changes — Change Batches — and `fullRefresh` when it cannot, and a notice of newer data
+ * asks it again ({@link PivotReportRequest.refreshData}). */
+export declare type PivotReportUpdateMode = 'incremental' | 'fullRefresh';
+
+/** The rows of a report asked for: from `start`, at most `count` of them. The whole report's row count is
+ * the metadata's. */
+export declare interface PivotReportWindow {
+    /** The first row, from 0. */
+    readonly start: number;
+    /** The most rows. */
+    readonly count: number;
+}
+
+/** Which side of a window a rest cell merges. */
+export declare type PivotRestSide = 'before' | 'after';
+
+/** What a row of a report stands for, across reports: its role, its Value Field and its Items. */
+export declare class PivotRowKey {
+    /** The row's role. */
+    readonly role: PivotRowRole;
+    /** The Value Field the row shows, or −1 when its columns say. */
+    readonly valueField: number;
+    /** The row's Items, outermost first. */
+    readonly items: readonly PivotItemKey[];
+    /** A key of a row's role, Value Field and Items. */
+    constructor(role: PivotRowRole, valueField: number, items: readonly PivotItemKey[]);
+    /** Whether two keys stand for one row: the same role, Value Field and Items. */
+    equals(other: PivotRowKey): boolean;
+    /** `item -1 [Text:East / Text:Apples]`, for messages and logs. */
+    toString(): string;
+}
+
+/** A row's label in one label column: its text, its indent in levels, and its button. */
+export declare interface PivotRowLabel {
+    /** The text, or `undefined` for an empty label cell. */
+    readonly text: string | undefined;
+    /** The indent, in levels. */
+    readonly indent: number;
+    /** The collapse button, beside an outer Item that has Items under it. */
+    readonly toggle?: PivotToggle;
+    /** The number a number Item's label shows, in full, which its copy carries. */
+    readonly number?: number;
+}
+
+/** What a row of a report stands for (ADR-0059/0060): an Item of the innermost field, a group row, a
+ * subtotal, or the grand total; or a Pending Row, kept for a sibling outside a Sibling Window and never shown
+ * (ADR-0370 section 3). */
+export declare type PivotRowRole = 'item' | 'group' | 'subtotal' | 'grandTotal' | 'pending';
+
+/**
+ * A server's Change Batch (ADR-0370 section 3): the records its data lost and the records it gained between two
+ * Source Versions, each with its values in the source's field order, as a record behind a cell carries them —
+ * a date by its ticks, a date part by its number. A changed record is the old one lost and the new one
+ * gained.
+ */
+export declare interface PivotServerChangeBatch {
+    /** Names the notice: the records the data lost and gained are told. */
+    readonly kind: 'changeBatch';
+    /** The Source Version the batch starts from. */
+    readonly from: string;
+    /** The Source Version it makes. */
+    readonly to: string;
+    /** The records the data lost, each with the values it had. */
+    readonly removed: readonly (readonly PivotDetailValue[])[];
+    /** The records the data gained. */
+    readonly added: readonly (readonly PivotDetailValue[])[];
+}
+
+/** That a server's data moved on, however the Consumer learned it (ADR-0370 section 3): the question is asked
+ * again. */
+export declare interface PivotServerChanged {
+    /** Names the notice: the data moved on, and its changes are not told. */
+    readonly kind: 'changed';
+    /** The Source Version the server answers under now, where the Consumer knows it. */
+    readonly sourceVersion?: string;
+}
+
+/** What the Consumer's transport tells a fetching source: that the data moved on, or how. */
+export declare type PivotServerNotice = PivotServerChanged | PivotServerChangeBatch;
+
+/** How a Value Field's values are shown after aggregation (ADR-0060). */
+export declare type PivotShowValuesAs = 'noCalculation' | 'percentOfGrandTotal' | 'percentOfColumnTotal' | 'percentOfRowTotal';
+
+/** Every Show Values As, in the C# engine's order: what Value Field Settings… offers. */
+export declare const pivotShowValuesAsList: readonly PivotShowValuesAs[];
+
+/** The id of a Show Values As choice's name: `show-percent-of-grand-total` is `% of Grand Total`. */
+export declare function pivotShowValuesAsNameId(showValuesAs: PivotShowValuesAs): string;
+
+/** How the engine's work paces itself (PV-40). */
+export declare interface PivotSlicing {
+    /** How long one slice works, in milliseconds, before it yields; 30 when left out, within the 50 a page
+     * may be blocked for. A slice always does some work, so 0 yields after every step. */
+    readonly sliceBudgetMs?: number;
+    /** What the work awaits between slices; a macrotask (`setTimeout(…, 0)`) when left out, which gives a
+     * browser a turn of its event loop to paint in. */
+    readonly yield?: () => Promise<void>;
+}
+
+/** An Item order: by label, ascending or descending, or by a Value Field's value at each Item's total;
+ * `(blank)` is last either way (ADR-0060). */
+export declare interface PivotSort {
+    /** Ascending or descending. */
+    readonly direction: PivotSortDirection;
+    /** The index in the layout's Values of the Value Field to order by; absent to order by label. */
+    readonly byValue?: number;
+}
+
+/** A sort, checked and frozen. */
+export declare function pivotSort(direction?: PivotSortDirection, byValue?: number): PivotSort;
+
+/** Ascending or descending, for an Item order; `(blank)` is last either way (ADR-0060). */
+export declare type PivotSortDirection = 'ascending' | 'descending';
+
+/** What a report asks its data (ADR-0066). Each question is answered under a Source Version, or refused. */
+export declare interface PivotSource {
+    /** The fields the source has. */
+    readonly fields: readonly PivotField[];
+    /** The Aggregations it answers. */
+    readonly features: PivotSourceFeatures;
+    /** The Leaf Aggregates of a question. */
+    aggregate(query: PivotQuery, signal?: AbortSignal): Promise<PivotAnswer>;
+    /** A page of a field's Items over all the data. */
+    items(query: PivotItemsQuery, signal?: AbortSignal): Promise<PivotItemPage>;
+    /** A page of the records behind a cell. */
+    details(query: PivotDetailsQuery, signal?: AbortSignal): Promise<PivotDetailPage>;
+    /** Each field's count of Items now (ADR-0370 section 3), asked of a source whose features declare
+     * {@link PivotSourceFeatures.countsItems}. The bundled sources answer it, for a server that answers from
+     * one, and do not declare it: in the page, a layout past the cap is refused as soon as a count would be
+     * known. */
+    itemCounts?(signal?: AbortSignal): Promise<PivotItemCounts>;
+    /** Tells `listener` each time the source's data moves on (ADR-0067, ADR-0370 section 3); the function
+     * returned stops telling it. A source whose data never moves has none. */
+    subscribe?(listener: (changed: PivotSourceChanged) => void): () => void;
+    /** Refresh: lets go of whatever the source holds for its questions, so the next one is asked of its data.
+     * A source that holds nothing past its data has none; a source that wraps another passes it on. */
+    refresh?(): void;
+}
+
+/** What a source says when its data moved on (ADR-0067): the Source Version it answers under now. */
+export declare interface PivotSourceChanged {
+    /** The Source Version the source answers under from now; absent where the source does not know it yet,
+     * as a server's notice may not, and the next answer carries it. A source over a Snapshot always knows it. */
+    readonly sourceVersion?: string;
+}
+
+/** The Aggregations a source answers, whether it can be refreshed, and whether it counts its fields' Items. */
+export declare class PivotSourceFeatures {
+    /** Every Aggregation, in the declared order. */
+    static readonly all: PivotSourceFeatures;
+    /** The Aggregations offered, in the declared order. */
+    readonly aggregations: readonly PivotAggregation[];
+    /** Whether Refresh asks the source again. */
+    readonly canRefresh: boolean;
+    /** Whether the source answers each field's count of Items ({@link PivotSource.itemCounts}, ADR-0370
+     * section 3): the report then asks it once when the source is opened and again under a new Source
+     * Version. */
+    readonly countsItems: boolean;
+    /** Whether the source answers a question carrying levels whose leaves pass its cap with the cells of the
+     * groups shown ({@link PivotAnswer.isLevels}, ADR-0370 section 3): a report source over it then asks with the
+     * groups its layout shows, and again when an expand shows groups the answer did not hold. */
+    readonly answersLevels: boolean;
+    /** The features of the Aggregations given, refusing one the engine does not know. */
+    constructor(aggregations: Iterable<PivotAggregation>, canRefresh?: boolean, countsItems?: boolean, answersLevels?: boolean);
+    /** Whether the source answers an Aggregation. */
+    offers(aggregation: PivotAggregation): boolean;
+    /** The Aggregations that read a part, when the source offers none of them; empty otherwise. */
+    missingFor(part: number): readonly PivotAggregation[];
+}
+
+/** A Pivot Source's refusal to answer: its kind, a sentence a person can read, and the field or the cap it
+ * concerns. The report stays on the layout it had and says why. */
+export declare interface PivotSourceRefusal {
+    /** Why the source refused. */
+    readonly kind: PivotSourceRefusalKind;
+    /** A sentence a person can read. */
+    readonly message: string;
+    /** The field the refusal concerns. */
+    readonly field?: string;
+    /** The cap a `tooManyLeaves` refusal passed. */
+    readonly limit?: number;
+}
+
+/** Why a Pivot Source refused a question (ADR-0066). */
+export declare type PivotSourceRefusalKind = 'tooManyLeaves' | 'unknownField' | 'aggregationNotOffered' | 'sourceVersionNotHeld';
+
+/** The button beside an outer row Item, which collapses or expands it. */
+export declare interface PivotToggle {
+    /** The row field whose Item it is. */
+    readonly field: string;
+    /** The Item it collapses or expands. */
+    readonly item: PivotItemKey;
+    /** The Item's label, for the button's accessible name. */
+    readonly itemLabel: string;
+    /** Whether the Item is collapsed now. */
+    readonly isCollapsed: boolean;
+}
+
+/** A value cell of a report: its text, its number, and its exact decimal where it was computed in one. */
+export declare interface PivotValue {
+    /** The text the cell shows. */
+    readonly text: string;
+    /** The number, as a double: the exact one converted where there is one; 0 for an error. */
+    readonly number: number;
+    /** The exact decimal, where the Aggregation was computed in one. */
+    readonly exact?: SnapshotDecimal;
+    /** The error value's text, `#DIV/0!` or `#NUM!`, when the cell is one. */
+    readonly error?: string;
+}
+
+/**
+ * Each Value Field's caption as the Field List shows it in Values, and the report heads its columns (ADR-0060):
+ * its own caption, or the default in the report's words, `Sum of Amount`, numbered to stay unique. A layout
+ * not yet answered is captioned as the report will caption it.
+ */
+export declare function pivotValueCaptions(layout: PivotLayout, fields: readonly PivotField[], options?: PivotOptions): readonly string[];
+
+/** A Pivot Field standing in Values (ADR-0060). */
+export declare interface PivotValueField {
+    /** The Pivot Field's name. */
+    readonly field: string;
+    /** How the records at a cell are summarised. */
+    readonly aggregation: PivotAggregation;
+    /** A caption of the Value Field's own (Excel's Custom Name), or absent for `<Aggregation> of <field>`. */
+    readonly caption?: string;
+    /** How the aggregated values are shown. */
+    readonly showValuesAs: PivotShowValuesAs;
+    /** A .NET format string the values are shown in under the report's locale, or absent for General,
+     * at most eleven characters besides a minus sign, or `0.00%` for a percentage. */
+    readonly numberFormat?: string;
+}
+
+/** A Value Field's settings, each its default when left out: Sum, the default caption, no calculation,
+ * General. */
+export declare interface PivotValueFieldInput {
+    /** The Pivot Field's name. */
+    readonly field: string;
+    /** How the records at a cell are summarised. */
+    readonly aggregation?: PivotAggregation;
+    /** A caption of the Value Field's own. */
+    readonly caption?: string;
+    /** How the aggregated values are shown. */
+    readonly showValuesAs?: PivotShowValuesAs;
+    /** A .NET format string the values are shown in. */
+    readonly numberFormat?: string;
+}
+
+/** A Pivot Layout written by a version this reader does not read: the C# engine's NotSupportedException. */
+export declare class PivotVersionError extends Error {
+    constructor(message: string);
+}
+
+/** Where one parent's window starts: the parent row group, by its Items, and the sibling it starts at. */
+export declare interface PivotWindowStart {
+    /** The parent's Items, outermost first: none for the grand total. */
+    readonly rows: readonly PivotItemKey[];
+    /** The place among the siblings, from 0, of the first one asked for. */
+    readonly start: number;
+}
+
+/** The word for an id: the Consumer's, the English where it says nothing, and the id itself where neither
+ * knows it — an id painted is a missing word seen, never a blank. */
+export declare function pivotWord(id: string, label: PivotLabel | undefined): string;
+
+/** Every id the engine has an English word for, a date part's included: what a Consumer replaces to give
+ * ExPivot another language. */
+export declare function pivotWordIdList(): readonly string[];
+
+/** The ids of the words a report paints, by what they name. */
+export declare const pivotWordIds: Readonly<{
+    /** The Compact form's label column header: `Row Labels`. */
+    rowLabels: "row-labels";
+    /** The Σ Values pseudo-field's header, and a report's lone value column when the values stand in
+     * rows: `Values`. */
+    values: "values";
+    /** The grand total row and column: `Grand Total`. */
+    grandTotal: "grand-total";
+    /** An outer Item's subtotal: `{0} Total`, `{0}` the Item's label. */
+    itemTotal: "item-total";
+    /** A Value Field's grand total row, with the values in rows: `Total {0}`, `{0}` its caption. */
+    totalOf: "total-of";
+    /** An outer Item's subtotal row for one Value Field: `{0} {1}`, the Item's label and the caption. */
+    itemValue: "item-value";
+    /** The Blank Item: `(blank)`. */
+    blank: "blank";
+    /** A report filter with nothing hidden: `(All)`. */
+    all: "all";
+    /** A report filter showing several Items: `(Multiple Items)`. */
+    multipleItems: "multiple-items";
+    /** The Σ Values entry in an Area: `Σ Values`. */
+    valuesPseudoField: "values-pseudo-field";
+    /** A year's Item: `{0}`, the year. */
+    dateYear: "date-year";
+    /** A quarter's Item: `Qtr{0}`, the quarter from 1 to 4. */
+    dateQuarter: "date-quarter";
+    /** A server's layout over the leaf cap, refused at the drop (ADR-0370 section 3), `{0}` the field moved,
+     * `{1}` its Area's word and `{2}` the cap:
+     * `{0} in {1} makes more than {2} combinations, the most server data allows.` */
+    tooManyCombinations: "refused-too-many-combinations";
+    /** The same refusal where the source counted the field, `{1}` the field's count of Items:
+     * `{0} ({1} items) in {2} makes more than {3} combinations, the most server data allows.` */
+    tooManyCombinationsCounted: "refused-too-many-combinations-counted";
+    /** The ways that remain after that refusal, `{0}` the field: `Put {0} in Filters, or filter {0} first.` */
+    tooManyCombinationsRemedy: "refused-too-many-combinations-remedy";
+}>;
+
+/** A field dropped from the list of fields on an Area at `index` (ADR-0061): in Values it is a new Value
+ * Field, whatever else it stands in; in Filters, Rows or Columns it is placed there, moving out of
+ * whichever of them it stood in, with its settings. */
+export declare function placeField(layout: PivotLayout, field: PivotFieldInfo, area: PivotArea, index: number): PivotLayout;
+
+/** Where a field stands among Filters, Rows and Columns, or `undefined` when it stands in none of them. */
+export declare function placementOf(layout: PivotLayout, field: string): {
+    readonly area: PivotArea;
+    readonly index: number;
+} | undefined;
+
+/** The placements of Filters, Rows or Columns. */
+export declare function placementsIn(layout: PivotLayout, area: PivotArea): readonly PivotFieldPlacement[];
+
+/** Whether the field stands anywhere, Values included: a ticked field. */
+export declare function placesField(layout: PivotLayout, field: string): boolean;
+
+/** The question a layout asks (ADR-0066): its row and column fields, the Filters that hide something, and
+ * each field in Values once, with the parts of every Value Field of it. */
+export declare function queryForLayout(layout: PivotLayout, maxLeaves?: number): PivotQuery;
+
+/**
+ * A layout read back from {@link writePivotLayoutJson}'s JSON. Refuses by name, with a PivotFormatError, a
+ * document that is not an object, an unknown name for a form, an axis, an Aggregation, a Show Values As, a
+ * sort direction or an Item kind, and a member of the wrong type; and with a PivotVersionError a document of
+ * another version.
+ */
+export declare function readPivotLayoutJson(json: string): PivotLayout;
+
+/** The bundled source over records in memory (ADR-0066): read into a Snapshot on the first question, each
+ * field through its accessor; it answers every Aggregation under one version, the records being fixed. */
+export declare class RecordPivotSource<TRecord> implements PivotSource {
+    #private;
+    /** The fields, each read through its accessor. */
+    readonly fields: readonly PivotRecordField<TRecord>[];
+    /** Every Aggregation. */
+    readonly features: PivotSourceFeatures;
+    /** The one version the source answers under. */
+    readonly sourceVersion: string;
+    /** The records, as given. */
+    readonly records: readonly TRecord[];
+    /** A source over records, refusing a name declared twice among the fields. */
+    constructor(records: readonly TRecord[], fields: readonly PivotRecordField<TRecord>[]);
+    /** The Leaf Aggregates of a question, or a refusal. */
+    aggregate(query: PivotQuery, signal?: AbortSignal): Promise<PivotAnswer>;
+    /** The Leaf Aggregates of a question, on the calling thread; past the cap, for a question carrying levels,
+     * the cells of the groups shown (ADR-0370 section 3). */
+    aggregateNow(query: PivotQuery): PivotAnswer;
+    /** A page of a field's Items. */
+    items(query: PivotItemsQuery, signal?: AbortSignal): Promise<PivotItemPage>;
+    /** Each field's count of Items over the records (ADR-0370 section 3). */
+    itemCounts(signal?: AbortSignal): Promise<PivotItemCounts>;
+    /** A page of the records behind a cell, each carrying its record. */
+    details(query: PivotDetailsQuery, signal?: AbortSignal): Promise<PivotDetailPage>;
+    /** The records behind a cell, in their order, refusing by name a field the source does not have. */
+    recordsBehind(query: PivotDetailsQuery): readonly TRecord[];
+}
+
+/**
+ * The records behind one cell of a report — Show Details (ADR-0063) — in their order: those no Hidden Item
+ * leaves out, carrying the row's Items and the column's. A label cell is value column −1, and is every
+ * record of its row.
+ */
+export declare function recordsBehind<TRecord>(records: readonly TRecord[], fields: readonly PivotRecordField<TRecord>[], report: PivotReport, row: PivotReportRow, valueColumn: number): readonly TRecord[];
+
+/** The id of a refusal's sentence among the report's words. */
+export declare function refusalWord(refusal: PivotRefusal): string;
+
+/** Removing an entry — Remove Field, or dragging it back to the list of fields (ADR-0061). Σ Values cannot
+ * be removed: it leaves when fewer than two Value Fields remain. */
+export declare function removeEntry(layout: PivotLayout, entry: PivotEntry): PivotLayout;
+
+/** One Item collapsed or expanded, wherever it appears (ADR-0060). */
+export declare function setCollapsed(layout: PivotLayout, field: string, item: PivotItemKey, collapsed: boolean): PivotLayout;
+
+/** Expand or Collapse Entire Field: every Item of the field, with no exception. */
+export declare function setFieldCollapsed(layout: PivotLayout, field: string, collapsed: boolean): PivotLayout;
+
+/**
+ * A field's Hidden Items, as Filter… applies them (ADR-0060/0061): refused when they would hide every one
+ * of `items` — the field's Items in the data — because a report of nothing reads as "no data". A key hidden
+ * that no Item carries is kept: it hides the Item if later data brings it.
+ */
+export declare function setHiddenItems(layout: PivotLayout, field: string, hidden: Iterable<PivotItemKey>, items: readonly PivotItemKey[]): PivotEditResult;
+
+/** A field's Item order — Sort A to Z, Z to A, or by a Value Field. */
+export declare function setSort(layout: PivotLayout, field: string, sort: PivotSort): PivotLayout;
+
+/** A field's subtotals: Automatic (true) or None. */
+export declare function setSubtotals(layout: PivotLayout, field: string, subtotals: boolean): PivotLayout;
+
+/**
+ * A Value Field's settings, as Value Field Settings… applies them (ADR-0060/0061): refused when its own
+ * caption is empty, or is another Value Field's caption or a Pivot Field's, or when its number format
+ * cannot be used. A caption is compared with the captions the report shows, in its words.
+ */
+export declare function setValueField(layout: PivotLayout, index: number, value: PivotValueFieldInput, fields: readonly PivotField[], options?: PivotOptions): PivotEditResult;
+
+/**
+ * The bundled source over a Snapshot (ADR-0066): it answers every Aggregation under the version
+ * `{identity}:{snapshot version}`, in slices (PV-40).
+ *
+ * **Live data** (ADR-0067): {@link SnapshotPivotSource.apply} takes a Change Batch. The Snapshot makes the next one, the answer the
+ * source holds for its last question is brought up to date from what the batch removed and added rather than
+ * read again — the exact parts by subtraction and addition, every other part recomputed for the leaves the
+ * batch touched — and each listener {@link SnapshotPivotSource.subscribe}d is told the new Source Version. Asked the same question
+ * again, the source answers from what it holds: after any sequence of batches, what a fresh source over the
+ * Snapshot they made answers, read in that Snapshot's order, to the last bit. A batch applied while an answer
+ * is assembled from what it holds waits until the answer is made, so that no answer is half a batch.
+ *
+ * It answers a field's Items and a cell's records under its current version and under the versions of its
+ * last {@link SnapshotPivotSource.answersHeld} answers — a Snapshot is immutable, so their records still add
+ * up — and refuses an older one.
+ */
+export declare class SnapshotPivotSource implements PivotSource {
+    #private;
+    /** How many of its latest answers' versions the source keeps answering Items and records under, besides
+     * its current one. */
+    static readonly answersHeld = 4;
+    /** The fields bound to the Snapshot's columns. */
+    readonly fields: readonly PivotField[];
+    /** Every Aggregation. */
+    readonly features: PivotSourceFeatures;
+    /** A source over a Snapshot: `fields` bound to its columns, or one field per column; its work paced by
+     * `slicing`. */
+    constructor(snapshot: Snapshot, fields?: readonly PivotField[], slicing?: PivotSlicing);
+    /** The Snapshot the source answers from now: the one it was made with, or the one the last Change Batch
+     * made. */
+    get snapshot(): Snapshot;
+    /** The version the source answers under now. */
+    get sourceVersion(): string;
+    /** Tells `listener` each new Source Version, after the source has moved on to it; the function returned
+     * stops telling it. */
+    subscribe(listener: (changed: PivotSourceChanged) => void): () => void;
+    /**
+     * Applies a Change Batch (ADR-0067): the Snapshot makes the next one, whole or not at all; the answer held
+     * for the last question is brought up to date from what the batch removed and added; and each listener is
+     * told the new Source Version, after the source has moved on. A batch the Snapshot refuses throws its
+     * `SnapshotError`, and nothing of it is applied. An error a listener throws does not stop the others being
+     * told, nor make the batch look refused: it is thrown again from a microtask, as an event listener's is.
+     */
+    apply(batch: ChangeBatch): SnapshotChange;
+    /**
+     * The Leaf Aggregates of a question, or a refusal, read in slices — or, for the question it answered last,
+     * from the pass it holds and has folded every batch into since. Past the cap, a question carrying levels
+     * is answered with the cells of the groups shown, at most that many (ADR-0370 section 3), though the source
+     * does not declare it, for a server that answers from it. The answer is assembled in slices too, and a
+     * cancelled question rejects with the signal's reason at the next slice.
+     */
+    aggregate(query: PivotQuery, signal?: AbortSignal): Promise<PivotAnswer>;
+    /** A page of a field's Items over all the data of the version asked, read in slices; refused under a
+     * version the source no longer holds. */
+    items(query: PivotItemsQuery, signal?: AbortSignal): Promise<PivotItemPage>;
+    /** Each field's count of Items in the current Snapshot, read in slices, field after field (ADR-0370
+     * section 3): what a server answering from this source answers its Field List with. A count is the
+     * length of the field's whole page of Items. */
+    itemCounts(signal?: AbortSignal): Promise<PivotItemCounts>;
+    /** A page of the records behind a cell in the version asked, in the Snapshot's order, read in slices;
+     * refused under a version the source no longer holds. */
+    details(query: PivotDetailsQuery, signal?: AbortSignal): Promise<PivotDetailPage>;
+}
+
+/** Whether two sorts are one. */
+export declare function sortsEqual(a: PivotSort, b: PivotSort): boolean;
+
+/** The key of a text Item. */
+export declare function textItemKey(text: string): PivotItemKey;
+
+/** Ticking a field (ADR-0061): one standing nowhere goes to the end of Values when it is declared Number,
+ * and to the end of Rows otherwise. A field already standing somewhere is left where it is. */
+export declare function tickField(layout: PivotLayout, field: PivotFieldInfo): PivotLayout;
+
+/** The words of Excel's English (United Kingdom) edition where they differ from the English (United
+ * States) edition's: `Max.`, `Max. of {0}`, `Summarise value field by`. */
+export declare const unitedKingdomPivotWords: PivotLabel;
+
+/** Unticking a field: it leaves every Area it stands in, each of its Value Fields included (ADR-0061). */
+export declare function untickField(layout: PivotLayout, field: string): PivotLayout;
+
+/** Refuses by name a layout that names an undeclared field, stands a field in two of Filters, Rows and
+ * Columns, orders by a Value Field it does not have, or carries a setting the engine does not know. */
+export declare function validateLayout(layout: PivotLayout, declared: ReadonlyMap<string, unknown>): void;
+
+/** Whether two Value Fields are one, member by member, as the C# engine's record equality says. */
+export declare function valueFieldsEqual(a: PivotValueField, b: PivotValueField): boolean;
+
+/** Σ Values, standing in the Area its axis names. */
+export declare function valuesPseudoField(axis: PivotAxis): PivotEntry;
+
+/** The layout as JSON, its members in the C# writer's order. */
+export declare function writePivotLayoutJson(layout: PivotLayout): string;
+
+export { }