@synertech/ui 0.42.0 → 0.44.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
-import react__default, { ReactNode, ReactElement, ComponentPropsWithoutRef, RefObject, ChangeEvent, MouseEvent, Dispatch, SetStateAction, HTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, TdHTMLAttributes } from 'react';
+import react__default, { ReactNode, ReactElement, ComponentPropsWithoutRef, PointerEvent, KeyboardEvent, CSSProperties, RefObject, ChangeEvent, MouseEvent, Dispatch, SetStateAction, HTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, TdHTMLAttributes } from 'react';
 import { M as MarkdownEditorComponent } from './types-99-Ej5og.js';
 export { a as MarkdownEditorProps } from './types-99-Ej5og.js';
 
@@ -123,6 +123,14 @@ type ChartSize = "sm" | "md" | "lg";
  */
 type ChartCurve = "linear" | "monotone" | "step" | "stepAfter";
 type ChartGridLines = "none" | "x" | "y" | "both";
+/**
+ * Which screen axis carries the values.
+ *
+ * `vertical` is the usual case — values run up the left side, categories along
+ * the bottom. `horizontal` swaps them, which is what a bar chart does when its
+ * category names are too long to be read rotated.
+ */
+type ChartOrientation = "vertical" | "horizontal";
 type ChartLegendPosition = "top" | "bottom" | "right";
 /** How the horizontal axis maps values to pixels. */
 type ChartScaleType = "category" | "linear" | "time";
@@ -155,6 +163,10 @@ interface ChartSeries {
      */
     type?: "bar" | "line";
 }
+/** A series whose palette slot has been resolved to a colour. */
+type ChartResolvedSeries = ChartSeries & {
+    color: string;
+};
 interface ChartXAxisConfig {
     /** Field read on each datum. */
     key: string;
@@ -243,6 +255,34 @@ interface ChartReferenceLine {
     color?: string;
     dashed?: boolean;
 }
+/** What every annotation carries. */
+interface ChartAnnotationBase {
+    /** The comment itself. Without it an annotation marks a spot and says nothing. */
+    label?: string;
+    /** Any CSS colour. Defaults to a muted grey, which is what keeps it chrome. */
+    color?: string;
+}
+/** A single observation worth commenting, marked where it sits on the plot. */
+interface ChartPointAnnotation extends ChartAnnotationBase {
+    type: "point";
+    x: ChartXValue;
+    /** Value the marker is pinned to, read on the chart's own value axis. */
+    y: number;
+}
+/** A moment: a release, a price change, the day the tracking broke. */
+interface ChartLineAnnotation extends ChartAnnotationBase {
+    type: "line";
+    x: ChartXValue;
+    /** Solid instead of dashed — for a boundary rather than an event. */
+    dashed?: boolean;
+}
+/** A stretch of the category axis: a campaign, an outage, a closed quarter. */
+interface ChartBandAnnotation extends ChartAnnotationBase {
+    type: "band";
+    from: ChartXValue;
+    to: ChartXValue;
+}
+type ChartAnnotation = ChartPointAnnotation | ChartLineAnnotation | ChartBandAnnotation;
 /** An entry of the legend. */
 interface ChartLegendItem {
     key: string;
@@ -256,6 +296,13 @@ interface ChartLegendItem {
      * series drawn as a line cannot wear the same block as the bars beside it.
      */
     marker?: "line" | "rect" | "dot";
+    /**
+     * Texture slot the entry wears, when the chart draws its marks with them.
+     *
+     * The swatch has to carry both channels the plot carries, or the texture is
+     * a pattern the reader cannot map onto anything.
+     */
+    pattern?: number;
 }
 /** A tick, already placed on its axis. */
 interface ChartTick {
@@ -265,11 +312,107 @@ interface ChartTick {
     offset: number;
     label: string;
 }
+/**
+ * The resolved geometry of a plot, handed to whatever an application draws
+ * inside it.
+ *
+ * Coordinates are relative to the **drawing area**, not to the SVG: `0, 0` is
+ * the top-left corner of the plot, inside the axis gutters, which is the frame
+ * the chart's own marks are placed in.
+ */
+interface ChartPlotContext {
+    /** Size of the drawing area, and the gutters reserved around it. */
+    dimensions: ChartDimensions;
+    /** Which screen axis carries the values. */
+    orientation: ChartOrientation;
+    /**
+     * Where an x value lands along the category axis, in pixels.
+     *
+     * `null` when the axis cannot place it — a category that is not in the data,
+     * or a date outside the window. Skip the mark rather than drawing it on the
+     * edge, which is what the chart's own overlays do.
+     */
+    xAt: (value: ChartXValue) => number | null;
+    /** Where a value lands along the value axis, in pixels. */
+    yAt: (value: number) => number;
+    /** Middle of each row's slot, in row order — where a mark is centred. */
+    categoryCenters: number[];
+    /** Width of a band. `0` where the rows are placed as points. */
+    bandwidth: number;
+    /** The x value of each row, in row order. */
+    xValues: ChartXValue[];
+    /** Rounded bounds of the value axis. */
+    domain: [number, number];
+    /** The rows the chart was given, untouched. */
+    data: readonly ChartDatum[];
+    /** The visible series, palette slots already resolved. */
+    series: readonly ChartResolvedSeries[];
+    /** The chart's own value formatter — a caption should read like its axis. */
+    formatValue: (value: number) => string;
+    /** The chart's own category formatter. */
+    formatX: (value: ChartXValue, index: number) => string;
+}
+/** Draws inside a chart's plot area, with the chart's own geometry. */
+type ChartOverlayRenderer = (context: ChartPlotContext) => ReactNode;
+/**
+ * What an application draws inside a chart.
+ *
+ * A bare function is drawn over the marks, which is what an extra label, a
+ * bracket or a custom threshold wants. The object form also reaches under
+ * them, for a region the data should sit on top of.
+ */
+type ChartOverlay = ChartOverlayRenderer | {
+    under?: ChartOverlayRenderer;
+    over?: ChartOverlayRenderer;
+};
+/**
+ * A window dragged across a chart's category axis.
+ *
+ * Both ends are inclusive, and both are given twice: as the x values a reader
+ * selected, and as the row indices they cover — filtering a dataset wants the
+ * indices, feeding a period picker wants the values.
+ */
+interface ChartBrushRange {
+    from: ChartXValue;
+    to: ChartXValue;
+    fromIndex: number;
+    toIndex: number;
+}
+/**
+ * What a panel carries besides its data.
+ *
+ * The three states are mutually exclusive and ranked: a chart that failed is
+ * not a chart that is empty, and a chart that is loading again is neither.
+ */
+interface ChartStatusProps {
+    /** Dims the plot while fresh data loads; a first load shows a spinner. */
+    loading?: boolean;
+    /** Replaces the "no data" message. */
+    emptyState?: ReactNode;
+    /**
+     * The data could not be loaded.
+     *
+     * Never the same thing as having none: a panel that says "no data" after a
+     * failed request states something false, and offers no way out.
+     */
+    error?: boolean;
+    /** Replaces the whole built-in error state, message and button included. */
+    errorState?: ReactNode;
+    /** Draws the retry button in the error state, and is called when pressed. */
+    onRetry?: () => void;
+    /**
+     * Slot on the right of the caption: an export button, a range picker.
+     *
+     * A filter that frames several panels belongs in a `ChartFilterBar` above
+     * all of them; this is for what belongs to *this* panel alone.
+     */
+    actions?: ReactNode;
+}
 /**
  * Props shared by every cartesian chart of the kit. Each chart adds its own
  * geometry on top — `curve` for lines, `stack` for areas and bars, and so on.
  */
-interface CartesianChartBaseProps {
+interface CartesianChartBaseProps extends ChartStatusProps {
     data: ChartDatum[];
     series: ChartSeries[];
     x: ChartXAxisConfig;
@@ -289,8 +432,8 @@ interface CartesianChartBaseProps {
     emphasis?: string;
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
+    /** Draws inside the plot, with the chart's own resolved geometry. */
+    overlay?: ChartOverlay;
     onPointClick?: (event: ChartPointEvent) => void;
     className?: string;
 }
@@ -317,7 +460,48 @@ interface AreaChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWit
     baseline?: number;
     connectNulls?: boolean;
     referenceLines?: ChartReferenceLine[];
+    /**
+     * What happened, drawn where it happened: a release, a campaign, an outage.
+     *
+     * The counterpart of `referenceLines`, which marks a threshold on the value
+     * axis. Bands are drawn under the areas, rules and pinned points over them.
+     */
+    annotations?: ChartAnnotation[];
+    /**
+     * Draws each band with a texture on top of its colour.
+     *
+     * The channel a reader falls back on when the hue fails them: severe colour
+     * vision deficiency, a grayscale print, a forced-colours theme. Off by
+     * default — it is an accessibility option, not a decoration.
+     *
+     * Only the bands of a stack take one. An overlay's fill is a 12% wash, thin
+     * enough that no texture survives it, and there the identity is carried by
+     * the edge line rather than by the surface under it.
+     */
+    patterns?: boolean;
     legendToggle?: boolean;
+    /**
+     * Thins the drawn bands to roughly this many points per series.
+     *
+     * Runs the path through LTTB, which keeps the peaks a stride sample walks
+     * straight past. Only the paths are thinned: the geometry, the crosshair,
+     * the tooltip and the data table keep reading every row. Left unset, a
+     * series past `CHART_POINT_BUDGET` warns once in development.
+     */
+    maxPoints?: number;
+    /**
+     * Lets a pointer drag a window across the category axis.
+     *
+     * Shift + arrows does the same from the keyboard, Escape drops it, and the
+     * window is published to the surrounding `ChartSyncProvider`.
+     */
+    brush?: boolean;
+    /** Called when a window is set, and with `null` when one is dropped. */
+    onBrush?: (range: ChartBrushRange | null) => void;
+    /** Accessible name of the selected window. */
+    brushLabel?: string;
+    /** `false` keeps the chart out of the surrounding `ChartSyncProvider`. */
+    sync?: boolean;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -333,7 +517,7 @@ interface AreaChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWit
  * bands, separated by 2px of the surface colour rather than by a border drawn
  * around each one.
  */
-declare function AreaChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, onPointClick, curve, stack, baseline, connectNulls, referenceLines, legendToggle, margin, locale, plotLabel, className, ...props }: AreaChartProps): react_jsx_runtime.JSX.Element;
+declare function AreaChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, error, errorState, onRetry, actions, onPointClick, curve, stack, baseline, connectNulls, referenceLines, annotations, overlay, patterns, legendToggle, maxPoints, brush, onBrush, brushLabel, sync, margin, locale, plotLabel, className, ...props }: AreaChartProps): react_jsx_runtime.JSX.Element;
 
 interface AvatarProps extends ComponentPropsWithoutRef<"div"> {
     src?: string;
@@ -362,14 +546,147 @@ declare namespace Badge {
     var displayName: string;
 }
 
+interface LinearScale {
+    /** Maps a value to a pixel position. */
+    (value: number): number;
+    /** Maps a pixel position back to a value. */
+    invert(pixel: number): number;
+    readonly domain: readonly [number, number];
+    readonly range: readonly [number, number];
+}
+
 /**
  * Which screen axis carries the values.
  *
- * `vertical` is the usual case — values run up the left side, categories along
- * the bottom. `horizontal` swaps them, which is what a bar chart does when its
- * category names are long enough to be unreadable rotated.
+ * The public spelling is `ChartOrientation`, declared beside the other types
+ * an application can see; this alias is what the engine has always called it.
  */
-type CartesianOrientation = "vertical" | "horizontal";
+type CartesianOrientation = ChartOrientation;
+/**
+ * How a row takes its place along the category axis.
+ *
+ * `point` spaces the rows evenly with the first and last on the edges, which
+ * is what a line or an area is plotted against. `band` gives each row a slot
+ * of its own, which is what a bar needs to have a width.
+ */
+type CategoryPlacement = "point" | "band";
+interface CartesianGeometryOptions {
+    /** Measured width of the plot area — never the `width` prop, which is usually unset. */
+    width: number;
+    height: number;
+    data: readonly ChartDatum[];
+    /** Describes the category axis, whichever side the orientation puts it on. */
+    x: ChartXAxisConfig;
+    /** Describes the value axis. */
+    y?: ChartYAxisConfig;
+    /**
+     * Bounds the value axis has to cover, before rounding.
+     *
+     * The caller computes them, because they are not always the extent of the
+     * raw values: a stacked chart measures its totals, not its series.
+     */
+    bounds: [number, number] | null;
+    margin?: Partial<ChartMargin>;
+    orientation?: CartesianOrientation;
+    placement?: CategoryPlacement;
+    /** Share of a band left empty between two neighbours. */
+    bandPaddingInner?: number;
+    formatValue: (value: number) => string;
+    formatX: (value: ChartXValue, index: number) => string;
+    /** Extra room at the top, for a caption drawn above the plot. */
+    extraTop?: number;
+    /**
+     * Whether zero stays inside the domain when the axis config does not say.
+     *
+     * A bar is read for the length of its mark, so it needs its baseline; a line
+     * is read for its slope, and forcing zero flattens the change.
+     */
+    defaultIncludeZero?: boolean;
+}
+interface CartesianGeometry {
+    margin: ChartMargin;
+    innerWidth: number;
+    innerHeight: number;
+    orientation: CartesianOrientation;
+    /** Maps a value to a pixel along the value axis. */
+    valueScale: LinearScale;
+    /** Rounded bounds of the value axis. */
+    domain: [number, number];
+    valueTicks: ChartTick[];
+    /** The x value of each row, in row order. */
+    xValues: ChartXValue[];
+    /** Where each row starts along the category axis. */
+    categoryPositions: number[];
+    /** Width of a band — `0` under a point placement. */
+    bandwidth: number;
+    /** Middle of a row's slot: where a tick, a line point or a hover lands. */
+    categoryCenters: number[];
+    categoryTicks: ChartTick[];
+    /** Length of the category axis in pixels. */
+    categoryLength: number;
+    /**
+     * The category axis as a continuous scale, when it is one.
+     *
+     * `null` for a list of categories, where a value that is not in the data
+     * has no position at all. It is what lets an overlay place a date the rows
+     * never carry — an annotation on the 14th of a weekly series.
+     */
+    categoryScale: LinearScale | null;
+}
+/**
+ * Everything a cartesian chart needs to place a mark, computed once.
+ *
+ * A pure function on purpose: it is the part of a chart that can be wrong in a
+ * way no rendering test would catch, and it is the part every cartesian chart
+ * of the kit shares. Line, area and bar differ in the mark they draw over this,
+ * not in how they lay it out.
+ *
+ * It speaks in value and category axes rather than x and y, because a
+ * horizontal bar chart swaps which screen axis carries which.
+ */
+declare function buildCartesianGeometry({ width, height, data, x, y, bounds, margin, orientation, placement, bandPaddingInner, formatValue, formatX, extraTop, defaultIncludeZero, }: CartesianGeometryOptions): CartesianGeometry;
+/**
+ * Where a raw x value lands on the category axis, in pixels.
+ *
+ * Two axes, one question. A continuous axis can place a value the data never
+ * carries, which is exactly what an annotation on an arbitrary date needs; a
+ * list of categories cannot, so a value it does not hold answers `null` and
+ * the caller skips the mark rather than drawing it on the edge.
+ *
+ * A position outside the plot answers `null` for the same reason: overlays are
+ * drawn without a clip path, and an out-of-window date would otherwise land in
+ * the axis gutter.
+ */
+declare function createCategoryLocator(geometry: Pick<CartesianGeometry, "categoryScale" | "xValues" | "categoryCenters" | "categoryLength">): (value: ChartXValue) => number | null;
+/**
+ * The resolved geometry of a plot, in the shape an application can draw with.
+ *
+ * The chart already holds every one of these; this only gathers them behind
+ * one type, so that `overlay` is a contract the kit can keep rather than a
+ * bag of whatever a chart happened to have in scope.
+ */
+declare function createPlotContext({ geometry, width, height, data, series, formatValue, formatX, }: {
+    geometry: CartesianGeometry;
+    /** Total width of the SVG, gutters included. */
+    width: number;
+    height: number;
+    data: readonly ChartDatum[];
+    /** The visible series only — an overlay should not draw a hidden one. */
+    series: readonly ChartResolvedSeries[];
+    formatValue: (value: number) => string;
+    formatX: (value: ChartXValue, index: number) => string;
+}): ChartPlotContext;
+/**
+ * An overlay in its two halves, whichever form it was given in.
+ *
+ * A bare function draws over the marks, which is what a label, a bracket or a
+ * custom threshold wants. Reaching under them is the rarer case and says so by
+ * taking the object form.
+ */
+declare function splitOverlay(overlay: ChartOverlay | undefined): {
+    under?: ChartOverlayRenderer;
+    over?: ChartOverlayRenderer;
+};
 
 /**
  * Binning, for the one chart that counts rather than reads a measure.
@@ -418,7 +735,7 @@ declare function binEdges(values: readonly number[], spec?: BinSpec): number[];
  */
 declare function binValues(values: readonly (number | null | undefined)[], spec?: BinSpec): HistogramBin[];
 
-/** Resets the histogram warning. Test helper. */
+/** Resets the one-shot warnings. Test helper. */
 declare function resetBarChartWarnings(): void;
 type BarChartOrientation = CartesianOrientation;
 interface BarChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWithoutRef<"figure">, keyof CartesianChartBaseProps | "children" | "title"> {
@@ -478,7 +795,42 @@ interface BarChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWith
     /** Draws the value at the end of each bar, where it fits without collision. */
     showValues?: boolean;
     referenceLines?: ChartReferenceLine[];
+    /**
+     * What happened, drawn where it happened: a release, a campaign, an outage.
+     *
+     * Read on the category axis, so a **vertical** chart alone takes them: the
+     * horizontal one runs its categories up the side, and a moment placed there
+     * is not a moment any more. They are ignored, with a warning, when the bars
+     * are laid out horizontally.
+     */
+    annotations?: ChartAnnotation[];
+    /**
+     * Draws each series with a texture on top of its colour.
+     *
+     * The channel a reader falls back on when the hue fails them: severe colour
+     * vision deficiency, a grayscale print, a forced-colours theme. Off by
+     * default — it is an accessibility option, not a decoration, and a textured
+     * chart nobody needs textured is just a busier chart.
+     *
+     * Ignored where the bars are painted by their own value (a lone series
+     * against a reference): the ramp measures a magnitude, and a texture can
+     * only say which series a mark belongs to.
+     */
+    patterns?: boolean;
     legendToggle?: boolean;
+    /**
+     * Lets a pointer drag a window across the category axis.
+     *
+     * Shift + arrows does the same from the keyboard, Escape drops it, and the
+     * window is published to the surrounding `ChartSyncProvider`.
+     */
+    brush?: boolean;
+    /** Called when a window is set, and with `null` when one is dropped. */
+    onBrush?: (range: ChartBrushRange | null) => void;
+    /** Accessible name of the selected window. */
+    brushLabel?: string;
+    /** `false` keeps the chart out of the surrounding `ChartSyncProvider`. */
+    sync?: boolean;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -494,7 +846,7 @@ interface BarChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWith
  * is read for the length of its mark, and an axis starting at 40 exaggerates
  * every difference on the chart.
  */
-declare function BarChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, onPointClick, orientation, stack, diverging, bins, curve, barSize, sort, showValues, referenceLines, legendToggle, margin, locale, plotLabel, className, ...props }: BarChartProps): react_jsx_runtime.JSX.Element;
+declare function BarChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, error, errorState, onRetry, actions, onPointClick, orientation, stack, diverging, bins, curve, barSize, sort, showValues, referenceLines, annotations, overlay, patterns, legendToggle, brush, onBrush, brushLabel, sync, margin, locale, plotLabel, className, ...props }: BarChartProps): react_jsx_runtime.JSX.Element;
 
 type BannerVariant = "notification" | "hero" | "promotion";
 type BannerType = "info" | "success" | "warning" | "error" | "default";
