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

package/dist/index.d.ts

@@ -0,0 +1,2358 @@
+/**
+ * ExChart in TypeScript (ADR-0370): a chart's definition, checked when it is made, and the scene it is
+ * laid out as in CSS pixels — panels, axes, ticks, each series' lines, markers, candles and intervals —
+ * what its tooltip, its summary and its files say, the fits and interpolations a Consumer hands in, and a 3D
+ * surface as the mesh its entry draws and the 2D charts its slices are; the Chart Spec, a chart said in JSON as
+ * an AI writes it and a Board holds it, read against the tables its Data Handles name and answered as the tool an
+ * AI calls answers (ADR-0320); its Script
+ * Core, `createChart` and `createSurface`, which draw a chart as SVG into an element and hear the pointer, the
+ * legend and Chart Filters, free of any UI framework; and the selection bridge, `GridChartBridge`, which charts
+ * a grid's selection from its context menu and keeps the rows it was made from (ADR-0258). A Framework Adapter
+ * mounts it; the C# engine and this package are held to one another by the shared cases under
+ * `tests/cases/chart/`.
+ *
+ * @packageDocumentation
+ */
+
+import type { CellPosition } from '@ex-grid/core';
+import type { GridColumn } from '@ex-grid/core';
+import type { GridCommand } from '@ex-grid/core';
+import type { GridContextMenuContext } from '@ex-grid/core';
+import { GridDensity } from '@ex-grid/core';
+import type { GridHeaderGroup } from '@ex-grid/core';
+import type { GridSource } from '@ex-grid/core';
+import type { RowKey } from '@ex-grid/core';
+import type { RowKeyOf } from '@ex-grid/core';
+import type { SelectionRange } from '@ex-grid/core';
+
+/**
+ * Reads `text`, a Chart Spec, against `tables` and answers as the tool answers the AI: the refusal, or the
+ * chart said in words with how many pixels were thinned and how many points are missing, at `metrics`
+ * (800 by 400 CSS pixels by default). A surface is said as a screen reader hears it, with why a scale it
+ * asked for is not drawn. Anything thrown but a refusal of the spec or of the chart is thrown on.
+ */
+export declare function answerChartSpec(text: string, tables: (handle: string) => ChartData | undefined, metrics?: ChartMetrics): ChartSpecAnswer;
+
+/** The keys a series' look is chosen by; the same key always takes the same look (ADR-0256). */
+export declare interface AppearanceKeys {
+    /** The colour key. */
+    readonly colour: string;
+    /** The line-style key; absent for a solid line. */
+    readonly lineStyle?: string;
+    /** The marker key; absent for the first marker. */
+    readonly marker?: string;
+}
+
+/**
+ * How an axis places its positions (ADR-0251): in proportion, evenly as categories, or by their logarithm,
+ * all above zero (ADR-0290).
+ */
+export declare type AxisScale = 'proportional' | 'categories' | 'logarithmic';
+
+/** The vertical axis a series reads on. */
+export declare type AxisSide = 'left' | 'right';
+
+/** How the horizontal axis is ticked and labelled: three independent choices. */
+export declare interface AxisStyle {
+    /** Where the ticks go; `auto` by default. */
+    readonly placement?: TickPlacement;
+    /** How a date tick is labelled; `auto` by default. */
+    readonly label?: DateLabel;
+    /** The labels' angle: 0 (the default), 45 or 90 degrees, read upwards. */
+    readonly angle?: number;
+}
+
+/** What the horizontal positions are: dates as day numbers, numbers, or labels by their index. */
+export declare type AxisValues = 'dates' | 'numbers' | 'labels';
+
+/** A lower and an upper bound. */
+export declare type Bounds = readonly [lower: number, upper: number];
+
+/** A rectangle in CSS pixels. */
+export declare interface Box {
+    /** Its left. */
+    readonly x: number;
+    /** Its top. */
+    readonly y: number;
+    /** Its width. */
+    readonly width: number;
+    /** Its height. */
+    readonly height: number;
+}
+
+/**
+ * Lays `definition` out at `metrics`, narrowed by the options' view. `independentScales` lists the panels
+ * whose left and right axes the Consumer declared independent (ADR-0251); `legend` says where each panel's
+ * legend sits (ADR-0271).
+ */
+export declare function buildScene(definition: ChartDefinition, metrics: ChartMetrics, options?: SceneOptions): ChartScene;
+
+/** The calendar period candles merge into past the plot's pixels (ADR-0302): each the market's own. */
+export declare type CandlePeriod = 'row' | 'week' | 'month' | 'quarter' | 'year';
+
+/** The horizontal axis, its defaults applied. */
+export declare interface ChartAxis {
+    /** What the positions are. */
+    readonly values: AxisValues;
+    /** The axis' title. */
+    readonly title: string;
+    /** The scale declared, or absent for the default. */
+    readonly scale?: AxisScale;
+    /** The categories' labels. */
+    readonly labels: readonly string[];
+    /** The declared positions' labels. */
+    readonly named: readonly NamedPosition[];
+    /** Days in a year, for an Amount per period on dates. */
+    readonly daysPerYear: number;
+    /** Whether the sessions are packed. */
+    readonly packed: boolean;
+    /** The Consumer's writer of a position, if any. */
+    readonly format?: (position: number) => string;
+    /** The format code that writes its positions, if any (ADR-0420). */
+    readonly formatCode?: string;
+    /** The scale, defaults applied. */
+    readonly effectiveScale: AxisScale;
+}
+
+/** The horizontal axis as a Consumer declares it (ADR-0251). */
+export declare interface ChartAxisOptions {
+    /** What the positions are. */
+    readonly values: AxisValues;
+    /** The axis' title; empty by default. */
+    readonly title?: string;
+    /** How positions are placed; absent takes the default for `values`. */
+    readonly scale?: AxisScale;
+    /** The categories' labels in their order, for `labels`; position i is label i. */
+    readonly labels?: readonly string[];
+    /** Labels for declared positions, shown in place of the number. */
+    readonly named?: readonly NamedPosition[];
+    /** How many days a year has when an Amount per period on a Dates axis is drawn per year; 365.25 by default. */
+    readonly daysPerYear?: number;
+    /** The sessions packed (ADR-0301): each position a Price Range has one evenly spaced slot. */
+    readonly packed?: boolean;
+    /** Writes a position, as the column the positions came from writes it (ADR-0250). */
+    readonly format?: (position: number) => string;
+    /**
+     * An Excel number format code in the invariant spelling that writes every position (ADR-0420): a date code
+     * on a Dates axis, a number code on a Numbers axis, written invariantly. A code the reader does not read,
+     * one beside a `format`, and one on a Labels axis are refused.
+     */
+    readonly formatCode?: string;
+}
+
+/** The Chrome slots a chart takes: the parts a Wrapper draws, each in place of the built-in markup's. A slot not
+ * given is the built-in markup's. */
+export declare interface ChartChrome {
+    /** The toolbar, with Chart Filters' range and the axis switch (ADR-0273, ADR-0281). */
+    readonly toolbar?: ChartChromeSlot<ChartToolbarSlotContext>;
+    /** The context menu's contents (ADR-0281). */
+    readonly menu?: ChartChromeSlot<ChartMenuSlotContext>;
+}
+
+/**
+ * A Chrome slot's mount function (ADR-0350 section 9): it draws the part into `slot`, the element the chart made
+ * for it, from `context`, and answers the function that takes what it drew away. The chart calls that cleanup
+ * before the slot goes, and before it mounts again on the same slot with a new context.
+ */
+export declare type ChartChromeSlot<Context> = (slot: HTMLElement, context: Context) => () => void;
+
+/** One command the chart decides (ADR-0281): what it is called, whether it is available, and what it does. */
+export declare interface ChartCommand {
+    /** Stable, for an icon: one of `chartWordIds`' command ids. */
+    readonly id: string;
+    /** What it is called, in the chart's words. */
+    readonly label: string;
+    /** Whether it is available: Reset range is not while nothing is narrowed, CSV not on a chart its Chart Source thinned. */
+    readonly enabled: boolean;
+    /** For a toggle, Chart Filters and View as table, whether what it opens is open; absent on a plain command. */
+    readonly expanded?: boolean;
+    /** Why it is not available, where the chart says why (CSV on a thinned chart, ADR-0344); absent otherwise. */
+    readonly title?: string;
+    /** Runs it, as the built-in control's click does; from the context menu it closes the menu first. Nothing once
+     * the contents it was handed to are taken away or handed another context: what they drew is no longer the
+     * chart's (spine rule 6). */
+    readonly invoke: () => void;
+}
+
+/**
+ * A row per point, after a byte-order mark: Series, the axis' title, Value, Kind (quoted, interpolated,
+ * extrapolated; a Price Range's columns are "price range", an Interval's bounds "interval") and Method (the
+ * Segment's). Its empty Value is only ever a missing one.
+ */
+export declare function chartCsvLong(definition: ChartDefinition, metrics: ChartMetrics, view?: ChartView): string;
+
+/**
+ * A row per position, a column per series, after a byte-order mark — an Interpolated series' column says
+ * so, and a series with extrapolated points has a column of its own for them. An empty cell cannot tell a
+ * missing value from a position the series has no point at; the long form can.
+ */
+export declare function chartCsvWide(definition: ChartDefinition, metrics: ChartMetrics, view?: ChartView): string;
+
+/**
+ * A table a chart reads by column name (ADR-0320, ADR-0322), as C#'s `IChartData` is read. A value is
+ * `null` where it is missing, and otherwise one of: a `number` (C#'s `double`), a `bigint` (a whole number,
+ * held exactly as C#'s `int` and `long` are), a Snapshot's decimal `{ mantissa, scale }` (C#'s `decimal`),
+ * a `string`, a `boolean`, a `Temporal.PlainDate` (C#'s `DateOnly`) or a `Temporal.PlainDateTime` (C#'s
+ * `DateTime`). A date is recognised by its own tag and read through its own members, never through the
+ * global `Temporal`, as `@ex-grid/data` reads one.
+ */
+export declare interface ChartData {
+    /** The columns' names, in the table's order. */
+    readonly columns: readonly string[];
+    /** How many rows it has. */
+    readonly rowCount: number;
+    /** The value in `column` at `row`, as the table holds it; `null` where it is missing. */
+    value(column: string, row: number): unknown;
+}
+
+/**
+ * A table of columns held in memory, each `[name, values]`, all of one length: the reference implementation
+ * of {@link ChartData}, as C#'s `ChartData.Of` is. Two columns of one name, or columns of different lengths,
+ * are refused with a `TypeError`; reading a column it does not have, or a row past its last, with a
+ * `RangeError`.
+ */
+export declare function chartDataOf(columns: readonly (readonly [name: string, values: readonly unknown[]])[]): ChartData;
+
+/**
+ * What a chart is of, in the data's own terms (ADR-0251): its horizontal axis, its series and the
+ * Consumer's Notes. A definition that cannot be drawn honestly is refused when it is made, with a
+ * `ChartRefusedError` whose sentence says why.
+ */
+export declare class ChartDefinition {
+    #private;
+    /** A chart of the given series on the given axis; refused when it cannot be drawn as asked. */
+    constructor(options: ChartDefinitionOptions);
+    /** The horizontal axis. */
+    get axis(): ChartAxis;
+    /** The series, in the order the legend lists them. */
+    get series(): readonly ChartSeries[];
+    /** The Consumer's Notes. */
+    get notes(): readonly string[];
+}
+
+/** What a chart is of: its horizontal axis, its series, and the Consumer's Notes (ADR-0251, ADR-0257). */
+export declare interface ChartDefinitionOptions {
+    /** The horizontal axis. */
+    readonly axis: ChartAxisOptions;
+    /** The series, in the order the legend lists them. */
+    readonly series: readonly ChartSeriesOptions[];
+    /** The Consumer's Notes: plain lines shown under the chart (ADR-0257). */
+    readonly notes?: readonly string[];
+}
+
+/** An edge between two nodes of an Observation, each named by its point's `row` (ADR-0321). */
+export declare interface ChartEdge {
+    /** The Row Key of the node it starts at. */
+    readonly from: unknown;
+    /** The Row Key of the node it ends at. */
+    readonly to: unknown;
+}
+
+/** An edge as the pointer finds it (ADR-0321). */
+export declare interface ChartEdgeMark {
+    /** The series' identity. */
+    readonly seriesId: string;
+    /** The panel it is drawn in. */
+    readonly panel: number;
+    /** The edge as drawn, cut to the plot; its `index` names which of the series' edges it is. */
+    readonly edge: DrawnEdge;
+}
+
+/** The formats a chart saves as. */
+export declare type ChartFileFormat = 'csv' | 'svg' | 'png';
+
+/**
+ * Chart Filters (ADR-0273): the range typed in the axis' own values, and the axis switch. The contents hold what is
+ * being typed; the chart reads it when it is applied, and says what it could not read rather than guess (spine
+ * rule 1).
+ */
+export declare interface ChartFiltersSlotContext {
+    /** What the axis holds: a date axis may take a date input, a category axis one of {@link ChartFiltersSlotContext.labels}. */
+    readonly values: AxisValues;
+    /** The categories of a category axis, in order; empty otherwise. */
+    readonly labels: readonly string[];
+    /** The range's start as the chart holds it, in the axis' text (a date as yyyy-MM-dd); `null` for the axis' own
+     * start. It changes when Chart Filters opens, a drag narrows the range, or Reset range returns it, and what the
+     * contents hold typed is then replaced by it. */
+    readonly from: string | null;
+    /** The range's end, likewise; `null` for the axis' own end. */
+    readonly to: string | null;
+    /** What a value looks like on this axis. */
+    readonly hint: string;
+    /** Why the last range applied was not taken; `null` when it was. */
+    readonly error: string | null;
+    /** Applies a typed range: an end empty or `null` is the axis' own end. Nothing once the contents are handed
+     * another context, as a command's `invoke`. */
+    readonly apply: (from: string | null, to: string | null) => void;
+    /** How positions are spaced, where the axis can be switched; absent where it cannot. */
+    readonly scale?: AxisScale;
+    /** Switches the axis; nothing once the contents are handed another context. */
+    readonly setScale: (scale: AxisScale) => void;
+}
+
+/** A chart drawn into an element, handed back by {@link createChart}. */
+export declare interface ChartHandle {
+    /** Takes the options again, whole: what did not change costs nothing, and a part of the drawing that did
+     * not change is not touched (ADR-0252). */
+    update(options: ChartOptions): void;
+    /** Stops the chart: it hears nothing more and empties its element. */
+    destroy(): void;
+    /**
+     * Saves the chart as a file, as the user sees it (ADR-0282): `csv`, the visible series in the range shown;
+     * `svg`, the drawing; `png`, that drawing painted at the screen's Device Pixel. One call is one save. False
+     * for a CSV of a chart its Chart Source thinned (ADR-0344), and once the chart is destroyed.
+     */
+    download(format: ChartFileFormat): Promise<boolean>;
+    /**
+     * Returns the range the user narrowed to the whole without raising `onRangeChanged`: for a Framework Adapter
+     * whose host learns only after the release that the data was replaced before it (ADR-0272, spine rule 6).
+     */
+    dropRange(): void;
+}
+
+/** The Consumer's word for an id, or `undefined` to keep the English. */
+export declare type ChartLabel = (id: string) => string | undefined;
+
+/** A marker of an Observation series as the pointer finds it (ADR-0290). */
+export declare interface ChartMark {
+    /** The series' identity. */
+    readonly seriesId: string;
+    /** The panel it stands in. */
+    readonly panel: number;
+    /** Its centre across, in pixels. */
+    readonly x: number;
+    /** Its centre down, in pixels. */
+    readonly y: number;
+    /** The index of the series' point it stands for, the first where it stands for more than one. */
+    readonly point: number;
+    /** How many of the series' points it stands for. */
+    readonly count: number;
+}
+
+/** What the context menu's contents are handed (ADR-0281). The slot is the menu's frame (`role="menu"`, named by
+ * the chart), which opens where it was asked for and takes the keyboard; a click outside it, Escape on it or a
+ * command invoked closes it. The contents draw one item per command, in this order. */
+export declare interface ChartMenuSlotContext {
+    /** The menu's accessible name. */
+    readonly name: string;
+    /** Reset range, View as table, then CSV, SVG and PNG. */
+    readonly commands: readonly ChartCommand[];
+    /** Closes the menu, for a dismissal of the contents' own; nothing once the menu has closed. */
+    readonly close: () => void;
+}
+
+/** The geometry a chart is laid out with, in CSS pixels, resolved by the caller and never paired with a stylesheet literal. */
+export declare interface ChartMetrics {
+    /** The chart's width. */
+    readonly width: number;
+    /** The chart's height. */
+    readonly height: number;
+    /** Device pixels per CSS pixel, which Thinning and sampling count in (ADR-0090); 1 by default. */
+    readonly devicePixelRatio?: number;
+    /** A label's height; 14 by default. */
+    readonly lineHeight?: number;
+    /** The space around the plots; 8 by default. */
+    readonly padding?: number;
+    /** The space between panels; 16 by default. */
+    readonly panelGap?: number;
+    /** A label's estimated width; text is never measured (ADR-0021). By default 0.6 of the line height a character. */
+    readonly textWidth?: (text: string) => number;
+    /** How many colour slots the stylesheet defines: ten, unless a theme declares more (ADR-0256). */
+    readonly colourSlots?: number;
+}
+
+/** What a chart is drawn from, and what it tells. */
+export declare interface ChartOptions {
+    /** The chart, in the data's terms. */
+    readonly definition: ChartDefinition;
+    /** The drawing's width in CSS pixels; geometry is an option, never only a stylesheet value (ADR-0027). 800 unless given. */
+    readonly width?: number;
+    /** The drawing's height in CSS pixels; 400 unless given. */
+    readonly height?: number;
+    /** The density whose font size and glyph widths lay out the labels, as a grid's (ADR-0016, ADR-0028); `standard` unless given. */
+    readonly density?: GridDensity;
+    /** The chart's name, which its accessible summary and its table's caption begin with (ADR-0275). */
+    readonly title?: string;
+    /** A description the Consumer adds after the generated summary. */
+    readonly description?: string;
+    /** Where the legend sits: top (the default), bottom, left or right, aligned, or none (ADR-0271). */
+    readonly legend?: LegendPlacement;
+    /** How the horizontal axis places and writes its ticks. */
+    readonly axisStyle?: AxisStyle;
+    /** The panels whose left and right axes the Consumer declared independent (ADR-0251). */
+    readonly independentScales?: ReadonlySet<string> | readonly string[];
+    /** How many colour slots the stylesheet defines: ten, unless a theme declares more (ADR-0256). */
+    readonly colourSlots?: number;
+    /** The keys of the series hidden, taken back from `onSeriesVisibilityChanged`. */
+    readonly hiddenSeries?: ReadonlySet<string> | readonly string[];
+    /** Hears the user hide or show a series from the legend. */
+    readonly onSeriesVisibilityChanged?: (change: SeriesVisibility) => void;
+    /** The range shown, taken back from `onRangeChanged`; absent or `null` for the whole range. */
+    readonly range?: ChartRange | null;
+    /** Hears the user narrow the range, or return it to the whole (`null`). */
+    readonly onRangeChanged?: (range: ChartRange | null) => void;
+    /** The scale the horizontal axis is switched to, taken back from `onScaleChanged`; absent for the declared one. */
+    readonly scale?: AxisScale;
+    /** Hears the user switch the horizontal axis under Chart Filters. */
+    readonly onScaleChanged?: (scale: AxisScale) => void;
+    /** The vertical axes' scale: `logarithmic`, or absent for proportional (ADR-0290). A value at or below zero keeps them proportional, with a Note naming it. */
+    readonly yScale?: AxisScale;
+    /** Hears a click on a point: pressed and released at one position, on the series nearest the pointer that has a value there (ADR-0258). */
+    readonly onPointClick?: (click: ChartPointClick) => void;
+    /** The name a saved file takes, without its extension; the title's when absent, else `chart` (ADR-0282). */
+    readonly fileName?: string;
+    /** The words of the built-in markup by id (ADR-0370 section 10): the Consumer's, `japaneseChartWords`, or the English. */
+    readonly label?: ChartLabel;
+    /** The parts a Wrapper's Chrome draws in place of the built-in markup: the toolbar and the context menu's
+     * contents (ADR-0281, ADR-0390). */
+    readonly chrome?: ChartChrome;
+}
+
+/**
+ * Whether a selection's series run down its columns or along its rows (ADR-0258). It comes from the grid's
+ * declarations, never from the selection's shape: `seriesInColumns` is a history, each column a series along
+ * an axis column (dates or numbers); `seriesInRows` is a curve, each row a series across columns at declared
+ * positions (tenors).
+ */
+export declare type ChartOrientation = 'seriesInColumns' | 'seriesInRows';
+
+/** A point of a series: its position across and its value, or `null` where it is missing — a gap, never a zero. */
+export declare interface ChartPoint {
+    /** The position: a day number, a number, or a category's index. */
+    readonly x: number;
+    /** The value, or `null` where it is missing. */
+    readonly y: ChartValue | null;
+    /** What the point is, such as a name, which an Observation's tooltip says (ADR-0290). */
+    readonly name?: string;
+    /** The Row Key of the row the point was read from, raised when it is clicked (ADR-0290). */
+    readonly row?: unknown;
+}
+
+/** A click on a point of a chart (ADR-0258): the series nearest the pointer, at the position clicked. */
+export declare interface ChartPointClick {
+    /** The series' identity, as the Chart Definition gives it. */
+    readonly seriesId: string;
+    /** The position clicked, in the axis' own values. */
+    readonly position: number;
+    /** The Row Key of an Observation's point clicked, as its point gives it (ADR-0290); absent otherwise. */
+    readonly row?: unknown;
+}
+
+/**
+ * The range of the horizontal axis the user narrowed the chart to (ADR-0273), in the axis' own values — a
+ * date's day number, a number, a category's index — never in pixels (ADR-0272). An end left out is the
+ * data's own.
+ */
+export declare interface ChartRange {
+    /** The first position shown; absent for the data's first. */
+    readonly from?: number;
+    /** The last position shown; absent for the data's last. */
+    readonly to?: number;
+    /** The lowest value the left axis shows, which a rectangle dragged across a scatter narrows (ADR-0290); absent for the data's. */
+    readonly yFrom?: number;
+    /** The highest; absent for the data's. */
+    readonly yTo?: number;
+}
+
+/** What the tooltip says at one position in one panel, over a mark or over an edge (ADR-0270). */
+export declare interface ChartReading {
+    /** The position, written as the axis writes it, or what the mark or the edge is named by. */
+    readonly position: string;
+    /** The lines shown, top to bottom: the nearest to the pointer's height, as many as fit the plot. */
+    readonly lines: readonly ReadingLine[];
+    /** How many series are not listed, which the tooltip says as "and M more series"; never a silent cut. */
+    readonly more: number;
+}
+
+/** A chart that cannot be drawn as it was asked for, said by name (spine rule 1). */
+export declare class ChartRefusedError extends Error {
+    /** A refusal saying why. */
+    constructor(message: string);
+}
+
+/** A chart laid out in CSS pixels as immutable pieces (ADR-0252). */
+export declare interface ChartScene {
+    /** The panels, top to bottom. */
+    readonly panels: readonly PanelScene[];
+    /** The horizontal axis' ticks, each with its pixel position. */
+    readonly xTicks: readonly HorizontalTick[];
+    /** The first position shown. */
+    readonly xFrom: number;
+    /** The last. */
+    readonly xTo: number;
+    /** The lines said under the chart: the Consumer's Notes, each Segment's method, and what the scene itself must say. */
+    readonly notes: readonly string[];
+    /** The positions the pointer can be over, each with its pixel position, left to right (ADR-0255). */
+    readonly positions: readonly PointerPosition[];
+    /** Whether a visible series is an Observation: the pointer then finds the nearest mark (ADR-0290). */
+    readonly scatter: boolean;
+    /** The Observation series' marks, in drawing order (ADR-0290). */
+    readonly marks: readonly ChartMark[];
+    /** The edges drawn, which the pointer finds the nearest of where no mark is within reach (ADR-0321). */
+    readonly edgeMarks: readonly ChartEdgeMark[];
+    /** Whether the axis across is logarithmic as drawn (ADR-0290). */
+    readonly logarithmicX: boolean;
+    /** The colour bars of the visible series that take their colour from a column (ADR-0320). */
+    readonly colourKeys: readonly ColourKey[];
+    /** The size keys of the visible series that take their size from a column (ADR-0320). */
+    readonly sizeKeys: readonly SizeKey[];
+    /** The horizontal axis' title as drawn, with what the scene must add to it (ADR-0301, ADR-0302). */
+    readonly xTitle: string;
+}
+
+/** One series, its defaults applied. */
+export declare interface ChartSeries {
+    /** Its identity. */
+    readonly id: string;
+    /** Its name. */
+    readonly name: string;
+    /** Its Series Kind. */
+    readonly kind: SeriesKind;
+    /** Which interval a step's point stands for. */
+    readonly step: StepSide;
+    /** The vertical axis it reads on. */
+    readonly axis: AxisSide;
+    /** Its panel. */
+    readonly panel: string;
+    /** The keys declared, if any. */
+    readonly keys?: AppearanceKeys;
+    /** Whether it said it reaches zero, if it said. */
+    readonly fromZero?: boolean;
+    /** Whether it is the Consumer's interpolation. */
+    readonly interpolated: boolean;
+    /** Its Segments. */
+    readonly segments: readonly Segment[];
+    /** Its points; a Price Range's are its closes. */
+    readonly points: readonly ChartPoint[];
+    /** Its colour scale, if any. */
+    readonly colourBy?: PointColour;
+    /** Its size scale, if any. */
+    readonly sizeBy?: PointSize;
+    /** Its tooltip's columns. */
+    readonly details: readonly PointDetail[];
+    /** Its edges. */
+    readonly edges: readonly ChartEdge[];
+    /** A Price Range's rows. */
+    readonly bars: readonly PriceBar[];
+    /** A Price Range's fixed period, if any. */
+    readonly mergeTo?: CandlePeriod;
+    /** Its vertical Interval, if any. */
+    readonly interval?: SeriesInterval;
+    /** Its horizontal Interval, if any. */
+    readonly xInterval?: SeriesInterval;
+    /** What its source's thinned pixels held. */
+    readonly thinned: readonly PixelSummary[];
+    /** Its function, if it is sampled. */
+    readonly sampler?: SeriesSampler;
+    /** Its writer of values, if any. */
+    readonly format?: (value: ChartValue) => string;
+    /** The format code that writes its values, if any (ADR-0420). */
+    readonly formatCode?: string;
+    /** The keys its look is chosen by, its id standing for a colour key it does not set. */
+    readonly effectiveKeys: AppearanceKeys;
+    /** Whether its axis reaches zero, defaults applied. */
+    readonly reachesZero: boolean;
+}
+
+/** One series as a Consumer declares it, in the data's own terms (ADR-0251). */
+export declare interface ChartSeriesOptions {
+    /** The series' identity in the chart: unique, and stable through a sort or a recalculation. */
+    readonly id: string;
+    /** Its name in the legend and the tooltip. */
+    readonly name: string;
+    /** What its numbers are; a series that declares none is refused (ADR-0253). */
+    readonly kind: SeriesKind;
+    /** Which interval a step's point stands for; `preceding` by default. */
+    readonly step?: StepSide;
+    /** The vertical axis it reads on; `left` by default. */
+    readonly axis?: AxisSide;
+    /** The panel it is drawn in; series naming the same panel share it. Empty by default. */
+    readonly panel?: string;
+    /** The keys its look is chosen by (ADR-0256); by default its colour key is its id. */
+    readonly keys?: AppearanceKeys;
+    /** Whether its axis reaches zero; absent takes the default for its kind (ADR-0253, ADR-0290). */
+    readonly fromZero?: boolean;
+    /** Whether it is values the Consumer computed between quotes (ADR-0257). */
+    readonly interpolated?: boolean;
+    /** The ranges of an Interpolated series and each one's method (ADR-0257). */
+    readonly segments?: readonly Segment[];
+    /** Its points, in increasing position (an Observation's in any order). */
+    readonly points?: readonly ChartPoint[];
+    /** An Observation's colour read from a column (ADR-0320). */
+    readonly colourBy?: PointColour;
+    /** An Observation's size read from a column (ADR-0320). */
+    readonly sizeBy?: PointSize;
+    /** An Observation's columns its tooltip says (ADR-0321). */
+    readonly details?: readonly PointDetail[];
+    /** An Observation's edges between its nodes (ADR-0321). */
+    readonly edges?: readonly ChartEdge[];
+    /** A Price Range's rows (ADR-0300); its points are then each row's close, or a gap. */
+    readonly bars?: readonly PriceBar[];
+    /** A Price Range's period fixed by the Consumer (ADR-0302). */
+    readonly mergeTo?: CandlePeriod;
+    /** The vertical Interval (ADR-0303, ADR-0304). */
+    readonly interval?: SeriesInterval;
+    /** An Observation's horizontal Interval (ADR-0304). */
+    readonly xInterval?: SeriesInterval;
+    /** What each pixel its Chart Source thinned held (ADR-0344). */
+    readonly thinned?: readonly PixelSummary[];
+    /** The function it is sampled from, in place of points. */
+    readonly sampler?: SeriesSampler;
+    /** Writes one of its values, as its column does (ADR-0250, ADR-0251). */
+    readonly format?: (value: ChartValue) => string;
+    /**
+     * An Excel number format code in the invariant spelling that writes every value, held or computed (ADR-0420),
+     * written invariantly. A code the reader does not read, a date code, and one beside a `format` are refused.
+     */
+    readonly formatCode?: string;
+}
+
+/**
+ * Where a chart reads a series' points (ADR-0322): thinned where the data lives. The counterpart of C#'s
+ * `IChartSource`.
+ */
+export declare interface ChartSource {
+    /** Answers `query` with the points the chart draws; `signal` is aborted when the chart no longer waits for it. */
+    thin(query: ChartSourceQuery, signal: AbortSignal): Promise<ChartSourceAnswer>;
+}
+
+/**
+ * A {@link ChartSource}'s answer (ADR-0344): the rows kept, in order across, as a table with the query's `x` and
+ * `y` columns, what each thinned pixel held, and the version of the data it was read from. The counterpart of C#'s
+ * `ChartSourceAnswer`.
+ */
+export declare interface ChartSourceAnswer {
+    /** The version of the data the answer was read from, as a Snapshot names its own; an answer for an older one is never
+     * drawn over a newer one. */
+    readonly version: bigint;
+    /** The rows kept, in order across. */
+    readonly points: ChartData;
+    /** What each pixel that held more than one row held, in the data's positions; empty when nothing was thinned. */
+    readonly thinned: readonly PixelSummary[];
+}
+
+/** A Chart Source over a table held in the page, thinning it as it is asked, its answers naming `version`; a refusal is
+ * its promise's. */
+export declare function chartSourceOver(data: ChartData, version?: bigint): ChartSource;
+
+/**
+ * What a chart asks a {@link ChartSource} (ADR-0322, ADR-0344): one column of values, read across another, from
+ * `from` to `to`, at `pixels` columns. The counterpart of C#'s `ChartSourceQuery`.
+ */
+export declare interface ChartSourceQuery {
+    /** The Data Handle the series reads. */
+    readonly data: string;
+    /** The column across. */
+    readonly x: string;
+    /** The column of values. */
+    readonly y: string;
+    /** What the axis places: dates, as their day numbers, or numbers. A labels axis is never asked of a source. */
+    readonly values: AxisValues;
+    /** The first position asked for, in the axis' own values; `null` for the data's first. */
+    readonly from: number | null;
+    /** The last, or `null` for the data's last. */
+    readonly to: number | null;
+    /** How many columns the range is cut into, each keeping its first, last, lowest and highest point. */
+    readonly pixels: number;
+}
+
+/** A Chart Spec read through Chart Sources (ADR-0344): its reading, and the version each Data Handle was read at. */
+export declare interface ChartSourceReading {
+    /** The title and the definition. */
+    readonly reading: ChartSpecReading;
+    /** The version each Data Handle's answers named. */
+    readonly versions: ReadonlyMap<string, bigint>;
+}
+
+/** What the tool answers the AI: the counterpart of C#'s `ChartSpecAnswer`. */
+export declare type ChartSpecAnswer = {
+    /** The chart can be drawn. */
+    readonly accepted: true;
+    /** The chart said in words, to check against what was meant. */
+    readonly text: string;
+    /** The spec read. */
+    readonly reading: ChartSpecReading;
+} | {
+    /** The chart cannot be drawn. */
+    readonly accepted: false;
+    /** The refusal, which names the path and the reason, for the AI to act on. */
+    readonly text: string;
+    /** No reading: nothing was drawn. */
+    readonly reading: undefined;
+};
+
+/** A Chart Spec read: its title, and the Chart Definition or the 3D surface it describes. */
+export declare class ChartSpecReading {
+    #private;
+    /** A spec of series, or of a 3D surface, read. */
+    constructor(options: ChartSpecReadingOptions);
+    /** The chart's title, or empty when the spec gives none. */
+    get title(): string;
+    /**
+     * The chart of series, its points read from the tables the spec names. A spec of a 3D surface, which
+     * {@link ChartSpecReading.surface} holds, throws an `Error`: a chart of series read from it would be no
+     * chart at all (spine rule 1).
+     */
+    get definition(): ChartDefinition;
+    /** The 3D surface a spec of one describes (ADR-0274); `undefined` for a spec of series. */
+    get surface(): SurfaceDefinition | undefined;
+}
+
+/** A Chart Spec read: its title, and the Chart Definition or the 3D surface it describes. */
+export declare type ChartSpecReadingOptions = {
+    /** The chart's title, or empty when the spec gives none. */
+    readonly title: string;
+    /** The chart, its points read from the tables the spec names. */
+    readonly definition: ChartDefinition;
+} | {
+    /** The surface's title, or empty when the spec gives none. */
+    readonly title: string;
+    /** The surface, its points read from the tables the spec names (ADR-0274). */
+    readonly surface: SurfaceDefinition;
+};
+
+/**
+ * A Chart Spec that cannot be drawn (ADR-0320): its message names the path in the spec and the reason, in
+ * one sentence a host returns to the AI that wrote it, so the AI can correct the spec. The counterpart of
+ * C#'s `ChartSpecRefusedException`.
+ */
+export declare class ChartSpecRefusedError extends Error {
+    /** Where in the spec it was refused, such as `series[1].kind`; empty for the spec as a whole. */
+    readonly path: string;
+    /** A refusal at `path`, said by `message`. */
+    constructor(path: string, message: string);
+}
+
+/** The version of the Chart Spec this reader reads. */
+export declare const chartSpecVersion = 1;
+
+/**
+ * The chart's name, the horizontal axis with its range, each panel's vertical axes with theirs, and each
+ * visible series with its maximum, written through its format, then the Consumer's description. The view
+ * is the scene's own: what it hides and the range it shows are already laid out in it.
+ */
+export declare function chartSummary(definition: ChartDefinition, scene: ChartScene, title?: string, description?: string): string;
+
+/** A table of what the chart shows: a header and rows of invariant text. */
+export declare interface ChartTable {
+    /** The column headers: the axis' title, then a column per series. */
+    readonly header: readonly string[];
+    /** A row per position. */
+    readonly rows: readonly (readonly string[])[];
+}
+
+/** The wide form's header and rows, unquoted: what "View as table" shows (ADR-0275), the same content as {@link chartCsvWide}. */
+export declare function chartTable(definition: ChartDefinition, metrics: ChartMetrics, view?: ChartView): ChartTable;
+
+/** A chart the user registered as a target of "Add to chart" (ADR-0258, U7). */
+export declare interface ChartTarget {
+    /** The chart's name, as the menu item says it. */
+    readonly name: string;
+    /** The chart as it stands. */
+    readonly chart: GridChart;
+}
+
+/** What the toolbar's contents are handed (ADR-0281). The slot stands above the plot; the contents draw the toolbar
+ * (`role="toolbar"`, named {@link ChartToolbarSlotContext.name}) and, while {@link ChartToolbarSlotContext.filters} is
+ * given, Chart Filters below it. */
+export declare interface ChartToolbarSlotContext {
+    /** The toolbar's accessible name: the chart's title, or its word for a chart. */
+    readonly name: string;
+    /** Chart Filters' toggle, Reset range, View as table, then CSV, SVG and PNG, in that order. */
+    readonly commands: readonly ChartCommand[];
+    /** Chart Filters while it is open; absent while it is closed. */
+    readonly filters?: ChartFiltersSlotContext;
+    /** One of the chart's words by its id (`chartWordIds`): the Consumer's `label`, else the built-in English. */
+    readonly label: (id: string) => string;
+}
+
+/**
+ * A series' value: a number, or a whole number held exactly as a bigint, so the tooltip and the files
+ * write the digits the cell holds (ADR-0251). It becomes a number only where a position is computed.
+ */
+export declare type ChartValue = number | bigint;
+
+/** What the viewer narrowed a chart to — its Chart Filters — which narrow the drawing, never the definition. */
+export declare interface ChartView {
+    /** The identities of the series hidden. */
+    readonly hidden?: ReadonlySet<string> | readonly string[];
+    /** The first position shown; absent for the data's first. */
+    readonly from?: number;
+    /** The last position shown; absent for the data's last. */
+    readonly to?: number;
+    /** The scale the viewer switched the axis to; absent for the declared one (ADR-0251). */
+    readonly scale?: AxisScale;
+    /** The lowest value the left axis shows; absent for the data's (ADR-0290). */
+    readonly yFrom?: number;
+    /** The highest; absent for the data's. */
+    readonly yTo?: number;
+    /** The vertical axes' scale: `logarithmic`, or absent or `proportional` (ADR-0290). */
+    readonly yScale?: AxisScale;
+}
+
+/** Every id of ExChart's words, in no particular order. */
+export declare const chartWordIdList: readonly string[];
+
+/** The ids of the words ExChart's built-in markup shows. A command's id is its command id (`chartCommandIds`). */
+export declare const chartWordIds: Readonly<{
+    /** Opens or closes Chart Filters (ADR-0273): `Chart Filters`. */
+    filters: "exchart.filters";
+    /** Returns the range to the whole axis: `Reset range`. */
+    resetRange: "exchart.reset-range";
+    /** Shows the chart's data as a table (ADR-0275): `View as table`. */
+    table: "exchart.table";
+    /** The menu's word for the table while it is shown: `Hide table`. */
+    hideTable: "exchart.table.hide";
+    /** The toolbar's CSV button (ADR-0282): `CSV`. */
+    downloadCsv: "exchart.download.csv";
+    /** The toolbar's SVG button: `SVG`. */
+    downloadSvg: "exchart.download.svg";
+    /** The toolbar's PNG button: `PNG`. */
+    downloadPng: "exchart.download.png";
+    /** The menu's CSV command: `Download CSV`. */
+    menuDownloadCsv: "exchart.menu.download.csv";
+    /** The menu's SVG command: `Download SVG`. */
+    menuDownloadSvg: "exchart.menu.download.svg";
+    /** The menu's PNG command: `Download PNG`. */
+    menuDownloadPng: "exchart.menu.download.png";
+    /** The downloads' group name: `Download`. */
+    downloads: "exchart.downloads";
+    /** The chart's name where it has no title: `Chart`. */
+    chart: "exchart.chart";
+    /** The table's caption where the chart has no title: `Chart data`. */
+    chartData: "exchart.chart-data";
+    /** Chart Filters' start: `From`. */
+    from: "exchart.filters.from";
+    /** Chart Filters' end: `To`. */
+    to: "exchart.filters.to";
+    /** Applies the typed range: `Apply`. */
+    apply: "exchart.filters.apply";
+    /** The axis switch: `Axis`. */
+    axis: "exchart.filters.axis";
+    /** A proportional axis: `Proportional`. */
+    proportional: "exchart.filters.proportional";
+    /** An axis of categories: `Categories`. */
+    categories: "exchart.filters.categories";
+    /** What a value on a date axis looks like: `yyyy-MM-dd`. */
+    dateHint: "exchart.filters.hint.date";
+    /** On a category axis: `category`. */
+    categoryHint: "exchart.filters.hint.category";
+    /** On a number axis: `number`. */
+    numberHint: "exchart.filters.hint.number";
+    /** A typed value the axis does not hold, `{0}` the text and `{1}` what the axis holds: `“{0}” is not {1} on this axis.` */
+    notOnAxis: "exchart.filters.not-on-axis";
+    /** What a date axis holds: `a date (yyyy-MM-dd)`. */
+    aDate: "exchart.filters.a-date";
+    /** What a category axis holds: `a category`. */
+    aCategory: "exchart.filters.a-category";
+    /** What a number axis holds: `a number`. */
+    aNumber: "exchart.filters.a-number";
+    /** A typed range backwards: `From is after To.` */
+    fromAfterTo: "exchart.filters.from-after-to";
+    /** Why a chart its Chart Source thinned saves no CSV and shows no table (ADR-0344). */
+    thinnedAtSource: "exchart.thinned-at-source";
+    /** The tooltip's count of the series it does not list, one: `and 1 more series`. */
+    oneMoreSeries: "exchart.tooltip.one-more";
+    /** The same for more than one, `{0}` the count: `and {0} more series`. */
+    moreSeries: "exchart.tooltip.more";
+    /** The notice of a stylesheet of another version (ADR-0123). */
+    stylesheetNotice: "exchart.notice.stylesheet";
+    /** A 3D surface's button that returns its view (ADR-0274): `Reset view`. */
+    resetView: "exchart.surface.reset-view";
+    /** A surface's name where it has no title: `Surface`. */
+    surface: "exchart.surface";
+    /** A surface's table's caption where it has no title: `Surface data`. */
+    surfaceData: "exchart.surface.data";
+    /** What a surface's box is announced as: `3D surface`. */
+    surfaceRole: "exchart.surface.role";
+    /** The values' name where the surface gives none: `Value`. */
+    surfaceValue: "exchart.surface.value";
+    /** The tooltip's note on a value the data holds, on a surface the Consumer interpolated (ADR-0257): `quoted`. */
+    quoted: "exchart.surface.quoted";
+    /** The note on an interpolated value, `{0}` the method: `interpolated, {0}`. */
+    interpolated: "exchart.surface.interpolated";
+    /** A slice a grid does not hold, `{0}` the axis and `{1}` the value: `No slice at {0} {1}: this surface has no such value.` */
+    noSliceOnGrid: "exchart.surface.no-slice.grid";
+    /** A slice no triangle of a mesh crosses: `No slice at {0} {1}: no triangle of the mesh crosses there.` */
+    noSliceOnMesh: "exchart.surface.no-slice.mesh";
+}>;
+
+/** The colour bar a series' colour is read on (ADR-0320). */
+export declare interface ColourKey {
+    /** The series it belongs to. */
+    readonly seriesId: string;
+    /** What the colours are. */
+    readonly title: string;
+    /** The value at the foot of the lowest band. */
+    readonly from: number;
+    /** The value at the head of the highest band. */
+    readonly to: number;
+    /** Its ticks, the centre always among them when it diverges. */
+    readonly ticks: readonly KeyTick[];
+    /** Whether the bands diverge from a centre, which the middle band holds. */
+    readonly diverging: boolean;
+    /** The bar's box in CSS pixels; its title stands above it. */
+    readonly box: Box;
+    /** How many bands it is drawn in, low to high. */
+    readonly bands: number;
+}
+
+/** A column, by its name, at the rows it was made from (series in columns). */
+export declare interface ColumnSeries {
+    /** Says the series is a column. */
+    readonly type: 'column';
+    /** The series' identity in the Chart Definition: the column's name. */
+    readonly id: string;
+    /** The panel it was given when it was made: its Header Group, or a panel of its own for a Diff (ADR-0251). */
+    readonly panel: string;
+    /** The column's name. */
+    readonly column: string;
+    /** The rows it is charted at, by Row Key: its own, as every Excel series has its own ranges (U8). */
+    readonly rows: readonly KeyedPosition[];
+}
+
+/**
+ * Draws a chart into `element`, which becomes its instance root (ADR-0370 section 1): the chart owns
+ * everything inside it, and the element's own class and style it writes. A Framework Adapter renders the
+ * element and hands the chart its props; nothing here assumes React's lifecycle or Blazor's.
+ */
+export declare function createChart(element: HTMLElement, options: ChartOptions): ChartHandle;
+
+/**
+ * Draws a 3D surface into `element`, which becomes its instance root (ADR-0274, ADR-0370 section 1): the
+ * surface owns everything inside it. A Framework Adapter renders the element and hands the surface its props.
+ */
+export declare function createSurface(element: HTMLElement, options: SurfaceOptions): SurfaceHandle;
+
+/** How a date tick is labelled: the finest format the ticks need, 2026, 2026-10, 2026-10-19, Oct 2026, or a tenor. */
+export declare type DateLabel = 'auto' | 'year' | 'yearMonth' | 'date' | 'monthYear' | 'tenor';
+
+/** The view a surface is first drawn at. */
+export declare const defaultSurfaceView: SurfaceView;
+
+/** An edge in CSS pixels, cut at the plot's edges. */
+export declare interface DrawnEdge {
+    /** Where it starts across. */
+    readonly x1: number;
+    /** Where it starts down. */
+    readonly y1: number;
+    /** Where it ends across. */
+    readonly x2: number;
+    /** Where it ends down. */
+    readonly y2: number;
+    /** Which of its series' edges it is. */
+    readonly index: number;
+}
+
+/** A marker: where it stands, and whether it is filled — the function takes the value there — or an outline (ADR-0253). */
+export declare interface DrawnMarker {
+    /** The horizontal position. */
+    readonly x: number;
+    /** The height. */
+    readonly y: number;
+    /** Filled where the function takes the value; an outline where it does not. */
+    readonly filled: boolean;
+    /** The index of the series' point the marker stands for, or -1 when it stands for none. */
+    readonly point: number;
+    /** How many of the series' points it stands for: more than one where markers on one device pixel were merged (ADR-0290). */
+    readonly count: number;
+    /** An Observation's vertical interval at the marker; where marks merged, the union of theirs (ADR-0304). */
+    readonly yBounds?: Bounds;
+    /** An Observation's horizontal interval at the marker (ADR-0304). */
+    readonly xBounds?: Bounds;
+    /** Its colour band from the series' colour scale; absent for the series' own colour (ADR-0320). */
+    readonly band?: number;
+    /** Its radius from the series' size scale: a share of the largest in a drawing, CSS pixels in a scene (ADR-0320). */
+    readonly radius?: number;
+}
+
+/** A point of a drawn line, in the axes' own units: the horizontal position and the height. */
+export declare interface DrawnPoint {
+    /** The horizontal position. */
+    readonly x: number;
+    /** The height, in the vertical axis' units. */
+    readonly y: number;
+}
+
+/** A whisker as drawn: a point's interval. */
+export declare interface DrawnWhisker {
+    /** The point's position. */
+    readonly x: number;
+    /** Its lower bound. */
+    readonly lower: number;
+    /** Its upper bound. */
+    readonly upper: number;
+}
+
+/**
+ * Ordinary least squares (ADR-0291): the line that minimises the squared vertical distances, in `space`. A
+ * point whose x or y is not a finite number, or whose logarithm the space cannot take, is refused.
+ */
+export declare function fitLeastSquares(xs: readonly number[], ys: readonly number[], space?: FitSpace): FittedCurve;
+
+/** Least squares of a polynomial of `degree` (ADR-0291), solved by Householder QR; degree 1 is `fitLeastSquares`. */
+export declare function fitPolynomial(xs: readonly number[], ys: readonly number[], degree: number, space?: FitSpace): FittedCurve;
+
+/** The space a fit is made in (ADR-0291): y against x, ln y against x (an exponential), or ln y against ln x (a power law). */
+export declare type FitSpace = 'linear' | 'logY' | 'logLog';
+
+/**
+ * A curve fitted by one of the fits (`fitLeastSquares`, `fitTheilSen`, `fitPolynomial`): its method, its
+ * coefficients in the space it was fitted in, R² there, how many points it was fitted on, and the range of x
+ * they span (ADR-0291).
+ */
+export declare class FittedCurve {
+    #private;
+    /** A curve of the given coefficients; refused when it has none, since a polynomial has a constant at least. */
+    constructor(options: FittedCurveOptions);
+    /** The method's name, such as `OLS` or `Theil–Sen`. */
+    get method(): string;
+    /** The polynomial's coefficients from the constant up: for a line, the intercept then the slope. */
+    get coefficients(): readonly number[];
+    /** The share of the variance it explains, in the space it was fitted in; never below zero for least squares, and below
+     * zero for Theil–Sen where it does worse than the mean. */
+    get rSquared(): number;
+    /** How many points it was fitted on. */
+    get count(): number;
+    /** The smallest x it was fitted on. */
+    get from(): number;
+    /** The largest x it was fitted on. */
+    get to(): number;
+    /** The space it was fitted in. */
+    get space(): FitSpace;
+    /** The intercept: the constant coefficient. */
+    get intercept(): number;
+    /** The slope: the first-degree coefficient, or zero for a constant. */
+    get slope(): number;
+    /** The polynomial's degree. */
+    get degree(): number;
+    /**
+     * Its Note: one line naming the method and the space, the equation for a line or the degree for a higher
+     * polynomial, R² and n (ADR-0291), such as `OLS: y = 41.2x + 88.5, R² = 0.63, n = 212`.
+     */
+    get note(): string;
+    /** The fitted value at `x`, back in y, or `null` outside the range it was fitted over or where it is not a finite number. */
+    valueAt(x: number): number | null;
+    /**
+     * The curve as a Level series over the range it was fitted on, sampled by the chart as it draws, read away
+     * from zero, with one Segment named by its Note, so the Notes say it (ADR-0291).
+     */
+    series(id: string, name: string): ChartSeriesOptions;
+}
+
+/** What a fitted curve is made of: the C# record's members. */
+export declare interface FittedCurveOptions {
+    /** The method's name, such as `OLS` or `Theil–Sen`. */
+    readonly method: string;
+    /** The polynomial's coefficients from the constant up: for a line, the intercept then the slope. */
+    readonly coefficients: readonly number[];
+    /** The share of the variance it explains, in the space it was fitted in; never below zero for least squares, and below
+     * zero for Theil–Sen where it does worse than the mean. */
+    readonly rSquared: number;
+    /** How many points it was fitted on. */
+    readonly count: number;
+    /** The smallest x it was fitted on. */
+    readonly from: number;
+    /** The largest. */
+    readonly to: number;
+    /** The space it was fitted in; `linear` where absent. */
+    readonly space?: FitSpace;
+}
+
+/**
+ * Theil–Sen (ADR-0291): the median of the slopes between every pair of points with different x, and the
+ * median of yᵢ − slope·xᵢ as the intercept. A single point far off does not drag it. More than
+ * `theilSenLimit` points are refused.
+ */
+export declare function fitTheilSen(xs: readonly number[], ys: readonly number[], space?: FitSpace): FittedCurve;
+
+/** Where a click on a chart's point lands in the grid (ADR-0258, M3-Q6). */
+export declare interface GridCell {
+    /** The point's row, by its Row Key. */
+    readonly rowKey: RowKey;
+    /** The point's column, by its name. */
+    readonly column: string;
+}
+
+/**
+ * A chart made from a grid selection: the set of Row Keys and columns it was made from, never the positions
+ * it was painted at (ADR-0258). A recalculated value is redrawn, a row that no longer exists becomes a gap,
+ * and a new row is never added. Hold it as it was handed over: the bridge knows a chart it drew before by
+ * its identity.
+ */
+export declare interface GridChart {
+    /** Whether its series are columns or rows. */
+    readonly orientation: ChartOrientation;
+    /** The axis column of a chart of series in columns; absent for series in rows, whose axis is the declared positions. */
+    readonly axisColumn?: string;
+    /** Its series, in the order they were made and added. */
+    readonly series: readonly GridChartSeries[];
+}
+
+/**
+ * The grid's side of a chart, ready-made (ADR-0258): context-menu commands a Consumer adds to a grid in one
+ * line, which turn the selection into a {@link GridChart}, and the reading of that chart, by Row Key from the
+ * Consumer's data, into the Chart Definition an ExChart draws. The grid does not know it exists; where the
+ * chart is shown is the Consumer's.
+ */
+export declare class GridChartBridge<Row> {
+    #private;
+    /** A bridge that reads selections by `options.declarations`. */
+    constructor(options: GridChartBridgeOptions<Row>);
+    /** What the Consumer declared for the grid's selections. */
+    get declarations(): GridChartDeclarations<Row>;
+    /**
+     * The commands for the grid's `contextCommands`, worded by {@link gridChartCommandLabel}: "Chart", or "Series
+     * in columns" and "Series in rows" when the selection declares both, and "Add to chart" for each target. It is
+     * one function for the bridge's life, so it can be handed to the grid as it is on every render (ADR-0003).
+     */
+    readonly commands: (context: GridContextMenuContext<Row>) => readonly GridCommand[];
+    /**
+     * The Chart Definition `chart` stands for now, read by Row Key from the declarations' `rowOf`: a recalculated
+     * value is redrawn, and a row that no longer exists is a gap with a Note (ADR-0258). While nothing it reads
+     * has changed, the definition last returned for the same chart is returned again, so the chart skips its
+     * render (ADR-0252). A chart that can no longer be drawn, such as one whose axis column left the grid, is
+     * refused with a `ChartRefusedError`.
+     */
+    draw(chart: GridChart): ChartDefinition;
+    /** The grid cell a click on a point of `chart` stands for, or `undefined` when its row no longer exists. */
+    cellOf(chart: GridChart, click: ChartPointClick): GridCell | undefined;
+    /**
+     * Scrolls the grid to the cell a click on a point stands for and puts the Focus on it (ADR-0258, M3-Q6),
+     * through the Consumer's `placeSelection`. Answers whether the Focus was placed; false where the point's row
+     * no longer exists.
+     */
+    showInGrid(chart: GridChart, click: ChartPointClick): Promise<boolean>;
+    /**
+     * Scrolls the grid to `cell` and puts the Focus on it, as a click on a point does (ADR-0258): for a chart the
+     * Consumer built by hand, such as a scatter whose points carry their Row Keys, whose click names the row
+     * (ADR-0290). Answers whether the Focus was placed; when the row is not among the rows the grid shows,
+     * `onRefused` says so.
+     */
+    showCellInGrid(cell: GridCell): Promise<boolean>;
+}
+
+/** What a {@link GridChartBridge} is made with. */
+export declare interface GridChartBridgeOptions<Row> {
+    /** What the Consumer declared for the grid's selections. */
+    readonly declarations: GridChartDeclarations<Row>;
+    /** The grid whose selections are charted, read each time it is needed; `undefined` while there is none. */
+    readonly grid: () => GridChartGrid<Row> | undefined;
+    /** The open charts the menu offers "Add to chart" for (ADR-0258, U7), in the menu's order, read each time the
+     * menu opens; none unless given. */
+    readonly targets?: () => readonly ChartTarget[];
+    /** Hears a chart made from the selection; the Consumer decides where it is shown. */
+    readonly onChart?: (chart: GridChart) => void;
+    /** Hears a target and the chart it becomes with the selection's series added. */
+    readonly onAdded?: (target: ChartTarget, chart: GridChart) => void;
+    /** Hears the sentence that says why a selection was not charted, or a point not shown in the grid. */
+    readonly onRefused?: (why: string) => void;
+    /**
+     * Places the Selection and the Focus on a cell and scrolls the grid to it, as C#'s `PlaceSelectionAsync`
+     * does, answering whether it was placed: the grid's `placeSelection`, reached through its handle (or
+     * `ExGridApi` under React), which the bridge does not hold. Without it `showInGrid` refuses to be asked.
+     */
+    readonly placeSelection?: (placement: GridSelectionPlacement) => boolean | Promise<boolean>;
+}
+
+/** The stable identities of the commands a {@link GridChartBridge} adds to a grid's menu (ADR-0036). */
+export declare const gridChartCommandIds: Readonly<{
+    /** "Chart": the selection in the one orientation its columns declare. */
+    readonly chart: 'exchart.chart';
+    /** "Series in columns", offered beside `inRows` only when a selection declares both. */
+    readonly inColumns: 'exchart.chart.columns';
+    /** "Series in rows", offered beside `inColumns` only when a selection declares both. */
+    readonly inRows: 'exchart.chart.rows';
+    /** The prefix of "Add to chart: <name>"; the target's name follows it. */
+    readonly addPrefix: "exchart.add:";
+}>;
+
+/** The wording of one of the bridge's commands, for the grid's `commandLabel`; `undefined` for any other. */
+export declare function gridChartCommandLabel(id: string): string | undefined;
+
+/**
+ * What the Consumer declares for a grid's selections to be charted (ADR-0251, ADR-0258). Nothing here is read
+ * off a header or guessed from a selection's shape: "6m" is a header's text, 0.5 years is what the Consumer
+ * says it stands for.
+ */
+export declare interface GridChartDeclarations<Row> {
+    /** A row's identity (ADR-0140), which a chart follows through a sort, a filter and a recalculation. */
+    readonly rowKey: RowKeyOf<Row>;
+    /**
+     * The row a Row Key names in the Consumer's data now, or `undefined` once it no longer exists. A chart reads
+     * its values here, never from the grid's Window, so a row only filtered out of the grid is not reported as
+     * gone (ADR-0258, M3-Q7).
+     */
+    readonly rowOf: (key: RowKey) => Row | undefined;
+    /** Each column's Series Kind by its name (ADR-0253); `undefined` for none. A column with none declared is
+     * refused when it is charted. */
+    readonly kindOf?: (column: string) => SeriesKind | undefined;
+    /**
+     * Whether each column's values are read from zero, by its name (ADR-0253, ADR-0258): false for a level read
+     * away from zero, such as rates between 3.0% and 3.6%; `undefined`, or no function, leaves the Series Kind's
+     * default. A series in rows takes its columns' declaration; they must read zero alike once each is resolved
+     * by its Series Kind's default (`undefined` beside true is alike for a Level), or the curve is refused by
+     * name.
+     */
+    readonly fromZeroOf?: (column: string) => boolean | undefined;
+    /** The number columns that are an axis, by name. A date column is always one; a number column is one only
+     * when it is named here. None unless given. */
+    readonly axisColumns?: ReadonlySet<string> | readonly string[];
+    /** A column's declared position along a curve's axis (a tenor's years), or `undefined` for a column that has none. */
+    readonly positionOf?: (column: string) => number | undefined;
+    /** The title of the declared positions' axis, such as "Tenor (years)"; empty unless given. */
+    readonly positionTitle?: string;
+    /** Whether the declared positions are drawn proportional to their values or as categories (ADR-0251);
+     * `proportional` unless given. */
+    readonly positionScale?: AxisScale;
+    /** A row's name in the legend and the tooltip, for series in rows; the Row Key's text unless given. */
+    readonly rowName?: (row: Row) => string;
+    /** The orientation every selection is charted in, when the Consumer fixes it; absent lets the grid's
+     * declarations decide (ADR-0258). */
+    readonly orientation?: ChartOrientation;
+}
+
+/**
+ * The grid whose selections are charted, as the Consumer handed it to `createGrid` or `<ExGrid>`: its columns
+ * and Header Groups as they stand, and the Grid Source its rows come from, whose snapshot is the Window and the
+ * Row Sequence Version the grid shows.
+ */
+export declare interface GridChartGrid<Row> {
+    /** The columns, in display order. */
+    readonly columns: readonly GridColumn<Row>[];
+    /** The Header Groups over them; none unless given. */
+    readonly headerGroups?: readonly GridHeaderGroup[];
+    /** The source the grid reads its rows from. */
+    readonly source: GridSource<Row>;
+}
+
+/** Every Row Key some series of `chart` is charted at. */
+export declare function gridChartRowKeys(chart: GridChart): ReadonlySet<RowKey>;
+
+/** One series of a {@link GridChart}, in the data's terms (ADR-0251). */
+export declare type GridChartSeries = ColumnSeries | RowSeries;
+
+/**
+ * Where the bridge asks the grid to put the Focus (ADR-0258, M3-Q6): the cell a point stands for, as the
+ * Selection, under the Row Sequence Version the bridge found it in, which the grid's placement refuses under
+ * another order.
+ */
+export declare interface GridSelectionPlacement {
+    /** The Selection to place: the one cell. */
+    readonly range: SelectionRange;
+    /** Where the Focus goes: the same cell. */
+    readonly focus: CellPosition;
+    /** The Row Sequence Version the positions are written in. */
+    readonly rowSequenceVersion: number;
+}
+
+/** A tick of the horizontal axis: its position, its pixel, and its label or `null`. */
+export declare type HorizontalTick = readonly [position: number, x: number, label: string | null];
+
+/**
+ * A curve interpolated by one of the methods (`interpolateLinear`, `interpolateNaturalCubicSpline`): its
+ * method's name, the range it has values over, and its value at a position, `null` outside that range
+ * (ADR-0257).
+ */
+export declare class Interpolant1D {
+    #private;
+    /** A curve of the given method and function. */
+    constructor(options: Interpolant1DOptions);
+    /** The method's name, shown as it is, such as `natural cubic spline`. */
+    get method(): string;
+    /** The first position it has a value at. */
+    get from(): number;
+    /** The last position it has a value at. */
+    get to(): number;
+    /** Its value at a position, `null` outside `from`–`to`, as the function it was made with answers. */
+    get evaluate(): (x: number) => number | null;
+    /** The value at `x`, or `null` outside the range it was made over or where it is not a finite number. */
+    valueAt(x: number): number | null;
+    /**
+     * The curve as a series declared Interpolated, sampled by the chart as it draws, with one Segment named by
+     * the method, so the tooltip and the Notes say it (ADR-0257).
+     */
+    series(id: string, name: string): ChartSeriesOptions;
+}
+
+/** What a curve interpolated by one of the methods is made of: the C# record's members. */
+export declare interface Interpolant1DOptions {
+    /** The method's name, shown as it is, such as `natural cubic spline`. */
+    readonly method: string;
+    /** The first position it has a value at. */
+    readonly from: number;
+    /** The last position it has a value at. */
+    readonly to: number;
+    /** Its value at a position, `null` outside `from`–`to`. */
+    readonly evaluate: (x: number) => number | null;
+}
+
+/**
+ * A surface interpolated by one of the methods (`interpolateBilinear`, `interpolateTriangles`): its method's
+ * name, the rectangle it is evaluated over, and its value at a point, `null` where it has none — outside the
+ * points it was made from, or where a value it would need is missing (ADR-0257, ADR-0274).
+ */
+export declare class Interpolant2D {
+    #private;
+    /** A surface of the given method and function. */
+    constructor(options: Interpolant2DOptions);
+    /** The method's name, shown as it is, such as `bilinear`. */
+    get method(): string;
+    /** The rectangle's left edge. */
+    get xFrom(): number;
+    /** Its right edge. */
+    get xTo(): number;
+    /** Its near edge. */
+    get yFrom(): number;
+    /** Its far edge. */
+    get yTo(): number;
+    /** Its value at a point, or `null`, as the function it was made with answers. */
+    get evaluate(): (x: number, y: number) => number | null;
+    /** The value at (`x`, `y`), or `null` where it has none or where it is not a finite number. */
+    valueAt(x: number, y: number): number | null;
+    /**
+     * The surface sampled across its rectangle under its method's name, as `SurfaceDefinition.sampled` samples a
+     * function (ADR-0257): every value marked interpolated, a hole where it has none.
+     */
+    surface(options: InterpolatedSurfaceOptions): SurfaceDefinition;
+}
+
+/** What a surface interpolated by one of the methods is made of: the C# record's members. */
+export declare interface Interpolant2DOptions {
+    /** The method's name, shown as it is, such as `bilinear`. */
+    readonly method: string;
+    /** The rectangle's left edge. */
+    readonly xFrom: number;
+    /** Its right edge. */
+    readonly xTo: number;
+    /** Its near edge. */
+    readonly yFrom: number;
+    /** Its far edge. */
+    readonly yTo: number;
+    /** Its value at a point, or `null` where it has none. */
+    readonly evaluate: (x: number, y: number) => number | null;
+}
+
+/**
+ * Bilinear interpolation on a grid (ADR-0257): `z` holds one row per y value and one value per x value, both
+ * axes strictly increasing. A cell with a missing corner, `null`, has no value inside (ADR-0274).
+ */
+export declare function interpolateBilinear(xs: readonly number[], ys: readonly number[], z: readonly (readonly (number | null)[])[]): Interpolant2D;
+
+/**
+ * What a surface from an interpolant is sampled with besides: everything `SurfaceDefinition.sampled` takes but
+ * the method, the rectangle and the function, which the interpolant gives.
+ */
+export declare type InterpolatedSurfaceOptions = Omit<SurfaceSampledOptions, 'method' | 'xFrom' | 'xTo' | 'yFrom' | 'yTo' | 'z'>;
+
+/** Straight lines between neighbouring points (ADR-0257); `xs` strictly increasing. */
+export declare function interpolateLinear(xs: readonly number[], ys: readonly number[]): Interpolant1D;
+
+/** A natural cubic spline through the points (ADR-0257): zero second derivative at both ends; `xs` strictly increasing. */
+export declare function interpolateNaturalCubicSpline(xs: readonly number[], ys: readonly number[]): Interpolant1D;
+
+/**
+ * Linear interpolation on a triangle mesh (P1, ADR-0257): within each triangle the plane through its three
+ * corners. `triangles` index into `points`; outside every triangle there is no value. The mesh is the
+ * Consumer's, from its own solver or triangulation.
+ */
+export declare function interpolateTriangles(points: readonly MeshPoint[], triangles: readonly SurfaceTriangle[]): Interpolant2D;
+
+/** An Interval's bounds at one position of its series (ADR-0303). */
+export declare interface IntervalBound {
+    /** The position: one of the series' points. */
+    readonly x: number;
+    /** The lower bound, or `null`. */
+    readonly lower: ChartValue | null;
+    /** The upper bound, or `null`. */
+    readonly upper: ChartValue | null;
+}
+
+/** How a series' Interval is drawn (ADR-0303): whiskers at each point, or a band joining neighbours. */
+export declare type IntervalStyle = 'whiskers' | 'band';
+
+/** ExChart's Japanese: `label: japaneseChartWords`. A Consumer's own function may fall back to it. */
+export declare const japaneseChartWords: ChartLabel;
+
+/** A row a series was made from, by its Row Key, with the axis value it had then. */
+export declare interface KeyedPosition {
+    /** The row's Row Key (ADR-0140). */
+    readonly key: RowKey;
+    /** The row's axis value when the chart was made, which places its gap once the row is gone. */
+    readonly x: number;
+}
+
+/** A tick of a key: its value, its height in CSS pixels, and its label. */
+export declare interface KeyTick {
+    /** The value. */
+    readonly value: number;
+    /** Its height in CSS pixels. */
+    readonly y: number;
+    /** Its label. */
+    readonly label: string;
+}
+
+/** How a legend's entries align along its side (ADR-0271). */
+export declare type LegendAlign = 'start' | 'centre' | 'end';
+
+/** One legend entry, laid out. */
+export declare interface LegendEntry {
+    /** The key a click hides it by: the series' identity, which for quotes and their Interpolated curve is the quotes' and hides both (ADR-0257). */
+    readonly id: string;
+    /** Its name. */
+    readonly name: string;
+    /** Its look, which hiding does not change. */
+    readonly look: SeriesLook;
+    /** Whether it is hidden, which fades the entry. */
+    readonly hidden: boolean;
+    /** Where the entry sits, swatch first. */
+    readonly box: Box;
+}
+
+/**
+ * The identities of the series the legend entry keyed `key` stands for (ADR-0257): the quotes and their
+ * Interpolated curves for a pair's entry, otherwise the series itself. Showing the entry again shows each
+ * of them, however one came to be hidden.
+ */
+export declare function legendMembers(definition: ChartDefinition, key: string): readonly string[];
+
+/** The Consumer's placement of the legend: a side and an alignment, never a pixel offset (ADR-0271). */
+export declare interface LegendPlacement {
+    /** The side; `top` by default. */
+    readonly position?: LegendPosition;
+    /** The alignment; `start` by default. */
+    readonly align?: LegendAlign;
+}
+
+/** Where a panel's legend sits (ADR-0271). */
+export declare type LegendPosition = 
+/** Above each panel's plot. */
+'top'
+/** Below it; under the horizontal axis for the last panel. */
+| 'bottom'
+/** Left of the plots. */
+| 'left'
+/** Right of the plots. */
+| 'right'
+/** No legend. */
+| 'none';
+
+/** The shapes a marker key chooses from, in order. */
+export declare type MarkerShape = 'circle' | 'square' | 'diamond' | 'triangle';
+
+/** A point of a Consumer's mesh: its position and its value. */
+export declare interface MeshPoint {
+    /** Its x position. */
+    readonly x: number;
+    /** Its y position. */
+    readonly y: number;
+    /** Its value. */
+    readonly z: number;
+}
+
+/** A labelled position of a number axis, such as "6M" at 0.5. */
+export declare type NamedPosition = readonly [position: number, label: string];
+
+/** A panel: its plot's box, its vertical axes and its series. */
+export declare interface PanelScene {
+    /** The panel's name. */
+    readonly name: string;
+    /** The plot's box. */
+    readonly plot: Box;
+    /** The left axis, or `null` when no series reads on it. */
+    readonly left: VerticalAxis | null;
+    /** The right axis, or `null`. */
+    readonly right: VerticalAxis | null;
+    /** The height of zero in pixels, where the plot holds it, or `null`. */
+    readonly zeroY: number | null;
+    /** The visible series, in the definition's order. */
+    readonly series: readonly SeriesPiece[];
+    /** Its legend: every series of the panel, hidden ones included (ADR-0271). */
+    readonly legend: readonly LegendEntry[];
+    /** The Price Range whose volume this panel draws, or `null` for a panel of the Consumer's (ADR-0300). */
+    readonly volumeOf: string | null;
+}
+
+/** What one thinned device pixel holds, for the tooltip to say (ADR-0254). */
+export declare interface PixelSummary {
+    /** The first position in the pixel. */
+    readonly from: number;
+    /** The last. */
+    readonly to: number;
+    /** The lowest height. */
+    readonly min: number;
+    /** The highest. */
+    readonly max: number;
+    /** How many points the pixel holds. */
+    readonly count: number;
+}
+
+/** A Price Range's candle in pixels (ADR-0300). */
+export declare interface PlacedCandle {
+    /** Its centre across. */
+    readonly x: number;
+    /** Half its body's width. */
+    readonly halfWidth: number;
+    /** Its open's height, or `null` for a High-Low-Close bar. */
+    readonly openY: number | null;
+    /** Its high's height. */
+    readonly highY: number;
+    /** Its low's height. */
+    readonly lowY: number;
+    /** Its close's height. */
+    readonly closeY: number;
+    /** Its close above its own open, drawn hollow. */
+    readonly rising: boolean;
+    /** Its close equal to its own open. */
+    readonly unchanged: boolean;
+    /** How many rows it stands for. */
+    readonly rows: number;
+    /** The first position it stands for. */
+    readonly from: number;
+    /** The last. */
+    readonly to: number;
+}
+
+/** A volume bar in pixels (ADR-0300). */
+export declare interface PlacedVolume {
+    /** Its centre across. */
+    readonly x: number;
+    /** Half its width. */
+    readonly halfWidth: number;
+    /** Its top's height. */
+    readonly topY: number;
+    /** Its base's height: zero's. */
+    readonly baseY: number;
+    /** Whether its candle rose. */
+    readonly rising: boolean;
+    /** Whether its candle was unchanged. */
+    readonly unchanged: boolean;
+    /** How many rows it stands for. */
+    readonly rows: number;
+    /** The first position it stands for. */
+    readonly from: number;
+    /** The last. */
+    readonly to: number;
+}
+
+/** A point's colour read from a column (ADR-0320): one value a point, coloured in nine bands. */
+export declare interface PointColour {
+    /** What the values are. */
+    readonly title: string;
+    /** One value a point; `null` where it has none, drawn as an outline. */
+    readonly values: readonly (ChartValue | null)[];
+    /** The value the colours diverge from (ADR-0310); absent colours the values low to high. */
+    readonly centre?: number;
+}
+
+/** A column an Observation's tooltip says beside its values, one value a point (ADR-0321). */
+export declare interface PointDetail {
+    /** What the values are. */
+    readonly title: string;
+    /** One value a point, written; `null` where the point has none. */
+    readonly values: readonly (string | null)[];
+}
+
+/** A position the pointer can be over, and its pixel. */
+export declare type PointerPosition = readonly [position: number, x: number];
+
+/** A point's size read from a column (ADR-0320): one value a point, never negative. */
+export declare interface PointSize {
+    /** What the values are. */
+    readonly title: string;
+    /** One value a point; `null` where it has none, drawn as an outline. */
+    readonly values: readonly (ChartValue | null)[];
+}
+
+/** The position across that stands at `x` pixels, on a proportional or logarithmic axis. */
+export declare function positionAt(scene: ChartScene, x: number): number;
+
+/** One row of a Price Range (ADR-0300): a period's open, high, low and close, and optionally its volume. */
+export declare interface PriceBar {
+    /** The period's position: on a Dates axis, its day number. */
+    readonly x: number;
+    /** The first price of the period, or `null`. */
+    readonly open: ChartValue | null;
+    /** The highest, or `null`. */
+    readonly high: ChartValue | null;
+    /** The lowest, or `null`. */
+    readonly low: ChartValue | null;
+    /** The last, or `null`. */
+    readonly close: ChartValue | null;
+    /** The quantity traded, or `null` (absent is the same). */
+    readonly volume?: ChartValue | null;
+}
+
+/**
+ * Reads `text`, a Chart Spec, into a Chart Definition or a 3D surface, taking each Data Handle's table from
+ * `tables`, which answers `undefined` for a handle it does not know: the counterpart of C#'s
+ * `ChartSpec.Read`. A spec that cannot be drawn throws a {@link ChartSpecRefusedError}, whose message says
+ * where and why.
+ */
+export declare function readChartSpec(text: string, tables: (handle: string) => ChartData | undefined): ChartSpecReading;
+
+/**
+ * Reads `text`, a Chart Spec, through Chart Sources (ADR-0344): each series asks its Data Handle's source for its own
+ * column, from `from` to `to` at `pixels` columns, all at once, and is read from the points the source kept, carrying
+ * what each thinned pixel held. What a thinned point cannot stand for — a surface, a labels axis, a series that is not
+ * a line from `x` and `y` — is refused by path before any source is asked, and so is a reading whose answers for one
+ * Data Handle name different versions of its data: one chart is never drawn from two moments (spine rule 6). The
+ * counterpart of C#'s `ChartSpec.ReadAsync`.
+ */
+export declare function readChartSpecThrough(text: string, sources: (handle: string) => ChartSource | undefined, pixels: number, options?: {
+    readonly from?: number | null;
+    readonly to?: number | null;
+    readonly signal?: AbortSignal;
+}): Promise<ChartSourceReading>;
+
+/**
+ * What the tooltip says at `position` in panel `panel` of `scene`, built from `definition` at `metrics`.
+ * Past what fits the plot's height, the series nearest `pointerY` are listed and the rest counted. The
+ * view is the scene's own: what it hides and the range it shows are already laid out in it.
+ */
+export declare function readingAt(definition: ChartDefinition, scene: ChartScene, metrics: ChartMetrics, position: number, panel: number, pointerY: number): ChartReading;
+
+/** One series' line in the tooltip (ADR-0270). */
+export declare interface ReadingLine {
+    /** The series' identity. */
+    readonly id: string;
+    /** Its name. */
+    readonly name: string;
+    /** Its look, for the swatch. */
+    readonly look: SeriesLook;
+    /** Its value at the position, written through the series' format; `null` when it has none there. */
+    readonly value: string | null;
+    /** What the value is: a step's interval, a thinned pixel's count, interpolated or extrapolated, or why there is no value. */
+    readonly note: string | null;
+    /** The value's height in pixels, which the nearest lines are chosen by; `null` when it has none there. */
+    readonly y: number | null;
+}
+
+/**
+ * What the tooltip says over an edge (ADR-0321): its two keys. An edge has no value of its own, and nothing
+ * about it is read from its nodes.
+ */
+export declare function readingOfEdge(definition: ChartDefinition, scene: ChartScene, edge: number): ChartReading;
+
+/**
+ * What the tooltip says over an Observation's mark (ADR-0290): the point's name, or its position across,
+ * then the series with the point's x and y, and how many points the mark stands for when markers on one
+ * device pixel were merged — never one of them as if it were the only one.
+ */
+export declare function readingOfMark(definition: ChartDefinition, scene: ChartScene, mark: number): ChartReading;
+
+/** A row, by its Row Key, across columns at declared positions (series in rows). */
+export declare interface RowSeries {
+    /** Says the series is a row. */
+    readonly type: 'row';
+    /** The series' identity in the Chart Definition: the row's key and its Header Group. */
+    readonly id: string;
+    /** The panel it was given when it was made. */
+    readonly panel: string;
+    /** The row's Row Key (ADR-0140). */
+    readonly rowKey: RowKey;
+    /** The row's name when the chart was made, kept for the legend once the row is gone. */
+    readonly name: string;
+    /** The Header Group the columns stand under, or empty. */
+    readonly group: string;
+    /** The columns it is charted across, by name, in their positions' order. */
+    readonly columns: readonly string[];
+}
+
+/** What a scene is laid out with, beside the definition and the metrics. */
+export declare interface SceneOptions {
+    /** What the viewer narrowed the chart to; everything by default. */
+    readonly view?: ChartView;
+    /** How the horizontal axis is ticked and labelled. */
+    readonly style?: AxisStyle;
+    /** The panels whose left and right axes the Consumer declared independent (ADR-0251). */
+    readonly independentScales?: ReadonlySet<string> | readonly string[];
+    /** Where each panel's legend sits (ADR-0271); top, at the start, by default. */
+    readonly legend?: LegendPlacement;
+}
+
+/** A range of an Interpolated series and the method the Consumer used over it (ADR-0257). */
+export declare interface Segment {
+    /** Where the range starts. */
+    readonly from: number;
+    /** Where it ends. */
+    readonly to: number;
+    /** The method's name, as the tooltip and the Notes say it. */
+    readonly method: string;
+    /** Whether the range lies beyond the quotes. */
+    readonly extrapolated?: boolean;
+}
+
+/** A series' Interval (ADR-0303): bounds handed in by the Consumer, with what they mean. */
+export declare interface SeriesInterval {
+    /** What the interval is — "95% CI", "±1σ", "Bid–Ask"; required. */
+    readonly meaning: string;
+    /** The bounds at the series' positions. */
+    readonly bounds: readonly IntervalBound[];
+    /** Whiskers (the default) or a band. */
+    readonly style?: IntervalStyle;
+}
+
+/** What a series' numbers are, which decides how it is drawn (ADR-0253). Declared, never defaulted. */
+export declare type SeriesKind = 
+/** A quantity at an instant: points, joined only to their neighbours in the data. */
+'level'
+/** A rate constant over an interval: a step with a filled end where it takes the value and an open end where it does not. */
+| 'rateOverInterval'
+/** A total over its interval: a step whose height is the amount per year, from zero. */
+| 'amountPerPeriod'
+/** One thing measured on two quantities: a marker, never joined, its points neither ordered nor unique in x (ADR-0290). */
+| 'observation'
+/** One period's open, high, low and close, and optionally its volume: a candle (ADR-0300). */
+| 'priceRange';
+
+/** The look a series' Appearance Keys chose (ADR-0256): slot numbers the stylesheet's Visual Tokens say the look of. */
+export declare interface SeriesLook {
+    /** The colour slot, from 0. */
+    readonly colour: number;
+    /** The line-style slot, from 0 (solid). */
+    readonly lineStyle: number;
+    /** The marker slot, from 0 (a circle). */
+    readonly marker: number;
+    /** The marker's shape. */
+    readonly shape: MarkerShape;
+}
+
+/** One series as the scene draws it: everything its component needs (ADR-0252). */
+export declare interface SeriesPiece {
+    /** The series' identity. */
+    readonly id: string;
+    /** Its name. */
+    readonly name: string;
+    /** The keys its look is chosen by (ADR-0256). */
+    readonly keys: AppearanceKeys;
+    /** The look they chose. */
+    readonly look: SeriesLook;
+    /** Its Series Kind. */
+    readonly kind: SeriesKind;
+    /** Whether it is the Consumer's interpolation (ADR-0257). */
+    readonly interpolated: boolean;
+    /** Its lines in pixels, each unbroken. */
+    readonly lines: readonly (readonly DrawnPoint[])[];
+    /** Its markers in pixels. */
+    readonly markers: readonly DrawnMarker[];
+    /** Its extrapolated ranges in pixels, drawn distinctly. */
+    readonly extrapolated: readonly (readonly [from: number, to: number])[];
+    /** What each thinned pixel holds (ADR-0254). */
+    readonly thinned: readonly PixelSummary[];
+    /** A Price Range's candles in pixels (ADR-0300). */
+    readonly candles: readonly PlacedCandle[];
+    /** The period its candles stand for: a row each, or the market period they were merged into (ADR-0302). */
+    readonly period: CandlePeriod;
+    /** A volume panel's bars in pixels (ADR-0300). */
+    readonly volumes: readonly PlacedVolume[];
+    /** Its Interval's whiskers in pixels (ADR-0303). */
+    readonly whiskers: readonly DrawnWhisker[];
+    /** Its Interval's bands in pixels, each a run of neighbours. */
+    readonly bands: readonly (readonly DrawnWhisker[])[];
+    /** What its Interval means, or `null` when it has none. */
+    readonly intervalMeaning: string | null;
+    /** Whether its markers' colour bands diverge from a centre (ADR-0320, ADR-0310). */
+    readonly colourDiverging: boolean;
+    /** Its edges in pixels, cut to the plot, drawn under its nodes (ADR-0321). */
+    readonly edges: readonly DrawnEdge[];
+}
+
+/** A Consumer's curve as a function, asked at about one position per device pixel as it is drawn (ADR-0257). */
+export declare interface SeriesSampler {
+    /** The first position the function is asked at. */
+    readonly from: number;
+    /** The last. */
+    readonly to: number;
+    /** The Consumer's curve: the value at a position, or `null` where it has none. */
+    readonly valueAt: (position: number) => ChartValue | null;
+}
+
+/** A series the user hid or showed from the legend (ADR-0271, ADR-0272). */
+export declare interface SeriesVisibility {
+    /** The legend entry's key: the series' identity, which for quotes and their Interpolated curve is the quotes' and hides both (ADR-0257). */
+    readonly key: string;
+    /** Whether it is now hidden. */
+    readonly hidden: boolean;
+}
+
+/** A size key's entry: a value, its label, and the radius a marker of that value is drawn at. */
+export declare interface SizeEntry {
+    /** The value. */
+    readonly value: number;
+    /** Its label. */
+    readonly label: string;
+    /** The radius in CSS pixels. */
+    readonly radius: number;
+}
+
+/** The size key a series' size is read on (ADR-0320). */
+export declare interface SizeKey {
+    /** The series it belongs to. */
+    readonly seriesId: string;
+    /** What the sizes are. */
+    readonly title: string;
+    /** Its entries, smallest first. */
+    readonly entries: readonly SizeEntry[];
+    /** Its box in CSS pixels, under its title. */
+    readonly box: Box;
+}
+
+/** Which interval a step's point stands for: `preceding` is (tᵢ₋₁, tᵢ], `following` is [tᵢ, tᵢ₊₁). */
+export declare type StepSide = 'preceding' | 'following';
+
+/**
+ * One axis of a 3D surface (ADR-0274): its title and its values in order, each written through its
+ * format. A grid's lines are evenly spaced, one per value, unless its scale places them by value (ADR-0312).
+ */
+export declare class SurfaceAxis {
+    #private;
+    /** An axis of the given values, in the order the grid holds them; a code it cannot write them with is refused. */
+    constructor(options: SurfaceAxisOptions);
+    /** The axis' title. */
+    get title(): string;
+    /** The values, one per grid line, in order. */
+    get values(): readonly SurfaceValue[];
+    /** The Consumer's writer of a value, if any. */
+    get format(): ((value: SurfaceValue) => string) | undefined;
+    /** How the axis places its values (ADR-0312). */
+    get scale(): AxisScale;
+    /** The Excel format code its values and ticks are written by (ADR-0420), if any. */
+    get formatCode(): string | undefined;
+    /** Writes the value at `index` through the format or the code. */
+    write(index: number): string;
+    /** Writes `value` through the format or the code, or invariantly. */
+    writeValue(value: SurfaceValue): string;
+    /**
+     * Writes a position that need not be one of the values, such as a tick: through the code, through the
+     * format when the values are numbers, invariantly otherwise.
+     */
+    writeTick(position: number): string;
+    /** The index of `value` among the values, or -1. */
+    indexOf(value: SurfaceValue): number;
+    /**
+     * The value at `index` as a number; a value that is not one is a defect of the caller, which checked it.
+     *
+     * @internal
+     */
+    number(index: number): number;
+}
+
+/** One axis of a surface as a Consumer declares it (ADR-0274, ADR-0312). */
+export declare interface SurfaceAxisOptions {
+    /** The axis' title. */
+    readonly title: string;
+    /** The values, one per grid line, in order. */
+    readonly values: readonly SurfaceValue[];
+    /** Writes a value as the column it came from writes it; absent writes it invariantly. */
+    readonly format?: (value: SurfaceValue) => string;
+    /** How the axis places its values; `categories`, evenly spaced, by default (ADR-0312). */
+    readonly scale?: AxisScale;
+    /**
+     * An Excel number format code in the invariant spelling, such as `0.0%`, read by the family's `FormatCode`
+     * (ADR-0420): it writes the axis' values and its ticks between them, in place of a format. It writes numbers,
+     * so the axis' values are numbers.
+     */
+    readonly formatCode?: string;
+}
+
+/**
+ * How many colour bands a face is coloured from, low to high; each is a Visual Token, `--ex-chart-heat-0`
+ * on, or `--ex-chart-diverge-0` on when the colours diverge (ADR-0310).
+ */
+export declare const surfaceBandCount = 9;
+
+/** The colour bar beside a surface (ADR-0310). */
+export declare interface SurfaceColourBar {
+    /** The value at the foot of the lowest band, on the vertical scale. */
+    readonly from: number;
+    /** The value at the head of the highest band. */
+    readonly to: number;
+    /** The labelled values along it. */
+    readonly ticks: readonly SurfaceTick[];
+    /** Whether the bands diverge from a centre, which the middle band holds. */
+    readonly diverging: boolean;
+    /** How many bands it is drawn in: `surfaceBandCount`, handed to the entry so it holds no copy. */
+    readonly bands: number;
+}
+
+/**
+ * A 3D surface in the data's terms (ADR-0274): x values × y values × a table of z, one row per y value
+ * and one column per x value. A missing value is a hole, drawn as one: never 0 and never filled from its
+ * neighbours. Scattered points are refused by name (`fromPoints`). Interpolation is the Consumer's
+ * (ADR-0257): a surface may be handed in as a function, which ExChart samples (`sampled`), or as a grid
+ * whose interpolated values are marked. A Consumer's own triangle mesh is drawn as its triangles
+ * (`fromTriangles`, ADR-0311).
+ */
+export declare class SurfaceDefinition {
+    #private;
+    private constructor();
+    /** A surface of the given grid; refused with a `ChartRefusedError` when it cannot be drawn as asked. */
+    static grid(options: SurfaceGridOptions): SurfaceDefinition;
+    /**
+     * A surface from points, each at an x value and a y value. The points must lie on a grid: every x value
+     * they name must hold a value at two y values at least, and every y value at two x values, or the point
+     * stands alone and could join a surface only by interpolation (ADR-0257, ADR-0274). Where the grid has no
+     * point, it has a hole.
+     */
+    static fromPoints(options: SurfacePointsOptions): SurfaceDefinition;
+    /**
+     * A surface drawn on the Consumer's own triangle mesh (ADR-0311), each triangle flat through its three
+     * corners, never resampled onto a grid. A slice cuts the triangles exactly, reading between nodes
+     * linearly on them (`trianglesMethod`), which it says.
+     */
+    static fromTriangles(options: SurfaceTrianglesOptions): SurfaceDefinition;
+    /**
+     * A surface handed in as a function z(x, y), the Consumer's interpolation, which names its method
+     * (ADR-0257). ExChart samples it on a grid of `samples` values an axis across the rectangle — evenly in
+     * the axis' own scale, so geometrically on a logarithmic one (ADR-0312) — and draws a hole where it
+     * returns `null`. Every value is marked interpolated.
+     */
+    static sampled(options: SurfaceSampledOptions): SurfaceDefinition;
+    /** The x axis: the table's columns, or a mesh's x positions in order. */
+    get x(): SurfaceAxis;
+    /** The y axis: the table's rows, or a mesh's y positions in order. */
+    get y(): SurfaceAxis;
+    /** A grid's values, one row per y value, `null` at a hole; empty for a mesh. */
+    get z(): readonly (readonly (ChartValue | null)[])[];
+    /** What the values are, such as "Volatility". */
+    get zTitle(): string;
+    /** The Consumer's writer of a value, if any. */
+    get zFormat(): ((value: ChartValue) => string) | undefined;
+    /** The Excel format code the values are written by (ADR-0420), if any. */
+    get zFormatCode(): string | undefined;
+    /** The method the interpolated values were made with, if the surface claims one. */
+    get method(): string | undefined;
+    /** Which values are interpolated, in the table's shape; absent with a method marks every value. */
+    get interpolated(): readonly (readonly boolean[])[] | undefined;
+    /** The Consumer's Notes (ADR-0257). */
+    get notes(): readonly string[];
+    /** A mesh's nodes; absent for a grid (ADR-0311). */
+    get nodes(): readonly SurfaceNode[] | undefined;
+    /** A mesh's triangles; absent for a grid (ADR-0311). */
+    get triangles(): readonly SurfaceTriangle[] | undefined;
+    /** Whether the surface is a Consumer's triangle mesh rather than a grid (ADR-0311). */
+    get isMesh(): boolean;
+    /** The vertical scale asked for (ADR-0312). */
+    get zScale(): AxisScale;
+    /** The value the colours diverge from, if any (ADR-0310). */
+    get centre(): number | undefined;
+    /** The vertical scale as drawn: the one asked for, unless a value or the centre cannot lie on it. */
+    get effectiveZScale(): AxisScale;
+    /** The lines shown under the surface: the Consumer's Notes, the method (ADR-0257), and why a logarithmic scale stays proportional (ADR-0312). */
+    get allNotes(): readonly string[];
+    /** How many points the surface holds: a grid's points, row by row, or a mesh's nodes. */
+    get nodeCount(): number;
+    /** Whether a grid's value at x index `x` and y index `y` is interpolated; a mesh has no grid indices, and is refused. */
+    isInterpolated(x: number, y: number): boolean;
+    /** A grid's value at x index `x` and y index `y`, or `null` at a hole; a mesh has no grid indices, and is refused. */
+    at(x: number, y: number): ChartValue | null;
+    /** The point at `index`, counted as `nodeCount` counts: its x and y as the axes hold them, and its value, or `null`. */
+    node(index: number): readonly [x: SurfaceValue, y: SurfaceValue, z: ChartValue | null];
+    /** Whether the point at `index` is interpolated; a mesh's nodes are its values. */
+    isInterpolatedNode(index: number): boolean;
+    /**
+     * A tick on the vertical axis or the colour bar, and the centre the colours diverge from: through the code, as
+     * the values are, or plainly; a format, written for the values a column holds, leaves them plain (ADR-0420).
+     *
+     * @internal
+     */
+    writeZTick(value: number): string;
+    /** Writes a value through the format or the code, or invariantly. */
+    writeZ(value: ChartValue): string;
+    /**
+     * The values the surface holds, holes left out.
+     *
+     * @internal
+     */
+    present(): ChartValue[];
+    /**
+     * The slice as a 2D chart (ADR-0274): the values along the other axis, read exactly — as categories on
+     * an evenly spaced axis, as numbers on the axis' own scale otherwise (ADR-0312). A hole is a gap. A
+     * mesh's slice cuts its triangles and reads between nodes linearly on them, which it says (ADR-0311).
+     * `undefined` when the slice's value is not on this surface.
+     */
+    sliceChart(slice: SurfaceSlice): ChartDefinition | undefined;
+    /**
+     * A mesh cut at the slice's value (ADR-0311): the runs of positions along the other axis and the values
+     * there, linear on each triangle, broken where no triangle is. `undefined` when the value is not a number
+     * within the mesh's positions.
+     *
+     * @internal
+     */
+    cut(slice: SurfaceSlice): readonly (readonly {
+        readonly along: number;
+        readonly z: ChartValue;
+    }[])[] | undefined;
+}
+
+/** A face the 3D entry draws: its corners, as indices of the nodes, and its colour band. */
+export declare interface SurfaceFace {
+    /** Four corners for a grid's cell, three for a mesh's triangle. */
+    readonly corners: readonly number[];
+    /** Its colour band, 0 to `surfaceBandCount` - 1. */
+    readonly band: number;
+}
+
+/** A surface of a grid (ADR-0274): `z` holds one row per y value, each with one value per x value. */
+export declare interface SurfaceGridOptions extends SurfaceScaleOptions {
+    /** The x axis: the table's columns. */
+    readonly x: SurfaceAxisOptions;
+    /** The y axis: the table's rows. */
+    readonly y: SurfaceAxisOptions;
+    /** The values, one row per y value, `null` at a hole. */
+    readonly z: readonly (readonly (ChartValue | null)[])[];
+    /** What the values are; empty by default. */
+    readonly zTitle?: string;
+    /** Writes a value as its cell writes it. */
+    readonly zFormat?: (value: ChartValue) => string;
+    /** The method the interpolated values were made with, as the tooltip and the Notes say it (ADR-0257). */
+    readonly method?: string;
+    /** Which values are interpolated, in the table's shape; absent with a method marks every value. */
+    readonly interpolated?: readonly (readonly boolean[])[];
+    /** The Consumer's Notes, shown under the surface (ADR-0257). */
+    readonly notes?: readonly string[];
+}
+
+/** A 3D surface drawn into an element, handed back by {@link createSurface}. */
+export declare interface SurfaceHandle {
+    /** Takes the options again, whole: what did not change costs nothing. */
+    update(options: SurfaceOptions): void;
+    /** Stops the surface: it hears nothing more and empties its element. */
+    destroy(): void;
+    /**
+     * Saves the drawing as it stands as `svg`, or as `png` painted at the screen's Device Pixel (ADR-0282). One
+     * call is one save. False for `csv` — a surface's values are read in "View as table" — and once destroyed.
+     */
+    download(format: ChartFileFormat): Promise<boolean>;
+    /** The drawing as it stands as SVG text, its colours resolved; `undefined` once destroyed (ADR-0282). */
+    svgText(): string | undefined;
+}
+
+/** What the 3D entry is handed to draw a surface (ADR-0255). */
+export declare interface SurfaceMesh {
+    /** The x axis' title. */
+    readonly xTitle: string;
+    /** The y axis' title. */
+    readonly yTitle: string;
+    /** The values' title. */
+    readonly zTitle: string;
+    /** The points, counted as the definition's `nodeCount` counts them. */
+    readonly nodes: readonly SurfaceMeshNode[];
+    /** The faces to draw; a face with a hole at a corner is no face. */
+    readonly faces: readonly SurfaceFace[];
+    /** A grid's lines along x, one per y value, as node indices; empty for a mesh. */
+    readonly rows: readonly (readonly number[])[];
+    /** A grid's lines along y, one per x value, as node indices; empty for a mesh. */
+    readonly columns: readonly (readonly number[])[];
+    /** The floor's lines across x. */
+    readonly xLines: readonly SurfaceTick[];
+    /** The floor's lines along y. */
+    readonly yLines: readonly SurfaceTick[];
+    /** The bottom of the vertical scale. */
+    readonly zMin: number;
+    /** The top of the vertical scale. */
+    readonly zMax: number;
+    /** The vertical scale's ticks. */
+    readonly zTicks: readonly SurfaceTick[];
+    /** The colour bar. */
+    readonly bar: SurfaceColourBar;
+    /** How many points are holes. */
+    readonly holes: number;
+}
+
+/** The mesh of `definition`. */
+export declare function surfaceMesh(definition: SurfaceDefinition): SurfaceMesh;
+
+/** A point of a surface as the 3D entry places it. */
+export declare interface SurfaceMeshNode {
+    /** Its place across the floor, 0 to 1. */
+    readonly x: number;
+    /** Its place along the floor, 0 to 1. */
+    readonly y: number;
+    /** Its value on the vertical scale (its logarithm on a logarithmic one), or `null` at a hole. */
+    readonly z: number | null;
+    /** Whether its value is interpolated, so the entry draws it no dot (ADR-0257). */
+    readonly interpolated: boolean;
+}
+
+/** A point of a slice's line on the surface, placed as a mesh node is. */
+export declare interface SurfaceMeshPoint {
+    /** Its place across the floor, 0 to 1. */
+    readonly x: number;
+    /** Its place along the floor, 0 to 1. */
+    readonly y: number;
+    /** Its value on the vertical scale. */
+    readonly z: number;
+}
+
+/** A node of a Consumer's triangle mesh (ADR-0311): its place in the plane and its value, or `null`, a hole. */
+export declare interface SurfaceNode {
+    /** Its x position. */
+    readonly x: number;
+    /** Its y position. */
+    readonly y: number;
+    /** Its value, or `null`: no triangle at it is drawn. */
+    readonly z: ChartValue | null;
+}
+
+/** What a 3D surface is drawn from, and what it raises. */
+export declare interface SurfaceOptions {
+    /** The surface, in the data's terms. */
+    readonly definition: SurfaceDefinition;
+    /** Its width in CSS pixels: 640 when not given. Geometry is an option, never only a stylesheet value (ADR-0027). */
+    readonly width?: number;
+    /** Its height in CSS pixels, which the slice's chart beside it shares: 420 when not given. */
+    readonly height?: number;
+    /** The width of the slice's chart, in CSS pixels: 420 when not given. */
+    readonly sliceWidth?: number;
+    /** The density the font size is resolved from, as a grid's is (ADR-0028): `standard` when not given. */
+    readonly density?: GridDensity;
+    /** The surface's title, which opens its accessible summary. */
+    readonly title?: string;
+    /** A sentence the accessible summary ends with. */
+    readonly description?: string;
+    /** The view, taken back from `onViewChanged`; `null` or not given is the default view. */
+    readonly view?: SurfaceView | null;
+    /** Raised when the user ends a turn, a zoom or a pan, with the view it left (ADR-0272). */
+    readonly onViewChanged?: (view: SurfaceView) => void;
+    /** The slice drawn beside the surface, taken back from `onSliceChanged`; `null` or not given draws none. */
+    readonly slice?: SurfaceSlice | null;
+    /** Raised when the user clicks a tenor or a strike, with the slice it names (ADR-0274). */
+    readonly onSliceChanged?: (slice: SurfaceSlice) => void;
+    /** The name a saved file takes, without its extension; the title when not set, then `surface` (ADR-0282). */
+    readonly fileName?: string;
+    /** The Consumer's words for ExChart's own (ADR-0370 section 10); `japaneseChartWords` for Japanese. */
+    readonly label?: ChartLabel;
+}
+
+/** A point of a surface handed in as points, at an x value and a y value. */
+export declare interface SurfacePoint {
+    /** Its x value. */
+    readonly x: SurfaceValue;
+    /** Its y value. */
+    readonly y: SurfaceValue;
+    /** Its value. */
+    readonly z: ChartValue;
+}
+
+/** A surface from points on a grid (ADR-0274). */
+export declare interface SurfacePointsOptions extends SurfaceScaleOptions {
+    /** The points. */
+    readonly points: readonly SurfacePoint[];
+    /** The x axis' title. */
+    readonly xTitle: string;
+    /** The y axis' title. */
+    readonly yTitle: string;
+    /** What the values are. */
+    readonly zTitle?: string;
+    /** Writes an x value. */
+    readonly xFormat?: (value: SurfaceValue) => string;
+    /** Writes a y value. */
+    readonly yFormat?: (value: SurfaceValue) => string;
+    /** The x axis' Excel format code, in place of `xFormat` (ADR-0420). */
+    readonly xFormatCode?: string;
+    /** The y axis' Excel format code, in place of `yFormat`. */
+    readonly yFormatCode?: string;
+    /** Writes a value. */
+    readonly zFormat?: (value: ChartValue) => string;
+}
+
+/** A surface handed in as the Consumer's function z(x, y), which names its method (ADR-0257). */
+export declare interface SurfaceSampledOptions extends SurfaceScaleOptions {
+    /** The method the function interpolates with, as the tooltip and the Notes say it. */
+    readonly method: string;
+    /** The first x sampled. */
+    readonly xFrom: number;
+    /** The last. */
+    readonly xTo: number;
+    /** The first y sampled. */
+    readonly yFrom: number;
+    /** The last. */
+    readonly yTo: number;
+    /** The Consumer's surface: the value at (x, y), or `null` where it has none, outside its points. */
+    readonly z: (x: number, y: number) => ChartValue | null;
+    /** The x axis' title. */
+    readonly xTitle: string;
+    /** The y axis' title. */
+    readonly yTitle: string;
+    /** What the values are. */
+    readonly zTitle?: string;
+    /** How many values an axis is sampled at; 25 by default. */
+    readonly samples?: number;
+    /** Writes an x value. */
+    readonly xFormat?: (value: SurfaceValue) => string;
+    /** Writes a y value. */
+    readonly yFormat?: (value: SurfaceValue) => string;
+    /** The x axis' Excel format code, in place of `xFormat` (ADR-0420). */
+    readonly xFormatCode?: string;
+    /** The y axis' Excel format code, in place of `yFormat`. */
+    readonly yFormatCode?: string;
+    /** Writes a value. */
+    readonly zFormat?: (value: ChartValue) => string;
+    /** How x values are sampled and placed; `categories` by default. */
+    readonly xScale?: AxisScale;
+    /** How y values are sampled and placed. */
+    readonly yScale?: AxisScale;
+}
+
+/** How the values are scaled, coloured and written, which every form of surface may say (ADR-0310, ADR-0312, ADR-0420). */
+export declare interface SurfaceScaleOptions {
+    /**
+     * An Excel number format code in the invariant spelling, such as `0.00%`, read by the family's `FormatCode`
+     * (ADR-0420): it writes the values the surface holds and the ones a slice reads between them, in place of a
+     * `zFormat`.
+     */
+    readonly zFormatCode?: string;
+    /** The vertical scale: `proportional`, the default, or `logarithmic`; never `categories`. */
+    readonly zScale?: AxisScale;
+    /** The value the colours diverge from, such as 0 for a P&L (ADR-0310); absent colours low to high. */
+    readonly centre?: number;
+}
+
+/** A slice of a surface, named in the data's terms (ADR-0272, ADR-0274): the axis held fixed and its value there. */
+export declare interface SurfaceSlice {
+    /** The axis held fixed. */
+    readonly axis: SurfaceSliceAxis;
+    /** Its value, as the axis holds it. */
+    readonly value: SurfaceValue;
+}
+
+/** Which of a surface's two axes a slice holds fixed: `x` runs along y, `y` along x. */
+export declare type SurfaceSliceAxis = 'x' | 'y';
+
+/**
+ * The slice's line on the surface, placed as the mesh's points are, in runs broken at a hole: along a
+ * grid's line, or across a mesh's triangles where the slice cuts them (ADR-0311). Empty when the slice is
+ * not on this surface.
+ */
+export declare function surfaceSlicePath(definition: SurfaceDefinition, slice: SurfaceSlice): readonly (readonly SurfaceMeshPoint[])[];
+
+/**
+ * The surface said in words, for a screen reader (ADR-0275's shape): what it is of, its grid or its mesh,
+ * the range of its values, its holes, and how it is coloured and scaled; then the Consumer's description.
+ */
+export declare function surfaceSummary(definition: SurfaceDefinition, title?: string, description?: string): string;
+
+/** A labelled position on one of a surface's scales: its value there, and its label or `null` where labels would crowd. */
+export declare interface SurfaceTick {
+    /** A fraction of the floor for x and y; a value on the vertical scale for z and the colour bar. */
+    readonly value: number;
+    /** The label, or `null` for a line drawn unlabelled. */
+    readonly label: string | null;
+}
+
+/** A triangle of a Consumer's mesh (ADR-0311): the indices of its three nodes. */
+export declare interface SurfaceTriangle {
+    /** The first corner's index. */
+    readonly a: number;
+    /** The second corner's index. */
+    readonly b: number;
+    /** The third corner's index. */
+    readonly c: number;
+}
+
+/** A surface on the Consumer's own triangle mesh (ADR-0311). */
+export declare interface SurfaceTrianglesOptions extends SurfaceScaleOptions {
+    /** The nodes. */
+    readonly nodes: readonly SurfaceNode[];
+    /** The triangles. */
+    readonly triangles: readonly SurfaceTriangle[];
+    /** The x axis' title. */
+    readonly xTitle: string;
+    /** The y axis' title. */
+    readonly yTitle: string;
+    /** What the values are. */
+    readonly zTitle?: string;
+    /** Writes an x position. */
+    readonly xFormat?: (value: SurfaceValue) => string;
+    /** Writes a y position. */
+    readonly yFormat?: (value: SurfaceValue) => string;
+    /** The x axis' Excel format code, in place of `xFormat` (ADR-0420). */
+    readonly xFormatCode?: string;
+    /** The y axis' Excel format code, in place of `yFormat`. */
+    readonly yFormatCode?: string;
+    /** Writes a value. */
+    readonly zFormat?: (value: ChartValue) => string;
+    /** How x positions are placed: `proportional`, the default, or `logarithmic`. */
+    readonly xScale?: AxisScale;
+    /** How y positions are placed. */
+    readonly yScale?: AxisScale;
+    /** The Consumer's Notes. */
+    readonly notes?: readonly string[];
+}
+
+/** A value of a surface's axis: a strike, a delta or a tenor, as the column holds it. */
+export declare type SurfaceValue = string | number;
+
+/** How a surface is seen, in its own terms (ADR-0272): angles in degrees, the zoom, and the centre's offset as fractions. Never pixels. */
+export declare interface SurfaceView {
+    /** The turn about the vertical, in degrees. */
+    readonly yaw: number;
+    /** The tilt from level, in degrees, -90 to 90. */
+    readonly pitch: number;
+    /** The zoom, 1 fitting the surface to its box. */
+    readonly zoom: number;
+    /** The centre's horizontal offset, as a fraction of the width. */
+    readonly panX: number;
+    /** The centre's vertical offset, as a fraction of the height. */
+    readonly panY: number;
+}
+
+/** A tenor in years written as the market writes it: 6M, 18M, 1Y, 2.5Y. */
+export declare function tenor(years: number): string;
+
+/** The most points `fitTheilSen` takes: it weighs every pair, which past this is too many to run. */
+export declare const theilSenLimit = 3000;
+
+/**
+ * Thins `data` as `query` asks (ADR-0344): the range cut into `pixels` equal columns, each keeping its first, last,
+ * lowest and highest row (ADR-0254), never a row picked by LTTB; a row with no value kept where it is, so a gap stays a
+ * gap. Rows are answered in order across, a row's place in the data breaking a tie. A table without the query's
+ * columns, or a query of no pixels, of a range that is not finite or of a labels axis, is refused with a `TypeError`; a
+ * position that is not the axis' kind, or a value that is no number, with a {@link ChartSpecRefusedError}.
+ */
+export declare function thinChartData(data: ChartData, query: ChartSourceQuery, version?: bigint): ChartSourceAnswer;
+
+/** Where a horizontal axis puts its ticks. */
+export declare type TickPlacement = 
+/** The default for the axis: calendar boundaries for dates, round numbers for numbers, every category. */
+'auto'
+/** At calendar boundaries — years, quarters, months or days, the finest that fits. */
+| 'calendar'
+/** At every position some series has a point at. */
+| 'everyPoint'
+/** At the market's tenors counted from the first date: 1M, 3M, 6M, 1Y, 2Y, 3Y, 5Y, 7Y, 10Y … */
+| 'tenors'
+/** At the positions the axis names. */
+| 'named';
+
+/** The method a slice through a Consumer's triangles reads between its nodes with (ADR-0311). */
+export declare const trianglesMethod = "linear on the Consumer's triangles (P1)";
+
+/** The value that stands at height `y` on `plot`. */
+export declare function valueAt(axis: VerticalAxis, y: number, plot: Box): number;
+
+/** A vertical axis, laid out. */
+export declare interface VerticalAxis {
+    /** Which side it stands on. */
+    readonly side: AxisSide;
+    /** The value at the plot's foot. */
+    readonly min: number;
+    /** The value at its top. */
+    readonly max: number;
+    /** Its ticks. */
+    readonly ticks: readonly VerticalTick[];
+    /** Whether it does not reach zero, which a break mark at its foot says (ADR-0253). */
+    readonly broken: boolean;
+    /** Whether it is logarithmic, its `min` and `max` then both above zero (ADR-0290). */
+    readonly logarithmic: boolean;
+}
+
+/** A tick of a vertical axis: its value, its height in pixels, and its label. */
+export declare type VerticalTick = readonly [value: number, y: number, label: string];
+
+/** The height in pixels at which `value` stands on `plot`. */
+export declare function yOf(axis: VerticalAxis, value: number, plot: Box): number;
+
+export { }