@abdullahjaswal/tickyr-charts 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1725 @@
+import * as React_2 from 'react';
+
+export declare interface Anchor {
+    /** Time in ms since the epoch. */
+    t: number;
+    /** Price (in the chart's price scale). */
+    y: number;
+}
+
+/** Anchor count required for each drawing type. The chart's drawing
+ *  pipeline asserts that `drawing.anchors.length >= ANCHOR_COUNTS[type]`. */
+export declare const ANCHOR_COUNTS: Record<DrawingType, number>;
+
+export declare const ANIMATION_DEFAULTS: AnimationAxes;
+
+declare interface AnimationAxes {
+    barEntryAnimation: BarEntryAnimation;
+    barUpdateAnimation: BarUpdateAnimation;
+    /** ms ≥ 0; clamps to 0 under reduced-motion. */
+    crosshairFadeDuration: number;
+    /** ms ≥ 0; clamps to 0 under reduced-motion. */
+    tooltipFadeDuration: number;
+    panZoomSmoothing: boolean;
+    themeSwitchTransition: ThemeSwitchTransition;
+}
+
+declare interface AnimationInputs {
+    barEntryAnimation?: BarEntryAnimation;
+    barUpdateAnimation?: BarUpdateAnimation;
+    crosshairFadeDuration?: number;
+    tooltipFadeDuration?: number;
+    panZoomSmoothing?: boolean;
+    themeSwitchTransition?: ThemeSwitchTransition;
+}
+
+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";
+
+declare interface AtrSpecInput extends IndicatorPaneCommon {
+    type: "atr";
+    period?: number;
+}
+
+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;
+}
+
+export 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;
+}
+
+export declare type BarUpdateAnimation = "none" | "morph + flash-direction" | "morph" | "flash-neutral" | "flash-direction" | "pulse" | "glow" | "tick-line" | "flicker" | "rise";
+
+export declare interface BinaryCandleSeriesInput {
+    times: Float64Array;
+    opens: Float64Array;
+    highs: Float64Array;
+    lows: Float64Array;
+    closes: Float64Array;
+    volumes?: Float64Array;
+}
+
+export declare const BUILT_IN_PALETTES: {
+    readonly Monochrome: Palette;
+    readonly Classic: Palette;
+    readonly Accessible: Palette;
+};
+
+export declare type BuiltInPaletteName = keyof typeof BUILT_IN_PALETTES;
+
+export 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 class CandleSeries {
+    #private;
+    readonly times: Float64Array;
+    readonly opens: Float64Array;
+    readonly highs: Float64Array;
+    readonly lows: Float64Array;
+    readonly closes: Float64Array;
+    readonly volumes: Float64Array | null;
+    readonly length: number;
+    constructor(times: Float64Array, opens: Float64Array, highs: Float64Array, lows: Float64Array, closes: Float64Array, volumes: Float64Array | null);
+    get revisionId(): number;
+    bumpRevision(): number;
+}
+
+export 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";
+
+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 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;
+}
+
+/** Concatenate two ingested `CandleSeries` (history first, visible
+ *  second). Re-runs ingestion on the combined typed arrays so the
+ *  result is validated as a single monotonic series (catches
+ *  history that overlaps the visible window via duplicate / out-of-
+ *  order timestamps).
+ *
+ *  When the history series is empty, returns the visible unchanged
+ *  (zero-allocation fast path). */
+export declare function concatCandleSeries(history: CandleSeries, visible: CandleSeries): CandleSeries;
+
+/** Concatenate two ingested `LineSeries`. Same contract as
+ *  `concatCandleSeries`. */
+export declare function concatLineSeries(history: LineSeries, visible: LineSeries): LineSeries;
+
+/** Connection-indicator modes. */
+export 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";
+
+declare type CurveType = CurveTypeName | CurveTypeConfig;
+
+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;
+}
+
+declare type CurveTypeName = "linear" | "monotone" | "monotone-x" | "monotone-y" | "step" | "step-before" | "step-after" | "bump" | "bump-x" | "bump-y" | "natural" | "basis" | "cardinal" | "catmull-rom";
+
+export declare class DataValidationError extends Error {
+    readonly name = "DataValidationError";
+}
+
+declare type DateFormat = "auto" | "short" | "medium" | "iso";
+
+declare type DecimalPlaces = "auto" | number;
+
+export declare function DefaultCandleTooltip(props: CandleChartTooltipProps): React_2.ReactElement;
+
+export declare function DefaultTooltip(props: LineChartTooltipProps): React_2.ReactElement;
+
+export declare function DefaultVolumeBarTooltip(props: VolumeBarTooltipProps): React_2.ReactElement;
+
+export declare function deriveLiveState(input: LiveStateInput): LiveState;
+
+declare type DigitGrouping = "international" | "lakh-crore" | "none";
+
+export 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>;
+}
+
+export 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;
+}
+
+export declare type DrawingType = "trend-line" | "horizontal-line" | "vertical-line" | "rectangle" | "ellipse" | "arrow" | "text" | "fib-retracement" | "fib-extension" | "pitchfork" | "channel" | "brush";
+
+export declare type EventKind = "earnings" | "dividend" | "split" | "news";
+
+export 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;
+}
+
+/** Standard fib extension levels. */
+export declare const FIB_EXTENSION_LEVELS: readonly [1, 1.272, 1.414, 1.618, 2, 2.618];
+
+/** Standard fib retracement levels. */
+export declare const FIB_RETRACEMENT_LEVELS: readonly [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+
+/** `'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. */
+declare type GlowColorInput = "auto" | string;
+
+/** Host-supplied input. Named presets resolve to fixed strengths; numeric
+ *  values clamp to `[0, 1]`. */
+declare type GlowInput = GlowPreset | number;
+
+declare type GlowPreset = "off" | "subtle" | "standard" | "intense";
+
+declare type GridStyle = "solid" | "dashed" | "dotted";
+
+/** Marker mode for the visible-window high / low. */
+export declare type HighLowMarkers = "off" | "lines+labels" | "labels-only";
+
+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;
+
+export declare function isValidDrawing(d: Drawing): boolean;
+
+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 LastPriceLineStyle = "off" | "solid" | "dashed" | "dotted";
+
+/** Corner anchor for the legend. */
+export declare type LegendPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+
+/** Legend visibility. */
+declare type LegendVisibility = "always" | "on-hover" | "off";
+
+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;
+}
+
+declare type LineDash = "solid" | "dashed" | "dotted" | readonly number[];
+
+export declare interface LinePoint {
+    t: number;
+    value: number;
+}
+
+declare class LineSeries {
+    #private;
+    readonly times: Float64Array;
+    readonly values: Float64Array;
+    readonly length: number;
+    constructor(times: Float64Array, values: Float64Array);
+    get revisionId(): number;
+    bumpRevision(): number;
+}
+
+export declare type LineSeriesInput = {
+    points: readonly LinePoint[];
+} | {
+    times: Float64Array;
+    values: Float64Array;
+};
+
+declare type Listener = () => void;
+
+export declare function listPalettes(): readonly string[];
+
+/** Live-bar indicator modes. */
+export declare type LiveBarIndicator = "none" | "dot" | "badge" | "glow" | "outline" | "pulse-bar";
+
+export declare type LiveState = "live" | "stale" | "disconnected";
+
+declare interface LiveStateInput {
+    /** Explicit override from host. When set, wins over auto-detection. */
+    readonly connectionState?: LiveState | undefined;
+    /** ms timestamp of the last successful tick. Undefined → no signal. */
+    readonly liveSince?: number | undefined;
+    /** ms; 0 disables auto-detection. */
+    readonly staleThreshold: number;
+    /** ms; clock used for the freshness comparison. Pure → injectable. */
+    readonly now: number;
+}
+
+declare interface MacdSpecInput extends IndicatorPaneCommon {
+    type: "macd";
+    fastPeriod?: number;
+    slowPeriod?: number;
+    signalPeriod?: number;
+    histogramVisible?: boolean;
+}
+
+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). */
+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);
+
+declare type MarkerStyle = "circle" | "square" | "diamond" | "triangle" | "triangle-down" | "cross" | "plus" | "star" | "direction" | "custom";
+
+declare type MarketKind = "equity" | "dst-equity" | "crypto-24-7";
+
+/** Fire all registered listeners. Hosts call this when the platform
+ *  signals memory pressure (e.g. iOS `didReceiveMemoryWarning` bridged
+ *  through to web, or a manual host-side throttle). The lib also calls
+ *  it internally from the visibility helper when a chart returns from
+ *  > 5 minutes of background time (TODO - wire from VisibilityGate). */
+export declare function notifyMemoryPressure(): void;
+
+declare type NumberAbbreviation = "off" | "compact" | "lakh-crore" | "auto";
+
+export declare interface Oklch {
+    L: number;
+    C: number;
+    h: number;
+}
+
+export declare function oklchToHex({ L, C, h }: Oklch, alpha?: number): string;
+
+export declare function oklchToRgbF(o: Oklch): RgbF;
+
+/** Register a callback that fires whenever `notifyMemoryPressure()` is
+ *  called. Returns an unsubscribe function. Caches register at module
+ *  load time. Order of dispatch is registration order. */
+export declare function onMemoryPressure(cb: Listener): () => void;
+
+export 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";
+
+export declare type OrderSide = "buy" | "sell";
+
+declare interface OrderTooltipProps {
+    marker: OrderMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+
+declare type Orientation = "vertical" | "horizontal";
+
+export 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;
+    };
+}
+
+declare type PatternColorInput = "auto" | string;
+
+/** Host-supplied input - string preset, config form, or a literal
+ *  `CanvasPattern` (full dev control). */
+declare type PatternInput = PatternPreset | {
+    readonly type: PatternPreset;
+    readonly scale?: number;
+    readonly lineWidth?: number;
+    readonly color?: string;
+} | CanvasPattern;
+
+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;
+
+declare type PointMarkers = boolean | MarkerConfig;
+
+export 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 function registerPalette(palette: Palette): void;
+
+export declare function resolveAnimation(input: AnimationInputs, reducedMotion: boolean): AnimationAxes;
+
+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 RgbF {
+    r: number;
+    g: number;
+    b: number;
+}
+
+declare interface RsiSpecInput extends IndicatorPaneCommon {
+    type: "rsi";
+    period?: number;
+    overbought?: number;
+    oversold?: 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]`. */
+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;
+}
+
+export 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";
+
+export 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;
+}
+
+/** Slice the leading `n` values off a typed-array indicator output.
+ *  Zero-copy via `subarray()`. Used to drop the warmup-history
+ *  portion of an indicator result so the remainder aligns with the
+ *  visible data window. */
+export declare function sliceLeading(values: Float64Array, n: number): Float64Array;
+
+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. */
+export declare type StaleVisualization = "none" | "desaturate-pulse" | "banner" | "desaturate-pulse + banner";
+
+declare interface StochasticSpecInput extends IndicatorPaneCommon {
+    type: "stochastic";
+    kPeriod?: number;
+    dPeriod?: number;
+    smoothing?: number;
+    overbought?: number;
+    oversold?: number;
+}
+
+export declare type Theme = "light" | "dark";
+
+export declare type ThemeInput = "inherit" | "light" | "dark" | "system";
+
+export 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;
+}
+
+declare type TimeFormat = "auto" | "24h" | "12h";
+
+/** 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";
+
+/** 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 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 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";
+
+/** `'body'` = wick tracks the body's directional
+ *  color; `'neutral'` = wick uses `palette.neutral`; literal hex =
+ *  override. */
+export declare type WickColor = "body" | "neutral" | string;
+
+declare type XAxisPosition = "top" | "bottom";
+
+declare type YAxisPosition = "left" | "right";
+
+export { }