openalgo-charts 1.0.13 → 1.0.14

package/dist/draw/index.d.ts

@@ -1,360 +1,4 @@
-interface LogicalRange {
-    from: number;
-    to: number;
-}
-interface TimeScaleOptions {
-    barSpacing: number;
-    minBarSpacing: number;
-    maxBarSpacing: number;
-    /** Empty bars of space kept to the right of the latest bar. */
-    rightOffset: number;
-}
-declare class TimeScale {
-    private _barSpacing;
-    private _rightOffset;
-    private readonly _minBarSpacing;
-    private readonly _maxBarSpacing;
-    private _width;
-    private _baseIndex;
-    constructor(options?: Partial<TimeScaleOptions>);
-    setWidth(width: number): void;
-    get width(): number;
-    get barSpacing(): number;
-    setBarSpacing(value: number): void;
-    get rightOffset(): number;
-    setRightOffset(value: number): void;
-    /** Logical index of the latest bar; the right edge anchors to baseIndex+rightOffset. */
-    setBaseIndex(index: number): void;
-    private _rightEdgeIndex;
-    /** Logical index → x (media px), bar center. */
-    indexToX(index: number): number;
-    /** x (media px) → fractional logical index. */
-    xToIndex(x: number): number;
-    /** Currently visible logical index range (fractional, unclamped to data). */
-    visibleRange(): LogicalRange;
-    /** Alias of `visibleRange()` for naming parity with common charting APIs. */
-    getVisibleLogicalRange(): LogicalRange;
-    /**
-     * Set the visible logical range (best effort): pick a bar spacing so the span
-     * fills the width and anchor the right edge at `range.to`. Bar spacing is
-     * clamped to [min,max], so an extreme span lands at the nearest zoom. Fires the
-     * change handler so a host that mutates the scale directly still repaints.
-     */
-    setVisibleLogicalRange(range: LogicalRange): void;
-    /** Repaint hook injected by the host chart, fired after `setVisibleLogicalRange`. */
-    setChangeHandler(fn: (() => void) | null): void;
-    private _onChange;
-    /**
-     * Pan by a pixel delta. Positive `dx` drags chart content to the right
-     * (revealing older bars), matching a natural left-button drag.
-     */
-    scrollByPixels(dx: number): void;
-    /**
-     * Zoom around an anchor x (the cursor): change bar spacing by `factor`
-     * while keeping whatever logical index sits under `focusX` pinned there.
-     * `factor` > 1 zooms in (wider bars).
-     */
-    zoomAtX(focusX: number, factor: number): void;
-    /** Choose bar spacing so `barCount` bars fit the width, anchored at the right edge. */
-    fitContent(barCount: number): void;
-}
-
-interface PriceRange {
-    min: number;
-    max: number;
-}
-/**
- * Price-scale mode. `linear` and `logarithmic` are full coordinate transforms;
- * `percentage`/`indexed-to-100` (rebase to a baseline) and overlay scales are
- * not yet implemented (see the README known limitations).
- */
-type PriceScaleMode = 'linear' | 'logarithmic';
-interface PriceScaleOptions {
-    /** Fraction of pane height kept empty at top/bottom (default 0.1 each). */
-    marginTop: number;
-    marginBottom: number;
-    /** Instrument tick size (minMove), e.g. 0.05. 0 → infer from range. */
-    minMove: number;
-    /** Linear or logarithmic price↔y mapping. */
-    mode: PriceScaleMode;
-    /** Flip the axis (price increases downward) — for spread/short views. */
-    inverted: boolean;
-}
-declare class PriceScale {
-    private _options;
-    private _height;
-    private _min;
-    private _max;
-    private _autoScale;
-    /**
-     * True once a real range has been applied. The default 0..1 is a placeholder,
-     * not a measurement — anything converting y↔price before that would answer
-     * confidently with nonsense.
-     */
-    private _scaled;
-    private _priceFormatter;
-    constructor(options?: Partial<PriceScaleOptions>);
-    get options(): PriceScaleOptions;
-    /** Merge partial options (minMove, mode, inverted, margins) at runtime. */
-    setOptions(opts: Partial<PriceScaleOptions>): void;
-    setHeight(height: number): void;
-    get height(): number;
-    setPriceRange(range: PriceRange): void;
-    /** Whether a real price range has been applied (see `_scaled`). */
-    get scaled(): boolean;
-    priceRange(): PriceRange;
-    /** Whether the range tracks the data (true) or has been set manually (false). */
-    get autoScale(): boolean;
-    setAutoScale(on: boolean): void;
-    /**
-     * Manually scale the visible range around its centre. `factor` > 1 widens the
-     * range (compress / zoom out), < 1 narrows it (expand / zoom in). Switches the
-     * scale to manual mode so autoscale stops overriding it.
-     */
-    scaleAroundCenter(factor: number): void;
-    /**
-     * Pan the visible range vertically by `dy` media px (dragging the plot up/down).
-     * Works in transformed space so it's correct for log scales, and respects
-     * `inverted`. Switches to manual mode so autoscale stops overriding it.
-     */
-    panByPixels(dy: number): void;
-    /** Recompute the visible range from data extremes + configured margins. */
-    autoscale(low: number, high: number): void;
-    /** Coordinate transform for the active mode (identity for linear, log10 for log). */
-    private _t;
-    private _tInv;
-    /** Price → y (media px). Higher price → smaller y (top of pane), unless inverted. */
-    priceToY(price: number): number;
-    /** y (media px) → price. */
-    yToPrice(y: number): number;
-    /** Decimal precision implied by minMove (or the visible range if unset). */
-    precision(): number;
-    /** Snap a price to the instrument tick size (no-op if minMove is 0). */
-    snapToTick(price: number): number;
-    /**
-     * Override the numeric formatting used for axis tick labels, the last-price
-     * tag, and price-line labels (e.g. a currency or percent format). Pass null
-     * to restore the default tick-size-aware `toFixed`.
-     */
-    setPriceFormatter(fn: ((price: number) => string) | null): void;
-    /** Format a price for axis/label display. */
-    format(price: number): string;
-    /** Clamp a y to the pane (used by crosshair/order dragging). */
-    clampY(y: number): number;
-}
-
-/**
- * Internal time is always **UTC seconds** (integer). Feed adapters convert
- * broker formats (IST strings, epoch ms) to this at the edge; see ARCHITECTURE.md §4.0.
- */
-type UTCSeconds = number;
-/** A single OHLC(V) bar. `volume` is optional (not all feeds carry it). */
-interface Bar {
-    time: UTCSeconds;
-    open: number;
-    high: number;
-    low: number;
-    close: number;
-    volume?: number;
-}
-/** A single value point (for line/area/baseline series). */
-interface LinePoint {
-    time: UTCSeconds;
-    value: number;
-}
-/** A whitespace point: occupies a logical index for alignment but draws nothing. */
-interface Whitespace {
-    time: UTCSeconds;
-}
-/** Any item a series accepts: an OHLC bar, a value point, or a whitespace gap. */
-type SeriesDataItem = Bar | LinePoint | Whitespace;
-
-/**
- * Shared data layer (ARCHITECTURE.md §4.1). One per chart. Merges all series by
- * time onto a single logical-index space (0..N-1) so price + volume + indicator
- * panes stay aligned, and so non-trading gaps collapse (an absent time simply
- * has no logical index). Per-series rows are addressable by that shared index.
- */
-
-type SeriesId = number;
-interface IndexedBar {
-    index: number;
-    bar: Bar;
-}
-declare class DataLayer {
-    private readonly _series;
-    private _sortedTimes;
-    private readonly _indexByTime;
-    private _nextId;
-    /** Register a new series; returns its id. */
-    createSeries(): SeriesId;
-    removeSeries(id: SeriesId): void;
-    /**
-     * Bulk-load (full replace) one series' data, then re-merge the time axis.
-     * Input is sorted and de-duplicated by time (see {@link sortedUniqueByTime}).
-     */
-    setSeriesData(id: SeriesId, bars: readonly Bar[]): void;
-    /**
-     * Upsert bars into a series by time (used for history paging / backfill /
-     * out-of-order corrections — ARCHITECTURE.md §4.2). Existing times are
-     * replaced; new times are inserted; the result stays time-sorted.
-     *
-     * Prepending older bars shifts every existing logical index up by the
-     * inserted count — callers preserve the viewport by re-reading `baseIndex`
-     * (the invariant `rightEdge − index` is unchanged, so visible bars don't move).
-     */
-    addBars(id: SeriesId, bars: readonly Bar[]): void;
-    /**
-     * Apply a single live bar (ARCHITECTURE.md §4.2 hot path). Returns the kind of
-     * change so the chart auto-scrolls only on a genuine right-edge append:
-     * - `'append'`  → newer than the last bar (advances baseIndex)
-     * - `'replace'` → same time as the last bar (intra-bar tick) or an existing time
-     * - `'insert'`  → an older time inserted into history (late / out-of-order)
-     */
-    update(id: SeriesId, bar: Bar): 'append' | 'replace' | 'insert';
-    private _appendTime;
-    /** Number of logical indices (distinct time points across all series). */
-    get length(): number;
-    /** Logical index of the latest real bar (length - 1), or -1 if empty. */
-    get baseIndex(): number;
-    indexToTime(index: number): number | undefined;
-    timeToIndex(time: number): number | undefined;
-    /**
-     * Fractional logical index → UTC seconds, interpolating between bars and
-     * extrapolating past either edge at the nearest bar spacing.
-     *
-     * `indexToTime` only answers for indices that have a bar. Anything anchored to
-     * an arbitrary x — a drawing endpoint, a cursor readout, a projection to the
-     * right of the last bar — needs a time for positions *between* bars too, which
-     * the gapless axis (§5.3) makes common: everything a weekend or a session
-     * break collapsed away lands there. Returns NaN when there is no data.
-     */
-    indexToTimeFloat(index: number): number;
-    /** UTC seconds → fractional logical index. The inverse of `indexToTimeFloat`. */
-    timeToIndexFloat(time: number): number;
-    /**
-     * A series' bars, time-sorted, with no per-call allocation — the read path
-     * for anything that recomputes over full history (indicators, transforms).
-     * The array is live: treat it as read-only.
-     */
-    seriesBars(id: SeriesId): readonly Bar[];
-    /** All bars of a series paired with their shared logical index. */
-    indexedBars(id: SeriesId): IndexedBar[];
-    /**
-     * Bars of a series whose logical index lies within [fromIndex, toIndex].
-     * Binary-searches the (time-sorted) series into the visible time window instead
-     * of scanning all bars, so a full repaint costs O(log n + visible) per series,
-     * not O(total bars) - the hot path called for autoscale and drawing every frame.
-     */
-    visibleBars(id: SeriesId, fromIndex: number, toIndex: number): IndexedBar[];
-    /** The last bar of a series with its shared logical index, in O(1). */
-    lastIndexedBar(id: SeriesId): IndexedBar | null;
-    private _rebuild;
-}
-
-/**
- * Chart theme (palette). A single object drives chart chrome (background, grid,
- * axes, crosshair), series defaults (up/down, line, area gradient, last price),
- * and the trade layer (buy/sell, profit/loss). Renderers read theme colors when
- * a per-series style field is absent, so one theme restyles the whole chart.
- */
-interface ChartTheme {
-    background: string;
-    grid: string;
-    axisText: string;
-    axisLine: string;
-    crosshair: string;
-    /** Axis label font size in px (default 11). */
-    axisFontSize?: number;
-    /** Grid line dash style (default 'solid'). */
-    gridStyle?: 'solid' | 'dashed' | 'dotted';
-    /** Crosshair line dash style (default 'dashed'). */
-    crosshairStyle?: 'solid' | 'dashed' | 'dotted';
-    /** Crosshair line width in device px (default 1 = hairline). */
-    crosshairWidth?: number;
-    /** Background of the crosshair value tags (defaults to `crosshair`). */
-    crosshairLabelBackground?: string;
-    /** Show the crosshair price/time value tags (default true). */
-    crosshairLabelVisible?: boolean;
-    upColor: string;
-    downColor: string;
-    wickUpColor: string;
-    wickDownColor: string;
-    lineColor: string;
-    areaTopColor: string;
-    areaBottomColor: string;
-    baselineTopLine: string;
-    baselineTopFill: string;
-    baselineBottomLine: string;
-    baselineBottomFill: string;
-    lastPriceUp: string;
-    lastPriceDown: string;
-    lastPriceText: string;
-    buy: string;
-    sell: string;
-    profit: string;
-    loss: string;
-}
-
-/**
- * Primitive / plugin API (ARCHITECTURE.md §8). The extension point that keeps
- * the core small and powers markers, events, indicators, and the trade layer.
- * A primitive draws on a pane, optionally contributes to autoscale, and
- * optionally hit-tests for hover/drag.
- */
-
-type ZOrder = 'bottom' | 'normal' | 'top';
-interface PrimitiveRenderContext {
-    timeScale: TimeScale;
-    priceScale: PriceScale;
-    dataLayer: DataLayer;
-    plotWidth: number;
-    plotHeight: number;
-    priceAxisWidth: number;
-    dpr: number;
-    theme: ChartTheme;
-    /**
-     * The pane's primary price series, for a primitive that needs what price
-     * actually did rather than just the scales — a forecast scoring itself, say.
-     * Lazy, so nothing pays for it unless asked. Absent on synthetic contexts.
-     */
-    bars?: () => readonly Bar[];
-    /** externalId of the primitive hit under the pointer (hover state), if any. */
-    hoverId?: string | null;
-    /** externalId of the line being dragged (active state), if any. */
-    dragId?: string | null;
-}
-interface PrimitiveHit {
-    externalId: string;
-    zOrder: ZOrder;
-    /** Pixel distance from the cursor (smaller wins ties before z-order). */
-    distance: number;
-    cursor?: string;
-    /**
-     * Arm a drag on press. Price lines set `cursor: 'ns-resize'` and move on one
-     * axis; anything that moves on **both** (a drawing anchor, a whole shape)
-     * declares it here, and the drag callbacks receive time as well as price.
-     */
-    draggable?: boolean;
-}
-/** Injected when a primitive is attached; lets it request a repaint. */
-interface PrimitiveHost {
-    requestUpdate(): void;
-}
-interface IPrimitive {
-    /** Layer order vs series: 'bottom' (behind), 'normal' (over), 'top' (overlay). */
-    zOrder(): ZOrder;
-    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
-    /** Optional: expand the pane's autoscale range so this primitive isn't clipped. */
-    autoscaleInfo?(): {
-        min: number;
-        max: number;
-    } | null;
-    /** Optional: topmost hit under (x,y) in media px (relative to the pane plot). */
-    hitTest?(x: number, y: number, rc: PrimitiveRenderContext): PrimitiveHit | null;
-    attached?(host: PrimitiveHost): void;
-    detached?(): void;
-}
+import { PrimitiveRenderContext, IPrimitive, PrimitiveHost, ZOrder, PrimitiveHit, DataLayer } from 'openalgo-charts';
 
 /**
  * Drawing model (ARCHITECTURE.md §8). A drawing is **plain data** — anchors in
@@ -580,1489 +224,6 @@ declare class DrawingLayer implements IPrimitive {
     hitTest(x: number, y: number, rc: PrimitiveRenderContext): PrimitiveHit | null;
 }
 
-/**
- * Invalidation model (ARCHITECTURE.md §3.2).
- *
- * A single global level is too coarse for multi-pane indicators and trade
- * overlays, so the mask carries a **global level + a per-pane map + a queue of
- * time-scale operations**. Multiple invalidations within one frame coalesce via
- * {@link InvalidateMask.merge}.
- */
-/** How much of a pane (or the whole chart) must be repainted this frame. */
-declare const InvalidationLevel: {
-    /** Nothing to do. */
-    readonly None: 0;
-    /** Repaint only the top (overlay) canvas — crosshair, hover, dragging primitives. */
-    readonly Cursor: 1;
-    /** Repaint the base canvas at the current scales — series moved/changed, no rescale. */
-    readonly Light: 2;
-    /** Recompute scales/ticks then repaint everything. */
-    readonly Full: 3;
-};
-type InvalidationLevel = (typeof InvalidationLevel)[keyof typeof InvalidationLevel];
-/** Per-pane invalidation entry. `autoScale` requests a price-axis rescale. */
-interface PaneInvalidation {
-    level: InvalidationLevel;
-    autoScale: boolean;
-}
-/** Discrete operations applied to the shared time scale before painting. */
-type TimeScaleOp = {
-    type: 'fitContent';
-} | {
-    type: 'applyBarSpacing';
-    value: number;
-} | {
-    type: 'applyRightOffset';
-    value: number;
-} | {
-    type: 'reset';
-};
-declare class InvalidateMask {
-    private _globalLevel;
-    private readonly _panes;
-    private _timeScaleOps;
-    constructor(globalLevel?: InvalidationLevel);
-    get globalLevel(): InvalidationLevel;
-    /** Raise the chart-wide level (monotonic — only ever increases). */
-    invalidateGlobal(level: InvalidationLevel): void;
-    /** Raise a single pane's level without touching the others. */
-    invalidatePane(paneIndex: number, invalidation: PaneInvalidation): void;
-    paneInvalidation(paneIndex: number): PaneInvalidation | undefined;
-    panes(): ReadonlyMap<number, PaneInvalidation>;
-    addTimeScaleOp(op: TimeScaleOp): void;
-    timeScaleOps(): readonly TimeScaleOp[];
-    isEmpty(): boolean;
-    /** Fold another mask into this one (coalescing multiple invalidations per frame). */
-    merge(other: InvalidateMask): void;
-}
-
-/**
- * Frame scheduler (ARCHITECTURE.md §3.2). Coalesces many `requestFrame()` calls
- * within a single tick into one `onFrame` invocation. The rAF function is
- * injectable so the loop is deterministically testable without a browser.
- */
-type RafScheduler = (cb: () => void) => number;
-type RafCanceller = (handle: number) => void;
-
-/**
- * A single `<canvas>` element with media/bitmap sizing. Constructed only in a
- * browser; the size math above is the part exercised by unit tests.
- */
-declare class CanvasLayer {
-    readonly element: HTMLCanvasElement;
-    readonly ctx: CanvasRenderingContext2D;
-    private _mediaWidth;
-    private _mediaHeight;
-    private _dpr;
-    constructor(doc: Document, zIndex: number);
-    get mediaWidth(): number;
-    get mediaHeight(): number;
-    get pixelRatio(): number;
-    /** Resize backing buffer + CSS box. No-op if nothing changed. */
-    resize(mediaWidth: number, mediaHeight: number, dpr: number): void;
-    /** Clear the whole bitmap and reset the transform to bitmap (device-px) scope. */
-    clearBitmap(): void;
-}
-
-/**
- * Unified style bag for all Family-A series types (ARCHITECTURE.md §6A). Each
- * renderer reads the fields it needs; per-type defaults are filled by the
- * chart-type registry. Keeping one optional-field interface avoids a sprawling
- * discriminated union at the rendering boundary.
- */
-interface SeriesStyle {
-    upColor?: string;
-    downColor?: string;
-    borderUpColor?: string;
-    borderDownColor?: string;
-    wickUpColor?: string;
-    wickDownColor?: string;
-    borderVisible?: boolean;
-    wickVisible?: boolean;
-    hollow?: boolean;
-    /** Scale candle body width by volume / maxVisibleVolume (volume candles). */
-    volumeScaled?: boolean;
-    /** Whether the series is drawn and counted in autoscale. Default true. */
-    visible?: boolean;
-    /** Optional label carried with the series (for host-drawn legends). */
-    title?: string;
-    /** Show the dashed horizontal last-price line across the plot. Default true. */
-    priceLineVisible?: boolean;
-    /** Show the last-value tag on the price axis. Default true. */
-    lastValueVisible?: boolean;
-    color?: string;
-    lineWidth?: number;
-    /** Line dash style for line/step/area/HLC series. Default 'solid'. */
-    lineStyle?: 'solid' | 'dashed' | 'dotted';
-    step?: boolean;
-    markers?: boolean;
-    /** Draw only the markers, with no connecting line (Parabolic SAR, scatter). */
-    markersOnly?: boolean;
-    markerRadius?: number;
-    areaTopColor?: string;
-    areaBottomColor?: string;
-    baseValue?: number;
-    topColor?: string;
-    bottomColor?: string;
-    highColor?: string;
-    lowColor?: string;
-    closeColor?: string;
-    base?: number;
-    /**
-     * Fallback box size for stacking P&F X/O glyphs. Columns from
-     * `PointFigureTransform` carry their own `boxSize`, which wins — set this only
-     * for hand-built column data.
-     */
-    boxSize?: number;
-    /** Kagi thick (yang) line color. */
-    thickColor?: string;
-    /** Kagi thin (yin) line color. */
-    thinColor?: string;
-}
-
-/**
- * Chart-type registry (ARCHITECTURE.md §6A). Every series type registers a
- * descriptor: how to draw it and how it contributes to autoscale. The core
- * iterates descriptors, so adding a style is one registration — no core change.
- * Phase 5 fills the Family-A (time-indexed) types; Families B/C plug in later.
- */
-
-type SeriesType = 'candlestick' | 'hollow-candle' | 'volume-candle' | 'bar' | 'high-low' | 'line' | 'line-markers' | 'step' | 'area' | 'hlc-area' | 'baseline' | 'column' | 'histogram' | 'point-figure' | 'kagi';
-
-type MarkerShape = 'arrowUp' | 'arrowDown' | 'circle' | 'square' | 'triangleUp' | 'triangleDown' | 'diamond' | 'flag' | 'text';
-type MarkerPosition = 'aboveBar' | 'belowBar' | 'inBar' | 'atPrice';
-type MarkerSize = 'tiny' | 'small' | 'medium' | 'big';
-interface SeriesMarker {
-    time: number;
-    position: MarkerPosition;
-    price?: number;
-    shape: MarkerShape;
-    size: MarkerSize;
-    color: string;
-    text?: string;
-    id?: string;
-}
-declare class SeriesMarkers implements IPrimitive {
-    private readonly _seriesId;
-    private _markers;
-    private _host;
-    private _lastPositions;
-    constructor(seriesId: SeriesId);
-    attached(host: PrimitiveHost): void;
-    detached(): void;
-    zOrder(): ZOrder;
-    setMarkers(markers: readonly SeriesMarker[]): void;
-    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
-    hitTest(x: number, y: number): PrimitiveHit | null;
-}
-
-/**
- * Series records (ARCHITECTURE.md §4.3). A series references its rows in the
- * shared DataLayer by id, names a registered chart type, and carries a style
- * bag. The chart-type registry (§6A) supplies the renderer + autoscale extents,
- * so the core never switches on type.
- */
-
-/**
- * Which price axis a series maps to. 'right' (default) and 'left' each draw an
- * axis and autoscale independently; '' is a hidden overlay scale (no axis, its
- * own autoscale) used to pin a volume histogram inside the price pane.
- */
-type PriceScaleId = 'right' | 'left' | '';
-interface SeriesRecord {
-    dataId: SeriesId;
-    type: SeriesType;
-    style: SeriesStyle;
-    scaleId: PriceScaleId;
-}
-/** Public handle returned by `chart.addSeries(...)`. */
-interface SeriesApi {
-    /** Replace all data. Accepts OHLC bars, `{ time, value }` points, or `{ time }` gaps. */
-    setData(bars: readonly SeriesDataItem[]): void;
-    /** Merge older data (history paging); same item shapes as `setData`. */
-    prependData(bars: readonly SeriesDataItem[]): void;
-    /** Live update: update the last item or append. Same item shapes as `setData`. */
-    update(bar: SeriesDataItem): void;
-    /** Current bars for this series (sorted old -> new, normalized to OHLC). Handy for computing the next live update. */
-    getData(): Bar[];
-    /** Merge a partial style into the series and repaint (recolor, `{ visible:false }` to hide, ...). */
-    applyOptions(style: Partial<SeriesStyle>): void;
-    /** Remove the series from its pane and free its data rows. */
-    remove(): void;
-    /** The price scale this series maps to (call `.setOptions({ marginTop, marginBottom })` on it). */
-    priceScale(): PriceScale;
-    /** Create a markers layer (buy/sell signals, shapes) bound to this series. */
-    createMarkers(): SeriesMarkers;
-}
-
-/**
- * Axis label rendering (ARCHITECTURE.md §6, §5.3). Price axis (right strip) and
- * time axis (bottom strip). Time labels switch from clock to date at IST day
- * boundaries; gaps are already collapsed by the logical-index time scale.
- */
-
-/**
- * Boundary class of a time-axis label, passed to a custom `timeFormatter` as a
- * hint so a host can render adaptive labels (year at year boundaries, month at
- * month boundaries, day otherwise, clock intraday) — parity with common
- * `tickMarkFormatter(time, tickMarkType)` APIs.
- */
-type TickMarkType = 'year' | 'month' | 'day' | 'time' | 'timeWithSeconds';
-
-/**
- * A pane is one vertically-stacked drawing region (price pane, volume pane,
- * indicator pane). It owns a base + top canvas (ARCHITECTURE.md §3.1) and a
- * price scale, and renders its series against the shared time scale + DataLayer.
- */
-
-interface PaneRenderContext {
-    timeScale: TimeScale;
-    dataLayer: DataLayer;
-    dpr: number;
-    priceAxisWidth: number;
-    /** Left inset (px) reserved chart-wide for a left price axis; 0/absent when none. */
-    leftAxisWidth?: number;
-    timeAxisHeight: number;
-    /** Only the bottom pane draws the time axis. */
-    showTimeAxis: boolean;
-    /** Enable OHLC-preserving conflation when bars fall below ~0.5px (§4.4). */
-    conflate: boolean;
-    /** Conflation aggressiveness (1 = perf only; higher = more smoothing). */
-    conflationFactor: number;
-    /** Active palette — drives chrome, series defaults, and trade colors. */
-    theme: ChartTheme;
-    /** Draw the vertical (time) grid lines. */
-    showVertGrid: boolean;
-    /** Draw the horizontal (price) grid lines. */
-    showHorzGrid: boolean;
-    /** Optional custom time label formatter (UTC seconds -> string). Defaults to IST. */
-    timeFormatter?: (utcSeconds: number, tickMark?: TickMarkType) => string;
-    /** externalId of the primitive under the pointer (hover visual state). */
-    hoverId?: string | null;
-    /** externalId of the line currently being dragged (active visual state). */
-    dragId?: string | null;
-}
-declare class Pane {
-    readonly element: HTMLElement;
-    readonly base: CanvasLayer;
-    readonly top: CanvasLayer;
-    readonly priceScale: PriceScale;
-    /** Extra scales created on demand: left axis and a hidden overlay (volume). */
-    private _leftScale;
-    private _overlayScale;
-    /** Relative height weight within the chart (price=1, volume≈0.3). */
-    weight: number;
-    private readonly _series;
-    private readonly _primitives;
-    private _width;
-    private _height;
-    constructor(doc: Document);
-    addSeries(record: SeriesRecord): void;
-    /** The PriceScale for a scale id, creating the left/overlay scale on first use. */
-    private _scaleFor;
-    /** The price scale a series maps to (for the series handle's `priceScale()`). */
-    scaleOf(record: SeriesRecord): PriceScale;
-    /** True when a left-axis scale is active (some series maps to it). */
-    hasLeftScale(): boolean;
-    /** Remove a series record if present; returns true if it was found. */
-    removeSeries(record: SeriesRecord): boolean;
-    series(): readonly SeriesRecord[];
-    /** Primitives attached to this pane, in draw order. */
-    primitives(): readonly IPrimitive[];
-    addPrimitive(primitive: IPrimitive, host: PrimitiveHost): void;
-    /** Remove a primitive if present; returns true if it was found. */
-    removePrimitive(primitive: IPrimitive): boolean;
-    /** Detach every primitive (lifecycle cleanup) and remove the pane element. */
-    destroy(): void;
-    private _primitiveContext;
-    /** Topmost primitive hit at media-px (x,y) relative to this pane's plot. */
-    hitTestPrimitives(x: number, y: number, ctx: PaneRenderContext): PrimitiveHit | null;
-    resize(width: number, height: number, dpr: number): void;
-    /**
-     * Give every scale on this pane its plot height. Height is a *layout*
-     * property, but it used to be set only inside the autoscale pass — so any
-     * y↔price conversion before the first paint divided by zero and returned
-     * ±Infinity. Layout is when the height is actually known.
-     */
-    setScaleHeights(plotHeight: number): void;
-    private _layout;
-    /** Autoscale each active price scale from its own series (independent axes). */
-    autoscale(ctx: PaneRenderContext): void;
-    private _autoscaleScale;
-    /** Paint background + grid + series + axes on the base canvas. */
-    paintBase(ctx: PaneRenderContext): void;
-    /**
-     * Top (overlay) canvas: top-layer primitives + crosshair. Cheap repaint on
-     * cursor moves. `cross.x` is the shared plot x (vertical line, drawn in every
-     * pane for a global crosshair); `cross.yLocal` is the price-line y for the
-     * hovered pane only (null elsewhere); `cross.showTimeTag` draws the date tag
-     * on the bottom pane's axis strip.
-     */
-    paintTop(cross: {
-        x: number;
-        yLocal: number | null;
-        showTimeTag: boolean;
-    } | null, ctx: PaneRenderContext): void;
-    /** Price at a media-px y on this pane (for crosshair magnet). */
-    yToPrice(y: number): number;
-}
-
-/**
- * Indicator registry (ARCHITECTURE.md §6A, §8). The sibling of the chart-type
- * registry: that one answers *"how do I paint an array of bars"*, this one
- * answers *"what do I compute, what does it plot, and what can a user tune"*.
- *
- * A descriptor is data, not code-in-the-core — the chart never switches on an
- * indicator id. Each `plot` names a registered **chart type**, so indicators
- * ride the existing Family-A renderers and add no drawing code at all.
- *
- * The built-in descriptors live in the lazy `openalgo-charts/indicators` tier;
- * only the registry and the runtime ship in the base bundle, so an app that
- * plots its own maths pays nothing for the catalog.
- */
-
-type IndicatorSettings = Record<string, unknown>;
-/** `calc` output: one array per plot key, aligned 1:1 with the input bars. */
-type IndicatorValues = Record<string, readonly (number | null)[]>;
-
-/**
- * Horizontal price line primitive (ARCHITECTURE.md §8). The reusable base for
- * order/SL/TP/alert/indicator-level lines: a line across the plot plus a fixed
- * right-axis price tag and an optional broker-style segmented pill group on the
- * line — [badge][qty][label][✕] — with hover / dragging states (the chart
- * passes `hoverId`/`dragId` on the render context) and a drag ghost at the
- * pre-drag price via `setDragGhost`. Interaction semantics are unchanged from
- * the classic tag: the ✕ hit-tests as `${id}::close`, everything else drags.
- */
-
-interface PriceLineOptions {
-    price: number;
-    color: string;
-    lineWidth: number;
-    dashed: boolean;
-    /** Right-axis tag text. Defaults to the formatted price. */
-    label?: string;
-    /** Solid colored badge segment at the start of the pill group (e.g. 'BUY', 'TP', 'SL'). */
-    badge?: string;
-    /** Quantity segment rendered as a neutral box after the badge. */
-    qty?: string | number;
-    /** Info text segment (order type, price, P&L ...) — the classic left tag text. */
-    leftLabel?: string;
-    /**
-     * Fraction of the plot width the line spans, measured from the right (price)
-     * axis. 1 = full width (default); 0.3 = only the rightmost 30%, like a
-     * partial-width order line. The right-axis tag is always drawn.
-     */
-    extentFromRight?: number;
-    /** Draw a cancel (✕) segment at the end of the pill group; hit-tests as `${id}::close`. */
-    closeButton?: boolean;
-    /** Stable id returned by hit-test (for click/drag routing). */
-    id: string;
-    /** Cursor hint when hovered (e.g. 'ns-resize' for draggable lines). */
-    cursor?: string;
-}
-declare class PriceLine implements IPrimitive {
-    private _opts;
-    private _host;
-    private _ghostPrice;
-    /** Pill-group geometry from the last draw (media px) for hit-testing. */
-    private _group;
-    constructor(opts: PriceLineOptions);
-    attached(host: PrimitiveHost): void;
-    detached(): void;
-    get price(): number;
-    /** Move the line; schedules a repaint via the host. */
-    setPrice(price: number): void;
-    /** Update the info segment text (e.g. live position P&L); repaints. */
-    setLeftLabel(text: string): void;
-    /**
-     * Show a dimmed reference line at the pre-drag price while the user drags
-     * (pass the original price on drag start, null on drag end to clear).
-     */
-    setDragGhost(price: number | null): void;
-    options(): Readonly<PriceLineOptions>;
-    zOrder(): ZOrder;
-    autoscaleInfo(): {
-        min: number;
-        max: number;
-    } | null;
-    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
-    hitTest(x: number, y: number, rc: PrimitiveRenderContext): PrimitiveHit | null;
-}
-
-/**
- * Pane legend (ARCHITECTURE.md §8) — the TradingView-style row at the top-left
- * of a pane: a color swatch, the source's name, its parameters, the value under
- * the crosshair, and inline action buttons on the right.
- *
- * Drawn on the canvas rather than in the DOM, like `BuySellButtons` and
- * `DomLadder`, so it composites into screenshots and costs no DOM per pane.
- * Buttons hit-test as `${id}::close`, `${id}::hide`, and `${id}::settings`, so
- * the host routes them through the same `subscribeClick` path as order pills.
- *
- * Rows stack: several legends on one pane offset each other vertically, which
- * the host does by giving each a `row` index.
- */
-
-type PaneLegendAction = 'hide' | 'settings' | 'up' | 'down' | 'maximize' | 'close';
-/**
- * One reading on a legend row. Multi-plot sources show one per plot, each in
- * that plot's own color (an MA ribbon's four averages, MACD's three lines) —
- * a single string in a single color cannot say which number is which.
- */
-interface LegendValue {
-    /** Dimmed prefix, e.g. `O` / `H` / `Vol`. */
-    label?: string;
-    text: string;
-    /** Defaults to the row's `valueColor`, then `color`, then the theme text. */
-    color?: string;
-}
-interface PaneLegendOptions {
-    /** Stable id; buttons hit-test as `${id}::close` etc. */
-    id: string;
-    /** Bold source name, e.g. `RSI`. */
-    title: string;
-    /** Dimmed parameter summary after the title, e.g. `14 close`. */
-    params?: string;
-    /** Swatch color; omitted draws no swatch. */
-    color?: string;
-    /**
-     * Color for the live value. Defaults to `color`, then the theme's text — so a
-     * row can tint its reading (an up/down change) without being forced to show a
-     * swatch in that same color.
-     */
-    valueColor?: string;
-    /** Vertical slot on the pane (0 = topmost). */
-    row?: number;
-    /**
-     * Which inline action buttons to draw, left to right. Each hit-tests as
-     * `${id}::<action>`:
-     *  - `up` / `down` — move this pane one slot (`::up` / `::down`)
-     *  - `hide`        — toggle visibility (`::hide`)
-     *  - `maximize`    — expand this pane to fill the chart (`::maximize`)
-     *  - `close`       — remove the source, and its pane if it empties (`::close`)
-     *
-     * Defaults to `['up', 'down', 'hide', 'maximize', 'close']` for pane sources
-     * and `['hide', 'close']` for overlays (pass explicitly to override).
-     */
-    actions?: readonly PaneLegendAction[];
-    /** Rendered as hidden (dimmed, eye hollow). */
-    hidden?: boolean;
-    /** Rendered as maximized (the maximize glyph becomes restore). */
-    maximized?: boolean;
-    /** Text size in media px. Default 11. */
-    font?: number;
-    /** Left inset from the plot edge in media px. Default 8. */
-    left?: number;
-    /** Top inset in media px. Default 6. */
-    top?: number;
-}
-declare class PaneLegend implements IPrimitive {
-    private _opts;
-    private _host;
-    private _values;
-    /** Button geometry from the last draw, in media px, for hit-testing. */
-    private _buttons;
-    /** Right edge of the drawn row, in media px. */
-    private _width;
-    constructor(opts: PaneLegendOptions);
-    attached(host: PrimitiveHost): void;
-    detached(): void;
-    zOrder(): ZOrder;
-    autoscaleInfo(): null;
-    /** A single live reading after the params (typically crosshair-driven). */
-    setValue(text: string, color?: string): void;
-    /** One reading per plot, each in its own color. */
-    setValues(values: readonly LegendValue[]): void;
-    setOptions(patch: Partial<PaneLegendOptions>): void;
-    options(): PaneLegendOptions;
-    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
-    hitTest(x: number, y: number): PrimitiveHit | null;
-}
-
-/**
- * Indicator runtime (ARCHITECTURE.md §8). Turns an `IndicatorDescriptor` into
- * live chart objects: one series per plot, optional reference levels, an
- * optional fixed pane range — and recomputes them when the source data or the
- * settings change.
- *
- * It adds **no rendering code**. Every plot names a registered chart type, so
- * indicators draw through the same Family-A renderers as any other series.
- */
-
-/** Public handle returned by `chart.addIndicator(...)`. */
-interface IndicatorApi {
-    /** Unique instance id (several instances of one indicator can coexist). */
-    readonly id: string;
-    /** The descriptor id, e.g. `'macd'`. */
-    readonly indicatorId: string;
-    /** Display name. */
-    readonly name: string;
-    /** Pane the indicator drew into. */
-    readonly paneIndex: number;
-    /** Current settings (a copy). */
-    settings(): IndicatorSettings;
-    /** Merge a settings patch, recompute, and restyle. */
-    setSettings(patch: Readonly<IndicatorSettings>): void;
-    /** The series backing one plot key, for direct styling. */
-    series(plotKey: string): SeriesApi | undefined;
-    /** Latest computed values (a reference — do not mutate). */
-    values(): IndicatorValues;
-    /** Whether the plots are drawn (the legend's eye toggle). */
-    visible(): boolean;
-    /** Show or hide every plot without removing the instance. */
-    setVisible(on: boolean): void;
-    /** This indicator's legend row, or null if it has none. */
-    legend(): PaneLegend | null;
-    /** Refresh the legend readings for a bar index; omit for the latest bar. */
-    updateLegendValues(index?: number): void;
-    /** Remove every series, level, and legend row this indicator created. */
-    remove(): void;
-}
-
-/**
- * Serialisable chart state — the keystone the persistence-shaped features hang
- * off (saved layouts, templates, an objects panel, favourites, drawings).
- *
- * The rule that shapes this type: **the chart serialises what the chart owns.**
- * Series *data* is the application's — it knows the symbol, the timeframe, and
- * the feed — so `restoreState` never recreates series. It restores the things
- * the chart is the source of truth for (viewport, grid, panes, price scales,
- * indicators) and reports the series it saw so an app can rebuild them itself
- * and re-apply their styling.
- */
-
-interface PriceScaleState {
-    marginTop: number;
-    marginBottom: number;
-    minMove: number;
-    mode: PriceScaleMode;
-    inverted: boolean;
-    /** False when the user (or an indicator's fixed range) pinned the scale. */
-    autoScale: boolean;
-    /** The pinned range, present only when `autoScale` is false. */
-    range?: {
-        min: number;
-        max: number;
-    };
-}
-interface PaneState {
-    /** Relative height weight among panes. */
-    weight: number;
-    priceScale: PriceScaleState;
-}
-/** A series descriptor — enough to rebuild the shell, never the data. */
-interface SeriesState {
-    type: string;
-    style: SeriesStyle;
-    paneIndex: number;
-    priceScaleId: PriceScaleId;
-}
-interface IndicatorState {
-    indicatorId: string;
-    settings: IndicatorSettings;
-    paneIndex: number;
-}
-interface ChartState {
-    version: number;
-    /** Visible logical range at save time. */
-    viewport?: {
-        from: number;
-        to: number;
-    };
-    barSpacing?: number;
-    grid?: {
-        vertLines: boolean;
-        horzLines: boolean;
-    };
-    crosshairMode?: 'normal' | 'magnet';
-    panes?: PaneState[];
-    /** Informational: `restoreState` does not recreate these (it has no data). */
-    series?: SeriesState[];
-    indicators?: IndicatorState[];
-    /**
-     * Opaque slot the drawing tier fills. The base engine round-trips it
-     * untouched, so an app that persists state keeps drawings for free once the
-     * tier is loaded.
-     */
-    drawings?: unknown;
-}
-/** What `restoreState` actually applied, so a caller can finish the job. */
-interface RestoreReport {
-    /** True when the payload was a recognised, applicable state object. */
-    applied: boolean;
-    /** Series descriptors found in the state — the app rebuilds these itself. */
-    series: SeriesState[];
-    /** Indicator instances recreated. */
-    indicators: number;
-    /** Set when the payload was rejected. */
-    reason?: string;
-}
-
-/**
- * Crosshair state + magnet snapping (ARCHITECTURE.md §6). Pure helpers so the
- * snap logic is unit-testable; drawing lives in render/crosshair.ts.
- */
-
-type CrosshairMode = 'normal' | 'magnet';
-
-/**
- * Keyboard shortcuts (ARCHITECTURE.md §7). A small, framework-free shortcut
- * manager for the chart: a default keymap wired to real chart actions, combos
- * expressed as physical key codes (layout-independent), rebinding / disabling /
- * custom commands, an alternate preset, hover-vs-global scope, and optional
- * localStorage persistence. Pure and testable - `resolve(event)` and
- * `handleKey(combo)` map input to a command id without needing a real DOM.
- */
-type ShortcutScope = 'hover' | 'global';
-type ShortcutPreset = 'default' | 'alt';
-interface CustomShortcut {
-    command: string;
-    label?: string;
-    combos: string | string[];
-    onTrigger: () => void;
-}
-interface ShortcutManagerOptions {
-    preset?: ShortcutPreset;
-    /** Rebind (`string`/`string[]`) or unbind (`null`) a command, still listed. */
-    overrides?: Record<string, string | string[] | null>;
-    /** Commands to unbind entirely (still listed in `list()`). */
-    disabledCommands?: string[];
-    customShortcuts?: CustomShortcut[];
-    /** `hover` fires while the pointer is over the chart (or it is focused); `global` always. */
-    scope?: ShortcutScope;
-    /** Persist rebinds/preset to localStorage. */
-    persist?: boolean;
-    storageKey?: string;
-    /** Force platform (⌘ vs Ctrl). Auto-detected when omitted. */
-    isMac?: boolean;
-}
-interface ShortcutTriggerEvent {
-    command: string;
-    combo: string;
-    isCustom: boolean;
-}
-interface KeyLike {
-    code?: string;
-    key?: string;
-    ctrlKey?: boolean;
-    metaKey?: boolean;
-    altKey?: boolean;
-    shiftKey?: boolean;
-}
-interface ShortcutListItem {
-    command: string;
-    label: string;
-    combos: string[];
-    isCustom: boolean;
-    isDisabled: boolean;
-}
-declare class ShortcutManager {
-    scope: ShortcutScope;
-    private readonly _isMac;
-    private readonly _persist;
-    private readonly _storageKey;
-    private _preset;
-    private _overrides;
-    private _disabled;
-    private readonly _custom;
-    private _entries;
-    private _reverse;
-    private readonly _listeners;
-    constructor(options?: ShortcutManagerOptions);
-    private _presetCombos;
-    private _effectiveCombos;
-    private _rebuild;
-    /** Resolve a keyboard event to a command id (or null). */
-    resolve(event: KeyLike): string | null;
-    /** Resolve a combo string to a command id (or null). */
-    handleKey(combo: string): string | null;
-    /** Run a custom command's handler (built-ins are executed by the chart). */
-    runCustom(command: string): boolean;
-    emitTrigger(command: string, combo?: string): void;
-    on(cb: (e: ShortcutTriggerEvent) => void): () => void;
-    setBinding(command: string, combo: string | string[]): boolean;
-    disable(command: string): void;
-    resetBinding(command: string): void;
-    resetAll(): void;
-    setPreset(preset: ShortcutPreset): void;
-    addCustom(shortcut: CustomShortcut): void;
-    list(): ShortcutListItem[];
-    state(): {
-        preset: ShortcutPreset;
-        overrides: Record<string, string[]>;
-        disabled: string[];
-    };
-    private _after;
-    private _save;
-    private _load;
-    /** True when a key event targets a text field and should be ignored. */
-    static shouldIgnore(target: unknown): boolean;
-}
-
-/**
- * Trading visualization API (ARCHITECTURE.md §9). A data-driven layer on top of
- * the chart: your app pushes exchange state (positions, orders, trades) and the
- * chart renders labelled price-line "pills" (with a cancel/close button and
- * drag-to-modify) plus trade-fill markers; user interaction is relayed back as
- * `trading:*` events for the app to send to the exchange. Original,
- * framework-free API.
- */
-
-type PositionSide = 'long' | 'short';
-type TradingOrderSide = 'buy' | 'sell';
-type TradingOrderType = 'limit' | 'stop' | 'stop_limit';
-type TradeMarkerVariant = 'chevron' | 'bubble' | 'count';
-type TradingLineVariant = 'standard' | 'line-only';
-type TradingLineStyle = 'solid' | 'dashed' | 'dotted';
-interface TradingPosition {
-    id: string;
-    side: PositionSide;
-    entryPrice: number;
-    size: number;
-    pnlText?: string;
-    pnlPercent?: string;
-    color?: string;
-    readOnly?: boolean;
-    variant?: TradingLineVariant;
-}
-interface TradingOrder {
-    id: string;
-    type: TradingOrderType;
-    side: TradingOrderSide;
-    price: number;
-    size: number;
-    parentId?: string;
-    bracketRole?: 'tp' | 'sl';
-    color?: string;
-    lineStyle?: TradingLineStyle;
-    lineWidth?: number;
-    readOnly?: boolean;
-    draggable?: boolean;
-    variant?: TradingLineVariant;
-}
-interface TradingTrade {
-    id: string;
-    side: TradingOrderSide;
-    price: number;
-    size: number;
-    /** Execution time in milliseconds. */
-    timestamp: number;
-    variant?: TradeMarkerVariant;
-    color?: string;
-    label?: string;
-}
-interface TradingSyncPayload {
-    positions?: TradingPosition[];
-    orders?: TradingOrder[];
-    trades?: TradingTrade[];
-}
-interface TradingColors {
-    long: string;
-    short: string;
-    order: string;
-    tp: string;
-    sl: string;
-    buy: string;
-    sell: string;
-}
-interface TradingSettings {
-    longColor?: string;
-    shortColor?: string;
-    orderColor?: string;
-    tpColor?: string;
-    slColor?: string;
-    buyColor?: string;
-    sellColor?: string;
-}
-/** What the controller needs from the chart (the Chart implements this). */
-interface TradingHost {
-    addPrimitive(p: IPrimitive): void;
-    removePrimitive(p: IPrimitive): void;
-    subscribeClick(cb: (externalId: string) => void): void;
-    subscribeDrag(onDrag: (externalId: string, price: number) => void, onDragEnd?: (externalId: string, price: number) => void): void;
-    /** Optional: route trading events onto the chart's unified `chart.on(...)` bus. */
-    emit?(event: string, payload: unknown): void;
-}
-declare class TradingController {
-    private readonly _host;
-    private readonly _positions;
-    private readonly _orders;
-    private readonly _trades;
-    private readonly _listeners;
-    private readonly _dragPrev;
-    private _colors;
-    private _markers;
-    constructor(host: TradingHost);
-    on(event: string, cb: (payload: unknown) => void): () => void;
-    off(event: string, cb: (payload: unknown) => void): void;
-    private _emit;
-    setSettings(settings: TradingSettings): void;
-    getSettings(): TradingColors;
-    setPositions(positions: readonly TradingPosition[]): void;
-    setOrders(orders: readonly TradingOrder[]): void;
-    setTrades(trades: readonly TradingTrade[]): void;
-    addTrade(trade: TradingTrade): void;
-    upsertOrder(order: TradingOrder): void;
-    removeOrder(id: string): void;
-    syncState(payload: TradingSyncPayload): void;
-    updatePositionPnl(id: string, unrealizedPnl: number, pnlText?: string, pnlPercent?: string): void;
-    getPositions(): TradingPosition[];
-    getOrders(): TradingOrder[];
-    getTrades(): TradingTrade[];
-    clear(): void;
-    private _renderTrades;
-    private _sync;
-    private _sig;
-    /** Info segment for a position: live P&L text (side/size live in badge/qty). */
-    private _positionPill;
-    private _positionOpts;
-    private _orderOpts;
-    private _onClick;
-    private _onDrag;
-    private _onDragEnd;
-}
-
-/**
- * Event markers (ARCHITECTURE.md §8.2): Earnings / Dividend / Split badges in a
- * strip near the bottom of the plot. Time-anchored only (no price). Hover/click
- * carry an external id for tooltip wiring. Data source is an integration concern
- * (OpenAlgo has no corporate-actions calendar) — the renderer ships regardless.
- */
-
-interface ChartEvent {
-    time: number;
-    type: 'earnings' | 'dividend' | 'split' | 'news' | string;
-    label: string;
-    color?: string;
-    id?: string;
-}
-declare class EventMarkers implements IPrimitive {
-    private _events;
-    private _host;
-    private _positions;
-    attached(host: PrimitiveHost): void;
-    detached(): void;
-    zOrder(): ZOrder;
-    setEvents(events: readonly ChartEvent[]): void;
-    draw(ctx: CanvasRenderingContext2D, rc: PrimitiveRenderContext): void;
-    hitTest(x: number, y: number): PrimitiveHit | null;
-}
-
-/**
- * Time navigator (ARCHITECTURE.md §8) — the hover-revealed zoom / step controls
- * that sit just above the time axis: `−` `+` to zoom, `‹` `›` to step one bar.
- *
- * Invisible until the pointer nears the bottom of the chart, so a clean chart
- * stays clean. It fades in and out rather than snapping, which is what keeps it
- * from reading as a glitch when the cursor crosses the reveal band.
- *
- * Reveal is driven by an explicit `setPointer` from the chart, **not** by
- * `rc.hoverId`. Hover ids come from `bestHit`, which picks the nearest primitive
- * — so a drawing or an order line near the bottom of the chart would win the
- * hit and silently hide the controls. Pointer position is the honest input here;
- * hit-testing still owns the buttons themselves.
- */
-
-/** Command each button runs. These are `Chart` shortcut command ids. */
-type TimeNavigatorAction = 'zoomOut' | 'zoomIn' | 'panLeftBar' | 'panRightBar';
-interface TimeNavigatorOptions {
-    /** Prefix for hit ids. Lets a host run more than one. */
-    id: string;
-    /** Buttons, left to right. A `null` inserts a gap between groups. */
-    buttons: readonly (TimeNavigatorAction | null)[];
-    /** Button box size in media px. */
-    size: number;
-    /** Gap between buttons, and the wider gap a `null` produces. */
-    gap: number;
-    groupGap: number;
-    /** Distance from the bottom of the plot to the bottom of the buttons. */
-    bottomMargin: number;
-    /**
-     * Height of the reveal band above the plot bottom. The pointer anywhere in
-     * this band brings the controls in.
-     */
-    revealHeight: number;
-    /** Seconds the fade takes. 0 disables the animation. */
-    fadeSeconds: number;
-    /** Tooltip label per action. */
-    labels: Record<TimeNavigatorAction, string>;
-    /** Optional keyboard hint shown next to the label, e.g. `"Ctrl + −"`. */
-    hints: Partial<Record<TimeNavigatorAction, string>>;
-    /** Show the tooltip above the hovered button. */
-    showTooltip: boolean;
-    font: number;
-    radius: number;
-    zOrder: ZOrder;
-}
-
-/**
- * Top-level chart orchestrator (ARCHITECTURE.md §3.3). Owns the shared
- * DataLayer + time scale, the panes, the invalidate mask, and the render loop.
- * Phase 2 renders static candlesticks with price/time axes; pan/zoom (Phase 3)
- * and live data (Phase 4) build on this.
- */
-
-interface ChartOptions {
-    document?: Document;
-    pixelRatio?: () => number;
-    raf?: {
-        schedule: RafScheduler;
-        cancel?: RafCanceller;
-    };
-    /** Full palette; pass `darkTheme` (default), `lightTheme`, or a custom ChartTheme. */
-    theme?: ChartTheme;
-    priceAxisWidth?: number;
-    timeAxisHeight?: number;
-    /**
-     * Crosshair behaviour. 'normal' (default) — the cross follows the pointer
-     * exactly. 'magnet' — the horizontal line snaps to the nearest O/H/L/C of the
-     * bar under the cursor (price pane only).
-     */
-    crosshairMode?: CrosshairMode;
-    /** Time source for kinetic animation (defaults to performance.now). */
-    now?: () => number;
-    /** Enable OHLC-preserving conflation when zoomed out (§4.4). Default false. */
-    conflate?: boolean;
-    /** Conflation aggressiveness (default 1). */
-    conflationFactor?: number;
-    /** Grid line visibility. Both default to true. */
-    grid?: {
-        vertLines?: boolean;
-        horzLines?: boolean;
-    };
-    /** Accessible label for the chart container (screen readers). */
-    ariaLabel?: string;
-    /**
-     * Keyboard shortcuts. Pass a configured `ShortcutManager`, options to build
-     * one, or `false` to disable keyboard control. Defaults to the built-in keymap.
-     */
-    shortcuts?: ShortcutManager | Partial<ShortcutManagerOptions> | false;
-    /**
-     * Custom price formatter for every pane's axis tick labels, the last-price
-     * tag, and price-line labels. e.g. `(p) => '$' + p.toFixed(2)`. When omitted,
-     * a tick-size-aware `toFixed` is used. Change it later via `setPriceFormatter`.
-     */
-    priceFormatter?: (price: number) => string;
-    /**
-     * Default price-scale options applied to every pane (tick size `minMove`,
-     * `mode: 'linear' | 'logarithmic'`, `inverted`, and top/bottom margins).
-     * Tune a single pane later via `chart.panes()[n].priceScale.setOptions(...)`.
-     */
-    priceScale?: Partial<PriceScaleOptions>;
-    /**
-     * Custom time-axis and crosshair label formatter (receives UTC seconds). When
-     * omitted, labels use IST (Indian market default). e.g. for UTC:
-     * `(s) => new Date(s * 1000).toISOString().slice(11, 16)`.
-     */
-    timeFormatter?: (utcSeconds: number, tickMark?: TickMarkType) => string;
-    /**
-     * Hover-revealed zoom / step controls above the time axis (TradingView-style).
-     * `true` by default — they stay invisible until the pointer nears the bottom
-     * of the chart. Pass `false` to drop them, or an options object to restyle.
-     */
-    timeNavigator?: boolean | Partial<TimeNavigatorOptions>;
-}
-interface AddSeriesOptions {
-    /** Target pane index (0 = price). Higher panes are created on demand. */
-    paneIndex?: number;
-    /** Style overrides merged onto the chart type's defaults. */
-    style?: SeriesStyle;
-    /**
-     * Which price axis this series maps to. 'right' (default) and 'left' each draw
-     * an axis and autoscale independently; '' is a hidden overlay scale (no axis)
-     * for a volume histogram inside the price pane.
-     */
-    priceScaleId?: PriceScaleId;
-    /**
-     * Value formatting applied to this series' price scale (axis + crosshair tag):
-     * `price` (tick-size precision), `volume` (compact 1.2K / 3.4M / 5.6B), or a
-     * `custom` formatter (currency, percent, ...).
-     */
-    priceFormat?: {
-        type: 'price';
-        precision?: number;
-        minMove?: number;
-    } | {
-        type: 'volume';
-    } | {
-        type: 'custom';
-        formatter: (value: number) => string;
-    };
-}
-/**
- * Emitted on every crosshair move (and `null` fields on pointer-leave) so a host
- * can render an OHLC legend / tooltip. `bar` is the hovered bar of the primary
- * price series; `point` is container-relative media px for positioning a
- * floating tooltip. See `subscribeCrosshairMove`.
- */
-interface CrosshairMoveEvent {
-    /** UTC seconds of the hovered bar, or null when off the data / pointer left. */
-    time: number | null;
-    /** Logical index under the cursor, or null. */
-    index: number | null;
-    /** Price under the cursor on the hovered pane, or null. */
-    price: number | null;
-    /** Hovered bar of the primary (first) price series, or null. */
-    bar: Bar | null;
-    /** Cursor position in container media px, or null on leave. */
-    point: {
-        x: number;
-        y: number;
-    } | null;
-    /** Pane under the cursor, or null on leave. */
-    paneIndex?: number | null;
-}
-declare class Chart {
-    private readonly _container;
-    private readonly _doc;
-    private readonly _pixelRatio;
-    private _theme;
-    private readonly _panes;
-    private readonly _loop;
-    private readonly _dataLayer;
-    private readonly _timeScale;
-    private readonly _priceAxisWidth;
-    private readonly _timeAxisHeight;
-    private _pending;
-    private _resizeObserver;
-    private _width;
-    private _height;
-    private _hasFitContent;
-    private _crosshairMode;
-    private _shortcuts;
-    private _trading;
-    private _pointerInside;
-    private _keyTarget;
-    private readonly _now;
-    private readonly _conflate;
-    private readonly _conflationFactor;
-    private _gridVert;
-    private _gridHorz;
-    private _cursorPane;
-    private _cursor;
-    private _dragging;
-    private _dragStartX;
-    private _dragStartY;
-    private _lastDragY;
-    private readonly _pointers;
-    private _pinch;
-    private _pinchPane;
-    private _liveRegion;
-    private _dragStartOffset;
-    private _lastDragX;
-    private _lastDragT;
-    private _dragVelocity;
-    private _kineticHandle;
-    private readonly _firstDataId;
-    private readonly _indicators;
-    /** Guards indicator recompute against re-entry via its own `series.setData`. */
-    private _recomputing;
-    /** Opaque drawing-tier payload, round-tripped through get/restoreState. */
-    private _drawingState;
-    /** Pane currently maximized, and the weights to restore when it un-maximizes. */
-    private _maximizedPane;
-    private _savedWeights;
-    /** Legend rows per pane, so new ones stack below existing ones. */
-    private readonly _legends;
-    /** Pane holding the primary price series (only this pane gets magnet snapping). */
-    private _firstPaneIndex;
-    private _historyLoader;
-    private _loadingHistory;
-    private _clickCb;
-    private _crosshairCb;
-    private _pointerMoved;
-    /** While true, pointer gestures place anchors instead of panning. */
-    private _placementMode;
-    private _downPane;
-    private _downX;
-    private _downLocalY;
-    private _dragId;
-    private _hoverId;
-    private _overlayFrozen;
-    private _dragCb;
-    private _dragEndCb;
-    private _axisDrag;
-    /** Active pane-divider drag: which boundary, and the weights/heights at grab time. */
-    /** True once a primitive drag has actually moved — see the pointerup note. */
-    private _dragMoved;
-    /** Where the drag was grabbed, in data space, so deltas start at the press. */
-    private _dragFrom;
-    private _paneResize;
-    private _axisStartCoord;
-    private _axisStartMin;
-    private _axisStartMax;
-    private _axisStartSpacing;
-    private _priceFormatter;
-    private _priceScaleOptions;
-    private _timeFormatter;
-    private _leftAxisWidth;
-    private _timeNav;
-    /** Pane the navigator is currently attached to, so it can follow the bottom. */
-    private _timeNavPane;
-    constructor(container: HTMLElement, options?: ChartOptions);
-    /** Register a callback fired when the user pans near the left (oldest) edge. */
-    setHistoryLoader(loader: () => void): void;
-    /** Call after a history-paging load resolves to re-enable the trigger. */
-    historyLoadComplete(): void;
-    get dataLayer(): DataLayer;
-    get timeScale(): TimeScale;
-    /** Restore a saved logical range (e.g. preserve the user's zoom across a data reload). */
-    setVisibleLogicalRange(range: LogicalRange): void;
-    /** The current visible logical range. */
-    getVisibleLogicalRange(): LogicalRange;
-    /** Fit all bars into view (no-arg convenience; bar count from the data). */
-    fitContent(): void;
-    /** The keyboard shortcut manager (null when shortcuts are disabled). */
-    get shortcuts(): ShortcutManager | null;
-    /**
-     * The data-driven trading layer: push positions/orders/trades and the chart
-     * renders pills + markers, emitting `trading:*` events on interaction. Created
-     * on first access.
-     */
-    get trading(): TradingController;
-    /** Add a series and return its data handle. */
-    addSeries(type: SeriesType, options?: AddSeriesOptions): SeriesApi;
-    /**
-     * `claimPrimary` is false for series the chart creates on a caller's behalf
-     * (indicator plots), so an indicator's line never becomes the price series
-     * that drives the magnet crosshair and the OHLC legend.
-     */
-    private _createSeries;
-    /** Add a horizontal price line (order/SL/TP/alert/level) to a pane. */
-    addPriceLine(opts: PriceLineOptions, paneIndex?: number): PriceLine;
-    /** Add an earnings/dividend/split event-marker strip to a pane. */
-    addEventMarkers(paneIndex?: number): EventMarkers;
-    /**
-     * Add a registered indicator. Built-in descriptors live in the lazy
-     * `openalgo-charts/indicators` tier — import it (or register your own with
-     * `registerIndicator`) before calling this.
-     *
-     * `'onchart'` indicators overlay the price pane; `'pane'` indicators get a new
-     * pane of their own unless `paneIndex` says otherwise. The returned handle
-     * recomputes automatically whenever the source data changes.
-     *
-     * ```ts
-     * import 'openalgo-charts/indicators';
-     * const macd = chart.addIndicator('macd', { fastPeriod: 8 });
-     * macd.setSettings({ fastPeriod: 12 });
-     * macd.remove();
-     * ```
-     */
-    addIndicator(indicatorId: string, settings?: Readonly<IndicatorSettings>, options?: {
-        paneIndex?: number;
-    }): IndicatorApi;
-    /** Every live indicator instance, in the order they were added. */
-    indicators(): readonly IndicatorApi[];
-    /** Remove one indicator instance by its handle id. Returns true if it existed. */
-    removeIndicator(instanceId: string): boolean;
-    private _indicatorHost;
-    /**
-     * Recompute every indicator after a source-data change. Reentrant-guarded:
-     * an indicator writes its plots with `series.setData`, which re-enters the
-     * same data-mutation path that called us.
-     */
-    private _recomputeIndicators;
-    /** Subscribe to clicks on hit-testable primitives (markers, events, lines). */
-    subscribeClick(cb: (externalId: string) => void): void;
-    /**
-     * Subscribe to crosshair movement for an OHLC legend / tooltip. The callback
-     * fires with the hovered bar of the primary price series on every move, and
-     * with all-null fields when the pointer leaves the plot.
-     */
-    subscribeCrosshairMove(cb: (e: CrosshairMoveEvent) => void): void;
-    /**
-     * Subscribe to drags of draggable primitives (order / SL / TP lines, drawing
-     * handles). Fires per move and on release.
-     *
-     * `time` is the UTC seconds under the cursor, interpolated between bars and
-     * extrapolated past the right edge — so a two-axis drag (a trendline endpoint,
-     * a projection) has a usable time even where the gapless axis has no bar.
-     * Price-only consumers can simply ignore it.
-     */
-    subscribeDrag(onDrag: (externalId: string, price: number, time: number) => void, onDragEnd?: (externalId: string, price: number, time: number) => void): void;
-    /**
-     * Guarantee a pane's price scale has a real range before converting y↔price.
-     * Autoscaling normally happens during paint, so every coordinate API — and
-     * the price carried by click/drag events — used to answer with the default
-     * 0..1 (or ±Infinity) until the first frame had run. Callers cannot be asked
-     * to wait for a paint, so scale on demand.
-     */
-    private _ensureScaled;
-    /** Container-relative x (media px) → UTC seconds on the (gapless) time axis. */
-    private _xToTime;
-    /** UTC seconds → container-relative x (media px). The inverse of `_xToTime`. */
-    timeToCoordinate(time: number): number;
-    /** Container-relative x (media px) → UTC seconds. */
-    coordinateToTime(x: number): number;
-    private readonly _listeners;
-    /** Subscribe to a named chart event. Returns an unsubscribe function. */
-    on(event: string, cb: (payload: unknown) => void): () => void;
-    /** Subscribe to the next occurrence of an event, then auto-unsubscribe. */
-    once(event: string, cb: (payload: unknown) => void): () => void;
-    /** Remove one listener, or (when `cb` is omitted) every listener for an event. */
-    off(event: string, cb?: (payload: unknown) => void): void;
-    /** Dispatch a named event. Public so the lazy trade layer can route through it. */
-    emit(event: string, payload: unknown): void;
-    /** Emit a viewport event ('pan' | 'zoom') carrying the visible time + logical range. */
-    private _emitViewport;
-    /** Public: attach any primitive (indicators, profiles, custom overlays) to a pane. */
-    addPrimitive(primitive: IPrimitive, paneIndex?: number): void;
-    /**
-     * Map a price to a container-relative Y in media (CSS) px, for positioning DOM
-     * overlays (order panels, tooltips) over a pane. Returns null if the pane
-     * doesn't exist. The inverse is `coordinateToPrice`.
-     */
-    priceToCoordinate(price: number, paneIndex?: number): number | null;
-    /** Map a container-relative media-px Y back to a price on a pane (inverse of priceToCoordinate). */
-    coordinateToPrice(y: number, paneIndex?: number): number | null;
-    /**
-     * Toggle the vertical (time) and/or horizontal (price) grid lines at runtime.
-     * Omitted fields keep their current visibility. Repaints every pane.
-     */
-    setGridOptions(opts: {
-        vertLines?: boolean;
-        horzLines?: boolean;
-    }): void;
-    /** Current grid line visibility. */
-    gridOptions(): {
-        vertLines: boolean;
-        horzLines: boolean;
-    };
-    /**
-     * Flatten every pane's base + overlay canvas into one opaque canvas (device
-     * px). The chart renders as stacked layered canvases, so the browser's native
-     * right-click "Save image" only captures the layer under the pointer (usually
-     * the transparent crosshair overlay) — use this to export the full chart.
-     */
-    takeScreenshot(): HTMLCanvasElement;
-    private _addPrimitive;
-    /** Remove a primitive from whichever pane holds it. */
-    removePrimitive(primitive: IPrimitive): void;
-    /**
-     * Renumber legend rows per pane in insertion order, so removing one closes
-     * the gap instead of leaving a hole where it used to sit.
-     */
-    private _restackLegends;
-    /** A host for the (lazy-loaded) trade layer to attach/detach its primitives on a pane. */
-    tradeHost(paneIndex?: number): {
-        addPrimitive(p: IPrimitive): void;
-        removePrimitive(p: IPrimitive): void;
-    };
-    /** Apply one live bar; auto-scroll only on a genuine right-edge append. */
-    private _updateBar;
-    private _ensurePane;
-    private _setData;
-    /** History paging: merge older bars, preserving the viewport (§4.2). */
-    private _prependData;
-    private _addPane;
-    /**
-     * Set a custom price formatter for every pane's axis labels, last-price tag,
-     * and price-line labels at runtime (e.g. switch to a currency format). Pass
-     * null to restore the default tick-size-aware formatting.
-     */
-    setPriceFormatter(fn: ((price: number) => string) | null): void;
-    /**
-     * Set a custom time-axis + crosshair label formatter (UTC seconds -> string)
-     * at runtime. Pass undefined to restore the IST default.
-     */
-    setTimeFormatter(fn: ((utcSeconds: number, tickMark?: TickMarkType) => string) | undefined): void;
-    /**
-     * Turn pointer gestures into anchor placement instead of panning. A host arms
-     * this while a drawing tool is active: a press no longer scrolls the chart, and
-     * a press-drag-release is reported as two `click` events (press point, then
-     * release point, the latter tagged `viaDrag`) so a two-point shape can be drawn
-     * in one gesture. `DrawingController` drives this for you.
-     */
-    setPlacementMode(active: boolean): void;
-    /** Swap the palette at runtime (dark/light toggle) without recreating the chart. */
-    setTheme(theme: ChartTheme): void;
-    /**
-     * Apply a subset of chart options at runtime (theme, grid, formatters,
-     * crosshair mode) without recreating the chart.
-     */
-    applyOptions(opts: {
-        theme?: ChartTheme;
-        grid?: {
-            vertLines?: boolean;
-            horzLines?: boolean;
-        };
-        priceFormatter?: ((price: number) => string) | null;
-        timeFormatter?: ((utcSeconds: number, tickMark?: TickMarkType) => string) | undefined;
-        crosshairMode?: CrosshairMode;
-    }): void;
-    panes(): readonly Pane[];
-    /**
-     * Capture the chart's serialisable state: viewport, grid, crosshair mode,
-     * pane weights and price scales, indicator instances, and a `drawings` slot
-     * the drawing tier fills. JSON-safe.
-     *
-     * Series **data** is not captured — the app owns that (it knows the symbol,
-     * the timeframe, and the feed). Series *descriptors* are, so an app that
-     * rebuilds its own series can re-apply their styling and placement.
-     */
-    getState(): ChartState;
-    /**
-     * Re-apply a state captured by `getState`. Restores grid, crosshair mode,
-     * pane weights and price scales, indicators, and the viewport — everything
-     * the chart is the source of truth for.
-     *
-     * It does **not** recreate series: the chart has no way to know their data.
-     * The returned report lists the series descriptors it saw so the caller can
-     * rebuild them (`addSeries(s.type, { paneIndex: s.paneIndex, style: s.style })`)
-     * and then feed them.
-     *
-     * Restore the viewport *after* your data lands — logical ranges index bars, so
-     * a range applied to an empty chart means nothing. Call `restoreState` again
-     * (or `setVisibleLogicalRange`) once the series are populated.
-     */
-    restoreState(state: unknown): RestoreReport;
-    /**
-     * The opaque `drawings` slot in the chart state. The base engine only
-     * round-trips it; the drawing tier reads and writes it.
-     */
-    drawingState(): unknown;
-    setDrawingState(value: unknown): void;
-    invalidate(build: (mask: InvalidateMask) => void): void;
-    applySize(width: number, height: number): void;
-    /** Distribute height across panes by weight; sync the shared time-scale width. */
-    private _relayout;
-    /** Reserve a chart-wide left-axis column when any pane has a left price scale. */
-    private _recomputeLeftAxis;
-    private _weightTotal;
-    /** Grab tolerance around a pane boundary, in media px. */
-    private static readonly DIVIDER_GRAB;
-    /**
-     * Index of the pane whose *bottom* boundary is within grab range of `y`, or
-     * null. Boundary `i` separates pane `i` from pane `i + 1`; the last pane's
-     * bottom is the chart edge and is not draggable.
-     */
-    private _dividerAt;
-    /**
-     * Set a pane's relative height weight. Panes share the chart height in
-     * proportion to their weights, so only the ratio matters.
-     */
-    setPaneWeight(index: number, weight: number): void;
-    paneWeight(index: number): number;
-    /**
-     * Remove a pane, everything drawn in it, and any indicator that lives there.
-     * Pane 0 (price) is never removable — removing it would leave the chart with
-     * no time axis owner.
-     *
-     * Returns false when the index is out of range or is pane 0.
-     */
-    removePane(index: number): boolean;
-    /**
-     * Move a pane up or down one slot. Pane 0 (price) is pinned — it owns the
-     * primary series and the shared price context — so a move that would displace
-     * it is refused.
-     */
-    movePane(index: number, direction: -1 | 1): boolean;
-    /**
-     * Expand one pane to fill the chart, collapsing the others to a sliver.
-     * Calling it again (or on another pane) restores the previous weights.
-     */
-    maximizePane(index: number): boolean;
-    /** The maximized pane index, or null when none is. */
-    maximizedPane(): number | null;
-    /**
-     * Route a pane-legend button press. Ids look like `indicator:<instanceId>::close`.
-     * Returns true when the id was ours and was handled.
-     */
-    private _handleLegendAction;
-    /** Cumulative top + height of each pane, by weight (the source of truth for hit-testing). */
-    private _paneLayout;
-    /**
-     * Keyboard hints for the navigator tooltips, read from the live keymap so a
-     * rebind shows up in the tooltip instead of a stale hardcoded string. The
-     * one-bar step buttons have no default binding, so they get no hint.
-     */
-    private _navHints;
-    /**
-     * Keep the navigator on the bottom pane — it belongs just above the time
-     * axis, and adding or removing a pane moves which one that is.
-     */
-    private _syncTimeNavPane;
-    /**
-     * Push the pointer to the navigator and keep painting while it fades, so the
-     * animation runs even when nothing else on the chart is changing.
-     */
-    private _feedTimeNav;
-    private _renderContext;
-    private _observeSize;
-    private _onFrame;
-    private _attachInput;
-    private readonly _onPointerEnter;
-    /**
-     * The chart renders as stacked canvases, so the browser's right-click
-     * "Save image as…" would capture only the topmost (transparent overlay)
-     * layer — a blank image. Just before the native menu opens, composite the
-     * clicked pane's base layer *beneath* its overlay bitmap so the saved image
-     * is the visible chart, and freeze overlay repaints (live ticks repaint every
-     * few hundred ms and would wipe the snapshot while the menu is open). The
-     * freeze lifts on the next pointer/wheel/key input after the menu closes.
-     * Apps that present their own menu (preventDefault on contextmenu) are
-     * unaffected. Multi-pane note: the native save captures the clicked pane
-     * only — use `downloadScreenshot()` for the full multi-pane composite.
-     */
-    private readonly _onContextMenu;
-    /** Resume overlay repaints after the native context menu closes. */
-    private _unfreezeOverlay;
-    private _localPoint;
-    private readonly _onPointerDown;
-    private readonly _onPointerMove;
-    private readonly _onPointerUp;
-    /**
-     * DOM pointerup entry point. Mirrors the primary-button guard in
-     * `_onPointerDown`: a right-click (or any non-primary mouse button) fires
-     * pointerdown *and* pointerup, but `_onPointerDown` ignores it — so the
-     * down state (`_downX`/`_downLocalY`/`_downPane`/`_pointerMoved`) is never
-     * refreshed and still holds the *previous* left-click. Letting a non-primary
-     * pointerup through would re-run the click branch against that stale position
-     * and replay the last click (e.g. re-firing a Buy/Sell button → a phantom
-     * order). Touch/pen are unaffected (they contact with button 0). The internal
-     * recovery call from `_onPointerMove` invokes `_onPointerUp` directly, so it
-     * bypasses this filter and still ends a drag when a button release is missed.
-     */
-    private readonly _onPointerUpNative;
-    private readonly _onPointerLeave;
-    private readonly _onWheel;
-    /**
-     * Restore the default view: fit all bars on the time axis and re-enable
-     * auto-scaling on every price axis (undoing any pan/zoom or manual axis drag).
-     * Same as double-clicking the chart.
-     */
-    resetScale(): void;
-    private readonly _onDblClick;
-    private _beginPinch;
-    private _updatePinch;
-    private readonly _onKeyDown;
-    /** Scope gating: hover keeps keys chart-local; global always acts. */
-    private _shortcutsActive;
-    /** Execute a built-in command; returns false for unknown (custom) commands. */
-    private _runShortcut;
-    /**
-     * Composite the full chart (all panes + overlays) and trigger a PNG download.
-     * This is what the screenshot keyboard shortcut runs; call it from a toolbar
-     * button for a reliable "save image" — the browser's native right-click
-     * "Save image as…" captures only the topmost (transparent overlay) canvas.
-     */
-    downloadScreenshot(filename?: string): void;
-    /** Refresh the polite live-region summary screen readers announce. */
-    private _updateAccessibleSummary;
-    /**
-     * Track the primitive under the pointer: apply its cursor hint to the
-     * container and repaint on hover enter/leave so lines/pills can render
-     * hover states (they read `hoverId` off the render context).
-     */
-    private _setHover;
-    private _updateCursor;
-    private _maybeLoadHistory;
-    private _startKinetic;
-    private _stopKinetic;
-    destroy(): void;
-}
-
 /**
  * Drawing controller — the interaction and persistence layer over
  * `DrawingLayer`. It is **headless**: no DOM, no toolbar. A host sets the
@@ -2074,6 +235,31 @@ declare class Chart {
  * callbacks, so a host keeps using those for its own order lines.
  */
 
