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

package/dist/index.d.ts

@@ -0,0 +1,814 @@
+/**
+ * ExPivot's Script Core (ADR-0370, section 1): Excel's PivotTable drawn by ExGrid as that grid's Consumer,
+ * with its Field List, in TypeScript and free of any UI framework. The report is computed by
+ * `@ex-grid/pivot-engine` and drawn by `@ex-grid/core`; a Framework Adapter mounts it.
+ *
+ * @packageDocumentation
+ */
+
+import { CellTextMetrics } from '@ex-grid/core';
+import type { GridChrome } from '@ex-grid/core';
+import { GridDensity } from '@ex-grid/core';
+import { GridHandle } from '@ex-grid/core';
+import { GridPresentationDefaults } from '@ex-grid/core';
+import { GridSelection } from '@ex-grid/core';
+import type { PivotAggregation } from '@ex-grid/pivot-engine';
+import type { PivotArea } from '@ex-grid/pivot-engine';
+import { PivotDetailPage } from '@ex-grid/pivot-engine';
+import { PivotDetailsQuery } from '@ex-grid/pivot-engine';
+import type { PivotEntry } from '@ex-grid/pivot-engine';
+import { PivotField } from '@ex-grid/pivot-engine';
+import { PivotFieldItem } from '@ex-grid/pivot-engine';
+import type { PivotItemKey } from '@ex-grid/pivot-engine';
+import { PivotLabel } from '@ex-grid/pivot-engine';
+import { PivotLayout } from '@ex-grid/pivot-engine';
+import type { PivotShowValuesAs } from '@ex-grid/pivot-engine';
+import { PivotSlicing } from '@ex-grid/pivot-engine';
+import { PivotSource } from '@ex-grid/pivot-engine';
+import { SelectionSummary } from '@ex-grid/core';
+import { SummaryFigure } from '@ex-grid/core';
+import { ViewportSize } from '@ex-grid/core';
+
+/**
+ * The first of `languages`, in the browser's order, that the pivot writes in, matched whole and without
+ * regard to case. A list with none it holds throws a `RangeError` that says to pass `locale`.
+ */
+export declare function browserPivotLocale(languages: readonly string[]): string;
+
+/**
+ * Draws an ExPivot into `element`, which becomes its root (ADR-0370 section 1): the report, drawn by ExGrid,
+ * beside the Field List. The pivot owns everything inside it; a Framework Adapter renders the element and
+ * hands the pivot its props, and nothing here assumes React's lifecycle or Blazor's.
+ */
+export declare function createPivot(element: HTMLElement, options: PivotViewOptions): PivotHandle;
+
+/** What one cell of the report stands for (ADR-0340): its row's Items and, for a value cell, its column's. */
+export declare interface PivotCellItems {
+    /** The Items its row's path names, outermost first. */
+    readonly row: readonly PivotFieldItem[];
+    /** The Items its column's path names, outermost first; none for a label cell. */
+    readonly column: readonly PivotFieldItem[];
+}
+
+/** A choice a panel offers: its value, its words, and whether it may be chosen. */
+export declare interface PivotChoice<T> {
+    /** The choice. */
+    readonly value: T;
+    /** What it is called. */
+    readonly label: string;
+    /** Whether it may be chosen: an Aggregation the Pivot Source does not answer is offered, and not available
+     * (ADR-0066). */
+    readonly enabled: boolean;
+    /** Why it may not be chosen, in words; absent while it may. */
+    readonly reason?: string;
+}
+
+/**
+ * The Chrome slots a pivot takes (ADR-0061, ADR-0390): the parts a Wrapper draws, each in place of the built-in
+ * markup's. A slot not given is the built-in markup's. A slot is read when its part opens: a part standing keeps the
+ * slot it opened with.
+ */
+export declare interface PivotChrome {
+    /** The stylesheets this Chrome brings (ADR-0123): the pivot's root renders a notice for each beside its own, which
+     * only another version's stylesheet shows. The report grid's Chrome declares its own. None where not given. */
+    readonly stylesheets?: readonly PivotChromeStylesheet[];
+    /** The report grid's Chrome, and Show Details' grids', so one Chrome dresses the pivot and the grids it draws. The
+     * Context Menu's commands are worded by the pivot. */
+    readonly grid?: GridChrome<unknown>;
+    /** A placed field's menu and the Layout menu. */
+    readonly menu?: PivotChromeSlot<PivotMenuSlotContext>;
+    /** Filter…, under a field's entry or a report filter's button. */
+    readonly itemFilter?: PivotChromeSlot<PivotItemFilterSlotContext>;
+    /** Field Settings… of a row or column field. */
+    readonly fieldSettings?: PivotChromeSlot<PivotFieldSettingsSlotContext>;
+    /** Value Field Settings…. */
+    readonly valueFieldSettings?: PivotChromeSlot<PivotValueFieldSettingsSlotContext>;
+    /** The Pivot Toolbar above the report. */
+    readonly toolbar?: PivotChromeSlot<PivotToolbarSlotContext>;
+    /** The report filter band, on the Pivot Toolbar's left. */
+    readonly reportFilters?: PivotChromeSlot<PivotReportFiltersSlotContext>;
+    /** The Stale Report's notice, under the Pivot Toolbar. */
+    readonly staleReport?: PivotChromeSlot<PivotStaleReportSlotContext>;
+    /** The Field List: Excel's PivotTable Fields pane. Its slot draws no box of its own, so the contents fill the
+     * Field List's height (`height: 100%`). */
+    readonly fieldList?: PivotChromeSlot<PivotFieldListSlotContext>;
+    /** The sheet tabs at the report's foot, while Show Details' records stand in a tab. */
+    readonly detailsTabs?: PivotChromeSlot<PivotDetailsTabsSlotContext>;
+    /** What the Show Details dialog draws inside its frame, a flex column; the slot draws no box of its own. */
+    readonly detailsDialog?: PivotChromeSlot<PivotDetailsDialogSlotContext>;
+}
+
+/**
+ * A Chrome slot's mount function (ADR-0350 section 9): it draws the part into `slot`, the element the pivot made for
+ * it, from `context`, and answers the function that takes what it drew away. The pivot calls that cleanup before the
+ * slot goes, and before it mounts again on the same slot with a new context.
+ */
+export declare type PivotChromeSlot<Context> = (slot: HTMLElement, context: Context) => () => void;
+
+/** A stylesheet a Chrome brings (ADR-0123), as its notice names it: a Wrapper has no root of its own (ADR-0062), so
+ * its Chrome declares the stylesheets it brings, and the pivot's root renders a notice for each beside its own. */
+export declare interface PivotChromeStylesheet {
+    /** The stylesheet's source file name, as the rules at the end of the shipped stylesheet name it: `mud-ex-pivot.css`. */
+    readonly name: string;
+    /** The SHA-256 of that source, as lower-case hex: the stamp the stylesheet the Chrome was built with hides its
+     * notice for. */
+    readonly stamp: string;
+}
+
+/** One Item of a cell's path: its field's caption and its label, as the report shows them. */
+export declare interface PivotDetailItem {
+    /** The caption of the Item's field. */
+    readonly field: string;
+    /** The Item's label. */
+    readonly item: string;
+}
+
+/** What the Show Details dialog's contents are handed (ADR-0059): its title, the anchor its records stand in and
+ * Close, inside the pivot's modal frame, which keeps the backdrop and Escape. Close takes the keyboard as the dialog
+ * opens, and the report's grid takes it back however it closes. */
+export declare interface PivotDetailsDialogSlotContext extends PivotStandingSlotContext<PivotDetailsDialogView> {
+    /** Close pressed. */
+    readonly close: () => void;
+    /** Hands in Close. */
+    readonly control: (name: 'close') => PivotPartRef;
+    /** Hands in the element the records stand in: their box takes the room the dialog gives it. */
+    readonly anchor: (name: 'records') => PivotPartRef;
+}
+
+/** What the Show Details dialog shows now (ADR-0059). */
+export declare interface PivotDetailsDialogView {
+    /** The cell the records are behind, which names the dialog. */
+    readonly title: string;
+    /** Close's words. */
+    readonly closeLabel: string;
+}
+
+/** What the sheet tabs' contents are handed (ADR-0059), at the report's foot while a Show Details sheet stands. The
+ * selected sheet's records are the pivot's, in a panel of its own over the report; the tab that opens takes the
+ * keyboard, and so does the one selected once a tab holding it closes. */
+export declare interface PivotDetailsTabsSlotContext extends PivotStandingSlotContext<PivotDetailsTabsView> {
+    /** A tab pressed, by its `key`: its sheet is selected. */
+    readonly select: (key: string) => void;
+    /** A details tab's close pressed, by its `key`: Excel's next sheet is selected, or the report. */
+    readonly close: (key: string) => void;
+    /** Hands in the control of the tab of `key`. */
+    readonly control: (key: string) => PivotPartRef;
+}
+
+/** What the sheet tabs show now (ADR-0059). */
+export declare interface PivotDetailsTabsView {
+    /** The tab list's name. */
+    readonly name: string;
+    /** The report's tab, then each Show Details sheet's, in the order they opened. */
+    readonly tabs: readonly PivotDetailsTabView[];
+}
+
+/** A sheet's tab at the report's foot (ADR-0059): the report's own, first, or a Show Details sheet's. */
+export declare interface PivotDetailsTabView {
+    /** The name the tab's control is handed in by, and `select` and `close` are handed. */
+    readonly key: string;
+    /** What the tab reads: the report's own words, or the cell the records are behind. */
+    readonly title: string;
+    /** Whether it is the selected sheet: a details sheet's records then cover the report. */
+    readonly selected: boolean;
+    /** The id of the panel its records stand in, for the control's `aria-controls`; absent on the report's tab. */
+    readonly panelId?: string;
+    /** Its close button's words, said as "Close …"; absent on the report's tab, which does not close. */
+    readonly closeLabel?: string;
+}
+
+/** Where the pivot shows the records when the Consumer does not take them: a tab at the report's foot, or a dialog. */
+export declare type PivotDetailsView = 'tab' | 'dialog';
+
+/** What is dragged in the Field List: a declared field from the list of fields, or a placed entry of an Area. */
+export declare type PivotDragSubject = {
+    readonly field: string;
+} | {
+    readonly entry: PivotEntry;
+};
+
+/** The Pivot Source failed to answer the report's newest question (ADR-0067). */
+export declare interface PivotFailedEvent {
+    /** What the source threw. */
+    readonly error: unknown;
+    /** Whether the report on screen stays as a Stale Report, whose notice says the failure: such a failure is raised here
+     * and thrown no further. Any other is said in the Pivot Toolbar, and thrown on after it is raised. */
+    readonly stale: boolean;
+}
+
+/** One Area of the Field List (ADR-0061). */
+export declare interface PivotFieldListAreaView {
+    /** Which Area. */
+    readonly area: PivotArea;
+    /** Its name: Filters, Columns, Rows, Values. */
+    readonly title: string;
+    /** What stands in it, Σ Values last where it stands. */
+    readonly entries: readonly PivotFieldListEntryView[];
+    /** The index a `dragenter` or a `drop` on the Area's box itself hands on: past its last entry. */
+    readonly end: number;
+    /** Whether what is dragged is over it, and may be dropped there. */
+    readonly dropTarget: boolean;
+    /** While a drop there would pass the leaf cap, by the counts, the words that say so, in a `role="status"`: a hint,
+     * never a refusal (ADR-0370 section 3). Absent otherwise. */
+    readonly overCap?: string;
+}
+
+/** A placed entry of an Area (ADR-0061). */
+export declare interface PivotFieldListEntryView {
+    /** Which entry it is: its Area and index there, −1 for Σ Values. */
+    readonly entry: PivotEntry;
+    /** The name its button and the anchor around it are handed in by, through `control` and `anchor`. */
+    readonly key: string;
+    /** What it is called: the field's caption, a Value Field's caption, Σ Values. */
+    readonly caption: string;
+    /** The button's accessible name: "Options for Region". */
+    readonly menuLabel: string;
+    /** Whether its field hides Items now. */
+    readonly filtered: boolean;
+    /** Whether it is Σ Values. */
+    readonly values: boolean;
+    /** Whether its menu, or a panel the menu opened, stands under it: the entry is then not draggable, so a press that
+     * moves a little on the menu is the menu's. */
+    readonly menuOpen: boolean;
+    /** Whether it is the one being dragged. */
+    readonly dragging: boolean;
+    /** Whether a drop now would land before it. */
+    readonly dropBefore: boolean;
+    /** The index a `dragenter` on it hands `dragEnter`, and a `drop` on it hands `drop`: its own, or for Σ Values,
+     * which always stands last, its Area's `end`. */
+    readonly dropIndex: number;
+}
+
+/** A declared field in the Field List (ADR-0061). */
+export declare interface PivotFieldListFieldView {
+    /** The field's name. */
+    readonly name: string;
+    /** What it is called. */
+    readonly caption: string;
+    /** The name its tick box is handed in by, through `control`. */
+    readonly key: string;
+    /** Whether it stands in any Area: its tick box. */
+    readonly placed: boolean;
+    /** Whether it hides Items now. */
+    readonly filtered: boolean;
+    /** Its count of Items, written in the pivot's locale, where the source counted them; absent otherwise. */
+    readonly count?: string;
+    /** The count as said: "12 Items"; absent with the count. */
+    readonly countLabel?: string;
+    /** Whether it is the one being dragged. */
+    readonly dragging: boolean;
+}
+
+/** The Field List shown or hidden by the user. */
+export declare interface PivotFieldListShownEvent {
+    /** Whether it now stands beside the report. */
+    readonly shown: boolean;
+}
+
+/**
+ * What the Field List's contents are handed (ADR-0061): the fields with their tick boxes and search, and the four
+ * Areas with their entries, each entry's open menu or panel placed by the pivot in the anchor around its button.
+ * Drag and drop is the browser's own: a draggable element calls `startDrag` on `dragstart` and `endDrag` on `dragend`;
+ * a drop target calls `dragOver` on `dragover` always — whether it may be dropped on is decided at the drop, never by a
+ * render that may still be on its way — `dragEnter` on `dragenter` for the marks, and `drop` (or `dropOnList`) on
+ * `drop`. Each Area's box is handed in by `area`, so a drag that leaves every Area is seen to.
+ */
+export declare interface PivotFieldListSlotContext extends PivotStandingSlotContext<PivotFieldListView> {
+    /** The search as it is typed. */
+    readonly setSearch: (text: string) => void;
+    /** A field's tick box pressed: ticks it into the layout, or takes it out. */
+    readonly toggle: (field: string) => void;
+    /** An entry's button pressed: opens its menu, or closes the one standing under it. */
+    readonly openMenu: (entry: PivotEntry) => void;
+    /** The heading's close button pressed: hides the Field List, keeping the layout and any pending one. */
+    readonly close: () => void;
+    /** A `dragstart` on a field or an entry: the drag starts, against the layout the pane shows. */
+    readonly startDrag: (event: DragEvent, subject: PivotDragSubject) => void;
+    /** A `dragover` on any drop target: takes the drop while a drag of the pane's is on. */
+    readonly dragOver: (event: DragEvent) => void;
+    /** A `dragenter` on an Area (`index` its entries' count) or an entry (`index` its own): where a drop would land. */
+    readonly dragEnter: (area: PivotArea, index: number) => void;
+    /** A `drop` on an Area or an entry, at the index `dragEnter` takes. */
+    readonly drop: (event: DragEvent, area: PivotArea, index: number) => void;
+    /** A `drop` on the list of fields: an entry dragged back is taken out of the layout. */
+    readonly dropOnList: (event: DragEvent) => void;
+    /** A `dragend`, whether or not anything was dropped. */
+    readonly endDrag: () => void;
+    /** Defer Layout Update ticked or unticked; unticking applies the pending layout, as Excel does. */
+    readonly setDeferred: (deferred: boolean) => void;
+    /** Update pressed: applies the pending layout in one change. */
+    readonly update: () => void;
+    /** Hands in a control: `search`, a field's tick box by its `key`, or an entry's button by its `key`. */
+    readonly control: (key: string) => PivotPartRef;
+    /** Hands in the anchor around an entry's button, or beside it, by the entry's `key`: an element of no position of
+     * its own, so the frame the pivot places in it takes the pane's width (ADR-0061). A press or focus on the entry's
+     * button, handed in by `control`, is inside its open menu wherever the anchor stands. */
+    readonly anchor: (key: string) => PivotPartRef;
+    /** Hands in an Area's box. */
+    readonly area: (area: PivotArea) => PivotPartRef;
+}
+
+/** What the Field List shows now (ADR-0061). */
+export declare interface PivotFieldListView {
+    /** The pane's name: "PivotTable Fields". */
+    readonly title: string;
+    /** The heading's close button's accessible name: "Hide Field List". */
+    readonly hideLabel: string;
+    /** The caption above the fields: "Choose fields to add to report:". */
+    readonly chooseCaption: string;
+    /** The search's accessible name and placeholder. */
+    readonly searchLabel: string;
+    /** The search as typed. */
+    readonly search: string;
+    /** The declared fields the search leaves, in declaration order. */
+    readonly fields: readonly PivotFieldListFieldView[];
+    /** The caption above the Areas: "Drag fields between areas below:". */
+    readonly dragCaption: string;
+    /** The four Areas, in Excel's order: Filters, Columns, Rows, Values. */
+    readonly areas: readonly PivotFieldListAreaView[];
+    /** Whether a drop on the list of fields, or on the report, removes what is dragged: a placed field's entry. */
+    readonly dropRemoves: boolean;
+    /** Defer Layout Update, at the pane's foot: its words, and whether it is ticked. */
+    readonly defer: {
+        readonly label: string;
+        readonly ticked: boolean;
+    };
+    /** Update: its words, and whether it would apply anything. */
+    readonly update: {
+        readonly label: string;
+        readonly enabled: boolean;
+    };
+}
+
+/** What Field Settings…' contents are handed (ADR-0061): a row or column field's subtotals and order. A request for
+ * the keyboard is for the first control, the subtotals' choice. */
+export declare interface PivotFieldSettingsSlotContext extends PivotPanelSlotContext {
+    /** What the panel shows now. */
+    readonly view: () => PivotFieldSettingsView;
+    /** Sets the draft's subtotals. */
+    readonly setSubtotals: (automatic: boolean) => void;
+    /** Sets the draft's order, by its index in the view's `sorts`. */
+    readonly setSort: (index: number) => void;
+}
+
+/** What Field Settings… shows now (ADR-0061): a new object at each change, and the same one otherwise. */
+export declare interface PivotFieldSettingsView {
+    /** The field's caption, the panel's title. */
+    readonly caption: string;
+    /** The draft's subtotals: Automatic (`true`) or None. */
+    readonly subtotals: boolean;
+    /** The orders there are, each by its words: A to Z and Z to A by label, then each Value Field's two. */
+    readonly sorts: readonly string[];
+    /** The draft's order, by its index in `sorts`. */
+    readonly sort: number;
+}
+
+/** An ExPivot drawn into an element, handed back by {@link createPivot}. */
+export declare interface PivotHandle {
+    /** Takes the options again, whole: what did not change asks nothing again. */
+    update(options: PivotViewOptions): void;
+    /** Opens the records of a Show Details event this pivot raised, as `detailsView` says: what a Consumer that
+     * heard `onShowDetails` and does not take them hands back (ADR-0059). */
+    openDetails(event: PivotShowDetailsEvent): void;
+    /**
+     * The grid that takes the inputs made at `element` (ADR-0240 section 6): a Show Details grid's, where `element`
+     * stands in that grid's Input Root, else the report's; undefined while the report draws no grid. For a Framework
+     * Adapter whose Chrome's contents arrive later than their slot, to hold that grid's inputs and Settled Mark until
+     * they stand (ADR-0410 section 5).
+     */
+    gridAround(element: Element): GridHandle<unknown> | undefined;
+    /** Holds the Settled Mark (ADR-0220) of the grid `element` stands in, as `gridAround` finds it, until the
+     * function it answers is called. Where no grid stands there yet, the hold waits for the grid that comes to: the
+     * report's next one while the report draws none, and a grid being made for a part it mounted before placing it,
+     * which meanwhile holds every grid. */
+    holdSettled(element: Element): () => void;
+    /** Stops the pivot: it asks and hears nothing more, and empties its element. The source stays the
+     * Consumer's. */
+    destroy(): void;
+}
+
+/** One Item as Filter… lists it. */
+export declare interface PivotItemChoice {
+    /** The Item. */
+    readonly key: PivotItemKey;
+    /** Its label. */
+    readonly label: string;
+    /** Whether it is shown in the draft. */
+    readonly ticked: boolean;
+}
+
+/** What Filter…' contents are handed (ADR-0061, ADR-0066): a field's Items, each ticked while shown, a search that
+ * narrows them, and OK and Cancel. A request for the keyboard is for the search. */
+export declare interface PivotItemFilterSlotContext extends PivotPanelSlotContext {
+    /** What the panel shows now. */
+    readonly view: () => PivotItemFilterView;
+    /** The search as typed. */
+    readonly setSearch: (text: string) => void;
+    /** Ticks or unticks one Item. */
+    readonly setTicked: (key: PivotItemKey, ticked: boolean) => void;
+    /** (Select All): ticks or unticks every Item the search lists. */
+    readonly setAll: (ticked: boolean) => void;
+}
+
+/** What Filter… shows now (ADR-0061, ADR-0066): a new object at each change, and the same one otherwise. */
+export declare interface PivotItemFilterView {
+    /** The field's caption, which names the list. */
+    readonly caption: string;
+    /** The search as typed. */
+    readonly search: string;
+    /** The Items the search leaves, in the field's order, at most the most Filter… lists. */
+    readonly items: readonly PivotItemChoice[];
+    /** (Select All)'s state over `items`: `true` for every one, `false` for none (and over no Items), or `undefined` for
+     * some. */
+    readonly allTicked: boolean | undefined;
+    /** Whether the Items, or the source's answer to the search, are on their way, with nothing yet to list. */
+    readonly loading: boolean;
+    /** Whether newer Items are on their way while what is shown stands: an earlier Source Version's Items, kept in
+     * view (ADR-0066 refined), or why they could not be listed, while they are asked again. A Chrome may mark the list
+     * as updating; it does not blank it, nor dim it. */
+    readonly updating: boolean;
+    /** Why the Items cannot be listed, in words, said in place of the list; absent while they can. */
+    readonly unavailable?: string;
+    /** A note under the Items: that more match than are listed, or that none matches the search; absent otherwise. */
+    readonly note?: string;
+    /** Whether OK may be pressed: not while every Item is unticked, nor while the Items are on their way. */
+    readonly canApply: boolean;
+    /** Why OK cannot apply, in words; absent while it can. */
+    readonly refusal?: string;
+}
+
+/** A Pivot Layout the user made and the report now shows. */
+export declare interface PivotLayoutChangedEvent {
+    /** The layout the report shows. */
+    readonly layout: PivotLayout;
+}
+
+/** One command of a menu the pivot decides (ADR-0061): what it is called, whether it is available, and what it does. */
+export declare interface PivotMenuCommand {
+    /** The command's id, which is also the id of its word, stable for an icon. */
+    readonly id: string;
+    /** What it is called, in the pivot's words. */
+    readonly label: string;
+    /** Whether it can be pressed: one that would change nothing is disabled. */
+    readonly enabled: boolean;
+    /** For a choice among others, the Layout menu's, whether it is the current one, which the menu marks; absent on a
+     * plain command. */
+    readonly checked?: boolean;
+    /** The heading of the group of choices that starts at this command: the Layout menu's Subtotals, Grand Totals and
+     * Report Layout; absent where it continues the group above. */
+    readonly heading?: string;
+    /** Runs it and closes the menu, or opens the panel it names in the menu's place. A disabled command runs nothing,
+     * and so does one pressed once the menu has closed or been drawn again without it. */
+    readonly invoke: () => void;
+}
+
+/**
+ * What a menu's contents are handed (ADR-0061): a placed field's menu, under its entry in the Field List, or the
+ * Layout menu, under Layout ▾. The slot stands inside the pivot's frame (`role="menu"`, named by the pivot), which
+ * Escape anywhere in it closes. The contents draw one item per command, in this order, a choice as a
+ * `menuitemradio` marked while it is the current one and a group's heading where one starts. A request for the
+ * keyboard is for the first enabled command; with none enabled the pivot gives the frame the keyboard itself.
+ */
+export declare interface PivotMenuSlotContext extends PivotPartSlotContext {
+    /** What the menu shows now. */
+    readonly view: () => PivotMenuView;
+    /** Hears each change to the view; answers the function that stops it. */
+    readonly subscribe: (listener: () => void) => () => void;
+    /** Closes the menu without running anything, for a dismissal of the contents' own; the keyboard goes back to what
+     * opened it. */
+    readonly close: () => void;
+}
+
+/** What a menu shows now (ADR-0061): a new object at each change, and the same one otherwise. */
+export declare interface PivotMenuView {
+    /** The menu's accessible name, which its frame carries. */
+    readonly name: string;
+    /** Excel's commands, in its order. */
+    readonly commands: readonly PivotMenuCommand[];
+}
+
+/** What the slots of a panel share (ADR-0061): its exits, and a popup of the contents' own. A panel holds a draft the
+ * pivot keeps; OK says it as the next layout, and Cancel and Escape drop it. */
+export declare interface PivotPanelSlotContext extends PivotPartSlotContext {
+    /** Hears each change to the view; answers the function that stops it. */
+    readonly subscribe: (listener: () => void) => () => void;
+    /** OK: the draft is applied and the panel closes. While the view says it cannot be, or the pivot refuses it, the
+     * panel stands and says why. */
+    readonly apply: () => void;
+    /** Cancel: the draft is dropped, the panel closes, and the keyboard goes back to what opened it. */
+    readonly cancel: () => void;
+    /** The contents report a popup of their own (a select's list) opening (`true`) and closing (`false`): while one
+     * is open, Escape is the popup's, and the next closes the panel (ADR-0039). */
+    readonly innerPopupChanged: (open: boolean) => void;
+}
+
+/** Takes one of a standing part's elements, or `null` once it is gone, as a callback ref does: hand it the element
+ * itself (a React `ref`, or a call with the element once it is drawn). */
+export declare type PivotPartRef = (element: HTMLElement | null) => void;
+
+/** What the slots of a part that takes the keyboard share: their words, and the keyboard's requests. */
+export declare interface PivotPartSlotContext {
+    /** One of the pivot's words by its id: the Consumer's `label`, else the built-in English. */
+    readonly label: (id: string) => string;
+    /** The count of the pivot's requests for the part to take the keyboard; zero asks nothing. Each request mounts the
+     * contents again, and whenever the count differs from the one they last answered they give DOM focus, through
+     * `takeFocus`, to the control the part's context names. */
+    readonly focusRequest: number;
+    /** Gives `control` DOM focus: wherever DOM focus stands while a request is owed, until the contents answer it or
+     * the user makes an input in the part, and otherwise only while the keyboard is still the pivot's (ADR-0204). */
+    readonly takeFocus: (control: HTMLElement) => void;
+}
+
+/** A move the report could not take, said where the user sees it (ADR-0066, ADR-0370 section 3). */
+export declare interface PivotRefusedEvent {
+    /** The sentence the pivot shows. */
+    readonly message: string;
+    /** The fields the refusal names, in the order they were moved: every move taken against the refused
+     * question, which went with it. Empty where it names none. */
+    readonly fields: readonly string[];
+}
+
+/** What the report filter band's contents are handed (ADR-0061): one entry per field in Filters, its caption and a
+ * button that says what it shows and opens Filter… in the anchor around it, over the report. */
+export declare interface PivotReportFiltersSlotContext extends PivotStandingSlotContext<PivotReportFiltersView> {
+    /** A filter's button pressed: opens its Filter…, or closes it when it is open. */
+    readonly toggle: (field: string) => void;
+    /** Hands in the button of the filter of `field`. */
+    readonly control: (field: string) => PivotPartRef;
+    /** Hands in the anchor around the button of the filter of `field`. */
+    readonly anchor: (field: string) => PivotPartRef;
+}
+
+/** What the report filter band shows now (ADR-0061). */
+export declare interface PivotReportFiltersView {
+    /** The band's accessible name, which a `role="group"` around it carries. */
+    readonly name: string;
+    /** One per field in Filters, in their order. */
+    readonly filters: readonly PivotReportFilterView[];
+}
+
+/** One report filter (ADR-0061). */
+export declare interface PivotReportFilterView {
+    /** The field's name. */
+    readonly field: string;
+    /** Its caption. */
+    readonly caption: string;
+    /** What it shows: (All), the one Item shown, or (Multiple Items). */
+    readonly summary: string;
+    /** Whether it hides Items. */
+    readonly filtered: boolean;
+    /** Whether its Filter… is open. */
+    readonly open: boolean;
+    /** The button's accessible name: "Filter Region". */
+    readonly buttonLabel: string;
+}
+
+/** The report's selection, as the grid raised it, and what its cells stand for. */
+export declare interface PivotSelectionChangedEvent {
+    /** The selection of the report grid. */
+    readonly selection: GridSelection;
+    /** Each selected cell's row and column Items, each cell once, in the order selected (ADR-0340); `undefined`
+     * when the selection reaches a row the grid does not hold drawn now, which is read from no Items rather than
+     * from some of them (spine rule 1), and when no report is shown. A selection dropped over a report is said with
+     * an empty list. */
+    readonly items: readonly PivotCellItems[] | undefined;
+}
+
+/** The records behind a value cell, which Show Details opens (ADR-0059): handed to `onShowDetails` when the Consumer
+ * listens, and otherwise shown by the pivot. */
+export declare interface PivotShowDetailsEvent {
+    /** What the cell stands for, as its sheet is titled: `Details: EU / Rates`. */
+    readonly title: string;
+    /** The Items of the cell's row, outermost first. */
+    readonly rowItems: readonly PivotDetailItem[];
+    /** The Items of the cell's column, outermost first. */
+    readonly columnItems: readonly PivotDetailItem[];
+    /** The caption of the cell's Value Field, or `undefined` where the cell is not one Value Field's. */
+    readonly valueField: string | undefined;
+    /** The question for the records, plain data a Consumer may send elsewhere, as the Razor component's
+     * `PivotDetails.Query` (ADR-0151): the cell's Items, the Hidden Items and the Source Version it is answered under. */
+    readonly query: PivotDetailsQuery;
+    /** The Pivot Source the report was computed from, which the records are asked of. */
+    readonly source: PivotSource;
+    /** The source's fields, which each record holds a value of, in order. */
+    readonly fields: readonly PivotField[];
+    /** A page of the records, from `start`, at most `count` of them, under the Source Version the report was computed
+     * from: a source that no longer holds it refuses, rather than answer records that do not add up. */
+    readonly records: (start: number, count: number, signal?: AbortSignal) => Promise<PivotDetailPage>;
+}
+
+/** What the Stale Report's notice's contents are handed (ADR-0067), inside the pivot's polite live region under the
+ * Pivot Toolbar, while the report is stale; the contents add no live region of their own. */
+export declare interface PivotStaleReportSlotContext extends PivotStandingSlotContext<PivotStaleReportView> {
+    /** Retry pressed: asks again what failed. */
+    readonly retry: () => void;
+    /** Hands in Retry. */
+    readonly control: (name: 'retry') => PivotPartRef;
+}
+
+/** What the Stale Report's notice shows now (ADR-0067). */
+export declare interface PivotStaleReportView {
+    /** The whole sentence: "Showing the data as of 14:32:05: the newest data needs more than 200,000 cells." */
+    readonly message: string;
+    /** When the data on screen arrived, as the sentence writes it. */
+    readonly asOfText: string;
+    /** What happened, as the sentence ends it. */
+    readonly reason: string;
+    /** Retry: its words, and whether it can be pressed — not while what it would ask is already out. */
+    readonly retry: {
+        readonly label: string;
+        readonly enabled: boolean;
+    };
+}
+
+/** What the slots of the pivot's standing parts share (ADR-0390): the Pivot Toolbar, the report filter band and the
+ * Stale Report's notice. Their contents are mounted once while the part stands, and draw its view again at each change.
+ * They hand in their controls by name, through `control`, so the pivot gives the keyboard to the one it means, as it
+ * does with the built-in markup's: after a menu closes, to the button that opened it. They hand in the anchors the
+ * pivot places a popup's frame in, through `anchor`: an element around the button that opens it, positioned, so the
+ * frame needs no position the pivot would have to measure (ADR-0061). */
+export declare interface PivotStandingSlotContext<View> {
+    /** What the part shows now: a new object at each change, and the same one otherwise. */
+    readonly view: () => View;
+    /** Hears each change to the view; answers the function that stops it. */
+    readonly subscribe: (listener: () => void) => () => void;
+    /** One of the pivot's words by its id: the Consumer's `label`, else the built-in English. */
+    readonly label: (id: string) => string;
+}
+
+/**
+ * What the Pivot Toolbar's contents are handed (ADR-0061): the report filter band on its left, and on its right, in
+ * this order, Layout ▾, Refresh where the source can be refreshed, and the Field List's toggle. The Layout menu opens
+ * in the anchor around Layout ▾, over the report, with a backdrop that closes it.
+ */
+export declare interface PivotToolbarSlotContext extends PivotStandingSlotContext<PivotToolbarView> {
+    /** Layout ▾ pressed: opens the Layout menu, or closes it when it is open. */
+    readonly toggleLayoutMenu: () => void;
+    /** Refresh pressed: asks the source again. */
+    readonly refresh: () => void;
+    /** The Field List's toggle pressed: shows the list, or hides it. */
+    readonly toggleFieldList: () => void;
+    /** Hands in a button: `layout`, `refresh` or `field-list`. */
+    readonly control: (name: 'layout' | 'refresh' | 'field-list') => PivotPartRef;
+    /** Hands in an anchor: `layout`, around Layout ▾, and `report-filters`, where the band stands. */
+    readonly anchor: (name: 'layout' | 'report-filters') => PivotPartRef;
+}
+
+/** What the Pivot Toolbar shows now (ADR-0061). */
+export declare interface PivotToolbarView {
+    /** Layout ▾: its words, and whether its menu is open. */
+    readonly layoutMenu: {
+        readonly label: string;
+        readonly open: boolean;
+    };
+    /** Refresh, while the source can be refreshed (ADR-0066); absent otherwise, and then there is no button. */
+    readonly refresh?: {
+        readonly label: string;
+    };
+    /** The Field List's toggle: its words, and whether the list is shown. */
+    readonly fieldList: {
+        readonly label: string;
+        readonly shown: boolean;
+    };
+    /** Whether the report filter band stands, on the toolbar's left: the contents then hand in its anchor,
+     * `anchor('report-filters')`, in which the pivot places the band. */
+    readonly reportFilters: boolean;
+    /** What the report could not do with the last change, in words — a layout refused by name, or the source's
+     * failure — said where the user sees it, as an alert (`role="alert"`); absent otherwise. Data that could not be
+     * shown is the Stale Report's notice's to say, not this. */
+    readonly refusal?: string;
+}
+
+/** What Value Field Settings…' contents are handed (ADR-0061). A request for the keyboard is for the first control,
+ * the caption's field. */
+export declare interface PivotValueFieldSettingsSlotContext extends PivotPanelSlotContext {
+    /** What the panel shows now. */
+    readonly view: () => PivotValueFieldSettingsView;
+    /** The caption as typed. */
+    readonly setCaption: (text: string) => void;
+    /** Sets the draft's Aggregation: one the source does not answer is never chosen. */
+    readonly setAggregation: (aggregation: PivotAggregation) => void;
+    /** Sets the draft's Show Values As. */
+    readonly setShowValuesAs: (showValuesAs: PivotShowValuesAs) => void;
+    /** The number format as typed. */
+    readonly setNumberFormat: (text: string) => void;
+}
+
+/** What Value Field Settings… shows now (ADR-0061): a new object at each change, and the same one otherwise. */
+export declare interface PivotValueFieldSettingsView {
+    /** The Pivot Field's caption, the Source Name. */
+    readonly sourceCaption: string;
+    /** The draft's caption, as its field shows it: one the user has not written follows the Aggregation. */
+    readonly caption: string;
+    /** The draft's Aggregation. */
+    readonly aggregation: PivotAggregation;
+    /** Every Aggregation, with its name and whether the source answers it. */
+    readonly aggregations: readonly PivotChoice<PivotAggregation>[];
+    /** The draft's Show Values As. */
+    readonly showValuesAs: PivotShowValuesAs;
+    /** Every Show Values As, with its name. */
+    readonly showValuesAsChoices: readonly PivotChoice<PivotShowValuesAs>[];
+    /** The draft's number format, as typed; empty for General. */
+    readonly numberFormat: string;
+    /** What an empty number format means, the field's placeholder: General. */
+    readonly numberFormatPlaceholder: string;
+    /** A number shown in the draft's format, or the reason it cannot be. */
+    readonly sample: string;
+    /** Why OK last refused, in words: a caption taken or empty, a format that cannot be used; absent otherwise. */
+    readonly refusal?: string;
+}
+
+/** An ExPivot's options (ADR-0370 section 1): what the Consumer hands, whole, on every update. */
+export declare interface PivotViewOptions {
+    /** The Pivot Source the report is computed from: its fields are what the Field List offers. A new
+     * instance is a refresh. */
+    readonly source: PivotSource;
+    /** The Pivot Layout, View State the Consumer holds (ADR-0059). A layout handed in replaces the one on
+     * screen; one this pivot raised through `onLayoutChanged` and handed back, however late, is its own and asks
+     * nothing, so an earlier layout is asked for again by handing in one of the Consumer's own making. Left out,
+     * the pivot starts from nothing and keeps the user's changes itself. A layout naming a field the source
+     * does not offer is refused by name. */
+    readonly layout?: PivotLayout;
+    /** Raised with the layout the report shows after each change the user made, once it is answered: never
+     * for one a newer move superseded, nor for one refused. */
+    readonly onLayoutChanged?: (event: PivotLayoutChangedEvent) => void;
+    /** Raised when a move is refused, with the sentence the pivot shows. */
+    readonly onRefused?: (event: PivotRefusedEvent) => void;
+    /** Raised when the Pivot Source fails to answer the report's newest question, as the Razor component keeps
+     * `LastError`: a live source whose transport is down is heard of here (ADR-0067). */
+    readonly onFailed?: (event: PivotFailedEvent) => void;
+    /** The locale numbers, dates and counts are written in and text Items ordered by: a BCP 47 tag, or
+     * `invariant`, which the pivot reads unless given (ADR-0370 section 10). A React adapter passes the
+     * browser's language. It changes no word. */
+    readonly locale?: string;
+    /** The Consumer's word for an id, or `undefined` to keep the English (ADR-0370 section 10).
+     * `japanesePivotWords` gives Excel's Japanese edition's words in one line. */
+    readonly label?: PivotLabel;
+    /** Whether the Field List stands beside the report; true unless given. */
+    readonly showFieldList?: boolean;
+    /** Raised when the report's selection changes, with what its cells stand for: what a Board reads its links
+     * by (ADR-0340). */
+    readonly onSelectionChanged?: (event: PivotSelectionChangedEvent) => void;
+    /** Raised when the user shows or hides the Field List. */
+    readonly onShowFieldListChanged?: (event: PivotFieldListShownEvent) => void;
+    /** The Field List's width in pixels; 300 unless given. */
+    readonly fieldListWidth?: number;
+    /** The report grid's height, header included: pixels, or `stretch` for the parent's; 400 unless given. */
+    readonly viewportHeight?: ViewportSize;
+    /** The report grid's width; `stretch` unless given, what the Field List leaves. */
+    readonly viewportWidth?: ViewportSize;
+    /** The most leaves a question may ask the source for (ADR-0066): 200,000 unless given. A layout past it is
+     * refused by name, and the report stays on the layout before. */
+    readonly maxLeaves?: number;
+    /** The most rows a report may have (ADR-0066): Excel's 1,048,576 unless given. A layout past it is refused, and
+     * newer data past it leaves a Stale Report. */
+    readonly maxRows?: number;
+    /** The most columns a report may have, its label columns included (ADR-0066): Excel's 16,384 unless given. A layout
+     * past it is refused, and newer data past it leaves a Stale Report. */
+    readonly maxColumns?: number;
+    /** How long after a change of data reached the screen the next is asked for, in milliseconds: 250 unless given
+     * (ADR-0067). The source's notices that come meanwhile are gathered and asked for once, so a source that changes
+     * many times a second redraws the report at most once per interval; a notice after a quiet spell is asked for at
+     * once. */
+    readonly redrawInterval?: number;
+    /** The report's row height, or the Density's. */
+    readonly rowHeight?: number;
+    /** The report's Density, beating a Wrapper's. */
+    readonly density?: GridDensity;
+    /** The widths the report's grids charge each glyph, beating a Wrapper's and the Density's (ADR-0016): whoever sets
+     * the font the cells are drawn in hands its widths, so `####` and the label widths are judged by the face on
+     * screen. */
+    readonly cellMetrics?: CellTextMetrics;
+    /** What a Wrapper hands the report's grids (ADR-0030): the widths of the font it sets, its Density, and its hover
+     * band and Row Stripes. A value the pivot is given beats these. */
+    readonly presentationDefaults?: GridPresentationDefaults;
+    /** How long the Change Highlight marks a value that changed with the data, in milliseconds: one second unless
+     * given (ADR-0068). The source's changes are marked when newer data is shown, and a Refresh marks what changed
+     * too; a move of the user's marks nothing. Zero marks nothing, and a negative or endless one is refused. */
+    readonly changeHighlightDuration?: number;
+    /** How the report's work shares the thread: a slice of 30 ms between macrotasks unless given (PV-40). Read
+     * once, when the pivot is made. */
+    readonly slicing?: PivotSlicing;
+    /** Hears Show Details (ADR-0059, ADR-0063): the records behind a value cell double clicked. A Consumer that
+     * listens takes them, and the pivot shows nothing; otherwise they open as `detailsView` says. */
+    readonly onShowDetails?: (event: PivotShowDetailsEvent) => void;
+    /** Where the records open when nobody hears `onShowDetails`: a tab at the report's foot, which covers the report
+     * while it is selected, or a dialog; `tab` unless given. */
+    readonly detailsView?: PivotDetailsView;
+    /** Whether the Selection Summary is shown under the report (ADR-0130): Excel's status-bar figures over the cells
+     * selected, summed by the report source over the whole report, rows not drawn included. On unless given. */
+    readonly showSelectionSummary?: boolean;
+    /** The Selection Summary's figures, Excel's Average, Count and Sum unless given (ADR-0130). The report holds the
+     * choice made in the figures menu from then on; figures handed in that differ from the ones last handed replace
+     * it. */
+    readonly summaryFigures?: readonly SummaryFigure[];
+    /** Raised when the figures menu changes the figures shown (ADR-0130). */
+    readonly onSummaryFiguresChanged?: (figures: readonly SummaryFigure[]) => void;
+    /** Hears the Selection Summary as it now stands (ADR-0130), for an application that shows the figures elsewhere. */
+    readonly onSelectionSummaryChanged?: (summary: SelectionSummary) => void;
+    /** The parts a Wrapper's Chrome, or the Consumer's own, draws in place of the built-in markup (ADR-0061, ADR-0390),
+     * its `grid` dressing the report's grid and Show Details' grids. A part standing keeps the slot it opened with. */
+    readonly chrome?: PivotChrome;
+}
+
+export { }