import { C as ChartConfig, O as OHLCVBar, I as IIndicator, a as ChartEventMap, T as Timeframe, S as SeriesType, b as ChartState, D as DrawingToolType, c as IDrawing, A as AnyDrawingStyle, d as IWebSocketAdapter, e as TradeLevelType, f as AnyLevel, g as DrawingPoint, h as ScaleManager, V as Viewport, P as PriceRange$1, i as DrawingHandle, j as ChartTheme, k as SerializedDrawing, l as Tick, m as StreamStatus } from './MACD-Dqi682ei.js';
export { n as ActiveIndicatorState, B as BollingerBands, o as BottomBarColors, p as BottomBarLabels, q as BottomBarUiConfig, r as CanvasColorSettings, s as ChartLabels, t as ChartMiscLabels, u as ChartThemeUi, v as CrosshairPosition, w as CrosshairUiConfig, x as DARK_THEME, y as DEFAULT_BOTTOM_BAR_CONFIG, z as DEFAULT_CROSSHAIR_CONFIG, E as DEFAULT_DRAWING_TOOLBAR_CONFIG, F as DEFAULT_INDICATOR_OVERLAY_CONFIG, G as DEFAULT_LABELS, H as DEFAULT_PRICE_AXIS_CONFIG, J as DEFAULT_TIME_AXIS_CONFIG, K as DEFAULT_TOP_BAR_CONFIG, L as DEFAULT_TRADE_BUTTON_CONFIG, M as DEFAULT_UI_CONFIG, N as DataLoaderParams, Q as DeepPartial, R as DeepPartialChartTheme, U as DialogLabels, W as DrawingToolbarColors, X as DrawingToolbarLabels, Y as DrawingToolbarUiConfig, Z as Duration, _ as EMA, $ as IndicatorOverlayColors, a0 as IndicatorOverlayUiConfig, a1 as IndicatorParams, a2 as IndicatorResult, a3 as IndicatorStateEntry, a4 as LIGHT_THEME, a5 as MACD, a6 as OhlcLabels, a7 as OrderSubmit, a8 as Padding, a9 as PendingOrderLevel, aa as PositionLevel, ab as PositionRenderStyle, ac as PriceAxisUiConfig, ad as RSI, ae as SMA, af as Theme, ag as ThemeOverrides, ah as TimeAxisUiConfig, ai as TopBarColors, aj as TopBarLabels, ak as TopBarUiConfig, al as TradeButtonUiConfig, am as TradeDisplayFilter, an as TradeLabels, ao as TradeLevel, ap as TradeLevelColors, aq as TradePanelColors, ar as UiConfig, as as deepMergeTheme, at as resolveCssVarsInTheme, au as resolveLabels, av as resolveUiConfig } from './MACD-Dqi682ei.js';

