@rioaxyz/sonrchart 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1116 @@
+import * as react from 'react';
+import { RefObject, ReactNode, CSSProperties, ButtonHTMLAttributes } from 'react';
+import { Point, Nullable, DeepPartial, OverlayStyle, OverlayMode, Chart, KLineData, Styles, PeriodType, OverlayCreateFiguresCallbackParams, OverlayFigure, Coordinate } from 'klinecharts';
+
+/** One saved overlay in a drawing template — the canonical serialized shape of
+ *  a user drawing, shared by ChartState.drawings and SonrChart's snapshot/
+ *  restore. Field types mirror KLineChart's `Overlay`, so a snapshot round-trips
+ *  straight back into `createOverlay` with no casts. */
+interface DrawingSnapshotItem {
+    name: string;
+    points: Array<Partial<Point>>;
+    styles?: Nullable<DeepPartial<OverlayStyle>>;
+    mode?: OverlayMode;
+    extendData?: unknown;
+}
+/** A full drawing template: the user overlays captured at save time. */
+type DrawingSnapshot = DrawingSnapshotItem[];
+/** Named-drawing-set store with change subscription (for a settings UI). */
+declare class DrawingTemplateStore {
+    private templates;
+    private subs;
+    /** Save (or overwrite) a named template from a drawing snapshot. */
+    save(name: string, snap: DrawingSnapshot): void;
+    /** The saved snapshot for a name, or undefined if there is none. */
+    get(name: string): DrawingSnapshot | undefined;
+    /** Names of all saved templates, in insertion order. */
+    list(): string[];
+    /** Remove a template. No-op if the name is unknown. */
+    delete(name: string): void;
+    /** Subscribe to list changes (save/delete). Returns an unsubscribe fn. */
+    subscribe(cb: () => void): () => void;
+    private notify;
+}
+
+/** One OHLC(V) bar. `time` is milliseconds since the Unix epoch. */
+interface Bar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+/** Chart interval token. Seconds ("10S"/"30S"), minutes ("1".."30"),
+ *  hour ("60"), or daily ("D"). Host apps may pass any string a matching
+ *  DataSource understands; these are what the built-in period mapping knows. */
+type Interval = "10S" | "30S" | "1" | "5" | "15" | "30" | "60" | "D" | (string & {});
+/** Resolved metadata for a symbol (issue #8). All fields optional except the
+ *  ticker; the host supplies whatever it knows. */
+interface SymbolInfo {
+    ticker: string;
+    name?: string;
+    /** Decimal places for prices; drives the y-axis format. */
+    pricePrecision?: number;
+    /** Decimal places for volume. */
+    volumePrecision?: number;
+    /** ISO currency code or symbol prices are quoted in (e.g. "USD", "$", "€").
+     *  Prefixed to prices in the legend / crosshair pill. */
+    currency?: string;
+    /** Unit prices are quoted in (e.g. "pts", "¢", "bps"). Suffixed to prices. */
+    unit?: string;
+    /** URL (or data URI) for the symbol's logo, shown in the info dialog + legend. */
+    logo?: string;
+    /** URL (or data URI) for the listing exchange's logo. */
+    exchangeLogo?: string;
+    /** Long-form description of the instrument, shown in the info dialog. */
+    description?: string;
+    /** Where the price data originates (e.g. "Alpaca", "IEX"), shown in the dialog. */
+    priceSource?: string;
+}
+/** One hit from a symbol search (issue #37). Only `symbol` is required; the
+ *  datafeed supplies whatever else it knows to help the user disambiguate. */
+interface SymbolSearchResult {
+    symbol: string;
+    name?: string;
+    exchange?: string;
+    type?: string;
+    /** URL (or data URI) for the symbol's logo, shown beside the result (#39). */
+    logo?: string;
+}
+/**
+ * How sonrchart gets its data. This is the whole integration seam: the
+ * component knows nothing about where bars come from, so any host — a REST
+ * API, a websocket, a local file, synthetic data — implements this.
+ */
+interface DataSource {
+    /** Return the most-recent `count` bars for a symbol/interval, oldest→newest. */
+    getBars(symbol: string, interval: Interval, count: number): Promise<Bar[]>;
+    /**
+     * Optional live feed. Call `onBar` for every new/updated bar (forming or
+     * closed). Return an unsubscribe function. Omit for a static chart.
+     */
+    subscribe?(symbol: string, interval: Interval, onBar: (bar: Bar) => void): () => void;
+    /**
+     * Optional symbol resolution (issue #8). Validate/enrich a ticker before it
+     * loads. Return `null` for an unknown symbol (the chart fires `onSymbolError`
+     * and skips loading), or a SymbolInfo to set precision/name.
+     */
+    resolveSymbol?(symbol: string): Promise<SymbolInfo | null>;
+    /**
+     * Optional symbol search (issue #37). Given a partial query, return matching
+     * symbols for a search-as-you-type dialog. Omit if the datafeed can't search
+     * (the SymbolSearch component degrades gracefully).
+     */
+    searchSymbols?(query: string): Promise<SymbolSearchResult[]>;
+}
+/** Price-scale configuration (issue #12). */
+interface PriceScale {
+    /** "normal" (default), "percentage" (% change), or "logarithm". */
+    type?: "normal" | "percentage" | "logarithm";
+    /** Flip the axis so price increases downward. */
+    invert?: boolean;
+    /** Draw the y-axis labels inside the plot area. */
+    inside?: boolean;
+}
+/** Price-scale labels shown on the y-axis (issue #41 — labels). Each toggles a
+ *  KLineChart price mark. `undefined` fields keep the current value. */
+interface PriceLabels {
+    /** The last-price value pill on the axis. */
+    lastValue?: boolean;
+    /** The horizontal line drawn across the chart at the last price. */
+    lastLine?: boolean;
+    /** The visible-range high price mark. */
+    high?: boolean;
+    /** The visible-range low price mark. */
+    low?: boolean;
+    /** Countdown to the current bar's close, under the last-price pill. */
+    countdown?: boolean;
+}
+/** Crosshair/drawing magnet mode (issue #13). `true` = weak. */
+type Magnet = boolean | "weak" | "strong";
+/** Candle rendering style (issue #1). "heikin_ashi" transforms the data. */
+type CandleStyle = "candle" | "hollow" | "hollow_up" | "ohlc" | "area" | "heikin_ashi" | "line" | "step" | "baseline" | "column" | "hlc" | "high_low";
+/** A comparison symbol overlaid on the main pane (issue #9). */
+interface CompareSpec {
+    symbol: string;
+    color?: string;
+}
+/** A KLineChart drawing-tool name (issue #3). */
+type DrawingTool = "segment" | "rayLine" | "straightLine" | "horizontalStraightLine" | "verticalStraightLine" | "priceLine" | "priceChannelLine" | "parallelStraightLine" | "fibonacciLine" | "simpleAnnotation" | "simpleTag" | "text" | "brush" | "highlighter" | "rectangle" | "ellipse" | "triangle" | "priceRange" | "riskReward" | "horizontalRay" | "crossLine" | "arrow" | "fibExtension" | "fibTimeZone" | "dateRange" | "datePriceRange";
+/** One active indicator row for the data-window panel (#45). */
+interface IndicatorRow {
+    name: string;
+    visible: boolean;
+}
+/** One user-drawing row for the object-tree panel (#45). */
+interface DrawingRow {
+    /** Overlay id — the stable handle for per-drawing operations. */
+    id: string;
+    /** Raw overlay/tool name (e.g. "segment", "sonrBrush", "text"). */
+    name: string;
+    /** Human label (tool name, or the text content for a text label). */
+    label: string;
+    visible: boolean;
+    locked: boolean;
+}
+/** Serialized chart state for save/load (issue #15). Opaque JSON the host
+ *  persists and hands back to `importState`. */
+interface ChartState {
+    version: 1;
+    drawings: DrawingSnapshotItem[];
+    indicators: Array<{
+        name: string;
+        paneId?: string;
+    }>;
+    priceScale?: PriceScale;
+}
+/** A horizontal reference line drawn across the chart (e.g. a trade plan's
+ *  entry / stop / target). Static — see OrderLine for draggable lines. */
+interface PriceLine {
+    price: number;
+    color?: string;
+    /** Short label drawn at the line, e.g. "Entry", "Stop", "Target". */
+    label?: string;
+    /** "solid" (default) | "dashed". */
+    style?: "solid" | "dashed";
+}
+/**
+ * A draggable on-chart order/position line (issue #19). Like PriceLine but the
+ * user can drag it to a new price; `onMove` fires with the new price when the
+ * drag ends (and continuously if `live`).
+ */
+interface OrderLine {
+    /** Stable id so React reconciliation and callbacks can identify the line. */
+    id: string;
+    price: number;
+    color?: string;
+    label?: string;
+    style?: "solid" | "dashed";
+    /** Allow dragging. Default true (that's the point of an OrderLine). */
+    draggable?: boolean;
+    /** Fires with the new price. `phase` is "moving" during the drag and "end"
+     *  when released. */
+    onMove?: (price: number, phase: "moving" | "end") => void;
+}
+/**
+ * How to add one technical indicator (issue #4). A bare string is shorthand
+ * for `{ name }`.
+ */
+interface IndicatorSpec {
+    /** KLineChart indicator name, e.g. "VOL", "MACD", "RSI", "BOLL", "MA". */
+    name: string;
+    /** "main" overlays it on the price pane; "new" (default) gives it a sub-pane. */
+    pane?: "main" | "new";
+    /** Indicator calc params, e.g. [5, 10, 20] for MA. */
+    calcParams?: number[];
+}
+/** A pattern-context marker drawn on the price pane (issue #5) — Sonr's own
+ *  custom indicator. Marks where a setup triggered. */
+interface PatternMarker {
+    /** Bar time (epoch ms) to anchor the marker to. */
+    time: number;
+    /** "long" draws below the bar pointing up; "short" above pointing down. */
+    kind?: "long" | "short";
+    /** Optional short label (e.g. the pattern name). */
+    label?: string;
+    color?: string;
+}
+/** Session background tinting (issue #10). `true` uses the default palette;
+ *  pass an object to override the pre/after-hours tints (regular hours are
+ *  untinted). Colors should be low-alpha so candles read through. */
+type SessionTint = boolean | {
+    premarket?: string;
+    afterhours?: string;
+};
+type Theme = "dark" | "light";
+/** Watermark configuration (issue: watermark controls). Show the symbol and/or
+ *  the interval, with a configurable color and opacity. */
+interface WatermarkOptions {
+    symbol: boolean;
+    interval: boolean;
+    /** #rrggbb ink color (opacity applied separately). */
+    color: string;
+    /** 0..1. */
+    opacity: number;
+}
+
+declare const BRUSH_OVERLAY = "sonrBrush";
+interface BrushStyle {
+    color: string;
+    size: number;
+}
+/** The two brush tools, keyed to the drawing-toolbar tool ids. */
+type BrushTool = "brush" | "highlighter";
+
+declare const TEXT_OVERLAY = "text";
+/** Styling for a text label (defaults for new labels live on the chart handle). */
+interface TextStyle {
+    color: string;
+    size: number;
+}
+/** Shape of a text overlay's extendData: the label plus its per-label style. */
+interface TextData extends Partial<TextStyle> {
+    text: string;
+}
+declare function registerTextOverlay(): void;
+
+interface SonrChartProps {
+    symbol: string;
+    interval?: Interval;
+    dataSource: DataSource;
+    /** "dark" | "light", or the name of a theme registered via `registerTheme`
+     *  or supplied in `customThemes`. (#46) */
+    theme?: Theme | string;
+    /** Inline named custom themes, looked up before the global registry. (#46) */
+    customThemes?: Record<string, DeepPartial<Styles>>;
+    styles?: DeepPartial<Styles>;
+    /** Indicators to show. Strings ("VOL") or specs. Default ["VOL"]. (#4) */
+    indicators?: (string | IndicatorSpec)[];
+    /** Per-indicator sub-pane heights in px, keyed by indicator name. (#7) */
+    paneHeights?: Record<string, number>;
+    /** Session background tinting for pre/after-hours. (#10) */
+    sessions?: SessionTint;
+    /** Underlaid symbol + interval watermark behind the candles. `true` shows both;
+     *  pass options to toggle each and set color/opacity. */
+    watermark?: boolean | Partial<WatermarkOptions>;
+    /** Pattern-context markers on the price pane. (#5) */
+    patterns?: PatternMarker[];
+    /** Static reference lines (entry / stop / target). */
+    priceLines?: PriceLine[];
+    /** Draggable order/position lines. (#19) */
+    orderLines?: OrderLine[];
+    /** Price-scale mode (log / percentage / invert / inside). (#12) */
+    priceScale?: PriceScale;
+    /** Price-scale labels (last value/line, high/low marks). (#41) */
+    priceLabels?: Partial<PriceLabels>;
+    /** Magnet mode for drawing tools — snap points to nearby OHLC. (#13) */
+    magnet?: Magnet;
+    /** Candle rendering style — solid/hollow/ohlc/area/heikin_ashi. (#1) */
+    candleStyle?: CandleStyle;
+    /** Comparison symbols overlaid on the main pane, ratio-scaled. (#9) */
+    compareSeries?: CompareSpec[];
+    /** How many bars to request on load. Default 500. */
+    barCount?: number;
+    /** Enable built-in keyboard shortcuts when the chart is focused. (#14)
+     *  Default true. See `onShortcut` to observe/extend them. */
+    keyboard?: boolean;
+    /** Called for every recognized shortcut ("escape" | "undo" | "redo" |
+     *  "delete") while the chart is focused, even when the built-in also runs —
+     *  a host can observe or extend the behavior. (#14) */
+    onShortcut?: (action: string, e: KeyboardEvent) => void;
+    /** Override the crosshair price pill / big-number formatting. (#46) */
+    priceFormatter?: (value: number) => string;
+    /** Override the crosshair date template, e.g. "YYYY-MM-DD HH:mm". (#46) */
+    dateFormat?: string;
+    /** IANA timezone for the x-axis + crosshair time (#38). Default
+     *  "America/New_York". Also settable via the handle / <TimezoneMenu>. */
+    timezone?: string;
+    /** Data-source label shown in the candle legend header (e.g. "Alpaca"),
+     *  after `symbol · interval`, TradingView-style. */
+    source?: string;
+    /** Show the built-in canvas candle legend (O/H/L/C/…). Default true. Set false
+     *  when rendering your own header via <ChartHeader> + `subscribeHeaderBar`. */
+    legend?: boolean;
+    onReady?: (chart: Chart) => void;
+    /** Fired when resolveSymbol returns null for the requested ticker. (#8) */
+    onSymbolError?: (symbol: string) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/** Imperative surface: raw chart, indicator control (#4), drawing tools (#3),
+ *  price scale (#12), snapshot (#20), and state save/load (#15). */
+interface SonrChartHandle {
+    chart(): Chart | null;
+    addIndicator(spec: string | IndicatorSpec): void;
+    removeIndicator(name: string): void;
+    listIndicators(): string[];
+    /** Start interactive drawing of a tool; honors the current magnet mode. */
+    startDrawing(tool: DrawingTool): void;
+    /** Cancel an armed-but-unplaced drawing (toggle the tool off). */
+    cancelDrawing(): void;
+    /** The tool currently armed for drawing, or null if none. */
+    activeDrawing(): DrawingTool | null;
+    /** Subscribe to armed-tool changes (arm → tool, placed/cancelled → null).
+     *  Returns an unsubscribe fn. Lets a toolbar highlight the active tool. */
+    subscribeDrawing(cb: (tool: DrawingTool | null) => void): () => void;
+    /** Remove all user-drawn overlays (leaves price/order lines + indicators). */
+    clearDrawings(): void;
+    /** Capture the chart to a data URL (PNG by default). */
+    snapshot(opts?: {
+        type?: "png" | "jpeg";
+        background?: string;
+        includeOverlays?: boolean;
+    }): string | null;
+    /** Serialize user drawings + indicators + price scale (#15). */
+    exportState(): ChartState;
+    /** Restore state produced by exportState (#15). */
+    importState(state: ChartState): void;
+    /** Current indicator set as specs — a study template to name/persist (#6). */
+    getIndicatorSet(): IndicatorSpec[];
+    /** Replace the user indicators with a saved set (#6). */
+    applyIndicatorSet(specs: (string | IndicatorSpec)[]): void;
+    /** Undo the last drawing change (#16). */
+    undo(): void;
+    /** Redo an undone drawing change (#16). */
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** Subscribe to undo/redo-availability changes (#16). Returns unsubscribe. */
+    subscribeHistory(cb: () => void): () => void;
+    /** Current magnet mode for new drawings (#13). */
+    getMagnet(): Magnet | undefined;
+    /** Set the magnet mode imperatively (a changed `magnet` prop still overrides). */
+    setMagnet(magnet: Magnet | undefined): void;
+    /** Subscribe to magnet-mode changes. Returns unsubscribe. */
+    subscribeMagnet(cb: (magnet: Magnet | undefined) => void): () => void;
+    /** Current theme selector ("dark"/"light" or a registered/custom name). (#46) */
+    getTheme(): Theme | string;
+    /** Apply a theme by name imperatively (a changed `theme` prop still wins). (#46) */
+    setTheme(theme: Theme | string): void;
+    subscribeTheme(cb: (theme: Theme | string) => void): () => void;
+    /** Current IANA timezone for the x-axis + crosshair time (#38). */
+    getTimezone(): string;
+    /** Set the timezone imperatively (a changed `timezone` prop still wins). (#38) */
+    setTimezone(tz: string): void;
+    subscribeTimezone(cb: (tz: string) => void): () => void;
+    getCandleStyle(): CandleStyle;
+    setCandleStyle(style: CandleStyle): void;
+    subscribeCandleStyle(cb: (style: CandleStyle) => void): () => void;
+    getPriceScale(): PriceScale | undefined;
+    setPriceScale(scale: PriceScale): void;
+    subscribePriceScale(cb: (scale: PriceScale) => void): () => void;
+    getSessions(): SessionTint | undefined;
+    setSessions(on: SessionTint): void;
+    subscribeSessions(cb: (on: SessionTint) => void): () => void;
+    getWatermark(): WatermarkOptions;
+    setWatermark(opts: boolean | Partial<WatermarkOptions>): void;
+    subscribeWatermark(cb: () => void): () => void;
+    /** Current price-scale label toggles (#41). */
+    getPriceLabels(): Required<PriceLabels>;
+    /** Toggle price-scale labels (merges over the current set). */
+    setPriceLabels(opts: Partial<PriceLabels>): void;
+    subscribePriceLabels(cb: () => void): () => void;
+    /** Current brush/highlighter stroke style (color + width). */
+    getBrushStyle(tool: BrushTool): BrushStyle;
+    /** Set the brush/highlighter stroke style — applies to subsequent strokes. */
+    setBrushStyle(tool: BrushTool, style: BrushStyle): void;
+    /** Subscribe to brush-style changes (for a settings UI). Returns unsubscribe. */
+    subscribeBrush(cb: () => void): () => void;
+    /** Default color/size applied to new text labels. */
+    getTextStyle(): TextStyle;
+    setTextStyle(style: TextStyle): void;
+    subscribeTextStyle(cb: () => void): () => void;
+    /** Lock every user drawing (non-interactive) or unlock them. New drawings
+     *  inherit the current lock state. */
+    setDrawingsLocked(locked: boolean): void;
+    /** Whether user drawings are currently locked. */
+    getDrawingsLocked(): boolean;
+    /** Show/hide every user drawing at once. New drawings inherit visibility. */
+    setDrawingsVisible(visible: boolean): void;
+    /** Whether user drawings are currently visible. */
+    getDrawingsVisible(): boolean;
+    /** Subscribe to hide/show-all changes (#35). Returns unsubscribe. */
+    subscribeDrawingsVisible(cb: (visible: boolean) => void): () => void;
+    /** Save the current user drawings as a named template (in-memory). */
+    saveDrawingTemplate(name: string): void;
+    /** Replace the current user drawings with a saved template's set. */
+    applyDrawingTemplate(name: string): void;
+    /** Names of all saved drawing templates. */
+    listDrawingTemplates(): string[];
+    /** Delete a saved drawing template. */
+    deleteDrawingTemplate(name: string): void;
+    /** Subscribe to drawing-template list changes. Returns unsubscribe. */
+    subscribeDrawingTemplates(cb: () => void): () => void;
+    /** Duplicate the most-recently-added user drawing (same points/style). */
+    cloneLastDrawing(): void;
+    /** Active user indicators as data-window rows (excludes internal overlays). */
+    listIndicatorRows(): IndicatorRow[];
+    /** Show/hide one indicator by name. */
+    setIndicatorVisible(name: string, visible: boolean): void;
+    /** Subscribe to indicator add/remove/visibility changes. Returns unsubscribe. */
+    subscribeIndicators(cb: () => void): () => void;
+    /** Every user drawing as object-tree rows (id/label/visible/locked). */
+    listDrawings(): DrawingRow[];
+    /** Show/hide one drawing by id. */
+    setDrawingVisible(id: string, visible: boolean): void;
+    /** Lock/unlock one drawing by id. */
+    setDrawingLocked(id: string, locked: boolean): void;
+    /** Remove one drawing by id. */
+    removeDrawing(id: string): void;
+    /** Scroll the chart so the drawing with this id is in view (#45). */
+    locateDrawing(id: string): void;
+    /** Change a drawing's stacking order: front/back (extreme) or forward/
+     *  backward (one step). */
+    setDrawingZOrder(id: string, mode: "front" | "back" | "forward" | "backward"): void;
+    /** Copy a drawing to the clipboard. */
+    copyDrawing(id: string): void;
+    /** Paste the copied drawing as a new drawing. */
+    pasteDrawing(): void;
+    /** Whether a copied drawing is available to paste. */
+    canPasteDrawing(): boolean;
+    /** Id of the drawing selected on the chart (clicked), or null. */
+    getSelectedDrawing(): string | null;
+    /** Zoom the visible window to the most recent `ms` of loaded data at the
+     *  current resolution (clamped to what's loaded). `Infinity` fits all data. */
+    setVisibleDuration(ms: number): void;
+    /** Scroll the visible window to the bar at (or nearest before) this epoch-ms. */
+    scrollToTimestamp(timestamp: number): void;
+    /** Jump the visible window to the latest (realtime) bar. */
+    scrollToRealTime(): void;
+    /** Zoom the visible range in one step (toward more detail). */
+    zoomIn(): void;
+    /** Zoom the visible range out one step (toward more history). */
+    zoomOut(): void;
+    /** Subscribe to the bar a custom header should show — the hovered bar while
+     *  the crosshair is active, else the latest bar (updates on each streamed
+     *  bar). Emits once immediately. Returns unsubscribe. (#45) */
+    subscribeHeaderBar(cb: (current: KLineData | null, prev: KLineData | null) => void): () => void;
+}
+declare const SonrChart: react.ForwardRefExoticComponent<SonrChartProps & react.RefAttributes<SonrChartHandle>>;
+
+/** Built-in chart shortcut actions surfaced to the host via `onShortcut`. */
+type ShortcutAction = "escape" | "undo" | "redo" | "delete" | "copy" | "paste";
+/** True when the event originates from a field where the user is typing — an
+ *  input/textarea/select or a contenteditable element. Shortcuts must never
+ *  hijack these (symbol search, settings inputs, etc.). */
+declare function isEditableTarget(target: EventTarget | null): boolean;
+/** Map a keydown to a built-in chart shortcut action, or null if none.
+ *  Pure — reads only the event's key + modifiers, never the DOM or app state.
+ *  The caller further gates "delete" on whether a drawing tool is armed. */
+declare function resolveShortcut(e: KeyboardEvent): ShortcutAction | null;
+
+type ScaleType = NonNullable<PriceScale["type"]>;
+interface Labels {
+    /** Indicators menu trigger + group label. */
+    indicators: string;
+    /** Price-scale trigger prefix, shown as `${scale}: ${scaleTypes[type]}`. */
+    scale: string;
+    /** Price-scale option labels, keyed by scale type. */
+    scaleTypes: Record<ScaleType, string>;
+    /** Price-scale labels section (#41). */
+    priceLabelsHeading: string;
+    priceLabelLastValue: string;
+    priceLabelLastLine: string;
+    priceLabelHigh: string;
+    priceLabelLow: string;
+    priceLabelCountdown: string;
+    /** Sessions (extended-hours tint) toggle. */
+    sessions: string;
+    /** Timezone menu trigger + group label (#38). */
+    timezone: string;
+    /** Snapshot button aria-label. */
+    snapshot: string;
+    /** Settings gear aria-label + settings dialog title. */
+    settings: string;
+    /** Candle-type menu aria/title prefix. */
+    candleType: string;
+    /** Drawing-tools menu aria/title. */
+    drawingTools: string;
+    /** Magnet toggle. */
+    magnet: string;
+    undo: string;
+    redo: string;
+    /** Clear-drawings button aria-label. */
+    clear: string;
+    /** Hide/show-all-drawings toggle labels (the eye button). */
+    hideDrawings: string;
+    showDrawings: string;
+    /** Clear-drawings confirmation dialog: prompt, confirm button, cancel button. */
+    clearConfirm: string;
+    clearConfirmOk: string;
+    cancel: string;
+    /** Data-window / object-tree panel chrome (#45). */
+    dataWindow: string;
+    objectTree: string;
+    /** Shell's side-panel toggle button (indicators + objects). */
+    panelToggle: string;
+    hide: string;
+    show: string;
+    lock: string;
+    unlock: string;
+    remove: string;
+    close: string;
+    noIndicators: string;
+    noDrawings: string;
+    /** Object-tree per-drawing actions (#35). */
+    duplicate: string;
+    bringToFront: string;
+    sendToBack: string;
+    searchUnavailable: string;
+    searching: string;
+    noResults: string;
+    /** Save / Load dialog (#45). */
+    saveLoad: string;
+    saveLoadExportLabel: string;
+    saveLoadImportLabel: string;
+    saveLoadCopy: string;
+    saveLoadCopied: string;
+    saveLoadDownload: string;
+    saveLoadLoad: string;
+    saveLoadError: string;
+    saveLoadClose: string;
+    /** Go-to-date dialog (#45). */
+    goToDate: string;
+    goToDateGo: string;
+    /** Symbol-info dialog (#45). */
+    symbolInfo: string;
+    symbolInfoTicker: string;
+    symbolInfoName: string;
+    symbolInfoPricePrecision: string;
+    symbolInfoVolumePrecision: string;
+    symbolInfoUnknown: string;
+    symbolInfoLoading: string;
+    symbolInfoType: string;
+    symbolInfoPointValue: string;
+    symbolInfoListedExchange: string;
+    symbolInfoExchange: string;
+    symbolInfoTickSize: string;
+    symbolInfoSession: string;
+    /** Symbol-info metadata fields (#39). */
+    symbolInfoCurrency: string;
+    symbolInfoUnit: string;
+    symbolInfoDescription: string;
+    symbolInfoPriceSource: string;
+    /** Nav / control bar (#45). */
+    navControls: string;
+    zoomOut: string;
+    zoomIn: string;
+    fitContent: string;
+    goToRealtime: string;
+    /** Market-status badge (#45). */
+    marketPre: string;
+    marketOpen: string;
+    marketAfter: string;
+    marketClosed: string;
+    marketTimezone: string;
+    /** Settings dialog section (nav) titles. */
+    settingsSections: Record<"candles" | "indicators" | "grid" | "sessions" | "drawing" | "drawings", string>;
+    /** Optional per-style overrides for the candle menu; falls back to the
+     *  option's own `label` when a style is not listed. */
+    candleStyles: Partial<Record<CandleStyle, string>>;
+    /** Optional per-tool overrides for the drawing menu; falls back to the
+     *  tool option's own `label` when a tool is not listed. */
+    drawingToolLabels: Partial<Record<DrawingTool, string>>;
+}
+declare const DEFAULT_LABELS: Labels;
+/** Merge a partial label override over the English defaults (nested records
+ *  merged one level deep). Returns DEFAULT_LABELS unchanged when nothing is
+ *  passed, so the no-`labels` path allocates nothing. */
+declare function mergeLabels(over?: Partial<Labels>): Labels;
+
+/** Common KLineChart indicators offered by default. `pane` decides overlay vs
+ *  sub-pane. Override via the `options` prop. */
+interface IndicatorOption {
+    name: string;
+    label: string;
+    pane?: "main" | "new";
+}
+declare const DEFAULT_INDICATOR_OPTIONS: IndicatorOption[];
+declare function IndicatorMenu({ chartRef, options, className, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    options?: IndicatorOption[];
+    className?: string;
+    labels?: Partial<Labels>;
+}): react.JSX.Element;
+
+interface DrawingToolOption {
+    tool: DrawingTool;
+    label: string;
+}
+declare const DEFAULT_DRAWING_TOOLS: DrawingToolOption[];
+declare const EXTENDED_DRAWING_TOOLS: DrawingToolOption[];
+declare const USER_DRAWING_GROUP = "sonr-user-drawing";
+/** Human label for a placed drawing in the object tree. Text labels show their
+ *  own content; freehand shares one overlay name; everything else maps to its
+ *  tool label (falling back to the raw overlay name). Pure. */
+declare function drawingLabel(name: string, extendData?: unknown): string;
+
+declare function DrawingToolbar({ chartRef, tools, className, showClear, showHide, showMagnet, showHistory, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    tools?: DrawingToolOption[];
+    className?: string;
+    showClear?: boolean;
+    /** Show the hide/show-all-drawings eye toggle. Default true. */
+    showHide?: boolean;
+    showMagnet?: boolean;
+    showHistory?: boolean;
+    labels?: Partial<Labels>;
+}): react.JSX.Element;
+
+declare function ConfirmDialog({ open, message, confirmLabel, cancelLabel, onConfirm, onCancel, }: {
+    open: boolean;
+    message: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+}): react.ReactPortal | null;
+
+declare function DataWindow({ chartRef, className, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    className?: string;
+    labels?: Partial<Labels>;
+}): react.JSX.Element;
+
+declare function ObjectTree({ chartRef, className, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    className?: string;
+    labels?: Partial<Labels>;
+}): react.JSX.Element;
+
+/** One lookback button: a label, the window length in ms (Infinity = all data),
+ *  and the words used in the "{range} in {interval} intervals" tooltip. */
+interface RangeOption {
+    label: string;
+    ms: number;
+    title: string;
+}
+declare const DEFAULT_RANGES: RangeOption[];
+declare function TimeframeBar({ chartRef, interval, ranges, className, children, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    /** Current resolution — only used to render the tooltip. */
+    interval: Interval;
+    /** Lookback ranges to offer, in display order (defaults to DEFAULT_RANGES). */
+    ranges?: RangeOption[];
+    className?: string;
+    /** Optional right-aligned slot for host nav/control widgets. */
+    children?: ReactNode;
+}): react.JSX.Element;
+
+/** One selectable timezone: an IANA name plus a short display label. */
+interface TimezoneOption {
+    /** IANA timezone name, e.g. "America/New_York". Passed to chart.setTimezone. */
+    value: string;
+    /** Short display label, e.g. "New York". */
+    label: string;
+}
+/** The chart's default timezone — US equities exchange time (ET). */
+declare const DEFAULT_TIMEZONE = "America/New_York";
+/** Curated common trading timezones, roughly west→east. Hosts can pass their own
+ *  set to <TimezoneMenu> or extend this via getTimezoneApi(). */
+declare const DEFAULT_TIMEZONES: TimezoneOption[];
+/** Human label for an IANA timezone, falling back to the raw name (with the
+ *  "Area/City" prefix stripped and underscores spaced) when it isn't in the
+ *  curated set. Pure. */
+declare function timezoneLabel(tz: string, options?: TimezoneOption[]): string;
+/**
+ * Timezone API (issue #38 `getTimezoneApi`). Returns the curated timezone list
+ * and a resolver, letting a host discover the built-in options and label an
+ * arbitrary IANA zone. Accepts custom aliases (merged ahead of the defaults) so
+ * a host can surface its own named zones.
+ */
+declare function getTimezoneApi(customAliases?: TimezoneOption[]): {
+    timezones: TimezoneOption[];
+    label: (tz: string) => string;
+};
+
+declare function TimezoneMenu({ chartRef, options, className, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    /** Timezones to offer (defaults to the curated common set). */
+    options?: TimezoneOption[];
+    className?: string;
+    labels?: Partial<Labels>;
+}): react.JSX.Element;
+
+/** Milliseconds in one unit of each period type. Week/month/year are nominal
+ *  (calendar-agnostic) — used only for the bar-close countdown, where an exact
+ *  calendar length isn't needed. */
+declare const UNIT_MS: Record<PeriodType, number>;
+/**
+ * Parse a resolution token to a KLineChart Period.
+ *
+ * Rules (case-insensitive):
+ * - `<n>S` → seconds (e.g. "10S", "30S", "5S")
+ * - `<n>H` → hours; bare `"60"` also maps to 1 hour (back-compat with the
+ *   original interval set, where "60" meant hourly)
+ * - `D` / `<n>D` → days
+ * - `W` / `<n>W` → weeks
+ * - `MO` / `<n>MO` → months
+ * - `Y` / `<n>Y` → years
+ * - `<n>` → minutes (e.g. "1", "5", "15", "240")
+ * - anything unrecognized → 1 minute (safe default)
+ */
+declare function parseResolution(interval: Interval): {
+    type: PeriodType;
+    span: number;
+};
+/** Duration of one bar at this resolution, in ms (drives the bar-close
+ *  countdown). Nominal for week/month/year (see UNIT_MS). */
+declare function resolutionMs(interval: Interval): number;
+/** Human words for a resolution, e.g. "30 minute", "1 hour" — used in tooltips
+ *  and menus. Pure. */
+declare function resolutionLabel(interval: Interval): string;
+/** A resolution option for a resolution menu/toolbar. */
+interface ResolutionOption {
+    /** The token passed as `interval`. */
+    value: Interval;
+    /** Short display label (e.g. "5m", "1H", "D"). */
+    label: string;
+}
+/** A sensible default resolution set spanning seconds → months. Hosts can pass
+ *  their own; any custom token `parseResolution` understands is valid. */
+declare const DEFAULT_RESOLUTIONS: ResolutionOption[];
+
+/** Quote metadata attached to a symbol (subset of SymbolInfo). */
+interface QuoteFormat {
+    /** Currency code or sign, prefixed (e.g. "USD", "$"). */
+    currency?: string;
+    /** Unit, suffixed (e.g. "pts", "¢"). */
+    unit?: string;
+}
+/**
+ * Decorate an already-formatted price string with a currency prefix and/or unit
+ * suffix. A glyph currency ("$", "€") hugs the number; an alphabetic code
+ * ("USD") gets a space. Passing neither returns the text unchanged, so this
+ * is a no-op for symbols without quote metadata. Pure.
+ */
+declare function formatWithUnit(text: string, quote?: QuoteFormat): string;
+
+type BrandCorner = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+interface BrandMarkProps {
+    /** Image source for a logo, rendered as an <img> (sized by `height`). */
+    src?: string;
+    alt?: string;
+    /** Brand content when not using `src` — a wordmark, inline SVG, etc. */
+    children?: ReactNode;
+    /** Corner placement within the positioned parent. Default "bottom-left". */
+    position?: BrandCorner;
+    /** Mark opacity (kept subtle by default). */
+    opacity?: number;
+    /** Optional link — wraps the mark in an anchor (opens in a new tab) and
+     *  re-enables pointer events for it. */
+    href?: string;
+    /** Logo image height in px (only when `src` is set). Default 18. */
+    height?: number;
+    className?: string;
+}
+declare function BrandMark({ src, alt, children, position, opacity, href, height, className }: BrandMarkProps): react.JSX.Element;
+
+interface SonrChartShellProps {
+    symbol: string;
+    interval: Interval;
+    dataSource: DataSource;
+    theme?: Theme | string;
+    /** Resolution buttons in the toolbar. Defaults to 10S…D. */
+    intervals?: Interval[];
+    /** Lookback ranges for the bottom bar. */
+    ranges?: RangeOption[];
+    /** Data-source label shown in the header (e.g. "Alpaca"). */
+    source?: string;
+    /** Instrument venue label for the Symbol-info dialog (e.g. "Alpaca"). */
+    exchange?: string;
+    onIntervalChange?: (interval: Interval) => void;
+    onSymbolChange?: (symbol: string) => void;
+    /** Brand mark content (host logo), shown in a chart corner. Omit for none. */
+    brand?: ReactNode;
+    brandCorner?: BrandCorner;
+    brandOpacity?: number;
+    /** Snapshot filename. Defaults to `${symbol}-${interval}.png`. */
+    snapshotName?: string;
+    indicators?: (string | IndicatorSpec)[];
+    sessions?: SessionTint;
+    watermark?: boolean | Partial<WatermarkOptions>;
+    patterns?: PatternMarker[];
+    priceLines?: PriceLine[];
+    orderLines?: OrderLine[];
+    timezone?: string;
+    /** Localized chrome strings, threaded to every piece. */
+    labels?: Partial<Labels>;
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * The full chart application shell. Forwards a ref to the underlying
+ * SonrChartHandle so a host can still drive the chart imperatively.
+ */
+declare const SonrChartShell: react.ForwardRefExoticComponent<SonrChartShellProps & react.RefAttributes<SonrChartHandle>>;
+
+declare function isChartState(value: unknown): value is ChartState;
+declare function SaveLoadDialog({ chartRef, open, onClose, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    open: boolean;
+    onClose: () => void;
+    labels?: Partial<Labels>;
+}): react.ReactPortal | null;
+
+declare function parseLocalDateTime(value: string): number | null;
+declare function GoToDateDialog({ chartRef, open, onClose, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    open: boolean;
+    onClose: () => void;
+    labels?: Partial<Labels>;
+}): react.ReactPortal | null;
+
+declare function SymbolInfoDialog({ dataSource, symbol, open, onClose, labels, type, exchange, listedExchange, pointValue, tickSize, now, }: {
+    dataSource: DataSource;
+    symbol: string;
+    open: boolean;
+    onClose: () => void;
+    labels?: Partial<Labels>;
+    /** Instrument type (default "Stock"). */
+    type?: string;
+    /** Trading venue label (e.g. "Alpaca"). */
+    exchange?: string;
+    /** Primary listing exchange, if known (default "—"). */
+    listedExchange?: string;
+    /** Contract point value (default 1 for cash equities). */
+    pointValue?: number;
+    /** Minimum price increment. Defaults to 10^-pricePrecision from resolveSymbol. */
+    tickSize?: number;
+    /** Fixed instant for the session timeline (defaults to the live clock). */
+    now?: number;
+}): react.ReactPortal | null;
+
+declare function NavControlBar({ chartRef, labels, className, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    labels?: Partial<Labels>;
+    className?: string;
+}): react.JSX.Element;
+
+/** The four US-equities session phases. */
+type MarketPhase = "pre" | "open" | "after" | "closed";
+/**
+ * Classify an instant into a US-equities session phase, evaluated in ET.
+ * Weekends are "closed"; holidays are not modeled. Pure.
+ */
+declare function marketStatus(nowMs: number): MarketPhase;
+interface MarketStatusProps {
+    /** Fixed instant (epoch ms) to classify. Omit to track the live clock (the
+     *  badge re-evaluates every 30s). */
+    now?: number;
+    labels?: Partial<Labels>;
+    className?: string;
+}
+/**
+ * Market-status pill (colored dot + phase). Click it to open a popover with a
+ * countdown to the next session transition, a day timeline, and the exchange
+ * timezone. Uncontrolled clock by default; pass `now` to pin a fixed instant.
+ */
+declare function MarketStatus({ now, labels, className }: MarketStatusProps): react.JSX.Element;
+
+interface ChartHeaderProps {
+    chartRef: RefObject<SonrChartHandle>;
+    symbol: string;
+    interval: Interval;
+    /** Data-source label shown after `symbol · interval` (e.g. "Alpaca"). */
+    source?: string;
+    /** Precision for O/H/L/C/change (defaults to 2). */
+    pricePrecision?: number;
+    labels?: Partial<Labels>;
+    className?: string;
+}
+declare function ChartHeader({ chartRef, symbol, interval, source, pricePrecision, labels, className }: ChartHeaderProps): react.JSX.Element;
+
+interface CandleStyleOption {
+    style: CandleStyle;
+    label: string;
+}
+declare const DEFAULT_CANDLE_STYLES: CandleStyleOption[];
+declare function CandleMenu({ value, onChange, options, className, labels, }: {
+    value?: CandleStyle;
+    onChange?: (style: CandleStyle) => void;
+    options?: CandleStyleOption[];
+    className?: string;
+    labels?: Partial<Labels>;
+}): react.JSX.Element;
+
+declare function PriceScaleMenu({ value, onChange, className, labels, chartRef, }: {
+    value?: PriceScale;
+    onChange?: (scale: PriceScale) => void;
+    className?: string;
+    labels?: Partial<Labels>;
+    /** When supplied, renders the price-scale label toggles (#41). */
+    chartRef?: RefObject<SonrChartHandle>;
+}): react.JSX.Element;
+
+declare function SettingsModal({ chartRef, open, onClose, labels, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    open: boolean;
+    onClose: () => void;
+    labels?: Partial<Labels>;
+}): react.ReactPortal | null;
+
+declare function ChartToolbar({ chartRef, intervals, interval, onIntervalChange, candleStyle, onCandleStyleChange, candleStyles, priceScale, onPriceScaleChange, sessions, onSessionsChange, indicatorOptions, drawingTools, showCandle, showScale, showSessions, showDrawing, showSnapshot, showSettings, snapshotName, dataSource, onSymbolSelect, spreadOperators, className, labels, children, }: {
+    chartRef: RefObject<SonrChartHandle>;
+    intervals?: Interval[];
+    interval?: Interval;
+    onIntervalChange?: (interval: Interval) => void;
+    candleStyle?: CandleStyle;
+    onCandleStyleChange?: (style: CandleStyle) => void;
+    candleStyles?: CandleStyleOption[];
+    priceScale?: PriceScale;
+    onPriceScaleChange?: (scale: PriceScale) => void;
+    sessions?: boolean;
+    onSessionsChange?: (on: boolean) => void;
+    indicatorOptions?: IndicatorOption[];
+    drawingTools?: DrawingToolOption[];
+    showCandle?: boolean;
+    showScale?: boolean;
+    showSessions?: boolean;
+    showDrawing?: boolean;
+    showSnapshot?: boolean;
+    showSettings?: boolean;
+    snapshotName?: string;
+    /** DataSource used to power the optional symbol-search box (issue #37). */
+    dataSource?: DataSource;
+    /** When provided (with `dataSource`), a SymbolSearch renders at the toolbar's
+     *  left; picking a result fires this. Omit for the pre-#37 toolbar. */
+    onSymbolSelect?: (symbol: string) => void;
+    /** Forwarded to SymbolSearch — allow spread/expression pass-through. */
+    spreadOperators?: boolean;
+    className?: string;
+    /** Localized chrome strings (issue #46). Merged over English defaults and
+     *  threaded to the menus/settings; omit for the current English. */
+    labels?: Partial<Labels>;
+    children?: ReactNode;
+}): react.JSX.Element;
+
+declare function SymbolSearch({ dataSource, onSelect, spreadOperators, placeholder, className, }: {
+    dataSource: DataSource;
+    onSelect: (symbol: string) => void;
+    spreadOperators?: boolean;
+    placeholder?: string;
+    className?: string;
+}): react.JSX.Element;
+
+declare function ToolbarButton({ active, children, className, ...rest }: {
+    active?: boolean;
+    children: ReactNode;
+} & ButtonHTMLAttributes<HTMLButtonElement>): react.JSX.Element;
+
+/** Inject the default toolbar stylesheet once. No-op on the server, when already
+ *  injected, or if the host opted out via `data-sonr-no-default-styles` on
+ *  <html> (for consumers that ship a full theme and want nothing shipped). */
+declare function ensureDefaultStyles(): void;
+
+declare const SONR_TRADE_BOX = "sonrTradeBox";
+interface TradeBoxData {
+    up?: boolean;
+    label?: string;
+    /** Draw a horizontal reference line at the entry price across the box. */
+    entryLine?: boolean;
+}
+type Params = OverlayCreateFiguresCallbackParams<TradeBoxData>;
+declare function tradeBoxFigures({ coordinates, overlay }: Params): OverlayFigure[];
+/** Register the trade-review overlay once. Idempotent. */
+declare function registerTradeReview(): void;
+
+/** All extended overlay names, in toolbar order. */
+declare const EXTENDED_OVERLAYS: readonly ["horizontalRay", "crossLine", "arrow", "fibExtension", "fibTimeZone", "dateRange", "datePriceRange"];
+/** Trend-based Fibonacci extension levels (retracement + projection). */
+declare const FIB_EXTENSION_LEVELS: readonly number[];
+/** Fibonacci sequence multipliers for time zones (starts 1,2,3,5,8,…). Pure. */
+declare function fibSequence(count: number): number[];
+/**
+ * Arrowhead polygon for a segment ending at (x2,y2), coming from (x1,y1). Two
+ * barbs swept back from the tip by `size` px at ±`spread` radians. Pure. Returns
+ * [leftBarb, tip, rightBarb]. Zero-length segments yield a degenerate triangle
+ * at the tip (harmless).
+ */
+declare function arrowHeadPoints(x1: number, y1: number, x2: number, y2: number, size?: number, spread?: number): Coordinate[];
+/** Human duration for a millisecond span, coarse-grained (largest two units).
+ *  Pure. E.g. 3_660_000 → "1h 1m", 45_000 → "45s". */
+declare function humanDuration(ms: number): string;
+/** Measurement label for a date range: bar count + human time span. Pure. */
+declare function dateRangeLabel(bars: number, ms: number): string;
+/** Register all extended-family overlays once. Idempotent. */
+declare function registerExtendedDrawings(): void;
+
+declare function downloadSnapshot(handle: SonrChartHandle | null, filename?: string, opts?: {
+    type?: "png" | "jpeg";
+    background?: string;
+    includeOverlays?: boolean;
+}): boolean;
+
+declare function toHeikinAshi(bars: Bar[]): Bar[];
+
+declare const SHAPE_RECTANGLE = "rectangle";
+declare const SHAPE_ELLIPSE = "ellipse";
+declare const SHAPE_TRIANGLE = "triangle";
+declare const SHAPE_PRICE_RANGE = "priceRange";
+declare const SHAPE_RISK_REWARD = "riskReward";
+/** All shape/measurement overlay names, in toolbar order. */
+declare const SHAPE_OVERLAYS: readonly ["rectangle", "ellipse", "triangle", "priceRange", "riskReward"];
+/** Format a price-range measurement: absolute delta + percentage between two
+ *  prices. Pure so it's unit-testable. */
+declare function priceRangeLabel(from: number, to: number): string;
+/** Risk/reward stats for a long setup (entry / stop / target). Pure so it's
+ *  unit-testable. `rr` is reward-per-unit-risk (an R multiple); NaN-safe. */
+declare function riskRewardStats(entry: number, stop: number, target: number): {
+    risk: number;
+    reward: number;
+    rr: number;
+};
+/** Register all shape/measurement overlays once. Idempotent. */
+declare function registerShapeOverlays(): void;
+
+/** Register a named theme's style object so `theme="<name>"` applies it. */
+declare function registerTheme(name: string, styles: DeepPartial<Styles>): void;
+/** Look up a previously registered theme's styles (undefined if unknown). */
+declare function getRegisteredTheme(name: string): DeepPartial<Styles> | undefined;
+/**
+ * KLineChart style object for a theme. Deliberately limited to the style keys
+ * that typecheck cleanly under klinecharts v10 (grid, candle bars, axes,
+ * crosshair line) — callers can override anything via the `styles` prop.
+ */
+declare function themeStyles(theme: Theme): DeepPartial<Styles>;
+declare const PALETTE: {
+    GREEN: string;
+    RED: string;
+    DARK: {
+        text: string;
+        muted: string;
+        grid: string;
+        axis: string;
+        pill: string;
+        pillText: string;
+    };
+    LIGHT: {
+        text: string;
+        muted: string;
+        grid: string;
+        axis: string;
+        pill: string;
+        pillText: string;
+    };
+};
+/**
+ * Resolve a theme selector to a KLineChart style object (issue #46).
+ * "dark"/"light" use the built-ins unchanged. Any other string is looked up in
+ * `customThemes` first, then the module registry; a match layers over the dark
+ * base so partial palettes still get sensible crosshair/candle defaults. An
+ * unknown name falls back to the dark theme.
+ */
+declare function resolveThemeStyles(theme: Theme | string, customThemes?: Record<string, DeepPartial<Styles>>): DeepPartial<Styles>;
+
+/**
+ * Read a CSS custom property's computed value. Returns "" when the variable is
+ * unset or when there is no `document` (SSR). `name` may include or omit `--`.
+ */
+declare function getCSSCustomProperty(name: string, el?: Element | null): string;
+/**
+ * Write a CSS custom property (inline `style`). No-op under SSR. `name` may
+ * include or omit `--`. Defaults to `:root` (document.documentElement).
+ */
+declare function setCSSCustomProperty(name: string, value: string, el?: HTMLElement | null): void;
+
+declare const SESSION_INDICATOR = "SONR_SESSION";
+declare const PATTERN_INDICATOR = "SONR_PATTERNS";
+declare const WATERMARK_INDICATOR = "SONR_WATERMARK";
+declare const SERIES_INDICATOR = "SONR_SERIES";
+declare const VWAP_INDICATOR = "VWAP";
+/** Background watermark content (the underlaid ticker + interval). */
+interface WatermarkData {
+    title: string;
+    subtitle?: string;
+    color: string;
+}
+interface SessionColors {
+    premarket: string;
+    afterhours: string;
+}
+declare const DEFAULT_SESSION_COLORS: SessionColors;
+declare function registerSonrIndicators(): void;
+
+export { BRUSH_OVERLAY, type Bar, type BrandCorner, BrandMark, type BrandMarkProps, type BrushStyle, type BrushTool, CandleMenu, type CandleStyle, type CandleStyleOption, ChartHeader, type ChartHeaderProps, type ChartState, ChartToolbar, type CompareSpec, ConfirmDialog, DEFAULT_CANDLE_STYLES, DEFAULT_DRAWING_TOOLS, DEFAULT_INDICATOR_OPTIONS, DEFAULT_LABELS, DEFAULT_RANGES, DEFAULT_RESOLUTIONS, DEFAULT_SESSION_COLORS, DEFAULT_TIMEZONE, DEFAULT_TIMEZONES, type DataSource, DataWindow, type DrawingRow, type DrawingSnapshot, type DrawingSnapshotItem, DrawingTemplateStore, type DrawingTool, type DrawingToolOption, DrawingToolbar, EXTENDED_DRAWING_TOOLS, EXTENDED_OVERLAYS, FIB_EXTENSION_LEVELS, GoToDateDialog, IndicatorMenu, type IndicatorOption, type IndicatorRow, type IndicatorSpec, type Interval, type Labels, type Magnet, type MarketPhase, MarketStatus, type MarketStatusProps, NavControlBar, ObjectTree, type OrderLine, PALETTE, PATTERN_INDICATOR, type PatternMarker, type PriceLabels, type PriceLine, type PriceScale, PriceScaleMenu, type QuoteFormat, type RangeOption, type ResolutionOption, SERIES_INDICATOR, SESSION_INDICATOR, SHAPE_ELLIPSE, SHAPE_OVERLAYS, SHAPE_PRICE_RANGE, SHAPE_RECTANGLE, SHAPE_RISK_REWARD, SHAPE_TRIANGLE, SONR_TRADE_BOX, SaveLoadDialog, type SessionTint, SettingsModal, type ShortcutAction, SonrChart, type SonrChartHandle, type SonrChartProps, SonrChartShell, type SonrChartShellProps, type SymbolInfo, SymbolInfoDialog, SymbolSearch, type SymbolSearchResult, TEXT_OVERLAY, type TextData, type Theme, TimeframeBar, TimezoneMenu, type TimezoneOption, ToolbarButton, UNIT_MS, USER_DRAWING_GROUP, VWAP_INDICATOR, WATERMARK_INDICATOR, type WatermarkData, type WatermarkOptions, arrowHeadPoints, dateRangeLabel, downloadSnapshot, drawingLabel, ensureDefaultStyles, fibSequence, formatWithUnit, getCSSCustomProperty, getRegisteredTheme, getTimezoneApi, humanDuration, isChartState, isEditableTarget, marketStatus, mergeLabels, parseLocalDateTime, parseResolution, priceRangeLabel, registerExtendedDrawings, registerShapeOverlays, registerSonrIndicators, registerTextOverlay, registerTheme, registerTradeReview, resolutionLabel, resolutionMs, resolveShortcut, resolveThemeStyles, riskRewardStats, setCSSCustomProperty, themeStyles, timezoneLabel, toHeikinAshi, tradeBoxFigures };