@tensor_1/react 2.37.0 → 2.39.0

package/dist/chart-analytic.d.cts

@@ -0,0 +1,335 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { U as UixChartTokens, C as ChartLabels, a as ChartProps } from './ChartCore-BKK2HEfi.cjs';
+export { b as ChartEngine, c as ChartEventHandler, d as ChartLegend, e as ChartLegendItem, f as ChartLegendItemProps, g as ChartLegendProps, h as ChartMetric, i as ChartMetricProps, j as ChartOption, k as ChartTable, l as ChartTableRow, m as ChartTokenSource, D as DEFAULT_CHART_LABELS, n as mergeChartTheme, u as uixChartAreaGradient, o as uixChartPalette, p as uixChartTheme, q as uixChartTokens } from './ChartCore-BKK2HEfi.cjs';
+import { ScatterSeriesOption, MarkLineComponentOption, MarkAreaComponentOption, MarkPointComponentOption, LineSeriesOption, EChartsOption } from 'echarts';
+import { L as LinearFit } from './chart-stats-o4zDhpVm.cjs';
+export { C as ChartStatPoint, P as PredictionBandPoint, l as linearFit, n as normalQuantile, p as predictionBand, q as quantiles, s as studentTQuantile } from './chart-stats-o4zDhpVm.cjs';
+
+/** A position on the x axis: a category name, or a time value (ms or ISO string) on a time axis. */
+type ChartX = string | number;
+/** A target line, a limit or a zone. `to` turns a line into a zone between `value` and `to`. */
+interface ChartThreshold {
+    value: number;
+    to?: number;
+    kind: 'target' | 'limit' | 'floor' | 'budget';
+    tone: 'neutral' | 'warning' | 'danger';
+    label: string;
+    /** The side that is bad: shades from the line to the edge of the axis on that side. */
+    badSide?: 'above' | 'below';
+}
+/** Something that happened at (or from `at` to `to`) on the time axis. */
+interface ChartEvent {
+    at: ChartX;
+    to?: ChartX;
+    kind: string;
+    label: string;
+    href?: string;
+    tone?: 'neutral' | 'warning' | 'danger';
+}
+/** A projection with its uncertainty, computed by the consumer. `from` is the last actual x. */
+interface ChartForecast {
+    from: ChartX;
+    points: {
+        x: ChartX;
+        y: number;
+        lower: number;
+        upper: number;
+    }[];
+    /** Central coverage of the band, 0–1 (0.8 = 80 %). */
+    level: number;
+    /** How it was computed, for the tooltip and the table ("linear over 8 weeks"). */
+    method: string;
+}
+/** The previous period's values on the same x positions (a ghost line). */
+interface ChartComparison {
+    label: string;
+    values: (number | null)[];
+}
+/** Every word the overlays draw. English defaults in {@link DEFAULT_ANALYTIC_LABELS}. */
+interface ChartAnalyticLabels {
+    projection: string;
+    /** The band's name in the legend, the tooltip and the table, e.g. "80 % range". */
+    range: (level: number) => string;
+    partial: string;
+    crossed: (x: string) => string;
+    lower: string;
+    upper: string;
+    threshold: string;
+    event: string;
+    /** How an x value is written in labels and tables. */
+    formatX: (x: ChartX) => string;
+}
+declare const DEFAULT_ANALYTIC_LABELS: ChartAnalyticLabels;
+/** Series-level mark fragments; spread into one series, or combine several with {@link combineMarks}. */
+interface ChartMarks {
+    markLine?: MarkLineComponentOption;
+    markArea?: MarkAreaComponentOption;
+    markPoint?: MarkPointComponentOption;
+}
+/** Merge mark fragments into one (a series carries one markLine, one markArea and one markPoint). */
+declare function combineMarks(...fragments: (ChartMarks | null | undefined)[]): ChartMarks;
+/**
+ * Threshold lines and zones. A line is solid reference ink with its label in the right gutter
+ * (the plot needs `grid.right` ≥ 96 px; ChartPanels reserves it). A zone (`to`, or `badSide` with an
+ * axis `extent`) is a token wash. Lines never take a status hue: the zone carries the tone.
+ */
+declare function thresholdMarks(thresholds: readonly ChartThreshold[], options: {
+    tokens: UixChartTokens;
+    extent?: [number, number];
+}): ChartMarks;
+/** One pin in the event lane: [x, 0, index into the events]. */
+type ChartEventPin = [ChartX, number, number];
+/** The event lane: a thin row above the plot that owns the events' tooltip and click-through. */
+interface ChartEventLane {
+    series: ScatterSeriesOption;
+}
+/**
+ * Events: unlabeled solid lines through the plot (ranges as a light wash) plus the pins of the lane.
+ * The tone is carried by the pin's shape (circle, triangle, diamond) in event ink, never by a status
+ * hue, so the lane stays calm. Put `lane.series` on the lane's grid (ChartPanels does).
+ */
+declare function eventMarks(events: readonly ChartEvent[], options: {
+    tokens: UixChartTokens;
+    xAxisIndex?: number;
+    yAxisIndex?: number;
+    seriesId?: string;
+}): ChartMarks & {
+    lane: ChartEventLane;
+};
+/**
+ * A forecast as three series: a hidden lower bound, the band stacked on it (upper − lower) in
+ * `--uix-chart-forecast-band`, and the dashed centre line in the series colour, starting at `from`.
+ * The centre carries a light "Projection" wash from `from` to the last point.
+ */
+declare function forecastSeries(forecast: ChartForecast, options: {
+    name: string;
+    colorIndex?: number;
+    tokens: UixChartTokens;
+    labels?: Partial<ChartAnalyticLabels>;
+    /** The last actual value, so the dashed line starts where the solid one ends. */
+    fromValue?: number | null;
+    xAxisIndex?: number;
+    yAxisIndex?: number;
+    idPrefix?: string;
+}): LineSeriesOption[];
+/** The previous period as a thin SOLID ghost line (dashes are reserved for projections). */
+declare function comparisonSeries(comparison: ChartComparison, options: {
+    x: readonly ChartX[];
+    tokens: UixChartTokens;
+    xAxisIndex?: number;
+    yAxisIndex?: number;
+    id?: string;
+}): LineSeriesOption;
+/**
+ * The last, still-filling period: a shaded wash from the previous bucket (`from`) to `lastX`,
+ * labelled "Partial" at the foot of the plot. On a category line axis the points sit on the
+ * categories, so the wash spans the segment that leads into the partial point.
+ */
+declare function partialPeriod(lastX: ChartX, options: {
+    tokens: UixChartTokens;
+    from?: ChartX;
+    labels?: Partial<ChartAnalyticLabels>;
+}): ChartMarks;
+/**
+ * Indexes where the series first enters the bad side of a threshold (after being on the good side
+ * or at the start of a run of nulls). `badSide` defaults to `above` (`floor` thresholds: `below`).
+ */
+declare function findCrossings(values: readonly (number | null)[], threshold: Pick<ChartThreshold, 'value' | 'badSide' | 'kind'>): number[];
+/** A ringed point at each first crossing, labelled "Crossed <x>" above it. */
+declare function crossingPoints(values: readonly (number | null)[], threshold: ChartThreshold, options: {
+    x: readonly ChartX[];
+    tokens: UixChartTokens;
+    labels?: Partial<ChartAnalyticLabels>;
+}): ChartMarks;
+
+/** One variable in a panel. `values` align with `x.values`. */
+interface ChartPanelSeries {
+    id: string;
+    label: string;
+    values: (number | null)[];
+    /** Slot in the categorical palette (0-based). Defaults to the series' index in its panel. */
+    colorIndex?: number;
+}
+/** One panel: one unit, one y axis. */
+interface ChartPanel {
+    id: string;
+    title: string;
+    /** Written after values ("h", "%", "items"). `%` is attached, anything else follows a space. */
+    unit?: string;
+    /** Plot height in px (without the title row). Default 112. */
+    height?: number;
+    kind: 'line' | 'bar' | 'area';
+    series: ChartPanelSeries[];
+    thresholds?: ChartThreshold[];
+    /** A projection of the panel's first series. */
+    forecast?: ChartForecast;
+    comparison?: ChartComparison;
+}
+interface ChartPanelsX {
+    type: 'category' | 'time';
+    values: ChartX[];
+}
+/** Words ChartPanels draws or writes into its tables, on top of the overlay words. */
+interface ChartPanelsLabels extends ChartAnalyticLabels {
+    /** Header of the x column in each panel's data table. */
+    x: string;
+    /** A panel table's caption. */
+    table: (panelTitle: string) => string;
+    formatValue: (value: number, unit?: string) => string;
+}
+declare const DEFAULT_CHART_PANELS_LABELS: ChartPanelsLabels;
+interface ChartPanelsSpec {
+    x: ChartPanelsX;
+    panels: ChartPanel[];
+    /** One event lane on top; lines through every panel. */
+    events?: ChartEvent[];
+    /** The last x is a period still filling up: shaded and labelled in every panel. */
+    partialLast?: boolean;
+    /** Linked inside zoom (wheel / pinch) on every panel. */
+    zoom?: boolean;
+}
+/** A legend entry: identity is never colour alone (dataviz), so the swatch shape says the role. */
+interface ChartPanelsLegendItem {
+    label: string;
+    color: string;
+    swatch: 'line' | 'dash' | 'block';
+}
+interface ChartPanelsTable {
+    caption: string;
+    headers: string[];
+    rows: Record<string, string | number>[];
+}
+interface ChartPanelsModel {
+    option: EChartsOption;
+    /** Total chart height in px, from the panels. */
+    height: number;
+    legend: ChartPanelsLegendItem[];
+    tables: ChartPanelsTable[];
+    /** The x positions on the axis: `x.values` plus forecast positions past them. */
+    categories: ChartX[];
+    /** Series id → panel id, for click handling. */
+    seriesPanel: Record<string, string>;
+    /** The id of the event lane's series ('' when there are no events). */
+    laneSeriesId: string;
+}
+declare const CHART_PANELS_LAYOUT: {
+    readonly top: 8;
+    readonly lane: 14;
+    readonly laneGap: 10;
+    readonly title: 28;
+    readonly panelHeight: 112;
+    readonly panelGap: 14;
+    readonly axisBand: 30;
+    readonly left: 52;
+    readonly right: 16;
+    readonly gutter: 100;
+};
+/** A "nice" upper bound (1, 2, 2.5, 5 × 10ⁿ) at or above `value`. */
+declare function niceCeil(value: number): number;
+/** Build the panels' option, height, legend and tables from typed data. */
+declare function chartPanelsModel(spec: ChartPanelsSpec, tokens: UixChartTokens, labelOverrides?: Partial<ChartPanelsLabels>): ChartPanelsModel;
+
+interface CorrelationPoint {
+    x: number;
+    y: number;
+    label: string;
+    href?: string;
+    /** A point that matters (a breach): a status hue AND a distinct shape, never colour alone. */
+    emphasis?: 'danger' | 'warning';
+}
+interface CorrelationScatterLabels {
+    /** The stats caption. `r` is null when it is undefined (y constant). */
+    stats: (stats: {
+        r: number | null;
+        n: number;
+    }) => string;
+    notEnough: (n: number, min: number) => string;
+    percentile: (p: number) => string;
+    trend: string;
+    /** Header of the label column in the data table. */
+    point: string;
+    formatX: (x: number) => string;
+    formatY: (y: number) => string;
+}
+/** r to two decimals, truncated toward zero so an imperfect fit never reads "r = 1.00". */
+declare function formatCorrelation(r: number): string;
+declare const DEFAULT_CORRELATION_SCATTER_LABELS: CorrelationScatterLabels;
+interface CorrelationScatterSpec {
+    points: CorrelationPoint[];
+    xLabel: string;
+    yLabel: string;
+    trend?: 'linear' | 'none';
+    /** Percentile lines of y, in percent (e.g. [50, 90]). */
+    percentiles?: number[];
+    thresholds?: {
+        x?: ChartThreshold[];
+        y?: ChartThreshold[];
+    };
+    breakpoint?: {
+        x: number;
+        label: string;
+    };
+    /** Below this many points there is no trend and no stats. Default 8. */
+    minPoints?: number;
+}
+interface CorrelationScatterModel {
+    /** False below `minPoints`: render the "not enough data" state instead of a trend. */
+    enough: boolean;
+    n: number;
+    minPoints: number;
+    fit: LinearFit | null;
+    option: EChartsOption;
+    statsText: string;
+    table: {
+        headers: string[];
+        rows: Record<string, string | number>[];
+    };
+    /** Index into `points` for each data item of the hit series. */
+    hitSeriesId: string;
+}
+/** Hit target for every point, in px: above the 24 px accessible minimum (WCAG 2.5.8) with the 2 px gap around it. */
+declare const SCATTER_HIT_SIZE = 26;
+declare function correlationScatterModel(spec: CorrelationScatterSpec, tokens: UixChartTokens, labelOverrides?: Partial<CorrelationScatterLabels>): CorrelationScatterModel;
+
+interface ChartFrameProps {
+    /** Accessible name of the whole chart. Required: a chart without one tells a screen reader nothing. */
+    ariaLabel: string;
+    title?: string;
+    subtitle?: string;
+    header?: ReactNode;
+    headerAction?: ReactNode;
+    footer?: ReactNode;
+    loading?: boolean;
+    empty?: ReactNode;
+    className?: string;
+    /** Charts with the same group share one crosshair across cards. */
+    group?: string;
+}
+interface ChartPanelsProps extends ChartPanelsSpec, ChartFrameProps {
+    labels?: Partial<ChartPanelsLabels> & Partial<ChartLabels>;
+    /** A click on a panel's point. */
+    onPointClick?: (panelId: string, x: ChartX) => void;
+    /** A click on an event pin. Without a handler, an event with `href` navigates there. */
+    onEventClick?: (event: ChartEvent) => void;
+    /** Show the legend (series of multi-series panels, comparison, projection). Default: when there is one. */
+    legend?: boolean;
+}
+interface CorrelationScatterProps extends CorrelationScatterSpec, ChartFrameProps {
+    labels?: Partial<CorrelationScatterLabels> & Partial<ChartLabels>;
+    /** Show r, n and "association, not cause" under the plot. Default true. */
+    showStats?: boolean;
+    /** Plot height in px. Default 280. */
+    height?: number;
+    /** A click on a point. Without a handler, a point with `href` navigates there. */
+    onPointClick?: (point: CorrelationPoint) => void;
+}
+
+/** Chart on the analytic build: everything the lean preset has for line and bar, plus the overlays. */
+declare function Chart(props: ChartProps): react.JSX.Element;
+/** Aligned panels on one x axis with one crosshair; thresholds, events, forecasts, comparison, partial period. */
+declare function ChartPanels(props: ChartPanelsProps): react.JSX.Element;
+/** Two variables against each other: dots, OLS trend, r and n, percentiles, thresholds, a breaking point. */
+declare function CorrelationScatter(props: CorrelationScatterProps): react.JSX.Element;
+
+export { CHART_PANELS_LAYOUT, Chart, type ChartAnalyticLabels, type ChartComparison, type ChartEvent, type ChartEventLane, type ChartEventPin, type ChartForecast, ChartLabels, type ChartMarks, type ChartPanel, type ChartPanelSeries, ChartPanels, type ChartPanelsLabels, type ChartPanelsLegendItem, type ChartPanelsModel, type ChartPanelsProps, type ChartPanelsSpec, type ChartPanelsTable, type ChartPanelsX, ChartProps, type ChartThreshold, type ChartX, type CorrelationPoint, CorrelationScatter, type CorrelationScatterLabels, type CorrelationScatterModel, type CorrelationScatterProps, type CorrelationScatterSpec, DEFAULT_ANALYTIC_LABELS, DEFAULT_CHART_PANELS_LABELS, DEFAULT_CORRELATION_SCATTER_LABELS, LinearFit, SCATTER_HIT_SIZE, UixChartTokens, chartPanelsModel, combineMarks, comparisonSeries, correlationScatterModel, crossingPoints, eventMarks, findCrossings, forecastSeries, formatCorrelation, niceCeil, partialPeriod, thresholdMarks };