@@ -534,7 +886,7 @@ interface BreadcrumbProps extends ComponentPropsWithoutRef<"nav"> {
 }
 declare function Breadcrumb({ items, separator, size, maxItems, itemColor, activeColor, separatorColor, className, ...props }: BreadcrumbProps): react_jsx_runtime.JSX.Element;
 
-interface BulletChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface BulletChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per measure. */
     data: ChartDatum[];
     /** Field holding the name of each row. */
@@ -571,8 +923,6 @@ interface BulletChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "chi
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     locale?: string;
     plotLabel?: string;
     /** Header of the value column of the data table. */
@@ -609,7 +959,7 @@ interface BulletRow {
  * common axis to read across rows: pass `normalize="shared"` (or a `domain`)
  * when the rows carry the same unit, and the value axis comes back.
  */
-declare function BulletChart({ data, x, value, target, ranges, domain, normalize, showValues, trackSize, rangeColors, color, height, width, size, tooltip, tableView, title, description, loading, emptyState, locale, plotLabel, valueLabel, targetLabel, format, onRowClick, className, ...props }: BulletChartProps): react_jsx_runtime.JSX.Element;
+declare function BulletChart({ data, x, value, target, ranges, domain, normalize, showValues, trackSize, rangeColors, color, height, width, size, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, locale, plotLabel, valueLabel, targetLabel, format, onRowClick, className, ...props }: BulletChartProps): react_jsx_runtime.JSX.Element;
 
 interface ButtonProps extends ComponentPropsWithoutRef<"button"> {
     label?: string;
@@ -892,7 +1242,7 @@ interface BoxPlotBox {
     mean: number | null;
     datum: ChartDatum;
 }
-interface BoxPlotProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface BoxPlotProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per category compared. */
     data: ChartDatum[];
     /** Field holding the name of each category. */
@@ -942,8 +1292,6 @@ interface BoxPlotProps extends Omit<ComponentPropsWithoutRef<"figure">, "childre
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -968,7 +1316,7 @@ interface BoxPlotProps extends Omit<ComponentPropsWithoutRef<"figure">, "childre
  * with a panel each, which keeps them on a shared scale without asking the
  * reader to hold two colour legends at once.
  */
-declare function BoxPlot({ data, x, y, values, quantiles, whisker, orientation, boxSize, showOutliers, showMean, color, referenceLines, height, width, size, grid, tooltip, tableView, title, description, loading, emptyState, margin, locale, plotLabel, format, onBoxClick, className, ...props }: BoxPlotProps): react_jsx_runtime.JSX.Element;
+declare function BoxPlot({ data, x, y, values, quantiles, whisker, orientation, boxSize, showOutliers, showMean, color, referenceLines, height, width, size, grid, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, margin, locale, plotLabel, format, onBoxClick, className, ...props }: BoxPlotProps): react_jsx_runtime.JSX.Element;
 
 /** One session, as the tooltip and the click handler see it. */
 interface Candle {
@@ -985,7 +1333,7 @@ interface Candle {
     rising: boolean;
     datum: ChartDatum;
 }
-interface CandlestickChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface CandlestickChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per session. */
     data: ChartDatum[];
     /** Field holding the session's label — usually a date. */
@@ -1025,8 +1373,6 @@ interface CandlestickChartProps extends Omit<ComponentPropsWithoutRef<"figure">,
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -1057,7 +1403,7 @@ interface CandlestickChartProps extends Omit<ComponentPropsWithoutRef<"figure">,
  * its movement; a share worth 180 dollars read from zero is a flat band at
  * the top of the plot.
  */
-declare function CandlestickChart({ data, x, y, open, high, low, close, candleSize, fillRising, colors, referenceLines, height, width, size, grid, legend, tooltip, tableView, title, description, loading, emptyState, margin, locale, plotLabel, openLabel, highLabel, lowLabel, closeLabel, riseLabel, fallLabel, format, onCandleClick, className, ...props }: CandlestickChartProps): react_jsx_runtime.JSX.Element;
+declare function CandlestickChart({ data, x, y, open, high, low, close, candleSize, fillRising, colors, referenceLines, height, width, size, grid, legend, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, margin, locale, plotLabel, openLabel, highLabel, lowLabel, closeLabel, riseLabel, fallLabel, format, onCandleClick, className, ...props }: CandlestickChartProps): react_jsx_runtime.JSX.Element;
 
 /** Geometry handed to the render prop once the container has been measured. */
 interface ChartContainerRenderArgs {
@@ -1087,6 +1433,25 @@ interface ChartContainerProps extends Omit<ComponentPropsWithoutRef<"figure">, "
     /** The chart has nothing to draw. */
     empty?: boolean;
     emptyState?: ReactNode;
+    /**
+     * The data could not be loaded.
+     *
+     * Deliberately separate from `empty`: "there is nothing to show" and "we
+     * failed to fetch it" are two different statements, and a panel that says
+     * the first after a failed request is saying something false. Only this one
+     * offers a way out, through `onRetry`.
+     *
+     * A truthy `loading` wins over it, so a retry replaces the message with the
+     * spinner rather than leaving the reader wondering whether anything happened.
+     */
+    error?: boolean;
+    /** Replaces the whole built-in error state, message and button included. */
+    errorState?: ReactNode;
+    /** Draws the retry button, and is called when it is pressed. */
+    onRetry?: () => void;
+    errorLabel?: string;
+    errorHintLabel?: string;
+    retryLabel?: string;
     /** The data table twin, usually a `ChartTableView`. */
     table?: ReactNode;
     /** `true` keeps the table open, `"toggle"` puts it behind a button. */
@@ -1104,13 +1469,14 @@ interface ChartContainerProps extends Omit<ComponentPropsWithoutRef<"figure">, "
  * The frame every chart of the kit is drawn in.
  *
  * It owns what is identical from one chart to the next — measured width,
- * caption, legend slot, loading and empty states, and the data table toggle —
- * so that a chart component is left with its geometry and nothing else.
+ * caption, legend slot, the loading, empty and error states, and the data
+ * table toggle — so that a chart component is left with its geometry and
+ * nothing else.
  *
  * The plot area is a render prop: a chart cannot lay itself out before the
  * container has been measured.
  */
-declare function ChartContainer({ title, description, height, width: fixedWidth, size, legend, legendPosition, actions, loading, empty, emptyState, table, tableView, showTableLabel, hideTableLabel, noDataLabel, loadingLabel, ariaLabel, children, className, ...props }: ChartContainerProps): react_jsx_runtime.JSX.Element;
+declare function ChartContainer({ title, description, height, width: fixedWidth, size, legend, legendPosition, actions, loading, empty, emptyState, error, errorState, onRetry, errorLabel, errorHintLabel, retryLabel, table, tableView, showTableLabel, hideTableLabel, noDataLabel, loadingLabel, ariaLabel, children, className, ...props }: ChartContainerProps): react_jsx_runtime.JSX.Element;
 
 type ChartAxisOrientation = "bottom" | "left";
 interface ChartAxisProps extends Omit<ComponentPropsWithoutRef<"g">, "children"> {
@@ -1215,6 +1581,492 @@ interface ChartTooltipContentProps {
  */
 declare function ChartTooltipContent({ title, points }: ChartTooltipContentProps): react_jsx_runtime.JSX.Element;
 
+interface ChartAnnotationLayerProps {
+    annotations: readonly ChartAnnotation[];
+    /**
+     * Where an x value lands along the category axis, or `null` when it is not
+     * on the plot at all — an annotation for a date outside the window is
+     * skipped rather than drawn on the edge.
+     */
+    xAt: (value: ChartXValue) => number | null;
+    /** Where a value lands along the value axis. */
+    yAt: (value: number) => number;
+    /** Size of the plot area. */
+    width: number;
+    height: number;
+    /**
+     * Width of a band on the category axis, `0` on a point placement.
+     *
+     * A band annotation covers whole categories, so it reaches half a band past
+     * the centres its ends resolve to — otherwise "March to May" is drawn from
+     * the middle of March to the middle of May.
+     */
+    bandwidth?: number;
+    /**
+     * Which half of the layer to draw.
+     *
+     * `under` holds the bands and goes below the marks — a region the data sits
+     * in, not over it. `over` holds the rules and the pinned points, which are
+     * worthless hidden behind an area. A chart renders the component twice, once
+     * on each side of its series.
+     */
+    layer?: "under" | "over";
+}
+/**
+ * The annotation layer: what happened, drawn where it happened.
+ *
+ * Laid out behind the marks for the bands and over them for the lines and the
+ * points. A band is a region the data sits in and belongs under it; a line is
+ * a boundary and is worthless hidden behind an area.
+ *
+ * Everything here is chrome by default — grey, thin, dashed. An annotation
+ * that draws the eye more strongly than the data has become the chart.
+ */
+declare function ChartAnnotationLayer({ annotations, xAt, yAt, width, height, bandwidth, layer, }: ChartAnnotationLayerProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * The annotations, as one sentence for the chart's accessible name.
+ *
+ * An SVG marked `role="img"` exposes its name and nothing inside it, so a
+ * caption drawn on the plot is invisible to a screen reader. The comments are
+ * half of what an annotated chart says, so they are appended to the name the
+ * chart already carries rather than left on the picture alone.
+ */
+declare function describeAnnotations(annotations: readonly ChartAnnotation[] | undefined, prefix: string): string;
+
+interface ChartBrushLayerProps {
+    /** Where the window starts and ends along the category axis, in pixels. */
+    from: number;
+    to: number;
+    /** Size of the drawing area. */
+    width: number;
+    height: number;
+    /** Which screen axis the categories run along. */
+    orientation?: ChartOrientation;
+    /** Dashed while the pointer is still down, solid once the window is set. */
+    live?: boolean;
+    /** Names the region for assistive technology. */
+    label?: string;
+}
+/**
+ * The window a reader selected, drawn across the plot.
+ *
+ * Both edges are drawn as rules rather than left to the wash alone: the ends
+ * of the window are the part a reader checks, and the boundary of a 14%
+ * translucent band is not a line anybody can point at.
+ */
+declare function ChartBrushLayer({ from, to, width, height, orientation, live, label, }: ChartBrushLayerProps): react_jsx_runtime.JSX.Element | null;
+interface UseChartBrushOptions {
+    /** `false` leaves every handler a no-op, so a chart can wire them anyway. */
+    enabled: boolean;
+    /**
+     * Whether a window is currently set.
+     *
+     * A press that goes nowhere drops the window — otherwise a reader who has
+     * brushed once has no way back but to brush again. Without knowing there is
+     * one to drop, every ordinary click would fire a `null` nobody asked for.
+     */
+    active: boolean;
+    /** Middle of each row's slot along the category axis, in pixels. */
+    centers: readonly number[];
+    /** The x value of each row, in row order. */
+    xValues: readonly ChartXValue[];
+    /** Offset of the drawing area inside the SVG, on the axis the drag runs along. */
+    offset: number;
+    orientation: ChartOrientation;
+    /** Called when a window is set, and with `null` when one is dropped. */
+    onCommit: (range: ChartBrushRange | null) => void;
+}
+interface UseChartBrushResult {
+    /** The window being dragged right now, or `null`. */
+    dragging: ChartBrushRange | null;
+    onPointerDown: (event: PointerEvent<SVGSVGElement>) => void;
+    onPointerMove: (event: PointerEvent<SVGSVGElement>) => void;
+    onPointerUp: (event: PointerEvent<SVGSVGElement>) => void;
+    /**
+     * Shift + arrows to extend the window, Escape to drop it.
+     *
+     * Never consumes the key: the chart's own handler still moves its crosshair
+     * on the same press, which is what keeps the window's head and the focused
+     * position in step. Keyboard parity is not optional here — a filter that can
+     * only be set by dragging is a filter half the readers cannot reach.
+     */
+    onKeyDown: (event: KeyboardEvent<SVGSVGElement>, focusedIndex: number | null) => void;
+    /** `true` when the press that just ended was a drag, not a click. */
+    consumedClick: () => boolean;
+}
+/**
+ * Dragging a window across a chart's category axis.
+ *
+ * The gesture the whole of `ChartSyncProvider` exists for: a reader pulls a
+ * fortnight on the line and the dashboard is read over that fortnight. It has
+ * to live in the plot rather than in a strip of its own, because the range
+ * being chosen is a range *of the data on screen* — a second miniature chart
+ * under the first would be a different picture to aim at.
+ */
+declare function useChartBrush({ enabled, active, centers, xValues, offset, orientation, onCommit, }: UseChartBrushOptions): UseChartBrushResult;
+
+/**
+ * The periods a dashboard is read over, resolved to real dates.
+ *
+ * Pure functions on purpose: "the last 30 days" is the kind of thing that is
+ * wrong by one day for a month before anybody notices, and it is much easier
+ * to pin down here than through a rendered picker.
+ */
+/** The windows a filter row offers by name. */
+type ChartPeriodPreset = "7d" | "30d" | "90d" | "12m" | "mtd" | "qtd" | "ytd" | "custom";
+/** A resolved window: where it came from, and the two dates it covers. */
+interface ChartPeriod {
+    /** The entry that produced it. `custom` when the dates were picked by hand. */
+    preset: ChartPeriodPreset;
+    from: Date;
+    to: Date;
+}
+/** The presets a picker offers when it is not told otherwise. */
+declare const DEFAULT_CHART_PERIOD_PRESETS: readonly ChartPeriodPreset[];
+/** Midnight at the start of a day, in the reader's own time zone. */
+declare function startOfDay(date: Date): Date;
+/**
+ * The last millisecond of a day.
+ *
+ * A window ending at midnight drops everything that happened during its last
+ * day — the single most common off-by-one in a dashboard.
+ */
+declare function endOfDay(date: Date): Date;
+/**
+ * Resolves a named window against a reference moment.
+ *
+ * "The last 7 days" counts today as one of them, which is what a reader
+ * expects from a figure that includes what happened this morning.
+ */
+declare function resolvePeriodPreset(preset: ChartPeriodPreset, now?: Date): {
+    from: Date;
+    to: Date;
+};
+/** A named window, resolved into the period a chart is filtered by. */
+declare function createPeriod(preset: ChartPeriodPreset, now?: Date): ChartPeriod;
+/**
+ * The two ends of a window as one string.
+ *
+ * `formatRange` is what a locale expects here — it collapses the parts the two
+ * dates share ("1 – 15 March 2026" rather than twice the month and the year).
+ */
+declare function formatPeriodRange(from: Date, to: Date, locale?: string): string;
+/** `true` when two periods cover the same window, to the millisecond. */
+declare function samePeriod(a: ChartPeriod | undefined, b: ChartPeriod | undefined): boolean;
+
+/** What every panel of a synchronised group can see and change. */
+interface ChartSyncContextValue {
+    /** The position under the pointer, in whichever panel the pointer is in. */
+    hovered: ChartXValue | null;
+    /** The window dragged on any panel of the group. */
+    brush: ChartBrushRange | null;
+    /** `false` when the group was told not to share the pointer. */
+    hoverShared: boolean;
+    setHovered: (value: ChartXValue | null) => void;
+    setBrush: (range: ChartBrushRange | null) => void;
+}
+/**
+ * The group a chart belongs to, or `null` when it stands alone.
+ *
+ * Public because the two things a group carries — where the pointer is, and
+ * what window is selected — are exactly what a panel that is *not* a chart
+ * needs to stay in step: a legend, a figure beside the row, a table.
+ */
+declare function useChartSync(): ChartSyncContextValue | null;
+interface ChartSyncProviderProps {
+    children: ReactNode;
+    /**
+     * Shares the hovered position between the panels.
+     *
+     * The pointer draws a crosshair in every panel and a tooltip in one: four
+     * tooltips at once is four things to read and no answer.
+     */
+    hover?: boolean;
+    /** Controlled selection. Leave unset to let the group hold its own. */
+    brush?: ChartBrushRange | null;
+    /** Starting selection of an uncontrolled group. */
+    defaultBrush?: ChartBrushRange | null;
+    /** Called whenever a panel commits a dragged window, or clears it with `null`. */
+    onBrushChange?: (range: ChartBrushRange | null) => void;
+}
+/**
+ * Several charts read as one object rather than as a row of pictures.
+ *
+ * `ChartFilterBar` made a dashboard a **frame**: one row of filters above
+ * panels that therefore answer the same question. This makes it an **object**:
+ * the pointer lands on a moment in one panel and every other panel marks the
+ * same moment, and a window dragged on one is the window all of them show.
+ *
+ * Nothing is drawn here. The provider holds the two pieces of state a group
+ * shares and hands them to whichever panels are inside it; a chart opts out
+ * with `sync={false}`.
+ *
+ * ```tsx
+ * const [period, setPeriod] = useState(() => createPeriod("30d"));
+ *
+ * <ChartSyncProvider onBrushChange={(range) => range && setPeriod(brushToPeriod(range))}>
+ *   <ChartFilterBar>
+ *     <ChartPeriodPicker value={period} onChange={setPeriod} />
+ *   </ChartFilterBar>
+ *   <LineChart brush data={rows} … />
+ *   <BarChart data={rows} … />
+ * </ChartSyncProvider>
+ * ```
+ */
+declare function ChartSyncProvider({ children, hover, brush, defaultBrush, onBrushChange, }: ChartSyncProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * A dragged window, as the period a filter row is set to.
+ *
+ * The point of brushing: a reader drags a fortnight on the line and the
+ * dashboard is now read over that fortnight. Both ends are widened to whole
+ * days, the way `ChartPeriodPicker` resolves its own presets — a window ending
+ * at midnight drops its own last day.
+ *
+ * Answers `null` when the axis that was brushed carries no date at all. It
+ * cannot tell a timestamp from any other number, though — a time axis stores
+ * its values as numbers, and so does a linear one. Call it on a chart whose x
+ * axis carries dates; on any other the window it returns is arithmetic rather
+ * than a period.
+ */
+declare function brushToPeriod(range: ChartBrushRange): ChartPeriod | null;
+
+/**
+ * What a chart hands to a file.
+ *
+ * The same rows its data table draws, which is the point: `DataGrid` has
+ * exported CSV and JSON since it shipped, and a chart holds an exact table of
+ * its own already. Every value a reader can see is a value they can take away.
+ */
+interface ChartExportOptions {
+    data: readonly ChartDatum[];
+    series: readonly ChartSeries[];
+    /** Field the rows are keyed on — the chart's x axis. */
+    xKey: string;
+    /** Header of the first column. Defaults to `xKey`. */
+    xLabel?: string;
+    /**
+     * Formats the category of each row.
+     *
+     * Only the category: the measurements are written raw on purpose. A
+     * spreadsheet is going to compute on them, and `1 234,5 €` is a string.
+     */
+    formatX?: (value: ChartXValue, index: number) => string;
+}
+/** One exported row: the category, then one column per visible series. */
+type ChartExportRow = Record<string, string | number | null>;
+/** The chart's rows, in the shape a file wants: one object per row. */
+declare function toChartRows({ data, series, xKey, xLabel, formatX, }: ChartExportOptions): ChartExportRow[];
+/** The chart's data table as a CSV document. */
+declare function toChartCsv(options: ChartExportOptions, delimiter?: string): string;
+/** The chart's data table as a JSON document. */
+declare function toChartJson(options: ChartExportOptions): string;
+type ChartExportFormat = "csv" | "json";
+/**
+ * Hands the chart's rows to the browser as a file.
+ *
+ * Does nothing outside a browser rather than throwing: a chart is rendered on
+ * the server too, and a download is the one thing that cannot happen there.
+ */
+declare function downloadChartData(format: ChartExportFormat, options: ChartExportOptions, filename?: string): void;
+
+interface ChartExportButtonProps extends ChartExportOptions {
+    className?: string;
+    disabled?: boolean;
+    /** Which files to offer, in the order they are listed. */
+    formats?: readonly ChartExportFormat[];
+    /** Name of the downloaded file, without its extension. */
+    filename?: string;
+    size?: ChartSize;
+    /** Replaces the default caption — the translated "Export". */
+    label?: string;
+    /**
+     * Runs instead of the download.
+     *
+     * For an application that already owns its own export — a server-side
+     * report, a file named by the current filters — and only wants the control
+     * and the rows.
+     */
+    onExport?: (format: ChartExportFormat, options: ChartExportOptions) => void;
+}
+/**
+ * The chart's own table, as a file.
+ *
+ * The small gap the chart kit carried from the start: `DataGrid` exports CSV
+ * and JSON, and a chart holds an exact table of the very same shape without
+ * ever offering it. A reader who can see a number should be able to take it.
+ *
+ * A component rather than a prop on thirteen charts, because it belongs where
+ * the other controls already are — the `actions` slot of a `ChartContainer`,
+ * or of the `ChartFilterBar` above a whole dashboard.
+ *
+ * ```tsx
+ * <LineChart
+ *   data={rows}
+ *   series={series}
+ *   x={{ key: "month" }}
+ *   actions={<ChartExportButton data={rows} series={series} xKey="month" />}
+ * />
+ * ```
+ *
+ * The measurements are written raw, not formatted: whatever opens the file is
+ * going to compute on them.
+ */
+declare function ChartExportButton({ data, series, xKey, xLabel, formatX, formats, filename, size, label, onExport, className, disabled, }: ChartExportButtonProps): react_jsx_runtime.JSX.Element;
+
+interface PathPoint {
+    x: number;
+    y: number;
+    /** `false` marks a gap: the line breaks instead of crossing it. */
+    defined?: boolean;
+}
+
+/**
+ * How many points per series the kit draws before it starts warning.
+ *
+ * The figure is a measurement, not a taste: past roughly this many points a
+ * `d` attribute stops being a path and becomes a string the browser reparses
+ * on every re-render, and two neighbouring points land on the same pixel
+ * column anyway — the reader gains nothing for the cost.
+ *
+ * Nothing is dropped on its own when a series crosses it. A chart that quietly
+ * drew a different shape than the one it was handed would be worse than a slow
+ * one; the warning says what to pass instead.
+ */
+declare const CHART_POINT_BUDGET = 2000;
+/** Lets a test watch the warning fire more than once. */
+declare function resetPointBudgetWarning(): void;
+/** A point the decimation can reason about: a position and a measurement. */
+interface XY {
+    x: number;
+    y: number;
+}
+/**
+ * Largest-Triangle-Three-Buckets, returning the indices it keeps.
+ *
+ * The classic downsampling for a line: the series is cut into as many buckets
+ * as there is room for, and each bucket keeps the one point forming the
+ * largest triangle with the point already kept before it and the average of
+ * the bucket after it. Picking the largest triangle is what keeps the peaks —
+ * a stride sample walks straight past them, which is how a decimated series
+ * ends up flatter than the data it came from.
+ *
+ * Indices rather than points, so a caller can carry along whatever the point
+ * belonged to: a row, a screen coordinate, a tooltip payload.
+ */
+declare function lttb(points: readonly XY[], threshold: number): number[];
+/**
+ * An evenly spread sample, keeping the two ends.
+ *
+ * What an unordered cloud needs, where LTTB is the wrong tool: a scatter is
+ * read for where its points are dense, and keeping the largest triangles would
+ * carve out the envelope and throw the density away — a lie about the very
+ * thing the chart is for. An even stride keeps the shape of the cloud and
+ * thins it uniformly.
+ *
+ * Deterministic on purpose, rather than a random sample: the same data has to
+ * draw the same picture on the server and in the browser.
+ */
+declare function sampleEvenly<T>(items: readonly T[], threshold: number): T[];
+/**
+ * The rows a drawn path keeps, thinned to roughly `maxPoints` per series.
+ *
+ * Indices rather than points, because a band needs its top and its bottom
+ * thinned on the very same rows: thin them apart and the fill between them
+ * closes on two points that never faced each other.
+ *
+ * The gaps are structural and survive: a run of missing measurements is not
+ * noise to be smoothed away, it is the series saying it has nothing there.
+ * Each run of gaps keeps one row — enough for the path to lift the pen —
+ * and the defined runs between them share the budget in proportion to their
+ * length.
+ */
+declare function decimateIndices(points: readonly PathPoint[], maxPoints: number): number[];
+/**
+ * A drawn path, thinned to roughly `maxPoints` points per series.
+ *
+ * The chart's geometry is untouched — the hover, the crosshair, the tooltip
+ * and the data table all keep reading every row. Only the number of points the
+ * path is *drawn from* changes, which is the part that actually costs.
+ */
+declare function decimatePath(points: readonly PathPoint[], maxPoints: number): PathPoint[];
+
+/**
+ * The colour a texture is cut through — the chart surface itself.
+ *
+ * Declared in `src/styles/index.css` under both theme scopes, so a stripe is
+ * white on a white panel and gray-800 on a dark one without a component ever
+ * asking which theme is on.
+ */
+declare const CHART_SURFACE_COLOR = "var(--color-chart-surface)";
+/**
+ * The textures, in the order they are handed out.
+ *
+ * One per palette slot, and assigned the same way: by the series' position in
+ * `series`, never by its rank. Hiding a series repaints nothing, and the
+ * texture a reader learnt in the legend is still the one on the plot.
+ *
+ * Every hatch runs at 45° or its mirror at 135°, never horizontal and never
+ * vertical: those two align with the gridlines and with the edges of the
+ * marks, where they read as part of the chrome rather than as a fill. The
+ * first slot is left solid — an untextured mark is itself a texture, and the
+ * easiest of all to tell apart.
+ */
+declare const CHART_PATTERNS: readonly ["solid", "diagonal", "diagonal-reverse", "cross", "dots", "diagonal-wide", "diagonal-reverse-wide", "dots-wide"];
+type ChartPattern = (typeof CHART_PATTERNS)[number];
+/** The texture at `index`, wrapping around once past the last one. */
+declare function getPattern(index: number): ChartPattern;
+/**
+ * Id of the SVG pattern a chart declared for its `index`-th series.
+ *
+ * The base is stripped down to id characters: `useId` returns `:r0:` on React
+ * 18, and a fill pointing at `url(#:r0:-texture-1)` is a fragment reference
+ * browsers are not obliged to resolve.
+ */
+declare function patternId(baseId: string, index: number): string;
+/**
+ * The fill a mark wears.
+ *
+ * The texture when they are on and the slot has one, the flat colour
+ * otherwise — so a chart calls this once and never branches itself.
+ */
+declare function patternFill(enabled: boolean, baseId: string, index: number, color: string): string;
+/** One texture to declare: the slot it belongs to, and the colour it paints. */
+interface ChartPatternEntry {
+    /** Palette slot of the mark — what `patternFill` is called with. */
+    slot: number;
+    color: string;
+}
+interface ChartPatternDefsProps {
+    /** Unique per chart instance — a `useId()`, so two charts never collide. */
+    id: string;
+    /**
+     * The marks to declare a texture for.
+     *
+     * Keyed by slot rather than by position: a pie sorts its slices and a bar
+     * chart hides some of its series, and in both the texture has to keep
+     * following the identity it was handed out to.
+     */
+    entries: readonly ChartPatternEntry[];
+}
+/**
+ * The `<defs>` block holding one texture per series.
+ *
+ * A mark keeps its colour at full strength and the texture is *cut out* of it
+ * in the surface colour, rather than painted over a washed-down fill: a
+ * stacked band has to read as a quantity, and a fill dimmed to make room for
+ * stripes stops doing that.
+ */
+declare function ChartPatternDefs({ id, entries }: ChartPatternDefsProps): react_jsx_runtime.JSX.Element;
+/**
+ * The same texture, in CSS, for the HTML swatch of a legend.
+ *
+ * The legend and the plot have to carry the same two channels, or the texture
+ * becomes noise the reader cannot map onto anything. A gradient reproduces the
+ * SVG tile closely enough at swatch size, and it flips with the theme through
+ * the same surface variable.
+ */
+declare function patternBackground(index: number, color: string): CSSProperties;
+
 /**
  * Number of categorical slots the palette holds.
  *
@@ -1258,8 +2110,14 @@ declare function getSeriesColor(index: number, override?: string): string;
 declare function resolveSeriesColor(series: ChartSeries, index: number, emphasis?: string): string;
 /** Label shown for a series — its own, or its key as a fallback. */
 declare function getSeriesLabel(series: ChartSeries): string;
-/** Builds the legend entries of a series list, colours already resolved. */
-declare function toLegendItems(series: ChartSeries[], emphasis?: string): ChartLegendItem[];
+/**
+ * Builds the legend entries of a series list, colours already resolved.
+ *
+ * `patterns` mirrors the chart's own setting: when the marks are textured the
+ * swatches have to be too, since the texture is the channel a reader falls
+ * back on when the hue fails them.
+ */
+declare function toLegendItems(series: ChartSeries[], emphasis?: string, patterns?: boolean): ChartLegendItem[];
 /** One hue, light to dark: a continuous magnitude (a heat map). */
 declare const CHART_SEQUENTIAL_COLORS: readonly ["var(--color-chart-seq-1)", "var(--color-chart-seq-2)", "var(--color-chart-seq-3)", "var(--color-chart-seq-4)", "var(--color-chart-seq-5)", "var(--color-chart-seq-6)"];
 /** One hue in ordered steps: ranked bands, brackets, a funnel. */
@@ -1488,6 +2346,91 @@ declare function ChartFacets({ data, by, values, domain, includeZero, ticks, ord
 /** Resets the one-shot panel-count warning. Test helper. */
 declare function resetFacetWarnings(): void;
 
+interface ChartFilterBarProps extends Omit<ComponentPropsWithoutRef<"div">, "title"> {
+    /** Names the row for assistive technology. Defaults to the translated "Filters". */
+    label?: string;
+    /** Pushed to the far end of the row: an export, a refresh, a saved view. */
+    actions?: ReactNode;
+    /** Keeps the row on screen while a long dashboard scrolls under it. */
+    sticky?: boolean;
+    /** The rule under the row, which is what makes it read as a frame. */
+    bordered?: boolean;
+    size?: ChartSize;
+    children: ReactNode;
+}
+/**
+ * The filters, in one row above everything they frame.
+ *
+ * Not a chart and barely a component — a rule written down as a layout. A
+ * dashboard filtered per card is a dashboard whose numbers stop agreeing: two
+ * panels answer two questions and nothing on screen says so. One row, above
+ * the charts, applying to all of them, is the only arrangement where a reader
+ * can trust that two figures are comparable.
+ *
+ * It composes what the library already has — `ChartPeriodPicker` for the
+ * window, `Select` and `Dropdown` for the dimensions — rather than growing
+ * controls of its own.
+ *
+ * ```tsx
+ * <ChartFilterBar actions={<Button size="sm">Export</Button>}>
+ *   <ChartPeriodPicker value={period} onChange={setPeriod} />
+ *   <Select size="sm" options={regions} value={region} onValueChange={setRegion} />
+ * </ChartFilterBar>
+ * ```
+ */
+declare function ChartFilterBar({ label, actions, sticky, bordered, size, children, className, ...props }: ChartFilterBarProps): react_jsx_runtime.JSX.Element;
+
+interface ChartPeriodPickerProps extends Omit<ComponentPropsWithoutRef<"button">, "value" | "defaultValue" | "onChange" | "children"> {
+    /** Controlled window. */
+    value?: ChartPeriod;
+    /** Uncontrolled starting window — a resolved period, or a preset to resolve. */
+    defaultValue?: ChartPeriod | ChartPeriodPreset;
+    onChange?: (period: ChartPeriod) => void;
+    /** Which windows to offer, in the order they are listed. */
+    presets?: readonly ChartPeriodPreset[];
+    /** Offers the calendar, for a window the presets do not cover. */
+    custom?: boolean;
+    /** Overrides a preset's caption, without going through the labels provider. */
+    presetLabels?: Partial<Record<ChartPeriodPreset, string>>;
+    /**
+     * The moment the presets are measured from.
+     *
+     * Injected by a test, and by an application that freezes "today" — a report
+     * generated at 3am must not silently change window at midnight.
+     */
+    now?: Date;
+    /** Bounds of the calendar. A dashboard usually caps it at today. */
+    minDate?: Date;
+    maxDate?: Date;
+    /** Number of months shown side by side by the calendar. */
+    numberOfMonths?: number;
+    weekStartsOn?: CalendarWeekStart;
+    locale?: string;
+    size?: ChartSize;
+    /** Which end of the trigger the panel lines up with. */
+    align?: "start" | "end";
+    disabled?: boolean;
+    /** Names the control when the default "Period" is not specific enough. */
+    label?: string;
+}
+/**
+ * The window a dashboard is read over.
+ *
+ * The one filter every dashboard has, and the one the library was missing:
+ * `Calendar` picks a date and hands it back, which is a different job. This
+ * picks a *period*, offers the windows people actually ask for by name, and
+ * falls back to the calendar for the rest.
+ *
+ * It belongs in a `ChartFilterBar` with the other filters, above the charts
+ * and never inside one of them — a period picked per card is how two panels
+ * end up answering two questions without saying so.
+ *
+ * The presets are resolved against `now` rather than against a clock read
+ * somewhere inside: a window is data, and data a component makes up on its own
+ * cannot be tested, frozen or shared between two charts.
+ */
+declare function ChartPeriodPicker({ value, defaultValue, onChange, presets, custom, presetLabels, now, minDate, maxDate, numberOfMonths, weekStartsOn, locale, size, align, disabled, label, className, ...props }: ChartPeriodPickerProps): react_jsx_runtime.JSX.Element;
+
 /**
  * Width a chart draws at before its container has been measured.
  *
@@ -1576,7 +2519,7 @@ interface DumbbellRow {
     change: number | null;
     datum: ChartDatum;
 }
-interface DumbbellChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface DumbbellChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per item compared. */
     data: ChartDatum[];
     /** Field holding the name of each row. */
@@ -1615,8 +2558,6 @@ interface DumbbellChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "c
     showChange?: boolean;
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -1642,7 +2583,7 @@ interface DumbbellChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "c
  * `sort="gap"` is what turns the chart from a list into a finding: the rows
  * that moved most come to the top.
  */
-declare function DumbbellChart({ data, x, y, series, sort, sortBy, showValues, dotSize, referenceLines, height, width, size, grid, legend, legendToggle, tooltip, tableView, showChange, title, description, loading, emptyState, margin, locale, plotLabel, changeLabel, format, onRowClick, className, ...props }: DumbbellChartProps): react_jsx_runtime.JSX.Element;
+declare function DumbbellChart({ data, x, y, series, sort, sortBy, showValues, dotSize, referenceLines, height, width, size, grid, legend, legendToggle, tooltip, tableView, showChange, title, description, loading, emptyState, error, errorState, onRetry, actions, margin, locale, plotLabel, changeLabel, format, onRowClick, className, ...props }: DumbbellChartProps): react_jsx_runtime.JSX.Element;
 
 /** One stage, as the tooltip and the click handler see it. */
 interface FunnelStage {
@@ -1659,7 +2600,7 @@ interface FunnelStage {
     formattedValue: string;
     datum: ChartDatum;
 }
-interface FunnelChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface FunnelChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per stage, in the order they are walked. */
     data: ChartDatum[];
     /** Field holding the name of each stage. */
@@ -1695,8 +2636,6 @@ interface FunnelChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "chi
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     locale?: string;
     plotLabel?: string;
     /** Header of the value column of the data table. */
@@ -1725,7 +2664,7 @@ interface FunnelChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "chi
  * Use it for a path people walk in one direction. Stages that are not ordered
  * are a `BarChart`, and a breakdown of one total is a `PieChart`.
  */
-declare function FunnelChart({ data, x, value, align, showConversion, showValues, stageSize, colors, height, width, size, tooltip, tableView, title, description, loading, emptyState, locale, plotLabel, valueLabel, conversionLabel, dropOffLabel, format, onStageClick, className, ...props }: FunnelChartProps): react_jsx_runtime.JSX.Element;
+declare function FunnelChart({ data, x, value, align, showConversion, showValues, stageSize, colors, height, width, size, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, locale, plotLabel, valueLabel, conversionLabel, dropOffLabel, format, onStageClick, className, ...props }: FunnelChartProps): react_jsx_runtime.JSX.Element;
 
 /** One task, as the tooltip and the click handler see it. */
 interface GanttTask {
@@ -1748,7 +2687,7 @@ interface GanttTask {
     group: string | null;
     datum: ChartDatum;
 }
-interface GanttChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface GanttChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per task, in the order they are listed. */
     data: ChartDatum[];
     /** Field holding the name of each task. */
@@ -1794,8 +2733,6 @@ interface GanttChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "chil
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -1823,7 +2760,7 @@ interface GanttChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "chil
  * month — rather than on round numbers of milliseconds, which is what a
  * decimal tick generator produces when it is pointed at a date.
  */
-declare function GanttChart({ data, x, start, end, id, progress, milestone, dependencies, group, domain, today, ticks, barSize, rowSize, color, height, width, size, grid, legend, tooltip, tableView, title, description, loading, emptyState, margin, locale, plotLabel, startLabel, endLabel, progressLabel, todayLabel, formatDate, onTaskClick, className, ...props }: GanttChartProps): react_jsx_runtime.JSX.Element;
+declare function GanttChart({ data, x, start, end, id, progress, milestone, dependencies, group, domain, today, ticks, barSize, rowSize, color, height, width, size, grid, legend, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, margin, locale, plotLabel, startLabel, endLabel, progressLabel, todayLabel, formatDate, onTaskClick, className, ...props }: GanttChartProps): react_jsx_runtime.JSX.Element;
 
 /** What a step does to the running total. */
 type WaterfallKind = "increase" | "decrease" | "total";
@@ -1844,7 +2781,7 @@ interface WaterfallStep {
     formattedEnd: string;
     datum: ChartDatum;
 }
-interface WaterfallChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface WaterfallChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per step, in the order they are read. */
     data: ChartDatum[];
     /** Field holding the name of each step. */
@@ -1896,8 +2833,6 @@ interface WaterfallChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -1926,7 +2861,7 @@ interface WaterfallChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "
  * The order of the rows IS the chart, so there is no `sort`: reordering the
  * steps of a waterfall produces a different, and usually false, story.
  */
-declare function WaterfallChart({ data, x, y, value, total, start, orientation, connectors, showValues, barSize, colors, height, width, size, grid, legend, tooltip, tableView, title, description, loading, emptyState, margin, locale, plotLabel, valueLabel, totalLabel, increaseLabel, decreaseLabel, format, onStepClick, className, ...props }: WaterfallChartProps): react_jsx_runtime.JSX.Element;
+declare function WaterfallChart({ data, x, y, value, total, start, orientation, connectors, showValues, barSize, colors, height, width, size, grid, legend, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, margin, locale, plotLabel, valueLabel, totalLabel, increaseLabel, decreaseLabel, format, onStepClick, className, ...props }: WaterfallChartProps): react_jsx_runtime.JSX.Element;
 
 interface CheckboxProps extends Omit<ComponentPropsWithoutRef<"input">, "size" | "onChange" | "type"> {
     checked?: boolean;
@@ -2924,7 +3859,7 @@ declare namespace Label {
     var displayName: string;
 }
 
-interface HeatmapProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface HeatmapProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     /** One row per cell: its column, its row and its value. */
     data: ChartDatum[];
     /** Field holding the column each cell belongs to. */
@@ -2971,8 +3906,6 @@ interface HeatmapProps extends Omit<ComponentPropsWithoutRef<"figure">, "childre
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
     locale?: string;
     plotLabel?: string;
     onCellClick?: (cell: HeatmapCell) => void;
@@ -3002,7 +3935,7 @@ interface HeatmapCell {
  * neighbouring cells stop being tellable apart, and a fine grid is read as a
  * wash anyway.
  */
-declare function Heatmap({ data, x, y, value, format, domain, scale, center, steps, colors, xDomain, yDomain, cellGap, cellRadius, showValues, height, width, size, legend, legendLabel, tooltip, tableView, title, description, loading, emptyState, locale, plotLabel, onCellClick, className, ...props }: HeatmapProps): react_jsx_runtime.JSX.Element;
+declare function Heatmap({ data, x, y, value, format, domain, scale, center, steps, colors, xDomain, yDomain, cellGap, cellRadius, showValues, height, width, size, legend, legendLabel, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, locale, plotLabel, onCellClick, className, ...props }: HeatmapProps): react_jsx_runtime.JSX.Element;
 
 interface LineChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWithoutRef<"figure">, keyof CartesianChartBaseProps | "children" | "title"> {
     curve?: ChartCurve;
@@ -3020,8 +3953,53 @@ interface LineChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWit
     /** Draws through the gaps instead of breaking the line. */
     connectNulls?: boolean;
     referenceLines?: ChartReferenceLine[];
+    /**
+     * What happened, drawn where it happened: a release, a campaign, an outage.
+     *
+     * The counterpart of `referenceLines`, which marks a threshold on the value
+     * axis. A spike nobody explained is a question rather than an answer, and
+     * the explanation almost always sits on the time axis.
+     *
+     * The captions are appended to the chart's accessible name, since an SVG
+     * exposes nothing drawn inside it.
+     */
+    annotations?: ChartAnnotation[];
     /** Lets the legend show and hide series. */
     legendToggle?: boolean;
+    /**
+     * Thins the drawn path to roughly this many points per series.
+     *
+     * A series of fifty thousand rows builds a `d` attribute of fifty thousand
+     * coordinates, most of which land on a pixel column another one already
+     * covers. This runs the points through LTTB, which keeps the peaks a stride
+     * sample walks straight past.
+     *
+     * Only the *path* is thinned. The geometry, the crosshair, the tooltip and
+     * the data table keep reading every row, so no value stops being reachable —
+     * the chart draws the same shape from fewer points, it does not hold less
+     * data. Left unset, every point is drawn and a series past
+     * `CHART_POINT_BUDGET` warns once in development.
+     */
+    maxPoints?: number;
+    /**
+     * Lets a pointer drag a window across the category axis.
+     *
+     * Shift + arrows does the same from the keyboard, and Escape drops it. The
+     * window is published to the surrounding `ChartSyncProvider`, which is how
+     * one panel's selection becomes the whole dashboard's.
+     */
+    brush?: boolean;
+    /** Called when a window is set, and with `null` when one is dropped. */
+    onBrush?: (range: ChartBrushRange | null) => void;
+    /** Accessible name of the selected window. */
+    brushLabel?: string;
+    /**
+     * `false` keeps the chart out of the surrounding `ChartSyncProvider`.
+     *
+     * For the panel of a dashboard that plots something else entirely, where a
+     * shared crosshair would mark a position its axis does not carry.
+     */
+    sync?: boolean;
     margin?: Partial<ChartMargin>;
     /** BCP 47 tag used to format the axes and the tooltip. */
     locale?: string;
@@ -3038,8 +4016,12 @@ interface LineChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWit
  * There is deliberately no second value axis. Two measures on two scales
  * invent a correlation the data does not carry; plot them as two charts, or
  * index both to a common base.
+ *
+ * `overlay` is the way past everything this chart refuses to draw: it hands
+ * the resolved geometry over and lets the application draw inside the plot
+ * with the chart's own scales, instead of forking the component.
  */
-declare function LineChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, onPointClick, curve, forecastFrom, forecastLabel, markers, connectNulls, referenceLines, legendToggle, margin, locale, plotLabel, className, ...props }: LineChartProps): react_jsx_runtime.JSX.Element;
+declare function LineChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, error, errorState, onRetry, actions, onPointClick, curve, forecastFrom, forecastLabel, markers, connectNulls, referenceLines, annotations, overlay, legendToggle, maxPoints, brush, onBrush, brushLabel, sync, margin, locale, plotLabel, className, ...props }: LineChartProps): react_jsx_runtime.JSX.Element;
 
 interface ModalProps {
     isOpen: boolean;
@@ -3120,7 +4102,7 @@ interface PaginationProps extends Omit<ComponentPropsWithoutRef<"nav">, "onChang
 }
 declare function Pagination({ page, totalPages, onPageChange, size, variant, showFirstLast, siblings, boundaries, disabled, labels, totalItems, pageSize, pageSizeOptions, onPageSizeChange, className, ...props }: PaginationProps): react_jsx_runtime.JSX.Element;
 
-interface PieChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+interface PieChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title">, ChartStatusProps {
     data: ChartDatum[];
     /** Field holding the name of each slice. */
     x: ChartXAxisConfig;
@@ -3150,8 +4132,17 @@ interface PieChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "childr
     tableView?: boolean | "toggle";
     title?: ReactNode;
     description?: ReactNode;
-    loading?: boolean;
-    emptyState?: ReactNode;
+    /**
+     * Draws each slice with a texture on top of its colour.
+     *
+     * The channel a reader falls back on when the hue fails them: severe colour
+     * vision deficiency, a grayscale print, a forced-colours theme. Off by
+     * default — it is an accessibility option, not a decoration.
+     *
+     * The folded tail keeps its flat grey: it is the one slice that is not an
+     * identity, and giving it a texture would make it look like one.
+     */
+    patterns?: boolean;
     locale?: string;
     plotLabel?: string;
     onSliceClick?: (slice: {
@@ -3170,7 +4161,7 @@ interface PieChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "childr
  * over six slices at most, which is why the tail folds into a single bucket
  * rather than taking a seventh colour.
  */
-declare function PieChart({ data, x, value, variant, innerRadius, maxSlices, otherLabel, sort, showLabels, centerLabel, height, width, size, legend, tooltip, tableView, title, description, loading, emptyState, locale, plotLabel, onSliceClick, className, ...props }: PieChartProps): react_jsx_runtime.JSX.Element;
+declare function PieChart({ data, x, value, variant, innerRadius, maxSlices, otherLabel, sort, showLabels, centerLabel, patterns, height, width, size, legend, tooltip, tableView, title, description, loading, emptyState, error, errorState, onRetry, actions, locale, plotLabel, onSliceClick, className, ...props }: PieChartProps): react_jsx_runtime.JSX.Element;
 
 type ProgressBarSize = "xs" | "sm" | "md" | "lg" | "xl";
 type ProgressBarColor = "default" | "primary" | "success" | "warning" | "error" | "info";
@@ -3748,6 +4739,19 @@ interface ScatterChartProps extends Omit<CartesianChartBaseProps, "grid">, Omit<
     };
     pointRadius?: number;
     legendToggle?: boolean;
+    /**
+     * Thins each series to roughly this many marks.
+     *
+     * An **even** sample, not LTTB: a cloud is read for where its points are
+     * dense, and keeping the largest triangles would carve out the envelope and
+     * throw that density away — a lie about the very thing the chart is for. An
+     * even stride thins the cloud without changing its shape.
+     *
+     * The trend line and the data table are computed from every row, so a
+     * thinned plot still reports what the whole dataset says. Left unset, a
+     * series past `CHART_POINT_BUDGET` warns once in development.
+     */
+    maxPoints?: number;
     margin?: Partial<ChartMargin>;
     locale?: string;
     plotLabel?: string;
@@ -3760,7 +4764,7 @@ interface ScatterChartProps extends Omit<CartesianChartBaseProps, "grid">, Omit<
  * three slots stay tellable apart there. Past three series, facet the chart or
  * fold the tail — a fourth colour would not be distinguishable.
  */
-declare function ScatterChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, onPointClick, bubble, trendLine, quadrants, pointRadius, legendToggle, margin, locale, plotLabel, className, ...props }: ScatterChartProps): react_jsx_runtime.JSX.Element;
+declare function ScatterChart({ data, series, x, y, height, width, size, grid, legend, tooltip, tableView, emphasis, title, description, loading, emptyState, error, errorState, onRetry, actions, onPointClick, bubble, trendLine, quadrants, pointRadius, overlay, legendToggle, maxPoints, margin, locale, plotLabel, className, ...props }: ScatterChartProps): react_jsx_runtime.JSX.Element;
 
 type SchemaFieldType = "text" | "varchar" | "char" | "int2" | "int4" | "int8" | "serial" | "bigserial" | "float4" | "float8" | "numeric" | "decimal" | "bool" | "date" | "time" | "timestamp" | "timestamptz" | "uuid" | "json" | "jsonb" | "bytea" | (string & {});
 type SchemaField = {
@@ -4243,6 +5247,43 @@ interface UILabels {
     chartProgress: string;
     /** Name of the rule marking today on a schedule. */
     chartToday: string;
+    /** Word the annotation captions are announced under in a chart's name. */
+    chartAnnotations: string;
+    /** Accessible name of the filter row above a set of charts. */
+    chartFilters: string;
+    /** Accessible name of the period picker, and its caption when nothing is set. */
+    chartPeriod: string;
+    chartPeriodLast7Days: string;
+    chartPeriodLast30Days: string;
+    chartPeriodLast90Days: string;
+    chartPeriodLast12Months: string;
+    chartPeriodMonthToDate: string;
+    chartPeriodQuarterToDate: string;
+    chartPeriodYearToDate: string;
+    /** Entry opening the calendar, for a window the presets do not cover. */
+    chartPeriodCustom: string;
+    /**
+     * Shown in place of a chart whose data could not be loaded.
+     *
+     * Distinct from `chartNoData` on purpose: "there is nothing" and "we failed
+     * to fetch it" are two different statements, and only the second one asks
+     * the reader to do something about it.
+     */
+    chartError: string;
+    /** Second line of a chart's error state, under `chartError`. */
+    chartErrorHint: string;
+    /** Label of the button that asks a failed chart to load again. */
+    chartRetry: string;
+    /** Accessible name of a chart's export control. */
+    chartExport: string;
+    /** Entry downloading a chart's data table as a CSV file. */
+    chartExportCsv: string;
+    /** Entry downloading a chart's data table as a JSON file. */
+    chartExportJson: string;
+    /** Accessible name of the range a pointer drags across a chart's category axis. */
+    chartBrush: string;
+    /** Accessible name of the button dropping the dragged range. */
+    chartClearSelection: string;
 }
 /** English labels, used when no provider is mounted. */
 declare const defaultUILabels: UILabels;
@@ -4328,4 +5369,4 @@ declare function isFocusable(element: HTMLElement): boolean;
  */
 declare function getFocusableElements(container: HTMLElement): HTMLElement[];
 
-export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionType, type AccordionVariant, AdvanceDetachable, type AdvanceDetachableProps, type AdvanceDetachableRef, type AdvanceDetachableRenderContext, type AggregateFunction, type Align, AreaChart, type AreaChartProps, Avatar, type AvatarProps, Badge, type BadgeColor, type BadgeProps, type BadgeSize, type BadgeVariant, Banner, type BannerProps, type BannerType, type BannerVariant, BarChart, type BarChartOrientation, type BarChartProps, type BinSpec, BoxPlot, type BoxPlotBox, type BoxPlotProps, type BoxPlotQuantileKeys, type BoxStats, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, BulletChart, type BulletChartProps, type BulletRow, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, CHART_ALL_PAIRS_LIMIT, CHART_DIVERGING_COLORS, CHART_DIVERGING_DARK_STOPS, CHART_DIVERGING_NEUTRAL_INDEX, CHART_DOWN_COLOR, CHART_MAX_COLOR_CLASSES, CHART_MUTED_COLOR, CHART_ORDINAL_COLORS, CHART_ORDINAL_DARK_STOPS, CHART_PALETTE_SIZE, CHART_SEQUENTIAL_COLORS, CHART_SEQUENTIAL_DARK_STOPS, CHART_SERIES_COLORS, CHART_UP_COLOR, Calendar, type CalendarColor, type CalendarDateRange, type CalendarDayState, type CalendarLabels, type CalendarMode, type CalendarProps, type CalendarSize, type CalendarWeekStart, type Candle, CandlestickChart, type CandlestickChartProps, Card, CardBody, type CardBodyProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardImage, type CardImageProps, type CardProps, CardTitle, type CardTitleProps, type CartesianChartBaseProps, ChartAxis, type ChartAxisOrientation, type ChartAxisProps, type ChartColorScale, ChartContainer, type ChartContainerProps, type ChartContainerRenderArgs, type ChartCurve, type ChartDatum, type ChartDimensions, type ChartFacetPanel, ChartFacets, type ChartFacetsProps, ChartGrid, type ChartGridLines, type ChartGridProps, ChartLegend, type ChartLegendItem, type ChartLegendMarker, type ChartLegendPosition, type ChartLegendProps, type ChartMargin, type ChartPoint, type ChartPointEvent, type ChartReferenceLine, ChartScaleLegend, type ChartScaleLegendProps, type ChartScaleType, type ChartSeries, type ChartSize, ChartTableView, type ChartTableViewProps, type ChartTick, ChartTooltip, ChartTooltipContent, type ChartTooltipContentProps, type ChartTooltipPayload, type ChartTooltipProps, type ChartXAxisConfig, type ChartXValue, type ChartYAxisConfig, Checkbox, CheckboxGroup, CheckboxGroupItem, type CheckboxGroupItemProps, type CheckboxGroupProps, type CheckboxProps, Chip, type ChipColor, type ChipProps, type ChipSize, type ChipVariant, CircularProgress, type CircularProgressColor, type CircularProgressProps, type CircularProgressSize, type CircularProgressThickness, type ColumnDef, DEFAULT_CHART_WIDTH, DEFAULT_FIELD_TYPES, DataGrid, type DataGridMode, type DataGridProps, type DataGridRef, type Density, Detachable, type DetachableProps, type DetachableRef, DeviceMockup, type DeviceMockupProps, type DeviceOrientation, type DeviceSize, type DeviceTheme, type DeviceType, type DialogA11yProps, type DialogInitialFocus, type DialogReturnFocus, type DivergingScaleOptions, Divider, type DividerOrientation, type DividerProps, type DividerTextAlign, type DividerVariant, Drawer, type DrawerPosition, type DrawerProps, type DrawerSize, Dropdown, DropdownCheckboxItem, type DropdownCheckboxItemProps, DropdownContent, type DropdownContentProps, type DropdownContextValue, DropdownItem, type DropdownItemProps, DropdownLabel, type DropdownLabelProps, type DropdownProps, DropdownRadioGroup, type DropdownRadioGroupProps, DropdownRadioItem, type DropdownRadioItemProps, DropdownSeparator, type DropdownSeparatorProps, DropdownSubMenu, DropdownSubMenuContent, type DropdownSubMenuContentProps, type DropdownSubMenuProps, DropdownSubMenuTrigger, type DropdownSubMenuTriggerProps, DropdownTrigger, type DropdownTriggerProps, DumbbellChart, type DumbbellChartProps, type DumbbellRow, type DumbbellSort, FOCUSABLE_SELECTOR, FileSelector, type FileSelectorProps, type FilterOperator, type FilterType, type FilterValue, Footer, FooterBottom, type FooterBottomProps, FooterColumn, type FooterColumnProps, FooterLink, type FooterLinkProps, type FooterProps, FooterSection, type FooterSectionProps, FooterSocial, FooterSocialLink, type FooterSocialLinkProps, type FooterSocialProps, FunnelChart, type FunnelChartProps, type FunnelStage, GanttChart, type GanttChartProps, type GanttTask, Header, type HeaderProps, Heatmap, type HeatmapCell, type HeatmapProps, HelpButton, type HelpButtonProps, type HistogramBin, INERT_IGNORE_ATTRIBUTE, ImageUploader, type ImageUploaderProps, Indicator, type IndicatorColor, type IndicatorPlacement, type IndicatorProps, type IndicatorSize, type IndicatorVariant, Input, type InputProps, Label, type LabelColor, type LabelProps, type LabelSize, type LabelVariant, type LabelWeight, LineChart, type LineChartProps, MarkdownEditorComponent, type MentionData, MentionInput, type MentionInputProps, type MentionInputValue, type MentionSuggestion, Modal, type ModalProps, type NavItem, type NodeRegistryEntry, NumberInput, type NumberInputProps, Pagination, type PaginationConfig, type PaginationProps, PieChart, type PieChartProps, type Position, ProgressBar, type ProgressBarColor, type ProgressBarProps, type ProgressBarSize, type ProgressBarVariant, RadioButton, type RadioButtonProps, ScatterChart, type ScatterChartProps, SchemaEditor, type SchemaEditorProps, type SchemaEditorRef, type SchemaField, type SchemaFieldEvent, type SchemaFieldType, type SchemaRelation, type SchemaRelationCardinality, type SchemaTable, type SchemaTableEvent, type SchemaValue, type SchemaViewport, Select, type SelectOption, type SelectProps, type SelectedFile, type SelectionMode, type SequentialScaleOptions, type Side, Sidebar, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarPosition, type SidebarProps, SidebarSubMenu, type SidebarSubMenuProps, SidebarToggle, type SidebarToggleProps, type SidebarVariant, Skeleton, type SkeletonAnimation, type SkeletonProps, type SkeletonVariant, Slider, type SliderColor, type SliderMark, type SliderProps, type SliderSize, type SortDirection, type SortState, Sparkline, type SparklineProps, StatCard, type StatCardDelta, type StatCardDeltaDirection, type StatCardDeltaTone, StatCardGroup, type StatCardGroupProps, type StatCardProps, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableHeader, TableHeaderCell, type TableHeaderCellProps, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsColor, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsOrientation, type TabsProps, type TabsSize, TabsTrigger, type TabsTriggerProps, type TabsVariant, type TimeTickScale, type TimeUnit, Toast, type ToastPosition, type ToastProps, type ToastType, type ToastVariant, Tooltip, type TooltipPosition, type TooltipProps, type TooltipSize, type TooltipTrigger, type TooltipVariant, type UILabels, UILabelsProvider, type UILabelsProviderProps, type UseChartSizeOptions, type UseChartSizeResult, type UseDialogA11yOptions, type UseDialogA11yResult, type UseKeyboardNavigationOptions, type UsePositioningOptions, WaterfallChart, type WaterfallChartProps, type WaterfallKind, type WaterfallStep, WithHelpButton, type WithHelpButtonProps, Wizard, WizardActions, type WizardActionsProps, type WizardColor, WizardContent, type WizardContentProps, type WizardContextValue, type WizardDirection, WizardNext, type WizardNextProps, type WizardOrientation, WizardPanel, type WizardPanelProps, WizardPrevious, type WizardPreviousProps, type WizardProps, type WizardSize, type WizardStepChangeMeta, type WizardStepDefinition, type WizardStepStatus, WizardSteps, type WizardStepsProps, type WizardVariant, type WorkflowDirection, type WorkflowEdge, WorkflowEditor, type WorkflowEditorProps, type WorkflowEditorRef, type WorkflowNode, type WorkflowNodeAction, type WorkflowNodeActionEvent, type WorkflowNodeActionPosition, type WorkflowNodeEvent, type WorkflowPort, type WorkflowValue, type WorkflowViewport, autoLayoutTables, binEdges, binValues, boxStats, cn, createDefaultField, createDefaultTable, createDivergingScale, createSequentialScale, defaultUILabels, findOwnedLayers, formatTimeTick, frenchUILabels, generateFieldId, generateRelationId, generateSQL, generateTableId, getFocusableElements, getOrdinalColor, getSeriesColor, getSeriesLabel, hideOthers, isElementVisible, isFocusable, niceTimeTicks, quantile, quantileSorted, rampColor, registerFloatingLayer, resetBarChartWarnings, resetDumbbellWarnings, resetFacetWarnings, resolveSeriesColor, sturgesBins, toLegendItems, toTimestamp, useChartSize, useClickOutside, useDialogA11y, useDropdownContext, useFocusItem, useKeyboardNavigation, usePositioning, useSidebar, useUILabels, useWizard };
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionType, type AccordionVariant, AdvanceDetachable, type AdvanceDetachableProps, type AdvanceDetachableRef, type AdvanceDetachableRenderContext, type AggregateFunction, type Align, AreaChart, type AreaChartProps, Avatar, type AvatarProps, Badge, type BadgeColor, type BadgeProps, type BadgeSize, type BadgeVariant, Banner, type BannerProps, type BannerType, type BannerVariant, BarChart, type BarChartOrientation, type BarChartProps, type BinSpec, BoxPlot, type BoxPlotBox, type BoxPlotProps, type BoxPlotQuantileKeys, type BoxStats, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, BulletChart, type BulletChartProps, type BulletRow, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, CHART_ALL_PAIRS_LIMIT, CHART_DIVERGING_COLORS, CHART_DIVERGING_DARK_STOPS, CHART_DIVERGING_NEUTRAL_INDEX, CHART_DOWN_COLOR, CHART_MAX_COLOR_CLASSES, CHART_MUTED_COLOR, CHART_ORDINAL_COLORS, CHART_ORDINAL_DARK_STOPS, CHART_PALETTE_SIZE, CHART_PATTERNS, CHART_POINT_BUDGET, CHART_SEQUENTIAL_COLORS, CHART_SEQUENTIAL_DARK_STOPS, CHART_SERIES_COLORS, CHART_SURFACE_COLOR, CHART_UP_COLOR, Calendar, type CalendarColor, type CalendarDateRange, type CalendarDayState, type CalendarLabels, type CalendarMode, type CalendarProps, type CalendarSize, type CalendarWeekStart, type Candle, CandlestickChart, type CandlestickChartProps, Card, CardBody, type CardBodyProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardImage, type CardImageProps, type CardProps, CardTitle, type CardTitleProps, type CartesianChartBaseProps, type CartesianGeometry, type CartesianGeometryOptions, type CartesianOrientation, type CategoryPlacement, type ChartAnnotation, type ChartAnnotationBase, ChartAnnotationLayer, type ChartAnnotationLayerProps, ChartAxis, type ChartAxisOrientation, type ChartAxisProps, type ChartBandAnnotation, ChartBrushLayer, type ChartBrushLayerProps, type ChartBrushRange, type ChartColorScale, ChartContainer, type ChartContainerProps, type ChartContainerRenderArgs, type ChartCurve, type ChartDatum, type ChartDimensions, ChartExportButton, type ChartExportButtonProps, type ChartExportFormat, type ChartExportOptions, type ChartExportRow, type ChartFacetPanel, ChartFacets, type ChartFacetsProps, ChartFilterBar, type ChartFilterBarProps, ChartGrid, type ChartGridLines, type ChartGridProps, ChartLegend, type ChartLegendItem, type ChartLegendMarker, type ChartLegendPosition, type ChartLegendProps, type ChartLineAnnotation, type ChartMargin, type ChartOrientation, type ChartOverlay, type ChartOverlayRenderer, type ChartPattern, ChartPatternDefs, type ChartPatternDefsProps, type ChartPatternEntry, type ChartPeriod, ChartPeriodPicker, type ChartPeriodPickerProps, type ChartPeriodPreset, type ChartPlotContext, type ChartPoint, type ChartPointAnnotation, type ChartPointEvent, type ChartReferenceLine, type ChartResolvedSeries, ChartScaleLegend, type ChartScaleLegendProps, type ChartScaleType, type ChartSeries, type ChartSize, type ChartStatusProps, type ChartSyncContextValue, ChartSyncProvider, type ChartSyncProviderProps, ChartTableView, type ChartTableViewProps, type ChartTick, ChartTooltip, ChartTooltipContent, type ChartTooltipContentProps, type ChartTooltipPayload, type ChartTooltipProps, type ChartXAxisConfig, type ChartXValue, type ChartYAxisConfig, Checkbox, CheckboxGroup, CheckboxGroupItem, type CheckboxGroupItemProps, type CheckboxGroupProps, type CheckboxProps, Chip, type ChipColor, type ChipProps, type ChipSize, type ChipVariant, CircularProgress, type CircularProgressColor, type CircularProgressProps, type CircularProgressSize, type CircularProgressThickness, type ColumnDef, DEFAULT_CHART_PERIOD_PRESETS, DEFAULT_CHART_WIDTH, DEFAULT_FIELD_TYPES, DataGrid, type DataGridMode, type DataGridProps, type DataGridRef, type Density, Detachable, type DetachableProps, type DetachableRef, DeviceMockup, type DeviceMockupProps, type DeviceOrientation, type DeviceSize, type DeviceTheme, type DeviceType, type DialogA11yProps, type DialogInitialFocus, type DialogReturnFocus, type DivergingScaleOptions, Divider, type DividerOrientation, type DividerProps, type DividerTextAlign, type DividerVariant, Drawer, type DrawerPosition, type DrawerProps, type DrawerSize, Dropdown, DropdownCheckboxItem, type DropdownCheckboxItemProps, DropdownContent, type DropdownContentProps, type DropdownContextValue, DropdownItem, type DropdownItemProps, DropdownLabel, type DropdownLabelProps, type DropdownProps, DropdownRadioGroup, type DropdownRadioGroupProps, DropdownRadioItem, type DropdownRadioItemProps, DropdownSeparator, type DropdownSeparatorProps, DropdownSubMenu, DropdownSubMenuContent, type DropdownSubMenuContentProps, type DropdownSubMenuProps, DropdownSubMenuTrigger, type DropdownSubMenuTriggerProps, DropdownTrigger, type DropdownTriggerProps, DumbbellChart, type DumbbellChartProps, type DumbbellRow, type DumbbellSort, FOCUSABLE_SELECTOR, FileSelector, type FileSelectorProps, type FilterOperator, type FilterType, type FilterValue, Footer, FooterBottom, type FooterBottomProps, FooterColumn, type FooterColumnProps, FooterLink, type FooterLinkProps, type FooterProps, FooterSection, type FooterSectionProps, FooterSocial, FooterSocialLink, type FooterSocialLinkProps, type FooterSocialProps, FunnelChart, type FunnelChartProps, type FunnelStage, GanttChart, type GanttChartProps, type GanttTask, Header, type HeaderProps, Heatmap, type HeatmapCell, type HeatmapProps, HelpButton, type HelpButtonProps, type HistogramBin, INERT_IGNORE_ATTRIBUTE, ImageUploader, type ImageUploaderProps, Indicator, type IndicatorColor, type IndicatorPlacement, type IndicatorProps, type IndicatorSize, type IndicatorVariant, Input, type InputProps, Label, type LabelColor, type LabelProps, type LabelSize, type LabelVariant, type LabelWeight, LineChart, type LineChartProps, MarkdownEditorComponent, type MentionData, MentionInput, type MentionInputProps, type MentionInputValue, type MentionSuggestion, Modal, type ModalProps, type NavItem, type NodeRegistryEntry, NumberInput, type NumberInputProps, Pagination, type PaginationConfig, type PaginationProps, PieChart, type PieChartProps, type Position, ProgressBar, type ProgressBarColor, type ProgressBarProps, type ProgressBarSize, type ProgressBarVariant, RadioButton, type RadioButtonProps, ScatterChart, type ScatterChartProps, SchemaEditor, type SchemaEditorProps, type SchemaEditorRef, type SchemaField, type SchemaFieldEvent, type SchemaFieldType, type SchemaRelation, type SchemaRelationCardinality, type SchemaTable, type SchemaTableEvent, type SchemaValue, type SchemaViewport, Select, type SelectOption, type SelectProps, type SelectedFile, type SelectionMode, type SequentialScaleOptions, type Side, Sidebar, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, type SidebarPosition, type SidebarProps, SidebarSubMenu, type SidebarSubMenuProps, SidebarToggle, type SidebarToggleProps, type SidebarVariant, Skeleton, type SkeletonAnimation, type SkeletonProps, type SkeletonVariant, Slider, type SliderColor, type SliderMark, type SliderProps, type SliderSize, type SortDirection, type SortState, Sparkline, type SparklineProps, StatCard, type StatCardDelta, type StatCardDeltaDirection, type StatCardDeltaTone, StatCardGroup, type StatCardGroupProps, type StatCardProps, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableHeader, TableHeaderCell, type TableHeaderCellProps, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsColor, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsOrientation, type TabsProps, type TabsSize, TabsTrigger, type TabsTriggerProps, type TabsVariant, type TimeTickScale, type TimeUnit, Toast, type ToastPosition, type ToastProps, type ToastType, type ToastVariant, Tooltip, type TooltipPosition, type TooltipProps, type TooltipSize, type TooltipTrigger, type TooltipVariant, type UILabels, UILabelsProvider, type UILabelsProviderProps, type UseChartBrushOptions, type UseChartBrushResult, type UseChartSizeOptions, type UseChartSizeResult, type UseDialogA11yOptions, type UseDialogA11yResult, type UseKeyboardNavigationOptions, type UsePositioningOptions, WaterfallChart, type WaterfallChartProps, type WaterfallKind, type WaterfallStep, WithHelpButton, type WithHelpButtonProps, Wizard, WizardActions, type WizardActionsProps, type WizardColor, WizardContent, type WizardContentProps, type WizardContextValue, type WizardDirection, WizardNext, type WizardNextProps, type WizardOrientation, WizardPanel, type WizardPanelProps, WizardPrevious, type WizardPreviousProps, type WizardProps, type WizardSize, type WizardStepChangeMeta, type WizardStepDefinition, type WizardStepStatus, WizardSteps, type WizardStepsProps, type WizardVariant, type WorkflowDirection, type WorkflowEdge, WorkflowEditor, type WorkflowEditorProps, type WorkflowEditorRef, type WorkflowNode, type WorkflowNodeAction, type WorkflowNodeActionEvent, type WorkflowNodeActionPosition, type WorkflowNodeEvent, type WorkflowPort, type WorkflowValue, type WorkflowViewport, autoLayoutTables, binEdges, binValues, boxStats, brushToPeriod, buildCartesianGeometry, cn, createCategoryLocator, createDefaultField, createDefaultTable, createDivergingScale, createPeriod, createPlotContext, createSequentialScale, decimateIndices, decimatePath, defaultUILabels, describeAnnotations, downloadChartData, endOfDay, findOwnedLayers, formatPeriodRange, formatTimeTick, frenchUILabels, generateFieldId, generateRelationId, generateSQL, generateTableId, getFocusableElements, getOrdinalColor, getPattern, getSeriesColor, getSeriesLabel, hideOthers, isElementVisible, isFocusable, lttb, niceTimeTicks, patternBackground, patternFill, patternId, quantile, quantileSorted, rampColor, registerFloatingLayer, resetBarChartWarnings, resetDumbbellWarnings, resetFacetWarnings, resetPointBudgetWarning, resolvePeriodPreset, resolveSeriesColor, samePeriod, sampleEvenly, splitOverlay, startOfDay, sturgesBins, toChartCsv, toChartJson, toChartRows, toLegendItems, toTimestamp, useChartBrush, useChartSize, useChartSync, useClickOutside, useDialogA11y, useDropdownContext, useFocusItem, useKeyboardNavigation, usePositioning, useSidebar, useUILabels, useWizard };