@skdx/angular-charts 0.33.0 → 0.34.1

package/types/skdx-angular-charts-internal.d.ts

@@ -1,86 +1,995 @@
+import * as _skdx_angular_charts_internal from '@skdx/angular-charts/internal';
 import * as _angular_core from '@angular/core';
 
+/** A plotted value; `null` (or `NaN`) is a gap. */
+type Value = number | null;
+/** A stable identifier of a series, datum, node, link or feature; defaults to the item's name. */
+type ChartItemId = string | number;
+/**
+ * Locates one item, or a set of items, across a chart: every field given must match. `{ series }`
+ * is a whole series, `{ series, index }` one point, `{ id }` one datum/node/feature/link.
+ * Ids fall back to names, so `{ id: 'EMEA' }` finds a slice named EMEA that has no explicit id.
+ */
+interface ChartItemRef {
+    id?: ChartItemId | undefined;
+    series?: ChartItemId | undefined;
+    index?: number | undefined;
+    category?: string | undefined;
+}
+/** A selection: refs, or bare ids as `{ id }` sugar (`selected="EMEA"` selects the EMEA item). */
+type Selection = ChartItemId | ChartItemRef | (ChartItemId | ChartItemRef)[];
+/** Common identity and annotation metadata a datum-like object may carry. */
+interface Identified {
+    /** Stable identifier used by selection, highlighting, events and tests. @default the name */
+    id?: ChartItemId | undefined;
+}
 /** One plotted series: a name for the legend/title and a value per category. */
