@luxalgo/vela 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,1189 @@
+import { D as DrawingsDocument, R as Resolved } from './contributions-hX3EUyjG.js';
+export { B as BarsChangeReason, C as ContextSelect, b as DataControl, c as DrawingsControl, E as EngineAlert, d as EngineCapabilities, e as EngineContextSnapshot, f as EngineFactory, g as EngineWarning, h as ExecutionHandlers, i as ExecutionMarket, j as ExecutionRequest, k as ExecutionSession, F as FetchSeries, l as IndicatorEventMap, I as IndicatorHandle, m as IndicatorSummary, L as LegendActionDescriptor, n as LegendIndicatorInfo, N as NativeIndicator, o as NativeIndicatorContext, p as NativeIndicatorDescriptor, q as NativeIndicatorInfo, r as NativeIndicatorOutput, P as ParsedSymbol, s as PreparedScript, t as RendererControl, u as RunIndicatorResult, v as SceneInspection, a as ScriptRun, w as ScriptRunCause, x as ScriptRunResult, S as ScriptingEngine, y as SidePanelButton, z as SidePanelDescriptor, A as SidePanelHandle, G as SidePanelHeader, H as StrategyFill, J as StrategyState, K as StrategyTrade, T as TypedEventBus, V as Vela, M as VelaDeps, O as VelaEventMap, Q as VisibleBarRange, U as WidgetActionDescriptor, X as WidgetActionTarget, Y as WidgetAttachment, W as WidgetContext, Z as getNativeIndicator, _ as legendActions, $ as nativeIndicatorDescriptors, a0 as nativeIndicatorTypes, a1 as registerDefaultEngine, a2 as registerLegendAction, a3 as registerNativeIndicator, a4 as registerSidePanel, a5 as registerWidgetAction, a6 as registerWidgetAttachment, a7 as resolveEngines, a8 as sidePanels, a9 as unregisterDefaultEngine, aa as unregisterLegendAction, ab as unregisterNativeIndicator, ac as unregisterSidePanel, ad as unregisterWidgetAction, ae as unregisterWidgetAttachment, af as widgetActions, ag as widgetAttachments } from './contributions-hX3EUyjG.js';
+import { D as Drawing, S as SerializedDrawing, U as Unsubscribe, L as LineStyle, P as PriceStyle, I as IChartRenderer, R as RendererCapabilities, d as RendererDisplayOptions, e as IndicatorRenderHandle, f as IndicatorStatus, c as VelaTheme, O as OHLCV, g as Pane, h as PaneAction, i as MoveTarget, j as IndicatorModel, k as ScenePatch, l as InputValue, m as SymbolPickerFn, n as LegendActionView, o as InputChangeEvent, T as ThemeName, C as CrosshairEvent, p as ClickEvent, a as VisibleRange, q as DataWindowReadout, r as IDrawingsRendererPort, s as Millis, t as SnapMode, u as DrawingTypeKey, v as ToolbarDefinition, M as MarketConfig } from './options-Q-576hIi.js';
+export { A as AddIndicatorOptions, B as Background, w as BoxFontFamily, x as BoxHAlign, y as BoxTextSize, z as BoxVAlign, E as CandleBarColor, F as CandleSeries, G as CandleStyle, H as DataWindowGroup, J as DataWindowOHLC, K as DataWindowRow, Q as DirtyRange, W as DrawingBox, X as DrawingExtend, Y as DrawingIntent, Z as DrawingLabel, _ as DrawingLine, $ as DrawingLinefill, a0 as DrawingMode, a1 as DrawingPoint, a2 as DrawingPolyline, a3 as DrawingStyle, a4 as DrawingTable, a5 as DrawingText, a6 as DrawingXLoc, a7 as DrawingsOption, a8 as Fill, a9 as FillGradientStop, aa as IndicatorMeta, ab as InputSchema, ac as InputType, ad as LabelStyle, ae as LabelYLoc, af as LineLikeKind, ag as LineLikeSeries, ah as LineLikeStyle, ai as MarkerPoint, aj as MarkerSeries, ak as MarketSnapshot, al as MarketSwitch, am as PaneHint, an as PaneKind, ao as PolylinePoint, ap as PriceLine, aq as Projector, ar as ProviderName, as as RendererConstructor, at as Scene, au as SchemaPatch, av as SeriesKind, aw as SeriesPoint, ax as SeriesSpec, ay as SeriesValueDelta, az as SettingsField, aA as SettingsSchema, aB as TableCell, aC as TableMerge, aD as TablePosition, aE as ToolbarGroupConfig, aF as TradeExecution, aG as ValuePatch, b as VelaOptions, V as VisibleRangePreset, aH as buildToolbar, aI as defaultToolbar } from './options-Q-576hIi.js';
+import { M as MarketDataFeed, D as DataProvider, P as ProviderInfo, a as SymbolDescriptor, S as SymbolInfo, b as ProviderCapabilities, B as BarRange } from './DataProvider-Dzd-Erlk.js';
+export { A as ACCENT, a as ACCENT_BRIGHT, B as BEARISH, b as BULLISH, c as BarTransform, C as CATEGORICAL, d as CROSSHAIR, e as ChartTypeDefinition, f as ChartTypeSettingsSection, D as DrawingTypeMeta, H as HIGHLIGHT, I as INFO, g as INVALID, h as IdentifiableKind, M as MARKER, N as NEUTRAL, R as RendererLayerArgs, i as RendererLayerDefinition, j as RendererLayerInstance, S as SERIES_LINE, k as SESSION_OFF, l as SESSION_POST, m as SESSION_PRE, n as SLATE, o as SLATE_DEEP, p as SeriesDataEngine, q as SeriesDataEngineHost, r as SettingsRowDescriptor, T as TRADE_EXIT, s as TRADE_LONG, t as TRADE_SHORT, V as VALID, W as WARNING, u as categoricalColor, v as chartType, w as chartTypes, x as createDrawing, y as deserializeDrawing, z as drawingTypes, E as getDrawingType, F as registerChartType, G as registerDrawingType, J as registerRendererDefaults, K as registerRendererLayer, L as rendererDefaults, O as rendererLayers, P as stableSeriesId, Q as tickerModifierIds, U as unregisterChartType, X as unregisterRendererDefaults, Y as unregisterRendererLayer } from './plugin-aGUD1epn.js';
+export { D as DEFAULT_PANEL_MAX_WIDTH, a as DEFAULT_PANEL_MIN_WIDTH, b as DEFAULT_PANEL_WIDTH, S as SidePanelOptions, c as clampPanelWidth } from './side-panel-CT9ZwIGz.js';
+export { i as iconMarkup, r as registerIcon } from './icons-BZYbJXSV.js';
+export { a as KeyBindingDescriptor, R as ResolvedBinding } from './keymap-CGOz5F5f.js';
+
+/**
+ * The single source of truth for a chart's user drawings. Owns identity + paint
+ * order (z), exposes CRUD + persistence, and fires `onChange` so the controller
+ * re-syncs the renderer. Renderer-agnostic — holds {@link Drawing} instances, but
+ * everything that leaves is plain {@link SerializedDrawing} data.
+ */
+declare class DrawingStore {
+    private readonly byId;
+    private seq;
+    private zCounter;
+    private readonly listeners;
+    /** Allocate a unique, stable drawing id. */
+    nextId(): string;
+    /** Insert a drawing, assigning a mount-order z (later ⇒ painted in front) when it carries
+     *  none. The counter only ever grows, so the fallback stays the front among drawings even
+     *  after explicit keys landed below it. */
+    add(d: Drawing): Drawing;
+    remove(id: string): boolean;
+    get(id: string): Drawing | undefined;
+    has(id: string): boolean;
+    /** Apply a (possibly partial) record onto an existing drawing in place. */
+    update(id: string, patch: Partial<SerializedDrawing>): Drawing | null;
+    /** Every drawing in paint order (ascending z). */
+    all(): Drawing[];
+    /** Drawings on one pane, in paint order. */
+    byPane(paneId: string): Drawing[];
+    /** Raise over every drawing — and over `floorZ`, the top of the pane's series stack when
+     *  the renderer shares one z space with it, so "front" beats the candles too. */
+    bringToFront(id: string, floorZ?: number): void;
+    /** Drop under every drawing — and under `ceilZ`, the bottom of the pane's series stack,
+     *  so "back" lands behind the candles and the indicators, not just other drawings. */
+    sendToBack(id: string, ceilZ?: number): void;
+    setLocked(id: string, v: boolean): void;
+    setVisible(id: string, v: boolean): void;
+    clear(): void;
+    serialize(): DrawingsDocument;
+    /** Replace all drawings from a (validated) document. Unknown types are skipped. */
+    load(doc: unknown): void;
+    onChange(cb: () => void): Unsubscribe;
+    /** Keep `nextId()` from colliding with a loaded `dw-N` id. */
+    private bumpSeqPast;
+    private emit;
+}
+
+/** Price-axis display mode: absolute price, percent change vs a visible baseline, or
+ *  values indexed to 100 at that same baseline (`index = price / baseline * 100`). */
+type ScaleMode = 'price' | 'percent' | 'indexed';
+
+interface GridLineStyle {
+    visible: boolean;
+    /** `null` ⇒ inherit `theme.gridColor`. */
+    color: string | null;
+}
+interface CrosshairStyle {
+    /** `null` ⇒ inherit `theme.textColor`. */
+    color: string | null;
+    width: number;
+    style: LineStyle;
+    /** Line opacity (0–1); reference charting crosshairs are translucent. */
+    opacity: number;
+    /** Axis-chip background; `null` ⇒ inherit `theme.textColor`. */
+    labelBackground: string | null;
+}
+interface CandleStyle {
+    /** Whether the filled candle body is drawn (off ⇒ wicks/borders only). */
+    bodyVisible: boolean;
+    borderVisible: boolean;
+    /** `null` ⇒ inherit the body color. */
+    borderUpColor: string | null;
+    borderDownColor: string | null;
+    wickVisible: boolean;
+    wickUpColor: string | null;
+    wickDownColor: string | null;
+}
+/**
+ * Per-price-style cosmetics — each chart type carries its OWN colors and does NOT
+ * inherit from another style. A `null` color is the style's "use the chart's
+ * up/down default" sentinel (so an untouched style still matches the candle palette
+ * and the prior rendering); set it and that style becomes independent. The candle
+ * BODY colors stay the renderer's `upColor`/`downColor` (the `candles` block adds
+ * border/wick on top); these four blocks cover the non-candle styles.
+ */
+interface BarsStyle {
+    /** `null` ⇒ inherit the chart up color. */
+    upColor: string | null;
+    /** `null` ⇒ inherit the chart down color. */
+    downColor: string | null;
+}
+interface LineSeriesStyle {
+    /** `null` ⇒ inherit the chart up color. */
+    color: string | null;
+    width: number;
+}
+interface AreaSeriesStyle {
+    /** `null` ⇒ inherit the chart up color. */
+    lineColor: string | null;
+    width: number;
+    /** Gradient top (near the line); `null` ⇒ the resolved line color. */
+    topColor: string | null;
+    /** Gradient bottom (at the baseline); `null` ⇒ transparent. */
+    bottomColor: string | null;
+}
+interface BaselineSeriesStyle {
+    /** `null` ⇒ the baseline up default (`BASELINE_TOP_LINE`). */
+    topLineColor: string | null;
+    /** `null` ⇒ the baseline down default (`BASELINE_BOTTOM_LINE`). */
+    bottomLineColor: string | null;
+    /** Top area fill near the up line; `null` ⇒ a wash of the top line color at `BASELINE_FILL_ALPHA`. */
+    topFillColor: string | null;
+    /** Top area fill near the baseline (the lower end of the top area); `null` ⇒ a fainter
+     *  wash of the top line color at `BASELINE_FILL_ALPHA_FAR`. */
+    topFillColor2: string | null;
+    /** Bottom area fill near the down line; `null` ⇒ a wash of the bottom line color at `BASELINE_FILL_ALPHA`. */
+    bottomFillColor: string | null;
+    /** Bottom area fill near the baseline (the upper end of the bottom area); `null` ⇒ a fainter
+     *  wash of the bottom line color at `BASELINE_FILL_ALPHA_FAR`. */
+    bottomFillColor2: string | null;
+    width: number;
+    /** Baseline position as a percent of the visible pane price range (0 = low, 100 = high). */
+    baselineLevel: number;
+}
+interface ChartStyle {
+    /** Per-chart-type settings (plugin SDK sections), keyed by type id then row key. */
+    chartTypes: Record<string, Record<string, unknown>>;
+    /** Axis/label font size in CSS px (the family stays on the theme). */
+    fontSize: number;
+    gridVert: GridLineStyle;
+    gridHorz: GridLineStyle;
+    /** Axis frame lines (the right price-axis border); `null` ⇒ inherit `theme.borderColor`. */
+    borderColor: string | null;
+    /** The draggable line between stacked panes; `null` ⇒ inherit `theme.borderColor`. */
+    separatorColor: string | null;
+    crosshair: CrosshairStyle;
+    candle: CandleStyle;
+    bars: BarsStyle;
+    line: LineSeriesStyle;
+    area: AreaSeriesStyle;
+    baseline: BaselineSeriesStyle;
+}
+interface ChartConfig {
+    version: number;
+    layout: {
+        background: string;
+        textColor: string;
+        fontFamily: string;
+        fontSize: number;
+    };
+    grid: {
+        vertLines: {
+            visible: boolean;
+            color: string;
+        };
+        horzLines: {
+            visible: boolean;
+            color: string;
+        };
+    };
+    crosshair: {
+        color: string;
+        width: number;
+        style: LineStyle;
+        opacity: number;
+        labelBackground: string;
+    };
+    priceScale: {
+        mode: ScaleMode;
+        log: boolean;
+        /** Inverted price axis (high at the bottom). */
+        invert: boolean;
+        borderColor: string;
+        labelsVisible: boolean;
+        currentPriceLine: boolean;
+        priceLabel: boolean;
+        countdown: boolean;
+    };
+    /** Stacked-pane chrome — the draggable line between an indicator's pane and the one above it. */
+    panes: {
+        separatorColor: string;
+    };
+    /** Strategy trade markers (the `tradeMarkers` feature): the order-fill units on the price pane. */
+    trades: {
+        visible: boolean;
+        /** The order-id/comment text line. */
+        labels: boolean;
+        /** The signed-quantity text line. */
+        qty: boolean;
+        longColor: string;
+        shortColor: string;
+        exitColor: string;
+    };
+    timeScale: {
+        timezone: string;
+    };
+    /** Per-chart-type settings (plugin SDK sections), keyed by type id then row key. */
+    chartTypes: Record<string, Record<string, unknown>>;
+    candles: {
+        upColor: string;
+        downColor: string;
+        bodyVisible: boolean;
+        borderVisible: boolean;
+        borderUpColor: string;
+        borderDownColor: string;
+        wickVisible: boolean;
+        wickUpColor: string;
+        wickDownColor: string;
+    };
+    /** OHLC-bars style — its own up/down (independent of the candle body colors). */
+    bars: {
+        upColor: string;
+        downColor: string;
+    };
+    /** Line style — its own color + width. */
+    line: {
+        color: string;
+        width: number;
+    };
+    /** Area style — its own line + gradient-fill colors + width. */
+    area: {
+        lineColor: string;
+        width: number;
+        topColor: string;
+        bottomColor: string;
+    };
+    /** Baseline style — its own above/below line + two-stop fill colors + width + level. */
+    baseline: {
+        topLineColor: string;
+        bottomLineColor: string;
+        topFillColor: string;
+        topFillColor2: string;
+        bottomFillColor: string;
+        bottomFillColor2: string;
+        width: number;
+        baselineLevel: number;
+    };
+    series: {
+        style: PriceStyle;
+        baseline: number | null;
+        /** Spacing multiplier for non-connecting styles (candles/bars/HA/plugin types): scales the
+         *  center-to-center pitch (and the crosshair step) without changing body width. 1 = default. */
+        spacing: number;
+    };
+    /** Draw-order keys — what paints in front of what. The candles' own key plus one per
+     *  indicator id; user drawings persist their keys in the drawings document, in the same
+     *  space, so a saved chart keeps a drawing under the candles or between two indicators. */
+    stacking: {
+        candles: number;
+        series: Record<string, number>;
+    };
+}
+
+/**
+ * The native renderer's chart-settings dialog (item 15): a DOM overlay, opened from
+ * an in-chart gear, that edits a curated slice of the serializable `ChartConfig`
+ * (background, candle/grid/crosshair colors, fonts, price scale, timezone, …). Each
+ * control emits a minimal nested patch via `onChange`; the renderer merges it onto
+ * the live config and repaints with NO indicator re-run. A footer exposes the whole
+ * config as JSON for export/import — the templating surface.
+ *
+ * It is renderer chrome (a positioned overlay on the chart container), kept
+ * dependency-free and themed to match the chart, mirroring `InputsUI`.
+ */
+/** A host-contributed settings row: callback-based (the host owns the state).
+ *  `heading` opens a titled group inside the tab (an in-pane section title). */
+type HostSettingsRow = {
+    kind: 'heading';
+    label: string;
+} | {
+    kind: 'toggle';
+    label: string;
+    get: () => boolean;
+    set: (v: boolean) => void;
+} | {
+    kind: 'select';
+    label: string;
+    options: readonly string[];
+    get: () => string;
+    set: (v: string) => void;
+};
+/** A host-contributed settings tab (see `RendererControl.setSettingsSections`). */
+interface HostSettingsSection {
+    title: string;
+    rows: readonly HostSettingsRow[];
+    /** Tab position: own tab after Symbol (default), end of the rail, or rows INSIDE
+     *  the Symbol tab itself (`'symbol'` — e.g. the widget's watermark toggle). */
+    placement?: 'after-symbol' | 'end' | 'symbol';
+}
+
+/**
+ * The from-scratch "native" renderer (canvas2d backend in P0/P1/P2; hand-rolled
+ * WebGL2 added in P3 behind the same backend seam). P0 implements the full
+ * `IChartRenderer` surface but only the foundation is live: layered DOM, the
+ * shared CoordinateSystem, the invalidation scheduler, pane layout, and
+ * pointer/wheel pan-zoom over a placeholder grid. Series/fills/drawings/axes/
+ * crosshair/inputs land in P1–P2.
+ */
+declare class NativeRenderer implements IChartRenderer {
+    readonly capabilities: RendererCapabilities;
+    private theme;
+    private surfaceBackground;
+    private surfaceTextColor;
+    private wrapper;
+    private plot;
+    private toolbarGutter;
+    private mountContainer;
+    private dataCanvas;
+    private volumeCanvas;
+    private vpvrCanvas;
+    private chromeCanvas;
+    private drawingsCanvas;
+    private cursorCanvas;
+    private overlayRoot;
+    private userDrawings;
+    private readonly volumeRenderer;
+    /** SDK renderer layers instantiated at mount ({@link registerRendererLayer}). */
+    private extLayers;
+    private attributionEl;
+    private attributionEnabled;
+    /** Host-supplied mark shown INSTEAD of the built-in one (`attribution: '<html>'`). */
+    private attributionHtml;
+    private readonly vpvrRenderer;
+    private resizeObserver;
+    private dprMedia;
+    private readonly coords;
+    private readonly scene;
+    private backend;
+    private backendMode;
+    private glowAmount;
+    private readonly chrome;
+    private readonly crosshairLayer;
+    private scheduler;
+    /** 1 Hz repaint pump so the price-axis countdown-to-bar-close ticks; null when off. */
+    private countdownTimer;
+    private animator;
+    private input;
+    private inputsUI;
+    private symbolPicker;
+    /** Indicator titles (the legend rows) shown — held here so a remount re-applies it. */
+    private indicatorTitlesOn;
+    /** Host-contributed legend actions — held here so a rebuild of the legend re-wires them. */
+    private legendActionsProvider;
+    private keyboard;
+    private keyboardEnabled;
+    /** Drawings layer self-serves Ctrl+Z/Y (see the `historyChords` feature). */
+    private historyChordsEnabled;
+    private liveRegion;
+    private animZoom;
+    private animPan;
+    private candleUp;
+    private candleDown;
+    private introStyle;
+    private introPlayed;
+    private introRaf;
+    /** The load affordance (three pulsing dots) — up while the host reports a bar load in
+     *  flight with nothing painted (first load, market switch). Rebuilt per show, so it
+     *  picks up the current theme without a setTheme hook. */
+    private loadingEl;
+    private modelAlpha;
+    private targetBarSpacing;
+    private zoomAnchorLogical;
+    private zoomAnchorX;
+    private zoomAnchorMode;
+    private panVelocity;
+    private bars;
+    private didInitialFit;
+    /** A data-tier paint has happened (scales + drawing resolvers are real) — gates the
+     *  cheap chrome-only repaint so it never draws over placeholder state. */
+    private paintedData;
+    private skeletonClockMs;
+    private candleBodyAlpha;
+    private candleStructureAlpha;
+    private lastPointer;
+    private volumeActive;
+    private volumeHidden;
+    private vpvrActive;
+    private vpvrHidden;
+    private liveEaseTime;
+    private liveEaseHigh;
+    private liveEaseLow;
+    private liveEaseClose;
+    private axisDragEnabled;
+    private scaleDragHolder;
+    private scaleDragHeight;
+    private scaleDragStart;
+    private paneResizeEnabled;
+    private resizeAbove;
+    private resizeBelow;
+    private resizeSplitStart;
+    private hoverSeparatorY;
+    private maximizedPaneId;
+    private rightAxisW;
+    private paneControls;
+    private readonly paneActionCbs;
+    private hoverLogical;
+    private settingsDialog;
+    /** Where modal dialogs mount — a HOST override (multi-chart shells pass their root
+     *  so dialogs center globally instead of clipping inside one cell). Null = the plot. */
+    private dialogHost;
+    private settingsButton;
+    private settingsEnabled;
+    private scrollButton;
+    private pointerNearScrollBtn;
+    private scrollTargetRO;
+    private scrollBtnBottomPx;
+    private scrollBtnRightPx;
+    private readonly viewportCbs;
+    private readonly crosshairCbs;
+    private readonly chartTypeSettingsCbs;
+    private readonly configChangedCbs;
+    /** The settings dialog's Canvas → Theme row raises the pick here; the host applies it. */
+    private readonly themeSelectCbs;
+    /** First-run config snapshot — what "Reset defaults" restores. */
+    private factoryConfig;
+    private hostSettingsSections;
+    private readonly clickCbs;
+    private readonly inputChangeCbs;
+    private readonly removeIndicatorCbs;
+    private readonly toggleVisibleCbs;
+    private readonly moveIndicatorCbs;
+    private readonly priceStyleCbs;
+    private readonly tableOverlays;
+    constructor(opts?: RendererDisplayOptions);
+    readonly name = "native";
+    readonly features: readonly string[];
+    /** Apply a render feature live — mutate the field + invalidate, no engine re-run. */
+    applyFeature(key: string, value: unknown): void;
+    readFeature(key: string): unknown;
+    /**
+     * Native-layer data push (see `setNativeData` on the port), keyed by native type. A chart-type
+     * indicator pushes its per-bar order-flow (revealed under the candles on zoom); the volume + VPVR
+     * indicators push their layer CONFIG only — both layers read the chart's bars each frame.
+     */
+    setNativeData(type: string, data: unknown): void;
+    /** Reflect an indicator's live status (loading / live / idle) in its legend row. */
+    setIndicatorStatus(handle: IndicatorRenderHandle, status: IndicatorStatus): void;
+    /**
+     * The host reports a bar load in flight with nothing painted (first load, market switch —
+     * see the port): three small dots pulse at the center of the plot. Web-Animations-driven,
+     * so no stylesheet crosses the renderer boundary; pointer-transparent, and removed (not
+     * hidden) on clear so a re-show picks up the current theme.
+     */
+    setLoading(loading: boolean): void;
+    /**
+     * Set the active symbol's tick size so the price axis shows the instrument's true
+     * precision (see the port). Undefined / non-positive ⇒ fall back to the zoom formula.
+     */
+    setPricePrecision(mintick: number | undefined): void;
+    /**
+     * Snapshot the full chart cosmetics as one serializable, versioned document.
+     * Every inherited value is resolved to a concrete one so an exported template
+     * stands on its own. Stable shape — safe to persist (localStorage) or share.
+     */
+    getConfig(): ChartConfig;
+    /**
+     * Apply a (possibly partial) config document — the inverse of `getConfig()`.
+     * Untrusted JSON is validated + merged onto the current config (`mergeConfig`),
+     * so malformed fields are dropped and a partial patch only changes what it names.
+     * Repaints with NO indicator re-run; safe to call live or before mount.
+     */
+    applyConfig(config: unknown): void;
+    /**
+     * Reorder one indicator's series layer. Accepts `{ id, to: 'front' | 'back' }`
+     * (relative to every layer incl. the candles) or `{ id, z }` (an explicit key).
+     */
+    private applySeriesOrder;
+    /** Toggle the in-chart settings gear + dialog (the `settings` feature). The gear
+     *  sits above the time axis, clear of the right price-axis strip. */
+    private setSettingsEnabled;
+    private makeSettingsButton;
+    /** Port surface: hosts (bottom-bar / chrome buttons) open the same dialog as the
+     *  in-chart gear — created on demand, independent of the gear feature being enabled. */
+    openSettingsDialog(section?: string): void;
+    /** (Re)aim the dialog's Canvas → Theme row: the current selection reflects the STABLE
+     *  app-theme surface (not the plot background, which the config recolors
+     *  independently); a pick is raised to the host (`onThemeSelect`), which owns the
+     *  canonical theme. */
+    private syncThemeControl;
+    private toggleSettingsDialog;
+    /** Close the in-chart dialogs (indicator settings + chart-settings gear). No-op when none are open. */
+    closeDialogs(): void;
+    /** Jump-back-to-latest button — same size/border chrome as the drawing-toolbar collapse toggle. */
+    private makeScrollToRealtimeButton;
+    /** Double-chevron icon — the "jump back to the latest bar" affordance. */
+    private scrollButtonIcon;
+    /** The button's fill — the chart background at 50% so it blends with the plot beneath. */
+    private scrollButtonSurface;
+    /** Re-sync the scroll button's colors when `layout.background` changes — called from both
+     *  `applyConfig` (playground path) and `setTheme` (app-theme swap). */
+    private refreshScrollButtonTheme;
+    /** Track cursor proximity to the scroll button on the plot (bubbles from the button too,
+     *  so moving onto the button doesn't count as leaving). */
+    private readonly onScrollProximityMove;
+    private readonly onScrollProximityLeave;
+    /** Show the button only when the latest bar is scrolled off the right edge AND the cursor is nearby. */
+    private updateScrollToRealtimeButton;
+    /** Glide the view back to the most recent bars, keeping the current zoom (barSpacing). */
+    private scrollToRealtime;
+    /** Ease rightOffset to `target` at constant zoom (see animTick's scroll glide);
+     *  instant when pan animation is off. Shared by scroll-to-latest and panBy. */
+    private glideRightOffset;
+    /**
+     * Export the current chart as a PNG data URL by compositing the geometry (L0)
+     * + chrome (L1) + user-drawings (L1.5) canvases onto an offscreen canvas. The
+     * background is filled first (the canvas2d data layer is transparent — its bg
+     * lives on the wrapper), and a fresh synchronous paint runs first so the WebGL2
+     * backend's (non-preserved) drawing buffer is populated before it's read back
+     * this tick — the same paint also repaints the drawings layers, so they're
+     * current (interleaved drawings are already inside the data composite). They're
+     * drawn bottom-up in DOM stacking order so the front user drawings (trend lines,
+     * boxes, etc.) sit above the Pine drawings on the chrome layer, matching what's
+     * on screen. The crosshair (L2) and DOM overlays (tables, legend) are
+     * intentionally excluded.
+     */
+    screenshot(): string | null;
+    /**
+     * The candles-first-appear reveal — animates the **candles themselves** (no extra
+     * element). Each candle's OHLC is interpolated from a flat tick at its open up to
+     * full size, eased, with a left→right stagger so the chart draws itself; `settle`
+     * adds an ease-out-back overshoot. Autoscale stays on the real bars so the frame
+     * never moves. Re-callable, so styles can be compared live from the console.
+     */
+    private playIntro;
+    /** After the candle reveal, fade the indicator models (series/fills/…) from hidden to full. */
+    private fadeInModels;
+    /**
+     * One candle of the reveal: interpolate its body + wick from a flat tick at the open
+     * up to full size, staggered left→right. `settle` overshoots past full then eases back.
+     */
+    private revealCandle;
+    /** Theme with the configured candle up/down colors applied (candles, wicks,
+     *  plotcandle defaults, and the current-price line direction all follow them). */
+    private deriveTheme;
+    /** The theme the chrome (drawing toolbar / settings popups) paints with: the live theme
+     *  but pinned to the stable surface background, text, and border, so custom plot cosmetics
+     *  never recolor the toolbar, gutters, or drawing UI chrome. */
+    private chromeTheme;
+    mount(container: HTMLElement, theme: VelaTheme): void;
+    /**
+     * Create + mount the L0 geometry backend and return its canvas. Picks WebGL2
+     * when allowed + available (probed), else the canvas2d backend (the permanent
+     * fallback). If a GL context can't be acquired the (tainted) canvas is discarded
+     * and a fresh one is made for canvas2d.
+     */
+    private makeDataCanvas;
+    private createGeometryBackend;
+    /**
+     * The WebGL2 context became permanently unusable (a restore couldn't rebuild
+     * the program) → replace the L0 backend with the canvas2d fallback on a fresh
+     * data canvas. The chrome/cursor layers + viewport state are untouched.
+     */
+    private swapToCanvas2dFallback;
+    /**
+     * Re-sync both canvases when devicePixelRatio changes WITHOUT a CSS resize —
+     * e.g. dragging the window to a monitor with different scaling, or an OS/
+     * browser zoom change (the ResizeObserver doesn't fire for those). A
+     * `(resolution: Xdppx)` query only tracks one dpr boundary, so it's re-armed
+     * for the new dpr each time it fires.
+     */
+    private watchDpr;
+    private readonly onDprChange;
+    setTheme(theme: VelaTheme): void;
+    resize(): void;
+    /** Run a 1 Hz repaint pump while the countdown chip is on (so it ticks); stop it otherwise.
+     *  Chrome tier: only the chip's wall-clock text moves — an idle chart must not recompute
+     *  scales or repaint the geometry/volume/VPVR/SDK layers once a second (that cost
+     *  multiplies by the cell count in a multi-chart workspace). */
+    private syncCountdownTimer;
+    destroy(): void;
+    setBars(bars: OHLCV[], opts?: {
+        preserveView?: boolean;
+    }): void;
+    updateBar(bar: OHLCV): void;
+    /** Snap the eased forming-bar state to `bar` — no glide (a fresh bar or the first tick of one). */
+    private syncLiveEase;
+    /** Glide the forming bar's displayed high/low/close toward the actual latest. Returns true while easing. */
+    private easeLiveBar;
+    ensurePane(pane: Pane): void;
+    removePane(id: string): void;
+    /** Move/merge a mounted indicator to another pane (its scale column follows via `ownScale`). */
+    setIndicatorPane(handle: IndicatorRenderHandle, paneId: string, opts?: {
+        ownScale?: boolean;
+    }): void;
+    orderPanes(orderedIds: string[]): void;
+    setPaneCollapsed(paneId: string, collapsed: boolean): void;
+    setPaneMaximized(paneId: string | null): void;
+    onPaneAction(cb: (a: PaneAction) => void): Unsubscribe;
+    private emitPaneAction;
+    onMoveIndicator(cb: (id: string, target: MoveTarget) => void): Unsubscribe;
+    /** The number of merged (own-scale) scale columns needed = max across panes. */
+    private maxOwnScaleColumns;
+    /** Recompute the right-gutter width (master column + one per merged scale). Re-sizes on change. */
+    private refreshAxisWidth;
+    /**
+     * Re-derive one model's index offset: the chart bar index of its `anchorTime` (see
+     * `IndicatorModel.anchorTime`). Absent anchor, or an anchor matching the first bar,
+     * means whole-chart alignment — offset 0, today's norm. An anchor that doesn't land
+     * exactly on a chart bar renders unanchored (defensive; engines stamp a real bar time).
+     */
+    private refreshAnchorOffset;
+    mountIndicator(model: IndicatorModel): IndicatorRenderHandle;
+    updateIndicator(handle: IndicatorRenderHandle, patch: ScenePatch): void;
+    removeIndicator(handle: IndicatorRenderHandle): void;
+    setIndicatorInputs(handle: IndicatorRenderHandle, values: Record<string, InputValue>): void;
+    setSymbolPicker(picker: SymbolPickerFn | null): void;
+    setLegendActions(provider: ((indicatorId: string) => LegendActionView[]) | null): void;
+    /**
+     * Hide/show a mounted indicator. Hiding drops its model from the scene (so every paint path —
+     * series, fills, drawings, tables, glow, data window — skips it) while keeping its z key and its
+     * legend row (marked hidden). The core re-mounts it on show, so this only needs to drop the
+     * visuals and flag the row.
+     */
+    setIndicatorVisible(handle: IndicatorRenderHandle, visible: boolean): void;
+    onInputChange(cb: (e: InputChangeEvent) => void): Unsubscribe;
+    onToggleIndicatorVisible(cb: (id: string, visible: boolean) => void): Unsubscribe;
+    onPriceStyleChange(cb: (style: PriceStyle) => void): Unsubscribe;
+    /**
+     * THE single write path for the base price style at runtime (feature set / settings dialog /
+     * config template — the constructor seeds the field directly, pre-listeners). Updates the
+     * scene, eases any reveal layer toward the new style's target, and notifies the core —
+     * which owns the DATA side of styles that need one (a chart type's SeriesDataEngine).
+     */
+    private setPriceStyle;
+    onRemoveIndicator(cb: (id: string) => void): Unsubscribe;
+    setSettingsSections(sections: HostSettingsSection[]): void;
+    onChartTypeSettingsChange(cb: (typeId: string, values: Record<string, unknown>) => void): Unsubscribe;
+    onConfigChanged(cb: () => void): Unsubscribe;
+    onThemeSelect(cb: (theme: ThemeName) => void): Unsubscribe;
+    onCrosshairMove(cb: (e: CrosshairEvent) => void): Unsubscribe;
+    onClick(cb: (e: ClickEvent) => void): Unsubscribe;
+    onViewportChange(cb: (range: VisibleRange) => void): Unsubscribe;
+    getVisibleRange(): VisibleRange | null;
+    setVisibleRange(range: VisibleRange): void;
+    /** Pan by a fraction of the visible width at constant zoom (positive ⇒ toward the
+     *  latest bars). Mirrors a drag exactly: the target is clamped by the same viewport
+     *  bounds (so panning forward stops at the newest candle plus the bounded right
+     *  whitespace) and eases on the scroll-to-latest glide — repeated calls retarget the
+     *  running glide, so a held key reads as one continuous scroll. */
+    panBy(fraction: number): void;
+    /** Instant viewport set (drag, freeze-on-touch, setVisibleRange) — stops any animation. */
+    private applyViewport;
+    /** Eased cursor-anchored zoom: glide barSpacing → target, pinning the anchor logical at its pixel. */
+    private zoomTo;
+    /** Inertial pan: continue with a rightOffset velocity (logical units / ms) that decays. */
+    private fling;
+    private anchoredRightOffset;
+    /**
+     * Bound the viewport so the user can't zoom/pan into a useless state:
+     *  - zoom OUT no further than "all bars + a small margin fill the width" (no thin strip
+     *    of compressed candles floating in whitespace);
+     *  - zoom IN no further than keeping ≥ {@link MIN_VISIBLE_BARS} candles on screen;
+     *  - pan no further than a bounded right whitespace / the same minimum visible.
+     * Applied at every viewport write (drag, wheel, fling, time-axis drag, keyboard).
+     */
+    private clampViewport;
+    /** One animation frame: ease zoom + integrate inertia + glide autoscale, then paint. */
+    private animTick;
+    /** Ease each pane's rendered scale toward its autoscale target (snap within epsilon).
+     *  Log panes ease in LOG space so the glide is uniform on screen (the pane renders
+     *  through Math.log), not a non-linear jump. */
+    private easeScales;
+    private emitViewportChange;
+    private handlePointerMove;
+    private handleClick;
+    private paneAtY;
+    /** The pane node whose vertical bounds contain `y` (linear scan; panes don't overlap). */
+    private paneNodeAtY;
+    /** The scale window a gesture targets: a pane's master scale, or a merged indicator's
+     *  own scale column (resolved from the grabbed x). Both share the four scale fields. */
+    private resolveScaleHolder;
+    /** Grab the price axis: snapshot the grabbed scale's window and freeze it into manual mode. */
+    private beginPriceScale;
+    /** Rescale the grabbed scale around its center by the total drag (down ⇒ zoom out). */
+    private priceScaleBy;
+    /** Grab inside the data area: vertical price-pan is available only when the pane is
+     *  already manual (so a normal drag stays a pure time-pan until the user opts in). */
+    private beginPricePan;
+    /** Pan the grabbed pane's price window by the total drag (down ⇒ show lower prices). */
+    private pricePanBy;
+    /** Double-click the price axis → drop manual mode for that scale (autoscale resumes). */
+    private resetPriceScale;
+    /**
+     * New double-click semantics inside the data area: the price pane toggles collapse of
+     * every study pane (hide/show sub panes); a study pane toggles maximize. (Keyboard `0`
+     * still fits the view.)
+     */
+    private dataDblClick;
+    /** Re-fit the view and drop every manual scale (keyboard `0`). */
+    private resetView;
+    private setManualScale;
+    /** Relayout + repaint + refresh the hover buttons after a collapse/maximize/order change. */
+    private afterPaneLayoutChange;
+    /** Thin projection of the panes for the hover-control cluster (top-to-bottom order). */
+    private paneControlViews;
+    /** Reorder a study pane one slot up/down (renderer-applied, mirrored to core via onPaneAction). */
+    private movePaneLocal;
+    /** True when `y` is within the hit zone of a draggable sub-pane separator. */
+    private paneSeparatorAt;
+    /** Pixel y of the draggable separator under the cursor (for the hover highlight), or null. */
+    private separatorHoverY;
+    /** Index (in `orderedPanes`) of the LOWER pane whose top separator is within the hit
+     *  zone of `y`, or null. Separators sit between every adjacent pair, so the first
+     *  candidate is index 1 (the top of the second pane). */
+    private separatorPaneIndexAt;
+    /** Grab the separator at `y`: snapshot the adjacent panes + their shared pixel span. */
+    private beginPaneResize;
+    /** Resize the grabbed panes by the total drag (down ⇒ grow the upper pane), keeping the
+     *  combined weight fixed so every other pane keeps its height. */
+    private paneResizeBy;
+    /** Double-click a separator → split the two adjacent panes evenly (each gets half of
+     *  their combined weight). A simple, predictable reset that leaves siblings untouched. */
+    private resetPaneSize;
+    /** Enable/disable keyboard control: focusability + ARIA + key listeners + live region. */
+    private setKeyboardEnabled;
+    /** Pan the view by a whole number of bars (keyboard): +bars ⇒ toward the latest. */
+    private panByBars;
+    /** Zoom one keyboard notch, right-edge anchored (+1 in, -1 out). */
+    private zoomByStep;
+    /** Move the focused bar by `delta` from the current crosshair bar (or the last bar). */
+    private stepCrosshair;
+    /** Center-ish the given bar in view (scrolling minimally), draw the crosshair on it,
+     *  and announce its OHLC + indicator values to the ARIA live region. */
+    private focusBar;
+    /** Update the ARIA live region with a spoken summary of bar `idx` (date + OHLC + values). */
+    private announceBar;
+    /** The data-window readout (port seam) — the hovered bar's date/time and OHLCV plus every
+     *  indicator's value there, or the latest bar when the cursor is off the plot. Values are
+     *  pre-formatted on the scale of the pane they belong to, so a host panel renders them as-is. */
+    getDataWindowReadout(): DataWindowReadout;
+    private dataWindowPricePane;
+    private dataWindowFmt;
+    private dataWindowOHLC;
+    /** One group per indicator (name = indicator title), each with a row per drawable plot. */
+    private dataWindowGroups;
+    private renderFrame;
+    /** Paint the below-data (L-1) + geometry (L0) + chrome (L1) layers from the current scene/coords. */
+    private paintData;
+    /** Build the data→pixel projector user drawings resolve their anchors through. */
+    private drawingProjector;
+    /** OHLC bars whose open-time falls within `[from, to]` (inclusive) — the data a regression
+     *  (or other statistical) drawing fits against. `this.bars` is ascending, so a linear scan is fine. */
+    private barsInTimeRange;
+    /** The interactive user-drawings surface the core DrawingController drives. */
+    get userDrawingsPort(): IDrawingsRendererPort | undefined;
+    /** Focus the data canvas — the element chart/drawing keyboard shortcuts key off
+     *  (tabIndex 0 while the `keyboard` feature is on). Host UIs call it after their
+     *  own controls steal focus (e.g. a shared workspace toolbar click). */
+    focus(): void;
+    /** EXTERNAL (synced) crosshair — a ghost marker driven by another chart. Kept in
+     *  DATA space (epoch-ms + optional price) so it stays glued through pan/zoom. */
+    private externalCross;
+    /** Show/clear the external ghost crosshair (port seam — see IChartRenderer). It only
+     *  repaints the cursor overlay (Cursor tier) and NEVER re-emits onCrosshairMove. */
+    setExternalCrosshair(time: Millis | null, price?: number | null): void;
+    /** Resolve the ghost to pixels for THIS frame (null when off-window or dataless).
+     *  Snaps by FLOOR to the bar CONTAINING the foreign time — never by rounding: a 1h
+     *  pointer at 14:00 must light THIS day's daily candle, not tomorrow's (a time past
+     *  a bar's midpoint still belongs to that bar). Before the first open or past the
+     *  forming bar there is no containing bar — no ghost. */
+    private externalCrossPx;
+    /** Sticky magnet mode for user drawings (off/weak/strong); the drawings toolbar drives it. */
+    private snapMode;
+    /** Set the sticky magnet mode (called by the drawings toolbar's 3-state button). */
+    setSnapMode(mode: SnapMode): void;
+    /**
+     * Snap a data point to the nearest candle for the drawing magnet: time → the nearest
+     * bar, price → that bar's closest OHLC value. Off the price pane (sub-panes have no
+     * OHLC) only the time snaps. `weak` only snaps when the candle point is within
+     * {@link WEAK_SNAP_PX} of the cursor pixel; `strong` always snaps; `off` is a no-op.
+     */
+    private snapToCandle;
+    /**
+     * Per-pane autoscale — the single price-window pass both layers consume. Folds
+     * the visible series (computePaneScale) with the visible Pine-drawing range
+     * (own drawings per pane + force_overlay drawings on the price pane), so a box/
+     * line/label outside the series range still expands the scale and never clips.
+     * Runs only on Light/Full frames (the crosshair-only Cursor tier reuses the
+     * retained pane.scale).
+     */
+    private computeScales;
+    /** Union of the visible trade-marker autoscale hints across every mounted indicator
+     *  (trade markers always target the price pane, whatever pane their model landed on). */
+    private tradesScaleHints;
+    private fitContent;
+    private paneBoundsFor;
+    /** The display title of a study pane's master (pane-scale) indicator — merged own-scale
+     *  indicators don't name the pane. Null when the pane holds no indicators. */
+    private paneMasterTitle;
+    /** The pane a bespoke-layer native indicator (volume/vpvr) currently lives in (null = not mounted). */
+    private nativeLayerPane;
+    /** True when an active volume layer is this study pane's ONLY content — so its scale should
+     *  come from volume, not the empty {0,1} placeholder. (In the price pane, or alongside a real
+     *  series, volume stays a bottom overlay and the master scale wins.) */
+    private volumeOwnsPane;
+    /** Per-pane scale state for a host UI (e.g. a price-axis context menu): the pane's pixel
+     *  band (`top`/`height`, so a click y maps to a pane) plus its current axis `mode`/`log`.
+     *  Top-to-bottom order. Every pane is independent — the price pane from the scene setting,
+     *  study panes from their own. */
+    private paneScaleInfos;
+    /** Set one pane's axis mode. The price pane routes to the scene-level setting (persisted +
+     *  keyboard shortcuts); a study pane keeps its own, so panes never affect each other. */
+    private setPaneScaleMode;
+    /** Set one pane's logarithmic flag. Clears that pane's frozen (manual) window so the new
+     *  space re-fits, and routes the price pane to the scene-level flag. */
+    private setPaneLog;
+    /** Flip one pane's axis (high at the bottom). The price pane routes to the scene-level flag
+     *  (persisted with the chart config); study panes keep their own so panes stay independent. */
+    private setPaneInvert;
+    /** Stamp each pane's current inversion onto the live scale objects that {@link CoordinateSystem}
+     *  reads (the pane master scale, its target/manual windows, and any merged own-scale columns),
+     *  so `priceToY`/`yToPrice` flip consistently across every layer — data, chrome, drawings,
+     *  crosshair, hit-testing. Run once per paint (scales are rebuilt each frame by autoscale/ease),
+     *  which also covers pointer-time reads between frames since the objects retain the last stamp. */
+    private stampScaleInvert;
+    /** The first visible value a study pane measures percent-change from: the earliest finite
+     *  value at bar `i0` across its master series (line-like value, else a candle/bar close).
+     *  0 when none is available yet — the axis then falls back to absolute. */
+    private firstVisibleValue;
+    /** Largest volume across the visible bar-index window (0 when none) — the volume pane's scale top. */
+    private maxVisibleVolume;
+    /** Create/update/destroy an indicator's DOM table overlay (anchored off real pane geometry). */
+    private syncTables;
+    private repositionTables;
+    private layoutPanes;
+    /** Pin the scroll-to-realtime button above the bottom-most EXPANDED pane's data area (like the
+     *  watermark): with all lower sub-panes collapsed it settles into the lowest open pane. */
+    private repositionScrollButton;
+    /** For each collapsed pane, the master (master-scale) indicator id whose legend row stays in the
+     *  strip — merged own-scale indicators are hidden while collapsed. */
+    private collapsedMasterMap;
+    /** Reserve `px` of left gutter for the docked drawings toolbar (0 releases it) + re-lay-out the plot. */
+    private setToolbarGutter;
+    /** Publish the gutter on the mount container as `--vela-toolbar-gutter`, so host
+     *  overlays sharing that container (a status line, a custom legend) can anchor to
+     *  the plot's left edge without reaching into the renderer's DOM. */
+    private publishToolbarGutter;
+    /** The built-in mark, or the host's own when one is set. */
+    private buildAttributionEl;
+    /** Swap the mark in place — the content kind changed (built-in ↔ host-supplied). */
+    private rebuildAttribution;
+    /** Bottom-left of the LOWEST visible, non-collapsed pane, above the time axis, clear of
+     *  the drawings toolbar — the same anchor rule as the scroll-to-realtime button. With
+     *  collapsed strips (or a maximize hiding the rest) at the bottom, the mark climbs into
+     *  the lowest open pane instead of sitting on a strip's legend. */
+    private positionAttribution;
+    /** Re-tint the mark when the plot background flips light/dark. A host-supplied mark
+     *  only gets the ink color — its own artwork keeps whatever colors it declares. */
+    private refreshAttributionColor;
+    private syncSize;
+    private applyBackground;
+}
+
+/** Cosmetic/placement options — defaults reproduce the in-renderer docked bar exactly. */
+interface DrawingToolbarOptions {
+    /** Border/divider color. Default: the theme's border color (follows theme swaps). */
+    borderColor?: string;
+    /** Bar width in px. In docked (`'absolute'`) use it MUST match the host renderer's
+     *  left-gutter reservation ({@link TOOLBAR_WIDTH}, 44). Default 44. */
+    width?: number;
+    /** `'absolute'` (default): pinned over the renderer's left gutter. `'static'`: a
+     *  normal column child — a workspace docks ONE shared bar in its own layout. */
+    dock?: 'absolute' | 'static';
+    /** Collapse/expand notification — a docked host resizes its gutter reservation to
+     *  {@link TOOLBAR_COLLAPSED_WIDTH} / the full width (a static bar reflows on its own). */
+    onCollapse?: (collapsed: boolean) => void;
+}
+/**
+ * The vertical drawing toolbar (renderer chrome), docked as a flush bar in the left gutter. Each
+ * {@link ToolGroup} is a cell: clicking the icon arms the group's last-used tool; a chevron beside
+ * it — its own hover target, revealed on cell hover — opens a flyout listing the group's tools. A
+ * cursor button returns to select/idle; measure/eraser modes sit at the bottom, and the magnet is a
+ * cell whose chevron opens an Off/Weak/Strong menu (its icon toggles the last-used strength on/off).
+ * Below the magnet, a stay-in-drawing-mode toggle keeps tools armed after each placement.
+ * Hover and active tints are CSS-driven (`:hover` + `[data-active]`) so they never lag. Tooltips
+ * appear after a 2s hover. Pure vanilla DOM on the host (a `pointer-events:auto` island).
+ */
+declare class DrawingToolbar {
+    private readonly host;
+    private theme;
+    private readonly onArm;
+    private readonly onMagnet;
+    private readonly onMeasure;
+    private readonly onEraser;
+    private readonly onToggleFavorite;
+    private readonly onStayMode;
+    private readonly root;
+    private def;
+    private active;
+    private readonly lastUsed;
+    /** FAVORITE tool types (core-authoritative; pushed via setFavorites). */
+    private favorites;
+    /** Per-tool shortcut display strings (host-pushed via setShortcuts). */
+    private shortcuts;
+    /** Star elements of the currently open flyout, by tool type (live-updated, never stale). */
+    private readonly starEls;
+    private flyout;
+    private flyoutOwnerId;
+    private flyoutCell;
+    private readonly groupCells;
+    private readonly groupIcons;
+    private cursorBtn;
+    private magnetCell;
+    private magnetIcon;
+    private magnetMode;
+    private lastMagnetOn;
+    private measureBtn;
+    private measureActive;
+    private eraserBtn;
+    private eraserActive;
+    private stayBtn;
+    private stayActive;
+    private collapseBtn;
+    private collapsed;
+    private visible;
+    private readonly tipText;
+    /** Chrome-tooltip disposers — flushed whenever the cells are recreated (rebuild/destroy). */
+    private tipDisposers;
+    /** Explicit border override from options; `null` follows the live theme's border. */
+    private readonly borderOverride;
+    private readonly width;
+    private readonly dock;
+    private readonly onCollapse;
+    constructor(host: HTMLElement, theme: VelaTheme, onArm: (type: DrawingTypeKey | null) => void, onMagnet?: (mode: SnapMode) => void, onMeasure?: () => void, onEraser?: () => void, onToggleFavorite?: (type: DrawingTypeKey, on: boolean) => void, onStayMode?: (on: boolean) => void, options?: DrawingToolbarOptions);
+    /** Live divider/border ink — the option override, else the current theme's border
+     *  (so a theme swap re-inks the bar without a rebuild option). */
+    private get borderColor();
+    /** Flush vertical bar pinned to the left gutter (full height, right border, no card chrome).
+     *  The shared tokens are written on the root so the scoped stylesheet drives every
+     *  hover/active state without per-frame JS — and so a workspace can dock the bar outside a
+     *  chart container and still resolve them. */
+    private styleRoot;
+    setDefinition(def: ToolbarDefinition): void;
+    /** Reflect the core's favorite set. An OPEN flyout updates its stars IN PLACE — starring
+     *  is a side action, so it must never close the menu the user is still browsing. */
+    setFavorites(types: readonly DrawingTypeKey[]): void;
+    /** Per-tool shortcut hints (pre-formatted display strings, e.g. `'Alt+T'`) shown at the
+     *  right edge of the flyout rows, beside the favorite star. */
+    setShortcuts(map: Readonly<Partial<Record<DrawingTypeKey, string>>>): void;
+    /** Paint one star for the current favorite state (filled + gold, or outline). */
+    private paintStar;
+    setVisible(visible: boolean): void;
+    setActiveTool(type: DrawingTypeKey | null): void;
+    setTheme(theme: VelaTheme): void;
+    destroy(): void;
+    private rebuild;
+    /** Collapse to a slim expand-strip / restore the full bar, and tell the host so a
+     *  docked renderer can resize its gutter reservation. */
+    private toggleCollapsed;
+    private paintCollapse;
+    /** A cell: a full-width icon button (arms/toggles the primary action) plus, when
+     *  {@link opts.multi} is set, a chevron button absolutely pinned to the right. The icon spans the
+     *  whole cell so its glyph stays centered in the bar (aligned with the single-icon buttons); the
+     *  hover/active tint lives on a centered square (`.vela-dtb-hit`) that hugs the glyph, not the whole
+     *  row. The chevron is its own hover target — revealed on cell hover, tinted only on its own hover. */
+    private makeCell;
+    private makeGroupCell;
+    private makeMagnetCell;
+    /** Clicking the icon arms the group's last-used tool (it does NOT open the flyout). */
+    private onGroupIconClick;
+    /** Clicking the chevron toggles the group's flyout (same group → close; another → switch). */
+    private onArrowClick;
+    /** The magnet icon toggles the last-used strength on/off; the chevron opens the strength menu. */
+    private toggleMagnet;
+    private onMagnetArrowClick;
+    /** Set the magnet mode, notify the renderer, and repaint (used by the menu + icon toggle). */
+    private applyMagnet;
+    /** Reflect the magnet mode externally (e.g. if set programmatically) without notifying back. */
+    setMagnetMode(mode: SnapMode): void;
+    /** Highlight the Measure ruler button while the transient ruler is armed. */
+    setMeasureActive(active: boolean): void;
+    private paintMeasure;
+    /** Highlight the Eraser button while erase mode is active. */
+    setEraserActive(active: boolean): void;
+    private paintEraser;
+    private paintMagnet;
+    /** Toggle stay-in-drawing-mode on/off and notify the renderer. */
+    private toggleStay;
+    /** Reflect stay-in-drawing-mode externally without notifying back. */
+    setStayMode(on: boolean): void;
+    private paintStay;
+    /** Create the positioned flyout panel anchored to a cell, register it as open, and start the
+     *  outside-dismiss. Callers fill it with items. */
+    private beginFlyout;
+    private openGroupFlyout;
+    private openMagnetFlyout;
+    private flyoutHeader;
+    private flyoutSeparator;
+    /** A flyout row, left to right: optional leading icon, label, a check when it's the selected
+     *  entry, an optional shortcut hint, and — at the far right — the favorite star (tool rows).
+     *  Hover tint is CSS (`.vela-dtb-item:hover`), so navigating the menu stays smooth. */
+    private makeFlyoutItem;
+    private readonly onOutside;
+    private closeFlyout;
+    private paintGroupIcon;
+    /** Reconcile active tints from state (armed group / open flyout / cursor / modes). Active is a
+     *  `data-active` attribute the stylesheet paints — no inline background, so hover never sticks. */
+    private highlight;
+    private makeButton;
+    private divider;
+}
+
+/**
+ * In-memory cache of CLOSED bars, keyed by `(provider, symbol, timeframe)`. Each
+ * series holds a single time-sorted, de-duplicated array. Scoped to the current
+ * symbol — `retainSymbol` evicts other symbols' series (the agreed purge policy;
+ * smarter eviction comes later) — except symbols protected via `retain`, the
+ * multi-chart seam: a workspace declares every cell's symbol so one cell's load
+ * never evicts the others' history.
+ *
+ * The default instance (`sharedBarStore`) is shared module-wide so it survives
+ * chart re-creation — that's the whole point: a fresh run for the same symbol
+ * reuses these bars instead of re-downloading them.
+ */
+declare class BarStore {
+    private readonly series;
+    /** Earliest bar-open time fetched for a series — what the cache actually covers. */
+    private readonly coveredFrom;
+    private currentSymbol?;
+    /** Symbols protected from the current-symbol purge (multi-chart cells). Empty = legacy single-chart behavior. */
+    private retained;
+    get(key: string): OHLCV[] | undefined;
+    /**
+     * Record that the series is covered back to `from`. Tracks the EARLIEST such
+     * time — what's been fetched, not what bar boundary happens to align. The
+     * coverage check uses this instead of the first cached bar's time (which is
+     * always at/after the requested `from`, so it can never prove coverage).
+     */
+    markCovered(key: string, from: number): void;
+    /** The earliest time the series is covered back to, or undefined if never fetched. */
+    coveredFromOf(key: string): number | undefined;
+    /** Merge `bars` into the series (dedup by time, incoming wins); keeps it sorted. Returns the merged set. */
+    merge(key: string, bars: OHLCV[]): OHLCV[];
+    /**
+     * Scope the cache to the current chart symbol. Idempotent per symbol: only
+     * purges other-symbol series when the symbol actually CHANGES — so secondary
+     * series (request.security cross-symbol/HTF/LTF) fetched during a run survive
+     * re-runs of the same chart, and are dropped only when the chart symbol flips.
+     * Symbols declared via {@link retain} are never purged.
+     */
+    retainSymbol(symbol: string): void;
+    /**
+     * Declare the set of symbols a multi-chart workspace is displaying (CANONICAL
+     * tickers, post-registry resolution — `chart.data.resolve(sym).ticker`). These
+     * survive every {@link retainSymbol} purge, so cells loading different symbols
+     * stop evicting each other's history. Replaces the previous set and purges
+     * anything now outside `symbols ∪ {currentSymbol}` immediately. An empty set
+     * restores the legacy single-chart policy. Note: SECONDARY symbols a script
+     * fetches (`request.security` cross-symbol) are not in this set and still drop
+     * on cross-cell loads — correctness is unaffected (they re-fetch on demand).
+     */
+    retain(symbols: ReadonlySet<string>): void;
+    /** Drop every series whose symbol is neither `current` nor retained. */
+    private purgeOutside;
+    clear(): void;
+}
+/** Shared module-level store — survives chart re-creation so re-runs reuse bars. */
+declare const sharedBarStore: BarStore;
+
+/**
+ * The default `MarketDataFeed`: a router over a registry of named `DataProvider`s.
+ * It parses every symbol (`name:SYMBOL` / bare `SYMBOL`), resolves a provider,
+ * rewrites the config to that provider's **canonical** identity, and delegates to
+ * an internal {@link CachingDataFeed} — so `BTCUSDT` and `BINANCE:BTCUSDT` collapse
+ * to one cache entry. Offline `data` bypasses the registry entirely.
+ *
+ * Providers are registered at runtime via `chart.data.registerProvider(...)`. Until
+ * one that resolves the chart symbol is registered, `load` **parks** (its promise
+ * stays pending) rather than fetching — so registration drives the first load.
+ */
+declare class MultiProviderFeed implements MarketDataFeed {
+    private readonly registry;
+    private readonly cache;
+    /** The chart symbol's resolved provider — the default for bare secondary symbols. */
+    private primaryProvider;
+    /** A copy of offline history, used to synthesize ticks for the `data` path. */
+    private liveBars;
+    /** Sync-accessible symbol metadata, warmed by load()/symbolInfoFor (the engine reads it synchronously). */
+    private readonly symInfoCache;
+    constructor(store?: BarStore);
+    registerProvider(name: string, provider: DataProvider): Promise<void>;
+    unregisterProvider(name: string): void;
+    providers(): ProviderInfo[];
+    resolveSymbol(raw: string): Resolved | null;
+    /** The registered provider INSTANCE under `name` (undefined if unknown). */
+    providerInstance(name: string): DataProvider | undefined;
+    symbols(name?: string): SymbolDescriptor[];
+    /** Told when a symbol stays unservable by everything registered (the load is parked). */
+    onUnresolved(cb: (info: {
+        symbol: string;
+        providers: string[];
+    }) => void): Unsubscribe;
+    /** Abandon parked waits — a destroyed chart must not keep listeners on the registry. */
+    destroy(): void;
+    /** Resolves when every registered provider's eager index has settled. */
+    ready(): Promise<void>;
+    /** Async per-symbol metadata (the facade's `chart.data.symbolInfo`); also warms the sync cache. */
+    symbolInfoFor(raw: string): Promise<SymbolInfo | undefined>;
+    /**
+     * Per-symbol capabilities, resolved through the owning provider's `capabilitiesFor`
+     * refinement (an instrument may support more than its provider-wide baseline), falling back to the
+     * provider-wide `info()` capabilities. Null when nothing resolves the symbol.
+     */
+    capabilitiesFor(raw: string): ProviderCapabilities | null;
+    load(cfg: MarketConfig): Promise<OHLCV[]>;
+    /**
+     * Synchronous per-symbol metadata for engines (Pine `syminfo.*`), served from the cache
+     * warmed by load(). Undefined until the prefetch lands (the engine then synthesizes a
+     * fallback) and real thereafter — the MarketDataFeed port is synchronous by contract.
+     */
+    symbolInfo(cfg: MarketConfig): SymbolInfo | undefined;
+    private prefetchSymbolInfo;
+    loadRange(cfg: MarketConfig, range: BarRange): Promise<OHLCV[]>;
+    subscribe(cfg: MarketConfig, onBar: (bar: OHLCV) => void): Unsubscribe;
+    /**
+     * Synthesize price-relative ticks for offline `data` runs (no network), so the
+     * forming-candle path is exercised at any price scale. Mirrors the bundled
+     * provider feed's offline behavior.
+     */
+    private synthesizeTicks;
+}
+
+/**
+ * A `MarketDataFeed` decorator that caches CLOSED bars in a shared in-memory
+ * `BarStore`. A new indicator run for the same `(provider, symbol, timeframe)`
+ * serves the already-fetched bars and re-downloads only the uncached **tail**
+ * (newly-closed bars + the forming candle). The forming bar is never cached — the
+ * live poll re-fetches it.
+ *
+ * Savings on a re-run ≈ ⌈N/1000⌉ − 1 requests: dormant for ≤1000-bar charts (the
+ * single tail request is the whole fetch either way), paying off with deep
+ * history. Needs the inner feed's `loadRange`; without it — or for offline
+ * `data` — it transparently falls back to a full `load`.
+ */
+declare class CachingDataFeed implements MarketDataFeed {
+    private readonly inner;
+    private readonly store;
+    constructor(inner: MarketDataFeed, store?: BarStore);
+    load(cfg: MarketConfig): Promise<OHLCV[]>;
+    /**
+     * Cache-backed ranged fetch — the gateway engines use for secondary series
+     * (`request.security` HTF/LTF/cross-symbol) and the orchestrator's backward
+     * history chunks. Caches per `(provider, symbol, timeframe)` in the shared
+     * store. Three cache-friendly shapes:
+     * - **historical** (`to` before the cached tip): served straight from cache
+     *   when it provably holds the window, else fetched whole (and cached — no
+     *   forming bar can exist there);
+     * - **backward extension** (`from` older than coverage): fetch ONLY the
+     *   missing head, never the already-covered remainder again;
+     * - **tail** (everything else covered): refresh only from the last cached bar.
+     * Falls back to a full `load` when the inner feed has no ranged support.
+     */
+    loadRange(cfg: MarketConfig, range: BarRange): Promise<OHLCV[]>;
+    /**
+     * THE provider round-trip chokepoint for ranged fetches. Two jobs:
+     * - Every request goes out with an **explicit `limit`** — some sources clip a
+     *   limit-less request to a small default window and tail-slice, silently
+     *   truncating wide date-bounded fetches (the `request.security` bug).
+     * - A request bigger than one page walks **backward in bounded pages**, so a
+     *   multi-hundred-thousand-bar series arrives as digestible responses instead
+     *   of one giant clip-prone payload.
+     * Returns ascending merged bars plus the oldest time the walk PROVED
+     * (`coveredDownTo`) — honest coverage marking: a count-satisfied early stop
+     * must never claim the requested `from`.
+     */
+    private fetchRange;
+    subscribe(cfg: MarketConfig, onBar: (bar: OHLCV) => void): Unsubscribe;
+    symbolInfo(cfg: MarketConfig): SymbolInfo | undefined;
+}
+
+/**
+ * Bar duration in ms for a Vela timeframe: a bare number is **minutes** (Pine
+ * resolution — `60` = 1h, `240` = 4h), `D`/`W`/`M` are the named periods, and the
+ * `15m`/`4h`/`1d`/`1w` aliases are also accepted. Falls back to 1h for anything unparsed.
+ */
+declare function timeframeToMs(timeframe: string): number;
+
+declare const DARK_THEME: VelaTheme;
+declare const LIGHT_THEME: VelaTheme;
+declare function resolveTheme(theme?: ThemeName | VelaTheme): VelaTheme;
+
+export { BarRange, BarStore, CachingDataFeed, type ChartConfig, type ChartStyle, ClickEvent, CrosshairEvent, DARK_THEME, DataProvider, DataWindowReadout, Drawing, DrawingStore, DrawingToolbar, type DrawingToolbarOptions, DrawingTypeKey, DrawingsDocument, IChartRenderer, IDrawingsRendererPort, IndicatorModel, IndicatorRenderHandle, InputChangeEvent, InputValue, LIGHT_THEME, LineStyle, MarketConfig, MarketDataFeed, Millis, MultiProviderFeed, NativeRenderer, OHLCV, Pane, PriceStyle, ProviderCapabilities, ProviderInfo, RendererCapabilities, RendererDisplayOptions, Resolved, ScenePatch, SerializedDrawing, SnapMode, SymbolDescriptor, SymbolInfo, ThemeName, ToolbarDefinition, VelaTheme, VisibleRange, resolveTheme, sharedBarStore, timeframeToMs };