acttrader-charts 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,1351 @@
+import { C as ChartConfig, O as OHLCVBar, I as IIndicator, a as ChartEventMap, S as SeriesType, b as ChartState, D as DrawingToolType, c as IDrawing, d as IWebSocketAdapter, T as TradeLevelType, A as AnyLevel, e as DrawingPoint, f as ScaleManager, V as Viewport, P as PriceRange$1, g as DrawingHandle, h as SerializedDrawing, i as Tick, j as StreamStatus } from './MACD-BmvUIYwI.cjs';
+export { k as ActiveIndicatorState, B as BollingerBands, l as BottomBarColors, m as BottomBarLabels, n as BottomBarUiConfig, o as CanvasColorSettings, p as ChartLabels, q as ChartMiscLabels, r as ChartTheme, s as ChartThemeUi, t as CrosshairPosition, u as CrosshairUiConfig, v as DARK_THEME, w as DEFAULT_BOTTOM_BAR_CONFIG, x as DEFAULT_CROSSHAIR_CONFIG, y as DEFAULT_DRAWING_TOOLBAR_CONFIG, z as DEFAULT_INDICATOR_OVERLAY_CONFIG, E as DEFAULT_LABELS, F as DEFAULT_PRICE_AXIS_CONFIG, G as DEFAULT_TIME_AXIS_CONFIG, H as DEFAULT_TOP_BAR_CONFIG, J as DEFAULT_UI_CONFIG, K as DataLoaderParams, L as DeepPartial, M as DeepPartialChartTheme, N as DialogLabels, Q as DrawingToolbarColors, R as DrawingToolbarLabels, U as DrawingToolbarUiConfig, W as Duration, X as EMA, Y as IndicatorOverlayColors, Z as IndicatorOverlayUiConfig, _ as IndicatorParams, $ as IndicatorResult, a0 as IndicatorStateEntry, a1 as LIGHT_THEME, a2 as MACD, a3 as OhlcLabels, a4 as OrderSubmit, a5 as Padding, a6 as PendingOrderLevel, a7 as PositionLevel, a8 as PositionRenderStyle, a9 as PriceAxisUiConfig, aa as RSI, ab as SMA, ac as Theme, ad as TimeAxisUiConfig, ae as Timeframe, af as TopBarColors, ag as TopBarLabels, ah as TopBarUiConfig, ai as TradeDisplayFilter, aj as TradeLabels, ak as TradeLevel, al as TradeLevelColors, am as TradePanelColors, an as UiConfig, ao as deepMergeTheme, ap as resolveCssVarsInTheme, aq as resolveLabels, ar as resolveUiConfig } from './MACD-BmvUIYwI.cjs';
+
+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 _mobileLayout;
+    private indicatorOverlay;
+    private subPaneOverlays;
+    private isinPickerModal;
+    private isins;
+    private siEl;
+    private siStreamDot;
+    private siSymbolSpan;
+    private siOHLCSpan;
+    private tickActivityTimer;
+    private tickActivityMs;
+    private streamStatus;
+    private indicatorSettingsDialog;
+    private chartSettingsDialog;
+    private tradeButton;
+    private tradePopover;
+    private draftOrderLabel;
+    private draftOrderQtyInput;
+    private _hoverBuyType;
+    private _hoverSellType;
+    private _onOrderSubmit;
+    private _minLots;
+    private scrollToEndBtn;
+    private scrollToEndVisible;
+    private scrollAnimId;
+    private resetViewBtn;
+    private dataStore;
+    private scaleManager;
+    private emitter;
+    private theme;
+    private themeName;
+    private _debug;
+    private series;
+    private showVolume;
+    private symbol;
+    private showBidAskLines;
+    private showActLogo;
+    private timeframe;
+    private duration;
+    private activeIndicators;
+    private get indicators();
+    private indicatorResults;
+    private viewport;
+    private crosshair;
+    private drawingManager;
+    private textInputEl;
+    private textInputDrawing;
+    private paneHeightOverrides;
+    private separatorDrag;
+    private readonly priceAxisWidth;
+    private readonly timeAxisHeight;
+    private priceScaleFactor;
+    private pricePanOffset;
+    private _displayedPriceRange;
+    private _lockedAutoFitBase;
+    private axisDrag;
+    private subPaneScaleFactors;
+    private _mobileCrosshairActive;
+    private _mobileTapStartXY;
+    private _isHoveringTradeButton;
+    private _tradeButtonClickData;
+    private panHandler;
+    private zoomHandler;
+    private resizeObserver;
+    private rafId;
+    private countdownRafId;
+    private countdownActive;
+    private _cachedWrapRect;
+    private _cachedDrawRect;
+    private _drawTouchAnchorActive;
+    private _lastDrawingTouchPoint;
+    private _drawTouchStartXY;
+    private _mobileDrawingFlyout;
+    private _isCssFullscreen;
+    private uiConfig;
+    private themeOverrides;
+    private settingsCanvasColors;
+    private aggregateFrom;
+    private labels;
+    private streamAdapter;
+    private liveBidAsk;
+    private tickClosePriceSource;
+    private levels;
+    private tradeLevelHitAreas;
+    private tradeLevelEditAreas;
+    private tradeHoverAreas;
+    private tradeLevelDragAreas;
+    private tradeLevelConfirmAreas;
+    private tradeAddBracketAreas;
+    private hoveredTradeLabel;
+    private selectedTradeLabel;
+    private tradeCanvas;
+    private tradeCtx;
+    private tradeDragHandler;
+    private tradeDragNewPrice;
+    /** bracketOrderLabel stored when a bracket drag starts, for use in the confirm message. */
+    private _pendingBracketOrderLabel;
+    /** True when the current bracket drag is adding a NEW bracket (via +SL/+TP button). */
+    private _isBracketNew;
+    private pendingLevelDrags;
+    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 maxCandles;
+    private mobileBarDivisor;
+    private explicitMobileDivisor;
+    private maxSubPanes;
+    private showCandleCountdown;
+    private candleCountdownTimeframes;
+    private loadingOverlayEl;
+    private logoImage;
+    constructor(config: ChartConfig);
+    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;
+    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;
+    setSeries(series: SeriesType): this;
+    private clearDuration;
+    setVolume(show: boolean): this;
+    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;
+    /**
+     * Restores chart configuration from a previously captured `ChartState`.
+     * Call this after construction to hydrate a chart from persisted state.
+     */
+    setState(state: ChartState): this;
+    /**
+     * 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;
+    setMinLots(lots: number): 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[];
+    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 without emitting any events.
+     * Call when the order panel closes or the user switches to market order type.
+     */
+    clearDraftOrder(): this;
+    /**
+     * Programmatically set the quantity on the active draft order's qty input.
+     * No-op when no draft order is currently shown.
+     * Use this to sync an external order panel's qty field to the chart.
+     */
+    setDraftOrderLots(lots: number): 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    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;
+    private storePendingChange;
+    private createDraftOrder;
+    private removeDraftOrder;
+    private applyPendingChanges;
+    private revertPendingChanges;
+    private render;
+    private recomputeIndicators;
+    private onResize;
+    private paneH;
+    /** Translate pixel + data space dimensions used for drawing hit-tests */
+    private getChartLayout;
+    /** 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;
+    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;
+    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;
+}
+/** 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;
+    /** Set to true by ChartEngine while the text input is focused — prevents Delete/Backspace from deleting the drawing. */
+    private editingText;
+    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;
+    /** 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;
+    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): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, _viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, _priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    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): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    private getCorners;
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    private getBoxW;
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, _isSelected: boolean): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, _isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    private getBadgeW;
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, _isSelected: boolean): 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;
+    constructor(point: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, _isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean, pricePrecision?: number): 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;
+    constructor(first: DrawingPoint);
+    render(ctx: CanvasRenderingContext2D, scale: ScaleManager, viewport: Viewport, priceRange: PriceRange$1, chartW: number, chartH: number, isSelected: boolean): 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, 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, type TradeLevelBracketDragArea, type TradeLevelDragArea, TradeLevelType, TrendAngle, TrendLine, Triangle, TrianglePattern, VerticalLine, Viewport, VolumeProfile, WebSocketAdapter, aggregateCandles };