@synertech/ui 0.41.0 → 0.43.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, 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';
 
@@ -144,6 +144,16 @@ interface ChartSeries {
     hidden?: boolean;
     /** Draws the line dashed — for a projection, a target, or a modelled value. */
     dashed?: boolean;
+    /**
+     * Mark this series is drawn with, where a chart can draw more than one.
+     *
+     * Only `BarChart` reads it, and only to lift a series out of the bars and
+     * draw it as a line over them — a volume and its trend on one panel. Both
+     * marks keep sharing the single value axis: a second axis lets two measures
+     * of unrelated magnitudes cross wherever the scaling happens to put them,
+     * which reads as a correlation the data never claimed.
+     */
+    type?: "bar" | "line";
 }
 interface ChartXAxisConfig {
     /** Field read on each datum. */
@@ -233,12 +243,54 @@ 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;
     label: string;
     color: string;
     hidden?: boolean;
+    /**
+     * Overrides the legend's shared swatch shape for this entry alone.
+     *
+     * What a combined chart needs: the swatch has to mirror the mark, so the
+     * 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 {
@@ -300,6 +352,25 @@ 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;
     margin?: Partial<ChartMargin>;
     locale?: string;
@@ -316,7 +387,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, onPointClick, curve, stack, baseline, connectNulls, referenceLines, annotations, patterns, legendToggle, margin, locale, plotLabel, className, ...props }: AreaChartProps): react_jsx_runtime.JSX.Element;
 
 interface AvatarProps extends ComponentPropsWithoutRef<"div"> {
     src?: string;
@@ -354,6 +425,55 @@ declare namespace Badge {
  */
 type CartesianOrientation = "vertical" | "horizontal";
 
+/**
+ * Binning, for the one chart that counts rather than reads a measure.
+ *
+ * A histogram is a bar chart whose categories the chart works out for itself,
+ * so the bucketing lives next to the scales rather than inside a component.
+ */
+/** One bucket of a histogram. */
+interface HistogramBin {
+    /** Lower edge, included. */
+    from: number;
+    /** Upper edge, excluded — except on the last bin, which closes on it. */
+    to: number;
+    count: number;
+    /** `true` for the last bin: the only one that includes its upper edge. */
+    last: boolean;
+}
+/**
+ * How the buckets are cut: a count, explicit edges, or `true` for a count
+ * derived from the sample size.
+ */
+type BinSpec = number | readonly number[] | boolean;
+/**
+ * Sturges' rule: `ceil(log2 n) + 1`.
+ *
+ * Not the most refined estimator — Freedman-Diaconis adapts to the spread —
+ * but it is the one a reader recognises, it never explodes on a heavy tail,
+ * and a histogram whose bin count changes with a single outlier is worse than
+ * one that is slightly too coarse.
+ */
+declare function sturgesBins(count: number): number;
+/**
+ * The edges a set of values would be bucketed on.
+ *
+ * Every edge lands on a round step — a bin running from 17.4 to 23.9 is
+ * arithmetically correct and unreadable on an axis — and among the round
+ * steps, the one whose bin count lands nearest what was asked for.
+ */
+declare function binEdges(values: readonly number[], spec?: BinSpec): number[];
+/**
+ * Counts a set of values into buckets.
+ *
+ * Every bin is half-open — `[from, to)` — except the last, which closes on its
+ * upper edge. Without that, the single largest observation of a sample falls
+ * out of the histogram entirely.
+ */
+declare function binValues(values: readonly (number | null | undefined)[], spec?: BinSpec): HistogramBin[];
+
+/** 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"> {
     /**
@@ -381,13 +501,59 @@ interface BarChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWith
      * above is not good.
      */
     diverging?: boolean | number | string;
+    /**
+     * Turns the chart into a histogram: the distribution of one numeric field.
+     *
+     * The chart then reads `x.key` on every row as a measurement, buckets those
+     * measurements, and draws how many fell in each bucket. `series` must hold a
+     * single entry, which names and colours the count — its `key` is the header
+     * of the count column, not a field read on the data.
+     *
+     * `true` picks a bucket count from the sample size, a number asks for that
+     * many, and an array of edges cuts them by hand (uneven widths allowed). The
+     * bars then touch, separated only by the surface gap: the axis underneath is
+     * a continuous measure, and air between the bars would read as empty ranges.
+     *
+     * Where a scatter plot shows a relation, a histogram shows a shape — which
+     * is why `sort`, `stack` and `diverging` are ignored here: the buckets have
+     * an order of their own and reordering them destroys the shape.
+     */
+    bins?: BinSpec;
+    /**
+     * Shape of the line drawn for a series marked `type: "line"`.
+     *
+     * Only read by a combined chart; the bars have no curve.
+     */
+    curve?: ChartCurve;
     /** Caps the thickness of a mark. Never fills the slot: the leftover is air. */
     barSize?: number;
-    /** Orders the categories by their total. */
+    /** Orders the categories by their total. Ignored by a histogram. */
     sort?: "none" | "asc" | "desc";
     /** 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;
     margin?: Partial<ChartMargin>;
     locale?: string;
@@ -404,7 +570,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, 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, onPointClick, orientation, stack, diverging, bins, curve, barSize, sort, showValues, referenceLines, annotations, patterns, legendToggle, margin, locale, plotLabel, className, ...props }: BarChartProps): react_jsx_runtime.JSX.Element;
 
 type BannerVariant = "notification" | "hero" | "promotion";
 type BannerType = "info" | "success" | "warning" | "error" | "default";
@@ -730,6 +896,245 @@ declare namespace CardDescription {
     var displayName: string;
 }
 
+/**
+ * Quantiles, and the five-number summary a box plot is drawn from.
+ *
+ * Written here rather than inside the component because it is the part that
+ * can be wrong without any rendering test noticing: a median off by one index
+ * still draws a perfectly plausible box.
+ */
+/**
+ * Quantile `p` (0 to 1) of an ascending list, interpolating between the two
+ * neighbouring observations.
+ *
+ * This is the R-7 / `numpy.percentile` definition — the one a reader will get
+ * if they check the numbers in a spreadsheet, which is the only property that
+ * matters for a library.
+ */
+declare function quantileSorted(sorted: readonly number[], p: number): number;
+/** Same, on a list that has not been sorted yet. */
+declare function quantile(values: readonly number[], p: number): number;
+/** The five-number summary, plus what falls outside the whiskers. */
+interface BoxStats {
+    /** Number of observations the summary was computed from. */
+    count: number;
+    /** Smallest observation, outliers included. */
+    min: number;
+    /** Largest observation, outliers included. */
+    max: number;
+    q1: number;
+    median: number;
+    q3: number;
+    /** `q3 - q1`: the width of the box, and the unit the whiskers are measured in. */
+    iqr: number;
+    /** End of the lower whisker: the smallest observation still within reach. */
+    lower: number;
+    /** End of the upper whisker. */
+    upper: number;
+    /** Observations beyond the whiskers, in ascending order. */
+    outliers: number[];
+}
+/**
+ * Turns a set of observations into the box a plot draws.
+ *
+ * The whiskers stop at the furthest observation within `whisker` times the
+ * interquartile range — Tukey's rule — rather than at the extremes. Whiskers
+ * drawn to the extremes cannot show an outlier at all: the point that matters
+ * most becomes the end of a line like any other.
+ *
+ * Returns `null` for an empty set, which a chart draws as a gap. A category
+ * with no observations is not a category with a median of zero.
+ */
+declare function boxStats(values: readonly (number | null | undefined)[], whisker?: number): BoxStats | null;
+
+/** Fields holding an already-computed summary, when the observations are not at hand. */
+interface BoxPlotQuantileKeys {
+    /** Lower whisker end. Defaults to `q1` when absent. */
+    min?: string;
+    q1: string;
+    median: string;
+    q3: string;
+    /** Upper whisker end. Defaults to `q3` when absent. */
+    max?: string;
+}
+/** One box, as the tooltip and the click handler see it. */
+interface BoxPlotBox {
+    index: number;
+    x: ChartXValue;
+    label: string;
+    /** `null` when the category holds no observation — drawn as a gap. */
+    stats: BoxStats | null;
+    /** Arithmetic mean. Only available when the raw observations were given. */
+    mean: number | null;
+    datum: ChartDatum;
+}
+interface BoxPlotProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+    /** One row per category compared. */
+    data: ChartDatum[];
+    /** Field holding the name of each category. */
+    x: ChartXAxisConfig;
+    y?: ChartYAxisConfig;
+    /**
+     * Field holding the observations of a category, as an array of numbers.
+     *
+     * The chart then computes the quartiles, the whiskers and the outliers
+     * itself — which is the only way it can know what an outlier is.
+     */
+    values?: string;
+    /**
+     * Fields holding an already-computed summary, for the case where the raw
+     * observations never reach the browser.
+     *
+     * The whiskers then stop where the data says, and no outlier can be drawn:
+     * Tukey's fences need the observations, not their summary.
+     */
+    quantiles?: BoxPlotQuantileKeys;
+    /**
+     * How many interquartile ranges the whiskers reach before a point counts as
+     * an outlier. Tukey's 1.5 by default.
+     */
+    whisker?: number;
+    orientation?: CartesianOrientation;
+    /** Caps the thickness of a box. */
+    boxSize?: number;
+    /** Draws the observations beyond the whiskers. */
+    showOutliers?: boolean;
+    /**
+     * Marks the mean with a diamond, beside the median line.
+     *
+     * The distance between the two is the reading: a mean pulled away from the
+     * median is the shape of the tail, which is the whole reason this chart
+     * exists rather than a bar of averages.
+     */
+    showMean?: boolean;
+    /** Colour of the boxes. Defaults to the first palette slot. */
+    color?: string;
+    referenceLines?: ChartReferenceLine[];
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    grid?: ChartGridLines;
+    tooltip?: boolean | ((box: BoxPlotBox) => ReactNode);
+    tableView?: boolean | "toggle";
+    title?: ReactNode;
+    description?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    margin?: Partial<ChartMargin>;
+    locale?: string;
+    plotLabel?: string;
+    format?: (value: number) => string;
+    onBoxClick?: (box: BoxPlotBox) => void;
+}
+/**
+ * What a mean hides.
+ *
+ * Median, quartiles, whiskers and the observations that fall outside them.
+ * A bar of averages says two categories are alike; a box plot is what shows
+ * that one of them is two populations wearing a trench coat.
+ *
+ * The whiskers stop at the furthest observation within 1.5 interquartile
+ * ranges — Tukey's rule — rather than at the extremes. Whiskers drawn to the
+ * extremes cannot show an outlier at all: the point that matters most becomes
+ * the end of a line like any other. That needs the observations, so a chart
+ * given a precomputed summary draws no outlier and says nothing it cannot
+ * know.
+ *
+ * One box per category: comparing two groups side by side is `ChartFacets`
+ * 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;
+
+/** One session, as the tooltip and the click handler see it. */
+interface Candle {
+    index: number;
+    x: ChartXValue;
+    label: string;
+    open: number | null;
+    high: number | null;
+    low: number | null;
+    close: number | null;
+    /** `close - open`. `null` when either end is missing. */
+    change: number | null;
+    /** `true` when the session closed at or above where it opened. */
+    rising: boolean;
+    datum: ChartDatum;
+}
+interface CandlestickChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+    /** One row per session. */
+    data: ChartDatum[];
+    /** Field holding the session's label — usually a date. */
+    x: ChartXAxisConfig;
+    y?: ChartYAxisConfig;
+    /** Field holding the opening figure. */
+    open: string;
+    /** Field holding the highest figure reached. */
+    high: string;
+    /** Field holding the lowest figure reached. */
+    low: string;
+    /** Field holding the closing figure. */
+    close: string;
+    /** Caps the thickness of a body. */
+    candleSize?: number;
+    /**
+     * Fills the body of a rising session instead of leaving it hollow.
+     *
+     * Off by default, and that default is an accessibility decision rather than
+     * a stylistic one: hollow against filled is what carries the direction for
+     * a reader who cannot separate green from red, which is the single worst
+     * pair there is under colour vision deficiency.
+     */
+    fillRising?: boolean;
+    /** Replaces the two status colours. Any CSS colours. */
+    colors?: {
+        up?: string;
+        down?: string;
+    };
+    referenceLines?: ChartReferenceLine[];
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    grid?: ChartGridLines;
+    legend?: boolean | ChartLegendPosition;
+    tooltip?: boolean | ((candle: Candle) => ReactNode);
+    tableView?: boolean | "toggle";
+    title?: ReactNode;
+    description?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    margin?: Partial<ChartMargin>;
+    locale?: string;
+    plotLabel?: string;
+    openLabel?: string;
+    highLabel?: string;
+    lowLabel?: string;
+    closeLabel?: string;
+    riseLabel?: string;
+    fallLabel?: string;
+    format?: (value: number) => string;
+    onCandleClick?: (candle: Candle) => void;
+}
+/**
+ * Open, high, low and close, one mark per session.
+ *
+ * A narrow audience, and no other shape of the kit can stand in for it: four
+ * figures per position, of which two are a range and two are an ordered pair
+ * inside it. A line of closing prices throws away three quarters of that.
+ *
+ * The colours are the status pair, not the categorical palette: a rise and a
+ * fall are not two identities a reader has to tell apart, they are the same
+ * measurement pointing two ways. Green against red is also the worst pair
+ * there is under colour vision deficiency, so the direction is carried a
+ * second time by the shape of the body — hollow for a rise, filled for a
+ * fall. Colour alone never says which way a session went.
+ *
+ * The value axis does not anchor at zero. A price is read for its level and
+ * 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;
+
 /** Geometry handed to the render prop once the container has been measured. */
 interface ChartContainerRenderArgs {
     width: number;
@@ -886,6 +1291,135 @@ 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;
+
+/**
+ * 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.
  *
@@ -906,6 +1440,8 @@ declare const CHART_PALETTE_SIZE = 8;
 declare const CHART_SERIES_COLORS: readonly ["var(--color-chart-1)", "var(--color-chart-2)", "var(--color-chart-3)", "var(--color-chart-4)", "var(--color-chart-5)", "var(--color-chart-6)", "var(--color-chart-7)", "var(--color-chart-8)"];
 /** Grey used for de-emphasised series and for the "Other" bucket. */
 declare const CHART_MUTED_COLOR = "var(--color-chart-muted)";
+declare const CHART_UP_COLOR = "var(--color-chart-up)";
+declare const CHART_DOWN_COLOR = "var(--color-chart-down)";
 /**
  * Number of series a chart can carry when any two marks may end up side by
  * side — a scatter or bubble plot. Neighbouring bars and lines only ever
@@ -927,8 +1463,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. */
@@ -1157,6 +1699,140 @@ 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;
+
+/**
+ * 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;
+
+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.
  *
@@ -1187,6 +1863,416 @@ interface UseChartSizeResult<T extends HTMLElement> {
  */
 declare function useChartSize<T extends HTMLElement = HTMLDivElement>(options?: UseChartSizeOptions): UseChartSizeResult<T>;
 
+/**
+ * Ticks for an axis carrying dates.
+ *
+ * `niceTicks` rounds a number to a 1 / 2 / 5 step, which is the right answer
+ * for a quantity and the wrong one for a date: time is not decimal. A step of
+ * "two hundred million milliseconds" is a perfectly round number and lands on
+ * 03:26 on a Tuesday. A reader of a schedule wants Mondays, or the first of
+ * the month — so the steps here are the ones a calendar actually has.
+ */
+type TimeUnit = "second" | "minute" | "hour" | "day" | "week" | "month" | "year";
+interface TimeTickScale {
+    /** Tick timestamps, ascending. */
+    values: number[];
+    /** Calendar unit the step is counted in — what a label should say. */
+    unit: TimeUnit;
+    /** How many of that unit each step covers. */
+    step: number;
+}
+/**
+ * Ticks covering `[min, max]`, landing on calendar boundaries.
+ *
+ * `count` is a target, not a promise — the same contract as `niceTicks`: the
+ * step is chosen first, and how many ticks fit follows from it.
+ *
+ * Steps are walked with `Date` arithmetic rather than by adding a constant, so
+ * a month tick stays on the first of the month across February and a day tick
+ * stays at midnight across a daylight saving change.
+ */
+declare function niceTimeTicks(min: number, max: number, count?: number): TimeTickScale;
+/**
+ * Renders a time tick at the precision its own step carries.
+ *
+ * A day step writes "12 Mar" and an hour step writes "14:00": showing the
+ * time under a monthly tick, or the year under an hourly one, is noise the
+ * reader has to filter out on every label.
+ */
+declare function formatTimeTick(value: number, unit: TimeUnit, locale?: string): string;
+/** Turns a date, a timestamp or a parsable string into a timestamp. */
+declare function toTimestamp(value: unknown): number | null;
+
+/** Resets the series warning. Test helper. */
+declare function resetDumbbellWarnings(): void;
+/** How the rows are ordered. */
+type DumbbellSort = "none" | "asc" | "desc" | "gap";
+/** One row, as the tooltip and the click handler see it. */
+interface DumbbellRow {
+    index: number;
+    x: ChartXValue;
+    label: string;
+    /** Every visible series' value on this row, in series order. */
+    points: ChartPoint[];
+    /** Smallest and largest value of the row, the two ends of its bar. */
+    from: number | null;
+    to: number | null;
+    /** Last series minus first: the move the chart is read for. */
+    change: number | null;
+    datum: ChartDatum;
+}
+interface DumbbellChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+    /** One row per item compared. */
+    data: ChartDatum[];
+    /** Field holding the name of each row. */
+    x: ChartXAxisConfig;
+    y?: ChartYAxisConfig;
+    /**
+     * The values compared on each row — usually two: before and after.
+     *
+     * Any two dots of a row can end up side by side, which is the same test a
+     * scatter plot puts the palette through: past three series only the first
+     * three slots stay tellable apart, and the chart says so.
+     */
+    series: ChartSeries[];
+    /**
+     * Orders the rows. `gap` sorts by the distance between the two ends, which
+     * is what turns the chart from a list into a finding: the biggest movers
+     * come to the top.
+     */
+    sort?: DumbbellSort;
+    /** Series the `asc` / `desc` orders read. Defaults to the last one. */
+    sortBy?: string;
+    /** Writes the value beside each dot, where there is room. */
+    showValues?: boolean;
+    /** Radius of a dot. */
+    dotSize?: number;
+    referenceLines?: ChartReferenceLine[];
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    grid?: ChartGridLines;
+    legend?: boolean | ChartLegendPosition;
+    legendToggle?: boolean;
+    tooltip?: boolean | ((row: DumbbellRow) => ReactNode);
+    tableView?: boolean | "toggle";
+    /** Adds the last-minus-first column to the data table. */
+    showChange?: boolean;
+    title?: ReactNode;
+    description?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    margin?: Partial<ChartMargin>;
+    locale?: string;
+    plotLabel?: string;
+    /** Header of the change column of the data table. */
+    changeLabel?: string;
+    format?: (value: number) => string;
+    onRowClick?: (row: DumbbellRow) => void;
+}
+/**
+ * Two points per item, and the distance between them.
+ *
+ * Before against after, or the two ends of a range. Two paired bars answer
+ * the same question and answer it badly: the reader has to compare the
+ * difference of two lengths across a dozen rows. Here the difference IS the
+ * mark — the rule between the dots — and the eye reads it directly.
+ *
+ * The value axis does not anchor at zero. A dumbbell is read for the gap
+ * between its two ends, and forcing zero in squeezes every gap on the chart
+ * towards nothing as soon as the values sit far from it. Pass
+ * `y={{ includeZero: true }}` on the rare chart where the absolute level is
+ * the point.
+ *
+ * `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;
+
+/** One stage, as the tooltip and the click handler see it. */
+interface FunnelStage {
+    index: number;
+    x: ChartXValue;
+    label: string;
+    value: number | null;
+    /** Share of the FIRST stage still here. `null` on the first stage itself. */
+    overall: number | null;
+    /** Share of the PREVIOUS stage still here. `null` on the first stage. */
+    conversion: number | null;
+    /** What the previous stage lost on the way here. `null` on the first stage. */
+    dropOff: number | null;
+    formattedValue: string;
+    datum: ChartDatum;
+}
+interface FunnelChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+    /** One row per stage, in the order they are walked. */
+    data: ChartDatum[];
+    /** Field holding the name of each stage. */
+    x: ChartXAxisConfig;
+    /** Field holding how many reached that stage. */
+    value: string;
+    /**
+     * Where each bar sits in its row.
+     *
+     * `center` is the funnel silhouette, `left` a plain ranked bar chart. The
+     * silhouette reads as a narrowing; the left alignment compares lengths more
+     * precisely. Both encode the value as a LENGTH — never as an area, which the
+     * eye cannot compare.
+     */
+    align?: "center" | "left";
+    /**
+     * Writes what each stage kept from the one before it.
+     *
+     * That ratio is the reason the chart exists: the absolute figures are a
+     * table, the step-to-step loss is the finding.
+     */
+    showConversion?: boolean;
+    /** Writes the figure reached at each stage. */
+    showValues?: boolean;
+    /** Caps the thickness of a stage. */
+    stageSize?: number;
+    /** Replaces the ordinal ramp — any CSS colours, first stage first. */
+    colors?: readonly string[];
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    tooltip?: boolean | ((stage: FunnelStage) => ReactNode);
+    tableView?: boolean | "toggle";
+    title?: ReactNode;
+    description?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    locale?: string;
+    plotLabel?: string;
+    /** Header of the value column of the data table. */
+    valueLabel?: string;
+    /** Header of the step-to-step conversion column. */
+    conversionLabel?: string;
+    /** Header of the step-to-step loss column. */
+    dropOffLabel?: string;
+    format?: (value: number) => string;
+    onStageClick?: (stage: FunnelStage) => void;
+}
+/**
+ * Ordered stages, and what is lost between them.
+ *
+ * The stages have an ORDER, which is why the colour comes from the ordinal
+ * ramp and not from the categorical slots: the eight slots answer "which
+ * one", and the answer here is "the third of five". A funnel painted in
+ * identity colours says its stages are unrelated categories, which is the one
+ * thing they are not.
+ *
+ * The value is encoded as a length, never as an area: the trapezoid silhouette
+ * of the classic funnel asks the reader to compare two surfaces, and two
+ * surfaces cannot be compared by eye. `align="center"` keeps the silhouette
+ * while the measure stays the width of each bar.
+ *
+ * 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;
+
+/** One task, as the tooltip and the click handler see it. */
+interface GanttTask {
+    index: number;
+    /** Stable identity, used by the dependencies. Falls back to the row index. */
+    id: string;
+    x: ChartXValue;
+    label: string;
+    /** Start, as a timestamp. `null` when the row carries no usable date. */
+    start: number | null;
+    /** End, as a timestamp. Equal to `start` on a milestone. */
+    end: number | null;
+    /** Share completed, from 0 to 1. `null` when the row says nothing. */
+    progress: number | null;
+    /** A point in time rather than a span. */
+    milestone: boolean;
+    /** Ids this task waits on. */
+    dependsOn: string[];
+    /** Name of the group the task belongs to, when there is one. */
+    group: string | null;
+    datum: ChartDatum;
+}
+interface GanttChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+    /** One row per task, in the order they are listed. */
+    data: ChartDatum[];
+    /** Field holding the name of each task. */
+    x: ChartXAxisConfig;
+    /** Field holding the start — a `Date`, a timestamp, or an ISO string. */
+    start: string;
+    /** Field holding the end. A row without one is drawn as a milestone. */
+    end?: string;
+    /** Field holding a stable id, which the dependencies point at. */
+    id?: string;
+    /** Field holding the share completed, from 0 to 1. */
+    progress?: string;
+    /** Field marking a row as a point in time rather than a span. */
+    milestone?: string;
+    /**
+     * Field holding the ids this task waits on, as an array.
+     *
+     * The arrows are drawn from the end of each predecessor to the start of the
+     * task: what a schedule is read for is rarely a single bar, it is what is
+     * blocking it.
+     */
+    dependencies?: string;
+    /** Field naming the group a task belongs to. Groups take the palette slots. */
+    group?: string;
+    /** Fixes the window shown. Defaults to the span of the tasks, plus air. */
+    domain?: [Date | number | string, Date | number | string];
+    /** Marks a moment with a rule. Pass `false` to leave it out. */
+    today?: Date | number | string | false;
+    /** Preferred number of ticks on the time axis. */
+    ticks?: number;
+    /** Caps the thickness of a bar. */
+    barSize?: number;
+    /** Height of a row. The chart's own height follows from it. */
+    rowSize?: number;
+    /** Colour of the bars when there are no groups. */
+    color?: string;
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    grid?: boolean;
+    legend?: boolean | ChartLegendPosition;
+    tooltip?: boolean | ((task: GanttTask) => ReactNode);
+    tableView?: boolean | "toggle";
+    title?: ReactNode;
+    description?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    margin?: Partial<ChartMargin>;
+    locale?: string;
+    plotLabel?: string;
+    startLabel?: string;
+    endLabel?: string;
+    progressLabel?: string;
+    todayLabel?: string;
+    /** Formats a date in the tooltip and the data table. */
+    formatDate?: (value: number) => string;
+    onTaskClick?: (task: GanttTask) => void;
+}
+/**
+ * Tasks in time, with their dependencies and their milestones.
+ *
+ * More a planning component than a chart, and it says so: there is no measure
+ * on the value axis, only dates. What it shows that a list cannot is the
+ * overlap — two tasks running at once, and the arrow saying one of them
+ * cannot start until the other is done.
+ *
+ * It does not overlap `Calendar`, which picks a date and hands it back.
+ * Nothing is selected here: a schedule is read, and a row that has no width
+ * on the time axis is a milestone rather than a day.
+ *
+ * The time axis lands on calendar boundaries — Mondays, the first of the
+ * 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;
+
+/** What a step does to the running total. */
+type WaterfallKind = "increase" | "decrease" | "total";
+/** One step, as the tooltip, the legend and the click handler see it. */
+interface WaterfallStep {
+    index: number;
+    x: ChartXValue;
+    label: string;
+    /** The contribution of the step, or the figure a total row lands on. */
+    value: number | null;
+    /** Running total the bar grows from. */
+    start: number;
+    /** Running total the bar grows to. */
+    end: number;
+    kind: WaterfallKind;
+    formattedValue: string;
+    /** The running total after the step, formatted. */
+    formattedEnd: string;
+    datum: ChartDatum;
+}
+interface WaterfallChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+    /** One row per step, in the order they are read. */
+    data: ChartDatum[];
+    /** Field holding the name of each step. */
+    x: ChartXAxisConfig;
+    y?: ChartYAxisConfig;
+    /** Field holding what the step adds to, or takes from, the running total. */
+    value: string;
+    /**
+     * Field marking a row as a checkpoint rather than a contribution.
+     *
+     * A truthy value draws the bar from zero to the running total instead of
+     * floating it — the opening balance, a subtotal, the closing figure. When
+     * such a row also carries a `value`, that figure wins and the running total
+     * is reset to it: a declared total that disagrees with the sum of the steps
+     * is a discrepancy worth seeing, not one worth hiding.
+     */
+    total?: string;
+    /** Figure the running total starts from. Defaults to `0`. */
+    start?: number;
+    /**
+     * `vertical` draws columns, `horizontal` draws bars — the same call as
+     * anywhere else: horizontal as soon as the step names are long.
+     */
+    orientation?: CartesianOrientation;
+    /**
+     * Draws the thin rule joining one bar to the next.
+     *
+     * On by default, and it is not decoration: without it a floating bar has no
+     * visible tie to the one before, and the chart reads as a set of unrelated
+     * marks rather than as one running total.
+     */
+    connectors?: boolean;
+    /** Writes each step's contribution at the end of its bar, where it fits. */
+    showValues?: boolean;
+    /** Caps the thickness of a mark. */
+    barSize?: number;
+    /** Replaces the three colours. Any CSS colours. */
+    colors?: {
+        increase?: string;
+        decrease?: string;
+        total?: string;
+    };
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    grid?: ChartGridLines;
+    legend?: boolean | ChartLegendPosition;
+    tooltip?: boolean | ((step: WaterfallStep) => ReactNode);
+    tableView?: boolean | "toggle";
+    title?: ReactNode;
+    description?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    margin?: Partial<ChartMargin>;
+    locale?: string;
+    plotLabel?: string;
+    /** Header of the contribution column of the data table. */
+    valueLabel?: string;
+    /** Header of the running total column, and label of the total legend entry. */
+    totalLabel?: string;
+    increaseLabel?: string;
+    decreaseLabel?: string;
+    format?: (value: number) => string;
+    onStepClick?: (step: WaterfallStep) => void;
+}
+/**
+ * How one figure became another.
+ *
+ * Every contribution between a start and an end, floating between the running
+ * total before it and after it — the budget variance chart. It answers a
+ * question no other shape of the kit can: a bar chart of the same steps shows
+ * their sizes and says nothing about how they add up.
+ *
+ * Colour comes from the diverging pair, because that is exactly what a step
+ * is: a move above or below the running total. It says the direction, never
+ * the verdict — a cost falling and a revenue falling wear the same colour,
+ * and the row label is what tells them apart.
+ *
+ * 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;
+
 interface CheckboxProps extends Omit<ComponentPropsWithoutRef<"input">, "size" | "onChange" | "type"> {
     checked?: boolean;
     defaultChecked?: boolean;
@@ -2279,6 +3365,17 @@ 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;
     margin?: Partial<ChartMargin>;
@@ -2298,7 +3395,7 @@ interface LineChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWit
  * invent a correlation the data does not carry; plot them as two charts, or
  * index both to a common base.
  */
