@wick-charts/vue 0.6.4 → 0.7.0

package/dist/index.d.ts

@@ -12,8 +12,8 @@ overlap?: number;
 right?: number;
 left?: number;
 };
-theme: ChartTheme;
 gradient: boolean;
+theme: ChartTheme;
 interactive: boolean;
 headerLayout: "overlay" | "inline";
 }, {}, {}, {}, string, ComponentProvideOptions, false, {
@@ -43,9 +43,9 @@ declare const __VLS_component_5: DefineComponent<__VLS_Props_15, {}, {}, {}, {},
 containerRef: HTMLDivElement;
 }, any>;
 
-declare const __VLS_component_6: DefineComponent<__VLS_Props_19, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_19> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component_6: DefineComponent<__VLS_Props_18, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_18> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
-declare const __VLS_component_7: DefineComponent<__VLS_Props_20, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_20> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+declare const __VLS_component_7: DefineComponent<__VLS_Props_19, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_19> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
 containerRef: HTMLDivElement;
 }, any>;
 
@@ -56,7 +56,8 @@ declare type __VLS_Props = {
      * Band data — one band per layer. A single band passes a flat
      * `{ time, low, high }[]`; several bands pass `BandPoint[][]`. To name/color
      * a band, pass `{ label, color?, data }` (or an array of them). Time accepts
-     * ms or `Date`.
+     * ms or `Date`. On a numeric or category X axis (`axis.x.type`) samples
+     * carry `x` in place of `time`: `{ x: 'EU', low, high }`.
      */
     data: BandData;
     /** Visual options override — fill, edge stroke, curve, entrance / intro / smoothing. */
@@ -65,6 +66,8 @@ declare type __VLS_Props = {
     id?: string;
     /** Show/hide the series without unmounting it — excludes it from the Y-range fit and tooltip/legend. Default `true`. Live. */
     visible?: boolean;
+    /** Named Y scale from the container's `scales` — autoscales on its own, sharing the time axis. Default: the default scale. Live. */
+    scale?: string;
 };
 
 declare type __VLS_Props_10 = {
@@ -91,6 +94,8 @@ declare type __VLS_Props_11 = {
     label?: string;
     /** Color override. Falls back to the series color (when `seriesId` is set), then the theme line color. */
     color?: string;
+    /** Named Y scale (`ChartContainer` `scales`) the `value` maps through. Default: the `seriesId` series' scale, else the default scale. */
+    scale?: string;
 };
 
 declare type __VLS_Props_12 = {
@@ -148,16 +153,11 @@ declare type __VLS_Props_16 = {
     style?: ReferenceLineStyle;
     /** Stroke width in CSS pixels. Default: `1`. */
     width?: number;
+    /** Named Y scale (`ChartContainer` `scales`) the `value` maps through. Default: the default scale. */
+    scale?: string;
 };
 
 declare type __VLS_Props_17 = {
-    /** Desired number of labels (≥ 2). Overrides chart-level `axis.x.labelCount`. */
-    labelCount?: number;
-    /** Minimum pixel gap between adjacent labels (hard floor). Overrides chart-level. */
-    minLabelSpacing?: number;
-};
-
-declare type __VLS_Props_18 = {
     /** Left edge — epoch ms or a `Date`. */
     from: TimeValue;
     /** Right edge — epoch ms or a `Date`. Omit (or pass `'now'`) for an open-ended band to the right edge. */
@@ -170,7 +170,7 @@ declare type __VLS_Props_18 = {
     color?: string;
 };
 
-declare type __VLS_Props_19 = {
+declare type __VLS_Props_18 = {
     /**
      * @deprecated Use the named `sub` slot instead — it accepts arbitrary
      * inline markup (icons, badges, formatted text) to mirror React's
@@ -184,19 +184,37 @@ declare type __VLS_Props_19 = {
     sub?: string;
 };
 
+declare type __VLS_Props_19 = {
+    sort?: SnapshotSort;
+    format?: TooltipFormatter;
+};
+
 declare type __VLS_Props_2 = {
-    /** Flat `TimePoint[]`, `TimePoint[][]`, or named `{ label, color?, data }` layers. Time accepts ms or `Date`. */
+    /**
+     * Flat `TimePoint[]`, `TimePoint[][]`, or named `{ label, color?, data }` layers. Time accepts ms or `Date`.
+     * On a numeric or category X axis (`axis.x.type`) points carry `x` in place of `time`.
+     */
     data: MultiLayerData;
     options?: Partial<BarSeriesOptions>;
     /** Stable series ID — same value across remounts. */
     id?: string;
     /** Show/hide the series without unmounting it — excludes it from the Y-range fit and tooltip/legend. Default `true`. Live. */
     visible?: boolean;
+    /** Named Y scale from the container's `scales` — autoscales on its own, sharing the time axis. Default: the default scale. Live. */
+    scale?: string;
 };
 
 declare type __VLS_Props_20 = {
-    sort?: SnapshotSort;
-    format?: TooltipFormatter;
+    /** Desired number of labels (≥ 2). Overrides chart-level `axis.x.labelCount`. */
+    labelCount?: number;
+    /** Minimum pixel gap between adjacent labels (hard floor). Overrides chart-level. */
+    minLabelSpacing?: number;
+    /**
+     * Custom label formatter. `x` is epoch ms on a time axis, the number on a
+     * numeric axis, the category name on a category axis; `step` is the tick
+     * spacing. Also formats the crosshair label and the tooltip / info-bar headers.
+     */
+    format?: XAxisFormatter;
 };
 
 declare type __VLS_Props_21 = {
@@ -209,6 +227,12 @@ declare type __VLS_Props_21 = {
     labelCount?: number;
     /** Minimum pixel gap between adjacent labels (hard floor). Overrides chart-level. */
     minLabelSpacing?: number;
+    /**
+     * Named Y scale (`ChartContainer` `scales`) this axis labels. Default: the
+     * default scale. An overlay scale has no column, so only `format` and the
+     * label density apply.
+     */
+    scale?: string;
 };
 
 declare type __VLS_Props_22 = {
@@ -219,13 +243,19 @@ declare type __VLS_Props_22 = {
      */
     seriesId?: string;
     color?: string;
-    /** Custom formatter; routed through NumberFlow's `formatter` so the digit animation still plays. */
+    /** Custom formatter; routed through NumberFlow's `formatter` so the digit animation still plays. Default: the scale's `<YAxis format>`, else a range-adaptive number. */
     format?: ValueFormatter;
     /**
      * Badge motion. `true` (default) glides + counts up + fades in with the
      * intro; `false` snaps with no easing; an object tunes individual parts.
      */
     animate?: YLabelAnimate;
+    /**
+     * Named Y scale (`ChartContainer` `scales`) the value maps through. Default:
+     * the series' own scale. The badge sits on that scale's axis side — the
+     * default axis side for an overlay scale.
+     */
+    scale?: string;
 };
 
 declare type __VLS_Props_3 = {
@@ -236,6 +266,8 @@ declare type __VLS_Props_3 = {
     id?: string;
     /** Show/hide the series without unmounting it — excludes it from the Y-range fit and tooltip/legend. Default `true`. Live. */
     visible?: boolean;
+    /** Named Y scale from the container's `scales` — autoscales on its own, sharing the time axis. Default: the default scale. Live. */
+    scale?: string;
 };
 
 declare type __VLS_Props_4 = {
@@ -243,6 +275,14 @@ declare type __VLS_Props_4 = {
     theme?: ChartTheme;
     /** Grouped axis configuration (Y/X visibility, bounds, sizing). Live. */
     axis?: AxisConfig;
+    /**
+     * Named secondary Y scales, keyed by id — a series opts in with its `scale`
+     * prop and autoscales on its own, sharing the time axis. Same fields as
+     * `axis.y`; `position` defaults to the side opposite the default axis. One
+     * axis column fits on each side — render it with `<YAxis scale="id" />`.
+     * Live.
+     */
+    scales?: Record<string, YAxisConfig>;
     /**
      * Viewport padding. `top`/`bottom` are in pixels. `left`/`right` accept either pixels (`50`)
      * or data intervals (`{ intervals: 3 }`). Set to 0 for edge-to-edge sparklines. Updates are
@@ -417,13 +457,18 @@ declare type __VLS_Props_5 = {
 };
 
 declare type __VLS_Props_6 = {
-    /** Flat `TimePoint[]`, `TimePoint[][]`, or named `{ label, color?, data }` layers. Time accepts ms or `Date`. */
+    /**
+     * Flat `TimePoint[]`, `TimePoint[][]`, or named `{ label, color?, data }` layers. Time accepts ms or `Date`.
+     * On a numeric or category X axis (`axis.x.type`) points carry `x` in place of `time`.
+     */
     data: MultiLayerData;
     options?: Partial<LineSeriesOptions>;
     /** Stable series ID — same value across remounts. */
     id?: string;
     /** Show/hide the series without unmounting it — excludes it from the Y-range fit and tooltip/legend. Default `true`. Live. */
     visible?: boolean;
+    /** Named Y scale from the container's `scales` — autoscales on its own, sharing the time axis. Default: the default scale. Live. */
+    scale?: string;
 };
 
 declare type __VLS_Props_7 = {
@@ -1034,7 +1079,7 @@ export declare type AxisBound = 'auto' | number | string | ((values: number[]) =
 export declare interface AxisConfig {
     /** Y-axis configuration — width, bounds, and visibility of the value axis. */
     y?: YAxisConfig;
-    /** X-axis configuration — height and visibility of the time axis. */
+    /** X-axis configuration — type, height and visibility of the X axis. */
     x?: XAxisConfig;
 }
 
@@ -1099,8 +1144,9 @@ export declare function backfillSweepIntro(): LineIntroFn;
  * `data` shape for a band series — the same omnivorous forms as
  * {@link MultiLayerData}, one band per layer: a flat `BandPointInput[]`, a
  * layered `BandPointInput[][]`, a named `SeriesLayer`, or an array mixing both.
+ * On a numeric or category X axis the samples are {@link XBandPointInput}s.
  */
-export declare type BandData = BandPointInput[] | SeriesLayer<BandPointInput> | Array<BandPointInput[] | SeriesLayer<BandPointInput>>;
+export declare type BandData = BandSampleInput[] | SeriesLayer<BandSampleInput> | Array<BandSampleInput[] | SeriesLayer<BandSampleInput>>;
 
 /** Entrance styles for band points added via `appendData` — the same set as {@link LineEntryAnimation}. */
 export declare type BandEntryAnimation = LineEntryAnimation;
@@ -1114,13 +1160,18 @@ export declare interface BandPoint {
     time: number;
     low: number;
     high: number;
+    /** The sample's X on a numeric or category axis, as passed in; `time` is then the internal X coordinate. */
+    x?: number | string;
 }
 
 /** {@link BandPoint} that also accepts `Date` for the time field. */
-export declare type BandPointInput = Omit<BandPoint, 'time'> & {
+export declare type BandPointInput = Omit<BandPoint, 'time' | 'x'> & {
     time: TimeValue;
 };
 
+/** A band input sample: keyed by `time` on a time axis, by `x` on a numeric or category axis. */
+export declare type BandSampleInput = BandPointInput | XBandPointInput;
+
 export declare const BandSeries: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
 visible: boolean;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
@@ -1322,7 +1373,10 @@ export declare const BarSeriesDef: SeriesDefinition<BarSeriesOptions>;
 
 /** Visual options for a bar series. */
 export declare interface BarSeriesOptions {
-    /** Width of each bar as a fraction of the available bar slot (0–1). `1` = bars touch; `0.6` = roughly 60 % of the slot. Default: 0.7. */
+    /**
+     * Width of each bar as a fraction of the available bar slot (0–1). `1` = bars touch; `0.6` = roughly 60 % of the slot.
+     * Applies on a time or numeric X axis only — on a category axis a bar fills its band (see `axis.x.padding`). Default: 0.7.
+     */
     barWidthRatio: number;
     /** Stacking mode. Default: 'off'. */
     stacking: StackingMode;
@@ -1480,6 +1534,12 @@ export declare interface BaseSeriesRenderer {
      * selects which internal store to target; defaults to 0.
      */
     setData(data: unknown, layerIndex?: number): void;
+    /**
+     * Replace the data like {@link setData}, but ease each point that keeps its
+     * `time` from the value on screen to its new one; a point with a new `time`
+     * plays its entrance. Optional — the chart falls back to {@link setData}.
+     */
+    morphData?(data: unknown, layerIndex?: number): void;
     /** Append a single point (real-time tick). Optional — not all renderers support streaming. */
     appendPoint?(point: unknown, layerIndex?: number): void;
     /**
@@ -2025,18 +2085,25 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
     #private;
     /** Maps time values to horizontal pixel coordinates. */
     readonly timeScale: XScale;
-    /** Maps price/value to vertical pixel coordinates. */
+    /** Maps price/value to vertical pixel coordinates — the default Y scale. */
     readonly yScale: YScale;
-    /** CSS px of the Y-axis column. The default collapses to `0` on a spatial-only chart. */
+    /** CSS px of the default Y-axis column. The default collapses to `0` on a spatial-only chart. */
     get yAxisWidth(): number;
-    /** Side of the plot area the Y-axis column sits on. */
+    /** Side of the plot area the default Y-axis column sits on. */
     get yAxisPosition(): YAxisPosition;
     /**
-     * Left edge of the plot area in container CSS px — the Y-axis width when
-     * the axis sits on the left, `0` otherwise. Scales map into the plot area,
-     * so add this to `timeScale.timeToX()` to get a container coordinate.
+     * Left edge of the plot area in container CSS px — the width of the Y-axis
+     * column on the left, `0` without one. Scales map into the plot area, so
+     * add this to `timeScale.timeToX()` to get a container coordinate.
      */
     get plotLeft(): number;
+    /**
+     * CSS px of the Y-axis column on `side` — the default axis's or the named
+     * scale's that owns that side — `0` when no column sits there.
+     */
+    getAxisColumnWidth(side: YAxisPosition): number;
+    /** The named scale whose axis column sits on `side`, `null` when the default axis's does or none. */
+    getAxisColumnScale(side: YAxisPosition): string | null;
     /** CSS px height of the floating Title / InfoBar header, `0` without one. A left
      *  axis shares its column with it, so tick labels fade out underneath. */
     get headerHeight(): number;
@@ -2057,24 +2124,28 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
     addSeries(type: 'candlestick', options?: Partial<CandlestickSeriesOptions & {
         id?: string;
         label?: string;
+        scale?: string;
     }>): string;
     addSeries(type: 'line', options?: Partial<LineSeriesOptions & {
         layers?: number;
         id?: string;
         label?: string;
         labels?: (string | undefined)[];
+        scale?: string;
     }>): string;
     addSeries(type: 'bar', options?: Partial<BarSeriesOptions & {
         layers?: number;
         id?: string;
         label?: string;
         labels?: (string | undefined)[];
+        scale?: string;
     }>): string;
     addSeries(type: 'band', options?: Partial<BandSeriesOptions & {
         layers?: number;
         id?: string;
         label?: string;
         labels?: (string | undefined)[];
+        scale?: string;
     }>): string;
     addSeries(type: 'pie', options?: Partial<PieSeriesOptions & {
         id?: string;
@@ -2089,6 +2160,7 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
         id?: string;
         label?: string;
         labels?: (string | undefined)[];
+        scale?: string;
     }): string;
     /** Remove a series by ID and clean up its resources. */
     removeSeries(id: string): void;
@@ -2166,10 +2238,13 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
      *
      * For line/bar accepts `TimePointInput[]` (time may be `Date`); for candlestick accepts `OHLCInput[]`;
      * for pie accepts `PieSliceData[]`. Time fields are normalized internally.
+     *
+     * On a category axis a replace is how a bar other than the last changes value,
+     * so it eases like a stream: points that keep their band ease to their new values.
      */
     setSeriesData(id: string, data: unknown, layerIndex?: number): void;
     /** Append a new data point to the end of a series (real-time tick). */
-    appendData(id: string, point: OHLCInput | TimePointInput | BandPointInput, layerIndex?: number): void;
+    appendData(id: string, point: SeriesPointInput, layerIndex?: number): void;
     /**
      * Prepend older points to the front of a series — the "load more history on
      * scroll" path. Unlike {@link setSeriesData}, this deliberately does NOT set
@@ -2183,9 +2258,9 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
      * first point; the sync reconciler guarantees this before calling here.
      * No-op if the renderer doesn't support prepend.
      */
-    prependData(id: string, points: (OHLCInput | TimePointInput | BandPointInput)[], layerIndex?: number): void;
+    prependData(id: string, points: SeriesPointInput[], layerIndex?: number): void;
     /** Update the last data point of a series in place (e.g. live candle update). */
-    updateData(id: string, point: OHLCInput | TimePointInput | BandPointInput, layerIndex?: number): void;
+    updateData(id: string, point: SeriesPointInput, layerIndex?: number): void;
     /**
      * Keep only the most recent `count` points of a series — drop the oldest
      * tail when the series exceeds the cap. Smooth Y-range chase (no snap):
@@ -2200,8 +2275,13 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
      * ```
      */
     keepLast(id: string, count: number, layerIndex?: number): void;
-    /** Update visual options (color, width, etc.) for an existing series. */
-    updateSeriesOptions(id: string, options: Partial<CandlestickSeriesOptions> | Partial<LineSeriesOptions> | Partial<BarSeriesOptions> | Partial<BandSeriesOptions> | Partial<PieSeriesOptions> | Partial<HeatmapSeriesOptions>): void;
+    /**
+     * Update visual options (color, width, etc.) for an existing series. `scale`
+     * (time series) moves it onto a named Y scale, `undefined` back to the default.
+     */
+    updateSeriesOptions(id: string, options: (Partial<CandlestickSeriesOptions> | Partial<LineSeriesOptions> | Partial<BarSeriesOptions> | Partial<BandSeriesOptions> | Partial<PieSeriesOptions> | Partial<HeatmapSeriesOptions>) & {
+        scale?: string;
+    }): void;
     /**
      * Batch multiple updates: suppress recomputes until `fn` returns. Exceptions
      * inside `fn` still flush the batch so counters don't leak across calls.
@@ -2331,9 +2411,9 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
     getSeriesIds(): string[];
     /**
      * Whether pan/zoom gestures currently apply — true when any visible series
-     * has a time axis. Part of the {@link PanZoomTarget} surface: on a
-     * spatial-only chart (pie, heatmap) the interaction layer stops capturing
-     * wheel and touch events, so the page scrolls normally under the cursor.
+     * has a time axis and `axis.x.panZoom` allows it. Part of the
+     * {@link PanZoomTarget} surface: otherwise the interaction layer stops
+     * capturing wheel and touch events, so the page scrolls normally under the cursor.
      */
     canPanZoom(): boolean;
     /**
@@ -2416,17 +2496,54 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
     getTimeZone(): string | undefined;
     /** Update axis configuration and re-render. */
     setAxis(config: AxisConfig): void;
+    /**
+     * Replace the named Y scales (see {@link ChartOptions.scales}). Added,
+     * removed and edited scales apply in place: a changed transform resets that
+     * scale's ticks, and every scale refits. A deep-equal replay is a no-op.
+     */
+    setScales(scales: Readonly<Record<string, YAxisConfig>> | undefined): void;
+    /** Ids of the named Y scales, in declaration order. */
+    getYScaleIds(): string[];
+    /** The Y scale named `scaleId`; the default scale for `undefined` or an id `scales` doesn't define. */
+    getYScale(scaleId?: string): YScale;
+    /**
+     * The column a scale's axis sits in — always the default axis's for
+     * `undefined`; `null` for an overlay scale or an unknown id.
+     */
+    getYScaleColumn(scaleId?: string): {
+        position: YAxisPosition;
+        width: number;
+    } | null;
+    /** The named scale a series maps through, `undefined` for the default scale. */
+    getSeriesScale(seriesId: string): string | undefined;
+    /**
+     * Install (or clear, with `null`) the value formatter `<YAxis format>` puts
+     * on a scale — its axis labels, crosshair label and `YLabel` read it. `scale`
+     * picks a named scale; an id `scales` doesn't define is a no-op.
+     */
+    setYAxisFormat(params: {
+        format: ValueFormatter | null;
+        scale?: string;
+    }): void;
     /**
      * Apply label-density knobs driven by `<YAxis labelCount=… minLabelSpacing=…>`
      * — kept separate from {@link setAxis} so component props don't force a
-     * Y-animation reset. Triggers a viewportChange + repaint so static charts
-     * react without waiting for pan/zoom.
+     * Y-animation reset. `scale` picks a named scale's axis — an id `scales`
+     * doesn't define is a no-op. Triggers a viewportChange + repaint so static
+     * charts react without waiting for pan/zoom.
      */
     setYAxisLabelDensity(params: {
         labelCount?: number | null;
         minLabelSpacing?: number | null;
+        scale?: string;
     }): void;
-    /** Label-density knobs for the time axis — mirror of {@link setYAxisLabelDensity}. */
+    /**
+     * Install (or clear, with `null`) the X label formatter `<XAxis format>`
+     * puts on the axis — its tick labels, the crosshair label, the tooltip and
+     * info-bar headers read it.
+     */
+    setXAxisFormat(format: XAxisFormatter | null): void;
+    /** Label-density knobs for the X axis — mirror of {@link setYAxisLabelDensity}. */
     setTimeAxisLabelDensity(params: {
         labelCount?: number | null;
         minLabelSpacing?: number | null;
@@ -2545,6 +2662,16 @@ export declare interface ChartLayout {
 export declare interface ChartOptions {
     theme?: ChartTheme;
     axis?: AxisConfig;
+    /**
+     * Named secondary Y scales, keyed by id — a time series opts in with its
+     * `scale` option. Each one autoscales from its own series and animates
+     * like the default scale; X stays shared. Same fields as `axis.y`, except
+     * `position` defaults to the side opposite the default axis. One axis
+     * column fits on each side: a visible scale whose side is taken renders
+     * as an overlay (no column), as does `visible: false`. Grid lines follow
+     * the default scale. Live — `chart.setScales()` updates it after construction.
+     */
+    scales?: Record<string, YAxisConfig>;
     /**
      * Viewport padding. `top`/`bottom` are in pixels. `left`/`right` accept either pixels (`50`)
      * or data intervals (`{ intervals: 3 }`). Defaults: `{ top: 20, bottom: 20, right: { intervals: 3 }, left: { intervals: 0 } }`.
@@ -2910,8 +3037,13 @@ export declare interface CrosshairPosition {
     mediaX: number;
     /** Y position in CSS pixels relative to the chart container. */
     mediaY: number;
-    /** Snapped time value (timestamp in milliseconds) under the crosshair. */
+    /**
+     * Internal X coordinate under the crosshair — the timestamp in milliseconds
+     * on a time axis, the number on a numeric axis, the band index on a category axis.
+     */
     time: number;
+    /** X in the axis domain: epoch ms on a time axis, the number on a numeric axis, the category name on a category axis. */
+    x: number | string;
     /** Y (value) under the crosshair. */
     y: number;
 }
@@ -2939,7 +3071,7 @@ export declare interface CustomSpatialSeriesRenderer extends BaseSeriesRenderer
  */
 export declare function deepEqual(a: unknown, b: unknown): boolean;
 
-declare const _default: DefineComponent<__VLS_Props_17, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_17> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
+declare const _default: DefineComponent<__VLS_Props_20, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_20> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
 containerRef: HTMLDivElement;
 }, HTMLDivElement>;
 export { _default as TimeAxis }
@@ -3205,6 +3337,8 @@ export declare interface LayerSnapshot {
     color: string;
     low?: number;
     high?: number;
+    /** The sample's own X on a numeric or category axis. */
+    x?: number | string;
 }
 
 export declare const Legend: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
@@ -3273,6 +3407,7 @@ declare interface LineEntry {
     label?: string;
     style: ReferenceLineStyle;
     width: number;
+    scale?: string;
 }
 
 /**
@@ -3420,6 +3555,9 @@ declare interface LinePoint {
     y: number;
 }
 
+/** A line / bar input point: keyed by `time` on a time axis, by `x` on a numeric or category axis. */
+export declare type LinePointInput = TimePointInput | XPointInput;
+
 export declare const LineSeries: DefineComponent<__VLS_Props_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_6> & Readonly<{}>, {
 visible: boolean;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
@@ -3744,6 +3882,8 @@ export declare interface MarkerConfig {
     label?: string;
     /** Color override. Falls back to the series color (when `seriesId` is set), then the theme line color. */
     color?: string;
+    /** Named Y scale (`ChartOptions.scales`) the value maps through. Default: the `seriesId` series' scale, else the default scale. */
+    scale?: string;
 }
 
 /** Internal bookkeeping for a registered marker. `time` is normalized to epoch ms; `shape`/`pulse` carry resolved defaults. */
@@ -3756,6 +3896,7 @@ declare interface MarkerEntry {
     pulse: boolean;
     label?: string;
     color?: string;
+    scale?: string;
 }
 
 /**
@@ -3821,9 +3962,10 @@ declare interface MorphPlaceholder {
  * - an array mixing raw `TimePointInput[]` layers and named `SeriesLayer`s.
  *
  * Everything normalizes to `SeriesLayer[]` internally (see `toLayers`). Time
- * accepts epoch milliseconds or a `Date` on every point.
+ * accepts epoch milliseconds or a `Date` on every point. On a numeric or
+ * category X axis the points are {@link XPointInput}s instead.
  */
-export declare type MultiLayerData = TimePointInput[] | SeriesLayer<TimePointInput> | Array<TimePointInput[] | SeriesLayer<TimePointInput>>;
+export declare type MultiLayerData = LinePointInput[] | SeriesLayer<LinePointInput> | Array<LinePointInput[] | SeriesLayer<LinePointInput>>;
 
 declare const Navigator_2: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
 stripRef: HTMLDivElement;
@@ -3847,9 +3989,8 @@ export declare interface NavigatorCandlePoint {
  * left handle, right handle. The overlay is purely visual; pointer input is
  * captured on the canvas and hit-tested against the current window geometry.
  *
- * Both layers reserve `chart.yAxisWidth` on the Y-axis side so the
- * navigator's active zone aligns with the main chart's plot area (matches
- * the TimeAxis).
+ * Both layers reserve the main chart's Y-axis columns so the navigator's
+ * active zone aligns with its plot area (matches the TimeAxis).
  *
  * Event topology — navigator is a pure listener on the chart side, never emits:
  *   chart.viewportChange → reposition window DOM on next frame (canvas untouched)
@@ -4399,7 +4540,10 @@ export declare function plotterIntro(): LineIntroFn;
 export declare interface PointClickInfo {
     mediaX: number;
     mediaY: number;
+    /** Internal X coordinate — epoch ms on a time axis, the number on a numeric axis, the band index on a category axis. */
     time: number;
+    /** X in the axis domain: epoch ms on a time axis, the number on a numeric axis, the category name on a category axis. */
+    x: number | string;
     y: number;
     spatialHit: {
         seriesId: string;
@@ -4440,6 +4584,8 @@ export declare interface ReferenceLineConfig {
     style?: ReferenceLineStyle;
     /** Stroke width in CSS pixels. Default: `1`. */
     width?: number;
+    /** Named Y scale (`ChartOptions.scales`) a horizontal line's `value` maps through. Default: the default scale. */
+    scale?: string;
 }
 
 /** Orientation of a resolved reference line. */
@@ -4625,6 +4771,11 @@ export declare interface SeriesCreateEnv {
 export declare interface SeriesDefinition<O = Record<string, unknown>> {
     /** Discriminator for animation defaults and string-form lookup. */
     readonly type: SeriesType;
+    /**
+     * X axis types the series can plot on. Default: `['time']`. Not read for a
+     * spatial series (pie, heatmap), which has no X axis.
+     */
+    readonly xTypes?: readonly XAxisType[];
     /** Construct the renderer. `options` arrives with the chart's animation defaults/overrides already merged. */
     create(env: SeriesCreateEnv, options: Partial<O>): SeriesRenderer;
 }
@@ -4658,6 +4809,9 @@ declare interface SeriesLayer<T> {
     data: T[];
 }
 
+/** Any point `appendData` / `prependData` / `updateData` take. */
+declare type SeriesPointInput = OHLCInput | TimePointInput | BandPointInput | XPointInput | XBandPointInput;
+
 export declare interface SeriesRenderContext {
     scope: BitmapCoordinateSpace;
     timeScale: XScale;
@@ -4926,18 +5080,24 @@ export declare interface TimeFormatOptions {
 /** Custom time-tick formatter, mirroring {@link YScale}'s `ValueFormatter` contract. */
 export declare type TimeFormatter = (timestamp: number, interval: number) => string;
 
-/** A single time-value data point for line and bar series. Time is a timestamp in milliseconds. */
+/**
+ * A single time-value data point for line and bar series. Time is a timestamp in milliseconds.
+ * On a numeric or category X axis `time` is the internal X coordinate (the number, or the
+ * category's index) and `x` is the point's own X.
+ */
 export declare interface TimePoint {
     time: number;
     value: number;
+    /** The point's X on a numeric or category axis, as passed in. */
+    x?: number | string;
 }
 
 /** {@link TimePoint} that also accepts `Date` for the time field. */
-export declare type TimePointInput = Omit<TimePoint, 'time'> & {
+export declare type TimePointInput = Omit<TimePoint, 'time' | 'x'> & {
     time: TimeValue;
 };
 
-export declare const TimeRegion: DefineComponent<__VLS_Props_18, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_18> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export declare const TimeRegion: DefineComponent<__VLS_Props_17, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_17> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
 /**
  * A translucent vertical band shading the interval `[from, to]` — Grafana's
@@ -5306,14 +5466,69 @@ export declare function wickBodyIntro(): CandleIntroFn;
  */
 export declare function wipeIntro(): WaveIntroFn;
 
-/** Configuration for the X (time) axis. */
+/** Configuration for the X axis. */
 export declare interface XAxisConfig {
+    /**
+     * What the axis maps. Default: `'time'`. Read once at construction — a later
+     * change is ignored with a dev warning; remount the chart (a React `key`) to
+     * switch. Line, bar and band series work on every type, candlestick on
+     * `'time'` only. Navigator, EdgeLoader / `onEdgeReached` and TimeRegion are
+     * time-only.
+     */
+    type?: XAxisType;
+    /** Band spacing on a category axis. Ignored on other types. Live. */
+    padding?: XAxisPadding;
+    /**
+     * Whether drag and wheel move the X range. The crosshair works either way.
+     * Default: `true`, or `false` on a category axis. Live.
+     */
+    panZoom?: boolean;
     /** Height in CSS pixels. Default: 30, or 0 when every series is spatial (pie, heatmap). */
     height?: number;
     /** Whether the axis is visible. Default: true. When false, height is treated as 0. */
     visible?: boolean;
 }
 
+/**
+ * X label formatter for any axis type (`<XAxis format>`): `x` is epoch ms on a
+ * time axis, the number on a numeric axis, the category name on a category
+ * axis; `step` is the tick spacing in the internal coordinate.
+ */
+export declare type XAxisFormatter = (x: number | string, step: number) => string;
+
+/** Band spacing on a category axis, in fractions of one category step. */
+export declare interface XAxisPadding {
+    /** Gap between adjacent bands. Default: `0.3`. */
+    inner?: number;
+    /** Space before the first band and after the last one. Default: `0.2`. */
+    outer?: number;
+}
+
+/**
+ * What the X axis maps:
+ * - `'time'` — epoch-ms timestamps, points keyed by `time` (default);
+ * - `'numeric'` — plain numbers, points keyed by `x: number`, linear spacing;
+ * - `'category'` — names, points keyed by `x: string`, one band per category in
+ *   first-seen order across the series.
+ */
+export declare type XAxisType = 'time' | 'numeric' | 'category';
+
+/** A band sample on a numeric or category X axis — {@link XPointInput} with edges in place of a value. */
+export declare interface XBandPointInput {
+    x: number | string;
+    low: number;
+    high: number;
+}
+
+/**
+ * A line / bar point on a numeric or category X axis (`axis.x.type`): `x` is a
+ * number on a numeric axis and a category name on a category axis.
+ */
+export declare interface XPointInput {
+    x: number | string;
+    value: number;
+}
+
 /** Time range (timestamps in milliseconds) of the currently visible portion of the chart. */
 declare interface XRange {
     from: number;
@@ -5327,6 +5542,10 @@ export declare class XScale {
      * identical on both surfaces.
      */
     readonly tickTracker: AxisTickTracker;
+    private type;
+    /** Category names in band order — category `i` is centred on coordinate `i`. */
+    private categories;
+    private bandPadding;
     private from;
     private to;
     private width;
@@ -5334,7 +5553,7 @@ export declare class XScale {
     private dataInterval;
     private labelCountHintValue;
     private minSpacingValue;
-    /** Custom formatter (driven by `setFormat` / a future `<TimeAxis format=…>`). */
+    /** Custom formatter, installed by `<XAxis format=…>`. */
     private customFormat;
     /** Custom tick generator — bypasses tier resolution in `niceTickValues` when set. */
     private customTickGenerator;
@@ -5356,10 +5575,41 @@ export declare class XScale {
     update(range: XRange, mediaWidth: number, pixelRatio: number, dataInterval?: number): void;
     setLabelCount(n: number | null | undefined): void;
     setMinSpacing(px: number | null | undefined): void;
-    /** Install (or clear) a custom tick-label formatter. */
-    setFormat(fn: TimeFormatter | null): void;
+    /**
+     * Install (or clear) a custom tick-label formatter. A {@link TimeFormatter}
+     * fits a time axis, where every `x` is a timestamp.
+     */
+    setFormat(fn: XAxisFormatter | null): void;
+    setFormat(fn: TimeFormatter): void;
     /** Read back the currently installed formatter — null when the built-in is active. */
-    getFormat(): TimeFormatter | null;
+    getFormat(): XAxisFormatter | null;
+    /** What the axis maps. Set once by the chart at construction. */
+    setType(type: XAxisType): void;
+    getType(): XAxisType;
+    /** Category names in band order (category axis). */
+    setCategories(names: readonly string[]): void;
+    getCategories(): readonly string[];
+    /** Band spacing on a category axis; an omitted or invalid side takes its default. */
+    setBandPadding(padding: XAxisPadding | undefined): void;
+    getBandPadding(): Required<XAxisPadding>;
+    /**
+     * The coordinate range that fits every band with its outer padding, or
+     * `null` without categories. Band `i` spans `i ± (1 - inner) / 2`.
+     */
+    bandRange(): XRange | null;
+    /** Width of one category band in physical pixels — what a bar on a category axis fills. */
+    bandWidthBitmap(): number;
+    /**
+     * The internal coordinate the pointer resolves to: the nearest band's index
+     * on a category axis, `coord` itself elsewhere.
+     */
+    snapToBand(coord: number): number;
+    /**
+     * An internal coordinate in the axis domain: the category name at that
+     * band on a category axis (`''` without categories), the number itself on
+     * time and numeric axes.
+     */
+    domainValue(coord: number): number | string;
     /**
      * Install (or clear) a custom tick-value generator. When set, it replaces
      * `niceTimeIntervals` tier resolution entirely — `niceTickValues` calls it
@@ -5373,11 +5623,19 @@ export declare class XScale {
     setTimeZone(timeZone: string | undefined): void;
     getTimeZone(): string | undefined;
     /**
-     * Format a tick timestamp for display. A custom formatter (via
-     * {@link setFormat}) wins; otherwise falls back to the built-in
-     * `formatTime`, applying the installed locale/timezone.
+     * Format an internal X coordinate for display — a tick, the crosshair, a
+     * tooltip header. A custom formatter (via {@link setFormat}) gets the
+     * domain value; otherwise a time axis formats the timestamp with the
+     * installed locale/timezone, a numeric axis prints a locale number, and a
+     * category axis prints the name.
      */
-    formatX(timestamp: number, interval: number): string;
+    formatX(coord: number, interval: number): string;
+    /**
+     * Format a data point's X for a tooltip or info-bar header. Like
+     * {@link formatX}, except a numeric axis prints the value with its own
+     * decimals — `1.25` stays `1.25` where the step would round it.
+     */
+    formatPointX(coord: number, interval: number): string;
     private resetHysteresis;
     timeToX(time: number): number;
     /** X in physical (bitmap) pixels, snapped to the pixel grid — for
@@ -5404,6 +5662,8 @@ export declare class XScale {
         ticks: number[];
         tickInterval: number;
     };
+    /** One tick per category whose band centre is in view. */
+    private bandTicks;
     getRange(): XRange;
     getMediaWidth(): number;
     /**
@@ -5412,12 +5672,17 @@ export declare class XScale {
      * tier inside a ratio band so micro pan/zoom doesn't flip label density.
      */
     private resolveInterval;
+    /**
+     * Numeric counterpart of the time-tier walk: the {1,2,5}×10^k step that
+     * clears `minLabelSpacing` and targets `labelCount`, with the same hysteresis band.
+     */
+    private resolveNumericInterval;
     private countTicks;
 }
 
 export declare const YAxis: DefineComponent<__VLS_Props_21, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_21> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
 containerRef: HTMLDivElement;
-}, HTMLDivElement>;
+}, any>;
 
 /** Configuration for the Y axis. */
 export declare interface YAxisConfig {