@abdullahjaswal/tickyr-charts 0.1.0

package/dist/react.d.ts

@@ -0,0 +1,3741 @@
+import * as React_2 from 'react';
+
+/** Allocate a Float64-backed buffer using `SharedArrayBuffer` when
+ *  available, falling back to a regular `Float64Array`. The returned
+ *  array's `.buffer` is `SharedArrayBuffer` in the fast path; callers
+ *  that want to be sure should check `.buffer instanceof SharedArrayBuffer`. */
+export declare function allocSharedFloat64(length: number): Float64Array;
+
+/** Allocate a Uint32-backed buffer using `SharedArrayBuffer` when
+ *  available, falling back to a regular `Uint32Array`. */
+export declare function allocSharedUint32(length: number): Uint32Array;
+
+declare interface Anchor {
+    /** Time in ms since the epoch. */
+    t: number;
+    /** Price (in the chart's price scale). */
+    y: number;
+}
+
+/** Apply ARIA attributes to a canvas host element. Idempotent - safe to
+ *  call on every render. */
+export declare function applyAriaAttributes(el: HTMLElement | undefined, opts: {
+    readonly label: string;
+    readonly role?: "img" | "figure";
+    readonly description?: string;
+}): void;
+
+/** Decay velocity by friction `f` over `dtMs`. `f` defaults to 0.95 /
+ *  16ms (≈ ~6% per frame). Returns the new velocity. Below `eps`, the
+ *  caller should stop the animation. */
+export declare function applyInertiaDecay(velocity: number, dtMs: number, friction?: number): number;
+
+export declare type AreaBaseline = "zero" | "first-value" | "last-value" | "min" | "max" | "mean" | "average" | "median" | number | ((window: Float64Array) => number);
+
+export declare function AreaChart(props: AreaChartProps): React_2.ReactElement;
+
+export declare interface AreaChartProps extends Omit<LineChartProps, "areaFill"> {
+    /** Where the bottom of the fill anchors. Default `'min'` (visible window's
+     *  lowest value). See `AreaBaseline` for all 9 modes. */
+    baseline?: AreaBaseline;
+    /** Solid alpha fill (`'flat'`) or vertical gradient that fades to 0 at the
+     *  baseline (`'gradient'`). Default `'flat'` (clean read, low-tier-friendly). */
+    fillType?: AreaFillType;
+    /** 0–1. Alpha for `'flat'`; top-stop alpha for `'gradient'`. Default 0.6. */
+    fillOpacity?: number;
+    /** Optional color split at a y-value. **`false`** (default) = single-color
+     *  fill. **`true`** = split at the resolved baseline (or 0 when baseline
+     *  is non-numeric), `aboveColor=palette.up`, `belowColor=palette.down`.
+     *  **Config** = explicit value and/or custom above/below colors. The line
+     *  stroke is also color-split for a consistent above/below read. */
+    thresholdFill?: ThresholdFill;
+    /** Multi-series stacking mode (requires the `series` prop with 2+
+     *  entries; ignored otherwise).
+     *  - `false` (default): each series renders an overlapping independent
+     *    fill from the resolved baseline.
+     *  - `true`: additive stacking - each band stacks on the previous; the
+     *    sum at each x is visualized.
+     *  - `'normalized'`: 100%-stacked - every column normalizes to 1 so the
+     *    chart shows percentage breakdown. The y-axis becomes [0, 1].
+     *  Stacked modes require all series to share the same `times` view; the
+     *  lib validates this once at the public API boundary and throws a
+     *  descriptive error otherwise. */
+    stacked?: StackingMode;
+}
+
+/** Area-fill configuration. AreaChart sets this; LineChart renders it as a
+ * polygon between the line and a horizontal `baseline` y-value. Internal -
+ * LineChart's public surface intentionally has no area fill (that's
+ * <AreaChart>'s defining feature). Reused via `<AreaChart>` which forwards this transparently. */
+declare interface AreaFillConfig {
+    baseline: AreaBaseline;
+    fillType: "flat" | "gradient";
+    fillOpacity: number;
+    /** Optional threshold split. When set, the area fill renders as two
+     *  polygons (above + below threshold) and the line stroke is split too.
+     *  Mutually exclusive with `stacked`; when
+     *  both are set, `stacked` wins (threshold becomes a no-op). */
+    threshold?: AreaFillThreshold;
+    /** Multi-series stacking mode. Resolved form (AreaChart maps user-facing
+     *  `false | true | 'normalized'` to `false | 'additive' | 'normalized'`).
+     *  - `false` (default): non-stacked. With 2+ series, each band fills
+     *    independently from the resolved baseline (overlapping fills).
+     *  - `'additive'`: bands stack, total = sum at each x.
+     *  - `'normalized'`: bands stack, total = 1 (100%) at each x. */
+    stacked?: false | "additive" | "normalized";
+}
+
+declare interface AreaFillThreshold {
+    /** Domain-space y to split at. `undefined` → use the resolved baseline. */
+    readonly value: number | undefined;
+    /** Pre-resolved CSS rgba string for above-threshold runs. */
+    readonly aboveColor: string;
+    /** Pre-resolved CSS rgba string for below-threshold runs. */
+    readonly belowColor: string;
+}
+
+export declare type AreaFillType = "flat" | "gradient";
+
+export declare interface AtrSpecInput extends IndicatorPaneCommon {
+    type: "atr";
+    period?: number;
+}
+
+export declare const AUTO_OPACITY_THRESHOLDS: ReadonlyArray<{
+    readonly count: number;
+    readonly opacity: number;
+}>;
+
+export declare type AxisLabelsMode = "both" | "x-only" | "y-only" | "none";
+
+export declare function BarChart(props: BarChartProps): React_2.ReactElement;
+
+/** Framework-agnostic BarChart prop shape. Excludes the `tooltip` render-
+ *  prop field that each framework adapter retypes against its native JSX
+ *  element type. The controller's `BarChartControllerProps` extends this
+ *  with an `unknown`-returning tooltip so both adapters' shapes are
+ *  structurally assignable via covariance. */
+declare interface BarChartBaseProps {
+    /** Bar data - single series (categories + values). Mutually
+     *  exclusive with `series` for multi-series. */
+    data?: BarChartSeriesInput;
+    /** Multi-series mode: multiple parallel series. Layout follows
+     *  `grouping` (grouped / stacked / normalized). */
+    series?: readonly BarSeriesConfig[];
+    /** Multi-series layout: `"grouped"` (side-by-side bars per
+     *  category), `"stacked"` (vertically stacked), `"normalized"`
+     *  (stacked to 100%). */
+    grouping?: BarGrouping;
+    /** Padding between bar groups (0–1 fraction of slot width). */
+    groupPadding?: number;
+    /** Chart orientation: `"vertical"` (default, value on y) or
+     *  `"horizontal"` (value on x). */
+    orientation?: Orientation;
+    /** Render the bar value as a text label on/near the bar. */
+    valueLabels?: ValueLabels;
+    /** Legend visibility. */
+    legend?: LegendVisibility;
+    /** Legend anchor corner. */
+    legendPosition?: LegendPosition;
+    /** Toggle crosshair on hover. */
+    crosshairVisible?: boolean;
+    /** Crosshair line style. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape. */
+    crosshairMarker?: CrosshairMarker;
+    /** Chart width in CSS px. Default 800. */
+    width?: number;
+    /** Chart height in CSS px. Default 300. */
+    height?: number;
+    /** Color theme. */
+    theme?: ThemeInput;
+    /** Palette name. */
+    palette?: string;
+    /** `"Fill"` (default) or `"Outline"`. */
+    visualStyle?: "Fill" | "Outline";
+    /** Outline-mode fill color. */
+    outlineFillColor?: "auto" | string;
+    /** Outline-mode fill opacity (0–100). */
+    outlineFillOpacity?: number;
+    /** Cap the DPR. */
+    pixelDensityCap?: number;
+    /** Skip cosmetic features for low-end devices. */
+    fastMode?: boolean;
+    /** Direction-colored aura behind marks. */
+    glow?: GlowInput;
+    /** Glow color rule. `"auto"` = direction-derived. */
+    glowColor?: GlowColorInput;
+    /** Pattern fills (hatch, dots, etc.). */
+    pattern?: PatternInput;
+    /** Pattern scale multiplier. */
+    patternScale?: number;
+    /** Pattern color rule. `"auto"` = derived from bar color. */
+    patternColor?: PatternColorInput;
+    /** Force sparkline mode. */
+    sparkline?: boolean;
+    /** Override the auto-generated `aria-label`. */
+    ariaLabel?: string;
+    /** Toggle axis labels + spine. */
+    axisVisible?: boolean;
+    /** Value-axis position (depends on `orientation`). */
+    yAxisPosition?: YAxisPosition;
+    /** Category-axis position. */
+    xAxisPosition?: XAxisPosition;
+    /** Padding above/below the value-axis data range (fraction). */
+    yAxisPadding?: number;
+    /** Toggle gridlines. */
+    gridVisible?: boolean;
+    /** Gridline style. */
+    gridStyle?: GridStyle;
+    /** Gridline density. */
+    gridDensity?: "sparse" | "normal" | "dense";
+    /** Use accent tint for axis + grid. */
+    accents?: boolean;
+    /** Locale code. */
+    locale?: string;
+    /** IANA time zone. */
+    timeZone?: string;
+    /** Fraction of slot width consumed by the bar body (0–1).
+     *  Default 0.7. */
+    barWidthRatio?: number;
+    /** Bar corner radius in CSS px. Default 3. */
+    cornerRadius?: number;
+    /** Bar border width in CSS px. */
+    borderWidth?: number;
+    /** Digit-grouping rule (`"thousands"` / `"lakh-crore"` / `"none"`). */
+    digitGrouping?: DigitGrouping;
+    /** Compact number abbreviation rule. */
+    numberAbbreviation?: NumberAbbreviation;
+    /** Decimal-place rule for value labels. */
+    decimalPlaces?: DecimalPlaces;
+    /** ISO currency code. */
+    currency?: string;
+    /** Currency display style. */
+    currencyDisplay?: CurrencyDisplay;
+    /** Percentage precision. */
+    percentPrecision?: PercentPrecision;
+    /** Date format rule for time-axis category labels. */
+    dateFormat?: DateFormat;
+    /** Time format rule. */
+    timeFormat?: TimeFormat;
+}
+
+/** React BarChart prop shape. Extends the framework-agnostic
+ *  `BarChartBaseProps` (in `charts/bar-chart-helpers.ts`) with the React-
+ *  specific `tooltip` field whose return type is `React.ReactNode`. */
+export declare interface BarChartProps extends BarChartBaseProps {
+    tooltip?: BarChartTooltipProp;
+}
+
+/** Public input shape - same SoA + AoS pair as LineChart so hosts can
+ *  share data pipelines between line / area / bar without re-shaping. */
+export declare type BarChartSeriesInput = LineSeriesInput;
+
+/** Polymorphic tooltip prop. `undefined` (default) → built-in tooltip;
+ *  `false` → suppress; function → custom render. */
+export declare type BarChartTooltipProp = undefined | false | ((props: BarChartTooltipProps) => React_2.ReactNode);
+
+/** Props passed to a custom tooltip render function. Mirrors
+ *  `LineChartTooltipProps` but tailored to bar geometry (no
+ *  threshold-fill semantics; bar-snap uses the slot index). */
+export declare interface BarChartTooltipProps {
+    /** Time at the hovered bar (unix-ms). */
+    readonly t: number;
+    /** Bar index (0-based). */
+    readonly idx: number;
+    /** Per-series values at this x. */
+    readonly seriesValues: readonly BarTooltipSeriesValue[];
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+declare type BarEntryAnimation = "none" | "spring" | "fade" | "fade-stagger-left" | "fade-stagger-right" | "grow-from-baseline" | "rise-from-low" | "slide-from-right" | "slide-from-top" | "scale" | "expand-x" | "wave" | "wipe" | "random-fade";
+
+/** Multi-series rendering mode. */
+export declare type BarGrouping = "clustered" | "stacked" | "normalized" | "overlapping";
+
+/** Multi-series config - one entry per side-by-side bar at each x-slot.
+ *  Without per-series `color`, the lib auto-
+ *  cycles `palette.categorical[i]`. All series MUST share the same `times`
+ *  view (validated at the public API boundary). */
+export declare interface BarSeriesConfig {
+    readonly id: string;
+    readonly data: BarChartSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+}
+
+/** Per-series value at the hover slot - every visible series at that x. */
+export declare interface BarTooltipSeriesValue {
+    readonly id: string;
+    readonly label: string;
+    readonly color: string;
+    readonly value: number;
+}
+
+declare type BarUpdateAnimation = "none" | "morph + flash-direction" | "morph" | "flash-neutral" | "flash-direction" | "pulse" | "glow" | "tick-line" | "flicker" | "rise";
+
+/** Common props every tooltip in the lib receives. Chart-specific
+ *  tooltips extend this with their `target` payload (hovered point,
+ *  candle, slice, etc.). */
+export declare interface BaseTooltipProps {
+    /** Pointer position relative to the chart container, CSS px. */
+    readonly pointerX: number;
+    readonly pointerY: number;
+    /** Container dimensions, CSS px. */
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    /** Active theme + palette at the time of hover. */
+    readonly theme: Theme;
+    readonly palette: Palette;
+    /** Active locale + timezone for value formatting. */
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+}
+
+export declare type BinAlgorithm = "sturges" | "freedman-diaconis" | "scott" | "fixed";
+
+declare interface BinaryCandleSeriesInput {
+    times: Float64Array;
+    opens: Float64Array;
+    highs: Float64Array;
+    lows: Float64Array;
+    closes: Float64Array;
+    volumes?: Float64Array;
+}
+
+export declare type BoxSizingInput = number | `atr-${number}` | `percent-${number}` | {
+    readonly type: "fixed";
+    readonly value: number;
+} | {
+    readonly type: "atr";
+    readonly period: number;
+} | {
+    readonly type: "percent";
+    readonly value: number;
+};
+
+/** Accept brand input as OKLCH or hex string. */
+export declare type BrandInput = Oklch | string;
+
+export declare type BubbleScale = "linear" | "sqrt";
+
+export declare const BULK_BAR_THRESHOLD = 5000;
+
+declare interface Candle {
+    t: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v?: number;
+}
+
+export declare const CandleChart: React_2.ForwardRefExoticComponent<CandleChartProps & React_2.RefAttributes<CandleChartHandle>>;
+
+/** Framework-agnostic CandleChart prop shape. Excludes the eight render-
+ *  prop fields (`tooltip`, `extremeTooltip`, `volumeBarTooltip`,
+ *  `staleBanner`, `signalTooltip`, `orderTooltip`, `positionTooltip`,
+ *  `eventTooltip`) that each framework adapter retypes against its
+ *  native JSX element type. The controller's `CandleChartControllerProps`
+ *  extends this with `unknown`-returning render props so both adapters'
+ *  shapes are structurally assignable via covariance. */
+declare interface CandleChartBaseProps {
+    /** Required. OHLC(V) bars - either structured (`{ candles: Array<{t,o,h,l,c,v?}> }`)
+     *  or binary (per-field `Float64Array`). The binary path is zero-copy. */
+    data: CandleSeriesInput;
+    /** Older bars prepended to `data` for indicator warm-up. Same shape
+     *  as `data`. Lets RSI/MACD/etc. have priors so the visible window
+     *  starts post-warmup with non-NaN values. */
+    historyData?: CandleSeriesInput;
+    /** When `true` (default) and the dynamic
+     *  layer is above ~200×200 px, dirty-rect repaints clip the clear +
+     *  draw to V-strip + H-strip + live-bar regions instead of clearing
+     *  the entire canvas. Set `false` to force full-layer repaints. */
+    partialRepaints?: boolean;
+    /** VWAP price-overlay computed by the engine. When set,
+     *  the engine's `vwap(highs, lows, closes, volumes, sessionStarts)`
+     *  is computed once per data update and rendered as a line on the
+     *  price pane. Requires `data.volumes` - silently skipped when
+     *  volumes are absent. */
+    vwap?: {
+        /** Defaults to `true` when the `vwap` prop is present. */
+        visible?: boolean;
+        /** `"auto"` pulls from `palette[theme].indicators.vwap`. */
+        color?: "auto" | string;
+        /** Defaults to `indicatorLineWidth` from personalization. */
+        lineWidth?: number;
+        /** Session breakpoints - strictly-increasing indices into the
+         *  times array. Defaults to `[0]` (whole series is one session). */
+        sessionStarts?: Uint32Array;
+    };
+    /** Engine-backed streaming mode. When
+     *  set, `chart.onTick(t, p, s)` routes through the engine's
+     *  `Engine.pushTick` for validate-then-aggregate semantics:
+     *
+     *  - **Validation** - rejects non-positive prices, out-of-range
+     *    price/volume, backward timestamps (per the anomaly policy).
+     *  - **Bucket transitions** - engine returns `MutateLast` (extend
+     *    current bar) or `AppendNew` (current bar closed; new one opens)
+     *    so the controller correctly extends the series past the live bar.
+     *  - **Anomaly + audit + telemetry** - pass-through to the engine's
+     *    `setAnomalyPolicy` / `setAuditCallback` / `setTelemetryCallback`.
+     *
+     *  When omitted, `onTick` falls back to JS-side last-bar-only
+     *  mutation (suitable for hosts that own bar progression and just
+     *  want intra-bar high/low/close updates). */
+    streaming?: {
+        /** Timeframe in minutes. Must match the data's bar spacing. */
+        timeframeMinutes: number;
+        /** Market spec - controls session-aware bucketing. */
+        market: "equity" | "dst-equity" | "crypto-24-7";
+        /** Completed-candle ring capacity. */
+        capacity?: number;
+        /** Validator bounds (scaled-integer per `Market::price_scale.decimals`). */
+        minPriceRaw?: number;
+        maxPriceRaw?: number;
+        maxVolumeRaw?: number;
+        /** Optional anomaly policy. Each field accepts a negative value to
+         *  disable that specific check. */
+        anomaly?: {
+            maxRelativePriceJump?: number;
+            rejectZeroVolumeTrade?: boolean;
+            clockSkewToleranceMs?: number;
+            maxGapMs?: number;
+        };
+        /** Observability callbacks - wired into the engine's audit /
+         *  telemetry surfaces. */
+        onAudit?: (kind: number, tsMs: number, priceRaw: number, rejectReasonCode: number) => void;
+        onTelemetry?: (name: string) => void;
+    };
+    /** Candle visual: `"solid"` (default, filled bodies), `"hollow"`
+     *  (down bodies hollow), `"ohlc-bars"` (open/close ticks), or
+     *  `"heikin-ashi"` (smoothed Heikin-Ashi transform). */
+    candleType?: CandleType;
+    /** Fraction of the slot width consumed by the body (0–1). Default
+     *  0.7 - bars touch but don't overlap. */
+    bodyWidthRatio?: number;
+    /** Wick stroke width in CSS px. Default 1.4. */
+    wickWidth?: number;
+    /** Wick color rule: `"body"` (matches body color, default),
+     *  `"neutral"`, `"up"`, `"down"`. */
+    wickColor?: WickColor;
+    /** Minimum body height in CSS px so true-doji bars stay visible.
+     *  Default 1. */
+    dojiMinBodyHeight?: number;
+    /** Toggle the crosshair overlay on hover. Default `true`. */
+    crosshairVisible?: boolean;
+    /** Crosshair line style: `"solid"` / `"dashed"` / `"dotted"`. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape at the data intersection: `"circle"` / `"square"` /
+     *  `"none"`. CandleChart defaults to `"none"`. */
+    crosshairMarker?: CrosshairMarker;
+    /** Last-price horizontal reference line style. Default `"solid"`. */
+    lastPriceLine?: LastPriceLineStyle;
+    /** Show the last price as a pill on the y-axis. Default `true`. */
+    lastPriceLabel?: boolean;
+    /** Visible-range high/low marker mode: `"lines+labels"` (default),
+     *  `"labels"`, `"off"`. */
+    highLowMarkers?: HighLowMarkers;
+    /** Chart width in CSS pixels. Default 800. */
+    width?: number;
+    /** Chart height in CSS pixels. Default 400 (taller than LineChart
+     *  to accommodate the volume sub-pane). */
+    height?: number;
+    /** Color theme - `"light"`, `"dark"`, or `"inherit"`. */
+    theme?: ThemeInput;
+    /** Palette name (`"Monochrome"`, `"Classic"`, etc.). */
+    palette?: string;
+    /** `"Fill"` (default) = solid body fills; `"Outline"` = colored
+     *  border + translucent body fill. */
+    visualStyle?: "Fill" | "Outline";
+    /** In Outline mode, the fill color inside the outlined body. */
+    outlineFillColor?: "auto" | string;
+    /** In Outline mode, alpha of the outline body fill (0–100). */
+    outlineFillOpacity?: number;
+    /** Body corner radius in CSS px. Default 3. */
+    cornerRadius?: number;
+    /** Body border width in CSS px. Default 1.4. */
+    borderWidth?: number;
+    /** Cap the DPR (1–2 typical). */
+    pixelDensityCap?: number;
+    /** Skip cosmetic features for low-end devices. */
+    fastMode?: boolean;
+    /** Force sparkline mode (minimal axis-less render). */
+    sparkline?: boolean;
+    /** Override the auto-generated `aria-label`. */
+    ariaLabel?: string;
+    /** Toggle axis tick labels + spine. Default `true`. */
+    axisVisible?: boolean;
+    /** `"left"` or `"right"`. Default `"right"` for candles. */
+    yAxisPosition?: YAxisPosition;
+    /** `"bottom"` (default) or `"top"`. */
+    xAxisPosition?: XAxisPosition;
+    /** Fractional padding above/below the y-data range. Default 0.05. */
+    yAxisPadding?: number;
+    /** Toggle gridlines. */
+    gridVisible?: boolean;
+    /** Gridline style. */
+    gridStyle?: GridStyle;
+    /** Gridline density. */
+    gridDensity?: "sparse" | "normal" | "dense";
+    /** Use accent tint for axis + grid colors. */
+    accents?: boolean;
+    /** Locale code (e.g. `"USA"`). */
+    locale?: string;
+    /** IANA time zone. */
+    timeZone?: string;
+    /** Digit-grouping rule (`"thousands"` / `"lakh-crore"` / `"none"`). */
+    digitGrouping?: DigitGrouping;
+    /** Compact number abbreviation rule (e.g. `"short"` → `"1.2M"`). */
+    numberAbbreviation?: NumberAbbreviation;
+    /** Decimal-place rule for price labels. */
+    decimalPlaces?: DecimalPlaces;
+    /** ISO currency code (e.g. `"USD"`). */
+    currency?: string;
+    /** Currency display style. */
+    currencyDisplay?: CurrencyDisplay;
+    /** Percentage precision. */
+    percentPrecision?: PercentPrecision;
+    /** Date format rule. */
+    dateFormat?: DateFormat;
+    /** Time format rule. */
+    timeFormat?: TimeFormat;
+    /** Show the volume sub-pane. Requires `data.volumes` to be present.
+     *  Default `true` when volumes exist. */
+    volumeVisible?: boolean;
+    /** Volume placement: `"subpane"` (separate pane below price,
+     *  default) or `"overlay"` (transparent bars on the price pane). */
+    volumePlacement?: VolumePlacement;
+    /** Fraction of inner height given to the volume pane (0–1).
+     *  Default 0.25. */
+    volumeHeightRatio?: number;
+    /** Allow the user to drag the divider between price + volume panes. */
+    volumeResizable?: boolean;
+    /** Volume bar coloring: `"by-direction"` (matches candle direction,
+     *  default), `"single-color"`. */
+    volumeColoring?: VolumeColoring;
+    /** When `volumeColoring === "single-color"`, the bar color. */
+    volumeSingleColor?: "auto" | string;
+    /** Volume y-axis scale: `"linear"` (default) or `"log"`. */
+    volumeScale?: VolumeScale;
+    /** Sync the crosshair vertical line across price + volume +
+     *  indicator panes. Default `true`. */
+    crosshairPaneSync?: boolean;
+    /** Sub-pane indicators: RSI / MACD / Stochastic / ATR. Each becomes
+     *  its own pane below volume. */
+    indicators?: readonly IndicatorPaneSpec[];
+    /** Default line width for indicator lines. */
+    indicatorLineWidth?: number;
+    /** Default line style for indicator lines. */
+    indicatorLineStyle?: IndicatorLineStyle;
+    /** Default opacity for indicator lines (0–1). */
+    indicatorOpacity?: number;
+    /** Live-bar animation. */
+    liveBarIndicator?: LiveBarIndicator;
+    /** Connection-state badge: `"dot"` (default), `"pill"`, `"off"`.
+     *  Renders as an HTML overlay above the chart's plot area. */
+    connectionIndicator?: ConnectionIndicator;
+    /** Visual treatment for stale state. */
+    staleVisualization?: StaleVisualization;
+    /** Auto-stale timeout in ms. Default 5000. */
+    staleThreshold?: number;
+    /** Unix-ms of the latest accepted tick. */
+    liveSince?: number;
+    /** Host-asserted connection state. */
+    connectionState?: LiveState;
+    /** Anchor corner for the badge + legend overlay. */
+    legendPosition?: LegendPosition;
+    /** Host-forced reduced-motion override. */
+    reducedMotion?: boolean;
+    /** Animation when new bars first appear. */
+    barEntryAnimation?: BarEntryAnimation;
+    /** Animation when the live bar updates. */
+    barUpdateAnimation?: BarUpdateAnimation;
+    /** Crosshair fade-in duration (ms) on hover-enter. */
+    crosshairFadeDuration?: number;
+    /** Tooltip fade-in duration (ms). */
+    tooltipFadeDuration?: number;
+    /** Smooth wheel-zoom interpolation. */
+    panZoomSmoothing?: boolean;
+    /** Cross-fade transition when the theme changes. */
+    themeSwitchTransition?: ThemeSwitchTransition;
+    /** Drawing tool annotations (trendlines, fib, horizontal lines, etc.).
+     *  Host-controlled array - push new drawings via `onDrawingsChange`. */
+    drawings?: readonly Drawing[];
+    /** Default stroke color for new drawings. */
+    drawingDefaultColor?: "auto" | string;
+    /** Default stroke width for new drawings. */
+    drawingDefaultLineWidth?: number;
+    /** Default stroke style for new drawings. */
+    drawingDefaultLineStyle?: "solid" | "dashed" | "dotted";
+    /** Default fill opacity for filled drawings. */
+    drawingFillOpacity?: number;
+    /** When to show resize handles: `"always"`, `"on-select"` (default),
+     *  `"on-hover"`. */
+    drawingHandlesMode?: "always" | "on-select" | "on-hover";
+    /** Controlled-mode: id of the currently selected drawing. */
+    selectedDrawingId?: string;
+    /** Whitelist of drawing tool types the user can create. */
+    enabledTools?: readonly DrawingType[];
+    /** Snap mode for drawing tool placement. */
+    drawingSnap?: "free" | "x-axis" | "data";
+    /** Delete the selected drawing when the user presses Esc. */
+    drawingDeleteOnEsc?: boolean;
+    /** Fires when the user adds, modifies, or removes a drawing. */
+    onDrawingsChange?: (next: readonly Drawing[]) => void;
+    /** Fires when the selected drawing changes. */
+    onDrawingSelected?: (id: string | undefined) => void;
+    /** Signal markers (buy/sell arrows + confidence). */
+    signals?: readonly SignalMarker[];
+    /** Signal marker visualization mode. */
+    signalMarkers?: SignalMarkerMode;
+    /** Order markers (open/active orders with entry/SL/TP). */
+    orders?: readonly OrderMarker[];
+    /** Order marker visualization mode. */
+    orderMarkers?: OrderMarkerMode;
+    /** Singleton position marker (current open position). */
+    position?: PositionMarker;
+    /** Position marker visualization mode. */
+    positionMarker?: PositionMarkerMode;
+    /** Event markers (earnings, dividends, splits, news). */
+    events?: readonly EventMarker[];
+    /** Event marker visualization mode. */
+    eventMarkers?: EventMarkerMode;
+    /** Comparison series rendered as a normalized line overlay on the
+     *  price pane. */
+    compareData?: {
+        times: Float64Array;
+        closes: Float64Array;
+    };
+    /** Comparison rendering mode. */
+    symbolComparison?: "off" | "normalized-line";
+    /** Optional watermark - symbol text, symbol + exchange, or an image. */
+    watermark?: "off" | "symbol" | "symbol + exchange" | {
+        image: string;
+    };
+    /** Symbol ticker (e.g. `"AAPL"`) for watermark + tooltip header. */
+    symbol?: string;
+    /** Exchange code (e.g. `"NYSE"`) for watermark + tooltip header. */
+    exchange?: string;
+    /** Color-blind augmentation: `"arrows"` adds direction arrows to
+     *  bar bodies for users who can't distinguish red/green. */
+    colorBlindIndicators?: "off" | "arrows";
+    /** Direction-colored aura on candle bodies. */
+    glow?: GlowInput;
+    /** Glow color. */
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+}
+
+declare interface CandleChartHandle {
+    /** Arm the next pointerdown to start drawing this `type`. */
+    startDrawing(type: DrawingType): void;
+    /** Abort the in-flight tool selection (no shape committed). */
+    cancelDrawing(): void;
+    /** Whether a drawing tool is currently armed. */
+    readonly isDrawing: boolean;
+    /** Push a live tick (primitive args).
+     *  Updates the high/low/close of the most recent bar in-place.
+     *  Multiple ticks per rAF coalesce into one static draw. */
+    onTick(time: number, price: number, size?: number): void;
+}
+
+/** React CandleChart prop shape. Extends the framework-agnostic
+ *  `CandleChartBaseProps` (in `charts/candle-chart-helpers.ts`) with the
+ *  eight render-prop fields whose return type is `React.ReactNode`. */
+export declare interface CandleChartProps extends CandleChartBaseProps {
+    tooltip?: CandleChartTooltipProp;
+    extremeTooltip?: ExtremeTooltipProp;
+    volumeBarTooltip?: boolean | ((props: {
+        bar: {
+            t: number;
+            v: number;
+            idx: number;
+        };
+        avg20: number;
+        percentile: number;
+    }) => React_2.ReactNode);
+    staleBanner?: CandleStaleBannerProp;
+    signalTooltip?: false | ((p: SignalTooltipProps) => React_2.ReactNode);
+    orderTooltip?: false | ((p: OrderTooltipProps) => React_2.ReactNode);
+    positionTooltip?: false | ((p: PositionTooltipProps) => React_2.ReactNode);
+    eventTooltip?: false | ((p: EventTooltipProps) => React_2.ReactNode);
+}
+
+/** Polymorphic tooltip prop. `undefined` (default) → built-in OHLC
+ *  tooltip; `false` → suppress; function → custom render. */
+export declare type CandleChartTooltipProp = undefined | false | ((props: CandleChartTooltipProps) => React_2.ReactNode);
+
+/** Props passed to a custom CandleChart OHLC tooltip render function (and
+ *  to the built-in `DefaultCandleTooltip`). Framework-agnostic data shape. */
+export declare interface CandleChartTooltipProps {
+    /** Time at the active hover position (unix-ms). */
+    t: number;
+    /** Bar index in the candle series (0-based). */
+    idx: number;
+    /** Open / High / Low / Close at the hover bar. For Heikin-Ashi mode
+     *  these are the HA-transformed values (what the chart is actually
+     *  rendering); the tooltip stays consistent with what's on screen. */
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    /** Direction at hover - `'up'` if `c >= o`, `'down'` if `c < o`,
+     *  `'doji'` if the body collapsed below the floor and rendered with
+     *  `palette.doji`. */
+    direction: CandleDirection;
+    /** Pointer position in CSS pixels relative to the chart container. */
+    pointerX: number;
+    pointerY: number;
+    /** Container dimensions for placement decisions. */
+    containerWidth: number;
+    containerHeight: number;
+    theme: Theme;
+    palette: Palette;
+    locale: string;
+    timeZone: string | undefined;
+    formatter: ChartFormatter;
+}
+
+/** Direction signal for the OHLC bar at hover. `'doji'` when the
+ *  source-data |O−C| would render below `dojiMinBodyHeight` and the chart
+ *  is showing the doji floor in `palette.doji`. */
+export declare type CandleDirection = "up" | "down" | "doji";
+
+declare type CandleSeriesInput = {
+    candles: readonly Candle[];
+} | BinaryCandleSeriesInput;
+
+/** Polymorphic prop:
+ *   `undefined | true` - built-in amber pill with pause icon
+ *   `false`            - no banner (overrides staleVisualization)
+ *   function           - custom HTML component (lib positions it top-center). */
+declare type CandleStaleBannerProp = boolean | ((props: CandleStaleBannerRenderProps) => React_2.ReactNode);
+
+declare interface CandleStaleBannerRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    theme: Theme;
+    palette: Palette;
+}
+
+/** `solid` (Japanese candle), `heikin-ashi`
+ *  (smoothed via per-bar transform), `ohlc-bars` (Western tick bar). */
+export declare type CandleType = "solid" | "heikin-ashi" | "ohlc-bars";
+
+export declare type CellShape = "rect" | "circle";
+
+export declare type CenterLabelProp = false | true | string | ((data: DonutCenterLabelData) => React_2.ReactNode);
+
+declare class ChartFormatter {
+    private readonly opt;
+    private readonly resolvedAbbrev;
+    private readonly intlCache;
+    private readonly dateFmt;
+    private readonly timeFmt;
+    constructor(opt: ChartFormatterOptions);
+    private intlFor;
+    formatNumber(n: number, decimalsOverride?: number): string;
+    formatPrice(n: number, decimalsOverride?: number): string;
+    formatPercent(fraction: number, precisionOverride?: number): string;
+    formatDate(t: number): string;
+    formatTime(t: number): string;
+    private buildDateFmt;
+    private buildTimeFmt;
+}
+
+declare interface ChartFormatterOptions {
+    readonly locale: ResolvedLocale;
+    readonly digitGrouping: DigitGrouping;
+    readonly numberAbbreviation: NumberAbbreviation;
+    readonly decimalPlaces: DecimalPlaces;
+    readonly currency: string;
+    readonly currencyDisplay: CurrencyDisplay;
+    readonly percentPrecision: PercentPrecision;
+    readonly dateFormat: DateFormat;
+    readonly timeFormat: TimeFormat;
+    readonly timeZone?: string | undefined;
+}
+
+export declare function ChartGroup(props: ChartGroupProps): React_2.ReactElement;
+
+export declare function ChartGroupBrush(props: ChartGroupBrushProps): React_2.ReactElement;
+
+export declare interface ChartGroupBrushProps {
+    /** Time domain the brush spans (typically the host's full data range). */
+    readonly domain: {
+        start: number;
+        end: number;
+    };
+    /** CSS width in px (caller-controlled). */
+    readonly width?: number;
+    /** CSS height in px. */
+    readonly height?: number;
+    /** Background fill of the unselected track. Defaults to a translucent neutral. */
+    readonly trackColor?: string;
+    /** Fill of the selected (brushed) range. Defaults to translucent palette.up. */
+    readonly selectionColor?: string;
+    /** Stroke color of the brush handles. */
+    readonly handleColor?: string;
+}
+
+declare interface ChartGroupContextValue {
+    readonly options: ChartGroupOptions;
+    readonly state: ChartGroupState;
+    readonly version: number;
+}
+
+export declare function ChartGroupNavigator(props: ChartGroupNavigatorProps): React_2.ReactElement;
+
+export declare interface ChartGroupNavigatorProps {
+    /** Time-series data to render in the minimap. Use the same source data
+     *  as the children for a coherent overview; downsampling is the host's
+     *  responsibility. */
+    readonly data: LineSeriesInput;
+    /** Visible domain - the navigator covers this full range; the brush
+     *  controls a sub-range. Defaults to the data's first/last times. */
+    readonly domain?: {
+        start: number;
+        end: number;
+    };
+    readonly width?: number;
+    readonly height?: number;
+}
+
+export declare interface ChartGroupOptions {
+    /** Sync the visible x-domain across the group. */
+    readonly syncDomain: boolean;
+    readonly syncPanZoom: boolean;
+    readonly syncCrosshair: boolean;
+    readonly syncYScale: SyncYScale;
+    readonly referencePoint: ReferencePoint;
+    readonly syncSelection: boolean;
+    readonly syncTooltip: boolean;
+    /** Whether the group enables a brushable time-range selection. The
+     *  separate `<ChartGroupBrush>` component reads + writes this state. */
+    readonly brush: boolean;
+    /** Whether a `<ChartGroupNavigator>` minimap should engage. */
+    readonly navigator: boolean;
+}
+
+export declare interface ChartGroupProps extends Partial<ChartGroupOptions> {
+    children?: React_2.ReactNode;
+    /** Fired when any child publishes a click-selected time and `syncSelection`
+     *  is on. Receives the new selected time (or null on clear). */
+    onSelectionChange?: (time: number | null) => void;
+    /** Fired when the brush range changes. Receives `{ start, end }` or null. */
+    onBrushChange?: (range: TimeRange | null) => void;
+    /** Vertical-pane resize callback. The lib renders no
+     *  divider chrome itself - host writes the divider; this callback is here
+     *  to round out the API surface for when host-side divider components
+     *  forward their drag events through the group. */
+    onPaneResize?: (heights: readonly number[]) => void;
+}
+
+export declare interface ChartGroupState {
+    /** Last hover-position time observed in any sibling chart. */
+    readonly crosshairTime: number | null;
+    setCrosshairTime(t: number | null): void;
+    /** Last click-selection time. */
+    readonly selectedTime: number | null;
+    setSelectedTime(t: number | null): void;
+    /** Shared visible time-range when `syncDomain: true`. */
+    readonly domain: TimeRange | null;
+    setDomain(d: TimeRange | null): void;
+    /** Shared brush range. */
+    readonly brush: TimeRange | null;
+    setBrush(b: TimeRange | null): void;
+    /** Subscribe to any state change. Returns idempotent unsubscriber. */
+    subscribe(listener: () => void): () => void;
+}
+
+export declare type ChartKind = "line" | "area" | "candle" | "bar" | "renko" | "kagi" | "pnf" | "pie" | "donut" | "treemap" | "sunburst" | "heatmap" | "histogram" | "scatter" | "depth" | "sankey";
+
+export declare function ChartsProvider(props: ChartsProviderProps): React_2.ReactElement;
+
+export declare interface ChartsProviderProps {
+    theme?: ThemeInput;
+    palette?: string;
+    locale?: string;
+    timeZone?: string;
+    visualStyle?: VisualStyle;
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    cornerRadius?: number;
+    borderWidth?: number;
+    accents?: boolean;
+    osTheme?: Theme;
+    appTheme?: Theme;
+    /** Host-supplied custom palettes. Each gets
+     *  registered into the global palette registry on mount; downstream
+     *  charts can reference them by name via the `palette` prop. */
+    palettes?: readonly Palette[];
+    children?: React_2.ReactNode;
+}
+
+export declare interface ChartsProviderValue {
+    theme: ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: VisualStyle;
+    /** Outline-mode interior fill color. `'auto'`
+     *  derives from each mark's own stroke; literal hex/rgba = uniform tint. */
+    outlineFillColor: "auto" | string;
+    /** Outline-mode interior fill opacity (0–100).
+     *  Default 15. Doubled in dark mode at draw time. */
+    outlineFillOpacity: number;
+    /** Corner roundness (CSS px, ≥ 0). Default 3. */
+    cornerRadius: number;
+    /** Body/segment border width (CSS px, ≥ 0). Default 1.4. */
+    borderWidth: number;
+    accents: boolean;
+    osTheme: Theme;
+    appTheme: Theme;
+}
+
+/** Drop every cached offscreen surface. Hosts call this on
+ *  `onLowMemory` / `didReceiveMemoryWarning`. */
+export declare function clearGlowPool(): void;
+
+/** Compile + link a shader program with try/catch - returns `null` on
+ *  failure so the caller can fall back to canvas2d. */
+export declare function compileShaderProgram(gl: WebGL2RenderingContext, vsSource: string, fsSource: string): WebGLProgram | null;
+
+/** Connection-indicator modes. */
+declare type ConnectionIndicator = "off" | "dot" | "pill";
+
+/** Polymorphic prop:
+ *   `'off' | 'dot' | 'pill'`  - built-in canvas badge
+ *   function                  - custom HTML component, lib positions it. */
+declare type ConnectionIndicatorProp = ConnectionIndicator | ((props: ConnectionIndicatorRenderProps) => React_2.ReactNode);
+
+/** Props passed to a custom connection-indicator render-prop. Framework-
+ *  agnostic data shape - the React adapter renders this via a function
+ *  returning `React.ReactNode`; the Solid adapter via `JSX.Element`; the
+ *  controller widens to `unknown`. */
+declare interface ConnectionIndicatorRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    position: LegendPosition;
+    theme: Theme;
+    palette: Palette;
+}
+
+declare type CrosshairMarker = "none" | "circle" | "square";
+
+export declare type CrosshairMode = "follow" | "sticky";
+
+export declare type CrosshairSnap = "free" | "x-axis" | "data";
+
+declare type CurrencyDisplay = "none" | "symbol" | "code";
+
+export declare type CurveType = CurveTypeName | CurveTypeConfig;
+
+export declare interface CurveTypeConfig {
+    readonly type: CurveTypeName;
+    /** 0–1 - only honored for `cardinal`. Default 0. Higher = looser curve. */
+    readonly tension?: number;
+    /** 0–1 - only honored for `catmull-rom`. Default 0.5 (centripetal). */
+    readonly alpha?: number;
+}
+
+export declare type CurveTypeName = "linear" | "monotone" | "monotone-x" | "monotone-y" | "step" | "step-before" | "step-after" | "bump" | "bump-x" | "bump-y" | "natural" | "basis" | "cardinal" | "catmull-rom";
+
+declare type DateFormat = "auto" | "short" | "medium" | "iso";
+
+declare type DecimalPlaces = "auto" | number;
+
+export declare const DEFAULT_AXIS_LABELS: AxisLabelsMode;
+
+export declare const DEFAULT_BIN_ALGORITHM: BinAlgorithm;
+
+export declare const DEFAULT_BOX_SIZING: ResolvedBoxSizing;
+
+export declare const DEFAULT_BUBBLE_RANGE_PX: readonly [number, number];
+
+export declare const DEFAULT_CELL_SHAPE: CellShape;
+
+export declare const DEFAULT_DEPTH_FILL_TYPE: DepthFillType;
+
+export declare const DEFAULT_GLOW: GlowInput;
+
+export declare const DEFAULT_GLOW_COLOR: GlowColorInput;
+
+export declare const DEFAULT_GPU_RENDERER: GpuRendererInput;
+
+export declare const DEFAULT_HEATMAP_COLOR_SCALE: HeatmapColorScaleType;
+
+export declare const DEFAULT_KAGI_THICKNESS_RULE: KagiThicknessRule;
+
+export declare const DEFAULT_LABEL_BEHAVIOR: LabelBehavior;
+
+export declare const DEFAULT_LABEL_CONTENT: LabelContentPreset;
+
+export declare const DEFAULT_LABEL_PLACEMENT: LabelPlacement;
+
+export declare const DEFAULT_LABEL_ROTATION: LabelRotation;
+
+export declare const DEFAULT_LONG_PRESS_BEHAVIOR: LongPressBehavior;
+
+export declare const DEFAULT_NODE_ALIGNMENT: NodeAlignment;
+
+export declare const DEFAULT_NULL_BEHAVIOR: NullBehavior;
+
+export declare const DEFAULT_NUMBER_FORMAT: NumberFormatPreset;
+
+export declare const DEFAULT_PAN_ZOOM_OPTIONS: PanZoomOptions;
+
+export declare const DEFAULT_PATTERN: PatternInput;
+
+export declare const DEFAULT_PATTERN_COLOR: PatternColorInput;
+
+export declare const DEFAULT_PATTERN_SCALE = 1;
+
+export declare const DEFAULT_PNF_SYMBOL_STYLE: PnFSymbolStyle;
+
+export declare const DEFAULT_POINT_SIZE_PX = 9;
+
+export declare const DEFAULT_PRICE_RANGE_PCT = 0.05;
+
+export declare const DEFAULT_RADIUS_PROPORTION: RadiusProportion;
+
+export declare const DEFAULT_SANKEY_LINK_COLOR: SankeyLinkColorPreset;
+
+export declare const DEFAULT_SANKEY_VALUE_DISPLAY: SankeyValueDisplayMode;
+
+export declare const DEFAULT_SORT_ORDER: SortOrder;
+
+export declare const DEFAULT_SPREAD_DISPLAY: SpreadDisplayMode;
+
+export declare const DEFAULT_TILE_LAYOUT: TileLayout;
+
+export declare const DEFAULT_TIME_OFF_SOURCE: TimeOffSource;
+
+export declare const DEFAULT_TREEMAP_COLOR_SCALE: TreemapColorScale;
+
+export declare const DEFAULT_VIEW_MODE: ViewMode;
+
+export declare const DEFAULT_Y_AXIS_MODE: YAxisMode;
+
+/** Default `aria-label` template. Concise + readable; hosts
+ *  override via `ariaLabel` prop when they have more context. */
+export declare function defaultAriaLabel(opts: {
+    readonly kind: ChartKind;
+    readonly seriesCount?: number;
+    readonly markCount?: number;
+    readonly symbol?: string;
+}): string;
+
+export declare function DefaultCandleTooltip(props: CandleChartTooltipProps): React_2.ReactElement;
+
+/** Built-in tooltip rendered on H/L pill hover when the host doesn't
+ *  override `extremeTooltip`. Lightweight - labels the kind ("High" /
+ *  "Low") and shows price + bar index. Hosts can pass a function for
+ *  full custom render or `false` to suppress. */
+export declare function DefaultExtremeTooltip(p: ExtremeTooltipProps): React_2.ReactElement;
+
+export declare function DefaultTooltip(props: LineChartTooltipProps): React_2.ReactElement;
+
+export declare function DefaultVolumeBarTooltip(props: VolumeBarTooltipProps): React_2.ReactElement;
+
+export declare const DENSITY_AUTO_THRESHOLD = 50000;
+
+export declare type DensityInput = "off" | "auto" | "on";
+
+export declare type DensityRenderMode = "points" | "heatmap";
+
+export declare function DepthChart(props: DepthChartProps): React_2.ReactElement;
+
+declare interface DepthChartBaseProps {
+    /** Orderbook data - bids + asks parallel typed arrays. */
+    data?: DepthSeriesInput;
+    /** Default 'auto' (±5%). */
+    priceRange?: PriceRangeInput;
+    /** Default true (solid neutral line). */
+    midLine?: MidLineInput;
+    /** Default 'pill'. */
+    spreadDisplay?: SpreadDisplayInput;
+    /** Default true. */
+    cumulative?: boolean;
+    /** Default 'gradient'. */
+    fillType?: DepthFillType;
+    /** Default false. */
+    levelHighlight?: LevelHighlightInput;
+    /** Per-level data for `levelHighlight` - host-supplied. */
+    highlightLevels?: ReadonlyArray<{
+        readonly price: number;
+        readonly label?: string;
+    }>;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface DepthChartProps extends DepthChartBaseProps {
+    tooltip?: DepthChartTooltipProp;
+}
+
+export declare type DepthChartTooltipProp = undefined | false | ((props: DepthChartTooltipProps) => React_2.ReactNode);
+
+export declare interface DepthChartTooltipProps {
+    /** Which side the cursor is over. */
+    readonly side: "bid" | "ask";
+    /** Price at the cursor's x. */
+    readonly price: number;
+    /** Cumulative volume at that price (the chart's y value). */
+    readonly cumulativeVolume: number;
+    /** Distance from the mid price as a fraction (e.g. -0.025 = 2.5% below mid). */
+    readonly pctFromMid: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type DepthFillType = "flat" | "gradient";
+
+export declare interface DepthLevel {
+    readonly price: number;
+    readonly size: number;
+}
+
+export declare type DepthLimitInput = number | "all";
+
+export declare interface DepthSeriesInput {
+    readonly bids: readonly DepthLevel[] | {
+        readonly prices: Float64Array;
+        readonly sizes: Float64Array;
+    };
+    readonly asks: readonly DepthLevel[] | {
+        readonly prices: Float64Array;
+        readonly sizes: Float64Array;
+    };
+}
+
+/** Generate the chart-chrome accent tint. Per the built-ins, the accent
+ *  is a desaturated version of the brand pulled toward neutral so it
+ *  reads as "muted ink" against the chart background while still
+ *  carrying the brand hue. */
+export declare function deriveAccentTint(brand: BrandInput): Oklch;
+
+/** Generate `n` categorical colors by rotating hue around the brand.
+ *  The brand color sits at slot 0; subsequent slots step `360 / n`
+ *  degrees around the OKLCH hue wheel while preserving the brand's L
+ *  and C. Palettes are expected to define a usable
+ *  categorical array (used by multi-series, pie/donut, treemap, etc.).
+ *
+ *  Tunable count - defaults to 8 which matches the built-in palettes. */
+export declare function deriveCategoricalSet(brand: BrandInput, count?: number): readonly Oklch[];
+
+export declare function deriveDefaultPalette(brand: BrandInput, opts: DeriveDefaultPaletteOptions): Palette;
+
+/** Build a complete `Palette` from a brand color. Generates both
+ *  `light` and `dark` variants by calling `deriveVariant` twice with
+ *  theme-tuned L/C. */
+export declare interface DeriveDefaultPaletteOptions {
+    readonly name: string;
+    readonly tonalSymmetrySide?: TonalSymmetrySide;
+    readonly tonalSymmetryFlipInDarkMode?: boolean;
+}
+
+/** Build a `PaletteVariant` (one of `light` or `dark`) from a brand
+ *  color. Uses opinionated L/C tuning matching the built-in
+ *  Monochrome / Classic / Accessible variants:
+ *    - Light theme - up/down at L ≈ 0.70, C ≈ 0.18.
+ *    - Dark theme  - brightened L ≈ 0.78, C ≈ 0.20 for AA contrast.
+ *  Hue derives from the brand. Categorical = 8-step hue rotation. */
+export declare function deriveVariant(brand: BrandInput, theme: "light" | "dark"): PaletteVariant;
+
+/** Detect the FastModeContext from `navigator` + `matchMedia`. Safe to
+ *  call during SSR (returns an empty context). */
+export declare function detectFastModeContext(): FastModeContext;
+
+/** Heuristic - when `true`, treat the device as primarily touch
+ *  (collapses crosshair to pin-on-click, opt-in pinch zoom, etc.). */
+export declare function detectTouchOnly(): boolean;
+
+declare type DigitGrouping = "international" | "lakh-crore" | "none";
+
+/** Fixed-capacity ring of dirty rects. Caller pushes rects throughout
+ *  the frame; the consumer calls `flushCoalesced()` to get the merged
+ *  rect (null when empty). */
+export declare class DirtyRectRing {
+    private xs;
+    private ys;
+    private ws;
+    private hs;
+    private idx;
+    private filled;
+    push(x: number, y: number, w: number, h: number): void;
+    /** Merge all pending rects into a single bounding box. Resets the
+     *  ring. Returns `null` when there's nothing pending. */
+    flushCoalesced(): Rect | null;
+    /** Flush all pending rects into `out` (length = number of rects).
+     *  The caller owns the array - pass a reused
+     *  scratch to avoid allocation. Returns count of populated entries.
+     *  Resets the ring. */
+    flushAll(out: Rect[]): number;
+    /** Discard any pending rects without producing a flush. */
+    clear(): void;
+    size(): number;
+}
+
+declare interface DivergingConfig {
+    readonly type: "diverging";
+    /** Value mapped to the neutral mid-point. Default 0. */
+    readonly midpoint?: number;
+    /** `[low, high]` data range. When omitted, auto-fits to the data's
+     *  symmetric extent at compute time. */
+    readonly domain?: readonly [number, number];
+}
+
+/** Donut adds a centerLabel slot - string, ComponentType, or render-prop -
+ *  rendered as a positioned overlay inside the donut hole. */
+export declare interface DonutCenterLabelData {
+    readonly totalValue: number;
+    readonly formatter: ChartFormatter;
+    readonly theme: Theme;
+    readonly palette: Palette;
+}
+
+export declare function DonutChart(props: DonutChartProps): React_2.ReactElement;
+
+export declare interface DonutChartProps extends PieChartProps {
+    centerLabel?: CenterLabelProp;
+}
+
+export declare type DowngradeLevel = 0 | 1 | 2 | 3;
+
+export declare function downgradeOverrides(level: DowngradeLevel): RenderConfigOverrides;
+
+declare interface Drawing {
+    readonly id: string;
+    readonly type: DrawingType;
+    /** Anchors in data coordinates. Cardinality varies by type:
+     *  - 1: horizontal-line (y), vertical-line (t)
+     *  - 2: trend-line, rectangle, ellipse, arrow, text (single anchor
+     *       point + style.text), fib-retracement, fib-extension, brush
+     *  - 3: pitchfork, channel
+     *  Validation is host-side at construction; the chart trusts the
+     *  cardinality for the type it sees. */
+    readonly anchors: readonly Anchor[];
+    readonly style: DrawingStyle;
+    /** Optional metadata for host bookkeeping; not used by the chart. */
+    readonly meta?: Record<string, unknown>;
+}
+
+declare interface DrawingStyle {
+    /** Stroke / fill base color (resolved CSS string OR `'auto'` to use
+     *  the active palette's `drawings.stroke` slot). */
+    color?: string | "auto";
+    lineWidth?: number;
+    lineStyle?: "solid" | "dashed" | "dotted";
+    fillOpacity?: number;
+    /** Trend-line + arrow only - bool toggles arrowhead at the second
+     *  anchor. */
+    arrowhead?: boolean;
+    /** Text-drawing only. */
+    text?: string;
+    fontSize?: number;
+}
+
+declare type DrawingType = "trend-line" | "horizontal-line" | "vertical-line" | "rectangle" | "ellipse" | "arrow" | "text" | "fib-retracement" | "fib-extension" | "pitchfork" | "channel" | "brush";
+
+/** Run the glow compositor. When `glow.strength === 0`, this is a thin
+ *  pass-through that only invokes the sharp pass on the main context. */
+export declare function drawWithGlow(mainCtx: CanvasRenderingContext2D, opts: GlowOptions, draw: GlowDrawCallback): void;
+
+declare type EventKind = "earnings" | "dividend" | "split" | "news";
+
+declare interface EventMarker {
+    t: number;
+    kind: EventKind;
+    /** Short label (1-2 chars) for the glyph mode. */
+    glyph?: string;
+    /** Full title for the banner mode. */
+    title?: string;
+    meta?: Record<string, unknown>;
+}
+
+declare type EventMarkerMode = "off" | "glyph-axis" | "vertical-line" | "banner-strip";
+
+declare interface EventTooltipProps {
+    marker: EventMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+
+/** Polymorphic tooltip prop for visible-window high / low pill hover.
+ *
+ * - `true` (default) - built-in `<DefaultExtremeTooltip>`.
+ * - `false` - no tooltip on H/L pill hover.
+ * - function - render-prop receiving `ExtremeTooltipProps`. */
+export declare type ExtremeTooltipProp = boolean | ((props: ExtremeTooltipProps) => React_2.ReactNode);
+
+/** Props passed to a custom extreme-tooltip render function (H/L pill hover).
+ *  Framework-agnostic data shape - same in both React and Solid. */
+export declare interface ExtremeTooltipProps {
+    kind: "high" | "low";
+    /** Bar index in the source series. */
+    barIdx: number;
+    price: number;
+    /** Time at the extreme bar (unix-ms). */
+    t: number;
+    /** Pointer position in CSS pixels relative to the chart container. */
+    pointerX: number;
+    pointerY: number;
+    containerWidth: number;
+    containerHeight: number;
+    theme: Theme;
+    palette: Palette;
+    /** Resolved platform locale (e.g. "en-US"). */
+    locale: string;
+    timeZone: string | undefined;
+    formatter: ChartFormatter;
+}
+
+export declare interface FastModeContext {
+    /** From `navigator.connection.effectiveType` if present. */
+    readonly effectiveType?: string;
+    /** From `navigator.deviceMemory` (GB). */
+    readonly deviceMemory?: number;
+    /** From `matchMedia('(prefers-reduced-motion: reduce)').matches`. */
+    readonly prefersReducedMotion?: boolean;
+}
+
+export declare type FastModeInput = boolean | "auto";
+
+export declare class FrameTimeMonitor {
+    private buf;
+    private idx;
+    private filled;
+    private level;
+    /** Cooldown counter - frames since the last level change. Prevents
+     *  the monitor from chasing its tail and downgrading multiple levels
+     *  in successive frames. */
+    private cooldown;
+    /** Record one frame's duration (ms). Returns the (possibly new) downgrade
+     *  level. Caller checks against the previous level to decide whether to
+     *  bust caches / re-render. */
+    recordFrame(ms: number): DowngradeLevel;
+    /** Current downgrade level (caller reads to apply to render config). */
+    currentLevel(): DowngradeLevel;
+    reset(): void;
+    private computeP95;
+}
+
+/** `'auto'` (default) = each mark glows in its own direction color
+ *  (`up`/`down`/`doji` from the palette). A literal color (any CSS-color
+ *  string, hex, or `oklch(...)`) overrides for uniform brand glow. */
+export declare type GlowColorInput = "auto" | string;
+
+/** Glow-pass draw callback. Called once per pass:
+ *  - `isGlowPass = true` → the caller draws into `ctx` using the halo
+ *    color resolver (or a constant color when `glow.color !== 'auto'`).
+ *    The draw should produce only the *shape mass* of the marks; strokes
+ *    can be thicker than normal for a fuller aura, but no axis chrome.
+ *  - `isGlowPass = false` → the caller draws the actual marks normally on
+ *    top of the glow.
+ *  The `ctx` is already translated so plot-rect origin maps to (0,0) on
+ *  glow passes; the caller does not need to re-apply the translate.
+ */
+export declare type GlowDrawCallback = (ctx: CanvasRenderingContext2D, isGlowPass: boolean) => void;
+
+/** Host-supplied input. Named presets resolve to fixed strengths; numeric
+ *  values clamp to `[0, 1]`. */
+export declare type GlowInput = GlowPreset | number;
+
+export declare interface GlowOptions {
+    readonly glow: ResolvedGlow;
+    readonly theme: Theme;
+    readonly plotRect: GlowPlotRect;
+    /** Device-pixel ratio multiplier for the offscreen surface. Passed
+     *  separately so glow renders crisp on high-DPR displays without
+     *  forcing the caller to re-apply `setTransform`. */
+    readonly dpr: number;
+}
+
+/** Plot-rect (CSS px) - the glow's offscreen surface matches this region
+ *  exactly so blur stays clipped to the plot. */
+export declare interface GlowPlotRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+
+export declare type GlowPreset = "off" | "subtle" | "standard" | "intense";
+
+export declare const GPU_ENGAGE_THRESHOLD = 50000;
+
+export declare interface GpuEngageContext {
+    /** Visible mark count after downsampling. */
+    readonly visibleMarkCount: number;
+    /** Host-resolved `gpuRenderer`. */
+    readonly gpuRenderer: GpuRendererInput;
+}
+
+export declare type GpuRendererInput = "auto" | "on" | "off";
+
+declare type GridStyle = "solid" | "dashed" | "dotted";
+
+export declare function HeatmapChart(props: HeatmapChartProps): React_2.ReactElement;
+
+declare interface HeatmapChartBaseProps {
+    /** Row-major matrix of values to color. See `HeatmapMatrixInput`
+     *  for the row labels / col labels / values shape. */
+    data?: HeatmapMatrixInput;
+    /** Default 'diverging'. */
+    colorScale?: HeatmapColorScaleInput;
+    /** Default 2 px (gapUnit). */
+    cellPadding?: number;
+    /** Default 'rect'. */
+    cellShape?: CellShape;
+    /** Default false. true = auto-contrast text per cell. */
+    valueDisplay?: boolean;
+    /** Default 'both'. */
+    axisLabels?: AxisLabelsMode;
+    /** Default 'cross-hatch'. */
+    nullBehavior?: NullBehavior;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface HeatmapChartProps extends HeatmapChartBaseProps {
+    tooltip?: HeatmapChartTooltipProp;
+}
+
+export declare type HeatmapChartTooltipProp = undefined | false | ((props: HeatmapChartTooltipProps) => React_2.ReactNode);
+
+export declare interface HeatmapChartTooltipProps {
+    readonly row: number;
+    readonly col: number;
+    readonly value: number | null;
+    readonly rowLabel: string;
+    readonly colLabel: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type HeatmapColorScaleInput = HeatmapColorScaleType | DivergingConfig | SequentialConfig | QualitativeConfig;
+
+export declare type HeatmapColorScaleType = "sequential" | "diverging" | "qualitative";
+
+export declare interface HeatmapMatrixInput {
+    /** Number of rows (y-axis cells). */
+    readonly rows: number;
+    /** Number of columns (x-axis cells). */
+    readonly cols: number;
+    /** Cell values, row-major (`values[r * cols + c]`). Length = rows × cols. */
+    readonly values: Float64Array | readonly number[];
+    /** Optional per-row labels (length = rows). When omitted, row indices. */
+    readonly rowLabels?: readonly string[];
+    /** Optional per-column labels (length = cols). When omitted, column indices. */
+    readonly colLabels?: readonly string[];
+    /** Optional null mask, row-major (`1` = null cell, `0` = value). */
+    readonly nullMask?: Uint8Array | readonly number[];
+}
+
+/** Convert a sRGB hex string (`#rrggbb` or `#rgb`) to OKLCH. */
+export declare function hexToOklch(hex: string): Oklch;
+
+export declare interface HierarchyNode {
+    readonly name: string;
+    /** Optional explicit value. Internal-node values are always overridden
+     *  by the sum of leaf-descendant values (treemap layout invariant). */
+    readonly value?: number;
+    /** Optional CSS color override; auto-cycle through palette.categorical. */
+    readonly color?: string;
+    /** Optional signed percent change (e.g. `-2.2`,
+     *  `1.7`). When supplied, drives the `'directional'` color scale + the
+     *  `'ticker'` label preset (▲/▼ glyph + magnitude). Internal-node deltas
+     *  are computed at ingest time as the value-weighted average of leaf
+     *  descendants. */
+    readonly delta?: number;
+    /** Optional secondary line rendered below the name in 'ticker' label
+     *  layout (e.g. company name beneath the symbol). */
+    readonly sublabel?: string;
+    readonly children?: readonly HierarchyNode[];
+}
+
+/** Marker mode for the visible-window high / low. */
+export declare type HighLowMarkers = "off" | "lines+labels" | "labels-only";
+
+export declare function HistogramChart(props: HistogramChartProps): React_2.ReactElement;
+
+declare interface HistogramChartBaseProps {
+    /** Distribution data - raw values that will be binned by the
+     *  configured algorithm. See `HistogramSeriesInput`. */
+    data?: HistogramSeriesInput;
+    /** Default 'freedman-diaconis'. */
+    binAlgorithm?: BinAlgorithm;
+    /** Used when `binAlgorithm: 'fixed'`. */
+    binCount?: number;
+    /** `'auto'` → data min. */
+    binStart?: number | "auto";
+    /** `'auto'` → data max. */
+    binEnd?: number | "auto";
+    /** Default 'frequency'. */
+    yAxis?: YAxisMode;
+    /** Default 1.0 (touching bars). */
+    barWidthRatio?: number;
+    /** Default false. */
+    overlay?: HistogramOverlayInput;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface HistogramChartProps extends HistogramChartBaseProps {
+    tooltip?: HistogramChartTooltipProp;
+}
+
+export declare type HistogramChartTooltipProp = undefined | false | ((props: HistogramChartTooltipProps) => React_2.ReactNode);
+
+export declare interface HistogramChartTooltipProps {
+    /** Bin index (0-based). */
+    readonly binIdx: number;
+    /** Lower edge of the bin (data value). */
+    readonly binStart: number;
+    /** Upper edge of the bin (data value). */
+    readonly binEnd: number;
+    /** Raw count in this bin. */
+    readonly count: number;
+    /** Y-value rendered (frequency / density / cumulative). */
+    readonly value: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type HistogramOverlayInput = false | "normal" | "cumulative-line" | (OverlayStyle & {
+    readonly type: HistogramOverlayType;
+});
+
+export declare type HistogramOverlayType = "normal" | "cumulative-line";
+
+export declare type HistogramSeriesInput = {
+    readonly values: Float64Array;
+} | {
+    readonly values: readonly number[];
+};
+
+export declare type IndicatorLineStyle = "solid" | "dashed" | "dotted";
+
+declare interface IndicatorPaneCommon {
+    /** `'auto'` resolves from `palette.indicators.<type>` at draw time. */
+    color?: "auto" | string;
+    /** Overrides global `indicatorLineWidth`. */
+    lineWidth?: number;
+    /** Overrides global `indicatorLineStyle`. */
+    lineStyle?: IndicatorLineStyle;
+    /** Overrides global `indicatorOpacity`. */
+    opacity?: number;
+}
+
+export declare type IndicatorPaneSpec = RsiSpecInput | MacdSpecInput | StochasticSpecInput | AtrSpecInput;
+
+/** Sentinel - when |velocity| drops below this, stop the loop. */
+export declare const INERTIA_EPSILON = 0.01;
+
+/** Translate a `KeyboardEvent.key` into an intent. Returns `null` when
+ *  the key isn't bound (caller passes through). */
+export declare function intentFromKey(key: string): KeyboardIntent | null;
+
+/** Is `SharedArrayBuffer` available + the page is cross-origin-isolated? */
+export declare function isSharedMemoryAvailable(): boolean;
+
+/** Cheap probe - returns true if `WebGL2RenderingContext` exists in the
+ *  current realm. Doesn't actually allocate a context. */
+export declare function isWebgl2Available(): boolean;
+
+export declare function KagiChart(props: KagiChartProps): React_2.ReactElement;
+
+declare interface KagiChartBaseProps {
+    /** Required OHLC bars - Kagi filters out time and tracks direction
+     *  flips by reversal threshold. */
+    data?: CandleSeriesInput;
+    /** Price-distance required to reverse direction. `"auto"` =
+     *  ATR-derived; or a fixed value. */
+    reversalThreshold?: BoxSizingInput;
+    /** Rule for thick/thin line transitions (yang vs yin). */
+    thicknessRule?: KagiThicknessRule;
+    /** Stroke width for thick (uptrend) lines. */
+    thickLineWidth?: number;
+    /** Stroke width for thin (downtrend) lines. */
+    thinLineWidth?: number;
+    /** Source field for price comparisons. */
+    source?: TimeOffSource;
+    /** Toggle crosshair on hover. */
+    crosshairVisible?: boolean;
+    /** Crosshair line style. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape. */
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface KagiChartProps extends KagiChartBaseProps {
+    tooltip?: KagiChartTooltipProp;
+}
+
+export declare type KagiChartTooltipProp = undefined | false | ((props: KagiChartTooltipProps) => React_2.ReactNode);
+
+export declare interface KagiChartTooltipProps {
+    readonly idx: number;
+    readonly direction: 1 | -1;
+    readonly thick: boolean;
+    readonly startPrice: number;
+    readonly endPrice: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type KagiThicknessRule = "shoulder-waist" | "previous-high-low";
+
+export declare interface KeyboardHandlerOptions {
+    /** Called with the resolved intent. Caller decides which intents to
+     *  honor (e.g. ScatterChart ignores `go-end` since it has no time axis). */
+    readonly onIntent: (intent: KeyboardIntent, ev: KeyboardEvent) => void;
+    /** When `true` (default), the handler calls `preventDefault()` on the
+     *  bound keys so the browser doesn't scroll. */
+    readonly preventDefault?: boolean;
+}
+
+export declare type KeyboardIntent = "pan-left" | "pan-right" | "pan-up" | "pan-down" | "zoom-in" | "zoom-out" | "reset-zoom" | "reset-domain" | "go-end" | "escape";
+
+export declare type LabelBehavior = "show-all" | "truncate" | "wrap" | "hide-on-overflow" | "auto";
+
+export declare interface LabelConfig {
+    position?: ValueLabelPosition;
+    format?: "auto" | ((value: number) => string);
+    /** `'auto'` picks high-contrast based on fill (white on Fill mode,
+     *  theme primary text on Outline mode). Hex / rgba string overrides. */
+    color?: "auto" | string;
+    fontSize?: number;
+    fontWeight?: number | "normal" | "bold";
+}
+
+export declare type LabelContentInput = LabelContentPreset | ((slice: SliceLabelData) => string);
+
+export declare type LabelContentPreset = "name" | "value" | "percent" | "name + value" | "name + percent" | "all";
+
+export declare type LabelPlacement = "inside" | "outside" | "leader-line" | "auto" | "off";
+
+export declare type LabelRotation = "horizontal" | "radial" | "tangent" | "auto";
+
+export declare type LastPriceLineStyle = "off" | "solid" | "dashed" | "dotted";
+
+export declare interface LayerSplitOptions {
+    readonly cssWidth: number;
+    readonly cssHeight: number;
+    /** When `true`, the chart is in sparkline mode; sparklines never use
+     *  the dynamic layer (no hover affordances). */
+    readonly sparkline?: boolean;
+}
+
+/** Corner anchor for the legend. */
+declare type LegendPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+
+/** Legend visibility. */
+declare type LegendVisibility = "always" | "on-hover" | "off";
+
+declare interface LevelHighlightConfig {
+    /** `'auto'` resolves to `palette.warn` at draw time (visual urgency). */
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+    readonly lineDash?: readonly number[];
+}
+
+export declare type LevelHighlightInput = false | true | LevelHighlightConfig;
+
+export declare const LineChart: React_2.ForwardRefExoticComponent<LineChartProps & React_2.RefAttributes<LineChartHandle>>;
+
+/** Framework-agnostic LineChart prop shape. Excludes the four render-prop
+ *  fields (`tooltip`, `extremeTooltip`, `connectionIndicator`, `staleBanner`)
+ *  that each framework adapter retypes against its native JSX element type
+ *  (`React.ReactNode` for React, `JSX.Element` for Solid). The controller's
+ *  `LineChartControllerProps` extends this with `unknown`-returning render
+ *  props so both adapters' shapes are structurally assignable via covariance. */
+declare interface LineChartBaseProps {
+    /** Primary series data - either structured (`{ points: Array<{t, value}> }`)
+     *  or binary (`{ times: Float64Array; values: Float64Array }`). The
+     *  binary path is zero-copy. Mutually exclusive with `series` for
+     *  multi-series charts. */
+    data?: LineSeriesInput;
+    /** Older data prepended to `data` for indicator warm-up. Lets indicators
+     *  (SMA/EMA/etc.) have priors so the visible window starts post-warmup
+     *  with non-NaN values. Same shape as `data`. */
+    historyData?: LineSeriesInput;
+    /** Multi-series mode - overrides `data`. Each entry has its own id,
+     *  label, color, and `LineSeriesInput`. The first entry is the primary
+     *  series; subsequent entries draw as secondary lines. */
+    series?: readonly SeriesConfig[];
+    /** Chart width in CSS pixels. Default 800. */
+    width?: number;
+    /** Chart height in CSS pixels. Default 300. */
+    height?: number;
+    /** Color theme - `"light"`, `"dark"`, or `"inherit"` (follows
+     *  parent provider). Default: inherits from `<ChartsProvider>`. */
+    theme?: ThemeInput;
+    /** Palette name registered in the provider (e.g. `"Monochrome"`,
+     *  `"Classic"`, `"Accessible"`). Default: inherits from provider. */
+    palette?: string;
+    /** `"Fill"` (default) = solid up/down body fills. `"Outline"` =
+     *  colored border + translucent body fill. */
+    visualStyle?: "Fill" | "Outline";
+    /** In Outline mode, the fill color inside the outlined body.
+     *  `"auto"` (default) uses chart background. */
+    outlineFillColor?: "auto" | string;
+    /** In Outline mode, alpha of the outline body fill (0–100). Default 15. */
+    outlineFillOpacity?: number;
+    /** Cap the DPR used for canvas backing-store sizing (1–2 typical).
+     *  Reduces memory on hi-DPR screens with marginal sharpness loss.
+     *  Default 2. */
+    pixelDensityCap?: number;
+    /** Skip cosmetic features (glow, animations, full DPR) for low-end
+     *  devices. Adaptive complexity auto-engages this when fps drops. */
+    fastMode?: boolean;
+    /** Force sparkline mode - minimal axis-less render. Auto-engaged
+     *  when `width < 150`. */
+    sparkline?: boolean;
+    /** Override the auto-generated `aria-label` attached to the chart
+     *  container. Default summarizes data length + type. */
+    ariaLabel?: string;
+    /** When `true` (default) and the dynamic
+     *  layer is above ~200×200 px, dirty-rect repaints clip the clear +
+     *  draw to V-strip + H-strip + live-bar regions instead of clearing
+     *  the entire canvas. Set `false` to force full-layer repaints. */
+    partialRepaints?: boolean;
+    /** Time-axis mode per the engine boundary.
+     *  - `"wall-clock"` (default) - engine's `TimeAxis.wallClock`. Bars
+     *     are positioned at their actual unix-ms; off-hours / weekends
+     *     leave horizontal gaps.
+     *  - `"session-ordinal"` - engine's `TimeAxis.sessionOrdinal` for the
+     *     supplied market. Off-session time is collapsed; bars sit
+     *     continuously without overnight / weekend gaps. Required for
+     *     equity charts (regular session 9:30-16:00, weekdays only). */
+    timeAxisMode?: "wall-clock" | "session-ordinal";
+    /** Market spec for session-ordinal mode. Ignored when `timeAxisMode`
+     *  is `"wall-clock"` (the default). */
+    market?: "equity" | "dst-equity" | "crypto-24-7";
+    /** Toggle axis tick labels + spine. Default `true`. */
+    axisVisible?: boolean;
+    /** `"left"` (default) or `"right"`. */
+    yAxisPosition?: YAxisPosition;
+    /** `"bottom"` (default) or `"top"`. */
+    xAxisPosition?: XAxisPosition;
+    /** Fractional padding above/below the y-data range so marks don't
+     *  touch the axis edges. Default 0.05 (5%). */
+    yAxisPadding?: number;
+    /** Toggle gridlines. Default `true`. */
+    gridVisible?: boolean;
+    /** Gridline style: `"solid"` / `"dashed"` / `"dotted"`. Default `"solid"`. */
+    gridStyle?: GridStyle;
+    /** Number of gridline ticks - `"sparse"` (~3) / `"normal"` (~5) /
+     *  `"dense"` (~8). Default `"normal"`. */
+    gridDensity?: "sparse" | "normal" | "dense";
+    /** Use the palette's `accentTint` for axis + grid colors instead of
+     *  `neutral`. Default `false`. */
+    accents?: boolean;
+    /** Locale code for number/date formatting (e.g. `"USA"`, `"en-US"`).
+     *  Default: inherits from provider. */
+    locale?: string;
+    /** IANA time zone for date formatting (e.g. `"America/New_York"`).
+     *  Default: inherits from provider. */
+    timeZone?: string;
+    /** Toggle the crosshair overlay on hover. Default `true`. */
+    crosshairVisible?: boolean;
+    /** How the crosshair snaps to data: `"data"` snaps to nearest data
+     *  point, `"free"` follows pointer exactly. Default `"data"`. */
+    crosshairSnap?: CrosshairSnap;
+    /** Crosshair line span: `"horizontal"`, `"vertical"`, or `"both"`. */
+    crosshairMode?: CrosshairMode;
+    /** Crosshair line style: `"solid"` / `"dashed"` / `"dotted"`. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape at the data intersection: `"circle"` / `"square"`
+     *  / `"none"`. */
+    crosshairMarker?: CrosshairMarker;
+    indicators?: readonly LineChartIndicatorSpec[];
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    /** Decimal-place rule for price labels. Default 2. */
+    decimalPlaces?: DecimalPlaces;
+    /** ISO currency code (e.g. `"USD"`, `"EUR"`) for currency-formatted
+     *  labels. Default: inherit from provider locale. */
+    currency?: string;
+    /** `"symbol"` (default), `"code"`, or `"narrowSymbol"`. */
+    currencyDisplay?: CurrencyDisplay;
+    /** Precision for percentage-style labels. */
+    percentPrecision?: PercentPrecision;
+    /** Date format rule for time-axis labels (`"short"`, `"medium"`,
+     *  `"long"`). */
+    dateFormat?: DateFormat;
+    /** Time format rule for intraday tick labels. */
+    timeFormat?: TimeFormat;
+    /** Style of the last-price horizontal reference line: `"solid"` /
+     *  `"dashed"` / `"dotted"` / `false` to hide. Default `"solid"`. */
+    lastPriceLine?: LastPriceLineStyle;
+    /** Show the last price as a pill on the y-axis. Default `true`. */
+    lastPriceLabel?: boolean;
+    /** Override the chart background color (CSS). Default: theme-derived. */
+    chartBgColor?: string;
+    /** Show high + low markers on the visible data range:
+     *  `"lines+labels"` (default), `"labels"`, `"off"`. */
+    highLowMarkers?: HighLowMarkers;
+    /** Live-bar animation: `"glow"` / `"dot"` / `"pulse-bar"` / `"none"`. */
+    liveBarIndicator?: LiveBarIndicator;
+    /** Anchor for the connection-indicator badge + legend overlay:
+     *  `"top-left"` (default), `"top-right"`, `"bottom-left"`,
+     *  `"bottom-right"`. */
+    legendPosition?: LegendPosition;
+    /** Legend visibility: `"on"` (default), `"off"`, `"on-hover"`. */
+    legend?: LegendVisibility;
+    /** Visual treatment for stale connection state: `"banner"`,
+     *  `"desaturate-pulse"`, `"desaturate-pulse + banner"`, `"off"`. */
+    staleVisualization?: StaleVisualization;
+    /** Unix-ms timestamp of the latest accepted tick. Used to drive
+     *  the live/stale state machine + auto-stale timeout. */
+    liveSince?: number;
+    /** Host-asserted connection state - overrides `liveSince`-derived
+     *  state when present. `"live"` / `"stale"` / `"disconnected"`. */
+    connectionState?: LiveState;
+    /** Milliseconds after the last `liveSince` tick before the chart
+     *  auto-transitions to `"stale"`. Default 5000. */
+    staleThreshold?: number;
+    /** Host-forced reduced-motion override. When unset the chart reads
+     *  the user's `prefers-reduced-motion` media query. */
+    reducedMotion?: boolean;
+    /** Curve interpolation between points: `"linear"`, `"monotone"`,
+     *  `"step"`, `"step-before"`, `"step-after"`, `"basis"`, `"natural"`,
+     *  `"bump"`, or a parameterized form. Default `"linear"`. */
+    curveType?: CurveType;
+    /** When `curveType` is a `"step-*"` variant, radius (CSS px) for
+     *  rounded step corners. `0` (default) = square. */
+    stepEdgeRadius?: number;
+    /** Series stroke width in CSS px. Default 2. */
+    lineWidth?: number;
+    /** Dash pattern: `"solid"`, `"dashed"`, `"dotted"`. */
+    lineDash?: LineDash;
+    /** Multiplier for the dash gap when `lineDash !== "solid"`. */
+    lineDashSpacing?: number;
+    /** Per-point markers along the line: `"circle"`, `"diamond"`,
+     *  `"square"`, `"off"`. */
+    pointMarkers?: PointMarkers;
+    /** Area-fill config - when set, renders a filled polygon between the
+     *  line and a horizontal baseline. Switches the chart to AreaChart
+     *  visuals. See `AreaFillConfig` for full options. */
+    areaFill?: AreaFillConfig;
+    /** Direction-colored aura behind marks. */
+    glow?: GlowInput;
+    /** `'auto'` = direction-colored from palette;
+     *  literal color = uniform glow regardless of direction. */
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+}
+
+/** Imperative handle exposed via `ref` on `<LineChart>`. Lets the host
+ *  push live-tick updates without re-rendering the React tree.
+ *  Binary Data Ingestion: primitive args. */
+declare interface LineChartHandle {
+    /** Append a live tick (time ms, price). `size` is accepted for API
+     *  parity with CandleChart but is unused for line charts. */
+    onTick(time: number, price: number, size?: number): void;
+}
+
+/** Indicator overlays that LineChart can render on the price pane. VWAP
+ * needs OHLC + volume + session_starts and is only available on
+ * CandleChart. */
+export declare type LineChartIndicatorSpec = {
+    type: "sma";
+    period: number;
+    color?: string;
+} | {
+    type: "ema";
+    period: number;
+    color?: string;
+} | {
+    type: "wma";
+    period: number;
+    color?: string;
+} | {
+    type: "bollinger";
+    period: number;
+    multiplier: number;
+    color?: string;
+};
+
+/** React LineChart prop shape. Extends the framework-agnostic
+ *  `LineChartBaseProps` (in `charts/line-chart-helpers.ts`) with the four
+ *  React-specific render-prop fields whose return type is `React.ReactNode`.
+ *  See `LineChartControllerProps` for the controller's `unknown`-returning
+ *  variant of the same shape. */
+export declare interface LineChartProps extends LineChartBaseProps {
+    tooltip?: LineChartTooltipProp;
+    extremeTooltip?: ExtremeTooltipProp;
+    connectionIndicator?: ConnectionIndicatorProp;
+    staleBanner?: StaleBannerProp;
+}
+
+/**
+ * Polymorphic tooltip prop:
+ *   false             - no tooltip
+ *   true / undefined  - DefaultTooltip with theme-aware styling
+ *   function          - custom render-prop, called with LineChartTooltipProps
+ */
+export declare type LineChartTooltipProp = boolean | ((props: LineChartTooltipProps) => React_2.ReactNode);
+
+/** Props passed to a custom LineChart tooltip render function (and to the
+ *  built-in `DefaultTooltip` in both React and Solid). Framework-agnostic
+ *  data shape. */
+export declare interface LineChartTooltipProps {
+    /** Time at the active hover position (unix-ms). */
+    t: number;
+    /** Value at the active hover position (primary series only). */
+    value: number;
+    /** Bar index in the source series; -1 when free-snap. */
+    idx: number;
+    /** Per-series values at hover.t - primary first, then secondaries. */
+    seriesValues: readonly TooltipSeriesValue[];
+    /** Pointer position in CSS pixels relative to the chart container. */
+    pointerX: number;
+    pointerY: number;
+    /** Container dimensions for placement decisions. */
+    containerWidth: number;
+    containerHeight: number;
+    /** Resolved theme + palette for color matching. */
+    theme: Theme;
+    palette: Palette;
+    /** Resolved platform locale (e.g. "en-US"). */
+    locale: string;
+    timeZone: string | undefined;
+    /** Per-chart formatter - preferred over `locale` for new tooltip code. */
+    formatter: ChartFormatter;
+}
+
+export declare type LineDash = "solid" | "dashed" | "dotted" | readonly number[];
+
+declare interface LinePoint {
+    t: number;
+    value: number;
+}
+
+declare type LineSeriesInput = {
+    points: readonly LinePoint[];
+} | {
+    times: Float64Array;
+    values: Float64Array;
+};
+
+/** Live-bar indicator modes. */
+declare type LiveBarIndicator = "none" | "dot" | "badge" | "glow" | "outline" | "pulse-bar";
+
+declare type LiveState = "live" | "stale" | "disconnected";
+
+export declare type LongPressBehavior = "crosshair" | "context-menu" | "none";
+
+export declare interface MacdSpecInput extends IndicatorPaneCommon {
+    type: "macd";
+    fastPeriod?: number;
+    slowPeriod?: number;
+    signalPeriod?: number;
+    histogramVisible?: boolean;
+}
+
+/** Build a keyboard listener that funnels mapped keys into `onIntent`.
+ *  Unmapped keys pass through (no preventDefault). Returns a function
+ *  the caller can `removeEventListener` to dispose. */
+export declare function makeKeyboardHandler(opts: KeyboardHandlerOptions): (ev: KeyboardEvent) => void;
+
+/** Build a pinch handler. Tracks active pointers and emits scale deltas
+ *  on every pointermove during a two-finger gesture. */
+export declare function makePinchHandler(opts: PinchHandlerOptions): PinchHandler;
+
+export declare interface MarkerConfig {
+    style?: MarkerStyle;
+    /** Diameter / longest side, in CSS px. Floored to `MIN_MARKER_SIZE` (1.5)
+     *  internally so markers don't disappear at extreme zoom-out. Default 5. */
+    size?: number;
+    /** Fill color. `'auto'` = the line's resolved color. `'none'` = no fill. */
+    fill?: "auto" | "none" | string;
+    /** Stroke color. `'auto'` matches `fill`. `'none'` = no stroke. */
+    stroke?: "auto" | "none" | string;
+    /** Stroke width in CSS px. `0` (default) = no border. */
+    strokeWidth?: number;
+    /** Up-arrow color when `style: 'direction'`. `'auto'` = `palette.up`. */
+    upColor?: "auto" | string;
+    /** Down-arrow color when `style: 'direction'`. `'auto'` = `palette.down`. */
+    downColor?: "auto" | string;
+    /** Custom up/down icons for `style: 'direction'`. Defaults to the built-in
+     *  chevron when `undefined`. */
+    upIcon?: MarkerIcon;
+    downIcon?: MarkerIcon;
+    /** Required when `style: 'custom'`. Used for every data point. */
+    icon?: MarkerIcon;
+}
+
+/** Custom-icon shapes accepted by `MarkerConfig.icon` / `upIcon` / `downIcon`.
+ *  Evaluated synchronously per draw - no async resolution, no React-component
+ *  offscreen rendering (that's a future sweep when we add
+ *  bitmap-cache infra). */
+export declare type MarkerIcon = 
+/** SVG path-data string (e.g. `"M-1,-1 L1,1 ..."`). Parsed to a cached
+*  `Path2D` once per unique string at first use. */
+string
+/** Pre-built `Path2D` - used directly. */
+| Path2D
+/** Direct-draw function - called per point with translated origin.
+*  Receives a context whose origin is at (x, y) and scaled to half-size,
+*  so the function should draw the shape in [-1, 1] coordinates. */
+| ((ctx: CanvasRenderingContext2D) => void);
+
+export declare type MarkerStyle = "circle" | "square" | "diamond" | "triangle" | "triangle-down" | "cross" | "plus" | "star" | "direction" | "custom";
+
+declare type MarketKind = "equity" | "dst-equity" | "crypto-24-7";
+
+declare interface MidLineConfig {
+    readonly style?: MidLineStyle;
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+}
+
+export declare type MidLineInput = false | true | "dashed" | MidLineConfig;
+
+export declare type MidLineStyle = "solid" | "dashed";
+
+export declare const MULTI_CHART_THRESHOLD = 4;
+
+export declare type NodeAlignment = "justify" | "left" | "right" | "center";
+
+export declare type NullBehavior = "empty" | "cross-hatch" | "background";
+
+declare type NumberAbbreviation = "off" | "compact" | "lakh-crore" | "auto";
+
+/** Allow a user-supplied function to bypass all built-in behavior. */
+export declare type NumberFormatInput = NumberFormatPreset | ((n: number) => string);
+
+export declare type NumberFormatPreset = "standard" | "compact" | "pk-grouping" | "pk-compact" | "percent" | "currency";
+
+export declare interface OffscreenContext {
+    /** Total bars in the dataset. */
+    readonly bulkBarCount?: number;
+    /** Charts mounted on the same page sharing the engine. */
+    readonly mountedChartCount?: number;
+    /** Currently-visible marks (after downsampling). */
+    readonly visibleMarkCount?: number;
+    /** Honor host opt-outs (e.g. SSR snapshot mode). */
+    readonly disabled?: boolean;
+}
+
+declare interface Oklch {
+    L: number;
+    C: number;
+    h: number;
+}
+
+declare interface OrderMarker {
+    /** Bar t the order lives at (typically the most-recent bar). */
+    t: number;
+    side: OrderSide;
+    entryPrice: number;
+    stopLossPrice?: number;
+    takeProfitPrice?: number;
+    meta?: Record<string, unknown>;
+}
+
+declare type OrderMarkerMode = "off" | "lines" | "arrows-only" | "lines + zone";
+
+declare type OrderSide = "buy" | "sell";
+
+declare interface OrderTooltipProps {
+    marker: OrderMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+
+declare type Orientation = "vertical" | "horizontal";
+
+declare interface OverlayStyle {
+    /** `'auto'` resolves to `palette.neutral` at draw time. */
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+    readonly lineDash?: readonly number[];
+}
+
+declare interface Palette {
+    name: string;
+    light: PaletteVariant;
+    dark: PaletteVariant;
+    tonalSymmetrySide: TonalSymmetrySide;
+    tonalSymmetryFlipInDarkMode: boolean;
+}
+
+export declare class PaletteValidationError extends Error {
+    readonly paletteName: string;
+    readonly missingSlot: string;
+    readonly name = "PaletteValidationError";
+    constructor(paletteName: string, missingSlot: string);
+}
+
+declare interface PaletteVariant {
+    up: Oklch;
+    down: Oklch;
+    doji: Oklch;
+    neutral: Oklch;
+    /** Caution / amber - used for stale state (connection indicator + stale
+     *  banner). Must read as "warning" without competing with `up`/`down`. */
+    warn: Oklch;
+    accentTint: Oklch;
+    categorical: readonly Oklch[];
+    indicators: {
+        sma: Oklch;
+        ema: Oklch;
+        wma: Oklch;
+        bb: Oklch;
+        fib: Oklch;
+        rsi: Oklch;
+        macd: Oklch;
+        stochastic: Oklch;
+        atr: Oklch;
+        vwap: Oklch;
+    };
+    drawings: {
+        stroke: Oklch;
+        fill: Oklch;
+        handle: Oklch;
+        label: Oklch;
+    };
+    /** Optional event-kind colors. When absent,
+     *  the chart falls back to a built-in default for each kind. */
+    events?: {
+        earnings?: Oklch;
+        dividend?: Oklch;
+        split?: Oklch;
+        news?: Oklch;
+    };
+}
+
+export declare type PanAxis = "x" | "y" | "both";
+
+export declare type PanEdgeBehavior = 
+/** Hard stop at the data extents. */
+"stop"
+/** Allow over-pan with a small empty band. */
+| "overshoot"
+/** Wrap around (rarely useful for finance - left for completeness). */
+| "wrap";
+
+export declare interface PanZoomOptions {
+    readonly panEnabled: boolean;
+    readonly zoomEnabled: boolean;
+    readonly zoomAnchor: ZoomAnchor;
+    readonly panEdgeBehavior: PanEdgeBehavior;
+    readonly panInertia: boolean;
+    readonly wheelBehavior: WheelBehavior;
+    readonly panAxis: PanAxis;
+    readonly doubleClickReset: boolean;
+    readonly yAxisManualRescale: boolean;
+}
+
+export declare type PanZoomOptionsInput = {
+    readonly [K in keyof PanZoomOptions]?: PanZoomOptions[K] | undefined;
+};
+
+export declare type PatternColorInput = "auto" | string;
+
+/** Host-supplied input - string preset, config form, or a literal
+ *  `CanvasPattern` (full dev control). */
+export declare type PatternInput = PatternPreset | {
+    readonly type: PatternPreset;
+    readonly scale?: number;
+    readonly lineWidth?: number;
+    readonly color?: string;
+} | CanvasPattern;
+
+export declare type PatternPreset = "solid" | "diagonal-lines" | "diagonal-lines-reverse" | "cross-hatch" | "dots" | "circles" | "grid" | "horizontal-lines" | "vertical-lines" | "plus" | "chevron" | "zigzag" | "waves" | "checkerboard" | "hexagons" | "bricks";
+
+declare type PercentPrecision = "auto" | number;
+
+export declare function PieChart(props: PieChartProps): React_2.ReactElement;
+
+declare interface PieChartBaseProps {
+    /** Slice data - array of `{ name, value, color? }`. Each value
+     *  becomes a slice proportional to its share of the total. */
+    data?: PieSeriesInput;
+    /** Default -90° (12 o'clock). Degrees. */
+    startAngle?: number;
+    /** Default 270° (full circle). Degrees. */
+    endAngle?: number;
+    /** Default 3°. Gap between slices, in degrees. */
+    padAngle?: number;
+    /** Default 0 (Pie) / 0.5 (Donut). */
+    innerRadius?: number;
+    /** Default 'auto'. */
+    labelPlacement?: LabelPlacement;
+    /** Default 'name + percent'. */
+    labelContent?: LabelContentInput;
+    /** Default 'value-desc'. */
+    sortOrder?: SortOrder;
+    /** Default false. */
+    smallSliceThreshold?: SmallSliceThresholdInput;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface PieChartProps extends PieChartBaseProps {
+    tooltip?: PieChartTooltipProp;
+}
+
+export declare type PieChartTooltipProp = undefined | false | ((props: PieChartTooltipProps) => React_2.ReactNode);
+
+export declare interface PieChartTooltipProps {
+    /** Slice index in the post-sort/combine order. */
+    readonly idx: number;
+    readonly name: string;
+    readonly value: number;
+    /** 0–1 fraction of the total. */
+    readonly percent: number;
+    readonly color: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type PieSeriesInput = {
+    readonly slices: readonly PieSlice[];
+} | {
+    readonly values: Float64Array | readonly number[];
+    readonly names: readonly string[];
+    readonly colors?: ReadonlyArray<string | undefined>;
+};
+
+export declare interface PieSlice {
+    readonly name: string;
+    readonly value: number;
+    /** Optional CSS color override. When omitted, palette.categorical[i] cycles. */
+    readonly color?: string;
+}
+
+export declare interface PinchEvent {
+    /** Scale ratio relative to the gesture start (`1 = no change`,
+     *  `>1 = zoom in`, `<1 = zoom out`). */
+    readonly scale: number;
+    /** Midpoint of the two pointers, in CSS px on the host element. */
+    readonly centerX: number;
+    readonly centerY: number;
+}
+
+export declare interface PinchHandler {
+    onPointerDown(ev: PointerEvent): void;
+    onPointerMove(ev: PointerEvent): void;
+    onPointerUp(ev: PointerEvent): void;
+    /** Force-clear the active gesture (e.g. on unmount). */
+    dispose(): void;
+}
+
+export declare interface PinchHandlerOptions {
+    readonly onPinch: (ev: PinchEvent) => void;
+    readonly onPinchEnd?: () => void;
+}
+
+declare interface PnFChartBaseProps {
+    /** Required OHLC bars - the chart filters out time and renders X / O
+     *  symbols based on price-reversal logic. */
+    data?: CandleSeriesInput;
+    /** Box-size strategy - `"auto"` (ATR-derived) or explicit value. */
+    boxSize?: BoxSizingInput;
+    /** Number of boxes against the trend required to flip direction.
+     *  Standard is 3. */
+    reversalCount?: number;
+    /** Source field for price: `"close"` (default) or `"high-low"`. */
+    source?: TimeOffSource;
+    /** Symbol style for X / O columns. */
+    symbolStyle?: PnFSymbolStyle;
+    /** Padding between symbols within a column. */
+    symbolPadding?: number;
+    /** Toggle crosshair on hover. */
+    crosshairVisible?: boolean;
+    /** Crosshair line style. */
+    crosshairLineStyle?: GridStyle;
+    /** Snap-marker shape. */
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface PnFChartTooltipProps {
+    readonly idx: number;
+    readonly direction: 1 | -1;
+    readonly bottomBox: number;
+    readonly topBox: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type PnFSymbolStyle = "classic" | "filled";
+
+export declare function PointFigureChart(props: PointFigureChartProps): React_2.ReactElement;
+
+export declare interface PointFigureChartProps extends PnFChartBaseProps {
+    tooltip?: PointFigureChartTooltipProp;
+}
+
+export declare type PointFigureChartTooltipProp = undefined | false | ((props: PnFChartTooltipProps) => React_2.ReactNode);
+
+export declare type PointMarkers = boolean | MarkerConfig;
+
+export declare type PointOpacityInput = number | "auto";
+
+declare interface PointSizeConfig {
+    /** `'linear'` (radius linear in value) or `'sqrt'` (area linear in value).
+     *  Default `'sqrt'` - perceptually correct for area-encoded bubbles. */
+    readonly scale?: BubbleScale;
+    /** `[minPx, maxPx]` - the rendered diameter range. Default [4, 32]. */
+    readonly range?: readonly [number, number];
+}
+
+export declare type PointSizeInput = number | "data-driven" | PointSizeConfig;
+
+declare interface PositionMarker {
+    t: number;
+    side: "long" | "short";
+    entryPrice: number;
+    /** Quantity in shares / lots - used by P&L pill calculations. */
+    qty: number;
+    meta?: Record<string, unknown>;
+}
+
+declare type PositionMarkerMode = "off" | "line + pnl-pill" | "arrows-only";
+
+declare interface PositionTooltipProps {
+    marker: PositionMarker;
+    /** Live last close - for P&L snapshot in the tooltip. */
+    lastClose: number;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+
+export declare type PriceRangeInput = "auto" | number | PriceRangeWindow;
+
+export declare interface PriceRangeWindow {
+    /** Lower bound as fraction off mid (typically negative). */
+    readonly minPct: number;
+    /** Upper bound as fraction off mid (typically positive). */
+    readonly maxPct: number;
+}
+
+declare interface QualitativeConfig {
+    readonly type: "qualitative";
+}
+
+export declare type RadiusProportion = "uniform" | "value-weighted" | "sqrt-weighted";
+
+export declare interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+
+export declare type ReferencePoint = "first-visible" | "last-bar" | number;
+
+export declare function registerPalette(palette: Palette): void;
+
+export declare type RegressionLineInput = false | true | (RegressionStyle & {
+    readonly type: "linear";
+}) | (RegressionStyle & {
+    readonly type: "polynomial";
+    readonly degree?: number;
+}) | (RegressionStyle & {
+    readonly type: "exponential";
+}) | (RegressionStyle & {
+    readonly type: "lowess";
+    readonly bandwidth?: number;
+});
+
+declare interface RegressionStyle {
+    /** `'auto'` resolves to `palette.neutral` at draw time. */
+    readonly color?: "auto" | string;
+    readonly lineWidth?: number;
+    readonly lineDash?: readonly number[];
+}
+
+export declare type RegressionType = "linear" | "polynomial" | "exponential" | "lowess";
+
+/** Map a downgrade level to the render config the chart should apply. */
+export declare interface RenderConfigOverrides {
+    readonly disableGlow: boolean;
+    readonly disableAnimations: boolean;
+    readonly capDpr: boolean;
+}
+
+/** Resolves the polymorphic `extremeTooltip` prop to a React node. Same
+ *  shape as the LineChart / BarChart tooltip resolvers - `false`
+ *  suppresses, function takes precedence, default routes to the built-
+ *  in. */
+export declare function renderExtremeTooltip(prop: ExtremeTooltipProp | undefined, tooltipProps: ExtremeTooltipProps): React_2.ReactNode;
+
+export declare function RenkoChart(props: RenkoChartProps): React_2.ReactElement;
+
+declare interface RenkoChartBaseProps {
+    /** Required OHLC bars - Renko filters out time and renders fixed-
+     *  size price-movement bricks. */
+    data?: CandleSeriesInput;
+    /** Default 'atr-14'. */
+    brickSize?: BoxSizingInput;
+    /** Default 2. */
+    reversalThreshold?: number;
+    /** Default 'close'. */
+    source?: TimeOffSource;
+    /** Default 0 (touching bricks). */
+    brickGap?: number;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface RenkoChartProps extends RenkoChartBaseProps {
+    tooltip?: RenkoChartTooltipProp;
+}
+
+export declare type RenkoChartTooltipProp = undefined | false | ((props: RenkoChartTooltipProps) => React_2.ReactNode);
+
+export declare interface RenkoChartTooltipProps {
+    readonly idx: number;
+    readonly direction: 1 | -1;
+    readonly bottomPrice: number;
+    readonly topPrice: number;
+    readonly sourceTime: number;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+declare interface ResolvedAtrSpec {
+    type: "atr";
+    period: number;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+
+declare interface ResolvedBase {
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+    readonly lineDash: readonly number[] | null;
+}
+
+export declare type ResolvedBoxSizing = {
+    readonly type: "fixed";
+    readonly value: number;
+} | {
+    readonly type: "atr";
+    readonly period: number;
+} | {
+    readonly type: "percent";
+    readonly value: number;
+};
+
+export declare interface ResolvedGlow {
+    /** Normalized strength 0..1. Zero means glow is off; the rendering
+     *  primitive short-circuits and avoids the offscreen pass entirely. */
+    readonly strength: number;
+    /** Direction-aware or literal. `'auto'` triggers direction resolution at
+     *  draw time using the chart's palette. */
+    readonly color: "auto" | string;
+}
+
+export declare interface ResolvedHistogramOverlay {
+    readonly type: HistogramOverlayType;
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+    readonly lineDash: readonly number[] | null;
+}
+
+export declare type ResolvedIndicatorPaneSpec = ResolvedRsiSpec | ResolvedMacdSpec | ResolvedStochasticSpec | ResolvedAtrSpec;
+
+export declare interface ResolvedLevelHighlight {
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+    readonly lineDash: readonly number[] | null;
+}
+
+declare interface ResolvedLocale {
+    /** Uppercase ISO 3166-1 alpha-3 code. */
+    readonly country: string;
+    /** Platform-formatter locale for international grouping. */
+    readonly baseLocale: string;
+    /** Locale for lakh-crore (lakh/crore) grouping with Latin digits forced.
+     *  When undefined, the country has no native lakh-crore-grouping
+     *  locale; ChartFormatter falls back to its custom 5-line formatter
+     *  when the host opts into lakh-crore grouping. */
+    readonly lakhCroreLocale: string | undefined;
+    /** ISO 4217 currency code paired with this locale by default. */
+    readonly defaultCurrency: string;
+}
+
+declare interface ResolvedMacdSpec {
+    type: "macd";
+    fastPeriod: number;
+    slowPeriod: number;
+    signalPeriod: number;
+    histogramVisible: boolean;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+
+export declare interface ResolvedMidLine {
+    readonly style: MidLineStyle;
+    readonly color: "auto" | string;
+    readonly lineWidth: number;
+}
+
+export declare interface ResolvedNumberFormat {
+    readonly preset: NumberFormatPreset | null;
+    /** Non-null when the host passed a literal function. */
+    readonly custom: ((n: number) => string) | null;
+    /** Derived `digitGrouping` for the underlying formatter. */
+    readonly digitGrouping: DigitGrouping;
+    /** Derived `numberAbbreviation`. */
+    readonly numberAbbreviation: NumberAbbreviation;
+    /** When the preset is `'percent'` or `'currency'`, the formatter
+     *  routes through a percent / currency code path. */
+    readonly mode: "number" | "percent" | "currency";
+}
+
+export declare interface ResolvedPattern {
+    readonly type: PatternPreset;
+    readonly scale: number;
+    readonly lineWidth: number;
+    /** `'auto'` triggers per-mark color derivation at draw time (uses the
+     *  mark's own fill color with OKLCH L-shift); a literal string forces
+     *  uniform pattern color. */
+    readonly color: "auto" | string;
+    /** Literal `CanvasPattern` (custom dev pattern). When non-null, the
+     *  rendering primitive uses it directly and ignores `type`. */
+    readonly customPattern: CanvasPattern | null;
+}
+
+export declare type ResolvedPointSize = {
+    readonly kind: "fixed";
+    readonly size: number;
+} | {
+    readonly kind: "data-driven";
+    readonly scale: BubbleScale;
+    readonly range: readonly [number, number];
+};
+
+export declare type ResolvedRegressionLine = (ResolvedBase & {
+    readonly type: "linear";
+}) | (ResolvedBase & {
+    readonly type: "polynomial";
+    readonly degree: number;
+}) | (ResolvedBase & {
+    readonly type: "exponential";
+}) | (ResolvedBase & {
+    readonly type: "lowess";
+    readonly bandwidth: number;
+});
+
+declare interface ResolvedRsiSpec {
+    type: "rsi";
+    period: number;
+    overbought: number;
+    oversold: number;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+
+export declare type ResolvedSankeyLinkColor = {
+    readonly kind: SankeyLinkColorPreset;
+} | {
+    readonly kind: "literal";
+    readonly color: string;
+};
+
+export declare interface ResolvedSmallSliceThreshold {
+    readonly threshold: number;
+    readonly label: string;
+    readonly color: "auto" | string;
+}
+
+declare interface ResolvedStochasticSpec {
+    type: "stochastic";
+    kPeriod: number;
+    dPeriod: number;
+    smoothing: number;
+    overbought: number;
+    oversold: number;
+    color: "auto" | string;
+    lineWidth: number;
+    lineStyle: IndicatorLineStyle;
+    opacity: number;
+}
+
+/** Resolved + normalized tooltip slot - the chart calls `mode === 'render'`
+ *  and invokes `render(props)` to materialise the tooltip, or skips when
+ *  `mode === 'off'`. */
+export declare type ResolvedTooltip<P> = {
+    readonly mode: "off";
+} | {
+    readonly mode: "default";
+} | {
+    readonly mode: "render";
+    readonly render: (p: P) => unknown;
+};
+
+/** Translate `fastMode: 'auto'` into a concrete boolean using the
+ *  context. Three triggers:
+ *    - effectiveType is "slow-2g" / "2g"
+ *    - deviceMemory ≤ 2 GB
+ *    - prefersReducedMotion is set
+ *  Any one trigger flips fastMode on. */
+export declare function resolveFastModeAuto(input: FastModeInput | undefined, ctx: FastModeContext): boolean;
+
+/** Resolve glow inputs to a normalized form. `fastMode` forces strength
+ *  to zero regardless of input. */
+export declare function resolveGlow(input: GlowInput | undefined, color: GlowColorInput | undefined, fastMode: boolean): ResolvedGlow;
+
+/** Resolve the halo stroke/fill color used in glow passes for a given
+ *  mark direction. Returns a CSS color string ready to assign to
+ *  `ctx.strokeStyle` / `ctx.fillStyle`. */
+export declare function resolveGlowHaloColor(glow: ResolvedGlow, theme: Theme, directionRgba: string): string;
+
+export declare function resolveGpuRenderer(input: GpuRendererInput | undefined): GpuRendererInput;
+
+export declare function resolveNumberFormat(input: NumberFormatInput | undefined): ResolvedNumberFormat;
+
+export declare function resolvePanZoomOptions(input: PanZoomOptionsInput | undefined): PanZoomOptions;
+
+export declare function resolvePattern(input: PatternInput | undefined, scale: number | undefined, color: PatternColorInput | undefined): ResolvedPattern;
+
+export declare function resolveTooltip<P>(input: TooltipInput<P> | undefined): ResolvedTooltip<P>;
+
+export declare interface RsiSpecInput extends IndicatorPaneCommon {
+    type: "rsi";
+    period?: number;
+    overbought?: number;
+    oversold?: number;
+}
+
+export declare function SankeyChart(props: SankeyChartProps): React_2.ReactElement;
+
+declare interface SankeyChartBaseProps {
+    /** Flow data - `{ nodes: [{name}], links: [{source, target, value}] }`.
+     *  Sankey renders nodes as bars and links as proportional flow ribbons. */
+    data?: SankeyInput;
+    /** Default 'justify'. */
+    nodeAlignment?: NodeAlignment;
+    /** Default 8. */
+    nodePadding?: number;
+    /** Default 16. */
+    nodeWidth?: number;
+    /** Default 0.45. */
+    linkOpacity?: number;
+    /** Default 'source'. */
+    linkColor?: SankeyLinkColorInput;
+    /** Default 6. */
+    iterations?: number;
+    /** Default 'auto'. */
+    labelPosition?: LabelPlacement;
+    /** Default 'name + value'. */
+    labelContent?: LabelContentInput;
+    /** Default false. */
+    valueDisplay?: SankeyValueDisplayInput;
+    /** Default 'flat-categorical'. */
+    colorScale?: TreemapColorScale;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface SankeyChartProps extends SankeyChartBaseProps {
+    tooltip?: SankeyChartTooltipProp;
+}
+
+export declare type SankeyChartTooltipProp = undefined | false | ((props: SankeyChartTooltipProps) => React_2.ReactNode);
+
+export declare interface SankeyChartTooltipProps {
+    readonly target: {
+        kind: "node";
+        idx: number;
+        id: string;
+        name: string;
+        value: number;
+    } | {
+        kind: "link";
+        idx: number;
+        sourceId: string;
+        targetId: string;
+        value: number;
+    };
+    readonly color: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare interface SankeyInput {
+    readonly nodes: readonly SankeyNodeInput[];
+    readonly links: readonly SankeyLinkInput[];
+}
+
+export declare type SankeyLinkColorInput = SankeyLinkColorPreset | string;
+
+export declare type SankeyLinkColorPreset = "source" | "target" | "gradient" | "neutral";
+
+export declare interface SankeyLinkInput {
+    readonly source: string | number;
+    readonly target: string | number;
+    readonly value: number;
+    readonly color?: string;
+    readonly opacity?: number;
+}
+
+export declare interface SankeyNodeInput {
+    readonly id: string;
+    readonly name?: string;
+    readonly color?: string;
+    readonly label?: string;
+}
+
+export declare type SankeyValueDisplayInput = false | true | "on-link-hover";
+
+export declare type SankeyValueDisplayMode = "off" | "always" | "on-link-hover";
+
+export declare function ScatterChart(props: ScatterChartProps): React_2.ReactElement;
+
+declare interface ScatterChartBaseProps {
+    /** Single-series point data - `xs` + `ys` + optional `sizes`. */
+    data?: ScatterSeriesInput;
+    /** Multi-series - pass an array of named series. */
+    series?: readonly ScatterSeriesConfig[];
+    /** Default 9 (fixed pixel diameter). */
+    pointSize?: PointSizeInput;
+    /** Default 'auto' - lowers per-point alpha at high counts. */
+    pointOpacity?: PointOpacityInput;
+    /** Default false. */
+    regressionLine?: RegressionLineInput;
+    /** Default 'auto' - switches to heatmap at ≥50k points. */
+    density?: DensityInput;
+    /** Inherits LineChart's MarkerConfig - controls point shape + fill/stroke
+     *  treatment. `pointSize` overrides the size field. */
+    pointMarker?: PointMarkers;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    xAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface ScatterChartProps extends ScatterChartBaseProps {
+    tooltip?: ScatterChartTooltipProp;
+}
+
+export declare type ScatterChartTooltipProp = undefined | false | ((props: ScatterChartTooltipProps) => React_2.ReactNode);
+
+export declare interface ScatterChartTooltipProps {
+    /** X-coordinate of the hovered point. */
+    readonly x: number;
+    /** Y-coordinate of the hovered point. */
+    readonly y: number;
+    /** Optional size value (when `pointSize` is data-driven). */
+    readonly size: number | null;
+    /** Index into the hovered series. */
+    readonly idx: number;
+    /** Index into the chart's series list (0 = primary, ≥1 = secondaries). */
+    readonly seriesIdx: number;
+    /** Series id (from `series[i].id`, or `'primary'` when only `data` was passed). */
+    readonly seriesId: string;
+    /** Series display label (`series[i].label ?? id`, or `'Value'` for primary-only). */
+    readonly seriesLabel: string;
+    /** Resolved CSS color for this series (categorical[i] cycling already applied). */
+    readonly seriesColor: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare interface ScatterPoint {
+    readonly x: number;
+    readonly y: number;
+    /** Optional 3rd dimension - only consumed when `pointSize` is data-driven. */
+    readonly size?: number;
+}
+
+/** Multi-series ScatterChart entry. Always supported.
+ *  Without per-series `color`, the lib auto-cycles `palette.categorical[i]`. */
+declare interface ScatterSeriesConfig {
+    readonly id: string;
+    readonly data: ScatterSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+}
+
+/** AoS or SoA - host picks. SoA is zero-copy on ingest. */
+export declare type ScatterSeriesInput = {
+    readonly points: readonly ScatterPoint[];
+} | {
+    readonly xs: Float64Array;
+    readonly ys: Float64Array;
+    readonly sizes?: Float64Array;
+};
+
+declare interface SequentialConfig {
+    readonly type: "sequential";
+    /** `[low, high]` data range. When omitted, auto-fits to data extent. */
+    readonly domain?: readonly [number, number];
+}
+
+/** Multi-series config - one entry per line on the chart.
+ *  Each entry can override the chart-level
+ *  curveType / lineWidth / lineDash / lineDashSpacing / pointMarkers for
+ *  this one series. Without a per-series `color`, lib auto-cycles
+ *  `palette.categorical[i]`. */
+export declare interface SeriesConfig {
+    readonly id: string;
+    readonly data: LineSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+    readonly curveType?: CurveType;
+    readonly stepEdgeRadius?: number;
+    readonly lineWidth?: number;
+    readonly lineDash?: LineDash;
+    readonly lineDashSpacing?: number;
+    readonly pointMarkers?: PointMarkers;
+}
+
+/** Should the chart engage the offscreen-worker render path? */
+export declare function shouldEngageOffscreenWorker(ctx: OffscreenContext): boolean;
+
+/** Decide whether the chart should engage the WebGL2 renderer.
+ *  Returns false when WebGL2 is unavailable in this environment. */
+export declare function shouldEngageWebgl(ctx: GpuEngageContext): boolean;
+
+/** Centralised decision - should this chart use partial dirty-rect
+ *  repaints? Same threshold as the two-layer split for consistency. */
+export declare function shouldUseDirtyRects(cssWidth: number, cssHeight: number): boolean;
+
+/** Decide whether to engage the two-canvas split. Returns `false` when
+ *  the chart is too small or in sparkline mode; `true` otherwise. */
+export declare function shouldUseLayerSplit(opts: LayerSplitOptions): boolean;
+
+declare interface SignalMarker {
+    /** Time in ms (matches a candle's t). */
+    t: number;
+    side: SignalSide;
+    /** [0, 1] confidence - drives the marker size scale. */
+    confidence?: number;
+    /** Optional override for the chart's `signalTooltip` data. */
+    meta?: Record<string, unknown>;
+}
+
+declare type SignalMarkerMode = "off" | "arrows + letter" | "arrows" | "flags" | "dots" | "arrows + label";
+
+declare type SignalSide = "buy" | "sell";
+
+declare interface SignalTooltipProps {
+    marker: SignalMarker;
+    /** Bar's center x in CSS px (host can use for absolute positioning). */
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+
+export declare interface SliceLabelData {
+    readonly name: string;
+    readonly value: number;
+    /** 0–1 fraction of the total. */
+    readonly percent: number;
+}
+
+declare interface SmallSliceConfig {
+    /** 0-1 fraction of total. */
+    readonly threshold: number;
+    readonly label?: string;
+    /** `'auto'` resolves to a darker neutral at draw time. */
+    readonly color?: "auto" | string;
+}
+
+export declare type SmallSliceThresholdInput = false | number | SmallSliceConfig;
+
+export declare type SortOrder = "value-desc" | "value-asc" | "data-order" | "alphabetical";
+
+export declare const SPLIT_MIN_PX = 200;
+
+export declare type SpreadDisplayInput = false | true | "pill" | "inline";
+
+export declare type SpreadDisplayMode = "off" | "pill" | "inline";
+
+export declare type StackingMode = false | true | "normalized";
+
+/** Polymorphic prop:
+ *   `undefined | true` - built-in amber pill with pause icon
+ *   `false`            - no banner (overrides staleVisualization)
+ *   function           - custom HTML component (lib positions it top-center). */
+declare type StaleBannerProp = boolean | ((props: StaleBannerRenderProps) => React_2.ReactNode);
+
+/** Props passed to a custom stale-banner render-prop. Framework-agnostic
+ *  data shape - same widening pattern as `ConnectionIndicatorRenderProps`. */
+declare interface StaleBannerRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    theme: Theme;
+    palette: Palette;
+}
+
+/** Chart-wide stale-state visual treatment. */
+declare type StaleVisualization = "none" | "desaturate-pulse" | "banner" | "desaturate-pulse + banner";
+
+export declare class StaticLayerCache {
+    private cachedKey;
+    private cachedSurface;
+    /** Stats - flips a counter every hit / miss for benchmark + dev
+     *  inspection. Auditable side-effect. */
+    private hits;
+    private misses;
+    /** Returns the cached surface when `key` matches the prior call.
+     *  Returns null on miss; caller paints into the surface returned by
+     *  `acquireSurface(w, h, dpr)` next. */
+    lookup(key: StaticLayerCacheKey): HTMLCanvasElement | null;
+    /** Acquire (or recycle) the offscreen surface the caller will paint
+     *  into. Always recreated on size/DPR change (cheaper than scaling). */
+    acquireSurface(cssWidth: number, cssHeight: number, dpr: number): HTMLCanvasElement;
+    /** Commit the current surface to the cache under `key`. Caller calls
+     *  this after painting. */
+    commit(key: StaticLayerCacheKey): void;
+    /** Force a miss on the next lookup. */
+    invalidate(): void;
+    /** Inspection - useful for benches + dev audit. */
+    stats(): {
+        readonly hits: number;
+        readonly misses: number;
+    };
+}
+
+export declare interface StaticLayerCacheKey {
+    readonly cssWidth: number;
+    readonly cssHeight: number;
+    readonly dpr: number;
+    readonly themeFingerprint: string;
+    readonly dataFingerprint: string;
+    /** Hosts can suffix any extra state that affects the static layer. */
+    readonly extra: string;
+}
+
+export declare interface StochasticSpecInput extends IndicatorPaneCommon {
+    type: "stochastic";
+    kPeriod?: number;
+    dPeriod?: number;
+    smoothing?: number;
+    overbought?: number;
+    oversold?: number;
+}
+
+export declare function SunburstChart(props: SunburstChartProps): React_2.ReactElement;
+
+declare interface SunburstChartBaseProps {
+    /** Root hierarchy - a tree of `{ name, value?, children? }`. The
+     *  chart renders concentric rings, one per depth level. */
+    data?: HierarchyNode;
+    /** Default 'uniform'. */
+    radiusProportion?: RadiusProportion;
+    /** Default 'horizontal'. */
+    labelRotation?: LabelRotation;
+    /** Default false. Same shape as DonutChart's centerLabel. */
+    centerLabel?: boolean | string;
+    /** Inherited from PieChart-related axes - gap between slices. Default 1°. */
+    padAngle?: number;
+    /** Inherited from TreemapChart axes. */
+    labelBehavior?: LabelBehavior;
+    labelContent?: LabelContentInput;
+    depthLimit?: DepthLimitInput;
+    colorScale?: TreemapColorScale;
+    viewMode?: ViewMode;
+    breadcrumb?: boolean;
+    currentPath?: readonly string[];
+    onPathChange?: (path: readonly string[]) => void;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface SunburstChartProps extends SunburstChartBaseProps {
+    tooltip?: SunburstChartTooltipProp;
+}
+
+export declare type SunburstChartTooltipProp = undefined | false | ((props: SunburstChartTooltipProps) => React_2.ReactNode);
+
+export declare interface SunburstChartTooltipProps {
+    readonly idx: number;
+    readonly name: string;
+    readonly value: number;
+    readonly percent: number;
+    readonly depth: number;
+    readonly path: readonly string[];
+    readonly color: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type SyncYScale = "off" | "percent" | "absolute";
+
+declare type Theme = "light" | "dark";
+
+declare type ThemeInput = "inherit" | "light" | "dark" | "system";
+
+declare type ThemeSwitchTransition = "fade" | "none";
+
+export declare type ThresholdFill = false | true | ThresholdFillConfig;
+
+/** Optional config form of `thresholdFill`. */
+export declare interface ThresholdFillConfig {
+    /** Domain-space y to split at. Defaults to the resolved baseline value
+     *  when the user passes `thresholdFill: true`. */
+    value?: number;
+    /** CSS color for above-threshold runs. Defaults to `palette.up`. */
+    aboveColor?: string;
+    /** CSS color for below-threshold runs. Defaults to `palette.down`. */
+    belowColor?: string;
+}
+
+export declare type TileLayout = "squarify" | "slice-and-dice" | "strip" | "slice" | "dice" | "binary";
+
+declare type TimeFormat = "auto" | "24h" | "12h";
+
+export declare type TimeOffSource = "close" | "high-low";
+
+export declare interface TimeRange {
+    readonly start: number;
+    readonly end: number;
+}
+
+/** Per-palette declaration of the tonal-symmetry rule.
+ *  When `'positive'` or `'negative'`, the
+ *  chosen direction renders with the opposite-direction's color as
+ *  its stroke and a fully-transparent interior (regardless of
+ *  `visualStyle`). The non-chosen direction renders normally per
+ *  `visualStyle`. `'none'` disables the rule - both directions render
+ *  by their own palette color per `visualStyle`. */
+declare type TonalSymmetrySide = "positive" | "negative" | "none";
+
+/** Canonical list of tooltip-slot names the lib exposes.
+ *  Stored for audit + documentation; not used at runtime. */
+export declare const TOOLTIP_SLOT_NAMES: readonly ["tooltip", "markerTooltip", "signalTooltip", "orderTooltip", "positionTooltip", "eventTooltip", "drawingTooltip", "extremeTooltip", "volumeBarTooltip", "livePriceLineTooltip", "indicatorTooltip"];
+
+/** A tooltip slot's polymorphic input form. Used uniformly across
+ *  every tooltip prop (`tooltip`, `markerTooltip`, `signalTooltip`,
+ *  `orderTooltip`, `positionTooltip`, `eventTooltip`, `drawingTooltip`,
+ *  `extremeTooltip`, `volumeBarTooltip`, `livePriceLineTooltip`,
+ *  `indicatorTooltip`). Generic `P` is the chart-specific tooltip
+ *  props extending `BaseTooltipProps`. */
+export declare type TooltipInput<P> = false | true | ((props: P) => unknown);
+
+/** Per-series value at the hover-x. Every visible
+ *  series shows its value at the cursor in multi-series mode. */
+declare interface TooltipSeriesValue {
+    readonly id: string;
+    readonly label: string;
+    readonly color: string;
+    readonly value: number;
+}
+
+export declare type TooltipSlotName = (typeof TOOLTIP_SLOT_NAMES)[number];
+
+/** Reusable transferable-list builder. Caller passes the typed arrays
+ *  whose backing buffers should be transferred (zero-copy), and we
+ *  return the `Transferable[]` array `postMessage` consumes. */
+export declare function transferablesFor(arrs: readonly ArrayBufferView[]): Transferable[];
+
+export declare function TreemapChart(props: TreemapChartProps): React_2.ReactElement;
+
+declare interface TreemapChartBaseProps {
+    /** Root hierarchy - `{ name, value?, children? }`. The chart packs
+     *  children into rectangles proportional to their value. */
+    data?: HierarchyNode;
+    /** Default 'squarify'. */
+    tileLayout?: TileLayout;
+    /** Default 2 px. */
+    tilePadding?: number;
+    /** Default 4 px. */
+    parentChildPadding?: number;
+    /** Default 'auto'. */
+    labelBehavior?: LabelBehavior;
+    /** Default 'name + percent'. */
+    labelContent?: LabelContentInput;
+    /** Default 'all'. */
+    depthLimit?: DepthLimitInput;
+    /** Default 'flat-categorical'. */
+    colorScale?: TreemapColorScale;
+    /** Default 'nested'. */
+    viewMode?: ViewMode;
+    /** Default true (drill-down only). */
+    breadcrumb?: boolean;
+    /** Controlled-mode current path (drill-down only). When omitted, the
+     *  controller manages an internal session-state path. */
+    currentPath?: readonly string[];
+    /** Controlled-mode change handler. Required if `currentPath` is set. */
+    onPathChange?: (path: readonly string[]) => void;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+    /** Pattern fills. */
+    pattern?: PatternInput;
+    patternScale?: number;
+    patternColor?: PatternColorInput;
+    ariaLabel?: string;
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare interface TreemapChartProps extends TreemapChartBaseProps {
+    tooltip?: TreemapChartTooltipProp;
+}
+
+export declare type TreemapChartTooltipProp = undefined | false | ((props: TreemapChartTooltipProps) => React_2.ReactNode);
+
+export declare interface TreemapChartTooltipProps {
+    readonly idx: number;
+    readonly name: string;
+    readonly value: number;
+    readonly percent: number;
+    readonly depth: number;
+    readonly path: readonly string[];
+    readonly color: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+
+export declare type TreemapColorScale = "flat-categorical" | "depth-gradient" | "value-heat" | "directional";
+
+/** Try to obtain a WebGL2 context. Wraps the `getContext` call in
+ *  try/catch + reports `null` on any error so the chart can fall back
+ *  to canvas2d without crashing. */
+export declare function tryGetWebgl2(canvas: HTMLCanvasElement): WebGL2RenderingContext | null;
+
+/** Hook for charts to read shared group state. Returns `null` when no
+ *  `<ChartGroup>` is in the React tree - children behave standalone. */
+export declare function useChartGroup(): ChartGroupContextValue | null;
+
+export declare function useChartsContext(): ChartsProviderValue;
+
+export declare function useChartTheme(perChartTheme?: ThemeInput): Theme;
+
+/** React hook: own a streaming Engine + an SoA mirror; expose
+ *  `pushTick` + a `BinaryCandleSeriesInput` snapshot. */
+export declare function useStreamingCandles(opts: UseStreamingCandlesOptions): UseStreamingCandlesResult;
+
+export declare interface UseStreamingCandlesOptions {
+    /** Bucket timeframe in minutes (e.g. `1` for 1-minute bars). */
+    timeframeMinutes: number;
+    /** Market kind - controls trading-hours / DST rules. */
+    market: MarketKind;
+    /** Capacity of the bar ring buffer. Once full, the oldest bar is
+     *  evicted on the next `AppendNew`. Default `5_000`. */
+    capacity?: number;
+    /** Validator bounds for the engine. */
+    minPriceRaw: number;
+    maxPriceRaw: number;
+    maxVolumeRaw: number;
+    /** Anomaly policy - values < 0 / NaN disable that specific check.
+     *  See engine `setAnomalyPolicy`. */
+    anomalyPolicy?: {
+        maxRelativePriceJump?: number;
+        rejectZeroVolumeTrade?: boolean;
+        clockSkewToleranceMs?: number;
+        maxGapMs?: number;
+    };
+    /** Audit callback - fires per-tick `accept` / `reject`, plus
+     *  `candle-rolled` and policy-change events. Engine signature:
+     *  `(kind: number, tsMs: number, priceRaw: number, rejectReasonCode: number)`. */
+    onAudit?: (kind: number, tsMs: number, priceRaw: number, rejectReasonCode: number) => void;
+    /** Telemetry callback - fires per-tick a counter name string
+     *  (`'ticks_accepted'`, `'ticks_rejected_<reason>'`, `'candles_rolled'`). */
+    onTelemetry?: (name: string) => void;
+}
+
+export declare interface UseStreamingCandlesResult {
+    /** Snapshot of the current bars in `BinaryCandleSeriesInput` form.
+     *  The wrapping object is fresh per tick (so React's referential
+     *  equality check sees the change), but the underlying typed-array
+     *  buffers are reused. Pass directly to `<CandleChart data={candles} />`. */
+    candles: BinaryCandleSeriesInput;
+    /** Number of bars currently in the ring (≤ `capacity`). */
+    length: number;
+    /** Push a tick to the engine. Throws if the engine rejected the
+     *  tick (out-of-bounds price/volume, strictly older timestamp). */
+    pushTick: (tsMs: number, priceRaw: number, volumeRaw: number) => void;
+    /** Reset the engine + clear the bar buffer. */
+    reset: () => void;
+    /** Whether the engine is ready (WASM loaded). Pre-init `pushTick`
+     *  calls are buffered and replayed once the engine is ready. */
+    ready: boolean;
+}
+
+export declare type ValueLabelPosition = "auto" | "inside" | "outside" | "top" | "bottom";
+
+export declare type ValueLabels = false | true | LabelConfig;
+
+export declare type ViewMode = "nested" | "drill-down";
+
+export declare const VISIBLE_MARK_THRESHOLD = 50000;
+
+declare type VisualStyle = "Fill" | "Outline";
+
+/** Volume-bar tooltip render-prop param shape - framework-agnostic.
+ *  Mirrors `VolumeBarTooltipProps` in both `react/tooltips/default-volume-
+ *  bar-tooltip` and `solid/tooltips/default-volume-bar-tooltip`. The
+ *  controller's `volumeBarTooltip` widens the return type to `unknown`
+ *  so both the React adapter (`React.ReactNode`) and the Solid adapter
+ *  (`JSX.Element`) pass type-check via covariance. */
+export declare interface VolumeBarTooltipProps {
+    bar: {
+        t: number;
+        v: number;
+        idx: number;
+    };
+    avg20: number;
+    percentile: number;
+    pointerX: number;
+    pointerY: number;
+    containerWidth: number;
+    containerHeight: number;
+    theme: Theme;
+    palette: Palette;
+    locale: string;
+    timeZone: string | undefined;
+    formatter: ChartFormatter;
+}
+
+/** Volume bar coloring mode. */
+export declare type VolumeColoring = "by-direction" | "single" | "by-magnitude";
+
+export declare type VolumePlacement = "subpane" | "overlay";
+
+/** Volume bar scale. */
+export declare type VolumeScale = "linear" | "log";
+
+export declare type WheelBehavior = 
+/** Mouse-wheel zooms (default). Hosts may flip to scroll-only. */
+"zoom"
+/** Wheel scrolls the page; charts ignore wheel. */
+| "scroll"
+/** Wheel zooms only with the modifier key held. */
+| "ctrl-zoom";
+
+/** `'body'` = wick tracks the body's directional
+ *  color; `'neutral'` = wick uses `palette.neutral`; literal hex =
+ *  override. */
+export declare type WickColor = "body" | "neutral" | string;
+
+/** Host → worker. The host transfers the `OffscreenCanvas` reference
+ *  once during `init`; subsequent paints reuse the same canvas. Numeric
+ *  buffers are transferable typed arrays. */
+export declare type WorkerInput = {
+    readonly kind: "init";
+    readonly canvas: OffscreenCanvas;
+    readonly dpr: number;
+} | {
+    readonly kind: "resize";
+    readonly cssWidth: number;
+    readonly cssHeight: number;
+    readonly dpr: number;
+} | {
+    readonly kind: "paint";
+    readonly times: Float64Array;
+    readonly values: Float64Array;
+    readonly payload: Record<string, unknown>;
+} | {
+    readonly kind: "dispose";
+};
+
+/** Worker → host. The host updates UI based on these. */
+export declare type WorkerOutput = {
+    readonly kind: "ready";
+} | {
+    readonly kind: "painted";
+    readonly frameMs: number;
+} | {
+    readonly kind: "error";
+    readonly message: string;
+};
+
+declare type XAxisPosition = "top" | "bottom";
+
+export declare type YAxisMode = "frequency" | "density" | "cumulative";
+
+declare type YAxisPosition = "left" | "right";
+
+export declare type ZoomAnchor = 
+/** Anchor at the mouse / touch position (default). */
+"pointer"
+/** Anchor at the chart center. */
+| "center";
+
+export { }