+/**
+ * The slice of the chart this controller needs.
+ *
+ * Declared structurally rather than as `Chart` on purpose. Each tier ships its
+ * own bundled `.d.ts`, so naming the class here made the draw tier re-declare
+ * `Chart` — and because `Chart` has private members, TypeScript treats the two
+ * declarations as *different* types. A TS consumer passing the chart from
+ * `createChart()` got "separate declarations of a private property", which made
+ * the tier unusable from TypeScript at all. An interface with no private
+ * members is structural, so the real `Chart` satisfies it with nothing to cast.
+ */
+interface DrawingChartHost {
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    emit(event: string, payload: unknown): void;
+    addPrimitive(primitive: IPrimitive, paneIndex?: number): void;
+    removePrimitive(primitive: IPrimitive): void;
+    readonly dataLayer: DataLayer;
+    getVisibleLogicalRange(): {
+        from: number;
+        to: number;
+    } | null;
+    drawingState(): unknown;
+    setDrawingState(state: unknown): void;
+    setPlacementMode?(active: boolean): void;
+}
 interface DrawingControllerOptions {
     /**
      * Snap new anchors to the nearest O/H/L/C of the bar under the cursor.
@@ -2104,7 +290,7 @@ declare class DrawingController {
     private _lastCursor;
     /** Bar under the cursor, carried by the crosshair event — used by magnet. */
     private _lastBar;
-    constructor(chart: Chart, options?: DrawingControllerOptions);
+    constructor(chart: DrawingChartHost, options?: DrawingControllerOptions);
     /** Arm a tool for placement, or pass null to return to the cursor. */
     setTool(toolId: string | null): void;
     /**