declare class ChartEngine {
    private wrapper;
    private canvasWrap;
    private canvas;
    private drawCanvas;
    private ctx;
    private drawCtx;
    private topBar;
    private bottomBar;
    private leftBar;
    private leftBarVisible;
    private drawingToolsEnabled;
    private settingsEnabled;
    private fullscreenEnabled;
    private _mobileLayout;
    private indicatorOverlay;
    private subPaneOverlays;
    private isinPickerModal;
    private isins;
    private siEl;
    private siStreamDot;
    private siSymbolSpan;
    private siOHLCSpan;
    private siOHLC2Span;
    private tickActivityTimer;
    private tickActivityMs;
    private streamStatus;
    private _isDestroyed;
    private indicatorSettingsDialog;
    private chartSettingsDialog;
    private tradeButton;
    private tradePopover;
    private drawingStylePopover;
    private draftOrderLabel;
    private _minLots;
    private _showQuantityField;
    private _qtyFieldMin;
    private _qtyFieldMax;
    private _draftQtyFlyout;
    private _draftQtyPillArea;
    private _activeQtyPillLabel;
    private pendingQtyChanges;
    private originalQtyByLabel;
    private _onOrderSubmit;
    private scrollToEndBtn;
    private scrollToEndVisible;
    private scrollAnimId;
    private resetViewBtn;
    private resetViewVisible;
    private _defaultVisibleBars;
    private dataStore;
    private scaleManager;
    private emitter;
    private theme;
    private themeName;
    private _debug;
    private series;
    private showVolume;
    private symbol;
    private showBidAskLines;
    private showActLogo;
    private hideLevelConfirmCancel;
    private deselectActiveOnOutsideClick;
    private tradeLevelButtonScale;
    private levelClusteringEnabled;
    private clusterThresholdDistance;
    private enableThemeToggle;
    private timeframe;
    private duration;
    private activeIndicators;
    private get indicators();
    private indicatorResults;
    private viewport;
    private _targetViewport;
    private _isPanning;
    private crosshair;
    private drawingManager;
    private textInputEl;
    private textInputDrawing;
    /** Pending drag — committed only after mouse moves past DRAW_GESTURE_THRESHOLD. */
    private _pendingDrawDrag;
    /** Pending resize — committed only after mouse moves past DRAW_GESTURE_THRESHOLD. */
    private _pendingDrawResize;
    private static readonly DRAW_GESTURE_THRESHOLD;
    /**
     * Pending trade-level drag — committed only after mouse moves past TRADE_DRAG_PIXEL_THRESHOLD.
     * A mouseup before the threshold means it was a click: route to _openTradeLevelEditForm instead
     * of finishing a zero-delta drag (which would otherwise stage a spurious pending change).
     */
    private _pendingTradeDrag;
    private static readonly TRADE_DRAG_PIXEL_THRESHOLD;
    private paneHeightOverrides;
    private separatorDrag;
    private readonly priceAxisWidth;
    private readonly timeAxisHeight;
    private priceScaleFactor;
    private pricePanOffset;
    private _displayedPriceRange;
    private _lockedAutoFitBase;
    /**
     * When setState() restores a persisted viewport but data isn't loaded yet,
     * we stash the desired time window here and apply it from loadData() once
     * bars are available. Cleared after one application.
     */
    private _pendingViewportRestore;
    /**
     * Debounces viewport/priceScale stateChange emissions during continuous
     * gestures (pan, wheel-zoom, price-scale drag). Pan/zoom don't emit
     * stateChange directly because doing so per-frame would be wasteful; this
     * timer coalesces bursts so the persisted viewport catches up a few ms
     * after the user stops interacting. Paired with the consumer's own
     * debounce (e.g. CRM's 800ms save) for minimal traffic.
     */
    private _viewportPersistTimer;
    /** Schedules a stateChange emission so viewport/priceScale changes made by
     *  pan/zoom/price-scale drag reach persistence. Coalesces rapid calls. */
    private scheduleViewportPersist;
    private axisDrag;
    private subPaneScaleFactors;
    private _mobileCrosshairActive;
    private _mobileTapStartXY;
    private _longPressTimer;
    private _longPressPoint;
    private _lastTouchTime;
    private _tradeButtonClickData;
    private panHandler;
    private zoomHandler;
    private resizeObserver;
    private disposeVvListener;
    private rafId;
    private countdownRafId;
    private countdownActive;
    private _cachedWrapRect;
    private _cachedDrawRect;
    private _drawTouchAnchorActive;
    private _lastDrawingTouchPoint;
    private _drawTouchStartXY;
    private _mobileDrawingFlyout;
    private _isCssFullscreen;
    private get isFullscreen();
    /** True when any trading action is in progress — popover open, draft placed, level drag active, or pending confirm. */
    private get _isTradingActive();
    private uiConfig;
    private themeOverrides;
    private timezone;
    private settingsCanvasColors;
    private aggregateFrom;
    private labels;
    private streamAdapter;
    private liveBidAsk;
    private tickClosePriceSource;
    /** True while an async data fetch is in-flight; suppresses tick processing to
     *  prevent stale ticks from corrupting newly-loaded bars. */
    private _suppressTicks;
    private levels;
    private tradeLevelHitAreas;
    private offViewportHitAreas;
    private tradeLevelEditAreas;
    private tradeHoverAreas;
    private tradeLevelDragAreas;
    private tradeLevelConfirmAreas;
    private tradeAddBracketAreas;
    private clusterBadgeAreas;
    private lastClusters;
    /** Set of cluster IDs that are currently expanded (fanned out). */
    private expandedClusters;
    private hoveredTradeLabel;
    private selectedTradeLabel;
    /**
     * Label of the level whose external edit form is currently open (i.e. the label for which
     * `tradeLevelEditOpen` was most recently emitted and no matching cancel/confirm has fired yet).
     * Distinct from `selectedTradeLabel`, which can also be set by a plain desktop hover-click
     * that just shows brackets without opening the form. Used so outside-click / cross-button
     * can issue a proper cancel (emit `tradeLevelEditCancelled`) even when no pending drag is
     * staged — e.g. the user opened the form on a position that has no SL/TP yet and clicks
     * elsewhere without adding anything.
     */
    private _editOpenLabel;
    private tradeCanvas;
    private tradeCtx;
    /** Estimated PNL text for draft order SL/TP bracket lines, set by setDraftBracketPnl(). */
    private draftBracketPnl;
    private tradeDragHandler;
    private tradeDragNewPrice;
    /** Derived SL preview price during an entry drag in follow-brackets mode. */
    private tradeDragNewSLPrice;
    /** Derived TP preview price during an entry drag in follow-brackets mode. */
    private tradeDragNewTPPrice;
    /** bracketOrderLabel stored when a bracket drag starts, for use in the confirm message. */
    private _pendingBracketOrderLabel;
    /** ToClose sibling label for the SL bracket of the current entry drag (existing pending orders). */
    private _slSiblingOrderLabel;
    /** ToClose sibling label for the TP bracket of the current entry drag (existing pending orders). */
    private _tpSiblingOrderLabel;
    /** True when the current bracket drag is adding a NEW bracket (via +SL/+TP button). */
    private _isBracketNew;
    private pendingLevelDrags;
    private tfcEnabled;
    private tfcActive;
    private tradeDisplayFilter;
    private positionRenderStyle;
    private tradesThresholdForHorizontalLine;
    /** Explicit user override from settings dialog. null = no override yet. */
    private positionRenderStyleOverride;
    private readonly RENDER_STYLE_LS_KEY;
    private dataLoader;
    private isFetching;
    private noMoreData;
    private _loadGeneration;
    private maxCandles;
    private minInitialBars;
    private maxLookbackMs;
    private prefetchThreshold;
    private defaultVisibleBars;
    private defaultMobileVisibleBars;
    private mobileBarDivisor;
    private explicitMobileDivisor;
    private _autoVisibleBars;
    private targetCandleWidth;
    private maxSubPanes;
    private showCandleCountdown;
    private candleCountdownTimeframes;
    private showTradeLevelsAlways;
    private showPriceAxisCountdown;
    private readonly SHOW_SLTP_ALWAYS_LS_KEY;
    private readonly PRICE_AXIS_COUNTDOWN_LS_KEY;
    private loadingOverlayEl;
    private noDataOverlayEl;
    private logoImage;
    constructor(config: ChartConfig);
    /**
     * Completely resets the chart to a clean, empty state.
     *
     * Cancels any in-flight data fetch, clears all bars, resets the price/time
     * axes, discards the live bid/ask price line, and removes all user-drawn
     * drawings and trade/position levels (including any pending draft order
     * state). The chart will render as blank until the next `loadData()` call.
     *
     * Call this before switching to a new symbol so that no previous symbol's
     * data, drawings, trade levels, price lines, or stale ticks can bleed into
     * the new chart:
     * ```
     * chart.setSymbol('GBPUSD').resetData();
     * // … fetch new bars, then:
     * chart.loadData(newBars);
     * ```
     *
     * If you need to clear bars but preserve drawings (e.g. on a data refresh
     * of the same symbol), call `loadData([])` directly instead.
     */
    resetData(): this;
    loadData(bars: OHLCVBar[], fitAll?: boolean): this;
    /** Prepends historical bars before the current dataset without a visual jump. */
    prependData(bars: OHLCVBar[]): this;
    /** Shows or hides the loading overlay. */
    setLoading(loading: boolean): this;
    /** Shows or hides the "No data available" overlay. */
    private setNoData;
    private timeframeToMs;
    /** Returns the base interval to request from the dataLoader for the current timeframe.
     *  Falls back to the current timeframe itself when no mapping is configured. */
    private getBaseInterval;
    /** Returns true when the base interval is finer than the target timeframe,
     *  meaning the fetched bars must be aggregated before rendering. */
    private shouldAggregate;
    /** Aggregates bars if shouldAggregate(), otherwise returns them unchanged. */
    private maybeAggregate;
    private timeframeToInterval;
    private durationToMs;
    private triggerLoad;
    private checkNeedMoreData;
    addIndicator(indicator: IIndicator): this;
    removeIndicator(name: string): this;
    addIndicatorByName(shortName: string): void;
    private openIndicatorSettings;
    private updateIndicatorParams;
    on<K extends keyof ChartEventMap>(event: K, listener: (payload: ChartEventMap[K]) => void): () => void;
    private buildTheme;
    setTheme(theme: 'dark' | 'light'): this;
    /** Programmatically change the active timeframe and reload data. */
    setTimeframe(tf: Timeframe): this;
    /** Update per-theme deep-partial color overrides and rebuild the active theme. */
    setThemeOverrides(overrides: ChartConfig['themeOverrides']): this;
    /**
     * Changes the display timezone for all time-axis and crosshair labels.
     * Accepts any IANA string (e.g. `"America/New_York"`), `"UTC"`, or `"local"`.
     */
    setTimezone(tz: string): this;
    setSeries(series: SeriesType): this;
    /**
     * Toggle TFC (Trade from Charts) on or off at runtime.
     * When disabled, all trade levels, the trade button, and trade popover are hidden.
     * Only functional when `tfcEnabled` config option is `true` (default).
     */
    setTfcActive(enabled: boolean): this;
    private clearDuration;
    setVolume(show: boolean): this;
    /**
     * Dismisses all open flyouts, modals, dropdowns, and popovers in one call.
     * Intended for wiring to platform back events: Android hardware back button,
     * iOS swipe-back / custom back action, or PWA `popstate`.
     *
     * @returns `true` if at least one UI element was dismissed, `false` if
     *          nothing was open. Hosts should consume the back event only when
     *          this returns `true` — otherwise let the event propagate so the
     *          Activity / view can handle it normally.
     */
    dismissAllUI(): boolean;
    /** True when any dismissible UI (flyout, modal, dropdown, popover) is currently open. */
    private isAnyUIOpen;
    /** Emitted by each UI component via its visibility callback. */
    private emitUiState;
    private isRestoringState;
    private emitStateChange;
    /**
     * Returns a full serializable snapshot of the current chart configuration.
     * Includes timeframe, chart type, active indicators (with params), and drawings.
     */
    getState(): ChartState;
    /**
     * Captures the current viewport as a {startTime, endTime} timestamp pair,
     * preserving sub-bar fractional position. Returns undefined only when no
     * bars are loaded (viewport has no meaningful time anchor).
     */
    private getViewportTimestamps;
    /**
     * Restores the viewport from a timestamp pair, converting each edge back
     * into a fractional bar index relative to the current dataStore. Callers
     * must ensure bars are loaded before invoking.
     */
    private applyViewportFromTimestamps;
    /**
     * Restores chart configuration from a previously captured `ChartState`.
     * Call this after construction to hydrate a chart from persisted state.
     */
    setState(state: ChartState): this;
    /**
     * Converts a fractional barIndex into an absolute unix-ms timestamp by
     * interpolating across the containing bar. Extrapolates linearly for indexes
     * outside [0, bars.length-1] using the adjacent bar's width.
     *
     * This is the inverse of `timestampToBarIndex` and the authoritative way to
     * capture "where in time" a drawing point sits at placement, drag, or resize.
     * Returns undefined only when no bars are loaded.
     */
    private barIndexToTimestamp;
    /**
     * Converts a unix-ms timestamp into a fractional barIndex using floor-bar
     * containment: the result is `floorBar + (ts - floorBar.time) / (nextBar.time - floorBar.time)`.
     * Extrapolates linearly for timestamps outside the loaded range using the edge
     * bar width, so drawings outside the visible data still render at the correct
     * relative offset rather than snapping to an edge.
     *
     * Matches TradingView's floor-bar semantics and preserves sub-bar time
     * precision across timeframe changes.
     */
    private timestampToBarIndex;
    /**
     * Re-anchors all loaded drawings to the current dataset. For points with a
     * stored timestamp, barIndex is recomputed via `timestampToBarIndex`; for
     * points missing a timestamp (legacy saves or freshly placed points whose
     * timestamp capture was skipped), the timestamp is backfilled from the
     * current barIndex so subsequent data reloads remain accurate.
     *
     * Called after loadData(), prependData(), and whenever the underlying bars
     * change such that cached barIndex values would otherwise drift.
     */
    private reanchorDrawingsByTimestamp;
    /**
     * Captures a timestamp on any drawing point that is missing one, using the
     * current bars. Call this BEFORE mutating `dataStore.all` (insert/splice)
     * so that points still pointing at a stale barIndex get frozen to the
     * correct time before the mutation invalidates the index. Safe no-op for
     * points that already have a timestamp.
     */
    private backfillDrawingTimestamps;
    /**
     * Resets all chart settings that are captured by `getState()` back to their
     * defaults (candlestick / dark / 1D / 1Y / volume on / no indicators / no drawings)
     * and emits a `stateChange` event so consumers can persist the cleared state.
     */
    resetChartSettings(): this;
    setSymbol(symbol: string): this;
    /**
     * Update the list of symbols available in the ISIN picker modal.
     * Has no effect if the chart was not initialised with `isins` + `onIsinSelect`.
     */
    setIsins(isins: string[]): this;
    private renderSymbolInfoOHLC;
    /**
     * @deprecated Use `minLots` in the initial config or manage lot size externally.
     * Updates the trade popover lot display and the submitted lot size. Will be removed in a future version.
     */
    setMinLots(lots: number): this;
    /**
     * Updates the quantity (lots) shown in the draft order QTY pill and
     * submitted when the order is confirmed.
     * @param qty  Lot size to display and submit.
     */
    setDraftQty(qty: number): this;
    private setLevelQty;
    private openDraftQtyFlyout;
    /**
     * @deprecated DraftOrderQtyInput has been removed. This method is a no-op
     * kept for backward compatibility. It will be removed in a future version.
     */
    setDraftOrderLabels(_labels: Record<string, string>): this;
    setDrawingTool(tool: DrawingToolType | null): this;
    undoDrawing(): this;
    redoDrawing(): this;
    hideAllDrawings(): this;
    showAllDrawings(): this;
    lockAllDrawings(): this;
    unlockAllDrawings(): this;
    deleteSelectedDrawing(): this;
    clearAllDrawings(): this;
    getActiveTool(): DrawingToolType | null;
    /** Returns a copy of all current drawings as live IDrawing objects. */
    getDrawings(): IDrawing[];
    /** Returns the drawing matching `id`, or null. */
    getDrawingById(id: string): IDrawing | null;
    /** Returns the currently selected drawing, or null. */
    getSelectedDrawing(): IDrawing | null;
    /**
     * Shallow-merge a per-instance style override onto the drawing with `id`.
     * Fib `levels` are deep-merged (per-key) so partial overrides keep siblings.
     * Returns `this` for chaining.
     */
    updateDrawingStyle(id: string, patch: Partial<AnyDrawingStyle>): this;
    connectStream(adapter: IWebSocketAdapter): this;
    disconnectStream(): this;
    /** Push a live bid/ask tick directly — no adapter needed.
     *  Pass `T` from your feed as the server timestamp (ISO string or Unix ms)
     *  to avoid system clock skew causing premature candle formation. */
    pushTick(prices: {
        B: number;
        A: number;
        T?: string | number;
    }): this;
    /**
     * Replace all levels of a given type and trigger a re-render.
     * Pass an empty array to clear all levels of that type.
     *
     * @param data        Array of your domain objects (orders, positions, etc.)
     * @param labelKey    Key whose value is shown as the level label
     * @param priceKey    Key whose value is the entry/order price
     * @param type        `'trade'` → solid line, no PnL; `'position'` → dashed line, optional PnL
     * @param pnlKey      (positions only) Key whose numeric value determines PnL badge color
     * @param pnlTextKey  (positions only) Key whose pre-formatted string is rendered verbatim in the box
     */
    setLevels<T extends Record<string, unknown>>(data: T[], labelKey: keyof T, priceKey: keyof T, type: TradeLevelType, pnlKey?: keyof T, pnlTextKey?: keyof T): this;
    /**
     * Remove a single level by its label (derived from `labelKey` at `setLevels` time).
     * No-op if no level with that label exists.
     */
    removeLevelByLabel(label: string): this;
    /**
     * Show a draft pending order preview line on the chart.
     * Typically called from an external order panel when the user selects a limit/stop order type.
     * Clears any existing draft first. The draft line is draggable; price changes emit `tradeLevelDrag`.
     * When confirmed from the chart, `onOrderSubmit` is called and `tradeLevelConfirmed` is emitted.
     */
    showDraftOrder(price: number, side: 'buy' | 'sell', orderType: 'limit' | 'stop'): this;
    /**
     * Show a draft market order preview on the chart at the given price.
     * Unlike limit/stop drafts, the main line is informational (not draggable),
     * no qty overlay is shown, and no confirm/cancel buttons appear.
     * SL/TP brackets can still be attached via updateDraftOrderBracket.
     */
    showMarketDraft(price: number, side: 'buy' | 'sell'): this;
    /**
     * Remove the current draft order preview line and emit `draftCancelled`.
     * Call when the order panel closes or the user switches to market order type.
     * To cancel whatever is currently being edited or drafted (draft or existing level),
     * use `cancelCurrentEdit()` instead.
     */
    clearDraftOrder(): this;
    /**
     * Update the stop-loss or take-profit bracket price on any existing level by label.
     * Pass `null` to remove the bracket. No-op if no level with that label exists.
     * Use this when an external panel changes SL/TP for an open position or pending order.
     */
    updateLevelBracket(label: string, type: 'sl' | 'tp', price: number | null): this;
    /**
     * Add a SL or TP bracket to an existing level at an auto-computed default price.
     * Use this when an external panel enables a bracket without knowing the price.
     * The chart places the bracket at the same offset used by the canvas +SL/+TP button
     * and emits `tradeLevelBracketActivated` with the chosen price so the panel can populate its input.
     * No-op if the level doesn't exist or already has the requested bracket.
     */
    addLevelBracket(label: string, type: 'sl' | 'tp'): this;
    /**
     * Unified auto-price bracket placement for mobile UIs.
     * - If `label` is provided, operates on the matching existing level (delegates to addLevelBracket).
     * - If `label` is omitted, operates on the active draft order (no OrderID needed).
     * In both cases the chart computes a sensible default price (30px offset) and emits
     * `tradeLevelBracketActivated` with the result so the native form can populate its input.
     * No-op if the target doesn't exist or already has the requested bracket type.
     */
    addBracket(type: 'sl' | 'tp', label?: string): this;
    /**
     * Unified bracket removal for mobile UIs.
     * - If `label` is provided, removes the bracket from the matching existing level (calls updateLevelBracket with null price).
     * - If `label` is omitted, removes the bracket from the active draft order.
     * No-op if the target doesn't exist or doesn't have the bracket type.
     */
    removeBracket(type: 'sl' | 'tp', label?: string): this;
    /**
     * Move an existing level's entry price line to a new price and re-render.
     * Used when an external panel updates the entry price for an open position or pending order.
     * No-op if no level with that label exists.
     */
    updateLevelMainPrice(label: string, price: number): this;
    /**
     * Set or clear the estimated PNL text shown on the SL or TP bracket line.
     * Applies to the currently active bracket host — a draft order while drafting,
     * or the selected level while modifying an existing pending order or position.
     * Pass `null` to clear the text.
     * Use this to display the consumer-calculated estimated profit/loss next to the bracket.
     */
    setDraftBracketPnl(type: 'sl' | 'tp', pnlText: string | null): this;
    /**
     * Update the stop-loss or take-profit price on the current draft order.
     * Pass `null` to remove the bracket. No-op if no draft order is active.
     */
    updateDraftOrderBracket(type: 'sl' | 'tp', price: number | null): this;
    /**
     * Update the entry price of the active draft order in-place without recreating it.
     * Unlike `showDraftOrder`, this does NOT call `clearDraftOrder` + `createDraftOrder`,
     * so the qty overlay is repositioned but never re-focused.
     * Returns `true` if a draft existed and was updated, `false` if no draft is active.
     */
    updateDraftOrderPrice(price: number): boolean;
    /**
     * Cancel the pending edit state of a level without firing `tradeLevelEdit`.
     * Use when the external order panel has already handled the confirmation,
     * preventing the chart from sending a duplicate server request.
     */
    cancelLevelEdit(label: string): this;
    /**
     * Cancel whatever is currently being edited or drafted on the chart.
     * Handles all three cases without the caller needing to track the active label:
     *   - active limit/stop draft (`draftOrderLabel === selectedTradeLabel`) — emits `draftCancelled`
     *   - active market draft (`draftOrderLabel` set, no `selectedTradeLabel`) — emits `draftCancelled`
     *   - in-progress level edit (`selectedTradeLabel` set with pending changes) — reverts staged changes
     * No-op when nothing is being edited.
     */
    cancelCurrentEdit(): this;
    /**
     * Programmatically select (activate) a trade level by its label.
     * Pass `null` to deselect the currently active level.
     * Useful when an external panel (e.g. positions table) opens an edit form
     * and the chart should highlight the corresponding level.
     */
    selectLevel(label: string | null): this;
    /** Enable or disable trade-level fan-out clustering at runtime. */
    setLevelClusteringEnabled(enabled: boolean): this;
    /** Update the cluster proximity threshold (in pixels) at runtime. Only effective when levelClusteringEnabled is true. */
    setClusterThresholdDistance(px: number): this;
    /**
     * Scale the Confirm/Cancel/Edit/Close buttons on trade-level overlays.
     * Both visuals and hit-rects grow together. Clamped to `[1, 3]`.
     */
    setTradeLevelButtonScale(scale: number): this;
    destroy(): void;
    private createMobileDrawingFlyout;
    private showMobileDrawingFlyout;
    private hideMobileDrawingFlyout;
    private applyMobileDrawingFlyoutTheme;
    private scheduleRender;
    private startCountdownLoop;
    private stopCountdownLoop;
    private updateCountdownState;
    private openChartSettings;
    /** Returns the element floating UI should be parented to — the fullscreen element when active, otherwise document.body. */
    private getFloatingRoot;
    /**
     * Re-parents all floating elements (flyouts, modals) to the correct root.
     * Called on fullscreenchange so they remain visible inside the fullscreen context.
     */
    private reparentFloatingElements;
    private toggleDrawingTools;
    private _applyCssFullscreen;
    private toggleFullscreen;
    private recomputeRenderStyle;
    private renderTradeLayer;
    /** Returns the effective entry price for a level, preferring any staged main drag. */
    private _effectiveEntryPrice;
    /**
     * Returns the effective bracket (SL/TP) price for a level, preferring any staged
     * bracket drag over the level's stored bracket price. Used at entry-drag start so
     * the follow-brackets delta is measured from whatever the user currently sees.
     */
    private _effectiveBracketPrice;
    /**
     * Resolves the effective SL/TP prices for a level, checking both inline fields and
     * ToClose sibling levels (used by existing pending orders whose brackets are stored
     * as separate PendingOrderLevel objects rather than inline stopLossPrice/takeProfitPrice).
     * Also returns the sibling labels for proper bracketOrderLabel attribution.
     */
    private _resolveBracketPrices;
    /**
     * Finalises a main-line drag that may have dragged SL/TP along with it (follow-brackets mode).
     * Stores MAIN and, if the brackets were translated, synthesized SL/TP pending changes in one
     * batch. In mobile mode (`hideLevelConfirmCancel`) the final call triggers a single atomic
     * `applyPendingChanges` so consumers see one `tradeLevelEdit` event with all changes.
     */
    private _finalizeMainDragWithBrackets;
    private storePendingChange;
    private _orderTypeForPrice;
    private createDraftOrder;
    private removeDraftOrder;
    private applyPendingChanges;
    private revertPendingChanges;
    private undoIsNewBracketMutations;
    private render;
    private recomputeIndicators;
    private onResize;
    private paneH;
    /** Translate pixel + data space dimensions used for drawing hit-tests */
    private getChartLayout;
    /**
     * Returns canvasWrap-relative pixel coords of the topmost rendered point of
     * a drawing — used to anchor the floating style popover above it. Returns
     * null when the drawing has no on-screen points (e.g. fully clipped out).
     */
    private computeDrawingAnchorPx;
    /** Repositions each sub-pane IndicatorOverlay element to sit at the top of its pane */
    private updateSubPaneOverlayPositions;
    /** Y positions (logical px) of each sub-pane top separator, used for drag-resize */
    private getSeparatorPositions;
    private getScaledPriceRange;
    private onMouseMove;
    private onMouseLeave;
    private onMouseUp;
    private touchToDrawingPoint;
    /**
     * Builds a fully-populated DrawingPoint from raw float coordinates. Captures
     * the absolute timestamp at this fractional barIndex so the anchor survives
     * timeframe changes, data reloads, and serialization round-trips.
     */
    private makeDrawingPoint;
    /** Shared close-button handler used by both mouse click and touch tap. */
    private _handleTradeLevelClose;
    /** Activates the mobile crosshair at canvas coords (x, y). */
    private _activateMobileCrosshair;
    /**
     * Closes the edit form, clears selection, and emits `tradeLevelEditCancelled` when
     * the edit form was actually open for this label. Shared between click-outside,
     * repeat-click toggle, and the ✗ button so all exit paths produce the same payload.
     */
    private _cancelEditAndDeselect;
    /**
     * Opens the external edit form for a trade level by emitting `tradeLevelEditOpen`.
     * Shared between pencil click, bare box click, and drag start so every entry
     * point fires the same payload. No-op when the form is already open for this
     * label, so repeat opens (e.g. pencil click followed by drag) don't spam the event.
     */
    private _openTradeLevelEditForm;
    /** Shared helper: initiate a trade level main-line drag from a hit area. */
    private _startTradeDragFromHit;
    /** Shared helper: initiate a +SL/+TP add-bracket drag from a hit area. */
    private _startAddBracketFromHit;
    private onDrawingTouchStart;
    private onDrawingTouchMove;
    private onDrawingTouchEnd;
    private onCanvasClick;
    private onDoubleClick;
    private onKeyDown;
    private showTextInput;
    private commitTextInput;
    private cancelTextInput;
    private setDotTickActive;
    private onTick;
    /** Fetch bars that fall in a gap between the last historical bar and the first live bar.
     *  This happens when the system clock was behind feed time during the initial data load. */
    private fillTickGap;
    /** Re-fetch the just-closed candle (plus 2 neighbours) via `dataLoader` to replace
     *  tick-reconstructed OHLCV with authoritative exchange data. No-op if no loader. */
    private correctCompletedBar;
    /** Enable or disable verbose tick logging to the console for debugging live candle issues. */
    setDebug(enabled: boolean): this;
    /** Replace the bar with the given timestamp with authoritative OHLCV data.
     *  Use this when you receive a corrected candle from an external source. */
    correctBar(barTime: number, bar: OHLCVBar): void;
    private scrollToEnd;
    /**
     * Smooth-scroll the Y axis so `price` lands at the vertical center of the
     * chart. Animates `pricePanOffset` only — horizontal viewport is preserved.
     * Used by off-viewport level indicator clicks.
     */
    private scrollToCenterPrice;
    private resetPriceAxis;
    private resetTimeAxis;
    /** Reset both price and time axes to their default state. */
    resetView(): void;
    private applyResetViewBtnStyles;
    private applyScrollToEndBtnStyles;
}

