@tradecanvas/chart 1.4.0 → 1.7.0

package/dist/Chart.d.ts

@@ -1,7 +1,10 @@
-import { ChartOptions, ChartType, OHLCBar, DataSeries, Theme, ThemeName, ChartEventType, ChartEvent, ChartEventMap, TauriBridgeOptions, IndicatorPlugin, IndicatorDescriptor, IndicatorOutput, ResolvedIndicatorStyle, DrawingToolType, DrawingState, DrawingStyle, DrawingPlugin, PanelPosition, TradingOrder, TradingPosition, DepthData, TradingConfig, MarketConfig, Locale, StreamConfig, ConnectionState, ConnectionInfo, TimeFrame, FeaturesConfig, ExecutionAdapter, ExecutionConfig } from '@tradecanvas/commons';
-import { RangePreset } from '@tradecanvas/core';
+import { ChartOptions, ChartType, OHLCBar, DataSeries, Theme, ThemeName, ChartEventType, ChartEvent, ChartEventMap, TauriBridgeOptions, IndicatorPlugin, IndicatorDescriptor, IndicatorOutput, ResolvedIndicatorStyle, DrawingToolType, DrawingState, DrawingStyle, DrawingOptions, DrawingOptionDefs, DrawingDescriptor, DrawingPlugin, PanelPosition, TradingOrder, TradingPosition, DepthData, TradingConfig, MarketConfig, Locale, StreamConfig, ConnectionState, ConnectionInfo, TimeFrame, TimeZoneSetting, SymbolInfo, OverlayScale, FeaturesConfig, ExecutionAdapter, ExecutionConfig, ChartTypeOptions, PriceFormatter, PriceFraction, ShapeConfig, TimeFormatter } from '@tradecanvas/commons';
+import { BidAsk, ExportColumn, RangePreset, SessionHoursConfig, DrawingPatch, DrawingOrderMove } from '@tradecanvas/core';
+import { HistoryLoader } from './HistoryPager.js';
 import { PluginManager } from './plugins/PluginManager.js';
 import { ChartPlugin } from './plugins/contracts.js';