-interface Series {
+interface Series extends Identified {
     name: string;
-    data: number[];
+    data: Value[];
     /** Any CSS color; defaults to the next `@skdx/tokens` series color. */
     color?: string | undefined;
 }
-/** One named value, for the part-of-whole charts (pie, funnel). */
-interface Datum {
+/** One named value, for the part-of-whole charts (pie, funnel, radial bar). */
+interface Datum extends Identified {
     name: string;
     value: number;
     color?: string | undefined;
 }
+/**
+ * How values are written: a function, or a named `Intl` style. `percent` expects fractions
+ * (0.25 → 25%), `duration` expects seconds, the date styles expect epoch milliseconds.
+ */
+type Format = ((value: number) => string) | {
+    style: 'integer' | 'decimal' | 'percent' | 'currency' | 'compact' | 'scientific' | 'date' | 'time' | 'datetime' | 'duration';
+    /** BCP-47 locale; defaults to the runtime locale. */
+    locale?: string | undefined;
+    /** ISO 4217 code for `currency`. @default 'USD' */
+    currency?: string | undefined;
+    /** Fraction digits for the number styles. */
+    digits?: number | undefined;
+    /** Suffix written after the number, e.g. ` ms`. */
+    unit?: string | undefined;
+    /** IANA time zone for the date styles, e.g. `'UTC'`; defaults to the runtime zone. */
+    timeZone?: string | undefined;
+};
+/** Semantic color of a reference line or band. */
+type Variant = 'neutral' | 'primary' | 'success' | 'warning' | 'danger';
+/** Tooltip behaviour; `true`/`false` is shorthand for `{ enabled }`. */
+interface TooltipOptions {
+    /** @default true */
+    enabled?: boolean | undefined;
+    /**
+     * `item` shows the mark under the pointer; `axis` snaps to the nearest category and lists every
+     * series there (cartesian and candlestick charts; the same as `crosshair`). @default 'item'
+     */
+    trigger?: 'item' | 'axis' | undefined;
+    /** Replaces the tooltip text of a mark: one string, or one line per string. */
+    formatter?: ((item: ChartItem) => string | string[]) | undefined;
+    /** Rewrites the shared axis tooltip: the category line, then one line per series. */
+    axisFormatter?: ((rows: string[], index: number) => string[]) | undefined;
+    /**
+     * Render the tooltip as an HTML element positioned over the page instead of inside the svg,
+     * so it can escape a clipped or scaled container. @default false
+     */
+    portal?: boolean | undefined;
+    /** Where the box sits relative to its anchor; `auto` keeps it inside the canvas. @default 'auto' */
+    placement?: 'auto' | 'top' | 'bottom' | 'left' | 'right' | undefined;
+    /** Anchor the box to the pointer (`true`) or to the hovered mark (`false`). @default true */
+    followPointer?: boolean | undefined;
+}
+/** Legend layout; `true`/`false` is shorthand for `{ enabled }`. */
+interface LegendOptions {
+    /** @default true */
+    enabled?: boolean | undefined;
+    /** Above, below, or in a column beside the plot. @default 'top' */
+    position?: 'top' | 'bottom' | 'left' | 'right' | undefined;
+    /** Column width for `left`/`right`, in pixels. @default 120 */
+    width?: number | undefined;
+    /** Clicking or pressing Enter on an entry hides its series. @default true */
+    interactive?: boolean | undefined;
+    /** Entries beyond this many are summarized as `+N more`. */
+    maxItems?: number | undefined;
+    /** Rewrites an entry's text. */
+    formatter?: ((name: string) => string) | undefined;
+    /** Row alignment; `end` right-aligns (the default under `direction: 'rtl'`). @default 'start' */
+    align?: 'start' | 'end' | undefined;
+}
+/** Which marks stay full-strength while one is highlighted, and which fade. */
+interface HighlightScope {
+    /** Keep the highlighted item only, or its whole series. @default 'item' */
+    highlighted?: 'item' | 'series' | undefined;
+    /** Fade nothing, the rest of the item's series, or every other mark. @default 'global' */
+    faded?: 'none' | 'series' | 'global' | undefined;
+}
+/** Opt-in tabular fallback rendered next to the svg for screen readers. */
+interface AccessibleTableOptions {
+    /** Above this many rows a one-line summary is rendered instead of the table. @default 500 */
+    maxRows?: number | undefined;
+    /** Table caption. @default the chart label */
+    caption?: string | undefined;
+}
+/** A data problem found while laying out; reported through `onDataIssue`. */
+interface ChartDataIssue {
+    /** Machine-readable, e.g. `invalid-value`, `cycle`, `duplicate-id`, `unknown-node`. */
+    code: string;
+    severity: 'warning' | 'error';
+    message: string;
+    itemId?: ChartItemId | undefined;
+}
 interface Sized {
     /** @default 600 (300 for the round charts, 120 for sparklines) */
     width?: number | undefined;
     /** @default 300 (32 for sparklines) */
     height?: number | undefined;
-    /** Draw a legend row above the plot. @default false */
-    legend?: boolean | undefined;
-    /** Show a hover tooltip for the mark under the pointer. @default true */
-    tooltip?: boolean | undefined;
+    /** Draw a legend row above (or, with `{ position: 'bottom' }`, below) the plot. @default false */
+    legend?: boolean | LegendOptions | undefined;
+    /** Show a hover tooltip for the mark under the pointer; an object configures it. @default true */
+    tooltip?: boolean | TooltipOptions | undefined;
+    /** How values are written in ticks, labels and tooltips. @default the runtime locale's number format */
+    format?: Format | undefined;
+    /** Categorical series colors, cycled by series index. @default the `@skdx/tokens` scales */
+    palette?: string[] | undefined;
+    /** Series (by name) left out of the plot; their legend entries stay, dimmed. */
+    hiddenSeries?: string[] | undefined;
+    /**
+     * Selected items, outlined in the focus color. Part-of-whole and graph charts also give the
+     * selection a chart-specific meaning (a pulled-out slice, a lit neighbourhood).
+     */
+    selected?: Selection | undefined;
+    /** The item(s) under emphasis: everything outside `highlightScope` fades. `null` clears it. */
+    highlighted?: ChartItemRef | ChartItemId | (ChartItemRef | ChartItemId)[] | null | undefined;
+    highlightScope?: HighlightScope | undefined;
+    /** Draw a loading placeholder instead of the chart. @default false */
+    loading?: boolean | undefined;
+    /** Draw this message instead of the chart. */
+    error?: string | undefined;
+    /** Written in place of an empty chart. @default 'No data available' */
+    emptyMessage?: string | undefined;
+    /** Longer accessible description, rendered as the svg `<desc>`. */
+    description?: string | undefined;
+    /** Hide the chart from assistive technology, for charts that repeat adjacent text. @default false */
+    decorative?: boolean | undefined;
+    /** Render a visually hidden data table next to the svg. @default false */
+    accessibleTable?: boolean | AccessibleTableOptions | undefined;
+    /**
+     * Fade marks in on mount and transition them on data changes; `true` is 300 ms, a number sets
+     * the duration. Off under `prefers-reduced-motion` and above 1500 shapes. @default false
+     */
+    animate?: boolean | number | undefined;
+    /**
+     * Measure the container and lay the chart out at that width, so text keeps its size. An object
+     * also swaps in `compact` overrides below `breakpoint` pixels (default 480). @default false
+     */
+    responsive?: boolean | ResponsiveOptions | undefined;
+    /** Text direction; `rtl` right-aligns the legend and mirrors category axes. @default 'ltr' */
+    direction?: 'ltr' | 'rtl' | undefined;
 }
-type Curve = 'linear' | 'monotone';
-interface ChartInput extends Sized {
-    series: Series[];
-    /** X-axis labels; defaults to the 1-based index of each point. */
-    categories?: string[] | undefined;
+interface ResponsiveOptions {
+    /** @default 480 */
+    breakpoint?: number | undefined;
+    /** Input overrides applied while the measured width is below `breakpoint`, e.g. `{ legend: false, labels: false }`. */
+    compact?: Record<string, unknown> | undefined;
+}
+/** `smooth` is an alias of `monotone`: a cubic through every point that never overshoots. */
+type Curve = 'linear' | 'monotone' | 'smooth' | 'step' | 'stepBefore' | 'stepAfter';
+/** A horizontal or vertical line, or a shaded band, drawn behind the marks in data coordinates. */
+type Reference = {
+    label?: string | undefined;
+    /** @default 'neutral' */
+    variant?: Variant | undefined;
+    /** Any CSS color; wins over `variant`. */
+    color?: string | undefined;
+} & ({
+    y: number;
+    axis?: 'left' | 'right' | undefined;
+} | {
+    x: number | string | Date;
+} | {
+    y1: number;
+    y2: number;
+    axis?: 'left' | 'right' | undefined;
+} | {
+    x1: number | string | Date;
+    x2: number | string | Date;
+});
+interface AnnotationBase extends Identified {
+    label?: string | undefined;
+    /** @default 'neutral' */
+    variant?: Variant | undefined;
+    /** Any CSS color; wins over `variant`. */
+    color?: string | undefined;
+}
+/**
+ * Marks in data coordinates drawn over the plot: lines and bands (as `references`), a point or
+ * callout at `(x, y)`, free text, or a rectangle. `x` values name a category, number or date.
+ */
+type Annotation = AnnotationBase & ({
+    type: 'line';
+    y: number;
+    axis?: 'left' | 'right' | undefined;
+} | {
+    type: 'line';
+    x: number | string | Date;
+} | {
+    type: 'band';
+    y1: number;
+    y2: number;
+    axis?: 'left' | 'right' | undefined;
+} | {
+    type: 'band';
+    x1: number | string | Date;
+    x2: number | string | Date;
+} | {
+    type: 'point';
+    x: number | string | Date;
+    y: number;
+    axis?: 'left' | 'right' | undefined;
+} | {
+    type: 'callout';
+    x: number | string | Date;
+    y: number;
+    axis?: 'left' | 'right' | undefined;
+    /** Pixel offset of the text from the point. @default [16, -16] */
+    offset?: [number, number] | undefined;
+} | {
+    type: 'text';
+    x: number | string | Date;
+    y: number;
+    axis?: 'left' | 'right' | undefined;
+    text: string;
+} | {
+    type: 'rect';
+    x1: number | string | Date;
+    x2: number | string | Date;
+    y1: number;
+    y2: number;
+    axis?: 'left' | 'right' | undefined;
+});
+interface AxisOptions {
+    /** Identifies the axis so a series can pick it with `axis: id`. */
+    id?: string | undefined;
+    /**
+     * Which side a value axis is drawn on; extra axes stack outward. Horizontal charts draw
+     * `'left'`/`'bottom'` axes along the bottom and `'right'`/`'top'` axes along the top.
+     * @default 'left' (first), 'right' (second)
+     */
+    position?: 'left' | 'right' | 'top' | 'bottom' | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    /** @default 'linear' */
+    scale?: 'linear' | 'log' | 'sqrt' | undefined;
+    /** Overrides the chart-level `format` for this axis. */
+    format?: Format | undefined;
+    /** Axis title. */
+    label?: string | undefined;
+    /** Approximate tick count. @default 5 */
+    ticks?: number | undefined;
+    /** Draw grid lines at the ticks. @default true */
+    grid?: boolean | undefined;
+    /** Run the axis the other way (largest value at the origin). @default false */
+    reversed?: boolean | undefined;
+    /** Round the domain out to nice tick values; `false` keeps the exact data extent. @default true */
+    nice?: boolean | undefined;
+    /** Draw the axis line. @default true for the baseline */
+    showLine?: boolean | undefined;
+    /** Draw tick marks at the ticks. @default false */
+    showTicks?: boolean | undefined;
+    /** Tick mark length in pixels. @default 4 */
+    tickSize?: number | undefined;
+    /** Tick label rotation in degrees (category axes), e.g. `-45` for long labels. @default 0 */
+    tickRotation?: number | undefined;
+}
+interface XAxisOptions extends Pick<AxisOptions, 'format' | 'label' | 'grid' | 'showLine' | 'showTicks' | 'tickSize' | 'tickRotation'> {
+    /** Fixed category order and membership; categories not listed are dropped, missing ones are empty. */
+    domain?: Category[] | undefined;
+    /**
+     * `category` spaces points evenly; `time` and `linear` place numeric or date categories
+     * proportionally, so irregular timestamps land where they belong. Under `time`, ISO 8601
+     * strings are accepted as categories. @default 'category'
+     */
+    type?: 'category' | 'time' | 'linear' | undefined;
+}
+/** A visible window over the categories: indexes `[start, end)`. */
+interface Zoom {
+    start: number;
+    end: number;
+}
+/** An uncertainty around a value: a symmetric `±e`, or an absolute `[low, high]` pair. */
+type ErrorValue = number | [number, number] | null;
+/**
+ * A pure, deterministic step applied to a series' values in order. `movingAverage` leaves the
+ * first `window - 1` values as gaps; `difference` and `percentageChange` leave the first one.
+ */
+type SeriesTransform = {
+    type: 'cumulative';
+} | {
+    type: 'difference';
+} | {
+    type: 'percentageChange';
+} | {
+    type: 'movingAverage';
+    window: number;
+} | {
+    type: 'normalize';
+    to?: 'max' | 'sum' | undefined;
+} | {
+    type: 'rank';
+    order?: 'asc' | 'desc' | undefined;
+} | {
+    type: 'filter';
+    min?: number | undefined;
+    max?: number | undefined;
+}
+/** Orders the values (and, at chart level, the categories with them). */
+ | {
+    type: 'sort';
+    order?: 'asc' | 'desc' | undefined;
+}
+/** Folds every `every` consecutive values into one. */
+ | {
+    type: 'aggregate';
+    every: number;
+    method?: 'sum' | 'mean' | 'min' | 'max' | undefined;
+}
+/** Bins the values into counts (chart level: categories become bin labels). */
+ | {
+    type: 'bin';
+    bins?: number | undefined;
+    binWidth?: number | undefined;
+    domain?: [number, number] | undefined;
+};
+/**
+ * Point reduction for dense line and area series. `auto` samples above 2000 visible points with
+ * LTTB; `minmax` keeps the extremes of each bucket; `none` draws everything. Sampled charts keep
+ * their original point indexes in items and tooltips.
+ */
+type Sampling = 'none' | 'auto' | 'lttb' | 'minmax' | 'm4' | {
+    strategy: 'lttb' | 'minmax' | 'm4';
+    threshold?: number | undefined;
+};
+/** A bar, line or area series inside a cartesian chart. */
+interface CartesianSeries extends Series {
+    /** Defaults to the chart's own type: bars in a BarChart, lines in a LineChart, areas in an AreaChart. */
+    type?: 'bar' | 'line' | 'area' | undefined;
+    /** Which y axis the values are measured on: a side, or the `id` of an axis in `yAxis`. @default 'left' */
+    axis?: 'left' | 'right' | (string & {}) | undefined;
+    /** Overrides the chart-level curve for this line or area. */
+    curve?: Curve | undefined;
+    /** SVG dash pattern, e.g. `'4 3'`, for a line or area outline. */
+    dash?: string | undefined;
+    /** Area fill opacity, 0–1. @default 0.25 */
+    fillOpacity?: number | undefined;
+    /** Fade the area fill from `fillOpacity` at the line to transparent at the baseline. @default false */
+    gradient?: boolean | undefined;
+    /** Dots on line and area points. @default true up to 100 points, then off */
+    markers?: boolean | undefined;
+    /** Marker shape of a line or area series. @default 'circle' */
+    symbol?: MarkerSymbol | undefined;
+    /** Marker radius in pixels. @default 3 */
+    markerSize?: number | undefined;
+    /** Stack with the other series that share the same group; `true` is the default group. */
+    stack?: boolean | string | undefined;
+    /** Error bars per point: `±e` or `[low, high]`, drawn as whiskers on bars, lines and areas. */
+    errors?: ErrorValue[] | undefined;
+    /** Transforms applied to this series after the chart-level ones. */
+    transforms?: SeriesTransform[] | undefined;
 }
-interface BarChartInput extends ChartInput {
-    /** Stack series on top of each other instead of grouping them side by side. @default false */
-    stacked?: boolean | undefined;
+/** A shaded band between two series of values, e.g. a forecast interval. */
+interface RangeSeries extends Identified {
+    type: 'range';
+    name: string;
+    low: Value[];
+    high: Value[];
+    color?: string | undefined;
+    axis?: 'left' | 'right' | (string & {}) | undefined;
+    curve?: Curve | undefined;
+    /** A shaded band, floating bars from low to high, or two outlines. @default 'area' */
+    style?: 'area' | 'bar' | 'line' | undefined;
 }
-interface LineChartInput extends ChartInput {
-    /** Straight segments, or a monotone cubic that never overshoots the data. @default 'linear' */
+type Category = string | number | Date;
+interface ChartInput extends Sized {
+    series: (CartesianSeries | RangeSeries)[];
+    /** X-axis labels; defaults to the 1-based index of each point. Numbers and dates are written with `xAxis.format`. */
+    categories?: Category[] | undefined;
+    xAxis?: XAxisOptions | undefined;
+    /** The value axis, or several: each needs an `id` and a `position`; series pick one with `axis`. */
+    yAxis?: AxisOptions | AxisOptions[] | undefined;
+    /** Enables the second y axis on the right; series opt in with `axis: 'right'`. */
+    rightAxis?: AxisOptions | undefined;
+    references?: Reference[] | undefined;
+    /** Points, callouts, text and rectangles in data coordinates, drawn over the marks. */
+    annotations?: Annotation[] | undefined;
+    /** Write each value next to its mark. @default false */
+    labels?: boolean | undefined;
+    /** Straight segments, a monotone cubic, or steps, for the line and area series. @default 'linear' */
     curve?: Curve | undefined;
+    /** Draw lines across gaps instead of breaking them. @default false */
+    connectNulls?: boolean | undefined;
+    /** What a `null` does to a line: a gap, a straight bridge, or a zero. Wins over `connectNulls`. @default 'gap' */
+    nulls?: 'gap' | 'connect' | 'zero' | undefined;
+    /** Stack the series instead of grouping them; `'percent'` normalizes each category to 100%. @default false */
+    stacked?: boolean | 'percent' | undefined;
+    /**
+     * Where stacks stand: on zero, normalized to 100% (`expand`, the same as `stacked: 'percent'`),
+     * centred (`silhouette`) or with minimized wiggle (`wiggle`, a streamgraph). @default 'zero'
+     */
+    stackOffset?: 'zero' | 'expand' | 'silhouette' | 'wiggle' | undefined;
+    /** Bars grow along x, categories run down the y axis. Line and area series are ignored. @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    /** Corner radius of bars, in pixels. @default 0 */
+    radius?: number | undefined;
+    /** Share of each category slot left empty around its bars, 0–0.9. @default 0.2 */
+    barGap?: number | undefined;
+    /** Largest bar thickness in pixels; bars stay centred in their slot. */
+    barWidth?: number | undefined;
+    /** Smallest bar length in pixels, so tiny values stay visible. @default 0 */
+    minBarSize?: number | undefined;
+    /** Order categories by the first series' value, or by a named series. */
+    sort?: 'asc' | 'desc' | {
+        by: string;
+        order: 'asc' | 'desc';
+    } | undefined;
+    /** The value areas fill down to (and bars grow from). @default 0 */
+    baseline?: number | undefined;
+    /** Default fill opacity of areas, 0–1. @default 0.25 */
+    fillOpacity?: number | undefined;
+    /**
+     * `histogram`: each series' data is a raw sample, binned into equal-width bars.
+     * `cumulative`: each series is replaced by its running total.
+     */
+    transform?: 'histogram' | 'cumulative' | undefined;
+    /** Transforms applied to every non-range series, in order, after `transform`. */
+    transforms?: SeriesTransform[] | undefined;
+    /** Histogram bin count. @default Sturges' rule */
+    bins?: number | undefined;
+    /** Histogram bin width; wins over `bins`. */
+    binWidth?: number | undefined;
+    /** Histogram domain; samples outside are dropped. @default the sample extent */
+    binDomain?: [number, number] | undefined;
+    /** What histogram bars measure. @default 'count' */
+    binMode?: 'count' | 'density' | 'cumulative' | undefined;
+    /** Point reduction for dense line/area series. @default 'auto' */
+    sampling?: Sampling | undefined;
+    /** Visible category window, for zooming. */
+    zoom?: Zoom | undefined;
+    /** Draw a range strip under the plot showing the whole series and the zoomed window. @default false */
+    brush?: boolean | undefined;
+    /** Snap the hover tooltip to the nearest category and list every series' value there. @default false */
+    crosshair?: boolean | undefined;
 }
-type AreaChartInput = LineChartInput;
+type BarChartInput = ChartInput;
+type LineChartInput = ChartInput;
+type AreaChartInput = ChartInput;
 interface PieChartInput extends Sized {
     data: Datum[];
+    /** `donut` is a pie with `innerRadius` 0.6 unless set. @default 'pie' */
+    variant?: 'pie' | 'donut' | undefined;
     /** Hole radius as a fraction of the outer radius: 0 is a pie, 0.6 a donut. @default 0 */
     innerRadius?: number | undefined;
+    /** Outer radius as a fraction of the space available, leaving room around the pie. @default 1 */
+    outerRadius?: number | undefined;
     /** Write each slice's name and share on the slice. @default false */
     labels?: boolean | undefined;
+    /** Inside the slice, or outside with a connector. @default 'inside' */
+    labelPosition?: 'inside' | 'outside' | undefined;
+    /** Degrees clockwise from 12 o'clock where the first slice starts. @default 0 */
+    startAngle?: number | undefined;
+    /** Degrees clockwise from 12 o'clock where the last slice ends; `-90`/`90` makes a half circle. @default startAngle + 360 */
+    endAngle?: number | undefined;
+    /** Gap between slices, in degrees. @default 0 */
+    padAngle?: number | undefined;
+    /** Rounded slice corners, in pixels. @default 0 */
+    cornerRadius?: number | undefined;
+    /** Smallest angle a non-zero slice is drawn with, in degrees; the rest shrink to make room. @default 0 */
+    minAngle?: number | undefined;
+    /** How shares are written in labels and tooltips. @default whole percent */
+    percentFormat?: Format | undefined;
+    /** Order slices by value instead of input order. */
+    sort?: 'asc' | 'desc' | undefined;
+    /** Text in the middle of a donut, e.g. the total. */
+    centerLabel?: string | undefined;
 }
-interface ScatterSeries {
+/** A scatter point: an `[x, y]` pair, an `[x, y, size]` triple, or an object with an optional label. */
+type ScatterPoint = [number, number] | [number, number, number] | (Identified & {
+    x: number;
+    y: number;
+    size?: number | undefined;
+    label?: string | undefined;
+    /** Any CSS color for this point; wins over the series color and `colorScale`. */
+    color?: string | undefined;
+    /** The quantity `colorScale` maps to a color. */
+    value?: number | undefined;
+});
+/** Marker shape of a scatter series, so series are told apart by more than color. */
+type MarkerSymbol = 'circle' | 'square' | 'diamond' | 'triangle';
+interface ScatterSeries extends Identified {
     name: string;
-    /** `[x, y]` pairs. */
-    data: [number, number][];
+    /** `[x, y]` pairs, `[x, y, size]` triples for bubbles, or `{ x, y, size?, label? }` objects. */
+    data: ScatterPoint[];
     color?: string | undefined;
+    /** @default 'circle' */
+    symbol?: MarkerSymbol | undefined;
 }
 interface ScatterChartInput extends Sized {
     series: ScatterSeries[];
+    /** Bubble radius range in pixels, for `[x, y, size]` data. @default [3, 18] */
+    sizeRange?: [number, number] | undefined;
+    /** Write each point's `label` next to it. @default false */
+    labels?: boolean | undefined;
+    xAxis?: AxisOptions | undefined;
+    yAxis?: AxisOptions | undefined;
+    references?: Reference[] | undefined;
+    annotations?: Annotation[] | undefined;
+    /** Colors points by their `value` (object points only). */
+    colorScale?: ColorScale | undefined;
+    /** Draw the `colorScale` legend under the plot, or beside it. @default false */
+    colorLegend?: boolean | ColorLegendOptions | undefined;
+    /** Symbol radius in pixels for plain points. @default 3 */
+    markerSize?: number | undefined;
+    /** Extra invisible radius around each point that still counts as a hover/click. @default 0 */
+    hitRadius?: number | undefined;
+    /** Deterministic jitter in pixels applied to overlapping points. @default 0 */
+    jitter?: number | undefined;
+    /** Least-squares fit per series: `true` is linear. @default false */
+    trendline?: boolean | 'linear' | 'exponential' | 'logarithmic' | 'power' | 'polynomial' | undefined;
+    /** Above this many points every k-th point is kept (systematic sampling). @default 'none' */
+    sampling?: 'none' | 'auto' | {
+        threshold: number;
+    } | undefined;
+}
+/** Where a colour legend sits. */
+interface ColorLegendOptions {
+    /** @default 'horizontal' (under the plot); `vertical` is a column at the right */
+    orientation?: 'horizontal' | 'vertical' | undefined;
+    title?: string | undefined;
+}
+/** A bubble: two positions and a magnitude the bubble's area follows. */
+interface BubblePoint extends Identified {
+    x: number;
+    y: number;
+    /** Magnitude; the bubble's area, not its radius, is proportional to it. Negatives count as zero. */
+    z: number;
+    label?: string | undefined;
+    color?: string | undefined;
+    /** The quantity `colorScale` maps to a color. @default z */
+    value?: number | undefined;
+}
+interface BubbleSeries extends Identified {
+    name: string;
+    data: BubblePoint[];
+    color?: string | undefined;
+}
+interface BubbleChartInput extends Sized {
+    series: BubbleSeries[];
+    /** Smallest and largest bubble radius in pixels; the largest magnitude gets the largest radius. @default [4, 24] */
+    sizeRange?: [number, number] | undefined;
+    /** Write each bubble's `label` on it. @default false */
+    labels?: boolean | undefined;
+    xAxis?: AxisOptions | undefined;
+    yAxis?: AxisOptions | undefined;
+    /** How the magnitude is named and written in tooltips. */
+    zAxis?: Pick<AxisOptions, 'format' | 'label'> | undefined;
+    references?: Reference[] | undefined;
+    annotations?: Annotation[] | undefined;
+    /** Colors bubbles by their `value` (or `z`). */
+    colorScale?: ColorScale | undefined;
+    /** Draw the `colorScale` legend under the plot, or beside it. @default false */
+    colorLegend?: boolean | ColorLegendOptions | undefined;
+}
+/** A qualitative sector of a gauge or bullet scale. */
+interface Band {
+    from: number;
+    to: number;
+    variant?: Variant | undefined;
+    color?: string | undefined;
+    label?: string | undefined;
+}
+interface GaugeChartInput extends Sized {
+    /** The reading; values outside `min`–`max` are drawn clamped and reported as given. */
+    value: number;
+    /** @default 0 */
+    min?: number | undefined;
+    /** @default 100 */
+    max?: number | undefined;
+    /** `radial` reads with a needle over the bands; `solid` fills the arc up to the value. @default 'radial' */
+    variant?: 'radial' | 'solid' | undefined;
+    /** Degrees clockwise from 12 o'clock. `-90`/`90` is a semi-circle. @default -120 */
+    startAngle?: number | undefined;
+    /** @default 120 */
+    endAngle?: number | undefined;
+    /** Arc thickness as a fraction of the radius. @default 0.18 */
+    thickness?: number | undefined;
+    /** Threshold sectors in value units, e.g. healthy / warning / critical. */
+    bands?: Band[] | undefined;
+    /** A marker at this value. */
+    target?: number | undefined;
+    /** Tick marks: their count (including both ends), `true` for 5, `false` for none. @default true */
+    ticks?: number | boolean | undefined;
+    /** Write the tick values. @default true */
+    tickLabels?: boolean | undefined;
+    /** Text in the middle; defaults to the formatted value. */
+    centerLabel?: string | undefined;
+    /** Smaller text under the value, e.g. the metric name. */
+    caption?: string | undefined;
+}
+/** A single reading on a straight scale: the bullet engine with gauge semantics. */
+interface LinearGaugeInput extends Sized {
+    value: number;
+    /** @default 0 */
+    min?: number | undefined;
+    /** @default 100, or the largest of value, target and bands */
+    max?: number | undefined;
+    target?: number | undefined;
+    /** Threshold sectors in value units. */
+    bands?: Band[] | undefined;
+    /** @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical' | undefined;
+    /** The metric name, written before the scale and in tooltips. */
+    caption?: string | undefined;
+    /** Write the value after the bar. @default true */
+    labels?: boolean | undefined;
+    /** Approximate tick count of the scale. @default 5 */
+    ticks?: number | undefined;
+}
+interface HistogramInput extends Sized {
+    /** The raw sample; `null` and `NaN` are skipped. */
+    data: Value[];
+    /** Series name in tooltips and the legend. @default 'Count' */
+    name?: string | undefined;
+    color?: string | undefined;
+    /** Bin count. @default Sturges' rule */
+    bins?: number | undefined;
+    /** Bin width; wins over `bins`. */
+    binWidth?: number | undefined;
+    /** Explicit ascending bin edges; wins over `bins` and `binWidth` and allows unequal bins. */
+    thresholds?: number[] | undefined;
+    /** Value range binned; samples outside are dropped. @default the sample extent */
+    domain?: [number, number] | undefined;
+    /** What bars measure: observations, observations per unit (area sums to 1), or shares of the sample. @default 'count' */
+    mode?: 'count' | 'density' | 'percent' | undefined;
+    /** How bin edges are written. */
+    xAxis?: Pick<AxisOptions, 'format' | 'label'> | undefined;
+    yAxis?: AxisOptions | undefined;
+    references?: Reference[] | undefined;
+    annotations?: Annotation[] | undefined;
+    /** Write each bin's value above its bar. @default false */
+    labels?: boolean | undefined;
+    /** Share of each bin slot left empty. @default 0.05 */
+    barGap?: number | undefined;
+}
+interface BulletDatum extends Identified {
+    name: string;
+    /** The measure. */
+    value: number;
+    target?: number | undefined;
+    /** Qualitative upper bounds, ascending, e.g. `[50, 75, 100]` for poor / acceptable / good; overrides the chart-level `ranges`. */
+    ranges?: (number | Band)[] | undefined;
+    color?: string | undefined;
+}
+interface BulletChartInput extends Sized {
+    /** One row (or column) per datum. */
+    data: BulletDatum[];
+    /** @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical' | undefined;
+    /** Qualitative ranges shared by every datum without its own. */
+    ranges?: (number | Band)[] | undefined;
+    /** Scale start. @default 0, or the smallest value when negative */
+    min?: number | undefined;
+    /** Scale end. @default the largest of the values, targets and ranges */
+    max?: number | undefined;
+    /** Write each value after its bar. @default false */
+    labels?: boolean | undefined;
+    /** Approximate tick count of the value axis. @default 5 */
+    ticks?: number | undefined;
+}
+/** A combo series must say what it is: a bar, line, area or range. */
+type ComboSeries = (CartesianSeries & {
+    type: 'bar' | 'line' | 'area';
+}) | RangeSeries;
+/** Bars, lines, areas and ranges on one category axis and up to two value axes. */
+interface ComboChartInput extends Omit<ChartInput, 'series' | 'transform' | 'bins' | 'binWidth' | 'binDomain' | 'binMode'> {
+    series: ComboSeries[];
+}
+interface RangeChartSeries extends Identified {
+    name: string;
+    low: Value[];
+    high: Value[];
+    color?: string | undefined;
+    axis?: 'left' | 'right' | undefined;
+    curve?: Curve | undefined;
+}
+/** Low–high intervals per category: a band, floating bars, or two outlines. */
+interface RangeChartInput extends Pick<ChartInput, 'categories' | 'xAxis' | 'yAxis' | 'rightAxis' | 'references' | 'annotations' | 'curve' | 'connectNulls' | 'orientation' | 'radius' | 'barGap' | 'barWidth' | 'zoom' | 'brush' | 'crosshair'>, Sized {
+    series: RangeChartSeries[];
+    /** @default 'area' */
+    variant?: 'area' | 'bar' | 'line' | undefined;
+}
+/** A category with a start and an end value, joined by a connector: before/after, plan/actual. */
+interface DumbbellDatum extends Identified {
+    name: string;
+    start: Value;
+    end: Value;
+    color?: string | undefined;
+}
+interface DumbbellChartInput extends Sized {
+    data: DumbbellDatum[];
+    /** Names of the two ends, for the legend and tooltips. @default ['Start', 'End'] */
+    startLabel?: string | undefined;
+    endLabel?: string | undefined;
+    /** Categories run down y with values along x. @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical' | undefined;
+    /** Write both values next to their markers. @default false */
+    labels?: boolean | undefined;
+    /** Order categories by end value, or by the change. */
+    sort?: 'asc' | 'desc' | 'change' | undefined;
+    /** Marker radius in pixels. @default 5 */
+    markerSize?: number | undefined;
+    xAxis?: AxisOptions | undefined;
+    references?: Reference[] | undefined;
+}
+/** Categories sorted by value with the cumulative share as a line on the right axis. */
+interface ParetoChartInput extends Pick<ChartInput, 'labels' | 'radius' | 'barGap' | 'barWidth' | 'yAxis' | 'xAxis' | 'zoom' | 'brush' | 'crosshair'>, Sized {
+    data: Datum[];
+    /** A cumulative-share reference line, e.g. `0.8` for the 80/20 rule. */
+    threshold?: number | undefined;
+    /** Name of the cumulative line in the legend and tooltips. @default 'Cumulative' */
+    cumulativeLabel?: string | undefined;
+    /** Name of the bars in the legend and tooltips. @default 'Value' */
+    name?: string | undefined;
+}
+/** One Marimekko column: its width follows `total` (or the sum of its segments), segments stack to 100%. */
+interface MarimekkoCategory extends Identified {
+    name: string;
+    /** Segment values; keyed by the `segments` names in order. */
+    values: Value[];
+    /** Column width measure. @default the sum of `values` */
+    total?: number | undefined;
+}
+interface MarimekkoChartInput extends Sized {
+    /** Segment names, in stacking order; one color each. */
+    segments: (string | Pick<Datum, 'id' | 'name' | 'color'>)[];
+    data: MarimekkoCategory[];
+    /** Write segment shares inside cells wide enough. @default false */
+    labels?: boolean | undefined;
+    /** Gap between columns as a share of the plot width. @default 0.01 */
+    gap?: number | undefined;
+    /** How the column widths (totals) are written in tooltips and the x axis. */
+    xAxis?: Pick<AxisOptions, 'format' | 'label'> | undefined;
+}
+/** One axis of a parallel-coordinates chart. */
+interface ParallelDimension extends Identified {
+    /** Key in each row's values, and the axis title unless `label` is set. */
+    key: string;
+    label?: string | undefined;
+    min?: number | undefined;
+    max?: number | undefined;
+    format?: Format | undefined;
+    /** Run the axis top-down. @default false */
+    reversed?: boolean | undefined;
+}
+interface ParallelRow extends Identified {
+    name: string;
+    values: Record<string, Value>;
+    color?: string | undefined;
+    /** Category, for color and the legend. */
+    group?: string | undefined;
+}
+interface ParallelCoordinatesInput extends Sized {
+    dimensions: ParallelDimension[];
+    data: ParallelRow[];
+    /** Line opacity. @default 0.6, lower above 200 rows */
+    opacity?: number | undefined;
+    /** @default 'linear' */
+    curve?: Curve | undefined;
+    /** Draw lines across missing values instead of breaking them. @default false */
+    connectNulls?: boolean | undefined;
+    /** Keep rows whose value on `key` lies inside `[min, max]`; the rest fade. */
+    filters?: {
+        key: string;
+        min?: number | undefined;
+        max?: number | undefined;
+    }[] | undefined;
+}
+interface NetworkNode extends Identified {
+    id: string;
+    /** @default the id */
+    label?: string | undefined;
+    /** Node weight; the node's area follows it. */
+    value?: number | undefined;
+    /** Category, for color and the legend. */
+    group?: string | undefined;
+    color?: string | undefined;
+    /** Position in data units, used by `layout: 'manual'`. */
+    x?: number | undefined;
+    y?: number | undefined;
+}
+interface NetworkEdge extends Identified {
+    source: string;
+    target: string;
+    /** Edge weight; the stroke width follows it. */
+    value?: number | undefined;
+    label?: string | undefined;
+}
+interface NetworkChartInput extends Sized {
+    nodes: NetworkNode[];
+    edges: NetworkEdge[];
+    /** Force-directed, around a circle, or from each node's own `x`/`y`. @default 'force' */
+    arrange?: 'force' | 'circular' | 'manual' | undefined;
+    /** Write node labels. @default true up to 60 nodes, then off (titles remain) */
+    labels?: boolean | undefined;
+    /** Smallest and largest node radius in pixels. @default [5, 16] */
+    nodeRange?: [number, number] | undefined;
+    /** Force-layout iterations. @default scaled to the node count, 50–300 */
+    iterations?: number | undefined;
+    /** Draw an arrowhead at the target end of every edge. @default false */
+    directed?: boolean | undefined;
+    /** Write edge labels (and values) at the middle of each edge. @default false */
+    edgeLabels?: boolean | undefined;
+}
+interface TimelineEvent extends Identified {
+    date: string | number | Date;
+    label: string;
+    description?: string | undefined;
+    /** Lane the event sits on; lanes share the time axis. */
+    group?: string | undefined;
+    color?: string | undefined;
+    variant?: Variant | undefined;
+}
+interface TimelineChartInput extends Sized {
+    /** Point-in-time events, in any order. */
+    events: TimelineEvent[];
+    /** Time runs along x with labels staggered, or down y with one row per event. @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical' | undefined;
+    /** How dates are written. @default date, or time when the events span under two days */
+    xAxis?: Pick<AxisOptions, 'format' | 'label'> | undefined;
+    /** Write event labels. @default true */
+    labels?: boolean | undefined;
 }
 interface SparklineInput extends Sized {
-    data: number[];
+    data: Value[];
+    /** One x position per value (numbers or dates) for uneven spacing. @default even spacing */
+    x?: (number | Date)[] | undefined;
     color?: string | undefined;
     /** @default 'linear' */
     curve?: Curve | undefined;
+    /** `winloss` draws equal bars up for positives and down for negatives. @default 'area' */
+    variant?: 'area' | 'line' | 'bar' | 'winloss' | undefined;
+    /** Color by direction: success when the last value is above the first, danger below. @default false */
+    trend?: boolean | undefined;
+    /** Mark the minimum and maximum. @default false */
+    extremes?: boolean | undefined;
+    /** Write the last value after the line. @default false */
+    lastValue?: boolean | undefined;
+    /** A dashed reference line at this value, e.g. a target or the previous period. */
+    target?: number | undefined;
+    /** A shaded band between two values, e.g. the healthy range. */
+    band?: [number, number] | undefined;
+    /** Dots on the first and/or last point. @default ['last'] for lines and areas */
+    markers?: ('first' | 'last')[] | undefined;
+}
+/** One radar axis with its own scale. */
+interface RadarMetric extends Identified {
+    label: string;
+    /** @default 0 */
+    min?: number | undefined;
+    /** @default the largest value on this axis, rounded up */
+    max?: number | undefined;
+    format?: Format | undefined;
 }
 interface RadarChartInput extends Sized {
     series: Series[];
-    /** One axis per category. */
-    categories: string[];
-    /** Scale every series to its own maximum, so rings read as percentages. @default false */
-    normalize?: boolean | undefined;
+    /** One axis per category; `metrics` is the richer form with a scale per axis. */
+    categories?: string[] | undefined;
+    metrics?: RadarMetric[] | undefined;
+    /**
+     * `metric` scales each axis by its own min/max so unlike units compare; `series` scales every
+     * series to its own maximum (the pre-existing `true`, misleading across series);
+     * `none` shares one scale. @default 'metric' when `metrics` is given, else 'none'
+     */
+    normalize?: boolean | 'metric' | 'series' | 'none' | undefined;
+    /** Outer ring value. @default the largest value, rounded up */
+    max?: number | undefined;
+    /** Fill the polygons. @default true */
+    fill?: boolean | undefined;
+    /** Number of grid rings. @default 4 */
+    levels?: number | undefined;
+    /** Dots on the vertices. @default true */
+    markers?: boolean | undefined;
+    /** Marker radius in pixels. @default 3 */
+    markerSize?: number | undefined;
+    /** Write each value at its vertex. @default false */
+    labels?: boolean | undefined;
+    /** Degrees clockwise from 12 o'clock of the first axis. @default 0 */
+    startAngle?: number | undefined;
+    /** Grid rings as polygons or circles. @default 'polygon' */
+    gridShape?: 'polygon' | 'circle' | undefined;
+}
+interface CalendarCell {
+    date: string | number | Date;
+    value: number;
 }
+/** An ordinal palette, a one-way ramp, a two-way ramp around a midpoint, or exact classes. */
+type ColorScale = {
+    type: 'ordinal';
+    colors?: string[] | undefined;
+} | {
+    type: 'sequential';
+    /** @default the data extent */
+    domain?: [number, number] | undefined;
+    /** Stops, low to high; concrete colors interpolate, token colors quantize. @default one color, opacity ramp */
+    colors?: string[] | undefined;
+    /** Quantize into this many classes. */
+    steps?: number | undefined;
+    reversed?: boolean | undefined;
+} | {
+    type: 'diverging';
+    /** `[min, mid, max]`. @default symmetric around zero */
+    domain?: [number, number, number] | undefined;
+    /** `[low, high]` or `[low, mid, high]` stops. @default danger / surface / primary tokens */
+    colors?: string[] | undefined;
+    steps?: number | undefined;
+    reversed?: boolean | undefined;
+} | {
+    type: 'threshold';
+    /** Ascending class boundaries; `colors` has one more entry than `thresholds`. */
+    thresholds: number[];
+    colors: string[];
+    labels?: string[] | undefined;
+};
+/** A matrix (`rows`, `columns`, `data`) or a calendar (`calendar`); one of the two must be given. */
 interface HeatmapInput extends Sized {
-    rows: string[];
-    columns: string[];
-    /** `data[row][column]`. */
-    data: number[][];
+    rows?: string[] | undefined;
+    columns?: string[] | undefined;
+    /** `data[row][column]`; `null` cells are left blank. */
+    data?: Value[][] | undefined;
+    /** One value per day; laid out as weekday rows and week columns, labelled by month. */
+    calendar?: CalendarCell[] | undefined;
+    /** First day of the calendar week. @default 'monday' */
+    weekStart?: 'monday' | 'sunday' | undefined;
     /** The cell color; each cell's opacity follows its value. */
     color?: string | undefined;
     /** Split around zero: values below use `negativeColor`, opacity follows the distance from zero. @default false */
     diverging?: boolean | undefined;
     /** @default the tokens danger color */
     negativeColor?: string | undefined;
+    /** A full color scale; wins over `color`, `diverging`, `steps` and `domain`. */
+    colorScale?: ColorScale | undefined;
+    /** Draw the color scale under the grid, or beside it. @default false */
+    colorLegend?: boolean | ColorLegendOptions | undefined;
+    /** Fill for `null` cells. @default none (blank) */
+    missingColor?: string | undefined;
+    /** Write each value in its cell. @default false */
+    labels?: boolean | undefined;
+    /** Value range the opacity ramp covers. @default the data extent */
+    domain?: [number, number] | undefined;
+    /** Quantize the color ramp into this many discrete steps instead of a continuous ramp. */
+    steps?: number | undefined;
+    /** Gap between cells in pixels. @default 0 (1 for calendars) */
+    cellGap?: number | undefined;
+    /** Cell corner radius in pixels. @default 0 (2 for calendars) */
+    cellRadius?: number | undefined;
+    /** Order rows by their sum. */
+    rowOrder?: 'asc' | 'desc' | undefined;
+    /** Order columns by their sum. */
+    columnOrder?: 'asc' | 'desc' | undefined;
 }
 interface FunnelChartInput extends Sized {
     data: Datum[];
+    /** @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    /** `pyramid` widens toward the end and reports shares of the total instead of conversion. @default 'funnel' */
+    variant?: 'funnel' | 'pyramid' | undefined;
+    /** Gap between stages in pixels. @default 4 */
+    gap?: number | undefined;
+    /** Stage labels inside the stage, beside it, or hidden. @default 'inside' */
+    labelPosition?: 'inside' | 'outside' | 'none' | undefined;
+    /** Order stages by value (a funnel is drawn in input order by default). */
+    sort?: 'asc' | 'desc' | undefined;
+    /** Narrowest stage width as a fraction of the widest, so the last stage stays readable. @default 0 */
+    neckWidth?: number | undefined;
+    /** How conversion and drop-off are written in tooltips. @default whole percent */
+    percentFormat?: Format | undefined;
 }
 interface Tick {
     /** Pixel position along the axis. */
@@ -101,66 +1010,411 @@ interface Frame extends Canvas {
     /** Pixel y of value 0 (clamped into the plot): where bars and areas start and the x axis is drawn. */
     baseline: number;
 }
-interface SankeyLink {
+interface SankeyNode extends Identified {
+    id: string;
+    /** @default the id */
+    label?: string | undefined;
+    color?: string | undefined;
+}
+interface SankeyLink extends Identified {
     source: string;
     target: string;
     value: number;
 }
 interface SankeyInput extends Sized {
-    /** Nodes are derived from the link endpoints, in order of first appearance. */
+    /** Nodes are derived from the link endpoints, in order of first appearance, unless `nodes` is given. */
     links: SankeyLink[];
+    /** Explicit nodes with labels and colors; links to nodes not listed are reported and dropped. */
+    nodes?: SankeyNode[] | undefined;
+    /** `left` places a node right after its sources; `justify` pushes sinks to the last column. @default 'left' */
+    align?: 'left' | 'justify' | undefined;
+    /** Node thickness in pixels. @default 16 */
+    nodeWidth?: number | undefined;
+    /** Vertical gap between nodes in a column, in pixels. @default 8 */
+    nodePadding?: number | undefined;
+    /** Order nodes inside a column by value instead of first appearance. */
+    nodeSort?: 'asc' | 'desc' | undefined;
+    /** Order the ribbons leaving a node by value instead of link order. */
+    linkSort?: 'asc' | 'desc' | undefined;
+    /** Write node names. @default true */
+    nodeLabels?: boolean | undefined;
+    /** Write each link's value on it. @default false */
+    linkLabels?: boolean | undefined;
+    /**
+     * What to do with links that close a cycle: `drop` them (reported as a warning), `warn` (the
+     * same, spelled out), or `error` (the chart renders its error state). @default 'drop'
+     */
+    cyclePolicy?: 'drop' | 'warn' | 'error' | undefined;
 }
 interface TreemapInput extends Sized {
     /** Flat data, or a tree: branches are outlined and their children tiled inside. */
     data: TreeNode[];
+    /** Id (or name) of the node to show as the whole chart: controlled drill-down. */
+    rootId?: ChartItemId | undefined;
+    /** Write the path to `rootId` above the tiles. @default false */
+    breadcrumbs?: boolean | undefined;
+    /** Deepest level tiled; deeper nodes are summed into their ancestor. */
+    maxDepth?: number | undefined;
+    /** Tile order inside a branch. @default 'desc' */
+    sort?: 'asc' | 'desc' | 'none' | undefined;
+    /** Inset of children inside their branch, in pixels. @default 2 */
+    padding?: number | undefined;
+    /** Squarified rows, alternating slice/dice per depth, or one direction only. @default 'squarify' */
+    tiling?: 'squarify' | 'slice' | 'dice' | 'sliceDice' | undefined;
+    /** Colors leaves by their value instead of by branch. */
+    colorScale?: ColorScale | undefined;
+    /** Write leaf names on tiles wide enough. @default true */
+    labels?: boolean | undefined;
 }
-interface Candle {
-    label: string;
+interface Candle extends Identified {
+    label: Category;
     open: number;
     high: number;
     low: number;
     close: number;
+    /** Drawn as a bar in a pane under the candles when any candle has one. */
+    volume?: number | undefined;
+}
+/** A moving average over the closes, drawn as a line over the candles. */
+interface CandlestickOverlay {
+    type: 'sma' | 'ema';
+    /** Number of candles averaged. */
+    period: number;
+    color?: string | undefined;
+    /** @default `SMA 20` */
+    name?: string | undefined;
 }
 interface CandlestickInput extends Sized {
     data: Candle[];
     /** @default 'linear' */
     scale?: 'linear' | 'log' | undefined;
+    /** Bars with open/close ticks instead of filled candles. @default 'candlestick' */
+    variant?: 'candlestick' | 'ohlc' | undefined;
+    /** `type: 'time'` places candles proportionally to their labels' time, leaving gaps for missing sessions. */
+    xAxis?: (Pick<AxisOptions, 'format'> & {
+        type?: 'category' | 'time' | undefined;
+    }) | undefined;
+    references?: Reference[] | undefined;
+    annotations?: Annotation[] | undefined;
+    /** Moving-average lines. */
+    overlays?: CandlestickOverlay[] | undefined;
+    /** Quick zoom buttons above the plot, e.g. `[{ label: '1M', candles: 22 }]`; `candles: 0` shows all. */
+    rangeSelector?: {
+        label: string;
+        candles: number;
+    }[] | undefined;
+    /** Markers above the candles at given labels: earnings, splits, news. */
+    flags?: {
+        label: Category;
+        text: string;
+        variant?: Variant | undefined;
+    }[] | undefined;
+    /** Plot the change from the first visible close as a percentage instead of prices. @default false */
+    compare?: boolean | undefined;
+    /** @default the tokens success color */
+    upColor?: string | undefined;
+    /** @default the tokens danger color */
+    downColor?: string | undefined;
+    zoom?: Zoom | undefined;
+    brush?: boolean | undefined;
+    crosshair?: boolean | undefined;
+}
+interface WaterfallDatum extends Datum {
+    /**
+     * `change` (default) is a signed delta; `subtotal` and `total` stand on zero and show the
+     * running total (`value` is ignored). `subtotal: true` is the older spelling.
+     */
+    type?: 'change' | 'subtotal' | 'total' | undefined;
+    /** A bar from zero to the running total so far, instead of a delta; `value` is ignored. */
+    subtotal?: boolean | undefined;
 }
 interface WaterfallInput extends Sized {
-    /** Signed deltas, applied in order. */
-    data: Datum[];
+    /** Signed deltas, applied in order; `subtotal` rows show the running total. */
+    data: WaterfallDatum[];
     /** Label of a final bar showing the running total; omitted when unset. */
     total?: string | undefined;
+    /** Opening value the first delta applies to, drawn as a total bar when labelled. @default 0 */
+    start?: number | undefined;
+    startLabel?: string | undefined;
+    /** Bars grow along x with steps running down the y axis. @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    /** Dashed lines carrying the running total between bars. @default true */
+    connectors?: boolean | undefined;
+    /** Write each delta next to its bar. @default false */
+    labels?: boolean | undefined;
+    positiveColor?: string | undefined;
+    negativeColor?: string | undefined;
+    /** Color of subtotal and total bars. @default the first series color */
+    totalColor?: string | undefined;
 }
-interface GanttTask {
+interface GanttTask extends Identified {
     name: string;
     start: number;
     end: number;
     color?: string | undefined;
+    /** Tasks sharing a group share a row, so one row can hold several intervals. */
+    group?: string | undefined;
+    /** Completed share, 0–1, drawn as a darker inner bar. */
+    progress?: number | undefined;
+    /** A point in time drawn as a diamond at `start`; `end` is ignored. */
+    milestone?: boolean | undefined;
+    /** Names (or ids) of tasks that must finish first; drawn as connectors. */
+    dependsOn?: ChartItemId[] | undefined;
+    /** The planned interval, drawn as a thin bar under the task. */
+    baseline?: {
+        start: number;
+        end: number;
+    } | undefined;
+    /** Id (or name) of the parent task; children are indented and the parent spans them. */
+    parent?: ChartItemId | undefined;
 }
 interface GanttInput extends Sized {
     tasks: GanttTask[];
-    /** Formats the x-axis ticks, e.g. a timestamp as a date. @default formatValue */
-    format?: ((value: number) => string) | undefined;
+    /** Vertical lines and bands in time coordinates, e.g. `{ x: Date.now(), label: 'Today' }`. */
+    references?: Reference[] | undefined;
+    annotations?: Annotation[] | undefined;
+    /** A labelled "Today" line at this time. */
+    today?: number | Date | undefined;
+    /** Highlight the longest dependency chain and fade the rest. @default false */
+    criticalPath?: boolean | undefined;
+    /** How task times are written on the axis. */
+    xAxis?: Pick<AxisOptions, 'format' | 'label' | 'ticks'> | undefined;
+    /** Parents whose children are hidden: controlled expand/collapse. */
+    collapsed?: ChartItemId[] | undefined;
+    /** Weekdays (0 = Sunday … 6 = Saturday) shaded as non-working, for millisecond time axes. */
+    nonWorkingDays?: number[] | undefined;
+}
+/** A precomputed five-number summary, instead of raw samples. */
+interface BoxSummary extends Identified {
+    name: string;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    outliers?: number[] | undefined;
+    mean?: number | undefined;
+    color?: string | undefined;
 }
+/** A series with one raw sample per category, for grouped boxplots (`categories` required). */
+interface GroupedBoxSeries extends Identified {
+    name: string;
+    /** `data[categoryIndex]` is that category's sample. */
+    data: Value[][];
+    color?: string | undefined;
+}
+type BoxplotSeries = Series | BoxSummary | GroupedBoxSeries;
 interface BoxplotInput extends Sized {
-    /** One box per series, over that series' raw samples. */
-    series: Series[];
+    /** One box per series, over that series' raw samples or a precomputed summary. */
+    series: BoxplotSeries[];
+    /** @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    /**
+     * How quartiles are taken from a sample: `linear` interpolates between order statistics
+     * (R type 7, Excel QUARTILE.INC), `exclusive` excludes the median from the halves (type 6,
+     * QUARTILE.EXC), `tukey` uses hinges (medians of the halves). @default 'linear'
+     */
+    quartileMethod?: 'linear' | 'exclusive' | 'tukey' | undefined;
+    /** Whisker reach as a multiple of the IQR; samples beyond are outliers. @default 1.5 */
+    whisker?: number | undefined;
+    /** Mark the mean with a diamond. @default false */
+    mean?: boolean | undefined;
+    /** Draw every observation, jittered across the box. @default false */
+    points?: boolean | undefined;
+    /**
+     * Notch the box around the median by ±1.58 × IQR / √n (a rough 95% interval): notches that do
+     * not overlap suggest different medians. Only for raw samples. @default false
+     */
+    notched?: boolean | undefined;
+    /** Groups: one box per series inside each category; series then carry `data[category]`. */
+    categories?: string[] | undefined;
+    yAxis?: AxisOptions | undefined;
 }
-interface TreeNode {
+interface TreeNode extends Identified {
     name: string;
     /** Leaf size; a branch's size is the sum of its children when unset. */
     value?: number | undefined;
     children?: TreeNode[] | undefined;
     color?: string | undefined;
+    /** A second line under the name, e.g. a role in an organization chart. */
+    subtitle?: string | undefined;
+}
+/** A node-link tree: one box or dot per node, links to its children. */
+interface TreeChartInput extends Sized {
+    data: TreeNode[];
+    /** Root at the top with levels going down, or root at the left. @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    /** Dots with labels beside them, or boxes holding the name (and subtitle). @default 'circle' */
+    nodeShape?: 'circle' | 'box' | undefined;
+    /** Curved, elbow (orthogonal) or straight links. @default 'curve' */
+    linkStyle?: 'curve' | 'elbow' | 'straight' | undefined;
+    /** Id (or name) of the node to show as the root: controlled drill-down. */
+    rootId?: ChartItemId | undefined;
+    /** Nodes whose children are hidden: controlled expand/collapse; collapsed nodes get a `+` mark. */
+    collapsed?: ChartItemId[] | undefined;
+    /** Deepest level drawn. */
+    maxDepth?: number | undefined;
+    /** Write node names. @default true */
+    labels?: boolean | undefined;
+    /** Dot radius, or box height, in pixels. @default 5 / 36 */
+    nodeSize?: number | undefined;
+}
+/** An organization chart: a tree of boxes with elbow links and optional subtitles. */
+type OrganizationChartInput = Omit<TreeChartInput, 'nodeShape' | 'linkStyle'>;
+/** Nested circles: each node a circle sized by value, children packed inside their parent. */
+interface CirclePackingInput extends Sized {
+    data: TreeNode[];
+    rootId?: ChartItemId | undefined;
+    maxDepth?: number | undefined;
+    /** Write names on circles wide enough. @default true */
+    labels?: boolean | undefined;
+    /** Gap between sibling circles, in pixels. @default 2 */
+    padding?: number | undefined;
+    /** Colors leaves by their value instead of by branch. */
+    colorScale?: ColorScale | undefined;
+}
+/** A rectangular sunburst: one row (or column) per depth, children inside their parent's span. */
+interface IcicleInput extends Sized {
+    data: TreeNode[];
+    /** Root row at the top with depth going down, or root column at the left. @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    rootId?: ChartItemId | undefined;
+    /** Write the path to `rootId` above the cells. @default false */
+    breadcrumbs?: boolean | undefined;
+    maxDepth?: number | undefined;
+    /** Cell order inside a parent. @default 'none' (input order) */
+    sort?: 'asc' | 'desc' | 'none' | undefined;
+    /** Write names on cells wide enough. @default true */
+    labels?: boolean | undefined;
+    /** Gap between cells, in pixels. @default 1 */
+    padding?: number | undefined;
+    colorScale?: ColorScale | undefined;
+}
+/** Ranks over categories: one line per series, the top rank at the top. */
+interface BumpChartInput extends Sized {
+    /** Values per category; ranks are computed per category unless `ranked`. */
+    series: Series[];
+    categories?: Category[] | undefined;
+    /** The data are already ranks (1 = first). @default false */
+    ranked?: boolean | undefined;
+    /** Only the first `topRank` ranks are drawn; series that drop below leave the plot. */
+    topRank?: number | undefined;
+    /** @default 'monotone' */
+    curve?: Curve | undefined;
+    /** Write series names at the right end of their line. @default true */
+    labels?: boolean | undefined;
+    /** Marker radius in pixels. @default 5 */
+    markerSize?: number | undefined;
+    xAxis?: XAxisOptions | undefined;
+}
+/** A Nightingale rose: equal angular sectors whose radius follows the value. */
+interface PolarAreaChartInput extends Sized {
+    data: Datum[];
+    /** Radius proportional to the value (`linear`) or to its square root, so area is proportional (`sqrt`). @default 'sqrt' */
+    scale?: 'linear' | 'sqrt' | undefined;
+    /** Outer ring value. @default the largest value, rounded up */
+    max?: number | undefined;
+    /** Degrees clockwise from 12 o'clock. @default 0 */
+    startAngle?: number | undefined;
+    /** @default startAngle + 360 */
+    endAngle?: number | undefined;
+    /** Gap between sectors, in degrees. @default 0 */
+    padAngle?: number | undefined;
+    /** Hole radius as a fraction of the outer radius. @default 0 */
+    innerRadius?: number | undefined;
+    /** Number of grid rings. @default 4 */
+    levels?: number | undefined;
+    /** Write each name at its sector's edge. @default false */
+    labels?: boolean | undefined;
+}
+/** A beeswarm: every observation as a dot, spread sideways so none overlap. */
+interface SwarmPlotInput extends Sized {
+    /** One swarm per series, over that series' raw samples. */
+    series: Series[];
+    /** @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    /** Dot radius in pixels. @default 3 */
+    markerSize?: number | undefined;
+    yAxis?: AxisOptions | undefined;
+    references?: Reference[] | undefined;
+}
+/** A grid of cells, each standing for a share of the total, colored by datum. */
+interface WaffleChartInput extends Sized {
+    data: Datum[];
+    /** What the whole grid stands for. @default the sum of the values */
+    total?: number | undefined;
+    /** @default 10 */
+    rows?: number | undefined;
+    /** @default 10 */
+    columns?: number | undefined;
+    /** Fill column by column from the bottom-left, or row by row from the top-left. @default 'vertical' */
+    orientation?: 'vertical' | 'horizontal' | undefined;
+    /** Gap between cells in pixels. @default 2 */
+    cellGap?: number | undefined;
+    /** Cell corner radius in pixels. @default 2 */
+    cellRadius?: number | undefined;
+    /** Write each datum's share after its name in the legend. @default false */
+    labels?: boolean | undefined;
 }
 interface SunburstInput extends Sized {
     data: TreeNode[];
+    /** Hole radius as a fraction of the outer radius, e.g. for `centerLabel`. @default 0 */
+    innerRadius?: number | undefined;
+    /** Text in the middle, e.g. the total. */
+    centerLabel?: string | undefined;
+    /** Write names on the arcs wide enough to hold them. @default false */
+    labels?: boolean | undefined;
+    /** Id (or name) of the node whose subtree fills the rings: controlled drill-down. */
+    rootId?: ChartItemId | undefined;
+    /** Write the path to `rootId` in the middle. @default false */
+    breadcrumbs?: boolean | undefined;
+    /** Deepest ring drawn. */
+    maxDepth?: number | undefined;
+    /** Arc order inside a parent. @default 'none' (input order) */
+    sort?: 'asc' | 'desc' | 'none' | undefined;
+    /** Degrees clockwise from 12 o'clock. @default 0 */
+    startAngle?: number | undefined;
+    /** @default startAngle + 360 */
+    endAngle?: number | undefined;
+    /** Gap between sibling arcs, in degrees. @default 0 */
+    padAngle?: number | undefined;
+    /** Colors arcs by their value instead of by branch. */
+    colorScale?: ColorScale | undefined;
+}
+interface ChordLink extends Identified {
+    source: string;
+    target: string;
+    value: number;
 }
 interface ChordInput extends Sized {
-    names: string[];
+    /** Group names, in order around the circle. Required with `matrix`; derived from `links` otherwise. */
+    names?: string[] | undefined;
     /** `matrix[i][j]` is the flow from `i` to `j`. */
-    matrix: number[][];
+    matrix?: number[][] | undefined;
+    /** Edge-list form of the matrix; `names` orders the groups when given. */
+    links?: ChordLink[] | undefined;
+    /** Angular gap between groups, in degrees. @default 2.3 */
+    padding?: number | undefined;
+    /** Order groups by their total flow instead of `names` order. */
+    sort?: 'asc' | 'desc' | undefined;
+    /** Tick marks with values around each group. @default false */
+    ticks?: boolean | undefined;
+}
+interface GeoPoint {
+    type: 'Point';
+    coordinates: [number, number];
+}
+interface GeoMultiPoint {
+    type: 'MultiPoint';
+    coordinates: [number, number][];
+}
+interface GeoLineString {
+    type: 'LineString';
+    coordinates: [number, number][];
+}
+interface GeoMultiLineString {
+    type: 'MultiLineString';
+    coordinates: [number, number][][];
 }
 interface GeoPolygon {
     type: 'Polygon';
@@ -171,24 +1425,116 @@ interface GeoMultiPolygon {
     type: 'MultiPolygon';
     coordinates: [number, number][][][];
 }
-interface MapFeature {
+interface MapFeature extends Identified {
     name: string;
-    value: number;
-    geometry: GeoPolygon | GeoMultiPolygon;
+    /** The measure the fill follows; a feature without one is drawn in the neutral fill. */
+    value?: number | undefined;
+    /** Polygons are regions; points become markers and line strings routes, in the same layers as `points`/`lines`. */
+    geometry: GeoPolygon | GeoMultiPolygon | GeoPoint | GeoMultiPoint | GeoLineString | GeoMultiLineString;
+    /** A categorical color for this region, drawn at full opacity. */
+    color?: string | undefined;
+}
+/** A marker at a coordinate; with a `value` its area follows the value (a bubble). */
+interface MapPoint extends Identified {
+    name: string;
+    /** `[longitude, latitude]`. */
+    coordinates: [number, number];
+    value?: number | undefined;
+    color?: string | undefined;
+}
+/** A route or connection drawn through `[longitude, latitude]` points. */
+interface MapLine extends Identified {
+    name: string;
+    coordinates: [number, number][];
+    value?: number | undefined;
+    color?: string | undefined;
+    dash?: string | undefined;
 }
 interface MapInput extends Sized {
     /** GeoJSON-shaped regions; drawn with an equirectangular projection fitted to their bounds. */
     features: MapFeature[];
     /** The region color; each region's opacity follows its value. */
     color?: string | undefined;
+    /** A full color scale for the regions; wins over `color`. */
+    colorScale?: ColorScale | undefined;
+    /** Draw the color scale under the map, or beside it. @default false */
+    colorLegend?: boolean | ColorLegendOptions | undefined;
     /** @default 'equirectangular' */
     projection?: 'equirectangular' | 'mercator' | undefined;
+    /** A marker layer over the regions; markers with a `value` are sized by it. */
+    points?: MapPoint[] | undefined;
+    /** A line layer (routes, connections) over the regions. */
+    lines?: MapLine[] | undefined;
+    /** Marker radius range in pixels. @default [3, 14] */
+    sizeRange?: [number, number] | undefined;
+    /** Write each region's name at its centre. @default false */
+    labels?: boolean | undefined;
+    /** The visible window: pan/zoom state, controllable; `zoom` 1 fits the features. */
+    view?: MapView | undefined;
+}
+/** A map's pan/zoom state: the projected centre in `[longitude, latitude]` and a zoom factor. */
+interface MapView {
+    /** @default the centre of the features' bounds */
+    center?: [number, number] | undefined;
+    /** Scale multiplier over the fitted projection, 1–64. @default 1 */
+    zoom?: number | undefined;
+}
+interface RadialBand {
+    from: number;
+    to: number;
+    variant?: Variant | undefined;
+}
+interface RadialBarInput extends Sized {
+    /** One concentric arc per datum, the first outermost. */
+    data: Datum[];
+    /** The value a full arc represents. @default the largest value */
+    max?: number | undefined;
+    /** Degrees clockwise from 12 o'clock. @default 0 */
+    startAngle?: number | undefined;
+    /** @default 360 */
+    endAngle?: number | undefined;
+    /** Hole radius as a fraction of the outer radius. @default 0.3 */
+    innerRadius?: number | undefined;
+    /** Gap between arcs as a fraction of one arc's thickness. @default 0.25 */
+    gap?: number | undefined;
+    /** Draw the full-range track behind each arc. @default true */
+    track?: boolean | undefined;
+    /** Round the arc ends. @default true */
+    rounded?: boolean | undefined;
+    /** Write each name and value at the arc start. @default false */
+    labels?: boolean | undefined;
+    /** Threshold sectors drawn outside the arcs, in value units. */
+    bands?: RadialBand[] | undefined;
+    /** A tick across every arc at this value. */
+    target?: number | undefined;
+    /** Text in the middle, e.g. the headline value. */
+    centerLabel?: string | undefined;
+}
+/** What a click, focus or hover refers to. */
+interface ChartItem {
+    /** The tooltip text. */
+    label: string;
+    /** Stable identifier of the datum, node, link or feature; the name when none was given. */
+    id?: ChartItemId | undefined;
+    series?: string | undefined;
+    /** Stable identifier of the series; the series name when none was given. */
+    seriesId?: ChartItemId | undefined;
+    category?: string | undefined;
+    index?: number | undefined;
+    value?: number | undefined;
+    name?: string | undefined;
+    /** Set on legend entries, which toggle a series instead of reporting a value. */
+    legend?: boolean | undefined;
+    /** Set on range-selector buttons: clicking applies this zoom window. */
+    range?: Zoom | undefined;
 }
 interface ShapeBase {
     /** The `data-skdx-part` value, e.g. `node`, `link`, `grid`. */
     part: string;
     /** Native tooltip text. */
     title?: string | undefined;
+    /** What the mark stands for; makes it clickable and keyboard-focusable. */
+    item?: ChartItem | undefined;
 }
 type Shape = (ShapeBase & {
     kind: 'path';
@@ -200,6 +1546,7 @@ type Shape = (ShapeBase & {
     strokeLinejoin?: 'round' | undefined;
     opacity?: number | undefined;
     fillOpacity?: number | undefined;
+    dash?: string | undefined;
 }) | (ShapeBase & {
     kind: 'rect';
     x: number;
@@ -209,6 +1556,7 @@ type Shape = (ShapeBase & {
     fill: string;
     stroke?: string | undefined;
     opacity?: number | undefined;
+    rx?: number | undefined;
 }) | (ShapeBase & {
     kind: 'line';
     x1: number;
@@ -217,12 +1565,16 @@ type Shape = (ShapeBase & {
     y2: number;
     stroke: string;
     dash?: string | undefined;
+    strokeWidth?: number | undefined;
+    opacity?: number | undefined;
 }) | (ShapeBase & {
     kind: 'circle';
     cx: number;
     cy: number;
     r: number;
     fill: string;
+    stroke?: string | undefined;
+    opacity?: number | undefined;
 }) | (ShapeBase & {
     kind: 'text';
     x: number;
@@ -231,7 +1583,27 @@ type Shape = (ShapeBase & {
     anchor?: 'start' | 'middle' | 'end' | undefined;
     baseline?: 'middle' | 'hanging' | undefined;
     fill?: string | undefined;
+    weight?: 'bold' | undefined;
+    /** Rotation in degrees around `(x, y)`, e.g. `-45` for long category labels. */
+    rotate?: number | undefined;
 });
+/** Where the pointer can act inside a cartesian chart: category slots, the shared tooltip rows and the brush strip. */
+interface Hit {
+    plot: Box;
+    /** Pixel center of every visible category. */
+    xs: number[];
+    /** Tooltip lines per visible category: the category, then one per series. */
+    rows: string[][];
+    /** Total category count, before zooming. */
+    count: number;
+    zoom: Zoom;
+    /** The range strip, when `brush` is on. */
+    brush?: {
+        box: Box;
+        window: Box;
+    } | undefined;
+    crosshair: boolean;
+}
 /** What every layout returns: the outer size, the whole chart as shapes and the tooltip switch. */
 interface Canvas {
     width: number;
@@ -239,120 +1611,1148 @@ interface Canvas {
     /** Everything drawn, back to front: grid, marks, legend and labels. */
     shapes: Shape[];
     tooltip: boolean;
+    /** Rewrites a mark's tooltip text; from `TooltipOptions.formatter`. */
+    tooltipFormatter?: ((item: ChartItem) => string | string[]) | undefined;
+    description?: string | undefined;
+    decorative?: boolean | undefined;
+    /** Transition duration in ms when animation is on. */
+    animate?: number | undefined;
+    responsive?: boolean | undefined;
+    hit?: Hit | undefined;
+    /** Rewrites the shared axis tooltip rows; from `TooltipOptions.axisFormatter`. */
+    axisTooltipFormatter?: ((rows: string[], index: number) => string[]) | undefined;
+    /** Render the tooltip as an HTML element over the page; from `TooltipOptions.portal`. */
+    tooltipPortal?: boolean | undefined;
+    /** Where the tooltip box sits; from `TooltipOptions.placement`. */
+    tooltipPlacement?: 'auto' | 'top' | 'bottom' | 'left' | 'right' | undefined;
+    /** Anchor the tooltip to the mark instead of the pointer; from `TooltipOptions.followPointer: false`. */
+    tooltipAnchored?: boolean | undefined;
+    /** Gradient definitions the shapes reference as `url(#id)`. */
+    defs?: GradientDef[] | undefined;
+    /** Data problems found while laying out, for `onDataIssue`. */
+    issues?: ChartDataIssue[] | undefined;
+    /** Header and rows of the accessible table, when `accessibleTable` is on. */
+    table?: string[][] | undefined;
+    /** How Gantt bars map to time, so a root can turn a drag into a task change. */
+    edit?: EditModel | undefined;
+    /** The map's projection state, so a root can pan and zoom it. */
+    map?: MapModel | undefined;
+    /** Width of a left legend column the marks still have to move right by; see `placeLegend`. */
+    legendOffset?: number | undefined;
+}
+/** A linear gradient a shape's fill can reference as `url(#id)`. */
+interface GradientDef {
+    id: string;
+    /** Direction: top-to-bottom by default. */
+    vertical?: boolean | undefined;
+    stops: {
+        offset: number;
+        color: string;
+        opacity?: number | undefined;
+    }[];
+}
+/** What a root needs to drag Gantt bars: the time scale and where each editable bar sits. */
+interface EditModel {
+    /** Pixel x of a time value. */
+    scale: (value: number) => number;
+    /** Time value of a pixel x. */
+    invert: (x: number) => number;
+    /** Editable bars by shape index: their task and pixel extent. */
+    bars: {
+        index: number;
+        id: ChartItemId;
+        name: string;
+        start: number;
+        end: number;
+        x0: number;
+        x1: number;
+        y: number;
+        height: number;
+    }[];
+    /** Round dragged times to this step (ms or units), when set. */
+    snap?: number | undefined;
+}
+/** A dragged or resized task, as reported by `onTaskChange`. */
+interface TaskChange {
+    id: ChartItemId;
+    name: string;
+    start: number;
+    end: number;
+}
+/** The map's pan/zoom state and the bounds it was fitted to. */
+interface MapModel {
+    view: {
+        center: [number, number];
+        zoom: number;
+    };
+    /** The projected bounds at zoom 1, in the projection's own units. */
+    bounds: {
+        minLon: number;
+        maxLon: number;
+        minLat: number;
+        maxLat: number;
+    };
+    /** Plot area the map is drawn in. */
+    plot: Box;
+    /** Pixels per projected unit at the current zoom. */
+    scale: number;
+    /** Latitude to the projection's y unit, and back; identity for equirectangular. */
+    toY: (latitude: number) => number;
+    fromY: (y: number) => number;
 }
 interface LegendItem {
     name: string;
     color: string;
 }
 
-declare function layoutBarChart(input: BarChartInput): Canvas;
+/** Grouped, stacked, horizontal or histogram bars; series may also be lines, areas or ranges. */
+declare const layoutBarChart: (input: BarChartInput) => Canvas;
 
-declare function layoutLineChart(input: LineChartInput): Canvas;
-declare function layoutAreaChart(input: AreaChartInput): Canvas;
+/** One polyline per series with a dot per value; series may also be bars, areas or ranges. */
+declare const layoutLineChart: (input: LineChartInput) => Canvas;
+/** Filled (optionally stacked) areas down to zero; series may also be bars, lines or ranges. */
+declare const layoutAreaChart: (input: AreaChartInput) => Canvas;
+
+type Kind = 'bar' | 'line' | 'area';
+/** Markers are drawn up to this many visible points per series. */
+declare const MARKER_LIMIT = 100;
+/** Per-point titles (and so per-point tooltips) are emitted up to this many visible points per series. */
+declare const TITLE_LIMIT = 2000;
+/** Bars, lines, areas and range bands that share one category axis and up to two value axes. */
+declare function layoutCartesian(input: ChartInput, defaultType: Kind): Canvas;
+
+/** The legend options of an input; `undefined` when there is no legend. */
+declare function legendOptions(input: Sized): LegendOptions | undefined;
+/** The tooltip options of an input, with `enabled` resolved. */
+declare function tooltipOptions(input: Sized): Omit<TooltipOptions, 'enabled'> & {
+    enabled: boolean;
+};
+/**
+ * Moves the marks of a chart laid out with a left legend right by the legend's width, keeping the
+ * hit, edit and map models aligned. The roots apply it after layout; `svgMarkup` consumers of a
+ * raw layout call it themselves. Idempotent: a placed layout is returned as it is.
+ */
+declare function placeLegend(layout: Canvas): Canvas;
+/** A tooltip box next to the pointer, kept inside the canvas; one line per entry. */
+declare function tooltipShapes(x: number, y: number, text: string | string[], width: number, height: number, placement?: 'auto' | 'top' | 'bottom' | 'left' | 'right'): Shape[];
+/**
+ * The loading, error or empty placeholder, or `null` when the chart should draw. Charts call this
+ * first so no axis is drawn around missing data.
+ */
+declare function stateCanvas(input: Sized, empty: boolean, w?: number, h?: number): Canvas | null;
 
 declare function layoutScatterChart(input: ScatterChartInput): Canvas;
 
 declare function layoutPieChart(input: PieChartInput): Canvas;
 
+/** A small axis-less trend: an area (default), a bare line, or bars; optional extremes and last value. */
 declare function layoutSparkline(input: SparklineInput): Canvas;
 
+/**
+ * One polygon per series over a spoke per metric. Scaling: `none` shares one scale (values are
+ * comparable); `metric` scales every axis by its own min/max (unlike units, the default when
+ * `metrics` carry bounds); `series` scales every series to its own maximum (the historical
+ * `normalize: true`, which only shows shape, never magnitude, and is reported as such).
+ */
 declare function layoutRadarChart(input: RadarChartInput): Canvas;
 
 declare function layoutHeatmap(input: HeatmapInput): Canvas;
 
+/**
+ * Stages narrowing with their value (conversion), or a pyramid widening toward the end
+ * (shares of a whole). Vertical by default, horizontal when asked.
+ */
 declare function layoutFunnelChart(input: FunnelChartInput): Canvas;
 
 /**
- * Tooltip shapes for the mark under the pointer, or none. Reads the mark's
- * `<title>` and converts the pointer position into viewBox units.
+ * Concentric arcs, one per datum, each a share of `max`: KPI completion, utilization,
+ * quota attainment. `bands` and `target` turn it into a gauge; `startAngle`/`endAngle` open it.
+ */
+declare function layoutRadialBar(input: RadialBarInput): Canvas;
+
+/**
+ * One reading on an arc scale: a needle over threshold bands (`radial`), or the arc filled up to
+ * the value (`solid`). `startAngle`/`endAngle` open or close the arc; `-90`/`90` is a semi-circle.
+ */
+declare function layoutGaugeChart(input: GaugeChartInput): Canvas;
+
+/**
+ * Three quantities per mark: x, y and a magnitude the bubble's area is proportional to
+ * (radius ∝ √z), floored at the smallest radius so tiny values stay visible. Negative
+ * magnitudes count as zero; `NaN` magnitudes draw the smallest bubble.
+ */
+declare function layoutBubbleChart(input: BubbleChartInput): Canvas;
+
+/**
+ * The distribution of a raw sample: equal-width bins by count or width (Sturges by default), or
+ * explicit `thresholds`. Bars measure counts, density (area sums to 1) or shares of the sample.
+ * Bins render as categories, so unequal `thresholds` bins are equally wide; density corrects for that.
+ */
+declare function layoutHistogram(input: HistogramInput): Canvas;
+
+/**
+ * A measure against a target over qualitative ranges (Few's bullet graph): one row per KPI,
+ * or one column when vertical. Reads compactly in dashboard cards where a gauge would not fit.
+ */
+declare function layoutBulletChart(input: BulletChartInput): Canvas;
+
+/**
+ * Bars, lines, areas and ranges on one category axis: every series declares its `type`, so a
+ * revenue bar and a margin line (on `axis: 'right'`) share the frame, legend and crosshair.
+ * `ComboChartInput` (the public props) requires a `type` per series so nothing but cartesian
+ * series can be passed; the layout itself takes any cartesian input so the framework roots'
+ * shared cartesian prop sets can call it.
+ */
+declare const layoutComboChart: (input: ChartInput) => Canvas;
+
+/**
+ * Low–high intervals per category: a shaded band (`area`), floating bars (`bar`) or two
+ * outlines (`line`). Inverted intervals (`low > high`) are normalized, equal ends draw a hairline,
+ * and a missing end is a gap.
  */
-declare function hoverTooltip(target: EventTarget | null, svg: Element, clientX: number, clientY: number, width: number, height: number): Shape[];
+declare function layoutRangeChart(input: RangeChartInput): Canvas;
 
+/** Node labels are drawn by default up to this many nodes. */
+declare const NETWORK_LABEL_LIMIT = 60;
+/**
+ * Nodes and edges of an arbitrary graph: force-directed (default), around a circle, or at
+ * the nodes' own coordinates. Deterministic: the same input always gives the same picture.
+ */
+declare function layoutNetworkChart(input: NetworkChartInput): Canvas;
+
+/**
+ * Point-in-time events on a time axis, sorted chronologically. Horizontal lanes stagger their
+ * labels so dense events stay readable; the vertical layout is a list, one row per event, which
+ * reads evenly however uneven the gaps are.
+ */
+declare function layoutTimelineChart(input: TimelineChartInput): Canvas;
+
+interface BinOptions {
+    /** Bin count. @default Sturges' rule, `ceil(log2(n) + 1)` */
+    bins?: number | undefined;
+    /** Bin width; wins over `bins`. */
+    binWidth?: number | undefined;
+    /** Value range covered; samples outside are dropped. @default the sample extent */
+    domain?: [number, number] | undefined;
+    /** Explicit, ascending bin edges; wins over everything else and allows unequal widths. */
+    thresholds?: number[] | undefined;
+}
+interface Bin {
+    /** Inclusive lower edge. */
+    x0: number;
+    /** Exclusive upper edge (inclusive for the last bin). */
+    x1: number;
+    count: number;
+}
+/**
+ * Ascending bin edges for a sample: explicit `thresholds`, else equal widths from `binWidth`
+ * or `bins` over `domain`. Deterministic: the same options always yield the same edges.
+ */
+declare function binEdges(samples: readonly number[], options?: BinOptions): number[];
+/** Counts the finite samples into the bins between consecutive `edges`. */
+declare function binSamples(values: readonly (Value | undefined)[], edges: readonly number[]): Bin[];
+
+/**
+ * Series colors, cycling through the `@skdx/tokens` scales so charts follow the
+ * active theme. Load `@skdx/tokens/css` (or any theme) for these to resolve.
+ */
+declare const SERIES_COLORS: readonly string[];
 declare const CHART_COLORS: {
     readonly axis: "var(--skdx-color-border-strong)";
     readonly grid: "var(--skdx-color-border-subtle)";
     readonly label: "var(--skdx-color-text-muted)";
+    readonly focus: "var(--skdx-color-focus-ring)";
+    readonly positive: "var(--skdx-color-success-500)";
+    readonly negative: "var(--skdx-color-danger-500)";
     readonly fontFamily: "var(--skdx-font-family)";
     readonly fontSize: "var(--skdx-font-size-xs)";
 };
+/** Semantic color of a reference line, band or threshold sector. */
+declare const variantColor: (variant?: Variant) => string;
+
+/** The default: the runtime locale's plain number format, with float noise trimmed. */
+declare const formatValue: (v: number) => string;
+/** Turns a `Format` into a function; `undefined` gives the default number format. */
+declare function makeFormatter(format: Format | undefined): (value: number) => string;
+/** A category as axis text: strings as they are, numbers and dates through `format`. */
+declare function categoryLabel(c: Category, format?: Format): string;
+
+/** Converts a client position into viewBox units of the svg. */
+declare function toViewBox(svg: Element, clientX: number, clientY: number, width: number, height: number): {
+    x: number;
+    y: number;
+};
+/** The shared tooltip rows at the category nearest to `x`, through the axis formatter when set. */
+declare function crosshairRows(layout: Canvas, x: number): {
+    index: number;
+    rows: string[];
+} | undefined;
+/** The crosshair line alone, at the category nearest to `x`. */
+declare function crosshairLine(layout: Canvas, x: number): Shape | undefined;
+/** The crosshair line and shared tooltip at the category nearest to `x`, or none outside the plot. */
+declare function crosshairShapes(layout: Canvas, x: number, y: number): Shape[];
+/** The crosshair shapes at a category label, for charts synced to another chart's pointer. */
+declare function crosshairAt(layout: Canvas, category: string): Shape[];
+/**
+ * What a pointer at the given position should show when the tooltip is rendered outside the svg
+ * (`tooltip.portal`): the text lines, and the crosshair line to keep inside the svg.
+ */
+declare function pointerTooltipText(layout: Canvas, target: EventTarget | null, svg: Element, clientX: number, clientY: number): {
+    lines: string[];
+    shapes: Shape[];
+};
+/**
+ * Tooltip shapes for the mark under the pointer, or none. Reads the mark's `<title>` (or its
+ * item through `formatter`) and converts the pointer position into viewBox units.
+ */
+declare function hoverTooltip(target: EventTarget | null, svg: Element, clientX: number, clientY: number, width: number, height: number, layout?: Canvas): Shape[];
+/** What to draw for a pointer at the given position: the crosshair when on, else the hovered mark's tooltip. */
+declare function pointerShapes(layout: Canvas, target: EventTarget | null, svg: Element, clientX: number, clientY: number): Shape[];
+/** The ref of the mark under the pointer (legend entries excluded), or `null` off any mark. */
+declare function hoveredRef(layout: Canvas, target: EventTarget | null): ChartItemRef | null;
+/** Refs of the marks whose anchor lies inside a viewBox rectangle: rectangular brush selection. */
+declare function itemsInBox(layout: Canvas, box: Box): ChartItemRef[];
+/** The dashed rectangle drawn while a selection brush is dragged. */
+declare const brushBoxShape: (box: Box) => Shape;
+/** A box from two corners, normalized. */
+declare const boxFrom: (x0: number, y0: number, x1: number, y1: number) => Box;
+/** Whether a point is inside a polygon (even-odd rule). */
+declare function insidePolygon(points: readonly {
+    x: number;
+    y: number;
+}[], x: number, y: number): boolean;
+/** Refs of the marks whose anchor lies inside a drawn polygon: lasso selection. */
+declare function itemsInPolygon(layout: Canvas, points: readonly {
+    x: number;
+    y: number;
+}[]): ChartItemRef[];
+/** The dashed outline drawn while a lasso is dragged. */
+declare const lassoShape: (points: readonly {
+    x: number;
+    y: number;
+}[]) => Shape;
+interface GanttGrab {
+    bar: EditModel['bars'][number];
+    mode: 'move' | 'start' | 'end';
+}
+/** What a pointer down at viewBox `(x, y)` grabs on an editable Gantt, if anything. */
+declare function ganttGrab(layout: Canvas, x: number, y: number): GanttGrab | undefined;
+/** The task after dragging a grab by `dx` viewBox pixels; the end never crosses the start. */
+declare function ganttDrag(layout: Canvas, grab: GanttGrab, dx: number): TaskChange;
+/**
+ * Keyboard editing of the focused bar (shape index `focus`): Shift+Arrow moves the task one
+ * step, Alt+Arrow moves its end, Alt+Shift+Arrow its start. A step is the snap unit, or the
+ * time under 10 px. `undefined` when the key or the focused shape is not an edit.
+ */
+declare function ganttKey(layout: Canvas, focus: number | null, key: {
+    key: string;
+    shiftKey: boolean;
+    altKey: boolean;
+}): TaskChange | undefined;
+/** The ghost outline of a task while it is dragged. */
+declare function ganttGhost(layout: Canvas, grab: GanttGrab, change: TaskChange): Shape;
+/** The view after a wheel step at viewBox `(x, y)`: scrolling up zooms in around the pointer. */
+declare function mapWheel(model: MapModel, deltaY: number, x: number, y: number): MapView;
+/** The view after dragging the map by `(dx, dy)` viewBox pixels from where `from` was set. */
+declare function mapPan(model: MapModel, from: MapModel['view'], dx: number, dy: number): MapView;
+/** The shape index and item of the mark an event landed on, if it stands for something. */
+declare function itemAt(layout: Canvas, target: EventTarget | null): {
+    index: number;
+    item: ChartItem;
+} | undefined;
+/** Indexes of the shapes a keyboard user can land on, in drawing order. */
+declare const focusTargets: (layout: Canvas) => number[];
+/** A representative point of a shape, where its tooltip is anchored. */
+declare function anchorOf(s: Shape): {
+    x: number;
+    y: number;
+};
+/** The focus ring around a shape plus its tooltip, for keyboard users. */
+declare function focusShapes(layout: Canvas, index: number | null): Shape[];
+/**
+ * The mark to focus after a key press: arrows step, Home/End jump, Escape clears (`null`);
+ * `undefined` means the key was not handled and should propagate.
+ */
+declare function nextFocus(layout: Canvas, current: number | null, key: string): number | null | undefined;
+/** Whether the zoom shows everything. */
+declare const isUnzoomed: (zoom: Zoom | undefined, count: number) => boolean;
+/** The window after a wheel step at viewBox `x`: scrolling up narrows around the pointer, down widens. */
+declare function zoomWheel(hit: Hit, deltaY: number, x: number): Zoom | undefined;
+/**
+ * The window after a pinch: `ratio` is the current finger distance over the distance when the
+ * pinch began (`> 1` narrows the window), anchored at viewBox `x`.
+ */
+declare function zoomPinch(hit: Hit, from: Zoom, ratio: number, x: number): Zoom;
+/** The window after dragging the plot by `dx` viewBox pixels from where `from` was set. */
+declare function zoomPan(hit: Hit, from: Zoom, dx: number): Zoom;
+type BrushGrab = 'move' | 'left' | 'right';
+/**
+ * What a pointer-down at viewBox (x, y) grabs in the range strip: a handle, the window,
+ * or (outside the window) a window re-centred there. `undefined` outside the strip.
+ */
+declare function brushGrab(hit: Hit, x: number, y: number): {
+    grab: BrushGrab;
+    zoom: Zoom;
+} | undefined;
+/** The window after dragging a brush grab by `dx` viewBox pixels. */
+declare function brushDrag(hit: Hit, grab: BrushGrab, from: Zoom, dx: number): Zoom;
+
+/** What `exportChart` produces and how. */
+type ChartExportOptions = {
+    /** Accessible name written into the SVG. */
+    label: string;
+    /** Maps `var(--skdx-…)` to concrete colors, e.g. from `getComputedStyle`. Required for PNG. */
+    resolve?: ((cssVariable: string) => string) | undefined;
+} & ({
+    type: 'svg';
+} | {
+    type: 'png';
+    /** Device pixels per unit. @default 2 */
+    scale?: number | undefined;
+    /** Fill behind the chart, e.g. the page surface; transparent by default. */
+    background?: string | undefined;
+} | {
+    type: 'csv';
+    rows: (string | number | null | undefined)[][];
+});
+/**
+ * One entry point for the export formats: SVG markup, a PNG blob (browser only), or CSV of the
+ * rows given. Rejects when a PNG is asked for outside a browser.
+ */
+declare function exportChart(layout: Canvas, options: ChartExportOptions): Promise<string | Blob>;
+/** One shape as SVG markup. Shared by the export and usable for server rendering. */
+declare function shapeMarkup(s: Shape): string;
+/** The `<defs>` block for a layout's gradients, or an empty string. */
+declare function defsMarkup(layout: Canvas): string;
+/**
+ * A standalone SVG document of a layout, for download or server rendering. Colors stay as
+ * `var(--skdx-…)` references unless `resolve` maps them to concrete values, e.g. from
+ * `getComputedStyle(document.documentElement).getPropertyValue(name)`.
+ */
+declare function svgMarkup(layout: Canvas, label: string, resolve?: (cssVariable: string) => string): string;
+/**
+ * Rasterizes SVG markup (from `svgMarkup`, with tokens resolved) to a PNG blob at `scale` device
+ * pixels per unit. Browser only: needs `Image`, `document` and a canvas.
+ */
+declare function svgToPng(markup: string, width: number, height: number, scale?: number, background?: string): Promise<Blob>;
+/** RFC 4180 CSV of rows, for "download data" and clipboard copy. */
+declare function csv(rows: (string | number | null | undefined)[][]): string;
+/** Series and categories as CSV rows: a header of series names, one row per category. */
+declare function seriesCsv(series: {
+    name: string;
+    data: (number | null)[];
+}[], categories?: (string | number | Date)[]): string;
+
+/** Normalizes a `Selection` into refs; bare ids become `{ id }`. */
+declare function toRefs(selection: Selection | ChartItemRef | ChartItemId | null | undefined): ChartItemRef[];
+/** Effective id of an item: the explicit id, else its name, else its series. */
+declare const itemId: (item: ChartItem) => ChartItemId | undefined;
+/** Whether every field the ref gives matches the item. An empty ref matches nothing. */
+declare function matchesItem(item: ChartItem, ref: ChartItemRef): boolean;
+/** Whether the item is in the selection. */
+declare const isSelected: (item: ChartItem, selection: Selection | undefined, refs?: ChartItemRef[]) => boolean;
+/** Ids (or names) named by a selection, for layouts that key their data by id. */
+declare const selectedIds: (selection: Selection | undefined) => ChartItemId[];
+/** The ref a mark's item stands for, as reported by `onSelectedChange`. */
+declare function refOf(item: ChartItem): ChartItemRef;
+/** Whether two refs locate the same item. */
+declare const sameRef: (a: ChartItemRef, b: ChartItemRef) => boolean;
+/** The selection after a click on `item` in the given mode. */
+declare function toggleSelection(selection: Selection | undefined, item: ChartItem, mode: 'single' | 'multiple'): ChartItemRef[];
+/**
+ * Applies `selected` and `highlighted` to a laid-out chart: marks outside the highlight scope
+ * fade, selected marks get an outline appended after the marks (so shape indexes, and with them
+ * `data-skdx-i`, stay stable). Legend entries, grid, axes and tooltips are never touched.
+ */
+declare function emphasize(layout: Canvas, input: Sized): Canvas;
+
+/** A resolved color scale: value → fill and opacity, plus what its legend needs. */
+interface ResolvedColorScale {
+    /** Fill and opacity for a value; `undefined` for a non-finite value. */
+    color: (value: number | null | undefined) => {
+        fill: string;
+        opacity: number;
+    } | undefined;
+    /** The value range the scale covers. */
+    domain: readonly [number, number];
+    /** Legend swatches, low to high: a representative value (or class label) per swatch. */
+    swatches: {
+        fill: string;
+        opacity: number;
+        label: string;
+    }[];
+    kind: ColorScale['type'];
+}
+/** `[r, g, b]` of a `#rgb`, `#rrggbb` or `rgb(r, g, b)` color; `undefined` for anything else. */
+declare function parseColor(c: string): [number, number, number] | undefined;
+/**
+ * The color at `t` (0–1) along the stops: interpolated in RGB when every stop is a concrete
+ * color, else the nearest stop (token colors such as `var(--skdx-color-primary-500)` cannot be
+ * mixed in the core, so they quantize).
+ */
+declare function mixStops(stops: string[], t: number): string;
+/**
+ * Resolves a `ColorScale` over the data extent. Without explicit stops a sequential scale is
+ * `baseColor` at an opacity ramp (0.15–1) and a diverging scale splits `negativeColor` /
+ * `baseColor` around zero, which is what the heatmap and map always did.
+ */
+declare function makeColorScale(scale: ColorScale | undefined, values: Iterable<number | null | undefined>, baseColor: string, negativeColor?: string, format?: (v: number) => string): ResolvedColorScale;
+/**
+ * The color scale as swatches: a horizontal strip with labels underneath laid across `box`, or
+ * (`orientation: 'vertical'`) a column of swatches down `box` with labels to the right.
+ */
+declare function colorLegendShapes(scale: ResolvedColorScale, box: Box, options?: string | ColorLegendOptions): Shape[];
+
+declare const cumulative: (data: readonly Value[]) => Value[];
+/** `v[i] - v[i-1]`; the first value, and any value after a gap, is a gap. */
+declare const difference: (data: readonly Value[]) => Value[];
+/** `(v[i] - v[i-1]) / |v[i-1]|` as a fraction; a zero previous value is a gap. */
+declare const percentageChange: (data: readonly Value[]) => Value[];
+/** Trailing mean over `window` values; the first `window - 1` are gaps, as is any window with a gap. */
+declare function movingAverage(data: readonly Value[], window: number): Value[];
+/** Exponential moving average with `alpha = 2 / (window + 1)`, seeded by the first `window` mean. */
+declare function exponentialMovingAverage(data: readonly Value[], window: number): Value[];
+/** Values as a share of the maximum (0–1), or of the sum. */
+declare function normalize(data: readonly Value[], to?: 'max' | 'sum'): Value[];
+/** 1-based rank of each value, largest first by default; ties share the lower rank. */
+declare function rank(data: readonly Value[], order?: 'asc' | 'desc'): Value[];
+/** Keeps values inside `[min, max]`; the rest become gaps. */
+declare const filter: (data: readonly Value[], min?: number, max?: number) => Value[];
+/** Values sorted; gaps go last. */
+declare const sortValues: (data: readonly Value[], order?: "asc" | "desc") => Value[];
+/** Folds every `every` consecutive values into one by `method`; a fold of only gaps is a gap. */
+declare function aggregate(data: readonly Value[], every: number, method?: 'sum' | 'mean' | 'min' | 'max'): Value[];
+/** Counts the values into equal-width bins (see `binEdges`); the result has one count per bin. */
+declare function binCounts(data: readonly Value[], options?: {
+    bins?: number | undefined;
+    binWidth?: number | undefined;
+    domain?: [number, number] | undefined;
+}): {
+    edges: number[];
+    counts: number[];
+};
+/** Applies transforms in order. */
+declare function applyTransforms(data: readonly Value[], transforms: readonly SeriesTransform[] | undefined): Value[];
+
+/** Above this many visible points `sampling: 'auto'` kicks in. */
+declare const SAMPLING_THRESHOLD = 2000;
+/** The threshold and strategy a `Sampling` option resolves to; `undefined` when sampling is off. */
+declare function samplingOptions(sampling: Sampling | undefined): {
+    strategy: 'lttb' | 'minmax' | 'm4';
+    threshold: number;
+} | undefined;
+/**
+ * Largest-Triangle-Three-Buckets (Steinarsson 2013): keeps the point of each bucket that forms
+ * the largest triangle with the previous kept point and the next bucket's average, so peaks and
+ * the visual shape survive. Returns the kept indexes into `values`.
+ */
+declare function lttb(values: readonly Value[], threshold: number): number[];
+/** Keeps the minimum and maximum of each of `threshold / 2` equal buckets, plus every gap. */
+declare function minMaxSample(values: readonly Value[], threshold: number): number[];
+/**
+ * M4 (Jugel et al. 2014): keeps the first, last, minimum and maximum of each of `threshold / 4`
+ * equal buckets, which reproduces a line chart pixel-exactly at that width. Gaps are kept.
+ */
+declare function m4(values: readonly Value[], threshold: number): number[];
+/**
+ * Indexes to keep for a set of series sharing one category axis: the union of each series'
+ * sample, so every series keeps its own extremes. `undefined` when nothing needs sampling.
+ */
+declare function sampleIndexes(series: readonly (readonly Value[])[], count: number, sampling: Sampling | undefined): number[] | undefined;
+
+/** A node's size: its own value, else the sum of its children's. */
+declare const nodeValue: (n: TreeNode) => number;
+/** Levels below the given nodes (0 for none). */
+declare const depthOf: (nodes: readonly TreeNode[]) => number;
+/** A node's identity: its id, else its name. */
+declare const nodeId: (n: TreeNode) => ChartItemId;
+/** The path from a top-level node down to the node with `id` (or name), or `undefined`. */
+declare function findPath(nodes: readonly TreeNode[], id: ChartItemId): TreeNode[] | undefined;
+/** Children sorted by size, or as given. */
+declare const sortChildren: (nodes: readonly TreeNode[], sort: "asc" | "desc" | "none" | undefined) => TreeNode[];
+/** The tree cut at `maxDepth`: nodes at the limit keep their summed value and lose their children. */
+declare function cutDepth(nodes: readonly TreeNode[], maxDepth: number | undefined, depth?: number): TreeNode[];
+/**
+ * The subtree to draw and the breadcrumb path for a controlled drill-down `root`; the whole
+ * tree when `root` is unset or unknown.
+ */
+declare function drill(nodes: readonly TreeNode[], root: ChartItemId | undefined): {
+    nodes: TreeNode[];
+    path: TreeNode[];
+};
+
+/** Default row cap of the accessible table. */
+declare const TABLE_LIMIT = 500;
+/**
+ * Header and rows of the accessible table for a layout: the shared crosshair rows when the chart
+ * has them (one row per category, one column per series), else one row per titled mark
+ * (series, name, category, value). `undefined` when the option is off, the chart is in a state,
+ * or there are more rows than `maxRows`.
+ */
+declare function tableRows(layout: Canvas, option: boolean | AccessibleTableOptions | undefined): string[][] | undefined;
+
+/** What a group shares. Every field is optional: a chart publishes only what changed. */
+interface SyncState {
+    highlighted?: ChartItemRef | null | undefined;
+    selected?: ChartItemRef[] | undefined;
+    zoom?: Zoom | undefined;
+    hiddenSeries?: string[] | undefined;
+    /** The category under the crosshair (by label), or `null` when the pointer left. */
+    crosshair?: string | null | undefined;
+}
+type SyncListener = (state: SyncState, source: object) => void;
+interface SyncGroup {
+    /** Listens for changes published by other members; returns the unsubscribe function. */
+    subscribe(listener: SyncListener): () => void;
+    /** Publishes a change; `source` identifies the publisher so it can ignore its own echo. */
+    publish(state: SyncState, source: object): void;
+    /** The last published values, for members that join later. */
+    readonly current: SyncState;
+}
+/** The group for a `syncId`, created on first use; groups are keyed per JavaScript realm. */
+declare function syncGroup(id: string): SyncGroup;
+
+interface ReferenceScales {
+    plot: Box;
+    /** Pixel x of a data x, or `undefined` when it cannot be placed (unknown category). */
+    x: (value: Category) => number | undefined;
+    /** Pixel y of a data y on the named axis. */
+    y: (value: number, axis: 'left' | 'right') => number;
+    /** Categories run down the y axis and values along x (horizontal bars). */
+    horizontal?: boolean | undefined;
+}
+/**
+ * Lines and bands in data coordinates, drawn behind the marks: targets, SLAs, budgets,
+ * forecast periods, healthy ranges. Each carries its label at the plot edge.
+ */
+declare function referenceShapes(refs: Reference[] | undefined, s: ReferenceScales): Shape[];
+/**
+ * Annotations over the marks: lines and bands reuse the reference drawing; points, callouts,
+ * text and rectangles are placed at `(x, y)` in data coordinates. Each carries its label as a
+ * `<title>` and an item, so it is hoverable and a keyboard stop.
+ */
+declare function annotationShapes(annotations: Annotation[] | undefined, s: ReferenceScales): Shape[];
+
+/**
+ * A path moved by `(dx, dy)`: absolute commands are translated (for `A`, only the end point),
+ * relative (lowercase) commands are left as they are, `Z` has nothing to move.
+ */
+declare function translatePath(d: string, dx: number, dy: number): string;
+/** Every shape moved by `(dx, dy)`. */
+declare const translateShapes: (shapes: readonly Shape[], dx: number, dy: number) => Shape[];
+
+/** Above this many shapes animation switches itself off; the transitions would cost more than they explain. */
+declare const ANIMATION_LIMIT = 1500;
+/**
+ * The static stylesheet every root ships: marks fade in on mount and their geometry transitions on
+ * change, both over `--skdx-chart-duration`, which is `0ms` (nothing moves) unless the root sets it
+ * from `animationDuration`. Tooltips, focus rings and the crosshair are excluded so interaction
+ * stays immediate; `prefers-reduced-motion` turns everything off. Geometry transitions rely on
+ * SVG 2 presentation attributes as CSS properties, which evergreen browsers support.
+ */
+declare const ANIMATION_CSS: string;
+/** The `--skdx-chart-duration` value for a layout, e.g. `300ms`, or `undefined` when it must not animate. */
+declare function animationDuration(layout: Canvas): string | undefined;
+
+/**
+ * Round timestamps covering `[min, max]` (epoch ms), about `count` of them: seconds to weeks as
+ * UTC-aligned multiples, then whole months or years.
+ */
+declare function timeTicks(min: number, max: number, count?: number): number[];
 
 declare function layoutSankey(input: SankeyInput): Canvas;
 
+/**
+ * Tiles by value, branches outlined with their children tiled inside. `rootId` shows one node's
+ * subtree (controlled drill-down), `breadcrumbs` writes the path to it, `tiling` picks the
+ * algorithm and `colorScale` colors leaves by value instead of by branch.
+ */
 declare function layoutTreemap(input: TreemapInput): Canvas;
 
+/** Candles or OHLC bars on a time axis, with an optional volume pane, references, zoom and brush. */
 declare function layoutCandlestick(input: CandlestickInput): Canvas;
 
+/**
+ * Signed deltas stacked on the running total: `subtotal` and `total` rows stand on zero and show
+ * the level reached, `start` opens the bridge at a given level, and the steps run down the y
+ * axis when horizontal.
+ */
 declare function layoutWaterfall(input: WaterfallInput): Canvas;
 
+/**
+ * Intervals on a numeric time axis, one row per task, or per `group` when tasks share one.
+ * Generic enough for schedules, on-call shifts, uptime windows and market sessions.
+ */
 declare function layoutGantt(input: GanttInput): Canvas;
 
+/**
+ * One box per series (or per series and category when `categories` is set): raw samples
+ * summarized with the chosen quartile method, or a given summary.
+ */
 declare function layoutBoxplot(input: BoxplotInput): Canvas;
 
+/**
+ * Nested rings, one per tree depth, children inside their parent's span. `rootId` fills the
+ * rings with one node's subtree (controlled drill-down), `padAngle` separates siblings and
+ * `colorScale` colors leaves by value.
+ */
 declare function layoutSunburst(input: SunburstInput): Canvas;
 
 declare function layoutChord(input: ChordInput): Canvas;
 
-/** Projection fitted to the features' bounds (equirectangular by default, or Mercator); opacity follows the value. */
+/**
+ * Regions (a choropleth), a marker/bubble layer and a line layer, all under one projection
+ * fitted to the regions' bounds (equirectangular by default, or Mercator). Region fill follows
+ * the value through `colorScale`, by default a single color at an opacity ramp.
+ */
 declare function layoutMap(input: MapInput): Canvas;
 
-/** The accessible `<svg>` root every chart renders into: projected marks, then decorations, then the hover tooltip. */
+/**
+ * Two encodings in one chart: column widths follow each category's total (market size, revenue),
+ * segment heights inside a column follow that segment's share of the column (mix, composition).
+ * Every tooltip names both, since neither reads off the axes alone.
+ */
+declare function layoutMarimekkoChart(input: MarimekkoChartInput): Canvas;
+
+/** Per-row titles and keyboard stops are emitted up to this many rows. */
+declare const PARALLEL_TITLE_LIMIT = 500;
+/**
+ * One vertical axis per dimension, each on its own scale, and one polyline per row through its
+ * values: model comparisons, instance types, product specs. Filters fade the rows outside them.
+ */
+declare function layoutParallelCoordinates(input: ParallelCoordinatesInput): Canvas;
+
+/**
+ * One reading on a straight scale: the bullet engine with gauge semantics (`value`, `min`,
+ * `max`, `bands`, `target`). Reads in a KPI card where an arc would not fit.
+ */
+declare function layoutLinearGauge(input: LinearGaugeInput): Canvas;
+
+/**
+ * A category with a start and an end value joined by a connector: before/after, plan/actual,
+ * previous/current. Horizontal by default (categories down y), vertical on request.
+ */
+declare function layoutDumbbellChart(input: DumbbellChartInput): Canvas;
+
+/**
+ * Categories sorted by value with the cumulative share as a line on the right axis, so the
+ * "vital few" causes stand out. Reuses the cartesian engine: bars on the left axis, the
+ * cumulative line on a 0–100% right axis, an optional threshold reference (e.g. 80%).
+ */
+declare function layoutParetoChart(input: ParetoChartInput): Canvas;
+
+/**
+ * A node-link tree: leaves get evenly spaced slots in post-order and every parent sits over the
+ * middle of its children; depth runs down (or right). A tidy Reingold–Tilford layout is not
+ * needed for the dashboard-sized trees this draws.
+ */
+declare function layoutTreeChart(input: TreeChartInput): Canvas;
+/** An organization chart: the tree with boxes and elbow links. */
+declare const layoutOrganizationChart: (input: OrganizationChartInput) => Canvas;
+
+interface Circle {
+    x: number;
+    y: number;
+    r: number;
+}
+/**
+ * Packs circles of the given radii (largest first) around the origin: each next circle walks a
+ * spiral outward until it overlaps none of the placed ones, so the result is deterministic and
+ * compact enough for dashboards. Returns the circles and the enclosing radius.
+ * ponytail: O(n²) per sibling set; a front-chain packer if a node ever has thousands of children.
+ */
+declare function packCircles(radii: number[], padding: number): {
+    circles: Circle[];
+    enclosing: number;
+};
+/** Nested circles sized by value: children packed inside their parent, leaves filled. */
+declare function layoutCirclePacking(input: CirclePackingInput): Canvas;
+
+/**
+ * A rectangular sunburst (partition): one row per depth (or one column when horizontal), each
+ * node a cell whose extent is its share of the parent's, children stacked under their parent.
+ */
+declare function layoutIcicle(input: IcicleInput): Canvas;
+
+/**
+ * Ranks over categories: one line per series with rank 1 at the top. Ranks are computed per
+ * category from the values (largest first, ties in series order) unless the data already are
+ * ranks. A rank beyond `topRank`, or a gap, breaks the line.
+ */
+declare function layoutBumpChart(input: BumpChartInput): Canvas;
+
+/**
+ * A Nightingale rose: every datum gets the same angle and its radius follows the value, by
+ * default through a square root so that sector area, not radius, is proportional to it.
+ */
+declare function layoutPolarAreaChart(input: PolarAreaChartInput): Canvas;
+
+/** Per-series dot titles and keyboard stops are emitted up to this many dots. */
+declare const SWARM_TITLE_LIMIT = 2000;
+/**
+ * Offsets across the category band that keep dots of radius `r` from overlapping: samples come
+ * sorted by their pixel position along the value axis; each dot takes the smallest sideways
+ * offset (alternating sides, 1px steps) clear of every earlier dot within `2r` of it.
+ * ponytail: O(n × offsets) per swarm; fine to a few thousand dots, a grid index beyond.
+ */
+declare function swarmOffsets(positions: readonly number[], r: number, half: number): number[];
+/** Every observation as a dot, one swarm per series, spread sideways so none overlap. */
+declare function layoutSwarmPlot(input: SwarmPlotInput): Canvas;
+
+/**
+ * Cells per datum by the largest-remainder method: floors first, then the leftover cells go to the
+ * largest fractional parts, so the counts add up to `round(sum(quotas))` exactly.
+ */
+declare function waffleCounts(quotas: readonly number[]): number[];
+/** A grid of cells, each a share of the total, colored by datum; empty cells for the unaccounted rest. */
+declare function layoutWaffleChart(input: WaffleChartInput): Canvas;
+
+/** How clicks (and, for `brush`/`lasso`, drags) change the selection. */
+type SelectionMode = 'none' | 'single' | 'multiple' | 'brush' | 'lasso';
+/**
+ * The accessible `<svg>` root every chart renders into: marks, decorations, then the hover or
+ * keyboard tooltip. Owns focus state; reports legend toggles, zoom, view, selection, highlight
+ * and task changes to the chart, which applies them through its models.
+ */
 declare class SkdxChartRootComponent {
-    readonly layout: _angular_core.InputSignal<Canvas>;
+    /** The chart's layout, before selection and highlight emphasis. */
+    readonly layoutInput: _angular_core.InputSignal<Canvas>;
+    /** The shared options, for emphasis and the accessible table. */
+    readonly options: _angular_core.InputSignal<Sized>;
     readonly kind: _angular_core.InputSignal<string>;
     readonly label: _angular_core.InputSignal<string>;
+    /** Wheel and pinch zoom, drag pans the category axis (or the map). */
+    readonly zoomable: _angular_core.InputSignal<boolean>;
+    /** Clicks select marks: one, any number, a dragged rectangle or a drawn outline. */
+    readonly selectionMode: _angular_core.InputSignal<SelectionMode>;
+    /** Gantt bars can be dragged and resized. */
+    readonly editable: _angular_core.InputSignal<boolean>;
+    /** Charts sharing a `syncId` share highlight, selection, zoom, hidden series and the crosshair. */
+    readonly syncId: _angular_core.InputSignal<string | undefined>;
+    /** The category another chart of the group has its crosshair on. */
+    readonly crosshair: _angular_core.InputSignal<string | null>;
+    /** Measure the host and report its width, so the chart can lay out at that width. */
+    readonly responsive: _angular_core.InputSignal<boolean>;
+    /** A mark was clicked, or Enter/Space was pressed on the focused mark. */
+    readonly itemClick: _angular_core.OutputEmitterRef<ChartItem>;
+    /** The legend toggled a series; the chart applies it through its `hiddenSeries` model. */
+    readonly hiddenSeriesChange: _angular_core.OutputEmitterRef<string[]>;
+    /** Wheel, drag, pinch or brush moved the window; the chart applies it through its `zoom` model. */
+    readonly zoomChange: _angular_core.OutputEmitterRef<Zoom | undefined>;
+    /** The map was panned or zoomed; the chart applies it through its `view` model. */
+    readonly viewChange: _angular_core.OutputEmitterRef<MapView | undefined>;
+    /** A click or brush changed the selection; the chart applies it through its `selected` model. */
+    readonly selectedChange: _angular_core.OutputEmitterRef<ChartItemRef[]>;
+    /** The mark under the pointer or focus changed. */
+    readonly highlightedChange: _angular_core.OutputEmitterRef<ChartItemRef | null>;
+    /** A data problem was found while laying out. */
+    readonly dataIssue: _angular_core.OutputEmitterRef<ChartDataIssue>;
+    /** A Gantt bar was dragged or resized. */
+    readonly taskChange: _angular_core.OutputEmitterRef<TaskChange>;
+    /** Another chart in the sync group published a change; the chart applies it through its models. */
+    readonly syncChange: _angular_core.OutputEmitterRef<SyncState>;
+    /** The host's measured width, under `responsive`. */
+    readonly measured: _angular_core.OutputEmitterRef<number>;
     protected readonly colors: {
         readonly axis: "var(--skdx-color-border-strong)";
         readonly grid: "var(--skdx-color-border-subtle)";
         readonly label: "var(--skdx-color-text-muted)";
+        readonly focus: "var(--skdx-color-focus-ring)";
+        readonly positive: "var(--skdx-color-success-500)";
+        readonly negative: "var(--skdx-color-danger-500)";
         readonly fontFamily: "var(--skdx-font-family)";
         readonly fontSize: "var(--skdx-font-size-xs)";
     };
+    protected readonly layout: _angular_core.Signal<Canvas>;
+    protected readonly duration: _angular_core.Signal<string | null>;
+    protected readonly table: _angular_core.Signal<string[][] | undefined>;
+    protected readonly caption: _angular_core.Signal<string>;
+    private readonly pointers;
+    private readonly svg;
+    private hover;
+    private readonly token;
+    constructor();
     protected readonly tip: _angular_core.WritableSignal<Shape[]>;
+    protected readonly tipShapes: _angular_core.Signal<Shape[]>;
+    private lastCross;
+    protected readonly portal: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+        lines: string[];
+    } | null>;
+    protected readonly focused: _angular_core.WritableSignal<number | null>;
+    protected readonly overlay: _angular_core.WritableSignal<Shape[]>;
+    protected readonly canZoom: _angular_core.Signal<boolean>;
+    protected readonly canPan: _angular_core.Signal<boolean>;
+    protected readonly canEdit: _angular_core.Signal<boolean>;
+    protected readonly brushing: _angular_core.Signal<boolean>;
+    protected readonly active: _angular_core.Signal<boolean>;
+    protected readonly focusable: _angular_core.Signal<boolean>;
+    protected readonly descId: _angular_core.Signal<string | null>;
+    protected readonly focusShapes: _angular_core.Signal<Shape[]>;
+    private drag;
+    /** The rendered `<svg>`. */
+    getSvgElement(): SVGSVGElement;
+    /** The current layout: shapes, size, hit model. */
+    getLayout(): Canvas;
+    /** Moves keyboard focus to the first mark matching the ref; `false` when none matches. */
+    focusItem(ref: ChartItemRef): boolean;
+    /** SVG markup, a PNG blob, or CSV, through the core's `exportChart`. */
+    export(options: Omit<ChartExportOptions, 'label'> & {
+        label?: string;
+    }): Promise<string | Blob>;
+    private viewBox;
+    private publish;
+    private setZoom;
+    private setSelected;
+    private highlight;
+    private select;
+    private shareCrosshair;
+    private clearTip;
     protected onPointerMove(e: PointerEvent): void;
+    protected onPointerLeave(): void;
+    protected onBlur(): void;
+    protected onDoubleClick(): void;
+    protected onPointerDown(e: PointerEvent): void;
+    protected onPointerUp(e: PointerEvent): void;
+    protected onWheel(e: WheelEvent): void;
+    protected onClick(e: MouseEvent): void;
+    protected onKeyDown(e: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkdxChartRootComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkdxChartRootComponent, "skdx-chart-root", never, { "layout": { "alias": "layout"; "required": true; "isSignal": true; }; "kind": { "alias": "kind"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkdxChartRootComponent, "skdx-chart-root", never, { "layoutInput": { "alias": "layout"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "kind": { "alias": "kind"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "zoomable": { "alias": "zoomable"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "syncId": { "alias": "syncId"; "required": false; "isSignal": true; }; "crosshair": { "alias": "crosshair"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; "hiddenSeriesChange": "hiddenSeriesChange"; "zoomChange": "zoomChange"; "viewChange": "viewChange"; "selectedChange": "selectedChange"; "highlightedChange": "highlightedChange"; "dataIssue": "dataIssue"; "taskChange": "taskChange"; "syncChange": "syncChange"; "measured": "measured"; }, never, never, true, never>;
 }
-/** The `<svg>` root, grid, axis and tick labels every axis chart shares; marks are projected. */
+/** Size, state, formatting, accessibility and interaction inputs every chart takes. */
 declare abstract class SkdxSizedBase {
     readonly width: _angular_core.InputSignal<number | undefined>;
     readonly height: _angular_core.InputSignal<number | undefined>;
     /** Accessible name of the chart; defaults to "<Kind> chart". */
     readonly label: _angular_core.InputSignal<string | undefined>;
-    /** Draw a legend row above the plot. */
-    readonly legend: _angular_core.InputSignal<boolean>;
-    /** Show a hover tooltip for the mark under the pointer. */
-    readonly tooltip: _angular_core.InputSignal<boolean>;
+    /** Draw a legend row above the plot; an object sets position, interactivity and item limit. */
+    readonly legend: _angular_core.InputSignal<boolean | LegendOptions>;
+    /** Show a hover tooltip for the mark under the pointer; an object configures it. */
+    readonly tooltip: _angular_core.InputSignal<boolean | TooltipOptions>;
+    /** How values are written: a function or an `Intl` style such as `{ style: 'currency', currency: 'EUR' }`. */
+    readonly format: _angular_core.InputSignal<Format | undefined>;
+    /** Categorical series colors, cycled by series index. */
+    readonly palette: _angular_core.InputSignal<string[] | undefined>;
+    /** Series left out of the plot; two-way bindable, the legend toggles it. */
+    readonly hiddenSeries: _angular_core.ModelSignal<string[] | undefined>;
+    /** Selected items; two-way bindable, clicks update it under `selectionMode`. */
+    readonly selected: _angular_core.ModelSignal<Selection | undefined>;
+    /** Clicks select marks: one, any number, a dragged rectangle or a drawn outline. */
+    readonly selectionMode: _angular_core.InputSignal<SelectionMode>;
+    /** The item(s) under emphasis; two-way bindable, hover and focus update it. */
+    readonly highlighted: _angular_core.ModelSignal<_skdx_angular_charts_internal.ChartItemId | ChartItemRef | (_skdx_angular_charts_internal.ChartItemId | ChartItemRef)[] | null | undefined>;
+    readonly highlightScope: _angular_core.InputSignal<HighlightScope | undefined>;
+    /** Draw a loading placeholder instead of the chart. */
+    readonly loading: _angular_core.InputSignal<boolean>;
+    /** Draw this message instead of the chart. */
+    readonly error: _angular_core.InputSignal<string | undefined>;
+    /** Written in place of an empty chart. */
+    readonly emptyMessage: _angular_core.InputSignal<string | undefined>;
+    /** Longer accessible description, rendered as the svg `<desc>`. */
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    /** Hide the chart from assistive technology. */
+    readonly decorative: _angular_core.InputSignal<boolean>;
+    /** Render a visually hidden data table next to the svg. */
+    readonly accessibleTable: _angular_core.InputSignal<boolean | AccessibleTableOptions>;
+    /** Fade marks in and transition them on change; `true` is 300 ms, a number sets the duration. */
+    readonly animate: _angular_core.InputSignal<number | boolean>;
+    /** Lay the chart out at the host's width, so text keeps its size; an object adds `compact` overrides. */
+    readonly responsive: _angular_core.InputSignal<boolean | ResponsiveOptions>;
+    /** The width the root measured under `responsive`. */
+    protected readonly measuredWidth: _angular_core.WritableSignal<number | undefined>;
+    /** Visible category window; two-way bindable, wheel, drag, pinch and brush update it. */
+    readonly zoom: _angular_core.ModelSignal<Zoom | undefined>;
+    /** The map's pan/zoom state; two-way bindable, wheel and drag update it. */
+    readonly view: _angular_core.ModelSignal<MapView | undefined>;
+    /** Wheel zooms and drag pans the category axis (or the map). */
+    readonly zoomable: _angular_core.InputSignal<boolean>;
+    /** Gantt bars can be dragged and resized; listen to `(taskChange)`. */
+    readonly editable: _angular_core.InputSignal<boolean>;
+    /** Charts sharing a `syncId` share highlight, selection, zoom, hidden series and the crosshair. */
+    readonly syncId: _angular_core.InputSignal<string | undefined>;
+    /** With `syncId`: a selection made in another chart of the group fades everything else here. */
+    readonly crossFilter: _angular_core.InputSignal<boolean>;
+    /** The category another chart of the group has its crosshair on. */
+    protected readonly syncedCrosshair: _angular_core.WritableSignal<string | null>;
+    /** A mark was clicked, or Enter/Space was pressed on the focused mark. */
+    readonly itemClick: _angular_core.OutputEmitterRef<ChartItem>;
+    /** A data problem was found while laying out. */
+    readonly dataIssue: _angular_core.OutputEmitterRef<ChartDataIssue>;
+    /** A Gantt bar was dragged or resized. */
+    readonly taskChange: _angular_core.OutputEmitterRef<TaskChange>;
+    /** The root component, for the imperative surface. */
+    protected readonly chartRoot: _angular_core.Signal<SkdxChartRootComponent | undefined>;
+    /** Highlight received from the sync group, used while `highlighted` is not set. */
+    protected readonly syncedHighlight: _angular_core.WritableSignal<_skdx_angular_charts_internal.ChartItemId | ChartItemRef | (_skdx_angular_charts_internal.ChartItemId | ChartItemRef)[] | null | undefined>;
+    /** The shared options as one memoized object, so the root's input only changes when they do. */
+    protected readonly options: _angular_core.Signal<{
+        width: number | undefined;
+        height: number | undefined;
+        animate: number | boolean;
+        responsive: boolean | ResponsiveOptions;
+        legend: boolean | LegendOptions;
+        tooltip: boolean | TooltipOptions;
+        format: Format | undefined;
+        palette: string[] | undefined;
+        hiddenSeries: string[] | undefined;
+        selected: Selection | undefined;
+        highlighted: _skdx_angular_charts_internal.ChartItemId | ChartItemRef | (_skdx_angular_charts_internal.ChartItemId | ChartItemRef)[] | null | undefined;
+        highlightScope: HighlightScope | undefined;
+        loading: boolean;
+        error: string | undefined;
+        emptyMessage: string | undefined;
+        description: string | undefined;
+        decorative: boolean;
+        accessibleTable: boolean | AccessibleTableOptions;
+        zoom: Zoom | undefined;
+        view: MapView | undefined;
+    }>;
+    /** The rendered `<svg>`, or `null` before the first render. */
+    getSvgElement(): SVGSVGElement | null;
+    /** The current layout: shapes, size, hit model. */
+    getLayout(): Canvas | undefined;
+    resetZoom(): void;
+    zoomTo(zoom: Zoom): void;
+    /** Moves keyboard focus to the first mark matching the ref; `false` when none matches. */
+    focusItem(ref: ChartItemRef): boolean;
+    /** SVG markup, a PNG blob, or CSV, through the core's `exportChart`. */
+    export(options: Omit<ChartExportOptions, 'label'> & {
+        label?: string;
+    }): Promise<string | Blob>;
+    /** Applies a legend toggle reported by the root. */
+    protected toggle([name]: string[]): void;
+    /** Applies what another chart in the sync group published. */
+    protected sync(state: SyncState): void;
     protected sized(): {
         width: number | undefined;
         height: number | undefined;
-        legend: boolean;
-        tooltip: boolean;
+        animate: number | boolean;
+        responsive: boolean | ResponsiveOptions;
+        legend: boolean | LegendOptions;
+        tooltip: boolean | TooltipOptions;
+        format: Format | undefined;
+        palette: string[] | undefined;
+        hiddenSeries: string[] | undefined;
+        selected: Selection | undefined;
+        highlighted: _skdx_angular_charts_internal.ChartItemId | ChartItemRef | (_skdx_angular_charts_internal.ChartItemId | ChartItemRef)[] | null | undefined;
+        highlightScope: HighlightScope | undefined;
+        loading: boolean;
+        error: string | undefined;
+        emptyMessage: string | undefined;
+        description: string | undefined;
+        decorative: boolean;
+        accessibleTable: boolean | AccessibleTableOptions;
+        zoom: Zoom | undefined;
+        view: MapView | undefined;
     };
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkdxSizedBase, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkdxSizedBase, never, never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkdxSizedBase, never, never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "palette": { "alias": "palette"; "required": false; "isSignal": true; }; "hiddenSeries": { "alias": "hiddenSeries"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selectionMode": { "alias": "selectionMode"; "required": false; "isSignal": true; }; "highlighted": { "alias": "highlighted"; "required": false; "isSignal": true; }; "highlightScope": { "alias": "highlightScope"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; "accessibleTable": { "alias": "accessibleTable"; "required": false; "isSignal": true; }; "animate": { "alias": "animate"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "zoomable": { "alias": "zoomable"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "syncId": { "alias": "syncId"; "required": false; "isSignal": true; }; "crossFilter": { "alias": "crossFilter"; "required": false; "isSignal": true; }; }, { "hiddenSeries": "hiddenSeriesChange"; "selected": "selectedChange"; "highlighted": "highlightedChange"; "zoom": "zoomChange"; "view": "viewChange"; "itemClick": "itemClick"; "dataIssue": "dataIssue"; "taskChange": "taskChange"; }, never, never, true, never>;
 }
-/** Inputs the category charts take. */
+/** Inputs the cartesian charts (bar, line, area) take. */
 declare abstract class SkdxChartBase extends SkdxSizedBase {
-    readonly series: _angular_core.InputSignal<Series[]>;
-    readonly categories: _angular_core.InputSignal<string[] | undefined>;
+    readonly series: _angular_core.InputSignal<(CartesianSeries | RangeSeries)[]>;
+    /** X-axis labels; numbers and dates are written with `xAxis.format`. */
+    readonly categories: _angular_core.InputSignal<Category[] | undefined>;
+    readonly xAxis: _angular_core.InputSignal<XAxisOptions | undefined>;
+    readonly yAxis: _angular_core.InputSignal<AxisOptions | undefined>;
+    /** Enables the second y axis; series opt in with `axis: 'right'`. */
+    readonly rightAxis: _angular_core.InputSignal<AxisOptions | undefined>;
+    /** Lines and bands in data coordinates: targets, SLAs, forecast periods. */
+    readonly references: _angular_core.InputSignal<Reference[] | undefined>;
+    /** Points, callouts, text and rectangles in data coordinates. */
+    readonly annotations: _angular_core.InputSignal<Annotation[] | undefined>;
+    /** Write each value next to its mark. */
+    readonly labels: _angular_core.InputSignal<boolean>;
+    readonly curve: _angular_core.InputSignal<Curve | undefined>;
+    readonly connectNulls: _angular_core.InputSignal<boolean>;
+    /** What a null does to a line: a gap, a bridge, or a zero. */
+    readonly nulls: _angular_core.InputSignal<"gap" | "connect" | "zero" | undefined>;
+    /** Stack the series; `'percent'` normalizes each category to 100%. */
+    readonly stacked: _angular_core.InputSignal<boolean | "percent">;
+    /** Where stacks stand: zero, expand (100%), silhouette or wiggle (streamgraph). */
+    readonly stackOffset: _angular_core.InputSignal<"zero" | "expand" | "silhouette" | "wiggle" | undefined>;
+    readonly orientation: _angular_core.InputSignal<"vertical" | "horizontal" | undefined>;
+    /** Corner radius of bars. */
+    readonly radius: _angular_core.InputSignal<number | undefined>;
+    /** Share of each category slot left empty around its bars, 0–0.9. */
+    readonly barGap: _angular_core.InputSignal<number | undefined>;
+    /** Largest bar thickness in pixels. */
+    readonly barWidth: _angular_core.InputSignal<number | undefined>;
+    readonly sort: _angular_core.InputSignal<"asc" | "desc" | undefined>;
+    readonly transform: _angular_core.InputSignal<"cumulative" | "histogram" | undefined>;
+    /** Transforms applied to every series, in order. */
+    readonly transforms: _angular_core.InputSignal<SeriesTransform[] | undefined>;
+    readonly bins: _angular_core.InputSignal<number | undefined>;
+    readonly binWidth: _angular_core.InputSignal<number | undefined>;
+    readonly binDomain: _angular_core.InputSignal<[number, number] | undefined>;
+    readonly binMode: _angular_core.InputSignal<"cumulative" | "count" | "density" | undefined>;
+    /** Point reduction for dense series. */
+    readonly sampling: _angular_core.InputSignal<Sampling | undefined>;
+    /** Draw a range strip under the plot showing the whole series and the zoomed window. */
+    readonly brush: _angular_core.InputSignal<boolean>;
+    /** Snap the hover tooltip to the nearest category and list every series. */
+    readonly crosshair: _angular_core.InputSignal<boolean>;
     protected input(): {
-        series: Series[];
-        categories: string[] | undefined;
+        series: (CartesianSeries | RangeSeries)[];
+        categories: Category[] | undefined;
+        xAxis: XAxisOptions | undefined;
+        yAxis: AxisOptions | undefined;
+        rightAxis: AxisOptions | undefined;
+        references: Reference[] | undefined;
+        annotations: Annotation[] | undefined;
+        labels: boolean;
+        curve: Curve | undefined;
+        connectNulls: boolean;
+        nulls: "gap" | "connect" | "zero" | undefined;
+        stacked: boolean | "percent";
+        stackOffset: "zero" | "expand" | "silhouette" | "wiggle" | undefined;
+        orientation: "vertical" | "horizontal" | undefined;
+        radius: number | undefined;
+        barGap: number | undefined;
+        barWidth: number | undefined;
+        sort: "asc" | "desc" | undefined;
+        transform: "cumulative" | "histogram" | undefined;
+        transforms: SeriesTransform[] | undefined;
+        bins: number | undefined;
+        binWidth: number | undefined;
+        binDomain: [number, number] | undefined;
+        binMode: "cumulative" | "count" | "density" | undefined;
+        sampling: Sampling | undefined;
+        brush: boolean;
+        crosshair: boolean;
         width: number | undefined;
         height: number | undefined;
-        legend: boolean;
-        tooltip: boolean;
+        animate: number | boolean;
+        responsive: boolean | ResponsiveOptions;
+        legend: boolean | LegendOptions;
+        tooltip: boolean | TooltipOptions;
+        format: Format | undefined;
+        palette: string[] | undefined;
+        hiddenSeries: string[] | undefined;
+        selected: Selection | undefined;
+        highlighted: _skdx_angular_charts_internal.ChartItemId | ChartItemRef | (_skdx_angular_charts_internal.ChartItemId | ChartItemRef)[] | null | undefined;
+        highlightScope: HighlightScope | undefined;
+        loading: boolean;
+        error: string | undefined;
+        emptyMessage: string | undefined;
+        description: string | undefined;
+        decorative: boolean;
+        accessibleTable: boolean | AccessibleTableOptions;
+        zoom: Zoom | undefined;
+        view: MapView | undefined;
     };
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkdxChartBase, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkdxChartBase, never, never, { "series": { "alias": "series"; "required": true; "isSignal": true; }; "categories": { "alias": "categories"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SkdxChartBase, never, never, { "series": { "alias": "series"; "required": true; "isSignal": true; }; "categories": { "alias": "categories"; "required": false; "isSignal": true; }; "xAxis": { "alias": "xAxis"; "required": false; "isSignal": true; }; "yAxis": { "alias": "yAxis"; "required": false; "isSignal": true; }; "rightAxis": { "alias": "rightAxis"; "required": false; "isSignal": true; }; "references": { "alias": "references"; "required": false; "isSignal": true; }; "annotations": { "alias": "annotations"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "curve": { "alias": "curve"; "required": false; "isSignal": true; }; "connectNulls": { "alias": "connectNulls"; "required": false; "isSignal": true; }; "nulls": { "alias": "nulls"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; "stackOffset": { "alias": "stackOffset"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "barGap": { "alias": "barGap"; "required": false; "isSignal": true; }; "barWidth": { "alias": "barWidth"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "transform": { "alias": "transform"; "required": false; "isSignal": true; }; "transforms": { "alias": "transforms"; "required": false; "isSignal": true; }; "bins": { "alias": "bins"; "required": false; "isSignal": true; }; "binWidth": { "alias": "binWidth"; "required": false; "isSignal": true; }; "binDomain": { "alias": "binDomain"; "required": false; "isSignal": true; }; "binMode": { "alias": "binMode"; "required": false; "isSignal": true; }; "sampling": { "alias": "sampling"; "required": false; "isSignal": true; }; "brush": { "alias": "brush"; "required": false; "isSignal": true; }; "crosshair": { "alias": "crosshair"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** Draws a core shape list back to front. */
+/** Draws a core shape list back to front; marks with an `item` carry their index for hit-testing. */
 declare class SkdxChartShapesComponent {
     readonly shapes: _angular_core.InputSignal<Shape[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkdxChartShapesComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkdxChartShapesComponent, "g[skdxChartShapes]", never, { "shapes": { "alias": "shapes"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { CHART_COLORS, SkdxChartBase, SkdxChartRootComponent, SkdxChartShapesComponent, SkdxSizedBase, hoverTooltip, layoutAreaChart, layoutBarChart, layoutBoxplot, layoutCandlestick, layoutChord, layoutFunnelChart, layoutGantt, layoutHeatmap, layoutLineChart, layoutMap, layoutPieChart, layoutRadarChart, layoutSankey, layoutScatterChart, layoutSparkline, layoutSunburst, layoutTreemap, layoutWaterfall };
-export type { AreaChartInput, BarChartInput, Box, BoxplotInput, Candle, CandlestickInput, Canvas, ChartInput, ChordInput, Curve, Datum, Frame, FunnelChartInput, GanttInput, GanttTask, GeoMultiPolygon, GeoPolygon, HeatmapInput, LegendItem, LineChartInput, MapFeature, MapInput, PieChartInput, RadarChartInput, SankeyInput, SankeyLink, ScatterChartInput, ScatterSeries, Series, Shape, Sized, SparklineInput, SunburstInput, Tick, TreeNode, TreemapInput, WaterfallInput };
+export { ANIMATION_CSS, ANIMATION_LIMIT, CHART_COLORS, MARKER_LIMIT, NETWORK_LABEL_LIMIT, PARALLEL_TITLE_LIMIT, SAMPLING_THRESHOLD, SERIES_COLORS, SWARM_TITLE_LIMIT, SkdxChartBase, SkdxChartRootComponent, SkdxChartShapesComponent, SkdxSizedBase, TABLE_LIMIT, TITLE_LIMIT, aggregate, anchorOf, animationDuration, annotationShapes, applyTransforms, binCounts, binEdges, binSamples, boxFrom, brushBoxShape, brushDrag, brushGrab, categoryLabel, colorLegendShapes, crosshairAt, crosshairLine, crosshairRows, crosshairShapes, csv, cumulative, cutDepth, defsMarkup, depthOf, difference, drill, emphasize, exponentialMovingAverage, exportChart, filter, findPath, focusShapes, focusTargets, formatValue, ganttDrag, ganttGhost, ganttGrab, ganttKey, hoverTooltip, hoveredRef, insidePolygon, isSelected, isUnzoomed, itemAt, itemId, itemsInBox, itemsInPolygon, lassoShape, layoutAreaChart, layoutBarChart, layoutBoxplot, layoutBubbleChart, layoutBulletChart, layoutBumpChart, layoutCandlestick, layoutCartesian, layoutChord, layoutCirclePacking, layoutComboChart, layoutDumbbellChart, layoutFunnelChart, layoutGantt, layoutGaugeChart, layoutHeatmap, layoutHistogram, layoutIcicle, layoutLineChart, layoutLinearGauge, layoutMap, layoutMarimekkoChart, layoutNetworkChart, layoutOrganizationChart, layoutParallelCoordinates, layoutParetoChart, layoutPieChart, layoutPolarAreaChart, layoutRadarChart, layoutRadialBar, layoutRangeChart, layoutSankey, layoutScatterChart, layoutSparkline, layoutSunburst, layoutSwarmPlot, layoutTimelineChart, layoutTreeChart, layoutTreemap, layoutWaffleChart, layoutWaterfall, legendOptions, lttb, m4, makeColorScale, makeFormatter, mapPan, mapWheel, matchesItem, minMaxSample, mixStops, movingAverage, nextFocus, nodeId, nodeValue, normalize, packCircles, parseColor, percentageChange, placeLegend, pointerShapes, pointerTooltipText, rank, refOf, referenceShapes, sameRef, sampleIndexes, samplingOptions, selectedIds, seriesCsv, shapeMarkup, sortChildren, sortValues, stateCanvas, svgMarkup, svgToPng, swarmOffsets, syncGroup, tableRows, timeTicks, toRefs, toViewBox, toggleSelection, tooltipOptions, tooltipShapes, translatePath, translateShapes, variantColor, waffleCounts, zoomPan, zoomPinch, zoomWheel };
+export type { AccessibleTableOptions, Annotation, AreaChartInput, AxisOptions, Band, BarChartInput, Bin, BinOptions, Box, BoxSummary, BoxplotInput, BoxplotSeries, BrushGrab, BubbleChartInput, BubblePoint, BubbleSeries, BulletChartInput, BulletDatum, BumpChartInput, CalendarCell, Candle, CandlestickInput, CandlestickOverlay, Canvas, CartesianSeries, Category, ChartDataIssue, ChartExportOptions, ChartInput, ChartItem, ChartItemId, ChartItemRef, ChordInput, ChordLink, CirclePackingInput, ColorLegendOptions, ColorScale, ComboChartInput, ComboSeries, Curve, Datum, DumbbellChartInput, DumbbellDatum, EditModel, ErrorValue, Format, Frame, FunnelChartInput, GanttGrab, GanttInput, GanttTask, GaugeChartInput, GeoLineString, GeoMultiLineString, GeoMultiPoint, GeoMultiPolygon, GeoPoint, GeoPolygon, GradientDef, GroupedBoxSeries, HeatmapInput, HighlightScope, HistogramInput, Hit, IcicleInput, Identified, LegendItem, LegendOptions, LineChartInput, LinearGaugeInput, MapFeature, MapInput, MapLine, MapModel, MapPoint, MapView, MarimekkoCategory, MarimekkoChartInput, MarkerSymbol, NetworkChartInput, NetworkEdge, NetworkNode, OrganizationChartInput, ParallelCoordinatesInput, ParallelDimension, ParallelRow, ParetoChartInput, PieChartInput, PolarAreaChartInput, RadarChartInput, RadarMetric, RadialBand, RadialBarInput, RangeChartInput, RangeChartSeries, RangeSeries, Reference, ResolvedColorScale, ResponsiveOptions, Sampling, SankeyInput, SankeyLink, SankeyNode, ScatterChartInput, ScatterPoint, ScatterSeries, Selection, SelectionMode, Series, SeriesTransform, Shape, Sized, SparklineInput, SunburstInput, SwarmPlotInput, SyncGroup, SyncListener, SyncState, TaskChange, Tick, TimelineChartInput, TimelineEvent, TooltipOptions, TreeChartInput, TreeNode, TreemapInput, Value, Variant, WaffleChartInput, WaterfallDatum, WaterfallInput, XAxisOptions, Zoom };