/**
 * Aggregates an array of fine-grained OHLCV bars into a coarser timeframe.
 *
 * Bars are grouped by time bucket: `Math.floor(bar.time / targetIntervalMs) * targetIntervalMs`.
 * Each bucket produces one output bar:
 *   - open  = first bar's open
 *   - high  = max of all highs
 *   - low   = min of all lows
 *   - close = last bar's close
 *   - volume = sum of all volumes
 *
 * Empty time buckets (weekends, holidays, gaps) are skipped — no phantom bars are created.
 * Partial buckets (e.g. the live/in-progress candle) are included as-is.
 *
 * @param bars            Source bars sorted ascending by time.
 * @param targetIntervalMs Target candle duration in milliseconds.
 * @returns Aggregated bars sorted ascending by time.
 */
declare function aggregateCandles(bars: OHLCVBar[], targetIntervalMs: number): OHLCVBar[];

/** Drag handle hit area for the main level line (non-bracket). */
interface TradeLevelDragArea {
    label: string;
    type: AnyLevel['type'];
    data: unknown;
    /** The price of this level — used to initialize drag state. */
    price: number;
    x: number;
    y: number;
    w: number;
    h: number;
    isBracket: false;
    /**
     * True when this area covers the info box (not the line strip or grip).
     * On mobile a box tap opens the edit panel; only the line strip initiates a drag.
     */
    isBox?: boolean;
}
/** Drag handle hit area for a bracket (SL/TP) line. */
interface TradeLevelBracketDragArea {
    /** Label of the parent PendingOrderLevel. */
    label: string;
    data: unknown;
    bracketType: 'stopLoss' | 'takeProfit';
    /** The current price of this bracket line. */
    price: number;
    /** Price of the parent order (used for constraint enforcement). */
    parentPrice: number;
    /** Side of the parent order. */
    parentSide: 'buy' | 'sell';
    /**
     * When this bracket originated from a `ToClose` pending order, this holds
     * that order's own label — used in the drag confirmation message.
     * Undefined for inline stopLossPrice / takeProfitPrice fields.
     */
    bracketOrderLabel?: string;
    x: number;
    y: number;
    w: number;
    h: number;
    isBracket: true;
}
type AnyDragArea = TradeLevelDragArea | TradeLevelBracketDragArea;