package/dist/chart-analytic.d.ts

@@ -0,0 +1,19 @@
+import * as react from 'react';
+import { ChartProps } from './components/ChartCore.js';
+export { ChartEngine, ChartEventHandler, ChartLabels, ChartLegend, ChartLegendItem, ChartLegendItemProps, ChartLegendProps, ChartMetric, ChartMetricProps, ChartOption, ChartTable, ChartTableRow, DEFAULT_CHART_LABELS, uixChartPalette } from './components/ChartCore.js';
+import { ChartPanelsProps, CorrelationScatterProps } from './components/ChartPanels.js';
+export { ChartTokenSource, UixChartTokens, mergeChartTheme, uixChartAreaGradient, uixChartTheme, uixChartTokens } from './chart-theme.js';
+export { ChartAnalyticLabels, ChartComparison, ChartEvent, ChartEventLane, ChartEventPin, ChartForecast, ChartMarks, ChartThreshold, ChartX, DEFAULT_ANALYTIC_LABELS, combineMarks, comparisonSeries, crossingPoints, eventMarks, findCrossings, forecastSeries, partialPeriod, thresholdMarks } from './chart-analytic-model.js';
+export { CHART_PANELS_LAYOUT, ChartPanel, ChartPanelSeries, ChartPanelsLabels, ChartPanelsLegendItem, ChartPanelsModel, ChartPanelsSpec, ChartPanelsTable, ChartPanelsX, DEFAULT_CHART_PANELS_LABELS, chartPanelsModel, niceCeil } from './chart-panels-model.js';
+export { CorrelationPoint, CorrelationScatterLabels, CorrelationScatterModel, CorrelationScatterSpec, DEFAULT_CORRELATION_SCATTER_LABELS, SCATTER_HIT_SIZE, correlationScatterModel, formatCorrelation } from './correlation-scatter-model.js';
+export { ChartStatPoint, LinearFit, PredictionBandPoint, linearFit, normalQuantile, predictionBand, quantiles, studentTQuantile } from './chart-stats.js';
+import 'echarts';
+
+/** Chart on the analytic build: everything the lean preset has for line and bar, plus the overlays. */
+declare function Chart(props: ChartProps): react.JSX.Element;
+/** Aligned panels on one x axis with one crosshair; thresholds, events, forecasts, comparison, partial period. */
+declare function ChartPanels(props: ChartPanelsProps): react.JSX.Element;
+/** Two variables against each other: dots, OLS trend, r and n, percentiles, thresholds, a breaking point. */
+declare function CorrelationScatter(props: CorrelationScatterProps): react.JSX.Element;
+
+export { Chart, ChartPanels, ChartPanelsProps, ChartProps, CorrelationScatter, CorrelationScatterProps };