+/** `setTimezone(EXCHANGE_TIMEZONE)` shows the time zone of the symbol's exchange. */
+export declare const EXCHANGE_TIMEZONE = "exchange";
 export declare class Chart {
     static version: string;
     private engine;
@@ -43,10 +46,27 @@ export declare class Chart {
      * the layout again doesn't drop them.
      */
     private unrestoredIndicators;
+    /** Above 0 while indicators change as a whole (a layout, an undo): no undo steps are recorded. */
+    private indicatorHistoryDepth;
+    /** Alerts of deleted drawings, put back if an undo brings the drawing back. */
+    private removedDrawingAlerts;
+    /** The zoom-area tool is waiting for its box. */
+    private zoomAreaMode;
+    /** The "+" by the price axis. */
+    private priceAxisAddButton;
     /** Display timezone, minutes east of UTC; null = the browser's. */
-    private displayTzOffset;
+    /** The time zone shown: the setting, with 'exchange' resolved to the symbol's zone. */
+    private displayTz;
+    /** What `setTimezone` was given; 'exchange' follows the symbol. */
+    private timezoneSetting;
+    /** What the feed (or host) said about the symbol on the chart. */
+    private symbolInfo;
+    /** Bumped per symbol asked about: an answer about a symbol the chart left is dropped. */
+    private symbolInfoSeq;
     private sessionBreaks;
     private sessionShading;
+    /** The session hours the host set (or the default); a symbol's own hours show over them. */
+    private hostSessionHours;
     private compareRenderer;
     private countdownInterval;
     private volumeRenderer;
@@ -70,6 +90,9 @@ export declare class Chart {
      * back on `replayStop()`. `price` is the latest live tick.
      */
     private replaySession;
+    /** During a replay in finer steps: the steps, and the series they build. */
+    private replayStepsSeries;
+    private replayCoarse;
     private undoRedoManager;
     private autoSaveScheduler;
     private animator;
@@ -78,8 +101,29 @@ export declare class Chart {
     private interactionManager;
     private crosshairHandler;
     private chartRenderer;
+    /** Settings of the chart types that build their own bars. */
+    private chartTypeOptions;
+    private mainSeriesVisible;
+    /** The visible high and low, the bid and the ask. */
+    private priceLines;
+    /** Other symbols' bars, for the indicators that compare with them. */
+    private symbolSeries;
+    /** Bars outside the symbol's regular hours shown. */
+    private extendedHours;
+    /** A replay being restarted (or the chart going): its stop is not reported. */
+    private replayRestarting;
+    /** While they are hidden: the whole series, theirs included (the data manager has the rest). */
+    private fullSeries;
+    /** Symbols asked for (`symbolSeriesRequest`) and not given yet. */
+    private requestedSymbols;
     private gridRenderer;
     private priceAxis;
+    /** The left price scale: overlays put on it, else a mirror of the price scale. */
+    private leftPriceAxis;
+    private leftScaleRequested;
+    private leftAxisWidth;
+    /** The left scale's viewport this frame; null while it is hidden. */
+    private leftViewport;
     private timeAxis;
     private options;
     private features;
@@ -89,6 +133,10 @@ export declare class Chart {
     private numberLocale;
     /** The market's price precision, when set: otherwise it follows the visible range. */
     private marketPricePrecision;
+    /** The chart's price format (`priceFormat`), or null for decimals. */
+    private priceFormatter;
+    /** A fraction format's smallest step (a 32nd), or null. */
+    private priceUnit;
     private paneTitles;
     /**
      * The `autoScale` the chart was constructed with — distinct from
@@ -98,12 +146,68 @@ export declare class Chart {
      */
     private defaultAutoScale;
     private keyboardHandler;
+    private a11y;
     private onWindowKeyDown;
     private currentSymbol;
+    /** Timeframe and adapter of the connected stream, for paging its history. */
+    private streamTimeframe;
+    /** The symbol and timeframe last told (symbolChange, timeframeChange). */
+    private announcedSymbol;
+    private announcedTimeframe;
+    private streamAdapter;
+    /** Pages older bars in as the view nears the oldest one. */
+    private history;
+    /** Whether the history loader is the connected stream's (and goes with it). */
+    private historyFromStream;
+    /** Whether the host set a loader of its own: the stream's never replaces it. */
+    private hostHistoryLoader;
+    /** Symbol and timeframe of the series the last stream snapshot loaded. */
+    private snapshotKey;
+    private historyCheckQueued;
     constructor(container: HTMLElement, options: ChartOptions & {
         plugins?: ChartPlugin[];
     });
     setData(data: DataSeries): void;
+    /**
+     * `setData`; `restoring` puts the live series back after a replay, which
+     * goes on as it was for alerts (their bars and last values stay).
+     */
+    private loadSeries;
+    /**
+     * Add older bars in front of the data — e.g. a page of history loaded as
+     * the user scrolls back. Bars at or after the first loaded bar are skipped.
+     * The same bars stay on screen. Ignored during a replay. Returns how many
+     * bars were added.
+     */
+    prependBars(bars: OHLCBar[]): number;
+    /**
+     * A stream snapshot for the series already on the chart (a reconnect): keep
+     * the older bars paged in and the view, replace the rest.
+     */
+    private mergeSnapshot;
+    /**
+     * Load older bars as the user scrolls back: `loader(before, limit)` gets the
+     * oldest loaded bar's time and returns up to `limit` older bars (an empty
+     * array once the history starts). A connected stream whose adapter has
+     * `fetchHistoryBefore` sets this up by itself. Pass null to stop.
+     */
+    setHistoryLoader(loader: HistoryLoader | null, options?: {
+        pageSize?: number;
+    }): void;
+    /** Load one page of older bars now. Resolves to the number of bars added. */
+    loadMoreHistory(): Promise<number>;
+    /** Whether older bars can still be loaded (a loader is set and the start wasn't reached). */
+    hasMoreHistory(): boolean;
+    isLoadingHistory(): boolean;
+    /**
+     * Page older bars in when less than a screen of them is left of the view —
+     * after the current update, so a page that just landed reports itself
+     * before the next one starts. Not for chart types that reshape the bars
+     * (Renko, Kagi…): a handful of bricks can stand for a whole page.
+     */
+    private checkHistory;
+    /** Page the connected stream's history through its adapter, if it can. */
+    private useStreamHistory;
     appendBar(bar: OHLCBar): void;
     /**
      * Append multiple bars at once (e.g., catch-up after reconnect).
@@ -119,9 +223,138 @@ export declare class Chart {
         time: number;
     }): void;
     setChartType(type: ChartType | (string & {})): void;
-    addIndicator(id: string, params?: Record<string, number | string | boolean>, position?: PanelPosition): string | null;
+    /**
+     * Settings of Renko, Line Break, Kagi, Point & Figure and range bars, by
+     * type: each type given replaces that type's settings (`{}` puts it back
+     * to the defaults). Values it can't use are left out.
+     */
+    setChartTypeOptions(options: ChartTypeOptions): void;
+    getChartTypeOptions(): ChartTypeOptions;
+    /**
+     * Show or hide the bars outside the symbol's regular hours
+     * (`SymbolInfo.sessions`, in its `timezone`): pre- and post-market. Hidden,
+     * they are kept aside and come back when shown again. Bars a day or longer,
+     * and symbols without hours, are left as they are.
+     */
+    setExtendedHours(show: boolean): void;
+    isExtendedHoursVisible(): boolean;
+    /** Which bar times to show, for bars like `data`'s; null: all of them. */
+    private sessionKeep;
+    /** The bars of `all` the chart shows (no state kept). */
+    private shownBars;
+    /** The bars of `all` the chart shows; while some are hidden, `all` is kept as the whole series. */
+    private regularOnly;
+    /** A new or updated bar into the whole series (while one is kept): whether the chart shows it. */
+    /** A stream bar onto the bars shown: the last one again or a new one after it; false for an older one. */
+    private placeStreamBar;
+    private takeBar;
+    /** The bars shown again after the extended hours or the symbol's hours changed. */
+    private reapplyExtendedHours;
+    /** The price lines for this frame: during a replay without the live bid and ask. */
+    private quoteLines;
+    /**
+     * The shapes the chart draws: `tagRadius` rounds its price tags, axis
+     * pills and order badges (0: square, 999: pills). Kept through theme
+     * changes.
+     */
+    setShapes(shapes: ShapeConfig): void;
+    getShapes(): ShapeConfig;
+    /** Show or hide the main series (its bars, candles or line); the rest of the chart stays. */
+    setMainSeriesVisible(visible: boolean): void;
+    isMainSeriesVisible(): boolean;
+    /** Mark the highest high and lowest low on screen with a line and a price tag. */
+    setHighLowLines(visible: boolean): void;
+    isHighLowLinesVisible(): boolean;
+    /**
+     * Mark the best bid and ask with lines and price tags (null takes them
+     * off). A connected feed whose ticks carry `bid` / `ask` keeps them up to date.
+     */
+    setBidAsk(quote: BidAsk | null): void;
+    getBidAsk(): BidAsk | null;
+    /**
+     * Add an indicator. Panel indicators get a pane of their own at `position`.
+     * `options.pane` draws it in another indicator's pane instead, on that
+     * pane's scale; a price-pane indicator computed from a pane indicator's
+     * line (`source: 'ind:<instanceId>:<key>'`) goes there by itself.
+     */
+    addIndicator(id: string, params?: Record<string, number | string | boolean>, position?: PanelPosition, options?: {
+        pane?: string;
+        scale?: OverlayScale;
+    }): string | null;
+    private addIndicatorNow;
+    /**
+     * Another symbol's bars, for the indicators that read it ('compareSymbol',
+     * 'spread'): they line them up with the chart's bars by time. Give them
+     * again after a timeframe change; null forgets them.
+     */
+    setSymbolSeries(symbol: string, bars: DataSeries | null): void;
+    /** A symbol no indicator reads any more may be asked for again later. */
+    private forgetUnreadSymbols;
+    /** The bars given for `symbol`, or null. */
+    getSymbolSeries(symbol: string): DataSeries | null;
+    /** The symbols the chart's indicators read, whether their bars are here or not. */
+    getRequiredSymbols(): string[];
+    /**
+     * Ask once for the symbol an indicator just added or changed reads, when
+     * the chart hasn't got it (not for symbols other indicators read: one
+     * whose fetch failed is asked for again only by an indicator on it).
+     */
+    private requestMissingSymbols;
+    /**
+     * Change an indicator's inputs. A source that would make it read from its
+     * own lines (through other indicators) is ignored.
+     */
     updateIndicator(instanceId: string, params: Record<string, number | string | boolean>): void;
+    private updateIndicatorNow;
+    /**
+     * The pane an indicator is drawn in, other than its own: the pane of the
+     * instance `requested`, or, for a price-pane indicator computed from a pane
+     * indicator's line, that indicator's pane. Null = the price pane (overlays)
+     * or a pane of its own (panels).
+     */
+    private paneFor;
+    /** The instance owning the pane `instanceId` is drawn in; null for the price pane. */
+    private paneHostOf;
+    /** An indicator's reference levels (RSI 30 / 70): its own, else its indicator's defaults. */
+    getIndicatorLevels(instanceId: string): number[];
+    /**
+     * Put a price-pane overlay on the left price scale (fit to its own values,
+     * the scale shows by itself) or back on the price scale. False when the
+     * indicator isn't a price-pane overlay.
+     */
+    setIndicatorScale(instanceId: string, scale: OverlayScale): boolean;
+    private setIndicatorScaleNow;
+    getIndicatorScale(instanceId: string): OverlayScale;
+    /** Show the left price scale even without overlays on it (it then mirrors the price scale). */
+    setLeftPriceScaleVisible(visible: boolean): void;
+    /** Whether the left price scale is on screen: asked for, or carrying an overlay. */
+    isLeftPriceScaleShown(): boolean;
+    /** The left price scale's range on screen, or null while it is hidden. */
+    getLeftPriceRange(): {
+        min: number;
+        max: number;
+    } | null;
+    /**
+     * The left scale's viewport for this frame: fit to the overlays on it over
+     * the visible bars (on a plain linear scale), or the price scale's when
+     * none is.
+     */
+    private computeLeftViewport;
+    /** Set an indicator's reference levels; `null` restores its indicator's defaults. */
+    setIndicatorLevels(instanceId: string, levels: readonly number[] | null): void;
+    private setIndicatorLevelsNow;
+    /**
+     * Remove an indicator, and the indicators computed from its lines with it.
+     * Others drawn in its pane keep the pane (a pane indicator takes it over)
+     * or go back to the price pane.
+     */
     removeIndicator(instanceId: string): void;
+    private removeIndicatorNow;
+    /**
+     * Remove one indicator. The first pane indicator drawn in its pane takes the
+     * pane over and the others stay in it.
+     */
+    private detachIndicator;
     /** The colours, line widths and opacity an indicator draws with (a copy), or null. */
     getIndicatorStyle(instanceId: string): ResolvedIndicatorStyle | null;
     getIndicatorOutput(instanceId: string): IndicatorOutput | null;
@@ -131,12 +364,60 @@ export declare class Chart {
     static indicators(): IndicatorDescriptor[];
     setPanelPosition(instanceId: string, position: PanelPosition): void;
     setPanelSize(instanceId: string, size: number): void;
+    /**
+     * Move an indicator to another pane: `target` is an indicator drawn there
+     * (it joins that pane, on its scale), `'new'` a pane of its own (indicators
+     * that draw in a pane), or `'price'` the price pane (overlays). Indicators
+     * drawn in its own pane stay there (one of them takes the pane over) or
+     * follow it when they read its lines. False when it can't go there.
+     */
+    moveIndicatorToPane(instanceId: string, target: string): boolean;
+    /** Whether `moveIndicatorToPane(instanceId, target)` would move it. */
+    canMoveIndicatorToPane(instanceId: string, target: string): boolean;
+    /** Where a move would put the indicator: the pane's host, `null` (its own or the price pane), or `undefined` when it can't go. */
+    private paneMoveHost;
+    private moveIndicatorToPaneNow;
+    /**
+     * Fold a pane to its header, or open it again: the pane `instanceId` is
+     * drawn in. While a pane is maximised, this puts the panes back first.
+     */
+    setPaneCollapsed(instanceId: string, collapsed: boolean): boolean;
+    /** Whether the pane `instanceId` is drawn in shows folded (folded, or another pane is maximised). */
+    isPaneCollapsed(instanceId: string): boolean;
+    /** Let one pane take the room (the others fold, the price pane keeps a strip); `null` puts them back. */
+    setMaximizedPane(instanceId: string | null): boolean;
+    getMaximizedPane(): string | null;
+    /**
+     * A pane's value scale: logarithmic (used while all its values are above 0;
+     * linear otherwise), upside down. The pane `instanceId` is drawn in.
+     */
+    setPaneScale(instanceId: string, scale: {
+        log?: boolean;
+        invert?: boolean;
+        percent?: boolean;
+    }): boolean;
+    /** The pane's value scale as set (see `setPaneScale`). */
+    getPaneScale(instanceId: string): {
+        log: boolean;
+        invert: boolean;
+        percent: boolean;
+    };
+    /** A pane's first value on screen (its own indicator's first line), the 0% of a percent scale. */
+    private paneBaseline;
+    /** Move a pane one place up (`-1`) or down (`1`) among the panes on its side. */
+    movePane(instanceId: string, delta: -1 | 1): boolean;
+    /** Whether `movePane(instanceId, delta)` would move it. */
+    canMovePane(instanceId: string, delta: -1 | 1): boolean;
+    /** The pane an indicator is drawn in: its own, or the one it shares. */
+    private paneOf;
+    private paneChange;
     /**
      * Indicator panes, in CSS pixels relative to the container: the whole pane,
      * its 20 px header (where the name is written) included.
      */
     getIndicatorPanes(): {
         instanceId: string;
+        instanceIds: string[];
         rect: {
             x: number;
             y: number;
@@ -144,6 +425,8 @@ export declare class Chart {
             height: number;
         };
     }[];
+    /** Tag each indicator line's latest value on its value axis (default on). */
+    setIndicatorValueLabelsVisible(visible: boolean): void;
     /** Write each pane's indicator name and hovered values in its header (default); off when you label panes yourself. */
     setPaneTitlesVisible(visible: boolean): void;
     /**
@@ -157,7 +440,28 @@ export declare class Chart {
      * so a bar index on screen is not an index into the data.
      */
     isTimeAligned(): boolean;
-    /** A price as the price axis writes it: the market's precision or the visible range's, in the number locale. */
+    /**
+     * A price on the market's grid: a multiple of its smallest step (`minTick`),
+     * else rounded to its precision, else to the decimals the axis shows.
+     */
+    roundPrice(price: number): number;
+    /**
+     * How prices read on the price scale and everything that prints one: a
+     * function of yours, fractions of a point (`{ denominator: 32 }` prints
+     * `101'16`), or null for decimals. Indicator panes keep their own numbers.
+     */
+    setPriceFormat(format: PriceFormatter | PriceFraction | null): void;
+    /** The chart's price format as a function (`priceFormat`), or null for decimals. */
+    getPriceFormatter(): PriceFormatter | null;
+    private applyPriceFormat;
+    /** How times read on the time axis, the crosshair and the tooltip; null for the chart's own. */
+    setTimeFormatter(formatter: TimeFormatter | null): void;
+    private applyTimeFormatter;
+    /**
+     * A price as the price axis writes it: in the chart's price format when it
+     * has one (`priceFormat`), else at the market's precision or the visible
+     * range's, in the number locale.
+     */
     formatPrice(price: number): string;
     setDrawingTool(type: DrawingToolType | null): void;
     getDrawingTool(): DrawingToolType | null;
@@ -183,6 +487,8 @@ export declare class Chart {
         type: import('@tradecanvas/commons').DrawingToolType;
         anchors: import('@tradecanvas/commons').AnchorPoint[];
         style?: Partial<DrawingStyle>;
+        /** The tool's own settings (see `getDrawingOptionDefs`); its defaults fill the rest. */
+        options?: DrawingOptions;
         visible?: boolean;
         locked?: boolean;
         meta?: Record<string, unknown>;
@@ -193,46 +499,141 @@ export declare class Chart {
      */
     autoFib(): string | null;
     removeDrawing(id: string): void;
+    /** Remove several drawings as one undo step; locked ones stay. Returns how many went. */
+    removeDrawings(ids: readonly string[]): number;
+    /** A drawing tool's name, anchors, options and style fields; null for an unknown tool. */
+    getDrawingToolDescriptor(type: DrawingToolType): DrawingDescriptor | null;
+    /** The settings a drawing tool offers beyond the shared style (levels, extend…), with defaults. */
+    getDrawingOptionDefs(type: DrawingToolType): DrawingOptionDefs;
+    /** Every option of a drawing, its tool's defaults filled in. */
+    getDrawingOptions(id: string): DrawingOptions;
+    /** Change some of a drawing's options; invalid ones are dropped. False for an unknown drawing. */
+    setDrawingOptions(id: string, options: DrawingOptions): boolean;
+    /**
+     * Change a drawing's anchors (as many as it has), style or options, as one
+     * undo step — or as part of the edit begun with `beginDrawingEdit`.
+     * Applies to locked drawings too. False for an unknown drawing or wrong anchors.
+     */
+    updateDrawing(id: string, patch: DrawingPatch): boolean;
+    /** Start an edit (a settings dialog): the `updateDrawing` calls until `endDrawingEdit` are one undo step. */
+    beginDrawingEdit(id: string): boolean;
+    /** Keep the edit as one undo step, or with `cancel` put the drawing back as it was. */
+    endDrawingEdit(id: string, options?: {
+        cancel?: boolean;
+    }): void;
+    /** Options new drawings of `type` start with; null clears them. */
+    setDrawingToolDefaults(type: DrawingToolType, options: DrawingOptions | null): void;
+    getDrawingToolDefaults(type: DrawingToolType): DrawingOptions;
     setDrawingVisible(id: string, visible: boolean): void;
     setDrawingLocked(id: string, locked: boolean): void;
+    /** Show or hide several drawings (a selection, say) as one undo step. */
+    setDrawingsVisible(ids: readonly string[], visible: boolean): void;
+    /** Lock or unlock several drawings as one undo step. */
+    setDrawingsLocked(ids: readonly string[], locked: boolean): void;
     clearDrawings(): void;
     registerDrawingTool(plugin: DrawingPlugin): void;
     undo(): boolean;
     redo(): boolean;
+    /** Select a drawing (and the rest of its group); false for one it can't (unknown, hidden). */
+    selectDrawing(id: string): boolean;
     getUndoRedoState(): {
         canUndo: boolean;
         canRedo: boolean;
     };
-    /** Ignored (stays off) when `features.drawingMagnet` is false. */
+    /**
+     * Put a change of yours in the chart's undo history, with its drawings and
+     * indicators: undo (Ctrl/Cmd+Z) calls `undo`, redo calls `redo`. Call it
+     * after making the change. Changes about the same `subject` close together
+     * merge into one step (a colour dragged across a picker). Ignored when
+     * `features.drawingUndoRedo` is off.
+     */
+    recordUndo(step: {
+        undo: () => void;
+        redo: () => void;
+        subject?: string;
+    }): void;
+    /** The weak magnet on or off. Ignored (stays off) when `features.drawingMagnet` is false. */
     setDrawingMagnet(enabled: boolean): void;
+    /** Whether a magnet (weak or strong) is on. */
     getDrawingMagnet(): boolean;
+    /**
+     * Snap new anchors to the bar's open, high, low or close: 'weak' when the
+     * pointer is near one, 'strong' always. Stays off when
+     * `features.drawingMagnet` is false.
+     */
+    setDrawingMagnetMode(mode: 'off' | 'weak' | 'strong'): void;
+    getDrawingMagnetMode(): 'off' | 'weak' | 'strong';
+    /** The price and bar time at a right-click, as far as its area has them. */
+    private contextAt;
+    /** Show or hide the "+" by the price axis (`features.priceAxisAddButton`). */
+    setPriceAxisAddButton(visible: boolean): void;
+    /**
+     * The eraser: while on, clicking a drawing removes it (each one undoable).
+     * Picking a drawing tool or pressing Escape turns it off. `toolModeChange`
+     * reports `{ eraser }`.
+     */
+    setEraserMode(on: boolean): void;
+    isEraserMode(): boolean;
+    /**
+     * The zoom-area tool: the next drag draws a box and the chart zooms to its
+     * bars; then it turns itself off. `toolModeChange` reports `{ zoomArea }`.
+     */
+    setZoomAreaMode(on: boolean): void;
+    isZoomAreaMode(): boolean;
+    /** Zoom to the bars under a box dragged in zoom-area mode. */
+    private zoomToBox;
     lockAllDrawings(): void;
     unlockAllDrawings(): void;
     hideAllDrawings(): void;
     showAllDrawings(): void;
     duplicateDrawing(id?: string): string | null;
     /** Does nothing when `features.dataExport` is false. */
-    exportVisibleData(format?: 'csv' | 'json', filename?: string): void;
-    /** Does nothing when `features.dataExport` is false. */
-    exportAllData(format?: 'csv' | 'json', filename?: string): void;
+    /**
+     * Download the bars on screen as CSV or JSON, each indicator line in a
+     * column of its own (`indicators: false` leaves them out). Does nothing
+     * when `features.dataExport` is false.
+     */
+    exportVisibleData(format?: 'csv' | 'json', filename?: string, options?: {
+        indicators?: boolean;
+    }): void;
+    /** `exportVisibleData` for every bar loaded. Does nothing when `features.dataExport` is false. */
+    exportAllData(format?: 'csv' | 'json', filename?: string, options?: {
+        indicators?: boolean;
+    }): void;
+    /**
+     * The bars and their indicator lines, one column per line named as the
+     * legend names it ("SMA 20", "MACD 12 26 9 Signal"): every bar loaded, or
+     * those on screen (`range: 'visible'`).
+     */
+    getExportData(options?: {
+        range?: 'all' | 'visible';
+        indicators?: boolean;
+    }): {
+        bars: OHLCBar[];
+        columns: ExportColumn[];
+    };
+    /** `getExportData` as CSV or JSON text. */
+    getExportText(format?: 'csv' | 'json', options?: {
+        range?: 'all' | 'visible';
+        indicators?: boolean;
+    }): string;
+    private download;
     setAutoSave(key: string, delayMs?: number): void;
     disableAutoSave(): void;
     private scheduleAutoSave;
+    /** Something a saved layout holds changed: auto-save it, and say so. */
+    private markStateChanged;
+    private announceStateChange;
     getAvailableIndicators(): IndicatorDescriptor[];
     getIndicatorInputs(id: string): {
         id: string;
         params: Record<string, unknown>;
     } | null;
     /** Get all active indicator instances with their current params */
-    getActiveIndicators(): {
-        instanceId: string;
-        id: string;
-        params: Record<string, unknown>;
-        descriptor: IndicatorDescriptor;
-        visible: boolean;
-    }[];
+    getActiveIndicators(): import('@tradecanvas/core').ActiveIndicatorInfo[];
     /** Show or hide an indicator without removing it. */
     setIndicatorVisible(instanceId: string, visible: boolean): void;
+    private setIndicatorVisibleNow;
     /** Get current config for a specific indicator instance */
     getIndicatorConfig(instanceId: string): {
         id: string;
@@ -244,6 +645,7 @@ export declare class Chart {
         lineWidths?: number[];
         opacity?: number;
     }): void;
+    private updateIndicatorStyleNow;
     setOrders(orders: TradingOrder[]): void;
     /**
      * Begin placing a draggable bracket order (entry + stop-loss + take-profit).
@@ -273,17 +675,50 @@ export declare class Chart {
      */
     placeOrderIntent(intent: import('@tradecanvas/commons').OrderPlaceIntent): void;
     setPositions(positions: TradingPosition[]): void;
+    /** The working orders on the chart (`setOrders`, or the execution adapter's). */
+    getOrders(): TradingOrder[];
+    /** The open positions on the chart (`setPositions`, or the execution adapter's). */
+    getPositions(): TradingPosition[];
+    /** Fills marked on the chart, oldest first: the execution adapter's, or `addFill`'s. */
+    getFills(): import('@tradecanvas/commons').FillEvent[];
+    /** The P&L the fills realised since the last `clearFills`, all of them (the marks keep the latest 1000). */
+    getRealisedPnl(): number;
+    /** Mark a fill on the chart (without an execution adapter, a host reports its own). */
+    addFill(fill: import('@tradecanvas/commons').FillEvent): void;
+    clearFills(): void;
+    /**
+     * Ask for an order to be cancelled: emits `orderCancel`, which an execution
+     * adapter carries out (as the × on the order's line does).
+     */
+    cancelOrderIntent(orderId: string): void;
+    /** Ask for a position to be closed: emits `positionClose`. */
+    closePositionIntent(positionId: string): void;
+    /** Ask for a position to be reversed (closed, then the same size the other way): emits `positionReverse`. */
+    reversePositionIntent(positionId: string): void;
+    /** Ask for a position's stop-loss or take-profit to change (null removes it): emits `positionModify`. */
+    modifyPositionIntent(intent: import('@tradecanvas/commons').PositionModifyIntent): void;
     setDepthData(depth: DepthData | null): void;
     setCurrentPrice(price: number, _pulseColor?: string): void;
+    /** Whether a paper account trades on the replay (it takes a mark price) rather than on the live price. */
+    private replayTrades;
+    /** The orders and the alerts follow a live price (a paper account in a replay follows the replay). */
+    private followLivePrice;
+    /**
+     * Alerts against a live price, and against the indicator lines they watch,
+     * all as of the same moment (a line crossing another compares like with
+     * like). During a replay they keep watching the live market: the bars are
+     * the live ones, and indicator lines — computed on the replayed bars — wait.
+     */
+    private checkAlerts;
     /**
-     * Feed the latest indicator-line values to any indicator-channel alerts.
+     * The latest values of the indicator lines alerts watch or compare with.
      * Channel format: `<instanceId>:<key>`; instanceIds are `tc_<id>_<n>` and
      * built-in keys are colon-free, so the first colon splits them. Values come
      * from the recalculated series, so indicator alerts evaluate at bar cadence
      * (the live intrabar tick doesn't repaint closed-bar indicator values).
      * Cheap — only walks alerts whose channel isn't `'price'`, usually none.
      */
-    private feedIndicatorAlerts;
+    private collectIndicatorValues;
     setTradingConfig(config: Partial<TradingConfig>): void;
     /**
      * Connect to a real-time data source.
@@ -298,6 +733,8 @@ export declare class Chart {
      * });
      */
     connect(config: StreamConfig): Promise<void>;
+    /** The stream's symbol and timeframe, told when they change. */
+    private setStreamTarget;
     /**
      * Switch symbol or timeframe on an active stream without full reconnect.
      */
@@ -371,6 +808,8 @@ export declare class Chart {
      */
     setVisibleRangePreset(preset: RangePreset): void;
     scrollToEnd(): void;
+    /** Scroll by `bars` bars: later for a positive count, earlier for a negative one. */
+    scrollBars(bars: number): void;
     /**
      * Show the bars between two timestamps edge to edge. Times past either end
      * of the data are allowed (they map into the empty future / past).
@@ -455,10 +894,28 @@ export declare class Chart {
     isPeriodLevelsVisible(): boolean;
     setPeriodLevelsPeriod(period: import('@tradecanvas/core').LevelPeriod): void;
     /**
-     * Set the timezone for time-axis labels and the crosshair time pill.
-     * `null` = browser-local; a number = fixed UTC offset in minutes (e.g. -300
-     * for EST, 330 for IST).
+     * The timezone for the time axis, crosshair, tooltip, day breaks and range
+     * presets: an IANA zone (`'America/New_York'`, daylight saving included), a
+     * fixed offset in minutes east of UTC (`-300`, `330`), or null for the
+     * browser's. Throws a RangeError for a zone the browser doesn't know.
      */
+    setTimezone(tz: TimeZoneSetting): void;
+    /** What `setTimezone` was given — `'exchange'` included. */
+    getTimezone(): TimeZoneSetting;
+    /** The zone the chart shows: `'exchange'` resolved to the symbol's zone (UTC when unknown). */
+    getEffectiveTimezone(): TimeZoneSetting;
+    private applyTimezone;
+    /**
+     * What is known about the symbol on the chart — usually from the stream's
+     * adapter (`resolveSymbol`), which a connected chart asks by itself. Its
+     * price precision applies unless `setMarket` set one; its zone backs
+     * `setTimezone('exchange')`; its hours feed the session shading.
+     */
+    setSymbolInfo(info: SymbolInfo | null): void;
+    getSymbolInfo(): SymbolInfo | null;
+    /** Ask the stream's adapter about `symbol`, if it can tell; a late answer about another symbol is dropped. */
+    private resolveStreamSymbol;
+    /** `setTimezone` with a fixed offset in minutes east of UTC, or null for the browser's zone. */
     setTimezoneOffset(minutes: number | null): void;
     setPivotMarkersVisible(visible: boolean): void;
     isPivotMarkersVisible(): boolean;
@@ -475,7 +932,7 @@ export declare class Chart {
      * `windows` for a split session — a market with a midday recess (e.g. SET's
      * 10:00–12:30 and 14:30–16:30) — so the lunch break dims like pre-/post-market.
      */
-    setSessionShadingConfig(config: Partial<import('@tradecanvas/core').SessionHoursConfig>): void;
+    setSessionShadingConfig(config: Partial<SessionHoursConfig>): void;
     setTooltipVisible(visible: boolean): void;
     setLegend(config: Partial<import('@tradecanvas/core').LegendConfig>): void;
     setSymbolName(symbol: string): void;
@@ -489,11 +946,61 @@ export declare class Chart {
     copyScreenshot(): Promise<boolean>;
     screenshotDataURL(): string | null;
     screenshotBlob(): Promise<Blob | null>;
-    addAlert(price: number, condition?: import('@tradecanvas/core').AlertCondition, message?: string, channel?: string, label?: string): string | null;
+    /**
+     * Add an alert on `channel` (`'price'`, or an indicator line
+     * `'<instanceId>:<key>'`) at `price`. `options` compare with another line
+     * instead (`target`), measure a move (`movesUp` / `movesDown` with
+     * `percent` and `bars`), look only at closed bars (`onBarClose`), or end it
+     * (`expiresAt`). Throws a RangeError for options that don't fit together.
+     */
+    addAlert(price: number, condition?: import('@tradecanvas/core').AlertCondition, message?: string, channel?: string, label?: string, options?: import('@tradecanvas/core').AlertOptions): string | null;
     removeAlert(id: string): void;
+    /** Ids of the selected drawings, the one clicked last first. */
+    getSelectedDrawingIds(): string[];
+    /** Draw a drawing on top of the others, under them, or one step up or down. False when already there. */
+    moveDrawing(id: string, to: DrawingOrderMove): boolean;
+    /** Group drawings (two or more): they are then selected, hidden and locked together. Returns the group id. */
+    groupDrawings(ids: readonly string[], name?: string): string | null;
+    ungroupDrawings(groupId: string): boolean;
+    renameDrawingGroup(groupId: string, name: string): boolean;
+    setDrawingGroupVisible(groupId: string, visible: boolean): boolean;
+    setDrawingGroupLocked(groupId: string, locked: boolean): boolean;
+    /** Every drawing group, its drawings bottom to top. */
+    getDrawingGroups(): {
+        id: string;
+        name: string;
+        ids: string[];
+    }[];
+    private afterDrawingChange;
+    /** Whether a drawing has lines an alert can cross (trend lines, rays, horizontals, channels). */
+    canAddDrawingAlert(drawingId: string): boolean;
+    /**
+     * Where a drawing's lines are at the latest bar, as drawn on the chart's
+     * scale; null when it has none there (a trend line that ends before it).
+     */
+    private drawingLevelsNow;
+    /**
+     * A drawing's alerts go with it, and come back with it when an undo
+     * brings the drawing back.
+     */
+    private followDrawingAlerts;
+    /** Remove alerts on drawings no longer on the chart (drawings replaced or cleared). */
+    private dropOrphanDrawingAlerts;
+    /**
+     * Alert when the price crosses a drawing's line(s): a trend line where it
+     * is at the latest bar, any line of a channel. Removed with the drawing.
+     * Null when the drawing has no line to cross.
+     */
+    addDrawingAlert(drawingId: string, options?: {
+        condition?: 'crossing' | 'crossingUp' | 'crossingDown';
+        message?: string;
+        repeating?: boolean;
+        label?: string;
+    }): string | null;
     getAlerts(): import('@tradecanvas/core').PriceAlert[];
     clearAlerts(): void;
     saveAlerts(key: string): void;
+    /** Load alerts saved with `saveAlerts`. Alerts on drawings that aren't on the chart are dropped. */
     loadAlerts(key: string): void;
     addSignalMarker(marker: Omit<import('@tradecanvas/commons').SignalMarker, 'id'> & {
         id?: string;
@@ -518,8 +1025,32 @@ export declare class Chart {
      * aside (orders still track the live price), the price line shows the
      * replayed close, and auto-scale refits every step. `replayStop()` brings
      * back the live series, including everything that arrived meanwhile.
+     *
+     * With `steps` (finer bars), each step grows the forming bar from them.
+     * A connected execution adapter that takes a mark price (a paper one)
+     * trades on the replayed price and time.
      */
     replayStart(config?: Partial<import('@tradecanvas/core').ReplayConfig>): void;
+    /** Jump the replay to show the bars (or finer steps) that opened before `time`. */
+    replaySeekToTime(time: number): void;
+    /** A replay step's price to an adapter that takes a mark (a paper account), and to the orders on the chart. */
+    private feedReplayPrice;
+    /** A paper account trading on the replay goes back to the live price (the orders too), and its fills to the clock. */
+    private returnMarkToLive;
+    /**
+     * A paper account trades on the replayed prices and times, forward only:
+     * it gets every step past the latest time it has seen (a jump ahead passes
+     * them all, a long one in chunks), and nothing after a seek back or a
+     * restart from an earlier bar until the replay is past that time again.
+     */
+    private feedReplaySteps;
+    /**
+     * The bar of the chart's series the replay is on (the forming one), or -1
+     * without a replay.
+     */
+    getReplayBarIndex(): number;
+    /** Jump the replay to the end of bar `barIndex` of the chart's series (a click on it). */
+    replaySeekToBar(barIndex: number): void;
     replayPause(): void;
     replayResume(): void;
     /** End the replay and return to the live series (with updates that arrived meanwhile). */
@@ -545,6 +1076,44 @@ export declare class Chart {
     };
     /** Everything `loadState` restores: chart type, theme, drawings, indicators, alerts. */
     private captureSnapshot;
+    /**
+     * Put `list` in place of the chart's indicators (a layout, a template, an
+     * undo), with their panes as they were: size, order, fold, maximise.
+     * `keepIds` keeps each instance's id (an undo): the indicators still alike
+     * are changed in place, not taken down and put back. Otherwise the ids are
+     * new and the map says old → new.
+     */
+    private restoreIndicators;
+    /** An indicator's style, visibility and levels as `ind` has them, changing only what differs. */
+    private restoreLooks;
+    /** The panes as they were: size first (it opens a fold), then fold, order, maximise. */
+    private restorePanes;
+    /**
+     * The chart's indicators as a layout or a template keeps them: inputs,
+     * style, levels, scale and panes (shared, size, order, fold, maximise).
+     */
+    getIndicatorSetup(): import('@tradecanvas/core').SnapshotIndicator[];
+    /**
+     * Put a set of indicators (from `getIndicatorSetup`, a template) in place
+     * of the chart's, as one undo step.
+     */
+    applyIndicatorSetup(list: readonly SnapshotIndicator[]): void;
+    /**
+     * Alerts on the lines of indicators that went (`before`: id → kind) move to
+     * the one new indicator of the same kind (`added`), when there is just one;
+     * others stay as they are, as alerts on a removed indicator do.
+     */
+    private followIndicatorAlerts;
+    /** Run `change` without recording undo steps for the indicators it changes. */
+    private withoutIndicatorHistory;
+    /**
+     * Run an indicator change as one undo step (the indicators before and
+     * after). Quick changes to the same indicator (a colour dragged, a period
+     * typed) merge into one step.
+     */
+    private recordIndicators;
+    /** Undo or redo an indicator step: the indicators as they were, under their own ids. */
+    private applyIndicatorStep;
     saveState(key?: string): string | null;
     loadState(json: string): void;
     loadStateFromStorage(key: string): boolean;
@@ -559,6 +1128,8 @@ export declare class Chart {
     setNumberLocale(locale: string): void;
     getNumberLocale(): string;
     setMarket(config: MarketConfig): void;
+    /** Prices show `precision` decimals everywhere; null goes back to fitting the price range. */
+    private applyPricePrecision;
     getMarket(): MarketConfig | null;
     setPriceLimits(referencePrice: number): void;
     /** Get the resolved feature configuration */
@@ -593,6 +1164,14 @@ export declare class Chart {
     private applyDataToViewport;
     /** Full update: resolve layout, update viewport, sync context, request render. */
     private updateViewportAndRender;
+    /**
+     * Fit the data to the plot, then size both price scales to their labels. A
+     * scale that changes width changes the plot, so the data is fit again —
+     * before anything reads the layout for this frame.
+     */
+    private fitDataAndAxes;
+    /** Size the left scale to its widest label; true when the layout changed. */
+    private fitLeftAxisWidth;
     /**
      * Size the price axis to its widest label (tick labels, last-price tag,
      * crosshair pill), as an auto-width scale — so a sub-cent
@@ -614,9 +1193,13 @@ export declare class Chart {
     /** Cache container size for 500ms to avoid layout thrashing on rapid calls */
     private cachedContainerSize;
     private buildPanelRenderInfos;
+    /** Where the time axis starts: below the main chart and every pane under it. */
+    private timeAxisTop;
     private syncRenderContext;
     /** Draw registered overlay plugins for a layer (called by the engine). */
     private drawOverlayPlugins;
     private buildPriceLimits;
 }
+type SnapshotIndicator = import('@tradecanvas/core').SnapshotIndicator;
+export {};
 //# sourceMappingURL=Chart.d.ts.map