declare class DrawingManager {
    private drawings;
    private activeDrawing;
    private selectedDrawing;
    private activeTool;
    private state;
    private history;
    private redoStack;
    private onCompleteCallback;
    /** Called after any completed state-mutating operation (drawing placed, moved, deleted, etc.). */
    onDrawingsChange: (() => void) | null;
    /** Called when a text-type drawing is first completed — ChartEngine shows the text input. */
    onStartTextEdit: ((drawing: IDrawing) => void) | null;
    /**
     * Called after drag/resize mutates a drawing's points so ChartEngine can
     * refresh each point's `timestamp` from the current dataStore. Required
     * because DrawingManager has no access to the data layer, and drag
     * reconstructs points from raw (barIndex, price) deltas that strip the
     * original point's timestamp.
     */
    onPointsMutated: ((drawing: IDrawing) => void) | null;
    /** Called whenever the selected drawing changes (including to/from null). */
    onSelectionChange: ((drawing: IDrawing | null) => void) | null;
    /** Set to true by ChartEngine while the text input is focused — prevents Delete/Backspace from deleting the drawing. */
    private editingText;
    /** Centralizes selection mutation + change notification. */
    private setSelected;
    private dragDrawing;
    private dragStartMouse;
    private dragStartPoints;
    private resizeDrawing;
    private resizePointIndex;
    /** Called by ChartEngine to be notified when a drawing is finished. */
    setOnComplete(cb: () => void): void;
    /** Toggle the text-editing guard so Delete/Backspace are not intercepted. */
    setEditingText(editing: boolean): void;
    setActiveTool(tool: DrawingToolType | null): void;
    getActiveTool(): DrawingToolType | null;
    /** Returns true if the drawing system consumed the event */
    onMouseDown(point: DrawingPoint): boolean;
    onMouseMove(point: DrawingPoint): void;
    /**
     * Finalizes an open-ended drawing (Polyline, Path, Brush, Highlighter)
     * on double-click. Removes the dangling preview point and marks complete.
     */
    finalizePlacing(): void;
    startDrag(drawing: IDrawing, mouse: DrawingPoint): void;
    endDrag(): void;
    isDraggingDrawing(): boolean;
    /** True when a multi-point drawing has been started and is awaiting further touch/click input. */
    isPlacing(): boolean;
    startResize(drawing: IDrawing, pointIndex: number): void;
    endResize(): void;
    isResizingDrawing(): boolean;
    /** Shift all drawings' barIndex values by `delta` (called when bars are prepended to DataStore). */
    shiftBarIndices(delta: number): void;
    /** Returns the handle under (x,y) across all complete drawings, or null */
    getHandleAtPoint(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): {
        drawing: IDrawing;
        handle: DrawingHandle;
    } | null;
    /** Returns the drawing that was hit, or null */
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): IDrawing | null;
    selectDrawing(drawing: IDrawing | null): void;
    getSelectedDrawing(): IDrawing | null;
    /** Returns a drawing by id, or null if not found. */
    getDrawingById(id: string): IDrawing | null;
    /**
     * Shallow-merge a style patch into the drawing's `style` field. Triggers
     * `onDrawingsChange` so the chart re-renders. Returns the updated drawing,
     * or null if no drawing matches `id`.
     */
    updateDrawingStyle(id: string, patch: Partial<AnyDrawingStyle>): IDrawing | null;
    onKeyDown(key: string): boolean;
    deleteSelected(): void;
    undo(): void;
    redo(): void;
    hideAll(): void;
    showAll(): void;
    lockAll(): void;
    unlockAll(): void;
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, pricePrecision?: number, theme?: ChartTheme): void;
    getDrawings(): IDrawing[];
    /** Returns a JSON-serializable snapshot of all drawings (data fields only, no methods). */
    getDrawingsSnapshot(): SerializedDrawing[];
    /** Restores drawings from a serialized snapshot, replacing current drawings. */
    loadDrawings(drawings: SerializedDrawing[]): void;
    clearAll(): void;
    private notifyChange;
    private snapshot;
    private cloneDrawings;
    private createDrawing;
}