package/dist/chart-analytic.js

@@ -0,0 +1,95 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as echarts from "echarts/core";
+import { BarChart, LineChart, ScatterChart } from "echarts/charts";
+import {
+  AxisPointerComponent,
+  DataZoomInsideComponent,
+  GridComponent,
+  LegendComponent,
+  MarkAreaComponent,
+  MarkLineComponent,
+  MarkPointComponent,
+  TooltipComponent,
+  VisualMapPiecewiseComponent
+} from "echarts/components";
+import { SVGRenderer } from "echarts/renderers";
+import { ChartCore } from "./components/ChartCore.js";
+import { ChartPanelsCore, CorrelationScatterCore } from "./components/ChartPanels.js";
+echarts.use([
+  BarChart,
+  LineChart,
+  ScatterChart,
+  AxisPointerComponent,
+  DataZoomInsideComponent,
+  GridComponent,
+  LegendComponent,
+  MarkAreaComponent,
+  MarkLineComponent,
+  MarkPointComponent,
+  TooltipComponent,
+  VisualMapPiecewiseComponent,
+  SVGRenderer
+]);
+const analyticEngine = echarts;
+function Chart(props) {
+  return /* @__PURE__ */ jsx(ChartCore, { ...props, engine: analyticEngine });
+}
+function ChartPanels(props) {
+  return /* @__PURE__ */ jsx(ChartPanelsCore, { ...props, engine: analyticEngine });
+}
+function CorrelationScatter(props) {
+  return /* @__PURE__ */ jsx(CorrelationScatterCore, { ...props, engine: analyticEngine });
+}
+import { ChartLegend, ChartLegendItem, ChartMetric, DEFAULT_CHART_LABELS, uixChartPalette } from "./components/ChartCore.js";
+import { mergeChartTheme, uixChartAreaGradient, uixChartTheme, uixChartTokens } from "./chart-theme.js";
+import {
+  DEFAULT_ANALYTIC_LABELS,
+  combineMarks,
+  comparisonSeries,
+  crossingPoints,
+  eventMarks,
+  findCrossings,
+  forecastSeries,
+  partialPeriod,
+  thresholdMarks
+} from "./chart-analytic-model.js";
+import { CHART_PANELS_LAYOUT, DEFAULT_CHART_PANELS_LABELS, chartPanelsModel, niceCeil } from "./chart-panels-model.js";
+import { DEFAULT_CORRELATION_SCATTER_LABELS, SCATTER_HIT_SIZE, correlationScatterModel, formatCorrelation } from "./correlation-scatter-model.js";
+import { linearFit, normalQuantile, predictionBand, quantiles, studentTQuantile } from "./chart-stats.js";
+export {
+  CHART_PANELS_LAYOUT,
+  Chart,
+  ChartLegend,
+  ChartLegendItem,
+  ChartMetric,
+  ChartPanels,
+  CorrelationScatter,
+  DEFAULT_ANALYTIC_LABELS,
+  DEFAULT_CHART_LABELS,
+  DEFAULT_CHART_PANELS_LABELS,
+  DEFAULT_CORRELATION_SCATTER_LABELS,
+  SCATTER_HIT_SIZE,
+  chartPanelsModel,
+  combineMarks,
+  comparisonSeries,
+  correlationScatterModel,
+  crossingPoints,
+  eventMarks,
+  findCrossings,
+  forecastSeries,
+  formatCorrelation,
+  linearFit,
+  mergeChartTheme,
+  niceCeil,
+  normalQuantile,
+  partialPeriod,
+  predictionBand,
+  quantiles,
+  studentTQuantile,
+  thresholdMarks,
+  uixChartAreaGradient,
+  uixChartPalette,
+  uixChartTheme,
+  uixChartTokens
+};

