@x12i/charts 1.0.0 → 1.1.0

package/dist/echarts-option-DHFfEvN1.d.ts

@@ -0,0 +1,1251 @@
+import { TokenPath, ThemeName } from '@x12i/tokens';
+
+/**
+ * ChartSpec: a JSON-serializable description of one chart (spec section 8).
+ * The grammar is deliberately smaller than Vega-Lite. Renderers read a spec and
+ * draw it with kit tokens, so an engine can change without breaking apps.
+ *
+ * Everything added after the first release is optional, so specs written
+ * against the first release stay valid.
+ */
+/** Chart types by family. Entries marked 1.x in the spec are included so specs written today stay valid. */
+declare const chartTypes: readonly ["bar", "lollipop", "dot-plot", "bullet", "slope", "dumbbell", "line", "area", "step", "sparkline", "range-band", "candlestick", "ohlc", "histogram", "box-plot", "density", "strip", "beeswarm", "violin", "ecdf", "donut", "pie", "treemap", "waterfall", "funnel", "waffle", "sunburst", "marimekko", "scatter", "bubble", "connected-scatter", "heatmap", "hexbin", "contour", "stat", "gauge", "progress-ring", "sankey", "chord", "alluvial", "choropleth", "point-map", "heat-layer", "flow-map", "gantt", "timeline", "burndown", "cumulative-flow", "calendar-heatmap", "combo"];
+type ChartType = (typeof chartTypes)[number];
+type FieldType = "category" | "number" | "time" | "boolean";
+/** One data row. Values are looked up by field name. */
+type Row = Record<string, unknown>;
+/** Where the rows come from: a named dataset resolved by the app, or inline values. */
+type ChartData = {
+    ref: string;
+} | {
+    values: ReadonlyArray<Record<string, unknown>>;
+};
+interface Encoding {
+    field: string;
+    type: FieldType;
+    /**
+     * A named format (`compact`, `percent`, `integer`, `decimal`, `currency:USD`,
+     * `date`, `datetime`, `time`, `month`, `year`), a d3-format specifier such as
+     * `,.2f`, or a d3-time-format pattern such as `%b %Y`.
+     */
+    format?: string;
+    /** Axis or legend title. Axis titles carry units. */
+    title?: string;
+}
+/** Transforms run in order before drawing. */
+type Transform = {
+    type: "aggregate";
+    groupBy: string[];
+    op: "sum" | "mean" | "min" | "max" | "count";
+    field?: string;
+    as: string;
+} | {
+    type: "bin";
+    field: string;
+    maxBins?: number;
+    as: string;
+} | {
+    type: "stack";
+    field: string;
+    groupBy?: string[];
+    offset?: "zero" | "normalize";
+} | {
+    type: "percent-of-total";
+    field: string;
+    as: string;
+} | {
+    type: "sort";
+    field: string;
+    order?: "asc" | "desc";
+} | {
+    type: "top-n";
+    field: string;
+    n: number;
+    otherLabel?: string;
+} | {
+    type: "rolling-average";
+    field: string;
+    window: number;
+    as: string;
+} | {
+    type: "cumulative-sum";
+    field: string;
+    as: string;
+} | {
+    type: "period-change";
+    field: string;
+    periods?: number;
+    as: string;
+} | {
+    type: "downsample";
+    method: "lttb";
+    field: string;
+    threshold: number;
+};
+/** Meaning of a labeled mark. Status tones use muted status colors and a label, never color alone. */
+type AnnotationTone = "neutral" | "good" | "warning" | "critical";
+/** Targets, limits and forecasts are always labeled marks, never unlabeled lines. */
+type Annotation = {
+    type: "reference-line";
+    x?: number | string;
+    y?: number | string;
+    label: string;
+    tone?: AnnotationTone;
+    axis?: "y" | "y2";
+} | {
+    type: "reference-band";
+    from: number | string;
+    to: number | string;
+    axis: "x" | "y";
+    label: string;
+    tone?: AnnotationTone;
+} | {
+    type: "text";
+    x: number | string;
+    y: number | string;
+    text: string;
+} | {
+    type: "forecast";
+    from: number | string;
+    label: string;
+}
+/** A labeled point on the plot, for example a peak or an incident. */
+ | {
+    type: "point";
+    x: number | string;
+    y: number | string;
+    label: string;
+    tone?: AnnotationTone;
+};
+interface ChartInteractions {
+    tooltip?: boolean;
+    /** Brush to filter other charts and grids through the shared filter store. */
+    brush?: boolean;
+    /** Click a legend entry to isolate a series. */
+    legendIsolate?: boolean;
+    zoom?: boolean;
+    /** Click to drill down through the shared filter store. */
+    drilldown?: boolean;
+}
+/** Accessibility fields. Every chart has an accessible name, a description and a table view. */
+interface ChartA11y {
+    /** The long description read to screen reader users. */
+    description: string;
+    /** Show the underlying data as a table behind a "View as table" toggle. Defaults to true. */
+    table?: boolean;
+}
+type RendererChoice = "svg" | "canvas" | "auto";
+/**
+ * - `linear`, `log`, `sqrt`: quantitative.
+ * - `time`: a UTC time axis.
+ * - `band`: one slot per category, for bars.
+ * - `ordinal`: one position per category, for lines and points.
+ */
+type ScaleType = "linear" | "log" | "sqrt" | "time" | "band" | "ordinal";
+interface ScaleSpec {
+    type?: ScaleType;
+    /**
+     * Quantitative and time scales: `[min, max]` (time values are ISO strings or
+     * epoch milliseconds). Band and ordinal scales: the category order.
+     */
+    domain?: ReadonlyArray<number | string>;
+    /** Round the domain to nice values. Defaults to true for quantitative scales. */
+    nice?: boolean;
+    /** Force zero into a quantitative domain. Bars always include zero. */
+    zero?: boolean;
+    /** Log base. Defaults to 10. */
+    base?: number;
+    /** Flip the direction of the scale. */
+    reverse?: boolean;
+    /** Fraction of a band left empty between bands, from 0 to 0.9. */
+    padding?: number;
+}
+/** `stacked` adds up, `normalized` shows shares of 100%, `diverging` stacks negatives below zero. */
+type StackMode = "none" | "stacked" | "normalized" | "diverging";
+interface AxisSpec {
+    /** Hide the axis entirely. */
+    show?: boolean;
+    title?: string;
+    /** Draw gridlines for this axis. Defaults to true for the value axis only. */
+    grid?: boolean;
+    /** Approximate tick count; the scale picks nice values near it. */
+    ticks?: number;
+    /** Explicit tick values, which override `ticks`. */
+    tickValues?: ReadonlyArray<number | string>;
+    format?: string;
+    /** Label angle in degrees, or `auto` to rotate only when labels do not fit. */
+    labelAngle?: number | "auto";
+    /** Longest tick label in characters before it is shortened with an ellipsis. */
+    maxLabelLength?: number;
+}
+type MarkerShape = "circle" | "square" | "diamond" | "triangle" | "triangle-down" | "cross" | "plus";
+type DashStyle = "solid" | "dashed" | "dotted" | "dash-dot";
+/** Named series colors. Everything resolves to a kit token at render time. */
+type SeriesTone = "accent" | "muted" | "reference" | "good" | "warning" | "critical" | "categorical-1" | "categorical-2" | "categorical-3" | "categorical-4" | "categorical-5" | "categorical-6" | "categorical-7" | "categorical-8";
+/** Marks a single series can draw in a combo chart. */
+type SeriesMark = "bar" | "line" | "area" | "step" | "scatter";
+interface SeriesPoint {
+    /** Category label, number, epoch milliseconds, or an ISO date string. */
+    x: string | number;
+    y: number | null;
+    /** Bubble size. */
+    size?: number;
+    /** Overrides the x label in tooltips, tables and announcements. */
+    label?: string;
+}
+interface SeriesSpec {
+    /** Stable identifier used by legend toggles and callbacks. */
+    id: string;
+    /** Display name. Defaults to the id. */
+    label?: string;
+    /** In a combo chart, which mark this series draws. Defaults to `bar`. */
+    mark?: SeriesMark;
+    /** Wide format: read this column of the shared rows as the y value. */
+    field?: string;
+    /** Own points, instead of reading shared rows. */
+    points?: ReadonlyArray<SeriesPoint>;
+    /** Which value axis the series uses. `y2` needs `dualAxis: true`. */
+    axis?: "y" | "y2";
+    tone?: SeriesTone;
+    /** Point marker shape. Defaults to a different shape per series. */
+    marker?: MarkerShape;
+    /** Line dash pattern. Defaults to a different pattern per series. */
+    dash?: DashStyle;
+    /** Series with the same stack key stack together. */
+    stack?: string;
+    /** Start hidden. The legend can show it. */
+    hidden?: boolean;
+    /** Number format for this series in tooltips and tables. */
+    format?: string;
+}
+interface LegendSpec {
+    /** `auto` shows the legend when there is more than one series (or more than one slice). */
+    show?: boolean | "auto";
+    position?: "top" | "bottom";
+}
+/** A labeled limit or target. Breaching points get an extra mark and tooltip note, not only a color. */
+interface Threshold {
+    value: number | string;
+    label: string;
+    axis?: "x" | "y" | "y2";
+    tone?: AnnotationTone;
+    /** `above` flags values over the threshold, `below` flags values under it. */
+    breach?: "above" | "below";
+}
+interface GaugeSpec {
+    /** A literal value. Without it, the first row of the `value` (or `y`) encoding is used. */
+    value?: number;
+    min?: number;
+    max?: number;
+    target?: number;
+    /** Ranges behind the value arc, for example good, warning and critical. */
+    bands?: ReadonlyArray<{
+        from: number;
+        to: number;
+        tone: AnnotationTone;
+        label?: string;
+    }>;
+    /**
+     * Number format for the value, minimum, maximum and target. `percent` shows
+     * the share of the min to max range: 64 of 100 and 0.64 of 1 both read 64%.
+     * When `max` is omitted, a percent gauge with a value from 0 to 1 ends at 1.
+     */
+    format?: string;
+}
+interface DonutSpec {
+    /** Inner radius as a fraction of the outer radius, from 0 to 0.9. Defaults to 0.62 for `donut`, 0 for `pie`. */
+    innerRadius?: number;
+    /** Slices beyond this count merge into "Other". Defaults to 5, the spec's donut limit. */
+    maxSlices?: number;
+    /** Center label. Defaults to the total of all slices. */
+    centerLabel?: string;
+    /** Caption under the center value. */
+    centerCaption?: string;
+}
+interface WaterfallSpec {
+    /** Categories (x values) that are totals: their bars run from zero to the running sum. */
+    totals?: ReadonlyArray<string>;
+}
+interface ChartLabels {
+    /** Label line and area series at their last point instead of relying on the legend. `auto` does so for 2 to 5 series. */
+    direct?: boolean | "auto";
+    /** Print values on bars and slices. */
+    values?: boolean;
+}
+interface BinSpec {
+    /** Approximate number of bins. */
+    count?: number;
+    /** Explicit bin boundaries. */
+    thresholds?: ReadonlyArray<number>;
+}
+interface ChartSpec {
+    /** Schema version, so saved specs can be migrated. */
+    version?: 1;
+    /** The finding: a sentence that states what the chart shows. */
+    title: string;
+    /** Scope and units. */
+    subtitle?: string;
+    /** Where the data came from. Required in reports. */
+    source?: string;
+    data: ChartData;
+    mark: ChartType;
+    x?: Encoding;
+    y?: Encoding;
+    /** Series that differ in kind use the categorical palette, capped at 8 hues. */
+    color?: Encoding;
+    size?: Encoding;
+    /** The measure for heatmaps and gauges. Heatmaps fall back to `color`. */
+    value?: Encoding;
+    /** One accent on what the title is about, for example `week == 'W4'`. */
+    highlight?: {
+        where: string;
+    };
+    transforms?: Transform[];
+    annotations?: Annotation[];
+    interactions?: ChartInteractions;
+    /** Dual axes only behind an explicit flag, which adds a visible warning. */
+    dualAxis?: boolean;
+    renderer?: RendererChoice;
+    /** Whether axes mirror in right-to-left locales. */
+    direction?: "ltr" | "rtl" | "auto";
+    a11y: ChartA11y;
+    /** Explicit series. Without them, series come from `y`, or from the groups of `color`. */
+    series?: SeriesSpec[];
+    /** How series combine on one axis. Defaults to `none` (grouped bars, overlapping lines). */
+    stack?: StackMode;
+    /** `horizontal` bars put the categories on the vertical axis. */
+    orientation?: "vertical" | "horizontal";
+    scales?: {
+        x?: ScaleSpec;
+        y?: ScaleSpec;
+        y2?: ScaleSpec;
+    };
+    axes?: {
+        x?: AxisSpec;
+        y?: AxisSpec;
+        y2?: AxisSpec;
+    };
+    thresholds?: Threshold[];
+    legend?: LegendSpec;
+    labels?: ChartLabels;
+    /** Histogram bins. */
+    bins?: BinSpec;
+    gauge?: GaugeSpec;
+    donut?: DonutSpec;
+    waterfall?: WaterfallSpec;
+    /** IANA time zone used to format time values. Time axes are laid out in UTC. Defaults to `UTC`. */
+    timeZone?: string;
+}
+/** Identity helper that gives authoring-time type checking and autocomplete. */
+declare function defineChartSpec(spec: ChartSpec): ChartSpec;
+
+type Datasets = Readonly<Record<string, ReadonlyArray<Row>>>;
+/** Rows for a spec: inline values, or the named dataset from `datasets`. `undefined` when a `ref` is not provided. */
+declare function resolveRows(spec: ChartSpec, datasets?: Datasets): ReadonlyArray<Row> | undefined;
+/** Total number of data points a spec would draw, for choosing a renderer. */
+declare function countPoints(spec: ChartSpec, datasets?: Datasets): number;
+/** Reads a field, allowing dotted paths into nested objects. */
+declare function readField(row: Row, field: string): unknown;
+/** A finite number, or `null`. Numeric strings are accepted; booleans and blanks are not. */
+declare function toNumber(value: unknown): number | null;
+/**
+ * Epoch milliseconds from a Date, a number (already milliseconds), or a date
+ * string. Date-only strings and strings with an offset parse as written;
+ * strings without an offset are read as UTC so output does not depend on the
+ * machine's time zone.
+ */
+declare function toTime(value: unknown): number | null;
+/** Display key for a category value. Booleans and numbers become strings; blanks become an empty string. */
+declare function toCategory(value: unknown): string;
+interface TransformContext {
+    /** Field that names categories (the x field), used by `top-n` and `downsample`. */
+    categoryField?: string | undefined;
+    /** Field that splits rows into series (the color field); window transforms run per group. */
+    groupField?: string | undefined;
+    /** Whether x holds times or numbers (for sorting and downsampling). */
+    xKind?: "category" | "number" | "time" | undefined;
+    /** Label for the merged "Other" row of `top-n`. */
+    otherLabel?: string | undefined;
+}
+/** Runs transforms in order. Unknown or invalid parameters leave the rows unchanged. */
+declare function applyTransforms(rows: ReadonlyArray<Row>, transforms: ReadonlyArray<Transform> | undefined, context?: TransformContext): Row[];
+/** The stack mode a spec asks for: `spec.stack`, else implied by a `stack` transform, else `none`. */
+declare function effectiveStack(spec: ChartSpec): StackMode;
+
+/**
+ * The SVG renderer is comfortable up to roughly this many points per chart
+ * (spec section 8: about 1,000 to 5,000). Beyond it, auto mode uses canvas.
+ */
+declare const SVG_POINT_LIMIT = 5000;
+type RenderTarget = "screen" | "print" | "report";
+interface ResolveRendererInput {
+    renderer?: RendererChoice;
+    mark: ChartType;
+    pointCount: number;
+    target?: RenderTarget;
+}
+/**
+ * Picks a renderer for a chart. Reports and print always use SVG so the output
+ * stays vector; on screen, `auto` switches to canvas by point count and type.
+ */
+declare function resolveRenderer({ renderer, mark, pointCount, target, }: ResolveRendererInput): "svg" | "canvas";
+
+interface HistogramBin {
+    /** Inclusive lower edge. */
+    x0: number;
+    /** Exclusive upper edge (inclusive for the last bin). */
+    x1: number;
+    count: number;
+}
+interface HistogramOptions {
+    /** Approximate number of bins; boundaries land on nice values. */
+    count?: number;
+    /** Explicit boundaries, which override `count`. */
+    thresholds?: ReadonlyArray<number>;
+    /** Fixed range. Defaults to the data extent. */
+    domain?: readonly [number, number];
+}
+/**
+ * Bins numbers for a histogram. Non-finite values are ignored. Boundaries come
+ * from d3-array: nice values near the requested count, or the explicit list.
+ * Returns `[]` for empty input.
+ */
+declare function histogramBins(values: ReadonlyArray<number | null | undefined>, options?: HistogramOptions): HistogramBin[];
+
+interface ChartMessages {
+    loading: string;
+    empty: string;
+    error: string;
+    retry: string;
+    /** `{mark}` is the chart type name. */
+    unsupportedMark: string;
+    /** `{ref}` is the dataset name. */
+    missingDataset: string;
+    invalidSpec: string;
+    /** Shown when `echarts` cannot be loaded and the chart falls back to SVG. */
+    canvasMissing: string;
+    /** Shown when `echarts` loads but cannot draw this chart (for example a waterfall that crosses zero). */
+    canvasUnsupported: string;
+    canvasLoading: string;
+    allSeriesHidden: string;
+    /** Role description of the interactive plot, for example "chart". */
+    chartRoleDescription: string;
+    /** Accessible name. `{title}` and `{type}` (lower case, such as "bar chart"). */
+    chartName: string;
+    legend: string;
+    viewAsTable: string;
+    viewAsChart: string;
+    downloadCsv: string;
+    toolbar: string;
+    /** `{title}` is the chart title. */
+    tableCaption: string;
+    /** `{shown}` and `{total}` are row counts. */
+    tableTruncated: string;
+    dualAxisWarning: string;
+    other: string;
+    total: string;
+    noValue: string;
+    /** Waterfall legend keys. */
+    increase: string;
+    decrease: string;
+    axisX: string;
+    axisY: string;
+    axisY2: string;
+    /** `{axis}` and `{title}`. */
+    axisWithTitle: string;
+    columnSeries: string;
+    columnX: string;
+    columnY: string;
+    columnSize: string;
+    columnValue: string;
+    columnShare: string;
+    columnFrom: string;
+    columnTo: string;
+    columnCount: string;
+    columnChange: string;
+    columnRunningTotal: string;
+    columnMetric: string;
+    columnMinimum: string;
+    columnMaximum: string;
+    columnTarget: string;
+    columnCategory: string;
+    columnRow: string;
+    describeSummary: string;
+    describeCategories: string;
+    describeRange: string;
+    describeSeries: string;
+    trendRising: string;
+    trendFalling: string;
+    trendFlat: string;
+    trendRisingChange: string;
+    trendFallingChange: string;
+    describeSlices: string;
+    describeLargestSlice: string;
+    describeGauge: string;
+    describeGaugeTarget: string;
+    describeHeatmap: string;
+    describeHistogram: string;
+    describeThreshold: string;
+    describeBreaches: string;
+    describeHiddenSeries: string;
+    /** Pie and donut: `{type}`, `{count}`. */
+    describePieSummary: string;
+    /** `{start}`, `{end}`. */
+    describeWaterfall: string;
+    /** `{label}`, `{value}`. */
+    describeWaterfallUp: string;
+    describeWaterfallDown: string;
+    /** `{r}`: the correlation coefficient. */
+    describeCorrelationPositive: string;
+    describeCorrelationNegative: string;
+    describeCorrelationNone: string;
+    pointCategory: string;
+    pointSingle: string;
+    pointSlice: string;
+    pointXY: string;
+    pointBubble: string;
+    pointCell: string;
+    pointBin: string;
+    pointWaterfall: string;
+    pointWaterfallTotal: string;
+    /** `{text}`, `{index}`, `{count}`. */
+    pointPosition: string;
+    breachAbove: string;
+    breachBelow: string;
+    /** Text under a gauge value. `{min}` and `{max}`. */
+    gaugeRange: string;
+    /** Lower-case name of each chart type, for names and descriptions. */
+    markNames: Record<ChartType, string>;
+}
+type ChartMessagesInput = Partial<Omit<ChartMessages, "markNames">> & {
+    markNames?: Partial<Record<ChartType, string>>;
+};
+declare const defaultMessages: ChartMessages;
+/** Merges partial messages over the English defaults. */
+declare function resolveMessages(input?: ChartMessagesInput | undefined): ChartMessages;
+/**
+ * Fills an ICU-subset template. Unknown arguments render as empty text.
+ * Numbers passed as `number` are used for plural rules; pass already formatted
+ * text as `string` for display.
+ */
+declare function formatMessage(template: string, values?: Record<string, string | number | undefined>, locale?: string): string;
+
+/**
+ * Series styling: which tone, marker shape and dash pattern each series gets.
+ * Colors are never constants here; tones map to `--kit-*` variables, so charts
+ * theme through CSS (light, dark, high contrast) without any JavaScript.
+ *
+ * Color is never the only channel: every series also gets its own marker
+ * shape and dash pattern, so series stay distinguishable in grayscale and for
+ * color-blind readers.
+ */
+
+/** The categorical palette has eight hues; further series reuse them with new shapes and dashes. */
+declare const MAX_HUES = 8;
+declare const markerShapes: ReadonlyArray<MarkerShape>;
+declare const dashStyles: ReadonlyArray<DashStyle>;
+/** SVG `stroke-dasharray` for each dash style (undefined means a solid line). */
+declare const dashArrays: Readonly<Record<DashStyle, string | undefined>>;
+declare const categoricalTones: ReadonlyArray<SeriesTone>;
+interface SeriesStyle {
+    /** Position in the series list, for hatch patterns and `data-series`. */
+    index: number;
+    tone: SeriesTone;
+    marker: MarkerShape;
+    dash: DashStyle;
+}
+/**
+ * The style of series `index` out of `count`. A lone series uses the accent
+ * ("grey first, one accent"); several series use the categorical palette.
+ * Explicit `tone`, `marker` and `dash` on the series win.
+ */
+declare function seriesStyle(index: number, count: number, series?: Pick<SeriesSpec, "tone" | "marker" | "dash">): SeriesStyle;
+/** Token path for a tone, such as `color.chart.categorical.3` or `color.accent.default`. */
+declare function toneTokenPath(tone: SeriesTone): TokenPath;
+/** `var(--kit-color-chart-categorical-3)` and friends. */
+declare function toneCssVar(tone: SeriesTone): string;
+/** The bare custom property name (`--kit-color-chart-good`), for runtime lookups. */
+declare function toneVarName(tone: SeriesTone): string;
+/** Maps an annotation tone to a series tone. Neutral annotations are grey reference marks. */
+declare function annotationTone(tone: AnnotationTone | undefined): SeriesTone;
+/** CSS color for a value `t` (0 to 1) along the sequential ramp, interpolated between ramp steps. */
+declare function sequentialColor(t: number): string;
+/** CSS color for `t` (0 to 1) along the diverging ramp; 0.5 is the neutral midpoint. */
+declare function divergingColor(t: number): string;
+/** CSS gradient covering a whole ramp, for color scale legends. */
+declare function rampGradient(kind: "sequential" | "diverging"): string;
+/** Marker shapes drawn as open strokes (an X and a plus) instead of filled areas. */
+declare function isOpenMarker(shape: MarkerShape): boolean;
+/**
+ * SVG path data for a marker centered on (cx, cy) with "radius" r. All shapes
+ * are paths so one element type renders every series marker.
+ */
+declare function markerPath(shape: MarkerShape, cx: number, cy: number, r: number): string;
+
+/**
+ * Turns a `ChartSpec` plus rows into a `ChartModel`: typed series and points,
+ * categories, slices, bins and gauge values. Pure and server-safe. Everything
+ * downstream (layout, descriptions, tables, the canvas mapping) reads the model.
+ */
+
+type XKind = "category" | "number" | "time";
+/** Chart types the SVG renderer draws. */
+declare const supportedMarks: ReadonlyArray<ChartType>;
+declare function isSupportedMark(mark: ChartType): boolean;
+interface ModelPoint {
+    /** Position within the series. */
+    index: number;
+    /** Position of this point's x among the model's categories. */
+    categoryIndex: number;
+    /** Stable key for x: the category text, or the number or timestamp as text. */
+    key: string;
+    /** The x value: a category label, a number, or epoch milliseconds. */
+    x: string | number;
+    /** Upper edge of a histogram bin. */
+    x1?: number;
+    /** Row category of a heatmap cell. */
+    group?: string;
+    y: number | null;
+    size: number | null;
+    /** Label from the data, which replaces the formatted x in tooltips and tables. */
+    label?: string;
+    row: Row;
+    highlighted: boolean;
+}
+interface ModelSeries {
+    id: string;
+    label: string;
+    mark: SeriesMark;
+    axis: "y" | "y2";
+    style: SeriesStyle;
+    stackKey: string;
+    format?: string;
+    /** Starts hidden. */
+    hidden: boolean;
+    points: ModelPoint[];
+}
+interface ModelSlice {
+    id: string;
+    label: string;
+    value: number;
+    /** Fraction of the total, 0 to 1. */
+    share: number;
+    style: SeriesStyle;
+    highlighted: boolean;
+    /** True for the merged "Other" slice. */
+    other?: boolean;
+    row: Row | null;
+}
+interface ModelGauge {
+    value: number;
+    min: number;
+    max: number;
+    target: number | undefined;
+    bands: ReadonlyArray<{
+        from: number;
+        to: number;
+        tone: AnnotationTone;
+        label?: string | undefined;
+    }>;
+    format: string | undefined;
+}
+interface WaterfallStep {
+    key: string;
+    label: string;
+    delta: number;
+    start: number;
+    end: number;
+    total: boolean;
+}
+type ModelStatus = "ok" | "empty" | "missing-data" | "unsupported";
+interface ChartModel {
+    spec: ChartSpec;
+    mark: ChartType;
+    status: ModelStatus;
+    /** The dataset name that was not provided, when `status` is `missing-data`. */
+    missingRef?: string;
+    xKind: XKind;
+    /** Ordered union of x values across series, as keys. */
+    categories: string[];
+    /** Raw x value for each category key. */
+    categoryValues: Array<string | number>;
+    series: ModelSeries[];
+    /** Pie and donut slices; empty for other types. */
+    slices: ModelSlice[];
+    heatmap?: {
+        columns: string[];
+        rows: string[];
+        min: number;
+        max: number;
+    };
+    histogram?: {
+        bins: HistogramBin[];
+    };
+    gauge?: ModelGauge;
+    waterfall?: {
+        steps: WaterfallStep[];
+    };
+    stack: StackMode;
+    orientation: "vertical" | "horizontal";
+    /** True when the plot has a second value axis. */
+    dualAxis: boolean;
+    pointCount: number;
+    /** Rows dropped because x or y could not be read. */
+    droppedPoints: number;
+    xTitle: string | undefined;
+    yTitle: string | undefined;
+    y2Title: string | undefined;
+    timeZone: string;
+    /** True when time values carry a time of day. */
+    hasTimeOfDay: boolean;
+    hasHighlight: boolean;
+}
+interface BuildModelOptions {
+    datasets?: Datasets | undefined;
+    messages?: ChartMessagesInput | undefined;
+}
+/** True for chart types whose x axis has one slot per category. */
+declare function usesBandX(mark: ChartType): boolean;
+declare function buildChartModel(spec: ChartSpec, options?: BuildModelOptions): ChartModel;
+
+/** Type size the layout assumes for axis text. It matches the caption token (12). */
+declare const AXIS_FONT_SIZE = 12;
+/** Length of a tick mark. */
+declare const TICK_SIZE = 6;
+/** Gap between a tick mark and its label. */
+declare const TICK_PADDING = 4;
+type ContinuousKind = "linear" | "log" | "sqrt" | "time";
+interface ContinuousScale {
+    kind: ContinuousKind;
+    /** The final domain, after nice rounding. Time domains are epoch milliseconds. */
+    domain: [number, number];
+    range: [number, number];
+    (value: number): number;
+    /** About `count` tick values inside the domain. */
+    ticks(count: number): number[];
+}
+interface ContinuousScaleOptions {
+    kind: ContinuousKind;
+    domain: readonly [number, number];
+    range: readonly [number, number];
+    nice?: boolean;
+    /** Tick count that `nice` rounds towards. */
+    niceCount?: number;
+    base?: number;
+}
+/** A linear, log, square-root or UTC time scale as a plain function with a domain and ticks. */
+declare function createContinuousScale({ kind, domain, range, nice, niceCount, base, }: ContinuousScaleOptions): ContinuousScale;
+interface DomainOptions {
+    kind?: ContinuousKind | undefined;
+    /** Include zero (bars, areas and histograms always do). */
+    includeZero?: boolean | undefined;
+    /** Extra values the domain must cover, such as thresholds and reference lines. */
+    include?: ReadonlyArray<number> | undefined;
+    spec?: ScaleSpec | undefined;
+}
+/**
+ * Picks a numeric domain from data. An explicit `scale.domain` wins. Otherwise
+ * the domain covers the data (plus `include` and zero when asked), is widened
+ * when it would be a single value, and for log scales stays positive.
+ */
+declare function valueDomain(data: readonly [number, number] | null, { kind, includeZero, include, spec }?: DomainOptions): [number, number];
+interface BandScale {
+    (key: string): number | undefined;
+    bandwidth: number;
+    step: number;
+    domain: string[];
+    range: [number, number];
+}
+/** One slot per key. `padding` is the fraction of each step left empty (inner), with half of it outside. */
+declare function createBandScale(keys: ReadonlyArray<string>, range: readonly [number, number], padding?: number): BandScale;
+interface PointScale {
+    (key: string): number | undefined;
+    step: number;
+    domain: string[];
+}
+/** One position per key, with half a step of padding at each end. */
+declare function createPointScale(keys: ReadonlyArray<string>, range: readonly [number, number]): PointScale;
+/** Nice tick values for a numeric domain. */
+declare function niceTicks(domain: readonly [number, number], count?: number): number[];
+/** Rough width of text in pixels, from per-character class widths. Good enough to reserve margins and fit labels. */
+declare function estimateTextWidth(text: string, fontSize?: number): number;
+/** Shortens text to `maxLength` characters with an ellipsis. */
+declare function truncateLabel(text: string, maxLength: number): string;
+interface FittedLabel {
+    text: string;
+    /** The untruncated text, for titles and tooltips. */
+    full: string;
+    /** False when the label is skipped to avoid overlap. */
+    visible: boolean;
+}
+interface LabelFit {
+    labels: FittedLabel[];
+    /** Rotation in degrees (0, or negative in left-to-right layouts). */
+    angle: number;
+    anchor: "start" | "middle" | "end";
+    /** Height the labels need below the axis line, in pixels. */
+    height: number;
+    /** Every Nth label is shown. */
+    step: number;
+}
+interface FitLabelsOptions {
+    fontSize?: number;
+    /** A fixed angle in degrees, or `auto` to rotate only when needed. */
+    angle?: number | "auto" | undefined;
+    /** Longest label in characters before truncation. Defaults to 24 (16 when rotated). */
+    maxLength?: number | undefined;
+    /** Mirrored axes rotate the other way, so labels still end at their tick. */
+    rtl?: boolean | undefined;
+}
+/**
+ * Decides how to draw category tick labels in `slotWidth` pixels each: flat if
+ * they fit, otherwise rotated 45 degrees, then 90 degrees, and finally skipping
+ * every Nth label. Long labels are truncated with an ellipsis.
+ */
+declare function fitTickLabels(texts: ReadonlyArray<string>, slotWidth: number, { fontSize, angle, maxLength, rtl }?: FitLabelsOptions): LabelFit;
+interface Margin {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface AxisMarginInput {
+    /** Width of the widest tick label on the vertical axis (zero when it has no axis). */
+    verticalTickWidth: number;
+    /** Height the horizontal axis labels need (from `fitTickLabels`). Zero when there is no axis. */
+    horizontalTickHeight: number;
+    verticalTitle: boolean;
+    horizontalTitle: boolean;
+    /** Side of the vertical axis. Mirrored (right-to-left) charts put it on the `right`. */
+    verticalAxisSide: "left" | "right";
+    /** Width of the tick labels of a second vertical axis, drawn on the opposite side. Zero for none. */
+    secondTickWidth?: number;
+    secondTitle?: boolean;
+    /** Space for direct labels past the end of lines, on the side opposite the vertical axis. */
+    directLabelWidth?: number;
+    fontSize?: number;
+}
+/**
+ * Space around the plot for axes, titles and direct labels. Every side keeps
+ * at least `EDGE_MARGIN` so marks and glyphs never touch the border.
+ */
+declare function computeAxisMargins({ verticalTickWidth, horizontalTickHeight, verticalTitle, horizontalTitle, verticalAxisSide, secondTickWidth, secondTitle, directLabelWidth, fontSize, }: AxisMarginInput): Margin;
+/**
+ * Spreads label positions apart so they never overlap, keeping order and
+ * staying inside `[min, max]`. Used for direct labels at the end of lines.
+ */
+declare function dodgePositions(positions: ReadonlyArray<number>, gap: number, min: number, max: number): number[];
+
+interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface LayoutOptions {
+    width: number;
+    height: number;
+    /** Mirror horizontal time and category axes (right-to-left layouts). */
+    rtl?: boolean | undefined;
+    locale?: string | undefined;
+    messages?: ChartMessagesInput | undefined;
+    /** Ids of hidden series (or slices). */
+    hidden?: ReadonlySet<string> | undefined;
+    /** Show hatch patterns on filled marks even when there is only one series. */
+    patterns?: boolean | undefined;
+}
+type FocusShape = {
+    kind: "circle";
+    cx: number;
+    cy: number;
+    r: number;
+} | {
+    kind: "rect";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | {
+    kind: "path";
+    d: string;
+    tx?: number;
+    ty?: number;
+};
+interface HitTarget {
+    id: string;
+    /** Index into `model.series`; 0 for slices and gauges. */
+    series: number;
+    /** Index into the series' points; the slice index for pie and donut. */
+    point: number;
+    /** Position along the category axis, for navigation and shared tooltips. */
+    group: number;
+    /** Anchor for the tooltip and crosshair, in layout coordinates. */
+    x: number;
+    y: number;
+    focus: FocusShape;
+    kind: "point" | "slice" | "cell" | "gauge";
+    /** Row and column of a heatmap cell. */
+    row?: number;
+    column?: number;
+    /** A pie slice's angular extent in radians clockwise from twelve o'clock, with the ring radii. */
+    arc?: {
+        cx: number;
+        cy: number;
+        innerRadius: number;
+        outerRadius: number;
+        start: number;
+        end: number;
+    };
+    /** Rectangular hit region for bars and cells. */
+    bounds?: Box;
+    /** Index of the threshold this point breaches, if any. */
+    breach?: number;
+}
+interface AxisTick {
+    value: number | string;
+    /** Pixel position along the axis. */
+    position: number;
+    label: string;
+    /** Untruncated label, for tooltips. */
+    full: string;
+    visible: boolean;
+}
+interface AxisLayout {
+    /** Which encoding the axis carries, regardless of where it is drawn. */
+    id: "x" | "y" | "y2";
+    orient: "bottom" | "left" | "right" | "top";
+    /** Axis line from (x1, y1) to (x2, y2). */
+    line: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    title?: string;
+    /** Anchor of the axis title; `rotate` is degrees. */
+    titlePosition?: {
+        x: number;
+        y: number;
+        rotate: number;
+    };
+    ticks: AxisTick[];
+    labelAngle: number;
+    labelAnchor: "start" | "middle" | "end";
+    grid: boolean;
+    /** True when tick labels are numbers (drawn left to right even in right-to-left pages). */
+    numeric: boolean;
+}
+type MarkKind = "bar" | "line" | "area" | "point" | "arc" | "cell" | "stem" | "connector";
+interface LayoutMark {
+    id: string;
+    kind: MarkKind;
+    /** Index into `model.series`; -1 for marks that belong to no series. */
+    series: number;
+    seriesId: string;
+    /** Index into the series' points; -1 for whole-series marks. */
+    point: number;
+    tone: SeriesTone;
+    /** Position in the series list, which picks a hatch pattern. */
+    styleIndex: number;
+    /** Hatch pattern index (0 to 7) drawn over the fill, or -1 for a solid fill. */
+    pattern: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    cx?: number;
+    cy?: number;
+    r?: number;
+    shape?: MarkerShape;
+    /** Path data for lines, areas, arcs and point markers. */
+    d?: string;
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    /** `stroke-dasharray`, or undefined for solid. */
+    dash?: string;
+    muted?: boolean;
+    highlighted?: boolean;
+    breach?: boolean;
+    /** Value-axis side or mark role, such as `track` and `value` for gauges. */
+    role?: "track" | "band" | "value" | "target" | "ring";
+    /** Position on a color ramp (0 to 1), for heatmap cells. */
+    t?: number;
+    ramp?: "sequential" | "diverging";
+    /** Series mark kind, for combos. */
+    seriesMark?: SeriesMark;
+}
+interface TextLabel {
+    id: string;
+    text: string;
+    x: number;
+    y: number;
+    anchor: "start" | "middle" | "end";
+    kind: "value" | "direct" | "annotation" | "center" | "caption" | "cell";
+    /** Vertical alignment: `middle` centers on y, `above` sits over y, `below` hangs under y. */
+    baseline?: "middle" | "above" | "below";
+    tone?: SeriesTone;
+    series?: number;
+    /** Draw left to right regardless of page direction (numbers). */
+    numeric?: boolean;
+}
+interface AnnotationLayout {
+    id: string;
+    kind: "line" | "band" | "point" | "text" | "forecast";
+    tone: SeriesTone;
+    toneName: AnnotationTone | "neutral";
+    threshold: boolean;
+    /** Line endpoints. */
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    /** Band rectangle. */
+    box?: Box;
+    /** Marker position for labeled points. */
+    cx?: number;
+    cy?: number;
+    label?: TextLabel;
+}
+interface LegendEntry {
+    id: string;
+    label: string;
+    /** Index into `model.series`, or null for slices and keys. */
+    series: number | null;
+    tone: SeriesTone;
+    marker: MarkerShape;
+    dash: string | undefined;
+    /** What the series draws, so the legend glyph matches. */
+    glyph: "line" | "area" | "bar" | "point" | "slice";
+    pattern: number;
+    visible: boolean;
+    /** False for explanatory keys (a waterfall's increase and decrease) that cannot be toggled. */
+    toggle: boolean;
+}
+type HitStrategy = "category-x" | "category-y" | "nearest" | "arc" | "cell" | "none";
+type NavigationMode = "category-x" | "category-y" | "sequence" | "grid" | "spatial" | "single" | "none";
+interface ColorScale {
+    kind: "sequential" | "diverging";
+    min: number;
+    max: number;
+}
+interface ChartLayout {
+    mark: ChartType;
+    width: number;
+    height: number;
+    margin: Margin;
+    plot: Box;
+    orientation: "vertical" | "horizontal";
+    /** True when the horizontal axis runs right to left. */
+    mirrored: boolean;
+    axes: AxisLayout[];
+    marks: LayoutMark[];
+    labels: TextLabel[];
+    annotations: AnnotationLayout[];
+    targets: HitTarget[];
+    legend: LegendEntry[];
+    hit: HitStrategy;
+    navigation: NavigationMode;
+    /** Draw a crosshair line along this axis at the active target. */
+    crosshair: "x" | "y" | "none";
+    /** Center and radii for pie, donut and gauge layouts. */
+    radial?: {
+        cx: number;
+        cy: number;
+        outerRadius: number;
+        innerRadius: number;
+    };
+    colorScale?: ColorScale;
+    /** True when every series is hidden. */
+    allHidden: boolean;
+    /** Hatch pattern indices in use, so the renderer defines only those. */
+    patterns: number[];
+}
+
+/**
+ * The locale used when none is given. It is fixed rather than read from the
+ * runtime, so a chart renders the same text on the server, in the browser and
+ * in tests. The default messages are English, so English formats match them.
+ */
+declare const DEFAULT_LOCALE = "en";
+/** True when the locale's language is written right to left (Arabic, Hebrew, Persian, Urdu and others). */
+declare function isRtlLocale(locale: string | undefined): boolean;
+/** Upper-cases the first letter, using the locale's rules. */
+declare function capitalize(text: string, locale?: string): string;
+/** Joins items with the locale's list rules ("a, b, and c"). */
+declare function formatList(items: ReadonlyArray<string>, locale?: string): string;
+type Formatter<T> = (value: T) => string;
+/** Fraction digits needed to show a tick step without rounding it away (0.25 needs 2). */
+declare function fractionDigitsForStep(step: number | undefined, max?: number): number;
+interface NumberFormatOptions {
+    /** Tick spacing, used to pick the fraction digits so ticks never repeat a label. */
+    step?: number;
+}
+/**
+ * Builds a number formatter from a named format, a d3-format specifier, or
+ * nothing (a sensible default). Named formats: `auto`, `compact`, `percent`
+ * (the value is a fraction: 0.25 is 25%), `integer`, `decimal`,
+ * `currency:USD`, `currency:USD:compact`, `unit:kilometer`.
+ */
+declare function createNumberFormatter(format: string | undefined, locale?: string, { step }?: NumberFormatOptions): Formatter<number>;
+/**
+ * Builds a date formatter for epoch milliseconds. `format` is a named format
+ * (`date`, `datetime`, `time`, `month`, `year`, `day`, `weekday`, `iso`) or a
+ * d3-time-format pattern starting with `%` (patterns are UTC). Without a
+ * format, whole days print as dates and anything else as date and time.
+ */
+declare function createDateFormatter(format: string | undefined, locale?: string, timeZone?: string, hasTimeOfDay?: boolean): Formatter<number>;
+/**
+ * Picks a compact label for a run of time ticks: years when ticks are a year
+ * apart, short months, day and month, or clock times, depending on the spacing.
+ */
+declare function createTimeTickFormatter(ticks: ReadonlyArray<number>, locale?: string, timeZone?: string): Formatter<number>;
+/** Formats a share (0 to 1) as a percentage. */
+declare function formatShare(value: number, locale?: string): string;
+
+interface ChartFormatters {
+    locale: string | undefined;
+    messages: ChartMessages;
+    /** Label for an x value: category text, a date, or a number. */
+    x: Formatter<string | number>;
+    /** Label for a point: its own label, else the formatted x. */
+    point: (point: ModelPoint) => string;
+    /** Value formatter for series `index`. */
+    value: (seriesIndex: number) => Formatter<number>;
+    /** Value-axis formatters (for tooltips; axes build their own from tick steps). */
+    y: Formatter<number>;
+    /**
+     * Formatter for gauge and progress ring values. `percent` shows the share of
+     * the min to max range, so 64 of 100 and 0.64 of 1 both read "64%".
+     */
+    gauge: Formatter<number>;
+    size: Formatter<number>;
+    share: Formatter<number>;
+    noValue: string;
+}
+/** Formatters for a chart's values, shared by tooltips, descriptions and tables. */
+declare function createFormatters(model: ChartModel, { locale, messages }?: {
+    locale?: string | undefined;
+    messages?: ChartMessagesInput | undefined;
+}): ChartFormatters;
+
+type NavKey = "ArrowLeft" | "ArrowRight" | "ArrowUp" | "ArrowDown" | "Home" | "End" | "PageUp" | "PageDown";
+declare const navKeys: ReadonlyArray<NavKey>;
+declare function isNavKey(key: string): key is NavKey;
+declare function targetById(layout: ChartLayout, id: string | null | undefined): HitTarget | undefined;
+/**
+ * Finds the target under a pointer position (layout coordinates), using the
+ * layout's strategy: nearest category along the category axis for most charts,
+ * nearest mark for scatter plots, angle and radius for pies, containment for
+ * heatmap cells. Returns `null` when the pointer is not over the plot.
+ */
+declare function hitTest(layout: ChartLayout, x: number, y: number): HitTarget | null;
+/**
+ * The id of the target a navigation key moves to, or the current id when
+ * there is nowhere to go. With no current target, keys enter the plot at the
+ * first (or, for End, last) target.
+ *
+ * - Category charts: Left and Right move along the category axis (swapped when
+ *   the axis is mirrored), Up and Down move between series at the same category
+ *   in screen order. Home and End jump to the first and last category, and Page
+ *   Up and Page Down move ten categories.
+ * - Scatter plots: arrows move to the nearest point in that direction.
+ * - Heatmaps: arrows move by cell; Page Up and Page Down jump to the first and
+ *   last row.
+ * - Pies: arrows step through slices.
+ */
+declare function navigate(layout: ChartLayout, currentId: string | null, key: NavKey): string | null;
+interface TooltipRow {
+    id: string;
+    label: string;
+    value: string;
+    tone: SeriesTone;
+    glyph: "line" | "area" | "bar" | "point" | "slice";
+    marker: string;
+    pattern: number;
+    dash: string | undefined;
+    /** The row of the focused or hovered mark. */
+    active: boolean;
+    note?: string;
+}
+interface TooltipContent {
+    title: string;
+    rows: TooltipRow[];
+}
+/** What a tooltip shows for a target: the category title and one row per series at that category. */
+declare function tooltipFor(model: ChartModel, layout: ChartLayout, target: HitTarget, fmts: ChartFormatters): TooltipContent | null;
+/** The sentence a screen reader hears when a mark gets focus. */
+declare function describeTarget(model: ChartModel, layout: ChartLayout, target: HitTarget, fmts: ChartFormatters, { position }?: {
+    position?: boolean;
+}): string;
+interface ChartPointInfo {
+    /** Series id, or the slice id for pies and donuts. */
+    seriesId: string;
+    seriesLabel: string;
+    /** Index into the model's series (0 for slices). */
+    seriesIndex: number;
+    /** Index of the point within its series (the slice index for pies). */
+    pointIndex: number;
+    /** The x value: category label, number, or epoch milliseconds. */
+    x: string | number | null;
+    /** The x value as text. */
+    xLabel: string;
+    y: number | null;
+    size: number | null;
+    /** The source row (or a synthetic one for series with own points). */
+    row: Row | null;
+    /** Share of the total for slices, from 0 to 1. */
+    share?: number;
+    /** Row category of a heatmap cell. */
+    group?: string;
+}
+/** The payload of `onPointActivate` for a target. */
+declare function pointInfo(model: ChartModel, target: HitTarget, fmts: ChartFormatters): ChartPointInfo | null;
+
+/**
+ * Maps a chart model to an ECharts option object, for the canvas renderer.
+ * Pure and server-safe: it never imports `echarts`, and colors come in as
+ * resolved values (the React layer reads them from the `--kit-*` custom
+ * properties at runtime, so themes work on canvas too).
+ *
+ * The option contains formatter functions, so it is not JSON-serializable.
+ */
+
+/** Resolved colors for canvas drawing. */
+interface ChartThemeColors {
+    tones: Readonly<Record<SeriesTone, string>>;
+    text: string;
+    textSecondary: string;
+    axis: string;
+    grid: string;
+    surface: string;
+    border: string;
+    accent: string;
+    /** Nine steps, light to dark. */
+    sequential: ReadonlyArray<string>;
+    /** Nine steps, one hue through a neutral midpoint to another. */
+    diverging: ReadonlyArray<string>;
+    fontFamily: string;
+}
+/** The theme constants from `@x12i/tokens`, for server rendering and as a runtime fallback. */
+declare function themeColorsFromTokens(theme?: ThemeName): ChartThemeColors;
+interface EChartsOptionInput {
+    colors: ChartThemeColors;
+    locale?: string | undefined;
+    messages?: ChartMessagesInput | undefined;
+    /** Ids of hidden series or slices. */
+    hidden?: ReadonlySet<string> | undefined;
+    /** Animate on first draw. Turn off for reduced motion. Defaults to false. */
+    animate?: boolean | undefined;
+}
+type EChartsOptionObject = Record<string, unknown>;
+/**
+ * The ECharts option for a model, or `null` when the canvas renderer cannot
+ * draw it (no data, unsupported, or a waterfall that crosses zero), in which
+ * case callers use the SVG renderer.
+ */
+declare function toEChartsOption(model: ChartModel, input: EChartsOptionInput): EChartsOptionObject | null;
+
+export { AXIS_FONT_SIZE as A, DEFAULT_LOCALE as E, fractionDigitsForStep as a$, MAX_HUES as a0, applyTransforms as aA, buildChartModel as aB, capitalize as aC, categoricalTones as aD, chartTypes as aE, computeAxisMargins as aF, countPoints as aG, createBandScale as aH, createContinuousScale as aI, createDateFormatter as aJ, createFormatters as aK, createNumberFormatter as aL, createPointScale as aM, createTimeTickFormatter as aN, dashArrays as aO, dashStyles as aP, defaultMessages as aQ, defineChartSpec as aR, describeTarget as aS, divergingColor as aT, dodgePositions as aU, effectiveStack as aV, estimateTextWidth as aW, fitTickLabels as aX, formatList as aY, formatMessage as aZ, formatShare as a_, SVG_POINT_LIMIT as ag, TICK_PADDING as ao, TICK_SIZE as ap, annotationTone as az, histogramBins as b0, hitTest as b1, isNavKey as b2, isOpenMarker as b3, isRtlLocale as b4, isSupportedMark as b5, markerPath as b6, markerShapes as b7, navKeys as b8, navigate as b9, niceTicks as ba, pointInfo as bb, rampGradient as bc, readField as bd, resolveMessages as be, resolveRenderer as bf, resolveRows as bg, sequentialColor as bh, seriesStyle as bi, supportedMarks as bj, targetById as bk, themeColorsFromTokens as bl, toCategory as bm, toEChartsOption as bn, toNumber as bo, toTime as bp, toneCssVar as bq, toneTokenPath as br, toneVarName as bs, tooltipFor as bt, truncateLabel as bu, usesBandX as bv, valueDomain as bw };
+export type { LegendSpec as $, BandScale as B, ChartSpec as C, Datasets as D, DashStyle as F, DomainOptions as G, DonutSpec as H, EChartsOptionInput as I, EChartsOptionObject as J, Encoding as K, LayoutOptions as L, FieldType as M, FitLabelsOptions as N, FittedLabel as O, FocusShape as P, Formatter as Q, Row as R, StackMode as S, GaugeSpec as T, HistogramBin as U, HistogramOptions as V, HitStrategy as W, HitTarget as X, LabelFit as Y, LayoutMark as Z, LegendEntry as _, ChartModel as a, Margin as a1, MarkKind as a2, MarkerShape as a3, ModelGauge as a4, ModelPoint as a5, ModelSeries as a6, ModelSlice as a7, ModelStatus as a8, NavKey as a9, NavigationMode as aa, NumberFormatOptions as ab, PointScale as ac, RenderTarget as ad, RendererChoice as ae, ResolveRendererInput as af, ScaleSpec as ah, ScaleType as ai, SeriesMark as aj, SeriesPoint as ak, SeriesSpec as al, SeriesStyle as am, SeriesTone as an, TextLabel as aq, Threshold as ar, TooltipContent as as, TooltipRow as at, Transform as au, TransformContext as av, WaterfallSpec as aw, WaterfallStep as ax, XKind as ay, ChartLayout as b, ChartMessagesInput as c, Annotation as d, AnnotationLayout as e, AnnotationTone as f, AxisLayout as g, AxisMarginInput as h, AxisSpec as i, AxisTick as j, BinSpec as k, Box as l, BuildModelOptions as m, ChartA11y as n, ChartData as o, ChartFormatters as p, ChartInteractions as q, ChartLabels as r, ChartMessages as s, ChartPointInfo as t, ChartThemeColors as u, ChartType as v, ColorScale as w, ContinuousKind as x, ContinuousScale as y, ContinuousScaleOptions as z };