@photonviz/core 0.3.0 → 0.3.1

package/dist/index.d.ts

@@ -68,6 +68,13 @@ type Dim = "x" | "y";
  *  - `box-y`  drag selects a y-range only (full width band) — Y-only zoom
  */
 type InteractionMode = "pan" | "box" | "box-x" | "box-y";
+/**
+ * How a layer expects its data to change, mapped to a WebGL buffer-usage hint:
+ * `"static"` → `STATIC_DRAW` (upload once), `"dynamic"` → `DYNAMIC_DRAW` (stream
+ * via `setData`). Purely a performance hint — `setData` works either way. Default
+ * `"static"`. Set `"dynamic"` on layers you update every frame.
+ */
+type RenderType = "static" | "dynamic";
 type Range = readonly [number, number];
 interface Bounds {
     x: Range;
@@ -131,6 +138,8 @@ interface AreaOptions {
     /** Lower edge(s). Number or per-point array — pass cumulative to stack. */
     base?: number | ArrayLike<number>;
     color?: string | Color;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -146,6 +155,7 @@ declare class AreaLayer implements Layer {
     private uniforms;
     private vertexCount;
     private color;
+    private usage;
     private xRef;
     private yRef;
     private xBounds;
@@ -179,6 +189,13 @@ interface BarOptions {
      */
     orientation?: "v" | "h";
     color?: string | Color;
+    /**
+     * Per-bar colors (overrides {@link color}). Handy for tinting each bar — e.g.
+     * volume bars green/red by the candle's direction. Length should match `x`.
+     */
+    colors?: Array<string | Color>;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -194,6 +211,8 @@ declare class BarLayer implements Layer {
     private uniforms;
     private count;
     private color;
+    private colorsInput?;
+    private usage;
     private barWidth;
     private offset;
     private orientation;
@@ -202,9 +221,11 @@ declare class BarLayer implements Layer {
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: BarOptions);
+    /** Per-bar color array (each bar uses its `colors[i]` or falls back to `color`). */
+    private buildColors;
     private buildRects;
-    /** Replace bar values and re-upload (for streaming). */
-    setData(x: ArrayLike<number>, y: ArrayLike<number>, base?: number | ArrayLike<number>): void;
+    /** Replace bar values (and optionally per-bar colors) and re-upload for streaming. */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>, base?: number | ArrayLike<number>, colors?: Array<string | Color>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -228,6 +249,8 @@ interface BoxOptions {
     box?: boolean;
     /** Draw a violin (KDE) shape behind/instead of the box (default false). */
     violin?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class BoxLayer implements Layer {
@@ -247,7 +270,15 @@ declare class BoxLayer implements Layer {
     private lineCount;
     private pointStart;
     private pointCount;
+    private width;
+    private showBox;
+    private showViolin;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: BoxOptions);
+    /** Build box/whisker/violin geometry from the groups; sets refs, bounds and draw ranges. */
+    private build;
+    /** Replace the box groups and rebuild the geometry (for streaming). */
+    setData(groups: BoxGroup[], width?: number): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -271,9 +302,29 @@ interface CandlestickOptions {
     downColor?: string | Color;
     /** Wick thickness in CSS px. Default 1.5. */
     wickWidth?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
+/** The OHLC of a single candle — used by {@link CandlestickLayer.updateLast}/`appendCandle`. */
+interface Candle {
+    x: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}
+/** New OHLC arrays for {@link CandlestickLayer.setData} (colors/width stay fixed). */
+interface CandlestickData {
+    x: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+    /** Optional new body width; keeps the previous width if omitted. */
+    width?: number;
+}
 declare class CandlestickLayer implements Layer {
     readonly id: string;
     readonly name: string;
@@ -287,12 +338,120 @@ declare class CandlestickLayer implements Layer {
     private uBody;
     private uWick;
     private wickWidth;
+    private usage;
+    private up;
+    private down;
+    /** Body width in data units (median-derived unless the user fixed it). */
+    private bodyWidth;
+    private explicitWidth;
+    private xs;
+    private os;
+    private hs;
+    private ls;
+    private cs;
+    private rects;
+    private wicks;
+    private colors;
     private count;
     private xRef;
     private yRef;
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: CandlestickOptions);
+    /** Copy the incoming OHLC arrays into the retained plain arrays. */
+    private ingest;
+    /** Write candle `i`'s body rect, wick segment and up/down color into the arrays. */
+    private emitCandle;
+    /** Recompute width/refs/bounds and refill the vertex arrays from the retained OHLC. */
+    private rebuild;
+    /** Re-upload all three per-candle buffers (after a full rebuild). */
+    private upload;
+    /** Replace every candle and re-upload (for streaming a whole new window). */
+    setData(data: CandlestickData): void;
+    /**
+     * Append one new candle (grows the series). Prefer {@link updateLast} for the
+     * in-progress candle and `appendCandle` only when a bar closes and a new one opens.
+     */
+    appendCandle(c: Candle): void;
+    /**
+     * Update the most recent candle in place — the cheap hot path for a live
+     * (forming) bar. Only that candle's 12 floats are re-uploaded; bounds are
+     * extended (never shrunk) to include it. No-op when the series is empty.
+     */
+    updateLast(c: Candle): void;
+    bounds(): {
+        x: Range;
+        y: Range;
+    } | null;
+    draw(state: DrawState): void;
+    dispose(): void;
+}
+
+/**
+ * An OHLC bar chart — the western cousin of the candlestick. Each period is a
+ * vertical low→high line with a left tick at the open and a right tick at the
+ * close, colored up/down by direction. Streams like {@link CandlestickLayer}.
+ */
+interface OhlcOptions {
+    /** Bar positions (data space — e.g. epoch ms on a time axis). */
+    x: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+    /** Total tick span in data units (each open/close tick is half of this). Default 70% of median spacing. */
+    width?: number;
+    /** Close ≥ open color. Default green. */
+    upColor?: string | Color;
+    /** Close < open color. Default red. */
+    downColor?: string | Color;
+    /** Line thickness in CSS px. Default 1.5. */
+    lineWidth?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
+    name?: string;
+    yAxis?: string;
+}
+declare class OhlcLayer implements Layer {
+    readonly id: string;
+    readonly name: string;
+    readonly colorCss: string;
+    readonly yAxis: string;
+    private gl;
+    private program;
+    private vao;
+    private buffers;
+    private uniforms;
+    private lineWidth;
+    private usage;
+    private up;
+    private down;
+    private barWidth;
+    private explicitWidth;
+    private xs;
+    private os;
+    private hs;
+    private ls;
+    private cs;
+    private segs;
+    private colors;
+    private count;
+    private xRef;
+    private yRef;
+    private xBounds;
+    private yBounds;
+    constructor(gl: WebGL2RenderingContext, opts: OhlcOptions);
+    private ingest;
+    /** Write bar `i`'s three segments (+ colors) at instance base `i * SEGS_PER_BAR`. */
+    private emitBar;
+    private rebuild;
+    private upload;
+    /** Replace every bar and re-upload (for streaming a whole new window). */
+    setData(data: CandlestickData): void;
+    /** Append one new bar (grows the series). */
+    appendCandle(c: Candle): void;
+    /** Update the most recent bar in place — the cheap hot path for a live bar. */
+    updateLast(c: Candle): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -326,6 +485,8 @@ interface ContourOptions {
     /** Single line color; if omitted, levels are colored by a colormap. */
     color?: string | Color;
     colormap?: ColormapName;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class ContourLayer implements Layer {
@@ -340,7 +501,17 @@ declare class ContourLayer implements Layer {
     private xRef;
     private yRef;
     private ext;
+    private cols;
+    private rows;
+    private levelsOpt;
+    private cmap;
+    private fixedColor;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: ContourOptions);
+    /** Marching-squares the scalar field into iso-line segments; sets vertexCount. */
+    private build;
+    /** Replace the scalar field and recompute the iso lines (for streaming). */
+    setData(values: ArrayLike<number>, cols?: number, rows?: number): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -372,9 +543,20 @@ interface ErrorBarOptions {
     band?: boolean;
     /** Band fill opacity. Default 0.2. */
     bandOpacity?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
+/** New positions/errors for {@link ErrorBarLayer.setData} (styling stays fixed). */
+interface ErrorBarData {
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    yerr?: ErrInput;
+    yerrLow?: ErrInput;
+    yerrHigh?: ErrInput;
+    xerr?: ErrInput;
+}
 declare class ErrorBarLayer implements Layer {
     readonly id: string;
     readonly name: string;
@@ -395,6 +577,7 @@ declare class ErrorBarLayer implements Layer {
     private bandOpacity;
     private showWhiskers;
     private showBand;
+    private usage;
     private segCount;
     private capCount;
     private bandVerts;
@@ -403,6 +586,10 @@ declare class ErrorBarLayer implements Layer {
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: ErrorBarOptions);
+    /** Recompute refs/bounds/counts and the whisker/cap/band vertex arrays from new data. */
+    private build;
+    /** Replace the data and re-upload (for streaming). */
+    setData(data: ErrorBarData): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -421,9 +608,20 @@ interface GraphOptions {
     /** Node diameter in CSS pixels. Default 10. */
     nodeSize?: number;
     edgeColor?: string | Color;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
+/** New nodes/edges for {@link GraphLayer.setData} (colors/size stay fixed). */
+interface GraphData {
+    /** Node positions. Omit both to run a force layout from `edges`. */
+    x?: ArrayLike<number>;
+    y?: ArrayLike<number>;
+    edges: ReadonlyArray<readonly [number, number]>;
+    /** Node count for the force layout when `x`/`y` are omitted. Defaults to max edge index + 1. */
+    nodeCount?: number;
+}
 /** A node-link graph: edges as line segments, nodes as round points. */
 declare class GraphLayer implements Layer {
     readonly id: string;
@@ -446,7 +644,15 @@ declare class GraphLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: GraphOptions);
+    /** Build node/edge vertex arrays from positions + edges; sets counts, refs and bounds. */
+    private build;
+    /**
+     * Replace nodes and edges (for streaming). When `x`/`y` are omitted, node
+     * positions are recomputed with the package's force layout from the edges.
+     */
+    setData(data: GraphData): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -470,6 +676,8 @@ interface HeatmapOptions {
     domain?: Range;
     /** Bilinear filtering (default true) vs. hard cells. */
     smooth?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class HeatmapLayer implements Layer {
@@ -484,7 +692,15 @@ declare class HeatmapLayer implements Layer {
     private xRef;
     private yRef;
     private ext;
+    private lut;
+    private fixedDomain;
+    private cols;
+    private rows;
     constructor(gl: WebGL2RenderingContext, opts: HeatmapOptions);
+    /** Bake a `cols*rows` value grid into the RGBA data texture via the colormap. */
+    private uploadValues;
+    /** Replace the value grid and re-bake the data texture (for streaming). */
+    setData(values: ArrayLike<number>, cols?: number, rows?: number): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -501,6 +717,8 @@ interface HexbinOptions {
     colormap?: ColormapName;
     /** Count range mapped to the colormap. Defaults to [1, maxCount]. */
     domain?: Range;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     yAxis?: string;
 }
 declare class HexbinLayer implements Layer {
@@ -517,7 +735,15 @@ declare class HexbinLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private cmap;
+    private explicitRadius;
+    private domain;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: HexbinOptions);
+    /** Bin the points into hex cells; sets radius, refs, bounds and cell count. */
+    private build;
+    /** Replace the point arrays, re-bin and re-upload the cells (for streaming). */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -542,6 +768,8 @@ interface ImageOptions {
     opacity?: number;
     /** Called after an async (URL) image finishes loading — wire to `plot.requestRender`. */
     onLoad?: () => void;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -570,6 +798,10 @@ declare class ImageLayer implements Layer {
     private ready;
     private img;
     constructor(gl: WebGL2RenderingContext, opts: ImageOptions);
+    /** Point the texture at a new source: load a URL async, or upload a bitmap now. */
+    private setSource;
+    /** Replace the image source and re-upload the texture (for streaming). */
+    setData(source: ImageSource, onLoad?: () => void): void;
     private upload;
     bounds(): {
         x: Range;
@@ -629,6 +861,8 @@ interface LineOptions {
      * zoomed out (preserves peaks). Requires monotonic x; auto-detected. Default true.
      */
     decimate?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class LineLayer implements Layer {
     readonly id: string;
@@ -657,6 +891,7 @@ declare class LineLayer implements Layer {
     private monotonic;
     private gpuDec;
     private step?;
+    private usage;
     private xRef;
     private yRef;
     private xs;
@@ -707,6 +942,8 @@ interface PatchesOptions {
     domain?: Range;
     /** Fill opacity, 0..1. Default 1. */
     opacity?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -730,7 +967,16 @@ declare class PatchesLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private defRgba;
+    private opacity;
+    private cmap;
+    private domainOpt;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: PatchesOptions);
+    /** Triangulate the patches and recompute refs/bounds/vertexCount into position/color arrays. */
+    private build;
+    /** Replace the patches and re-upload (for streaming). */
+    setData(patches: Patch[]): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -754,6 +1000,8 @@ interface PieOptions {
     innerRadius?: number;
     /** Angle of the first slice edge, radians. Default `Math.PI / 2` (12 o'clock). */
     startAngle?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -777,7 +1025,19 @@ declare class PieLayer implements Layer {
     private yRef;
     private xBounds;
     private yBounds;
+    private cx;
+    private cy;
+    private R;
+    private rIn;
+    private start;
+    private colorsOpt;
+    private cmap;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: PieOptions);
+    /** Recompute vertexCount and the position/color triangle soup from new slice values. */
+    private build;
+    /** Replace the slice values and re-upload (for streaming). */
+    setData(values: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -806,6 +1066,8 @@ interface QuiverOptions {
         colormap?: ColormapName;
         domain?: Range;
     };
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -825,6 +1087,9 @@ declare class QuiverLayer implements Layer {
     private width;
     private headSize;
     private useVertexColor;
+    private explicitScale;
+    private colorBy;
+    private usage;
     private count;
     private xRef;
     private yRef;
@@ -832,6 +1097,10 @@ declare class QuiverLayer implements Layer {
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: QuiverOptions);
     private bindInstanceAttribs;
+    /** Recompute count/refs/bounds and the arrow+color arrays from new x/y/u/v. */
+    private build;
+    /** Replace the data and re-upload (for streaming). */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>, u: ArrayLike<number>, v: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -865,6 +1134,8 @@ interface ScatterOptions {
         /** Value range mapped to [0,1]. Defaults to the data min/max. */
         domain?: Range;
     };
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class ScatterLayer implements Layer {
     readonly id: string;
@@ -879,6 +1150,7 @@ declare class ScatterLayer implements Layer {
     private count;
     private size;
     private marker;
+    private usage;
     private color;
     private useVertexColor;
     private labels?;
@@ -912,6 +1184,8 @@ interface StemOptions {
     width?: number;
     /** Tip marker diameter in CSS px (0 hides). Default 6. */
     markerSize?: number;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
     name?: string;
     yAxis?: string;
 }
@@ -931,6 +1205,7 @@ declare class StemLayer implements Layer {
     private width;
     private markerSize;
     private count;
+    private usage;
     private baseline;
     private xRef;
     private yRef;
@@ -939,6 +1214,10 @@ declare class StemLayer implements Layer {
     private xBounds;
     private yBounds;
     constructor(gl: WebGL2RenderingContext, opts: StemOptions);
+    /** Recompute count/refs/bounds and the stem+tip vertex arrays from new x/y. */
+    private build;
+    /** Replace the data and re-upload (for streaming). */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>): void;
     bounds(): {
         x: Range;
         y: Range;
@@ -1017,8 +1296,32 @@ declare class CategoricalScale implements Scale {
     ticks(): Tick[];
     formatTick(value: number): string;
 }
-type ScaleType = "linear" | "log" | "time" | "categorical";
-declare function makeScale(type: ScaleType, domain?: Range, factors?: string[]): Scale;
+/**
+ * An **ordinal time** axis — the standard financial x-axis. Bars are plotted at
+ * evenly-spaced integer indices `0..n-1` (like {@link CategoricalScale}, so the
+ * domain is the band `[-0.5, n-1+0.5]`), which **collapses market gaps**
+ * (weekends, overnight, holidays) instead of leaving blank space the way a real
+ * {@link TimeScale} would. Each index carries a timestamp; ticks are placed at
+ * natural calendar boundaries (day / month / year, or hour / minute when zoomed
+ * in) and subsampled toward the target count, so labels stay readable at any zoom.
+ *
+ * Plot your candles/bars at `x = 0,1,2,…` and pass the per-bar epoch-ms `times`.
+ */
+declare class OrdinalTimeScale implements Scale {
+    readonly type = "ordinal-time";
+    readonly log = false;
+    times: number[];
+    domain: Range;
+    constructor(times?: ArrayLike<number>);
+    norm(value: number): number;
+    invert(t: number): number;
+    /** Timestamp at a (rounded, clamped) index. */
+    private timeAt;
+    ticks(target?: number): Tick[];
+    formatTick(value: number): string;
+}
+type ScaleType = "linear" | "log" | "time" | "categorical" | "ordinal-time";
+declare function makeScale(type: ScaleType, domain?: Range, factors?: string[], times?: ArrayLike<number>): Scale;
 
 /** Pixel geometry of the plot, in CSS pixels. The plot region excludes margins. */
 interface Layout {
@@ -1083,6 +1386,12 @@ interface AxisScaleOptions {
     domain?: Range;
     /** Factor labels for a `"categorical"` axis (fixes the domain to the bands). */
     factors?: string[];
+    /**
+     * Per-index epoch-ms timestamps for an `"ordinal-time"` axis (finance/session
+     * axis). Plot bars at integer indices `0..times.length-1`; gaps collapse and
+     * ticks show calendar dates.
+     */
+    times?: ArrayLike<number>;
 }
 /** Legend placement + styling. `legend: true` uses all defaults. */
 interface LegendOptions {
@@ -1100,6 +1409,8 @@ interface YAxisOptions extends AxisConfig {
     domain?: Range;
     /** Factor labels for a `"categorical"` axis. */
     factors?: string[];
+    /** Per-index epoch-ms timestamps for an `"ordinal-time"` axis. */
+    times?: ArrayLike<number>;
     /** Which side to draw the axis on. Default `"right"` for secondary axes. */
     side?: "left" | "right";
     /** Axis + label color (secondary axes often match their series). */
@@ -1303,6 +1614,11 @@ declare class Plot {
     private hoverReadout?;
     /** Cursor position while the pointer is pressed, when `crosshair`. */
     private pressPx;
+    private viewListeners;
+    private cursorListeners;
+    private lastEmittedX;
+    private lastEmittedCursor;
+    private linkedCursorX;
     private tooltip;
     /** A point clicked to pin its details, until another click clears it. */
     private selected;
@@ -1359,6 +1675,8 @@ declare class Plot {
     addStem(opts: StemOptions): StemLayer;
     addQuiver(opts: QuiverOptions): QuiverLayer;
     addCandlestick(opts: CandlestickOptions): CandlestickLayer;
+    /** An OHLC bar chart (low→high line with open/close ticks). Streams like candlesticks. */
+    addOhlc(opts: OhlcOptions): OhlcLayer;
     /** Filled polygons (choropleth-capable). Rings are triangulated with earcut. */
     addPatches(opts: PatchesOptions): PatchesLayer;
     /** A pie / donut chart. Set `equalAspect: true` on the plot so it stays circular. */
@@ -1399,6 +1717,10 @@ declare class Plot {
     }): BarLayer;
     /** Register an additional named y axis. Series opt in via `addLine({ yAxis })`. */
     addYAxis(id: string, opts?: YAxisOptions): void;
+    /** Whether a y axis with this id exists (the primary is always `"y"`). */
+    hasYAxis(id: string): boolean;
+    /** Remove a secondary y axis. No-op for the primary `"y"` or an unknown id. */
+    removeYAxis(id: string): void;
     removeLayer(layer: Layer): void;
     /** Configure ticks/format/title for the x axis or a y axis (default primary "y"). */
     setAxis(dim: Dim | string, config: Partial<AxisConfig>): void;
@@ -1408,6 +1730,18 @@ declare class Plot {
         y?: Range;
         yAxes?: Record<string, Range>;
     }): void;
+    /**
+     * Subscribe to x-domain changes (pan / zoom / home / setView). Fires once per
+     * frame after the domain settles. Returns an unsubscribe function. See {@link linkX}.
+     */
+    onViewChange(cb: (x: Range) => void): () => void;
+    /**
+     * Subscribe to the hover cursor's data-space x (or `null` when it leaves the
+     * plot). Returns an unsubscribe function. Used to share a crosshair across panes.
+     */
+    onCursorMove(cb: (dataX: number | null) => void): () => void;
+    /** Draw a linked crosshair at this data-space x (pushed from another pane), or clear it with `null`. */
+    setLinkedCursor(dataX: number | null): void;
     private setYDomain;
     setMode(mode: InteractionMode): void;
     getMode(): InteractionMode;
@@ -1420,6 +1754,8 @@ declare class Plot {
     private resize;
     requestRender(): void;
     private primaryY;
+    /** Fire view/cursor listeners once the frame's x-domain + cursor are settled. */
+    private emitLinks;
     render(): void;
     /** Named series that can appear in the legend: any layer exposing name + colorCss. */
     private legendEntries;
@@ -1466,6 +1802,21 @@ declare class Plot {
     private zoomAround;
 }
 
+/**
+ * Link the x-axis (pan / zoom) and hover crosshair of several plots so they move
+ * together — the standard multi-pane financial layout (price on top, volume /
+ * RSI / MACD below, all sharing one time axis). The plots should share the same
+ * x-scale semantics (e.g. all `ordinal-time` over the same bars).
+ *
+ * ```ts
+ * const detach = linkX([pricePlot, volumePlot, rsiPlot]);
+ * // …later: detach();
+ * ```
+ *
+ * @returns a function that unlinks them again.
+ */
+declare function linkX(plots: Plot[]): () => void;
+
 /** The subset of Plot the toolbar drives. Kept minimal to avoid an import cycle. */
 interface ToolbarHost {
     setMode(mode: InteractionMode): void;
@@ -1533,6 +1884,8 @@ interface PolarLineOptions {
     width?: number;
     /** Connect the last point back to the first. */
     closed?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 interface PolarScatterOptions {
     theta: ArrayLike<number>;
@@ -1541,6 +1894,8 @@ interface PolarScatterOptions {
     size?: number;
     /** Optional per-point labels (one per point), shown as the title of the click-pinned info box. */
     labels?: ArrayLike<string>;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A live handle to update a polar series with new (theta, r) data. */
 interface PolarSeries {
@@ -1672,6 +2027,8 @@ interface Bar3DOptions {
         domain?: Range;
     };
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** 3D bars (columns) on an x/z grid, lit like the surface and optionally colormapped. */
 declare class Bar3DLayer implements Layer3D {
@@ -1682,15 +2039,24 @@ declare class Bar3DLayer implements Layer3D {
     private program;
     private vao;
     private buffers;
+    private instBuf;
     private uniforms;
     private count;
     private width;
     private b3;
     private cInfo;
     private positions;
+    private base;
+    private optWidth?;
+    private colorByOpt?;
+    private usage;
     private lightDir;
     private ambient;
     constructor(gl: WebGL2RenderingContext, opts: Bar3DOptions);
+    /** Build the per-bar instances (base/height/color) and (re)upload the instance buffer. */
+    private build;
+    /** Stream new bar positions/heights (instances rebuilt). Call `plot.refresh()` after. */
+    setData(x: ArrayLike<number>, z: ArrayLike<number>, y: ArrayLike<number>): void;
     bounds3(): Bounds3 | null;
     colorInfo(): ColorInfo | null;
     pickData(): {
@@ -1716,6 +2082,8 @@ interface Contour3DOptions {
     color?: string | Color;
     colormap?: ColormapName;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /**
  * 3D contour: iso-height lines of a grid, each drawn at its own level height
@@ -1733,7 +2101,24 @@ declare class Contour3DLayer implements Layer3D {
     private vertCount;
     private b3;
     private cInfo;
+    private cmapName;
+    private fixed;
+    private levelsOpt?;
+    private cols;
+    private rows;
+    private extentX;
+    private extentZ;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: Contour3DOptions);
+    /** Marching-squares the grid at each iso level and (re)upload the line buffer. */
+    private build;
+    /** Stream a new scalar field (contours recomputed). Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>, opts?: {
+        cols?: number;
+        rows?: number;
+        extentX?: Range;
+        extentZ?: Range;
+    }): void;
     bounds3(): Bounds3 | null;
     colorInfo(): ColorInfo | null;
     draw(gl: WebGL2RenderingContext, mvp: Mat4): void;
@@ -1756,6 +2141,8 @@ interface IsosurfaceOptions {
     /** Fill opacity 0..1. Default 1. */
     opacity?: number;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A marching-cubes isosurface of a 3D scalar volume, lit and solid-colored. */
 declare class IsosurfaceLayer implements Layer3D {
@@ -1771,9 +2158,18 @@ declare class IsosurfaceLayer implements Layer3D {
     private color;
     private opacity;
     private b3;
+    private usage;
     private lightDir;
     private ambient;
     constructor(gl: WebGL2RenderingContext, opts: IsosurfaceOptions);
+    /** Run marching cubes and (re)upload the interleaved pos/normal vertex buffer. */
+    private build;
+    /** Stream a new volume + iso level (marching-cubes mesh recomputed). Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>, dims: [number, number, number], isoLevel: number, extent?: {
+        x: Range;
+        y: Range;
+        z: Range;
+    }): void;
     bounds3(): Bounds3 | null;
     /** Set the light direction (world space) and ambient term (0..1). */
     setLight(dir: [number, number, number], ambient: number): void;
@@ -1787,6 +2183,8 @@ interface Line3DOptions {
     z: ArrayLike<number>;
     color?: string | Color;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A 3D polyline / path (`GL_LINE_STRIP`). */
 declare class Line3DLayer implements Layer3D {
@@ -1802,6 +2200,7 @@ declare class Line3DLayer implements Layer3D {
     private color;
     private b3;
     private positions;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: Line3DOptions);
     bounds3(): Bounds3 | null;
     pickData(): {
@@ -1831,6 +2230,8 @@ interface PointCloudOptions {
     labels?: ArrayLike<string>;
     /** Series name (legend / colorbar label). */
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class PointCloudLayer implements Layer3D {
     readonly id: string;
@@ -1849,6 +2250,7 @@ declare class PointCloudLayer implements Layer3D {
     private labels?;
     /** Interleaved pos(3)+color(3)+size(1); positions are streamed in place. */
     private data;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: PointCloudOptions);
     private updateBounds;
     /** Stream new point positions (same count keeps colors/sizes). Call `plot.refresh()` after. */
@@ -1883,6 +2285,8 @@ interface Quiver3DOptions {
     /** Arrowhead length as a fraction of the arrow. Default 0.28. */
     headSize?: number;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /** A 3D vector field: each arrow is a shaft + a 4-wing arrowhead, drawn as lines. */
 declare class Quiver3DLayer implements Layer3D {
@@ -1898,7 +2302,16 @@ declare class Quiver3DLayer implements Layer3D {
     private b3;
     private cInfo;
     private positions;
+    private base;
+    private scale;
+    private headSize;
+    private colorByOpt?;
+    private usage;
     constructor(gl: WebGL2RenderingContext, opts: Quiver3DOptions);
+    /** Build the arrow line geometry (shaft + 4-wing head) and (re)upload the vertex buffer. */
+    private build;
+    /** Stream a new vector field (arrows rebuilt). Call `plot.refresh()` after. */
+    setData(x: ArrayLike<number>, y: ArrayLike<number>, z: ArrayLike<number>, u: ArrayLike<number>, v: ArrayLike<number>, w: ArrayLike<number>): void;
     bounds3(): Bounds3 | null;
     colorInfo(): ColorInfo | null;
     pickData(): {
@@ -1921,6 +2334,8 @@ interface SurfaceOptions {
     name?: string;
     /** Render the grid as a wireframe (lines) instead of a lit filled surface. */
     wireframe?: boolean;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 declare class SurfaceLayer implements Layer3D {
     readonly id: string;
@@ -1935,9 +2350,23 @@ declare class SurfaceLayer implements Layer3D {
     private cmapName;
     private vDomain;
     private wireframe;
+    private cols;
+    private rows;
+    private extentX;
+    private extentZ;
+    private usage;
     private lightDir;
     private ambient;
     constructor(gl: WebGL2RenderingContext, opts: SurfaceOptions);
+    /** Build the mesh (positions/normals/colors or wireframe) and (re)upload the vertex buffer. */
+    private build;
+    /** Stream a new height grid (mesh/normals/wireframe rebuilt). Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>, opts?: {
+        cols?: number;
+        rows?: number;
+        extentX?: Range;
+        extentZ?: Range;
+    }): void;
     bounds3(): Bounds3;
     colorInfo(): ColorInfo;
     /** Set the light direction (world space) and ambient term (0..1). */
@@ -1962,6 +2391,8 @@ interface VolumeOptions {
     /** Overall opacity multiplier. Default 1. */
     density?: number;
     name?: string;
+    /** Buffer-usage hint; set `"dynamic"` when streaming via setData. Default `"static"`. */
+    renderType?: RenderType;
 }
 /**
  * Direct volume rendering: GPU raymarching through a 3D texture with front-to-back
@@ -1983,8 +2414,15 @@ declare class VolumeLayer implements Layer3D {
     private density;
     private cmapName;
     private vDomain;
+    private dims;
+    private domainOpt?;
+    private usage;
     private camLocal;
     constructor(gl: WebGL2RenderingContext, opts: VolumeOptions);
+    /** Normalize the scalar field and (re)upload it into the R8 3D texture. */
+    private uploadVolume;
+    /** Stream a new scalar volume (same dims); re-uploads the 3D texture. Call `plot.refresh()` after. */
+    setData(values: ArrayLike<number>): void;
     bounds3(): Bounds3;
     colorInfo(): ColorInfo;
     /** Set the camera position in world space; converted to the volume's [0,1] local space. */
@@ -2241,6 +2679,8 @@ interface Density {
  */
 declare function kde(values: ArrayLike<number>, lo: number, hi: number, points?: number, bandwidth?: number): Density;
 
+/** Map a layer's {@link RenderType} to a WebGL buffer-usage hint (default STATIC_DRAW). */
+declare function bufferUsage(gl: WebGL2RenderingContext, renderType?: RenderType): number;
 /** Compile + link a vertex/fragment program. */
 declare function createProgram(gl: WebGL2RenderingContext, vert: string, frag: string): WebGLProgram;
 /** Cache uniform locations for a program by name. */
@@ -2268,9 +2708,230 @@ declare function uniformLocations(gl: WebGL2RenderingContext, program: WebGLProg
  */
 declare function earcut(data: number[], holeIndices?: number[], dim?: number): number[];
 
+/** Simple moving average over `period` samples. */
+declare function sma(values: ArrayLike<number>, period: number): Float64Array;
+/** Weighted moving average (linear weights 1..period, newest heaviest). */
+declare function wma(values: ArrayLike<number>, period: number): Float64Array;
+/**
+ * Exponential moving average, α = 2/(period+1). Seeded with the SMA of the first
+ * `period` samples at index `period-1` (the standard convention).
+ */
+declare function ema(values: ArrayLike<number>, period: number): Float64Array;
+/** Rolling population standard deviation over `period` samples. */
+declare function rollingStd(values: ArrayLike<number>, period: number): Float64Array;
+interface BollingerBands {
+    middle: Float64Array;
+    upper: Float64Array;
+    lower: Float64Array;
+}
+/** Bollinger Bands: SMA(period) ± `k`·rollingStd(period). Defaults 20, 2. */
+declare function bollinger(close: ArrayLike<number>, period?: number, k?: number): BollingerBands;
+/** Wilder's RSI over `period` (default 14). Values in 0..100; warm-up is NaN. */
+declare function rsi(close: ArrayLike<number>, period?: number): Float64Array;
+interface Macd {
+    macd: Float64Array;
+    signal: Float64Array;
+    histogram: Float64Array;
+}
+/** MACD: EMA(fast) − EMA(slow), its EMA(signal) line, and the histogram. Defaults 12/26/9. */
+declare function macd(close: ArrayLike<number>, fast?: number, slow?: number, signalPeriod?: number): Macd;
+/**
+ * Volume-weighted average price, cumulative from the first sample: running
+ * Σ(typical·volume) / Σ(volume), where typical = (high+low+close)/3.
+ */
+declare function vwap(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, volume: ArrayLike<number>): Float64Array;
+/** True range per bar: max(H−L, |H−prevC|, |L−prevC|). First bar is H−L. */
+declare function trueRange(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>): Float64Array;
+/** Wilder's Average True Range over `period` (default 14). */
+declare function atr(high: ArrayLike<number>, low: ArrayLike<number>, close: ArrayLike<number>, period?: number): Float64Array;
+/** Index of the first non-NaN value (−1 if all NaN). Handy for trimming warm-up. */
+declare function firstFinite(values: ArrayLike<number>): number;
+
+/**
+ * Chart-type transforms: turn raw OHLC(V) into the geometry a specialist finance
+ * chart needs. Each returns plain arrays you render with existing layers
+ * (candlestick, bar, area, scatter) — see the `Plot.add*` helpers that wrap them.
+ */
+interface Ohlc {
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+}
+interface OhlcArrays {
+    open: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    close: Float64Array;
+}
+/**
+ * Heikin-Ashi candles — a smoothed OHLC that filters noise and makes trends
+ * obvious. Output has the same length; feed it to a candlestick layer.
+ *
+ *   haClose = (o+h+l+c)/4
+ *   haOpen  = (prevHaOpen + prevHaClose)/2   (seed: (o₀+c₀)/2)
+ *   haHigh  = max(h, haOpen, haClose)
+ *   haLow   = min(l, haOpen, haClose)
+ */
+declare function heikinAshi(d: Ohlc): OhlcArrays;
+/** One brick / box for Renko & Line-break (each renders as a wickless candle body). */
+interface Brick {
+    /** Sequential column index (0..n-1); bricks are evenly spaced, time is discarded. */
+    x: number;
+    open: number;
+    close: number;
+    /** `true` when close > open (up brick). */
+    up: boolean;
+}
+/**
+ * Renko bricks from a close series. A new brick is emitted each time price moves
+ * a full `brickSize` from the last brick's close (multiple bricks if it jumps
+ * several sizes). Time is discarded — bricks are placed at successive indices.
+ */
+declare function renko(close: ArrayLike<number>, brickSize: number): Brick[];
+/**
+ * Three-line-break (generalised to `lines`): a new up brick when close exceeds
+ * the highest close of the last `lines` bricks, a down brick when it breaks the
+ * lowest; otherwise nothing. Bricks are placed at successive indices.
+ */
+declare function lineBreak(close: ArrayLike<number>, lines?: number): Brick[];
+/** One P&F column: a run of X's (rising) or O's (falling) spanning `from`→`to`. */
+interface PfColumn {
+    col: number;
+    kind: "X" | "O";
+    from: number;
+    to: number;
+    /** Box centers filled in this column (for plotting the X/O glyphs). */
+    boxes: number[];
+}
+/**
+ * Point & Figure columns. Price is quantised to `boxSize`; a column of X's grows
+ * while price rises, O's while it falls, and the column flips only after a
+ * `reversal`-box move against it. Time is discarded.
+ */
+declare function pointAndFigure(high: ArrayLike<number>, low: ArrayLike<number>, boxSize: number, reversal?: number): PfColumn[];
+interface VolumeProfile {
+    /** Bin center price for each level (length = bins). */
+    levels: Float64Array;
+    /** Total volume traded in each price bin. */
+    volume: Float64Array;
+    binSize: number;
+    priceMin: number;
+    priceMax: number;
+    /** Bin index of the highest-volume level (the Point of Control). */
+    pocIndex: number;
+}
+/**
+ * Volume profile — a histogram of traded volume by price level. Plot it as
+ * horizontal bars (`orientation:"h"`) with `levels` on the y axis.
+ */
+declare function volumeProfile(price: ArrayLike<number>, volume: ArrayLike<number>, bins?: number): VolumeProfile;
+interface DepthCurves {
+    /** Bid side: prices ascending toward mid, cumulative volume (best bid = largest cum). */
+    bidPrice: Float64Array;
+    bidCum: Float64Array;
+    /** Ask side: prices ascending away from mid, cumulative volume. */
+    askPrice: Float64Array;
+    askCum: Float64Array;
+}
+/**
+ * Order-book depth curves. `bids`/`asks` are `[price, size]` pairs (any order);
+ * returns cumulative-volume step curves ready for two step-area layers.
+ */
+declare function depth(bids: ArrayLike<readonly [number, number]>, asks: ArrayLike<readonly [number, number]>): DepthCurves;
+
+/**
+ * Convenience builders for specialist finance charts. Each takes a {@link Plot}
+ * and composes existing layers from a transform/indicator — mirroring the
+ * `addMap(plot, …)` free-function style. Import from `@photonviz/core`.
+ */
+
+/** Raw OHLC input shared by the candle-style helpers. */
+interface OhlcInput {
+    x: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+}
+interface HeikinAshiOptions extends Omit<CandlestickOptions, "open" | "high" | "low" | "close"> {
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+}
+/** Heikin-Ashi candles: smooth the OHLC, then draw it as a candlestick layer. */
+declare function addHeikinAshi(plot: Plot, opts: HeikinAshiOptions): CandlestickLayer;
+interface RenkoOptions {
+    close: ArrayLike<number>;
+    /** Fixed brick height in price units. */
+    brickSize: number;
+    upColor?: string | Color;
+    downColor?: string | Color;
+    name?: string;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/**
+ * Renko chart — bricks at successive integer indices (time discarded). Rendered
+ * as wickless candles, so pair it with an `ordinal-time`/linear x axis.
+ */
+declare function addRenko(plot: Plot, opts: RenkoOptions): CandlestickLayer;
+interface VolumeProfileOptions {
+    /** Price per sample (typically close). */
+    price: ArrayLike<number>;
+    volume: ArrayLike<number>;
+    /** Number of price bins. Default 24. */
+    bins?: number;
+    color?: string | Color;
+    /** Highlight the Point-of-Control bin with this color. */
+    pocColor?: string | Color;
+    name?: string;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/** Volume-by-price histogram as horizontal bars (price on the y axis). */
+declare function addVolumeProfile(plot: Plot, opts: VolumeProfileOptions): BarLayer;
+interface BollingerOptions {
+    x: ArrayLike<number>;
+    close: ArrayLike<number>;
+    period?: number;
+    k?: number;
+    /** Line color for the bands + middle. Default light blue. */
+    color?: string | Color;
+    /** Fill color between the bands (omit to skip the fill). */
+    bandColor?: string | Color;
+    width?: number;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/** Bollinger Bands: a shaded band between upper/lower plus the three lines. */
+interface BollingerHandle {
+    band?: AreaLayer;
+    upper: LineLayer;
+    middle: LineLayer;
+    lower: LineLayer;
+}
+declare function addBollinger(plot: Plot, opts: BollingerOptions): BollingerHandle;
+interface DepthOptions {
+    /** `[price, size]` levels (any order). */
+    bids: ArrayLike<readonly [number, number]>;
+    asks: ArrayLike<readonly [number, number]>;
+    bidColor?: string | Color;
+    askColor?: string | Color;
+    yAxis?: string;
+    renderType?: RenderType;
+}
+/** Order-book depth: cumulative bid/ask volume as two filled areas. */
+interface DepthHandle {
+    bid: AreaLayer;
+    ask: AreaLayer;
+}
+declare function addDepth(plot: Plot, opts: DepthOptions): DepthHandle;
+
 /** Parse a CSS hex/rgb color string into normalized RGBA (0..1). */
 declare function parseColor(input: string): [number, number, number, number];
 /** Normalized RGBA (0..1) back to a CSS `rgba(...)` string. */
 declare function toColorCss(c: readonly [number, number, number, number]): string;
 
-export { type Annotation, AreaLayer, type AreaOptions, type AreaSeries, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, Bar3DLayer, type Bar3DOptions, BarLayer, type BarOptions, type BarSeries, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, CandlestickLayer, type CandlestickOptions, CategoricalScale, type Color, type ColorInfo, type ColormapName, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type Density, type Dim, type DrawState, ErrorBarLayer, type ErrorBarOptions, type ForceLayoutOptions, type GraphInput, GraphLayer, type GraphOptions, type GroupedBarOptions, HeatmapLayer, type HeatmapOptions, HexbinLayer, type HexbinOptions, type Histogram, type HoverReadoutRow, ImageLayer, type ImageOptions, type ImageSource, type InteractionMode, IsosurfaceLayer, type IsosurfaceOptions, type Layer, type Layer3D, type Layout, type LegendOptions, Line3DLayer, type Line3DOptions, LineLayer, type LineOptions, LinearScale, LogScale, type MarkerShape, type Patch, PatchesLayer, type PatchesOptions, type PickMode, PieLayer, type PieOptions, Plot, Plot3D, type Plot3DOptions, type PlotOptions, type PlotTitleOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, Quiver3DLayer, type Quiver3DOptions, QuiverLayer, type QuiverOptions, type RGB, type Range, type ResolvedAxisStyle, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type Spectrogram, type StackedAreaOptions, type StackedBarOptions, StemLayer, type StemOptions, SurfaceLayer, type SurfaceOptions, TRANSFORM_GLSL, TRANSFORM_UNIFORMS, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, VolumeLayer, type VolumeOptions, type YAxisOptions, autoTicks, boxStats, colormap, colormapLUT, createProgram, createToolbar, darkTheme, defaultFormat, earcut, fft, forceLayout, histogram, kde, lightTheme, makeScale, marchingCubes, parseColor, quantileSorted, resolveAxisStyle, resolveTicks, setTransformUniforms, spectrogram, toColorCss, uniformLocations, withMinorTicks };
+export { type Annotation, AreaLayer, type AreaOptions, type AreaSeries, Axis, type AxisConfig, type AxisFrame, type AxisScaleOptions, Bar3DLayer, type Bar3DOptions, BarLayer, type BarOptions, type BarSeries, type BollingerBands, type BollingerHandle, type BollingerOptions, type Bounds, type Bounds3, type BoxGroup, BoxLayer, type BoxOptions, type BoxStats, type Brick, type Candle, type CandlestickData, CandlestickLayer, type CandlestickOptions, CategoricalScale, type Color, type ColorInfo, type ColormapName, Contour3DLayer, type Contour3DOptions, ContourLayer, type ContourOptions, type Density, type DepthCurves, type DepthHandle, type DepthOptions, type Dim, type DrawState, ErrorBarLayer, type ErrorBarOptions, type ForceLayoutOptions, type GraphInput, GraphLayer, type GraphOptions, type GroupedBarOptions, HeatmapLayer, type HeatmapOptions, type HeikinAshiOptions, HexbinLayer, type HexbinOptions, type Histogram, type HoverReadoutRow, ImageLayer, type ImageOptions, type ImageSource, type InteractionMode, IsosurfaceLayer, type IsosurfaceOptions, type Layer, type Layer3D, type Layout, type LegendOptions, Line3DLayer, type Line3DOptions, LineLayer, type LineOptions, LinearScale, LogScale, type Macd, type MarkerShape, type Ohlc, type OhlcArrays, type OhlcInput, OhlcLayer, type OhlcOptions, OrdinalTimeScale, type Patch, PatchesLayer, type PatchesOptions, type PfColumn, type PickMode, PieLayer, type PieOptions, Plot, Plot3D, type Plot3DOptions, type PlotOptions, type PlotTitleOptions, PointCloudLayer, type PointCloudOptions, type PolarLineOptions, type PolarOptions, PolarPlot, type PolarScatterOptions, type PolarSeries, Quiver3DLayer, type Quiver3DOptions, QuiverLayer, type QuiverOptions, type RGB, type Range, type RenderType, type RenkoOptions, type ResolvedAxisStyle, type Scale, type ScaleType, ScatterLayer, type ScatterOptions, type Spectrogram, type StackedAreaOptions, type StackedBarOptions, StemLayer, type StemOptions, SurfaceLayer, type SurfaceOptions, TRANSFORM_GLSL, TRANSFORM_UNIFORMS, type Theme, type Tick, type TicksSpec, TimeScale, type ToolbarHost, type ToolbarTheme, VolumeLayer, type VolumeOptions, type VolumeProfile, type VolumeProfileOptions, type YAxisOptions, addBollinger, addDepth, addHeikinAshi, addRenko, addVolumeProfile, atr, autoTicks, bollinger, boxStats, bufferUsage, colormap, colormapLUT, createProgram, createToolbar, darkTheme, defaultFormat, depth, earcut, ema, fft, firstFinite, forceLayout, heikinAshi, histogram, kde, lightTheme, lineBreak, linkX, macd, makeScale, marchingCubes, parseColor, pointAndFigure, quantileSorted, renko, resolveAxisStyle, resolveTicks, rollingStd, rsi, setTransformUniforms, sma, spectrogram, toColorCss, trueRange, uniformLocations, volumeProfile, vwap, withMinorTicks, wma };