declare class HorizontalLine implements IDrawing {
    readonly id: string;
    readonly type: "horizontalLine";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, _viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(_x: number, y: number, scale: ScaleManager, _viewport: Viewport, priceRange: PriceRange$1, _chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class VerticalLine implements IDrawing {
    readonly id: string;
    readonly type: "verticalLine";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, _priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, _y: number, scale: ScaleManager, viewport: Viewport, _priceRange: PriceRange$1, chartW: number, _chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class TrendLine implements IDrawing {
    readonly id: string;
    readonly type: "trendLine";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class TrendAngle implements IDrawing {
    readonly id: string;
    readonly type: "trendAngle";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class CrossLine implements IDrawing {
    readonly id: string;
    readonly type: "crossLine";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class ParallelChannel implements IDrawing {
    readonly id: string;
    readonly type: "parallelChannel";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FlatChannel implements IDrawing {
    readonly id: string;
    readonly type: "flatChannel";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class DisjointChannel implements IDrawing {
    readonly id: string;
    readonly type: "disjointChannel";
    readonly requiredPoints = 4;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibRetracement implements IDrawing {
    readonly id: string;
    readonly type: "fibRetracement";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(_x: number, y: number, scale: ScaleManager, _viewport: Viewport, priceRange: PriceRange$1, _chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibExtension implements IDrawing {
    readonly id: string;
    readonly type: "fibExtension";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(_x: number, y: number, scale: ScaleManager, _viewport: Viewport, priceRange: PriceRange$1, _chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibChannel implements IDrawing {
    readonly id: string;
    readonly type: "fibChannel";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibTimezone implements IDrawing {
    readonly id: string;
    readonly type: "fibTimezone";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, _y: number, scale: ScaleManager, viewport: Viewport, _priceRange: PriceRange$1, chartW: number, _chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibCircles implements IDrawing {
    readonly id: string;
    readonly type: "fibCircles";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibSpiral implements IDrawing {
    readonly id: string;
    readonly type: "fibSpiral";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    /** Compute the pivot center and radius for each arc in the spiral */
    private computeArcs;
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibFan implements IDrawing {
    readonly id: string;
    readonly type: "fibFan";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FibProjection implements IDrawing {
    readonly id: string;
    readonly type: "fibProjection";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(_x: number, y: number, scale: ScaleManager, _viewport: Viewport, priceRange: PriceRange$1, _chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class GannFan implements IDrawing {
    readonly id: string;
    readonly type: "gannFan";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class GannSquare implements IDrawing {
    readonly id: string;
    readonly type: "gannSquare";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class GannBox implements IDrawing {
    readonly id: string;
    readonly type: "gannBox";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Rectangle implements IDrawing {
    readonly id: string;
    readonly type: "rectangle";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class RotatedRectangle implements IDrawing {
    readonly id: string;
    readonly type: "rotatedRectangle";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    private getCorners;
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Ellipse implements IDrawing {
    readonly id: string;
    readonly type: "ellipse";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Triangle implements IDrawing {
    readonly id: string;
    readonly type: "triangle";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Circle implements IDrawing {
    readonly id: string;
    readonly type: "circle";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Arc implements IDrawing {
    readonly id: string;
    readonly type: "arc";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Polyline implements IDrawing {
    readonly id: string;
    readonly type: "polyline";
    readonly openEnded = true;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Path implements IDrawing {
    readonly id: string;
    readonly type: "path";
    readonly openEnded = true;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class PriceRange implements IDrawing {
    readonly id: string;
    readonly type: "priceRange";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class DateRange implements IDrawing {
    readonly id: string;
    readonly type: "dateRange";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class DatePriceRange implements IDrawing {
    readonly id: string;
    readonly type: "datePriceRange";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Ruler implements IDrawing {
    readonly id: string;
    readonly type: "ruler";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Pitchfork implements IDrawing {
    readonly id: string;
    readonly type: "pitchfork";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class SchiffPitchfork implements IDrawing {
    readonly id: string;
    readonly type: "schiffPitchfork";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ModifiedSchiff implements IDrawing {
    readonly id: string;
    readonly type: "modifiedSchiff";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class InsidePitchfork implements IDrawing {
    readonly id: string;
    readonly type: "insidePitchfork";
    readonly requiredPoints = 3;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class FixedRangeVP implements IDrawing {
    readonly id: string;
    readonly type: "fixedRangeVP";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class AnchoredVP implements IDrawing {
    readonly id: string;
    readonly type: "anchoredVP";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class VolumeProfile implements IDrawing {
    readonly id: string;
    readonly type: "volumeProfile";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class RegressionTrend implements IDrawing {
    readonly id: string;
    readonly type: "regressionTrend";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Text implements IDrawing {
    readonly id: string;
    readonly type: "text";
    points: DrawingPoint[];
    complete: boolean;
    text: string;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class Callout implements IDrawing {
    readonly id: string;
    readonly type: "callout";
    points: DrawingPoint[];
    complete: boolean;
    text: string;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    private getBoxW;
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class PriceLabel implements IDrawing {
    readonly id: string;
    readonly type: "priceLabel";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class ArrowMarker implements IDrawing {
    readonly id: string;
    readonly type: "arrowMarker";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Flag implements IDrawing {
    readonly id: string;
    readonly type: "flag";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class PriceNote implements IDrawing {
    readonly id: string;
    readonly type: "priceNote";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class AnchoredNote implements IDrawing {
    readonly id: string;
    readonly type: "anchoredNote";
    points: DrawingPoint[];
    complete: boolean;
    text: string;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    private getBadgeW;
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ArrowUp implements IDrawing {
    readonly id: string;
    readonly type: "arrowUp";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class ArrowDown implements IDrawing {
    readonly id: string;
    readonly type: "arrowDown";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(point: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(): DrawingHandle | null;
}

declare class HeadShoulders implements IDrawing {
    readonly id: string;
    readonly type: "headShoulders";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class TrianglePattern implements IDrawing {
    readonly id: string;
    readonly type: "trianglePattern";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ThreeDrives implements IDrawing {
    readonly id: string;
    readonly type: "threeDrives";
    readonly requiredPoints = 7;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class AbcdPattern implements IDrawing {
    readonly id: string;
    readonly type: "abcdPattern";
    readonly requiredPoints = 4;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class CypherPattern implements IDrawing {
    readonly id: string;
    readonly type: "cypherPattern";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ButterflyPattern implements IDrawing {
    readonly id: string;
    readonly type: "butterflyPattern";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class BatPattern implements IDrawing {
    readonly id: string;
    readonly type: "batPattern";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class GartleyPattern implements IDrawing {
    readonly id: string;
    readonly type: "gartleyPattern";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class CrabPattern implements IDrawing {
    readonly id: string;
    readonly type: "crabPattern";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class SharkPattern implements IDrawing {
    readonly id: string;
    readonly type: "sharkPattern";
    readonly requiredPoints = 5;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ElliottImpulse implements IDrawing {
    readonly id: string;
    readonly type: "elliottImpulse";
    readonly requiredPoints = 6;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ElliottCorrective implements IDrawing {
    readonly id: string;
    readonly type: "elliottCorrective";
    readonly requiredPoints = 4;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ElliottTriangle implements IDrawing {
    readonly id: string;
    readonly type: "elliottTriangle";
    readonly requiredPoints = 6;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ElliottCombination implements IDrawing {
    readonly id: string;
    readonly type: "elliottCombination";
    readonly requiredPoints = 7;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class ElliottWxy implements IDrawing {
    readonly id: string;
    readonly type: "elliottWxy";
    readonly requiredPoints = 4;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Brush implements IDrawing {
    readonly id: string;
    readonly type: "brush";
    readonly openEnded = true;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Highlighter implements IDrawing {
    readonly id: string;
    readonly type: "highlighter";
    readonly openEnded = true;
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class SineLine implements IDrawing {
    readonly id: string;
    readonly type: "sineLine";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class CyclicLines implements IDrawing {
    readonly id: string;
    readonly type: "cyclicLines";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, _y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class TimeCycles implements IDrawing {
    readonly id: string;
    readonly type: "timeCycles";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, _y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class Projection implements IDrawing {
    readonly id: string;
    readonly type: "projection";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class PriceProjection implements IDrawing {
    readonly id: string;
    readonly type: "priceProjection";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

declare class GhostFeed implements IDrawing {
    readonly id: string;
    readonly type: "ghostFeed";
    points: DrawingPoint[];
    complete: boolean;
    style?: AnyDrawingStyle;
    constructor(first: DrawingPoint);
    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, _pricePrecision?: number, theme?: ChartTheme): void;
    hitTest(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): boolean;
    getHandle(x: number, y: number, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number): DrawingHandle | null;
}

/**
 * Generic WebSocket adapter.
 *
 * Usage:
 *   const adapter = new WebSocketAdapter('wss://feed.example.com/ticks', msg => ({
 *     time:   new Date(msg.T).getTime(),
 *     bid:    msg.B,
 *     ask:    msg.A,
 *     volume: msg.v ?? 0,
 *   }));
 *   chart.connectStream(adapter);
 */
declare class WebSocketAdapter implements IWebSocketAdapter {
    private readonly url;
    /** Transform a raw server message into a Tick. Return null to skip. */
    private readonly transform;
    private ws;
    private tickCallbacks;
    private statusCallbacks;
    private reconnectTimer;
    private reconnectDelay;
    private destroyed;
    constructor(url: string, 
    /** Transform a raw server message into a Tick. Return null to skip. */
    transform?: (msg: unknown) => Tick | null);
    connect(): void;
    disconnect(): void;
    onTick(callback: (tick: Tick) => void): void;
    onStatus(callback: (status: StreamStatus) => void): void;
    private openSocket;
    private scheduleReconnect;
    private emitStatus;
}

export { AbcdPattern, AnchoredNote, AnchoredVP, type AnyDragArea, AnyLevel, Arc, ArrowDown, ArrowMarker, ArrowUp, BatPattern, Brush, ButterflyPattern, Callout, ChartConfig, ChartEngine, ChartEventMap, ChartState, ChartTheme, Circle, CrabPattern, CrossLine, CyclicLines, CypherPattern, DatePriceRange, DateRange, DisjointChannel, DrawingHandle, DrawingManager, DrawingPoint, DrawingToolType, ElliottCombination, ElliottCorrective, ElliottImpulse, ElliottTriangle, ElliottWxy, Ellipse, FibChannel, FibCircles, FibExtension, FibFan, FibProjection, FibRetracement, FibSpiral, FibTimezone, FixedRangeVP, Flag, FlatChannel, GannBox, GannFan, GannSquare, GartleyPattern, GhostFeed, HeadShoulders, Highlighter, HorizontalLine, IDrawing, IIndicator, IWebSocketAdapter, InsidePitchfork, ModifiedSchiff, OHLCVBar, ParallelChannel, Path, Pitchfork, Polyline, PriceLabel, PriceNote, PriceProjection, PriceRange, PriceRange$1 as PriceRangeType, Projection, Rectangle, RegressionTrend, RotatedRectangle, Ruler, SchiffPitchfork, SerializedDrawing, SeriesType, SharkPattern, SineLine, StreamStatus, Text, ThreeDrives, Tick, TimeCycles, Timeframe, type TradeLevelBracketDragArea, type TradeLevelDragArea, TradeLevelType, TrendAngle, TrendLine, Triangle, TrianglePattern, VerticalLine, Viewport, VolumeProfile, WebSocketAdapter, aggregateCandles };