-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, onPointClick, curve, forecastFrom, forecastLabel, markers, connectNulls, referenceLines, annotations, legendToggle, margin, locale, plotLabel, className, ...props }: LineChartProps): react_jsx_runtime.JSX.Element;
 
 interface ModalProps {
     isOpen: boolean;
@@ -2411,6 +3508,17 @@ interface PieChartProps extends Omit<ComponentPropsWithoutRef<"figure">, "childr
     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: {
@@ -2429,7 +3537,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, 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";
@@ -3464,6 +4572,59 @@ interface UILabels {
     chartValue: string;
     /** Header of the "aimed at" column of a bullet chart's data table. */
     chartTarget: string;
+    /** Legend entry and tooltip row for a waterfall step that adds. */
+    chartIncrease: string;
+    /** Legend entry and tooltip row for a waterfall step that takes away. */
+    chartDecrease: string;
+    /** Header of the running-total column of a waterfall's data table. */
+    chartRunningTotal: string;
+    /** Header of the "kept from the previous stage" column of a funnel. */
+    chartConversion: string;
+    /** Header of the "lost since the previous stage" column of a funnel. */
+    chartDropOff: string;
+    /** Header of the gap column of a dumbbell chart's data table. */
+    chartChange: string;
+    /** Header of the median column of a box plot's data table. */
+    chartMedian: string;
+    /** Header of the observation-count column of a box plot's data table. */
+    chartCount: string;
+    /** Header of the outlier column of a box plot's data table. */
+    chartOutliers: string;
+    /** Header of the opening-price column of a candlestick's data table. */
+    chartOpen: string;
+    /** Header of the high column of a candlestick's data table. */
+    chartHigh: string;
+    /** Header of the low column of a candlestick's data table. */
+    chartLow: string;
+    /** Header of the closing-price column of a candlestick's data table. */
+    chartClose: string;
+    /** Legend entry for a candlestick session that closed up. */
+    chartRise: string;
+    /** Legend entry for a candlestick session that closed down. */
+    chartFall: string;
+    /** Header of the start column of a schedule's data table. */
+    chartStart: string;
+    /** Header of the end column of a schedule's data table. */
+    chartEnd: string;
+    /** Header of the completion column of a schedule's data table. */
+    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;
 }
 /** English labels, used when no provider is mounted. */
 declare const defaultUILabels: UILabels;
@@ -3549,4 +4710,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, 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_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, Calendar, type CalendarColor, type CalendarDateRange, type CalendarDayState, type CalendarLabels, type CalendarMode, type CalendarProps, type CalendarSize, type CalendarWeekStart, 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, 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, Header, type HeaderProps, Heatmap, type HeatmapCell, type HeatmapProps, HelpButton, type HelpButtonProps, 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, 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, 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, cn, createDefaultField, createDefaultTable, createDivergingScale, createSequentialScale, defaultUILabels, findOwnedLayers, frenchUILabels, generateFieldId, generateRelationId, generateSQL, generateTableId, getFocusableElements, getOrdinalColor, getSeriesColor, getSeriesLabel, hideOthers, isElementVisible, isFocusable, rampColor, registerFloatingLayer, resetFacetWarnings, resolveSeriesColor, toLegendItems, 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_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 ChartAnnotation, type ChartAnnotationBase, ChartAnnotationLayer, type ChartAnnotationLayerProps, ChartAxis, type ChartAxisOrientation, type ChartAxisProps, type ChartBandAnnotation, type ChartColorScale, ChartContainer, type ChartContainerProps, type ChartContainerRenderArgs, type ChartCurve, type ChartDatum, type ChartDimensions, 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 ChartPattern, ChartPatternDefs, type ChartPatternDefsProps, type ChartPatternEntry, type ChartPeriod, ChartPeriodPicker, type ChartPeriodPickerProps, type ChartPeriodPreset, type ChartPoint, type ChartPointAnnotation, 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_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 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, createPeriod, createSequentialScale, defaultUILabels, describeAnnotations, endOfDay, findOwnedLayers, formatPeriodRange, formatTimeTick, frenchUILabels, generateFieldId, generateRelationId, generateSQL, generateTableId, getFocusableElements, getOrdinalColor, getPattern, getSeriesColor, getSeriesLabel, hideOthers, isElementVisible, isFocusable, niceTimeTicks, patternBackground, patternFill, patternId, quantile, quantileSorted, rampColor, registerFloatingLayer, resetBarChartWarnings, resetDumbbellWarnings, resetFacetWarnings, resolvePeriodPreset, resolveSeriesColor, samePeriod, startOfDay, sturgesBins, toLegendItems, toTimestamp, useChartSize, useClickOutside, useDialogA11y, useDropdownContext, useFocusItem, useKeyboardNavigation, usePositioning, useSidebar, useUILabels, useWizard };