package/dist/chart-panels-model.d.ts

@@ -0,0 +1,92 @@
+import { EChartsOption } from 'echarts';
+import { UixChartTokens } from './chart-theme.js';
+import { ChartAnalyticLabels, ChartX, ChartThreshold, ChartForecast, ChartComparison, ChartEvent } from './chart-analytic-model.js';
+
+/** One variable in a panel. `values` align with `x.values`. */
+interface ChartPanelSeries {
+    id: string;
+    label: string;
+    values: (number | null)[];
+    /** Slot in the categorical palette (0-based). Defaults to the series' index in its panel. */
+    colorIndex?: number;
+}
+/** One panel: one unit, one y axis. */
+interface ChartPanel {
+    id: string;
+    title: string;
+    /** Written after values ("h", "%", "items"). `%` is attached, anything else follows a space. */
+    unit?: string;
+    /** Plot height in px (without the title row). Default 112. */
+    height?: number;
+    kind: 'line' | 'bar' | 'area';
+    series: ChartPanelSeries[];
+    thresholds?: ChartThreshold[];
+    /** A projection of the panel's first series. */
+    forecast?: ChartForecast;
+    comparison?: ChartComparison;
+}
+interface ChartPanelsX {
+    type: 'category' | 'time';
+    values: ChartX[];
+}
+/** Words ChartPanels draws or writes into its tables, on top of the overlay words. */
+interface ChartPanelsLabels extends ChartAnalyticLabels {
+    /** Header of the x column in each panel's data table. */
+    x: string;
+    /** A panel table's caption. */
+    table: (panelTitle: string) => string;
+    formatValue: (value: number, unit?: string) => string;
+}
+declare const DEFAULT_CHART_PANELS_LABELS: ChartPanelsLabels;
+interface ChartPanelsSpec {
+    x: ChartPanelsX;
+    panels: ChartPanel[];
+    /** One event lane on top; lines through every panel. */
+    events?: ChartEvent[];
+    /** The last x is a period still filling up: shaded and labelled in every panel. */
+    partialLast?: boolean;
+    /** Linked inside zoom (wheel / pinch) on every panel. */
+    zoom?: boolean;
+}
+/** A legend entry: identity is never colour alone (dataviz), so the swatch shape says the role. */
+interface ChartPanelsLegendItem {
+    label: string;
+    color: string;
+    swatch: 'line' | 'dash' | 'block';
+}
+interface ChartPanelsTable {
+    caption: string;
+    headers: string[];
+    rows: Record<string, string | number>[];
+}
+interface ChartPanelsModel {
+    option: EChartsOption;
+    /** Total chart height in px, from the panels. */
+    height: number;
+    legend: ChartPanelsLegendItem[];
+    tables: ChartPanelsTable[];
+    /** The x positions on the axis: `x.values` plus forecast positions past them. */
+    categories: ChartX[];
+    /** Series id → panel id, for click handling. */
+    seriesPanel: Record<string, string>;
+    /** The id of the event lane's series ('' when there are no events). */
+    laneSeriesId: string;
+}
+declare const CHART_PANELS_LAYOUT: {
+    readonly top: 8;
+    readonly lane: 14;
+    readonly laneGap: 10;
+    readonly title: 28;
+    readonly panelHeight: 112;
+    readonly panelGap: 14;
+    readonly axisBand: 30;
+    readonly left: 52;
+    readonly right: 16;
+    readonly gutter: 100;
+};
+/** A "nice" upper bound (1, 2, 2.5, 5 × 10ⁿ) at or above `value`. */
+declare function niceCeil(value: number): number;
+/** Build the panels' option, height, legend and tables from typed data. */
+declare function chartPanelsModel(spec: ChartPanelsSpec, tokens: UixChartTokens, labelOverrides?: Partial<ChartPanelsLabels>): ChartPanelsModel;
+
+export { CHART_PANELS_LAYOUT, type ChartPanel, type ChartPanelSeries, type ChartPanelsLabels, type ChartPanelsLegendItem, type ChartPanelsModel, type ChartPanelsSpec, type ChartPanelsTable, type ChartPanelsX, DEFAULT_CHART_PANELS_LABELS, chartPanelsModel, niceCeil };