@synertech/ui 0.40.1 → 0.42.0

package/dist/index.d.ts

@@ -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. */
@@ -239,6 +249,13 @@ interface ChartLegendItem {
     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";
 }
 /** A tick, already placed on its axis. */
 interface ChartTick {
@@ -354,6 +371,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 histogram warning. Test helper. */
+declare function resetBarChartWarnings(): void;
 type BarChartOrientation = CartesianOrientation;
 interface BarChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWithoutRef<"figure">, keyof CartesianChartBaseProps | "children" | "title"> {
     /**
@@ -365,9 +431,49 @@ interface BarChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWith
     orientation?: BarChartOrientation;
     /** `none` groups the series side by side; the others stack them. */
     stack?: ChartStackMode;
+    /**
+     * Reads the bars against a reference instead of against zero.
+     *
+     * `true` centres on zero and a number centres on that value: the baseline
+     * moves there, bars run both ways from it, and a lone series takes the
+     * diverging ramp — the gap to a target, an index against its base.
+     *
+     * A series KEY centres the stack on that series instead, splitting it evenly
+     * on both sides: the Likert layout, where the middle of an agreement scale
+     * has to sit on the middle of the chart.
+     *
+     * The ramp says which side of the reference a bar falls on and how far. It
+     * never says whether that is good news — a schedule slipping is "above", and
+     * 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;
@@ -388,7 +494,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, 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, legendToggle, margin, locale, plotLabel, className, ...props }: BarChartProps): react_jsx_runtime.JSX.Element;
 
 type BannerVariant = "notification" | "hero" | "promotion";
 type BannerType = "info" | "success" | "warning" | "error" | "default";
@@ -428,6 +534,83 @@ 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"> {
+    /** One row per measure. */
+    data: ChartDatum[];
+    /** Field holding the name of each row. */
+    x: ChartXAxisConfig;
+    /** Field holding the figure reached. */
+    value: string;
+    /** Field holding the figure aimed at. Drawn as a tick across the track. */
+    target?: string;
+    /**
+     * Field holding the qualitative range boundaries — an ascending array of
+     * numbers, painted as grey bands behind the bar.
+     */
+    ranges?: string;
+    /** Fixed bounds for every row. Implies a shared scale and a value axis. */
+    domain?: [number, number];
+    /**
+     * `row` gives each row its own scale, which is what lets a revenue and an
+     * NPS share a panel. `shared` puts them all on one scale and draws the value
+     * axis — only meaningful when the rows carry the same unit.
+     */
+    normalize?: "row" | "shared";
+    /** Writes the figure reached after each track. */
+    showValues?: boolean;
+    /** Thickness of a track. */
+    trackSize?: number;
+    /** Replaces the range greys — any CSS colours, darkest first. */
+    rangeColors?: readonly string[];
+    /** Colour of the measure bar. Defaults to the first palette slot. */
+    color?: string;
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    tooltip?: boolean | ((row: BulletRow) => 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 target column of the data table. */
+    targetLabel?: string;
+    format?: (value: number) => string;
+    onRowClick?: (row: BulletRow) => void;
+}
+/** One measure, as the tooltip and the click handler see it. */
+interface BulletRow {
+    index: number;
+    x: ChartXValue;
+    label: string;
+    value: number | null;
+    target: number | null;
+    ranges: number[];
+    formattedValue: string;
+    formattedTarget: string;
+    /** `value / target`, or `null` when either is missing. */
+    attainment: number | null;
+    datum: ChartDatum;
+}
+/**
+ * What was reached, what was aimed at, and what counts as good — on one line.
+ *
+ * The densest readout of the kit: three measures fit where three gauges would
+ * take the page. It completes `StatCard` rather than competing with it — the
+ * card gives a figure and how it moved, the bullet gives where it stands
+ * against its target.
+ *
+ * Each row is scaled on its own by default, which is what lets a revenue in
+ * dollars and an NPS out of 100 share a panel. That also means there is no
+ * 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;
+
 interface ButtonProps extends ComponentPropsWithoutRef<"button"> {
     label?: string;
     children?: ReactNode;
@@ -637,6 +820,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;
@@ -793,6 +1215,172 @@ interface ChartTooltipContentProps {
  */
 declare function ChartTooltipContent({ title, points }: ChartTooltipContentProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Number of categorical slots the palette holds.
+ *
+ * Eight is not a round number picked for looks: past it, a generated hue is
+ * indistinguishable from an existing slot for a colour-blind reader. A ninth
+ * series is folded into an "Other" bucket, faceted into several charts, or
+ * given a second channel (shape, texture) — never a ninth colour.
+ */
+declare const CHART_PALETTE_SIZE = 8;
+/**
+ * The eight slots, in the order they are assigned.
+ *
+ * The order is the safety mechanism — it was picked among the orderings that
+ * keep every neighbouring pair distinguishable under simulated protanopia and
+ * deuteranopia, in both themes. The values live in `src/styles/index.css`, so
+ * an application can rebrand the kit without forking a component.
+ */
+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
+ * compare adjacent slots, which all eight clear; with every pair in play, only
+ * the first three do.
+ */
+declare const CHART_ALL_PAIRS_LIMIT = 3;
+/**
+ * Colour of the series sitting at `index`.
+ *
+ * Colour follows the series' position in the `series` array — its identity —
+ * so hiding or filtering one series never repaints the others.
+ */
+declare function getSeriesColor(index: number, override?: string): string;
+/**
+ * Colour of a series, taking the chart's `emphasis` into account: the
+ * emphasised series keeps its slot, every other one drops to grey.
+ */
+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[];
+/** 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. */
+declare const CHART_ORDINAL_COLORS: readonly ["var(--color-chart-ord-1)", "var(--color-chart-ord-2)", "var(--color-chart-ord-3)", "var(--color-chart-ord-4)", "var(--color-chart-ord-5)"];
+/**
+ * Two opposed poles around a neutral middle: a gap to a reference, a Likert
+ * scale. Blue on one side, orange on the other — two cool hues never read as
+ * opposites.
+ */
+declare const CHART_DIVERGING_COLORS: readonly ["var(--color-chart-div-1)", "var(--color-chart-div-2)", "var(--color-chart-div-3)", "var(--color-chart-div-4)", "var(--color-chart-div-5)", "var(--color-chart-div-6)", "var(--color-chart-div-7)"];
+/** Index of the neutral step of `CHART_DIVERGING_COLORS`. */
+declare const CHART_DIVERGING_NEUTRAL_INDEX = 3;
+declare const CHART_SEQUENTIAL_DARK_STOPS: readonly [false, false, false, false, true, true];
+declare const CHART_ORDINAL_DARK_STOPS: readonly [false, false, true, true, true];
+declare const CHART_DIVERGING_DARK_STOPS: readonly [true, false, false, false, false, false, true];
+/**
+ * Past this many colour classes, two neighbouring cells stop being tellable
+ * apart — the reader sees a texture rather than a scale. A finer grid is read
+ * as a continuous wash, which is what the scale does when `steps` is unset.
+ */
+declare const CHART_MAX_COLOR_CLASSES = 7;
+/** A colour ramp, already bound to the values it has to paint. */
+interface ChartColorScale {
+    /** Colour of a value. Out-of-domain values clamp to the nearest end. */
+    (value: number): string;
+    readonly domain: readonly [number, number];
+    /** The stops, in ramp order — what a legend draws its gradient from. */
+    readonly colors: readonly string[];
+    /** Number of classes the ramp was cut into, or `null` when it is continuous. */
+    readonly steps: number | null;
+    /** Where a value falls along the ramp, from 0 to 1. */
+    position(value: number): number;
+    /**
+     * `true` when the colour under `value` is dark enough that text written on
+     * it has to be light. Always `false` for a ramp brought by the caller,
+     * which the kit knows nothing about.
+     */
+    onDark(value: number): boolean;
+}
+/**
+ * Colour at `t` (0 to 1) along a ramp.
+ *
+ * Between two stops the colour is mixed in OKLab rather than snapped to the
+ * nearer one: a ramp cut into six classes reads as six bands, which is a lie
+ * about a measure that varies continuously. The mix happens in CSS, so the
+ * stops stay overridable variables instead of hex frozen into the bundle.
+ */
+declare function rampColor(colors: readonly string[], t: number): string;
+interface SequentialScaleOptions {
+    /** Cuts the ramp into that many classes instead of leaving it continuous. */
+    steps?: number;
+    /** Replaces the stops — any CSS colours, usually custom properties. */
+    colors?: readonly string[];
+    /**
+     * One flag per stop, saying which ones need light text written on them.
+     * Only worth passing alongside `colors`: the built-in ramps carry their own.
+     */
+    darkStops?: readonly boolean[];
+}
+/**
+ * Maps a magnitude onto the sequential ramp.
+ *
+ * A zero-width domain pins everything to the light end: with a single value
+ * on the grid there is no magnitude to show, and painting it as the maximum
+ * would invent one.
+ */
+declare function createSequentialScale(domain: readonly [number, number], options?: SequentialScaleOptions): ChartColorScale;
+interface DivergingScaleOptions extends SequentialScaleOptions {
+    /** Value the two directions are measured from. Defaults to `0`. */
+    center?: number;
+    /**
+     * Stretches the shorter arm so both cover the same distance. On by default:
+     * with independent arms, a gap of +5 and a gap of −5 come out at different
+     * intensities, which reads as one of them being the bigger miss.
+     */
+    symmetric?: boolean;
+}
+/**
+ * Maps a signed gap onto the diverging pair, neutral at the centre.
+ *
+ * The ramp says which side of the reference a value falls on and how far — it
+ * never says whether that is good news. A schedule slipping is "above", and
+ * above is not good; that judgement belongs to the status colours, which are
+ * reserved for exactly that and always carry a label.
+ */
+declare function createDivergingScale(domain: readonly [number, number], options?: DivergingScaleOptions): ChartColorScale;
+/**
+ * Colour of the `index`-th band of an ordered set.
+ *
+ * Spread across the whole ramp rather than taken from its start, so three
+ * bands use the light, the middle and the dark end instead of three steps
+ * that look alike.
+ */
+declare function getOrdinalColor(index: number, count?: number, colors?: readonly string[]): string;
+
+interface ChartScaleLegendProps extends Omit<ComponentPropsWithoutRef<"div">, "children"> {
+    /** The ramp the chart paints with — usually the one it built for its marks. */
+    scale: ChartColorScale;
+    /** What the colour encodes. Say the measure and its unit, not "legend". */
+    label?: ReactNode;
+    /** Formats the numbers under the bar. */
+    format?: (value: number) => string;
+    /** How many numbers to place. Ignored by a stepped ramp, which labels its classes. */
+    ticks?: number;
+    size?: ChartSize;
+    /** Thickness of the colour bar. */
+    thickness?: number;
+    locale?: string;
+}
+/**
+ * The legend of a colour ramp.
+ *
+ * Mandatory as soon as a colour encodes a magnitude: without it a heat map
+ * shows a pattern and states no value. It is the piece that turns "this cell
+ * is darker" into "this cell is 4 200".
+ *
+ * The bar is laid out in CSS rather than measured, so it needs no container
+ * observation and renders on the server.
+ */
+declare function ChartScaleLegend({ scale, label, format, ticks, size, thickness, locale, className, ...props }: ChartScaleLegendProps): react_jsx_runtime.JSX.Element;
+
 interface ChartTableViewProps extends ComponentPropsWithoutRef<"div"> {
     data: ChartDatum[];
     series: ChartSeries[];
@@ -816,6 +1404,90 @@ interface ChartTableViewProps extends ComponentPropsWithoutRef<"div"> {
  */
 declare function ChartTableView({ data, series, xKey, xLabel, formatX, formatValue, caption, emptyLabel, className, ...props }: ChartTableViewProps): react_jsx_runtime.JSX.Element;
 
+/** One panel, ready to be drawn. */
+interface ChartFacetPanel {
+    /** Stable identity of the panel — the raw value of the splitting field. */
+    key: string;
+    /** That value, formatted. */
+    label: string;
+    /** The rows belonging to this panel, in their original order. */
+    data: ChartDatum[];
+    /**
+     * The value domain EVERY panel has to draw against. Hand it straight to the
+     * chart: panels on free scales cannot be compared, which is the only reason
+     * to put them side by side.
+     */
+    domain: [number, number];
+    index: number;
+    count: number;
+}
+interface ChartFacetsProps extends Omit<ComponentPropsWithoutRef<"div">, "children" | "title"> {
+    data: ChartDatum[];
+    /** Field the panels are split on. */
+    by: string;
+    /** Fields the shared domain is measured over — the series each panel draws. */
+    values: string[];
+    /** Fixed bounds instead of the ones measured across the whole set. */
+    domain?: [number, number];
+    /**
+     * Keeps zero inside the shared domain. Off by default, which suits the lines
+     * and sparklines a facet grid usually holds; turn it on for bars, which are
+     * read for the length of their mark.
+     */
+    includeZero?: boolean;
+    /** Target tick count, which drives how the shared bounds are rounded. */
+    ticks?: number;
+    /** Explicit panel order. Values missing from the data are skipped. */
+    order?: ChartXValue[];
+    /** Orders the panels by their total instead. */
+    sort?: "none" | "asc" | "desc";
+    /** Fixed number of columns. Defaults to as many as `minPanelWidth` allows. */
+    columns?: number;
+    /** Narrowest a panel may get before the grid drops to fewer columns. */
+    minPanelWidth?: number;
+    formatLabel?: (value: ChartXValue, index: number) => string;
+    /** Hides the panel captions — for a grid whose charts carry their own title. */
+    showLabels?: boolean;
+    title?: ReactNode;
+    description?: ReactNode;
+    size?: ChartSize;
+    locale?: string;
+    emptyState?: ReactNode;
+    children: (panel: ChartFacetPanel) => ReactNode;
+}
+/**
+ * Small multiples: one chart repeated across a dimension, on a shared scale.
+ *
+ * Not a chart — a layout. It is the answer two components of the kit already
+ * give without it existing: `ScatterChart` caps itself at three series and
+ * `PieChart` folds its tail, both on the grounds that the rest belongs in
+ * separate panels.
+ *
+ * What makes it work is the one thing it computes itself: the value domain is
+ * measured across the whole set and imposed on every panel. Panels on free
+ * scales look comparable and are not, which is worse than not faceting at all.
+ *
+ * ```tsx
+ * <ChartFacets data={rows} by="region" values={["revenue"]}>
+ *   {({ data, domain, label }) => (
+ *     <LineChart
+ *       data={data}
+ *       series={[{ key: "revenue" }]}
+ *       x={{ key: "month" }}
+ *       y={{ domain }}
+ *       plotLabel={label}
+ *       height={140}
+ *     />
+ *   )}
+ * </ChartFacets>
+ * ```
+ *
+ * No hooks: the grid is laid out in CSS, so it renders on the server.
+ */
+declare function ChartFacets({ data, by, values, domain, includeZero, ticks, order, sort, columns, minPanelWidth, formatLabel, showLabels, title, description, size, locale, emptyState, children, className, ...props }: ChartFacetsProps): react_jsx_runtime.JSX.Element;
+/** Resets the one-shot panel-count warning. Test helper. */
+declare function resetFacetWarnings(): void;
+
 /**
  * Width a chart draws at before its container has been measured.
  *
@@ -847,48 +1519,414 @@ interface UseChartSizeResult<T extends HTMLElement> {
 declare function useChartSize<T extends HTMLElement = HTMLDivElement>(options?: UseChartSizeOptions): UseChartSizeResult<T>;
 
 /**
- * Number of categorical slots the palette holds.
+ * Ticks for an axis carrying dates.
  *
- * Eight is not a round number picked for looks: past it, a generated hue is
- * indistinguishable from an existing slot for a colour-blind reader. A ninth
- * series is folded into an "Other" bucket, faceted into several charts, or
- * given a second channel (shape, texture) — never a ninth colour.
+ * `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.
  */
-declare const CHART_PALETTE_SIZE = 8;
+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;
+}
 /**
- * The eight slots, in the order they are assigned.
+ * Ticks covering `[min, max]`, landing on calendar boundaries.
  *
- * The order is the safety mechanism — it was picked among the orderings that
- * keep every neighbouring pair distinguishable under simulated protanopia and
- * deuteranopia, in both themes. The values live in `src/styles/index.css`, so
- * an application can rebrand the kit without forking a component.
+ * `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 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 function niceTimeTicks(min: number, max: number, count?: number): TimeTickScale;
 /**
- * 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
- * compare adjacent slots, which all eight clear; with every pair in play, only
- * the first three do.
+ * 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 const CHART_ALL_PAIRS_LIMIT = 3;
+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;
+}
 /**
- * Colour of the series sitting at `index`.
+ * Two points per item, and the distance between them.
  *
- * Colour follows the series' position in the `series` array — its identity —
- * so hiding or filtering one series never repaints the others.
+ * 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 getSeriesColor(index: number, override?: string): string;
+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;
+}
 /**
- * Colour of a series, taking the chart's `emphasis` into account: the
- * emphasised series keeps its slot, every other one drops to grey.
+ * 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 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[];
+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;
@@ -1886,6 +2924,86 @@ declare namespace Label {
     var displayName: string;
 }
 
+interface HeatmapProps extends Omit<ComponentPropsWithoutRef<"figure">, "children" | "title"> {
+    /** One row per cell: its column, its row and its value. */
+    data: ChartDatum[];
+    /** Field holding the column each cell belongs to. */
+    x: ChartXAxisConfig;
+    /** Field holding the row each cell belongs to. */
+    y: ChartXAxisConfig;
+    /** Field holding the value the colour encodes. */
+    value: string;
+    /** Formats a value, in the cells, the legend, the tooltip and the table. */
+    format?: (value: number) => string;
+    /** Bounds the ramp covers. Defaults to the extent of the data. */
+    domain?: [number, number];
+    /**
+     * `sequential` paints a magnitude, `diverging` a gap on either side of
+     * `center` — a correlation matrix, a variance against a target.
+     */
+    scale?: "sequential" | "diverging";
+    /** Middle of a diverging ramp. Defaults to `0`. */
+    center?: number;
+    /**
+     * Cuts the ramp into that many classes. Left unset the wash is continuous,
+     * which is how a fine grid is read anyway.
+     */
+    steps?: number;
+    /** Replaces the ramp stops — any CSS colours. */
+    colors?: readonly string[];
+    /** Column order. Defaults to first appearance in the data. */
+    xDomain?: ChartXValue[];
+    /** Row order. Defaults to first appearance in the data. */
+    yDomain?: ChartXValue[];
+    /** Surface gap between two cells. */
+    cellGap?: number;
+    cellRadius?: number;
+    /** Writes the value inside each cell that has room for it. */
+    showValues?: boolean;
+    height?: number;
+    width?: number;
+    size?: ChartSize;
+    /** The scale legend. Mandatory reading, so it shows unless turned off. */
+    legend?: boolean | ChartLegendPosition;
+    /** What the colour encodes — the measure and its unit. */
+    legendLabel?: ReactNode;
+    tooltip?: boolean | ((cell: HeatmapCell) => ReactNode);
+    tableView?: boolean | "toggle";
+    title?: ReactNode;
+    description?: ReactNode;
+    loading?: boolean;
+    emptyState?: ReactNode;
+    locale?: string;
+    plotLabel?: string;
+    onCellClick?: (cell: HeatmapCell) => void;
+}
+/** A cell, as the tooltip and the click handler see it. */
+interface HeatmapCell {
+    x: ChartXValue;
+    y: ChartXValue;
+    xLabel: string;
+    yLabel: string;
+    /** `null` when the pair is missing from the data. */
+    value: number | null;
+    formattedValue: string;
+    color: string;
+    datum?: ChartDatum;
+}
+/**
+ * A magnitude on a grid: load by day and hour, retention by cohort, a
+ * correlation matrix.
+ *
+ * The one chart of the kit where colour carries the measure rather than the
+ * identity — which is why the scale legend is on by default and why the data
+ * table matters more here than anywhere else. A grid without its legend shows
+ * a pattern and states no value.
+ *
+ * The ramp stays continuous unless `steps` cuts it: past seven classes two
+ * 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;
+
 interface LineChartProps extends CartesianChartBaseProps, Omit<ComponentPropsWithoutRef<"figure">, keyof CartesianChartBaseProps | "children" | "title"> {
     curve?: ChartCurve;
     /**
@@ -3083,6 +4201,48 @@ interface UILabels {
     chartLoading: string;
     /** Bucket the smallest slices of a pie chart are folded into. */
     chartOther: string;
+    /** Header of the "reached" column of a bullet chart's data table. */
+    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;
 }
 /** English labels, used when no provider is mounted. */
 declare const defaultUILabels: UILabels;
@@ -3168,4 +4328,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, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, CHART_ALL_PAIRS_LIMIT, CHART_MUTED_COLOR, CHART_PALETTE_SIZE, 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, ChartContainer, type ChartContainerProps, type ChartContainerRenderArgs, type ChartCurve, type ChartDatum, type ChartDimensions, ChartGrid, type ChartGridLines, type ChartGridProps, ChartLegend, type ChartLegendItem, type ChartLegendMarker, type ChartLegendPosition, type ChartLegendProps, type ChartMargin, type ChartPoint, type ChartPointEvent, type ChartReferenceLine, 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, 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, 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 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, defaultUILabels, findOwnedLayers, frenchUILabels, generateFieldId, generateRelationId, generateSQL, generateTableId, getFocusableElements, getSeriesColor, getSeriesLabel, hideOthers, isElementVisible, isFocusable, registerFloatingLayer, 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_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 };