@abdullahjaswal/tickyr-charts 0.1.0

package/dist/solid.d.ts

@@ -0,0 +1,2971 @@
+import { Accessor } from 'solid-js';
+import { JSX } from 'solid-js';
+import { ParentComponent } from 'solid-js';
+
+/** 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): JSX.Element;
+
+export declare interface AreaChartProps extends Omit<LineChartProps, "areaFill"> {
+    baseline?: AreaBaseline;
+    fillType?: AreaFillType;
+    fillOpacity?: number;
+    thresholdFill?: ThresholdFill;
+    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 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): JSX.Element;
+
+export declare interface BarChartProps {
+    data?: BarChartSeriesInput;
+    series?: readonly BarSeriesConfig[];
+    grouping?: BarGrouping;
+    groupPadding?: number;
+    orientation?: Orientation;
+    valueLabels?: ValueLabels;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    tooltip?: BarChartTooltipProp;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    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;
+    barWidthRatio?: number;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+
+export declare type BarChartSeriesInput = LineSeriesInput;
+
+export declare type BarChartTooltipProp = undefined | false | ((props: BarChartTooltipProps) => JSX.Element);
+
+export declare interface BarChartTooltipProps {
+    readonly t: number;
+    readonly idx: number;
+    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";
+
+export declare type BarGrouping = "clustered" | "stacked" | "normalized" | "overlapping";
+
+export declare interface BarSeriesConfig {
+    readonly id: string;
+    readonly data: BarChartSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+}
+
+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 function CandleChart(props: CandleChartProps): JSX.Element;
+
+/** Imperative handle exposed via `ref` on `<CandleChart>`. Binary
+ *  data ingestion - primitive args. */
+declare interface CandleChartHandle {
+    /** Push a live tick. Updates high/low/close of the most recent bar
+     *  in-place; the host owns bar progression (call `update({ data })`
+     *  with a fresh last bar to start a new bucket). */
+    onTick(time: number, price: number, size?: number): void;
+}
+
+export declare interface CandleChartProps {
+    /** Solid ref callback - receives the imperative handle after mount. */
+    ref?: (handle: CandleChartHandle) => void;
+    data: CandleSeriesInput;
+    historyData?: CandleSeriesInput;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    cornerRadius?: number;
+    borderWidth?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    candleType?: CandleType;
+    bodyWidthRatio?: number;
+    wickWidth?: number;
+    wickColor?: WickColor;
+    dojiMinBodyHeight?: number;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    crosshairPaneSync?: boolean;
+    tooltip?: CandleChartTooltipProp;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+    lastPriceLine?: LastPriceLineStyle;
+    lastPriceLabel?: boolean;
+    highLowMarkers?: HighLowMarkers;
+    extremeTooltip?: ExtremeTooltipProp;
+    volumeVisible?: boolean;
+    volumePlacement?: VolumePlacement;
+    volumeColoring?: VolumeColoring;
+    volumeSingleColor?: "auto" | string;
+    volumeScale?: VolumeScale;
+    volumeHeightRatio?: number;
+    volumeBarTooltip?: boolean | ((props: VolumeBarTooltipProps) => JSX.Element);
+    indicators?: readonly IndicatorPaneSpec[];
+    indicatorLineWidth?: number;
+    indicatorLineStyle?: IndicatorLineStyle;
+    indicatorOpacity?: number;
+    liveBarIndicator?: LiveBarIndicator;
+    connectionIndicator?: ConnectionIndicator;
+    liveSince?: number;
+    connectionState?: LiveState;
+    staleThreshold?: number;
+    staleVisualization?: StaleVisualization;
+    staleBanner?: boolean | ((p: {
+        state: LiveState;
+        liveSince: number | undefined;
+        theme: Theme;
+        palette: Palette;
+    }) => JSX.Element);
+    legendPosition?: LegendPosition;
+    reducedMotion?: boolean;
+    barEntryAnimation?: BarEntryAnimation;
+    barUpdateAnimation?: BarUpdateAnimation;
+    drawings?: readonly Drawing[];
+    signals?: readonly SignalMarker[];
+    orders?: readonly OrderMarker[];
+    position?: PositionMarker;
+    events?: readonly EventMarker[];
+    signalTooltip?: false | ((p: SignalTooltipProps) => JSX.Element);
+    orderTooltip?: false | ((p: OrderTooltipProps) => JSX.Element);
+    positionTooltip?: false | ((p: PositionTooltipProps) => JSX.Element);
+    eventTooltip?: false | ((p: EventTooltipProps) => JSX.Element);
+}
+
+export declare type CandleChartTooltipProp = undefined | false | ((props: CandleChartTooltipProps) => JSX.Element);
+
+/** 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;
+
+export declare type CandleType = "solid" | "heikin-ashi" | "ohlc-bars";
+
+export declare type CellShape = "rect" | "circle";
+
+export declare type CenterLabelProp = false | true | string | ((data: DonutCenterLabelData) => JSX.Element);
+
+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): JSX.Element;
+
+export declare function ChartGroupBrush(props: ChartGroupBrushProps): JSX.Element;
+
+export declare interface ChartGroupBrushProps {
+    readonly domain: {
+        start: number;
+        end: number;
+    };
+    readonly width?: number;
+    readonly height?: number;
+    readonly trackColor?: string;
+    readonly selectionColor?: string;
+    readonly handleColor?: string;
+}
+
+declare interface ChartGroupContextValue {
+    readonly options: () => ChartGroupOptions;
+    readonly state: ChartGroupState;
+    readonly version: () => number;
+}
+
+export declare function ChartGroupNavigator(props: ChartGroupNavigatorProps): JSX.Element;
+
+export declare interface ChartGroupNavigatorProps {
+    readonly data: LineSeriesInput;
+    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?: JSX.Element;
+    onSelectionChange?: (time: number | null) => void;
+    onBrushChange?: (range: TimeRange | null) => void;
+    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 const ChartsProvider: ParentComponent<ChartsProviderProps>;
+
+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. */
+    palettes?: readonly Palette[];
+    children?: JSX.Element;
+}
+
+export declare interface ChartsProviderValue {
+    theme: ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: VisualStyle;
+    outlineFillColor: "auto" | string;
+    outlineFillOpacity: number;
+    cornerRadius: number;
+    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";
+
+export declare type ConnectionIndicatorProp = ConnectionIndicator | ((props: ConnectionIndicatorRenderProps) => JSX.Element);
+
+export 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_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_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): JSX.Element;
+
+export declare function DefaultExtremeTooltip(p: ExtremeTooltipProps): JSX.Element;
+
+export declare function DefaultTooltip(props: LineChartTooltipProps): JSX.Element;
+
+export declare function DefaultVolumeBarTooltip(props: VolumeBarTooltipProps): JSX.Element;
+
+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): JSX.Element;
+
+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) => JSX.Element);
+
+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];
+}
+
+export declare interface DonutCenterLabelData {
+    readonly totalValue: number;
+    readonly formatter: ChartFormatter;
+    readonly theme: Theme;
+    readonly palette: Palette;
+}
+
+export declare function DonutChart(props: DonutChartProps): JSX.Element;
+
+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 interface EventTooltipProps {
+    marker: EventMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+
+export declare type ExtremeTooltipProp = boolean | ((props: ExtremeTooltipProps) => JSX.Element);
+
+/** 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): JSX.Element;
+
+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) => JSX.Element);
+
+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";
+
+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): JSX.Element;
+
+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) => JSX.Element);
+
+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";
+
+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): JSX.Element;
+
+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) => JSX.Element);
+
+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 function LineChart(props: LineChartProps): JSX.Element;
+
+/** Imperative handle exposed via `ref` on `<LineChart>`. Lets the host
+ *  push live-tick updates without re-rendering the Solid component.
+ *  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;
+};
+
+export declare interface LineChartProps {
+    /** Solid ref callback - receives the imperative handle after mount. */
+    ref?: (handle: LineChartHandle) => void;
+    data?: LineSeriesInput;
+    historyData?: LineSeriesInput;
+    series?: readonly SeriesConfig[];
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    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;
+    crosshairVisible?: boolean;
+    crosshairSnap?: CrosshairSnap;
+    crosshairMode?: CrosshairMode;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    tooltip?: LineChartTooltipProp;
+    indicators?: readonly LineChartIndicatorSpec[];
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+    lastPriceLine?: LastPriceLineStyle;
+    lastPriceLabel?: boolean;
+    chartBgColor?: string;
+    highLowMarkers?: HighLowMarkers;
+    extremeTooltip?: ExtremeTooltipProp;
+    liveBarIndicator?: LiveBarIndicator;
+    connectionIndicator?: ConnectionIndicatorProp;
+    legendPosition?: LegendPosition;
+    legend?: LegendVisibility;
+    staleVisualization?: StaleVisualization;
+    staleBanner?: StaleBannerProp;
+    liveSince?: number;
+    connectionState?: LiveState;
+    staleThreshold?: number;
+    reducedMotion?: boolean;
+    curveType?: CurveType;
+    stepEdgeRadius?: number;
+    lineWidth?: number;
+    lineDash?: LineDash;
+    lineDashSpacing?: number;
+    pointMarkers?: PointMarkers;
+    areaFill?: AreaFillConfig;
+    glow?: GlowInput;
+    glowColor?: GlowColorInput;
+}
+
+export declare type LineChartTooltipProp = boolean | ((props: LineChartTooltipProps) => JSX.Element);
+
+/** 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";
+
+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 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 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): JSX.Element;
+
+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) => JSX.Element);
+
+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): JSX.Element;
+
+export declare interface PointFigureChartProps extends PnFChartBaseProps {
+    tooltip?: PointFigureChartTooltipProp;
+}
+
+export declare type PointFigureChartTooltipProp = undefined | false | ((props: PnFChartTooltipProps) => JSX.Element);
+
+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 interface PositionTooltipProps {
+    marker: PositionMarker;
+    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;
+}
+
+export declare function renderExtremeTooltip(prop: ExtremeTooltipProp | undefined, tooltipProps: ExtremeTooltipProps): JSX.Element;
+
+export declare function RenkoChart(props: RenkoChartProps): JSX.Element;
+
+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) => JSX.Element);
+
+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 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 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;
+}
+
+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;
+});
+
+export declare interface ResolvedSmallSliceThreshold {
+    readonly threshold: number;
+    readonly label: string;
+    readonly color: "auto" | string;
+}
+
+/** 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>;
+
+declare interface RsiSpecInput extends IndicatorPaneCommon {
+    type: "rsi";
+    period?: number;
+    overbought?: number;
+    oversold?: number;
+}
+
+export declare function ScatterChart(props: ScatterChartProps): JSX.Element;
+
+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) => JSX.Element);
+
+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;
+}
+
+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. */
+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 SignalSide = "buy" | "sell";
+
+declare interface SignalTooltipProps {
+    marker: SignalMarker;
+    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";
+
+export declare type StaleBannerProp = boolean | ((props: StaleBannerRenderProps) => JSX.Element);
+
+export 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;
+}
+
+declare interface StochasticSpecInput extends IndicatorPaneCommon {
+    type: "stochastic";
+    kPeriod?: number;
+    dPeriod?: number;
+    smoothing?: number;
+    overbought?: number;
+    oversold?: number;
+}
+
+export declare function SunburstChart(props: SunburstChartProps): JSX.Element;
+
+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) => JSX.Element);
+
+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";
+
+export declare type ThresholdFill = false | true | ThresholdFillConfig;
+
+export declare interface ThresholdFillConfig {
+    value?: number;
+    aboveColor?: string;
+    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. */
+export 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): JSX.Element;
+
+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) => JSX.Element);
+
+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;
+
+export declare function useChartGroup(): ChartGroupContextValue | null;
+
+/** Returns an accessor - call as `ctx()` to read the current provider value.
+ *  Mirrors React's `useChartsContext()` shape semantically; in Solid the
+ *  return is a getter so reactivity propagates through the chart components. */
+export declare function useChartsContext(): () => ChartsProviderValue;
+
+export declare function useChartTheme(perChartTheme?: ThemeInput): () => Theme;
+
+export declare function useStreamingCandles(opts: UseStreamingCandlesOptions): UseStreamingCandlesResult;
+
+export declare interface UseStreamingCandlesOptions {
+    timeframeMinutes: number;
+    market: MarketKind;
+    capacity?: number;
+    minPriceRaw: number;
+    maxPriceRaw: number;
+    maxVolumeRaw: number;
+    anomalyPolicy?: {
+        maxRelativePriceJump?: number;
+        rejectZeroVolumeTrade?: boolean;
+        clockSkewToleranceMs?: number;
+        maxGapMs?: number;
+    };
+    onAudit?: (kind: number, tsMs: number, priceRaw: number, rejectReasonCode: number) => void;
+    onTelemetry?: (name: string) => void;
+}
+
+export declare interface UseStreamingCandlesResult {
+    /** Accessor - call as `candles()` to read the latest snapshot. The
+     *  wrapping object is fresh per tick (so equality checks see the change),
+     *  but the underlying typed-array buffers are reused. */
+    candles: Accessor<BinaryCandleSeriesInput>;
+    /** Accessor for the current bar count. */
+    length: Accessor<number>;
+    pushTick: (tsMs: number, priceRaw: number, volumeRaw: number) => void;
+    reset: () => void;
+    /** Accessor - `true` once WASM is loaded; pre-init `pushTick` calls are
+     *  buffered and replayed once the engine is ready. */
+    ready: Accessor<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;
+}
+
+export declare type VolumeColoring = "by-direction" | "single" | "by-magnitude";
+
+export declare type VolumePlacement = "subpane" | "overlay";
+
+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";
+
+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 { }