openalgo-charts 2.5.7 → 2.5.9

package/dist/draw/index.d.ts

@@ -1,9 +1,10 @@
-import { AlertDrawingValue, AlertDrawingLevel, PrimitiveRenderContext, Bar, PriceScaleId, IndicatorApi, IPrimitive, DataLayer, PlotRect, AlertDrawingInfo, PrimitiveHost, ZOrder, PrimitiveHit } from 'openalgo-charts';
+import { AlertDrawingValue, AlertDrawingLevel, PrimitiveRenderContext, Bar, IPrimitive, DataLayer, PlotRect, IndicatorApi, SeriesApi, PriceScaleId, AlertDrawingInfo, PrimitiveHost, ZOrder, PrimitiveHit } from 'openalgo-charts';
 
 /**
  * The per-tool settings schema: what a host may show in a drawing's settings
  * dialog, expressed as dot paths into the drawing (`style.color`,
- * `text.fontSize`, `props.foo`, `zIndex`, `space`) with a control kind and a label.
+ * `text.fontSize`, `props.foo`, `intervals.from`, `zIndex`, `space`) with a
+ * control kind and a label.
  *
  * The rule the whole module exists for: a tool declares only fields its `draw`
  * actually reads. A schema is not a wish list. A host renders exactly what is
@@ -14,14 +15,19 @@ import { AlertDrawingValue, AlertDrawingLevel, PrimitiveRenderContext, Bar, Pric
  * lives in tools.ts so this file has no import that could loop back here.
  */
 
-type FieldKind = 'color' | 'number' | 'select' | 'lineStyle' | 'boolean' | 'text' | 'opacity' | 'levels';
+/**
+ * The control a field wants. `interval` is a chart interval code, which the
+ * host offers from its own interval list (the engine has none), with an
+ * empty choice for no limit.
+ */
+type FieldKind = 'color' | 'number' | 'select' | 'lineStyle' | 'boolean' | 'text' | 'opacity' | 'levels' | 'interval';
 /** The section a host groups a field under. */
-type FieldGroup = 'line' | 'fill' | 'text' | 'levels' | 'behavior';
+type FieldGroup = 'line' | 'fill' | 'text' | 'levels' | 'behavior' | 'visibility';
 interface SettingsField {
     /**
-     * Dot path into the drawing. Two segments under `style`, `text` or `props`
-     * (`style.lineWidth`), or one of the top-level fields `locked`, `visible`,
-     * `zIndex`, `space`.
+     * Dot path into the drawing. Two segments under `style`, `text`, `props`
+     * or `intervals` (`style.lineWidth`, `intervals.to`), or one of the
+     * top-level fields `locked`, `visible`, `zIndex`, `space`.
      */
     path: string;
     label: string;
@@ -91,6 +97,15 @@ declare const EXTEND_FIELDS: readonly SettingsField[];
  * keeps its place and only stops (or starts) following the bars.
  */
 declare const SPACE_FIELD: SettingsField;
+/**
+ * The intervals a drawing is shown on (`Drawing.intervals`), as two interval
+ * codes, each end included and either one left empty for no limit. No tool
+ * declares them, since the engine cannot list a host's intervals: a host that
+ * offers visibility per interval adds them to a tool's schema with
+ * `composeSettings`, and `applyDrawingSettings` writes the pair as the patch's
+ * `intervals`, with both ends cleared meaning every interval.
+ */
+declare const INTERVAL_FIELDS: readonly SettingsField[];
 declare const SHOW_LABELS_FIELD: SettingsField;
 declare const LEVEL_FIELDS: readonly SettingsField[];
 /**
@@ -140,7 +155,9 @@ declare function coerceSettingValue(field: SettingsField, raw: unknown): unknown
  * partial a controller's `update` accepts. Bags come back whole
  * (`style: { ...d.style, color }`), so it does not matter whether the
  * controller merges or replaces them. A value of `undefined` removes the key,
- * which is how a host offers "reset to default".
+ * which is how a host offers "reset to default". The `intervals` pair comes
+ * back whole as well, as the range to replace the drawing's; with neither end
+ * left it is `{}`, which a controller takes as no range, every interval.
  *
  * With a `schema`, each value is coerced to its field's kind and any path the
  * schema does not declare is dropped: a host can hand over its form state as
@@ -172,6 +189,14 @@ declare function applyDrawingSettings(d: Drawing, patch: Record<string, unknown>
  * their own so a time or a price never has to mean a pixel. The field is
  * optional and additive, which is why the document stays version 2: a save
  * with no viewport drawing is byte for byte what it was.
+ *
+ * Version 3 added one field, {@link Drawing.intervals}: the range of chart
+ * intervals a drawing is shown on. A version 2 document is a valid version 3
+ * one and loads unchanged, and a document is written as version 3 only when a
+ * drawing in it carries a range, so a save without one is still version 2.
+ * The version is raised for a range because an earlier build would not keep
+ * it: its migration drops the field, and the drawing would show on every
+ * interval there and lose its range on the next save.
  */
 
 /** One anchor, in data space. */
@@ -328,6 +353,19 @@ interface DrawingPolicy {
     /** `false`: left out of the object inventory (`ChartObjects`) and every panel built on it. */
     listed?: boolean;
 }
+/**
+ * The chart intervals a drawing is shown on, both ends included, as interval
+ * codes the chart's data context names (`'1m'`, `'1h'`, `'D'`, or a code the
+ * host registered). An absent end is no limit on that side, so `{ to: '1h' }`
+ * shows the drawing up to hourly bars. Intervals compare by bar length, so the
+ * two ends may be written either way round. See `drawingShownOnInterval`.
+ */
+interface DrawingIntervalRange {
+    /** The shortest interval the drawing is shown on. */
+    from?: string;
+    /** The longest interval the drawing is shown on. */
+    to?: string;
+}
 interface Drawing {
     id: string;
     /** Registered tool id. */
@@ -361,6 +399,13 @@ interface Drawing {
     policy?: DrawingPolicy;
     /** Default true. */
     visible?: boolean;
+    /**
+     * The chart intervals the drawing is shown on. Absent means every interval.
+     * On an interval outside the range the drawing is kept and saved but not
+     * on the chart: it is not painted, hit-tested, boxed or erased there, and
+     * the object inventory marks it. `visible` stays the user's own switch.
+     */
+    intervals?: DrawingIntervalRange;
     /**
      * Paint order. Below zero paints under the series, at or above zero paints
      * over it. Ties break by array order, so two drawings at 0 paint in the
@@ -406,6 +451,11 @@ type DrawingInput = Omit<Drawing, 'id' | 'zIndex' | 'createdAt'> & {
 type DrawingPatch = Partial<Pick<Drawing, 'points' | 'style' | 'text' | 'props' | 'locked' | 'visible' | 'zIndex' | 'policy' | 'space' | 'viewportPoints'>> & {
     /** A series-band entry to paint directly above, or null to leave the series band. */
     stackAbove?: string | null;
+    /**
+     * The intervals to show the drawing on, replacing any range it had, or
+     * null (or a range with neither end) to show it on every interval.
+     */
+    intervals?: DrawingIntervalRange | null;
 };
 /**
  * What `DrawingController.placeInStack` puts a drawing next to: another
@@ -416,20 +466,29 @@ type DrawingStackTarget = {
 } | {
     entry: string;
 };
-/** The persisted shape's version; bumped when {@link Drawing} changes. */
-declare const DRAWING_STATE_VERSION = 2;
 /**
- * What `toJSON` returns and `ChartState.drawings` carries. Versioned so a 1.9.x
- * save (a bare `Drawing[]`) is recognisable and upgraded rather than misread.
+ * The newest document version this build reads and writes; bumped when
+ * {@link Drawing} changes in a way an earlier build would lose. A document is
+ * written as the lowest version that holds it (see {@link DrawingsDocument}).
  */
+declare const DRAWING_STATE_VERSION = 3;
 /** A named set of drawing ids. A drawing belongs to at most one group. */
 interface DrawingGroup {
     id: string;
     name: string;
     members: string[];
 }
+/**
+ * What `toJSON` returns and `ChartState.drawings` carries. Versioned so a 1.9.x
+ * save (a bare `Drawing[]`) is recognisable and upgraded rather than misread.
+ */
 interface DrawingsDocument {
-    version: 2;
+    /**
+     * 3 when a drawing carries an interval range, else 2: the lowest version
+     * that holds the content, so an earlier build reads a document without a
+     * range exactly as it wrote one.
+     */
+    version: 2 | 3;
     drawings: Drawing[];
     groups?: DrawingGroup[];
 }
@@ -692,9 +751,12 @@ declare function fixedRangeVolumeProfileAnalysis(bars: readonly Bar[], fromTime:
  */
 declare const DRAWING_CLIPBOARD_KEY = "openalgo-charts/drawings";
 /**
- * Payload format version. Tracks the model version, since the body *is* a
- * drawings document: version 1 carried 1.9.x drawings, version 2 carries the
- * split text and levelled fibs.
+ * The newest payload version this build reads. Tracks the model version, since
+ * the body *is* a drawings document: version 1 carried 1.9.x drawings,
+ * version 2 carries the split text and levelled fibs, and version 3 adds the
+ * interval range a drawing is shown on. A payload is written as the lowest
+ * version that holds it, so a copy with no range still pastes into a build
+ * that reads only version 2, which refuses anything newer.
  */
 declare const DRAWING_CLIPBOARD_VERSION: number;
 /** The async slice of `navigator.clipboard` this module uses. */
@@ -780,46 +842,12 @@ declare class DrawingClipboard {
     read(): Promise<Omit<Drawing, 'id'>[] | null>;
 }
 
-/** Where a study's price input is picked and anchored: a pane, and a scale on it. */
-interface StudyInputTarget {
-    paneIndex: number;
-    priceScaleId: PriceScaleId;
-}
-/**
- * One anchor move as an undo step, walked by the drawing history or by the
- * host's timeline it was handed to (`DrawingController.delegateInputAnchorSteps`).
- * Each call writes the other side's point, and is false, writing nothing, once
- * the study no longer holds the point it starts from.
- */
-interface InputAnchorStep {
-    undo(): boolean;
-    redo(): boolean;
-}
-/**
- * The pane and scale a study's `price` input is picked on and anchored to,
- * or null when that cannot be told. An explicit `pick` target with both
- * halves is used as given. Otherwise the study's own plots decide: the price
- * belongs where they are drawn, which must be one scale on one pane (and
- * inside any half the descriptor did name), since a price read off the wrong
- * scale is a different number.
- */
-declare function studyInputTarget(chart: {
-    panes?(): readonly unknown[];
-}, study: IndicatorApi, key: string): StudyInputTarget | null;
-
 /**
- * Drawing controller: the interaction and persistence layer over
- * `DrawingLayer`. It is **headless**: no DOM, no toolbar. A host sets the
- * active tool (from its own button, a shortcut, a command palette) and the
- * controller runs placement, selection, dragging, undo, and serialisation.
- *
- * It listens on the chart's event bus (`click`, `crosshair:move`, `drag`,
- * `drag:end`) rather than the single-slot `subscribeClick`/`subscribeDrag`
- * callbacks, so a host keeps using those for its own order lines.
- *
- * Selection is a list. Every method that edits takes the whole list into one
- * undo entry, so a multi-drag, a batch delete or a paste of ten shapes is one
- * Ctrl+Z, which is what the hand that did it expects.
+ * The public shapes of the drawing controller: the slice of the chart it
+ * drives, its options, and the events and edit options its methods take.
+ * Kept apart from the controller so the class reads as behaviour, and so a
+ * module that needs one of these (the gestures read the gesture switches)
+ * names it without importing the controller itself.
  */
 
 /**
@@ -903,6 +931,19 @@ interface DrawingChartHost {
      * puts the price pane below its studies; without it the price pane is slot 0.
      */
     primaryPaneIndex?(): number;
+    /**
+     * Optional, all three, for the magnet: the price series' bars, the studies
+     * and a series' style. The chart reports no bar while a drawing is in hand,
+     * so a handle or a shape snaps against `primaryBars`; a study pane snaps
+     * to the values of the studies plotted on it, skipping a hidden plot. A
+     * host without them snaps placements on the price pane only.
+     */
+    primaryBars?(): readonly Bar[];
+    indicators?(): readonly IndicatorApi[];
+    seriesStyle?(series: SeriesApi): {
+        readonly visible?: boolean;
+        readonly color?: string;
+    } | null;
     /**
      * Optional, both: a pane's series band, back to front, and the call that
      * paints a layer directly above one of its entries. Without them no drawing
@@ -911,6 +952,20 @@ interface DrawingChartHost {
      */
     seriesStack?(paneIndex: number): readonly string[];
     setPrimitiveStackAbove?(primitive: IPrimitive, above: string | null): boolean;
+    /**
+     * Optional: the host's data context, whose `interval` decides which
+     * drawings with an interval range are shown (`Drawing.intervals`). Read
+     * when the controller is built and on every `data:context`, whose payload
+     * is the context itself; a host without it that emits `data:context` is
+     * followed through the payload alone. With no interval every drawing shows.
+     * The instrument is declared too, as the chart's context carries it, so one
+     * host object also satisfies `DrawingLinkChart`.
+     */
+    getDataContext?(): {
+        readonly symbol?: string;
+        readonly exchange?: string;
+        readonly interval?: string;
+    } | undefined;
 }
 interface DrawingControllerOptions {
     /**
@@ -960,6 +1015,46 @@ interface DrawingControllerOptions {
      * in settings and picked with `Chart.beginPick('point')`.
      */
     inputAnchors?: boolean;
+    /**
+     * The pointer gestures a held modifier key starts, each on unless set to
+     * false here, for a host whose own chart gestures already use that key.
+     * `setOptions` merges it flag by flag.
+     */
+    gestures?: DrawingGestureOptions;
+}
+/**
+ * The modifier gestures `DrawingControllerOptions.gestures` turns off. Ctrl
+ * means Cmd as well, for macOS. None of them is a key chord, so none can
+ * shadow one of `matchDrawingShortcut` or `keyToDrawingAction`.
+ */
+interface DrawingGestureOptions {
+    /**
+     * Ctrl held while placing an anchor or dragging a handle or a shape: the
+     * strong magnet for as long as it is held, whatever `magnet` is set to.
+     */
+    snapModifier?: boolean;
+    /**
+     * Shift+click on empty chart space, with no tool armed: a ruler from the
+     * click to the pointer, gone on the next click or `cancel()`. A preview,
+     * never a drawing: not saved, not an undo step, never linked.
+     */
+    measure?: boolean;
+    /**
+     * Ctrl plus a drag on empty chart space, with no tool armed: a box that
+     * selects every drawing whose geometry it touches, as a click there would
+     * find it, leaving out drawings that are hidden, locked or unselectable.
+     * Shift held as well adds them to the selection. While Ctrl is held over
+     * empty space the chart is in placement mode, so the press is not a pan.
+     */
+    boxSelect?: boolean;
+    /**
+     * Alt (Option) plus a drag on a drawing's body: the drawing stays where it
+     * is and a copy of it moves instead, as one undo step. The whole movable
+     * selection is copied, as a plain drag would move it, and each copy is the
+     * user's own drawing, with no policy and no link lineage. A copy waits for
+     * the pointer to travel three pixels, so a jitter leaves none behind.
+     */
+    dragCopy?: boolean;
 }
 /** How `DrawingController.setTool` arms a tool. */
 interface DrawingPlacementOptions {
@@ -1018,10 +1113,57 @@ interface DrawingEditOptions {
      */
     force?: boolean;
 }
+
+/** Where a study's price input is picked and anchored: a pane, and a scale on it. */
+interface StudyInputTarget {
+    paneIndex: number;
+    priceScaleId: PriceScaleId;
+}
+/**
+ * One anchor move as an undo step, walked by the drawing history or by the
+ * host's timeline it was handed to (`DrawingController.delegateInputAnchorSteps`).
+ * Each call writes the other side's point, and is false, writing nothing, once
+ * the study no longer holds the point it starts from.
+ */
+interface InputAnchorStep {
+    undo(): boolean;
+    redo(): boolean;
+}
+/**
+ * The pane and scale a study's `price` input is picked on and anchored to,
+ * or null when that cannot be told. An explicit `pick` target with both
+ * halves is used as given. Otherwise the study's own plots decide: the price
+ * belongs where they are drawn, which must be one scale on one pane (and
+ * inside any half the descriptor did name), since a price read off the wrong
+ * scale is a different number.
+ */
+declare function studyInputTarget(chart: {
+    panes?(): readonly unknown[];
+}, study: IndicatorApi, key: string): StudyInputTarget | null;
+
+/**
+ * Drawing controller: the interaction and persistence layer over
+ * `DrawingLayer`. It is **headless**: no DOM, no toolbar. A host sets the
+ * active tool (from its own button, a shortcut, a command palette) and the
+ * controller runs placement, selection, dragging, undo, and serialisation.
+ *
+ * It listens on the chart's event bus (`click`, `crosshair:move`, `drag`,
+ * `drag:end`) rather than the single-slot `subscribeClick`/`subscribeDrag`
+ * callbacks, so a host keeps using those for its own order lines.
+ *
+ * Selection is a list. Every method that edits takes the whole list into one
+ * undo entry, so a multi-drag, a batch delete or a paste of ten shapes is one
+ * Ctrl+Z, which is what the hand that did it expects.
+ */
+
 declare class DrawingController {
     private readonly _chart;
     private _opts;
     private readonly _clipboard;
+    /** Every conversion between data space and the screen. */
+    private readonly _screen;
+    /** The gestures that make no drawing: the temporary measure, box select and the eraser. */
+    private readonly _gestures;
     private readonly _layers;
     private _drawings;
     private _groups;
@@ -1048,6 +1190,16 @@ declare class DrawingController {
     private _slotKey;
     /** Shift as of the last pointer report: what angle lock reads mid-preview. */
     private _shift;
+    /** Ctrl or Cmd as of the last pointer report: the strong magnet while held. */
+    private _strong;
+    /** Placement mode as this controller last set it. */
+    private _placing;
+    /** Drawings an eraser drag has touched: still in the model, left unpainted until it lets go. */
+    private _hidden;
+    /** The chart interval drawings are shown for; see `interval()`. */
+    private _interval;
+    /** The drawings the chart's interval hid when the layers were last listed; see `_followInterval`. */
+    private _offInterval;
     /** The device behind the last pointer report, for target sizing. */
     private _pointerKind;
     /** Snapshots for undo/redo; each is a full drawing list (they are small). */
@@ -1092,10 +1244,33 @@ declare class DrawingController {
      * Guarded so a base bundle predating `setPlacementMode` still loads the tier.
      */
     private _setPlacementMode;
+    /**
+     * The armed tool's placement mode, or a gesture's. The gestures are asked even with a tool
+     * armed: their answer is also how they read the next press, and a stale one would take it.
+     */
+    private _placementWanted;
     activeTool(): string | null;
     setOptions(patch: DrawingControllerOptions): void;
     /** The snap mode in force, after the boolean form has been folded. */
     magnetMode(): MagnetMode;
+    /**
+     * Whether a temporary measure (Shift+click on empty space) is on the chart.
+     * `draw:measure` (`{ active }`) fires when one starts and when it goes. A
+     * host routing Escape to `cancel()` only while placing passes this too.
+     */
+    measuring(): boolean;
+    /**
+     * Eraser mode: a click on a drawing deletes it, and a drag deletes every
+     * drawing it crosses, as one undo step on release. What the user could not
+     * delete by selecting it (read-only, locked, unselectable or hidden) stays.
+     * While it is on the chart is in placement mode, so a drag erases rather
+     * than pans. Turning it on disarms any tool; arming a tool, `cancel()` and
+     * `setEraser(false)` turn it off. `draw:eraser` (`{ active }`) fires on
+     * each change.
+     */
+    setEraser(active: boolean): void;
+    /** Whether eraser mode is on. */
+    erasing(): boolean;
     /**
      * The drawing under the pointer, selected or not, as the chart's hit-test
      * last reported it. What a host passes as `hasTarget` to the key mapping,
@@ -1104,11 +1279,6 @@ declare class DrawingController {
     hovered(): string | null;
     /** The clipboard behind copy / cut / paste, for a host reporting failures. */
     clipboard(): DrawingClipboard;
-    /**
-     * Every drawing, in list order. That is creation order until a z-order call
-     * moves one; the list is the tie-break for equal `zIndex`, so it is also the
-     * paint order within a band.
-     */
     /** Named drawing sets, returned as detached records. */
     groups(): readonly DrawingGroup[];
     /**
@@ -1159,8 +1329,42 @@ declare class DrawingController {
     /** The drawings of one slot of a pane, in paint order. */
     private _slotMembers;
     private _remapPanes;
+    /**
+     * Every drawing, in list order, those the interval hides included. That is
+     * creation order until a z-order call moves one; the list is the tie-break
+     * for equal `zIndex`, so it is also the paint order within a band.
+     */
     drawings(): readonly Drawing[];
     get(id: string): Drawing | undefined;
+    /**
+     * The chart interval drawings are shown for: the data context's `interval`
+     * when the controller was built, then as each `data:context` announces it,
+     * or null when the host names none (or a blank one), and then every drawing
+     * shows. Each drawing's `intervals` range is read against it.
+     */
+    interval(): string | null;
+    /**
+     * Whether a drawing is on the chart at the chart's interval: false for an
+     * unknown id and for one whose `intervals` range leaves that interval out.
+     * `visible` is not read; it is the user's own switch.
+     */
+    shownOnInterval(id: string): boolean;
+    /**
+     * The ids of the drawings the chart's interval leaves off the chart, in
+     * model order. One pass for a caller asking about every drawing, as the
+     * object inventory does on each refresh: `shownOnInterval` per id would
+     * look each one up.
+     */
+    hiddenOnInterval(): string[];
+    /** The test of whether a drawing is shown at the chart's interval, resolved once for a pass over many. */
+    private _shownFilter;
+    /**
+     * Follow a change of the chart's interval: what it hides leaves the layers
+     * and the selection, what it shows comes back. The layers are listed again
+     * only when that set changed, since a list under the series costs the
+     * series a repaint and a new symbol on the same interval changes nothing.
+     */
+    private _followInterval;
     get isDestroyed(): boolean;
     /** Apply a linked commit without adding to this chart's local undo history. */
     applyLinkedDrawing(id: string, drawing: Drawing | null): void;
@@ -1330,14 +1534,6 @@ declare class DrawingController {
     private _offsetAnchors;
     /** Nudge every anchor so a pasted copy is not hidden under its original. */
     private _offsetPoints;
-    /**
-     * Move a price down the screen by `px`. Done per anchor rather than as one
-     * price delta so the move is a rigid *screen* translation, which is what the
-     * eye expects and what keeps a shape's proportions on a log scale.
-     */
-    private _offsetPrice;
-    /** Move a time right along the screen by `px`. */
-    private _offsetTime;
     /**
      * Move a study's input anchor (a price input declared with `timeKey` and
      * `anchor: true`) to `point` as the user, the way dragging its handle does:
@@ -1431,28 +1627,11 @@ declare class DrawingController {
     private _setHovered;
     /** Remember the device behind a report and size the layers' targets for it. */
     private _notePointer;
-    /**
-     * The positions a pressed move passed through, as anchors, ending on the
-     * move's own point. The samples carry pixels (container x, pane-local y);
-     * the payload's point is the same position in its own space, so the gap
-     * between the two is the pane's offset, and each sample maps back through
-     * the host's converters. A host without them, or a payload without
-     * samples, inks the one point the move reports.
-     */
-    private _coalesced;
-    /** A pressure worth storing: finite, and not the mouse's stand-in. */
-    private _pressureOf;
     /**
      * Let a tool turn the clicked anchors into its full set (the position tools
      * build a 1:1 box off one click). Identity for tools without the hook.
      */
     private _expand;
-    /**
-     * Bar spacing in seconds, read from the last gap in the data. A one-bar chart
-     * has no gap to read, so fall back to a minute rather than answering zero and
-     * producing zero-width defaults and invisible paste offsets.
-     */
-    private _barSeconds;
     private _isFreehand;
     /**
      * Append one sample to the stroke in progress. Points arriving closer than a
@@ -1472,7 +1651,6 @@ declare class DrawingController {
      * a pixel one; a host that cannot map to pixels keeps every sample.
      */
     private _finishFreehand;
-    private _thinStroke;
     /**
      * End a variable-anchor shape (polyline, path) at the anchors placed so far.
      * Those tools declare `points: 0`, so nothing else can ever complete them;
@@ -1515,24 +1693,42 @@ declare class DrawingController {
      */
     private _lockedPoint;
     /**
-     * The nearest O/H/L/C of the hovered bar, at that bar's time, when the
-     * magnet pulls; null when it does not. `strong` always pulls; `weak` only
-     * within a few pixels, measured on screen so the pull is the same reach at
-     * every zoom. Price panes only: an indicator pane's values are not prices.
+     * Where the magnet lands `point`, or null when it does not pull: the
+     * nearest O/H/L/C of `bar` on the price pane, the nearest plotted value on
+     * a study pane (`snap.ts`). Ctrl held pulls as the strong magnet whatever
+     * the mode. A placement reads the bar the chart reported under the
+     * pointer; a drag, which reports none, passes the bar under its time.
      */
     private _snapPoint;
+    /** Shift and Ctrl (Cmd) as the last pointer report carried them: the angle lock and the strong magnet. */
+    private _noteKeys;
+    /**
+     * The anchor of a grabbed shape the magnet lands: the one nearest the
+     * press, since what the hand is closest to is what it means to put down.
+     */
+    private _grabbedAnchor;
+    /**
+     * A shape's move with the magnet's pull on its grabbed anchor applied, or
+     * null when nothing pulls: the whole shape shifts by what lands that one
+     * anchor on the value, so it keeps its form.
+     */
+    private _pullShape;
     private _onDrag;
+    /** Whether a drag has left its press by more than the chart's click slop, on screen. */
+    private _travelled;
+    /**
+     * Copies of `sources` for a drag to move, in the model and selected. A
+     * copy is the user's own drawing, as a duplicate is: no policy, a fresh
+     * id, and `_insert` drops the link lineage.
+     */
+    private _copies;
+    /** A cancelled copy leaves nothing: its copies go, and the selection is what they were copied from. */
+    private _dropCopies;
     private _emitDragPreview;
     /** Roll back an interrupted drag and leave the pre-gesture undo/redo stacks intact. */
     cancelDrag(): boolean;
     /** Apply one drag frame to the model, from the gesture's snapshot. */
     private _moveDrag;
-    /** How far down the screen `to` is from `from` on one pane, in media px. */
-    private _pixelDelta;
-    /** An anchor in container media px, or null on a host without the mapping. */
-    private _toPixel;
-    /** The inverse of `_toPixel`. */
-    private _fromPixel;
     /**
      * The drawing's anchors in container media px, the space `timeToCoordinate`
      * and `priceToCoordinate` answer in, whichever space it is anchored in. What
@@ -1541,68 +1737,8 @@ declare class DrawingController {
      * a strip, or hidden behind a maximized pane).
      */
     screenPoints(id: string): ScreenPoint[] | null;
-    /** A pane's price projection, when the host exposes one. */
-    private _pane;
-    /**
-     * Where a pane's plot is and how big, or null when it has none on screen
-     * (folded to a strip, or hidden behind a maximized pane): a fraction of
-     * either would be a fraction of nothing. It needs a pane projection too,
-     * since every gesture reads its y back through one.
-     */
-    private _plotFrame;
-    /**
-     * A gesture's position on its pane's plot, in media px. y reads the price
-     * back through the pane's readout scale, the exact inverse of how the chart
-     * read it; x is the pointer's container x less the plot's left edge, or,
-     * for a payload without one, the time through the time axis.
-     */
-    private _gesturePlot;
-    /**
-     * Where a drag was pressed, on its pane's plot. Read from the press's time
-     * and price when the chart reports them, so the first move is measured from
-     * the press and not from itself; a chart with fewer than two bars has no
-     * time axis to read a position back from, so it measures from the first move.
-     */
-    private _dragOrigin;
-    /**
-     * Data anchors as fractions of their pane's plot at the view on screen, or
-     * null when it has none. What is on screen stays where it is; a drawing part
-     * way or wholly off the plot comes onto it, since once pinned no pan could
-     * bring it back. One that fits moves in whole. One wider or taller than the
-     * plot is cut to it on that axis instead, so every handle of a pinned box
-     * is on screen to be grabbed.
-     */
-    private _toViewport;
-    /**
-     * The inverse of `_toViewport`: fractions back to time and price at the view
-     * on screen, from where the drawing is painted, so it does not move.
-     */
-    private _fromViewport;
-    /**
-     * Anchors in plot px as the fractions a pinned drawing stores, moved first
-     * so its box lies inside the plot. Every gesture ends here, so what is
-     * stored is what is painted, and no drag can leave the box where the
-     * pointer cannot reach it.
-     */
-    private _pinPlot;
-    /**
-     * Pinned anchors moved by a screen distance in media px, from where the
-     * drawing is painted rather than from what it stores: a note the layer
-     * holds in from a stored place off the plot (a host's value, a larger
-     * chart) moves at once, with no dead travel before it starts.
-     */
-    private _shiftPinned;
     /** Put a drawing's anchors back as a gesture found them. */
     private _restoreAnchors;
-    /**
-     * `free` projected onto the nearest 45 degree ray from `anchor`, all in
-     * screen space: the angle the eye reads is the one on the canvas, and a log
-     * scale or a tall pane would make a data-space angle anything but. The
-     * projection rather than a rotation, so a level line still ends under the
-     * pointer's x and a vertical one under its y; only the stray axis is
-     * dropped. Null when the host cannot map pixels, or the two coincide.
-     */
-    private _lockAngle;
     private _onDragEnd;
     /**
      * The pair of layers for a pane, made on first use. The bottom one is added
@@ -1766,6 +1902,215 @@ declare class DrawingLinkGroup {
 }
 declare function createDrawingLinkGroup(options?: DrawingLinkOptions): DrawingLinkGroup;
 
+/**
+ * Drawings per instrument: one drawing document for each instrument a chart
+ * shows, kept in a store the host chooses, and swapped as the chart moves
+ * from one instrument to another.
+ *
+ * A trader's levels belong to the symbol they were drawn on. The controller
+ * holds one document and knows nothing of instruments (the engine has no
+ * instrument concept), so without this a trend line drawn on one symbol stays
+ * on screen for every symbol loaded after it, and deleting it anywhere
+ * deletes it everywhere.
+ *
+ * The rules this keeps, each of which a host would otherwise have to get right
+ * on its own:
+ *
+ * - **The instrument comes from the chart's data context.** A `data:context`
+ *   naming another symbol or exchange saves the outgoing document and loads
+ *   the incoming one, in the same turn, so nothing that listens after it (an
+ *   alert, a link group) ever sees one instrument's drawings under another's
+ *   name. An interval or a data variant is the same instrument, and a context
+ *   that names no instrument changes nothing.
+ * - **A swap is not an edit.** It records no undo step, and it clears the
+ *   drawing undo history the way any `fromJSON` does: a step taken on one
+ *   instrument describes that instrument's drawings, and taking it back on
+ *   another would put one of them there. A drag in progress is put back first
+ *   and a shape half placed is dropped, with the tool left armed.
+ * - **The whole document swaps**, drawings pinned to the viewport included: a
+ *   group or a stacking order can span both spaces, and a note pinned to the
+ *   screen is nearly always about the instrument on it. Transient drawings
+ *   (`policy.persistent` false) are the host's and are not saved; a host
+ *   keeping one per instrument places it again after the swap.
+ * - **Every committed change is written at once**, only when the saved
+ *   document actually changed, so a reload loses nothing and a stream of
+ *   updates to transient drawings writes nothing. An instrument left with no
+ *   drawings has its entry removed rather than an empty one kept.
+ * - **A store that fails loses nothing for the session.** A refused write is
+ *   reported through `onError` and the document is held in memory, read back
+ *   from there, and written again with the next change.
+ * - **Anything else that replaces the whole document** (a host's `fromJSON`,
+ *   a chart layout restored) is the current instrument's new document, and is
+ *   written as such.
+ * - **A stored document of an earlier version is read through the migration**
+ *   and written back only when something in it changes, in the version that
+ *   holds it then: a version 2 document stays version 2 until a drawing in it
+ *   is given an interval range, and a version 3 one keeps its ranges.
+ *
+ * The store is synchronous on purpose: a swap happens inside the context
+ * change, and an answer arriving later would land one instrument's drawings
+ * on whatever the chart shows by then. A host whose drawings live on a
+ * server keeps a synchronous copy here and syncs it in the background.
+ */
+
+/** An instrument as a chart's data context names it. */
+interface DrawingInstrument {
+    symbol?: string;
+    exchange?: string;
+}
+/**
+ * Where the documents live, one per instrument key. The host's choice:
+ * `memoryDrawingStore` (the default), `webStorageDrawingStore` over a web
+ * storage the host hands it, or its own. Synchronous; a throw from any
+ * method, or `set` returning false, is a failure the helper reports.
+ */
+interface DrawingDocumentStore {
+    /** The document stored under `key`, or null (or undefined) when there is none. */
+    get(key: string): unknown;
+    /** Store `document` under `key`. False, or a throw, when the write did not land. */
+    set(key: string, document: DrawingsDocument): boolean | void;
+    /** Forget whatever is stored under `key`. */
+    remove(key: string): void;
+}
+/** The three members of a web storage `webStorageDrawingStore` uses. */
+interface DrawingTextStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/** The slice of the chart `InstrumentDrawings` needs. */
+interface InstrumentDrawingsChart {
+    readonly isDestroyed?: boolean;
+    on(event: string, handler: (payload: unknown) => void): () => void;
+    getDataContext?(): Readonly<DrawingInstrument> | undefined;
+}
+/** A store operation that failed, as `InstrumentDrawingsOptions.onError` receives it. */
+interface InstrumentDrawingsError {
+    operation: 'read' | 'write' | 'remove';
+    key: string;
+    error: unknown;
+}
+interface InstrumentDrawingsOptions {
+    /** Where the documents live. Default: `memoryDrawingStore()`, for the life of the page. */
+    store?: DrawingDocumentStore;
+    /**
+     * The key an instrument's document is stored under, or null for a context
+     * that names no instrument. Default `instrumentDrawingsKey`. A host that
+     * wants drawings per data variant too, or one namespace per chart, says so here.
+     */
+    key?: (instrument: DrawingInstrument) => string | null;
+    /**
+     * Which document wins when the helper starts on an instrument the store
+     * already holds one for while the controller holds another. `'stored'`
+     * (default) loads the stored one, which is right for a chart built fresh.
+     * `'live'` keeps the controller's, even an empty one, and writes it to the
+     * store, for a host that has just loaded that instrument's drawings itself
+     * (a layout, a chart rebuilt from the one it replaces). Either way, drawings the
+     * controller holds for an instrument the store has nothing for are kept as
+     * that instrument's: that is how a document saved before drawings were per
+     * instrument is attached to the instrument it was drawn on.
+     */
+    prefer?: 'stored' | 'live';
+    /** Called for every store operation that failed. The document stays in memory for the session. */
+    onError?: (error: InstrumentDrawingsError) => void;
+}
+/**
+ * The default key: the exchange and the symbol, `NSE:INFY`, or the symbol
+ * alone when there is no exchange. Each part is URI-encoded, so a colon
+ * inside a symbol cannot make two instruments one key. Null when the symbol
+ * is missing or blank. Case is kept: the host decides whether `infy` and
+ * `INFY` are one instrument, and the widget uppercases symbols itself.
+ */
+declare function instrumentDrawingsKey(instrument: DrawingInstrument | null | undefined): string | null;
+/** A store in memory, for the life of the page. Each document is kept as text, so no caller shares an object with it. */
+declare function memoryDrawingStore(): DrawingDocumentStore;
+/**
+ * A store over a web storage the host hands it (the page's `localStorage`,
+ * or anything with the same three members), one JSON entry per instrument
+ * under `prefix`. A text that does not parse throws from `get`, which the
+ * helper reports and treats as no drawings.
+ */
+declare function webStorageDrawingStore(storage: DrawingTextStorage, prefix: string): DrawingDocumentStore;
+/**
+ * Attach a document saved before drawings were kept per instrument (one set
+ * for the whole chart) to the instrument it was saved with, so no one loses
+ * the drawings they already have. It is written only when the store holds
+ * nothing for that instrument yet and the document has something in it; an
+ * instrument that already has its own keeps it. True when it was written.
+ */
+declare function migrateUnscopedDrawings(store: DrawingDocumentStore, key: string | null, document: unknown): boolean;
+/**
+ * Keeps a drawing controller's document per instrument. Build it once the
+ * controller exists; it follows the chart's data context from then on.
+ *
+ * ```ts
+ * const scoped = new InstrumentDrawings(chart, draw, {
+ *   store: webStorageDrawingStore(localStorage, 'my-app:drawings:'),
+ * });
+ * chart.setDataContext({ symbol: 'INFY', exchange: 'NSE', interval: '5m' });
+ * ```
+ */
+declare class InstrumentDrawings {
+    private readonly _draw;
+    private readonly _store;
+    private readonly _keyOf;
+    private readonly _onError;
+    private _key;
+    /** The current instrument's document as last written or loaded, to skip a write that changes nothing. */
+    private _text;
+    /** Documents whose write failed, by key: what the store should hold, kept for the session. */
+    private readonly _held;
+    private _swapping;
+    private _destroyed;
+    private readonly _off;
+    constructor(chart: InstrumentDrawingsChart, controller: DrawingController, options?: InstrumentDrawingsOptions);
+    get isDestroyed(): boolean;
+    /** The key of the instrument whose drawings are on the chart, or null before the chart has named one. */
+    key(): string | null;
+    /**
+     * Move to another instrument now, without waiting for the chart's data
+     * context: for a host that does not publish one, or that switches its
+     * drawings ahead of its data. A later context naming the same instrument
+     * changes nothing. Null, or an instrument with no key, changes nothing.
+     */
+    setInstrument(instrument: DrawingInstrument | null): void;
+    /**
+     * The saved document of an instrument: the drawings on the chart for the
+     * current one, the stored document for any other, or null when it has
+     * none (or no key). A copy either way.
+     */
+    document(instrument: DrawingInstrument): DrawingsDocument | null;
+    /**
+     * Replace one instrument's drawings. On the current instrument that is the
+     * controller's `fromJSON`, which clears its undo history; on any other, the
+     * stored document, shown when the chart next moves there. For a layout
+     * that brings the drawings of an instrument the chart is about to show.
+     */
+    setDocument(instrument: DrawingInstrument, document: unknown): void;
+    /** Write the current instrument's document now, and any the store refused before. False while one is still refused. */
+    save(): boolean;
+    /** Stop following the chart. The documents stay where they are. */
+    destroy(): void;
+    private _keyFor;
+    /** The drawings the controller would save, as text. */
+    private _live;
+    /** Take `key` as the current instrument, with the drawings `prefer` picks. */
+    private _start;
+    private _follow;
+    private _swap;
+    /** Put `document` on the controller without the change it announces being written back. */
+    private _load;
+    private _changed;
+    /** Write the current document when it changed, or always when `force`. */
+    private _saveCurrent;
+    private _write;
+    /** The stored document for `key`, migrated to the current shape, or null. A held one comes first. */
+    private _read;
+    private _report;
+}
+/** `new InstrumentDrawings(chart, controller, options)`, as a function. */
+declare function createInstrumentDrawings(chart: InstrumentDrawingsChart, controller: DrawingController, options?: InstrumentDrawingsOptions): InstrumentDrawings;
+
 /**
  * Built-in drawing tools + the tool registry. Same philosophy as the chart-type
  * and indicator registries: a tool is a descriptor, the layer just runs it, and
@@ -2346,6 +2691,11 @@ declare function toolCursor(id: string, opts?: ToolCursorOptions): string;
  * top canvas. The layer that paints them is the one whose `requestUpdate`
  * the chart maps to the cursor tier, which is why the bottom layer of a pair
  * stores that state and asks for nothing.
+ *
+ * A hit test asks a tool for its distance only where the drawing can be: each
+ * layer keeps a box per drawing (src/draw/hit-index.ts) and a pointer outside
+ * it costs four comparisons. The answer is the one a test of every drawing
+ * gives, because a box covers every point its tool would report as a hit.
  */
 
 /**
@@ -2378,12 +2728,22 @@ declare class DrawingLayer implements IPrimitive {
     private _above;
     /** Sizes grab targets for the device last seen. */
     private _touch;
+    /** Hit boxes per drawing, kept while nothing that places them changes. */
+    private readonly _index;
+    /** Paint positions of the selected, unlocked, shown drawings, or null until asked again. */
+    private _selectedAt;
     constructor(order?: DrawingLayerOrder);
     attached(host: PrimitiveHost): void;
     detached(): void;
     zOrder(): ZOrder;
     /** Drawings overlay the price range; they never drive it. */
     autoscaleInfo(): null;
+    /**
+     * The drawings this layer paints and answers for. The hit boxes kept for
+     * the previous list all go, so a drawing edited in place must be handed
+     * over again, as the controller does after every edit, for a hover to see
+     * where it now is.
+     */
     setDrawings(drawings: readonly Drawing[]): void;
     setSelected(ids: readonly string[]): void;
     /**
@@ -2446,6 +2806,17 @@ declare class DrawingLayer implements IPrimitive {
     /** The magnet ring: hollow, in the axis text colour, at the snap point. */
     private _drawSnapRing;
     hitTest(x: number, y: number, rc: PrimitiveRenderContext): PrimitiveHit | null;
+    /**
+     * Paint positions of the drawings `_handled` lists, less the registry check,
+     * which is read live: a tool registered after the list was made makes its
+     * drawings handled from then on, with no new list to say so.
+     */
+    private _selectedPositions;
+    /**
+     * A drawing's body box: none for one that cannot be hit, everywhere for a
+     * tool the box table does not know, else its tool's box at this radius.
+     */
+    private _measure;
     private _hitHandle;
     private _hitBody;
 }
@@ -2521,7 +2892,7 @@ declare const NUDGE_STEP_SHIFT_PX = 10;
 declare function keyToDrawingAction(e: DrawingKeyEvent, ctx: DrawingKeyContext): DrawingKeyAction | null;
 
 /**
- * The 1.9.x to 2.0 drawing migration.
+ * The drawing migration: 1.9.x to 2.0, and document version 2 to 3.
  *
  * Hosts persist `toJSON()` verbatim, and a 1.9.x host has done so for a long
  * time: a bare `Drawing[]` per pane in local storage, for a great many users.
@@ -2554,19 +2925,36 @@ declare function keyToDrawingAction(e: DrawingKeyEvent, ctx: DrawingKeyContext):
  * - Garbage yields an empty document. This runs on the load path, where an
  *   exception would take the whole chart down with it.
  *
- * Idempotent on a version 2 document, so a host can call it on every load.
+ * Version 3 added one optional field, the interval range a drawing is shown
+ * on, so a version 2 document needs no upgrade and comes back unchanged,
+ * version and all. A range is kept when it names at least one bound, and the
+ * document out is version 3 only when a drawing kept one. A document from a
+ * later version is read the same lenient way: what this build knows is kept
+ * and the rest dropped, since refusing it would empty the chart on load.
+ *
+ * Idempotent on a version 2 or 3 document, so a host can call it on every load.
  */
 
 /**
  * Upgrade saved drawings to the current document shape. Accepts a 1.9.x
- * `Drawing[]` or a {@link DrawingsDocument}. Every field is validated, the
- * 1.9.x text keys are lifted out of the style bag into `text`, bare level
- * ratios become coloured levels, and array order is kept. An entry that could
- * never be rendered is dropped; anything unparseable yields an empty document
- * rather than an error.
+ * `Drawing[]` or a {@link DrawingsDocument} of any version. Every field is
+ * validated, the 1.9.x text keys are lifted out of the style bag into `text`,
+ * bare level ratios become coloured levels, and array order is kept. An entry
+ * that could never be rendered is dropped; anything unparseable yields an
+ * empty document rather than an error. The result is version 3 when a drawing
+ * carries an interval range and version 2 otherwise.
  */
 declare function migrateDrawings(input: unknown): DrawingsDocument;
 
+/**
+ * Whether a drawing is shown on a chart whose interval is `interval`. A
+ * drawing with no range is shown on every interval. For a host marking the
+ * drawings a range hides (an objects panel, a settings preview) without a
+ * controller at hand; `DrawingController.shownOnInterval` answers for the
+ * chart the controller is on.
+ */
+declare function drawingShownOnInterval(drawing: Pick<Drawing, 'intervals'>, interval: string | null | undefined): boolean;
+
 /**
  * Hit-test geometry for the drawing tier. Everything works in media px and
  * returns a distance, so `DrawingLayer` can pick the nearest shape under the
@@ -2660,4 +3048,4 @@ declare const PATTERN_DRAWING_TOOLS: readonly DrawingTool[];
 
 declare const DRAW_TIER: "draw";
 
-export { ADVANCED_GEOMETRY_TOOLS, ADVANCED_LINE_TOOLS, ALIGN_OPTIONS, ANCHORED_VWAP, ARC, ARROW, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, type AnalysisProfileRow, type AnalysisStatus, type AnchoredVwapOptions, type AnchoredVwapPoint, type AnchoredVwapResult, type AnchoredVwapSource, BALLOON, BRUSH, BUILTIN_DRAWING_TOOLS, CALLOUT, CHROME_ICONS, CHROME_ICON_ACCENTS, CHROME_ICON_ATTRS, CHROME_ICON_FILLED, CHROME_ICON_STROKE, CHROME_ICON_VIEWBOX, CIRCLE, COLOR_FIELD, COMMENT, CROSS_LINE, CURVE, CYCLE_PALETTE, CYCLIC_LINES, type ClipboardPort, DATE_RANGE, DEFAULT_FIB, DEFAULT_FIB_FAN, DEFAULT_FIB_TIME_ZONE, DEFAULT_GANN_BOX, DEFAULT_GANN_FAN, DOUBLE_CURVE, DRAWING_CLIPBOARD_KEY, DRAWING_CLIPBOARD_VERSION, DRAWING_STATE_VERSION, DRAWING_TOOL_ACCENTS, DRAWING_TOOL_ICONS, DRAW_TIER, type DrawContext, type Drawing, type DrawingChangeEvent, type DrawingChangeKind, type DrawingChartHost, DrawingClipboard, type DrawingClipboardOptions, DrawingController, type DrawingControllerOptions, type DrawingEditOptions, type DrawingGroup, type DrawingInput, type DrawingKeyAction, type DrawingKeyContext, type DrawingKeyEvent, DrawingLayer, type DrawingLayerOrder, type DrawingLinkChart, type DrawingLinkContext, type DrawingLinkContextSource, DrawingLinkGroup, type DrawingLinkOptions, type DrawingPatch, type DrawingPlacementOptions, type DrawingPoint, type DrawingPointerKind, type DrawingPolicy, type DrawingSpace, type DrawingStackTarget, type DrawingStyle, type DrawingText, type DrawingTool, type DrawingValueContext, type DrawingsDocument, ELLIPSE, EXTENDED_LINE, EXTEND_FIELDS, type ExpandContext, FIB_CHANNEL, FIB_EXTENSION, FIB_FAN, FIB_RETRACEMENT, FIB_TIME_ZONE, FILL_FIELDS, FIXED_RANGE_VOLUME_PROFILE, FLAG_MARK, FONT_FIELDS, FONT_OPTIONS, FORECAST, type FibLevel, type FieldGroup, type FieldKind, type FixedRangeVolumeProfileOptions, type FixedRangeVolumeProfileResult, GANN_BOX, GANN_FAN, HIGHLIGHTER, HORIZONTAL_LINE, HORIZONTAL_RAY, type HitContext, ICON_ATTRS, ICON_STROKE, ICON_SYMBOL_PREFIX, ICON_VIEWBOX, type IconAttrs, type IconSvgOptions, type InputAnchorStep, LEVEL_FIELDS, LEVEL_NEUTRAL, LINE_FIELDS, LINE_STYLE_FIELD, LINE_STYLE_OPTIONS, LINE_WIDTH_FIELD, LONG_POSITION, MEASURE, type MagnetMode, NOTE, NUDGE_STEP_PX, NUDGE_STEP_SHIFT_PX, PARALLEL_CHANNEL, PATH, PATTERN_DRAWING_TOOLS, PLATE_TEXT_FIELDS, POLYLINE, PRICE_LABEL, PRICE_NOTE, PRICE_RANGE, RAY, RECTANGLE, ROTATED_RECTANGLE, SHAPE_TEXT_FIELDS, SHORT_POSITION, SHOW_LABELS_FIELD, SIGNPOST, SINE_LINE, SPACE_FIELD, SPACE_OPTIONS, type ScreenPoint, type SettingsField, type SettingsSchema, type ShortcutEvent, type StudyInputTarget, TABLE, TEXT, TEXT_FIELDS, TEXT_POSITION_OPTIONS, TEXT_VALUE_FIELD, TIME_CYCLES, TREND_LINE, TRIANGLE, type ToolCursorOptions, VALIGN_OPTIONS, VERTICAL_LINE, type ViewportPoint, anchoredVwapAnalysis, applyDrawingSettings, boundsOf, catmullRom, chromeIcon, chromeIconAccent, chromeIconIds, chromeIconSvg, clearMemoryClipboard, cloneDrawing, cloneLevels, coerceSettingValue, composeSettings, createDrawingLinkGroup, cycleColor, decodeClipboardPayload, distToEllipse, distToLine, distToPolyline, distToRect, distToSegment, drawingSettingsSchema, drawingShortcuts, drawingToolAccent, drawingToolIcon, drawingToolIconIds, encodeClipboardPayload, extendSegment, fixedRangeVolumeProfileAnalysis, formatRatio, gannLabel, getDrawingTool, hasDrawingTool, iconSprite, iconSvg, iconUse, keyToDrawingAction, levelColor, matchDrawingShortcut, migrateDrawings, pressureWidth, rdpSimplify, readDrawingSetting, readDrawingSettings, rectOf, registerBuiltinDrawingTools, registerDrawingTool, registeredDrawingTools, sanitizeDrawing, sortByZIndex, studyInputTarget, systemClipboard, toolCursor };
+export { ADVANCED_GEOMETRY_TOOLS, ADVANCED_LINE_TOOLS, ALIGN_OPTIONS, ANCHORED_VWAP, ARC, ARROW, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, type AnalysisProfileRow, type AnalysisStatus, type AnchoredVwapOptions, type AnchoredVwapPoint, type AnchoredVwapResult, type AnchoredVwapSource, BALLOON, BRUSH, BUILTIN_DRAWING_TOOLS, CALLOUT, CHROME_ICONS, CHROME_ICON_ACCENTS, CHROME_ICON_ATTRS, CHROME_ICON_FILLED, CHROME_ICON_STROKE, CHROME_ICON_VIEWBOX, CIRCLE, COLOR_FIELD, COMMENT, CROSS_LINE, CURVE, CYCLE_PALETTE, CYCLIC_LINES, type ClipboardPort, DATE_RANGE, DEFAULT_FIB, DEFAULT_FIB_FAN, DEFAULT_FIB_TIME_ZONE, DEFAULT_GANN_BOX, DEFAULT_GANN_FAN, DOUBLE_CURVE, DRAWING_CLIPBOARD_KEY, DRAWING_CLIPBOARD_VERSION, DRAWING_STATE_VERSION, DRAWING_TOOL_ACCENTS, DRAWING_TOOL_ICONS, DRAW_TIER, type DrawContext, type Drawing, type DrawingChangeEvent, type DrawingChangeKind, type DrawingChartHost, DrawingClipboard, type DrawingClipboardOptions, DrawingController, type DrawingControllerOptions, type DrawingDocumentStore, type DrawingEditOptions, type DrawingGestureOptions, type DrawingGroup, type DrawingInput, type DrawingInstrument, type DrawingIntervalRange, type DrawingKeyAction, type DrawingKeyContext, type DrawingKeyEvent, DrawingLayer, type DrawingLayerOrder, type DrawingLinkChart, type DrawingLinkContext, type DrawingLinkContextSource, DrawingLinkGroup, type DrawingLinkOptions, type DrawingPatch, type DrawingPlacementOptions, type DrawingPoint, type DrawingPointerKind, type DrawingPolicy, type DrawingSpace, type DrawingStackTarget, type DrawingStyle, type DrawingText, type DrawingTextStorage, type DrawingTool, type DrawingValueContext, type DrawingsDocument, ELLIPSE, EXTENDED_LINE, EXTEND_FIELDS, type ExpandContext, FIB_CHANNEL, FIB_EXTENSION, FIB_FAN, FIB_RETRACEMENT, FIB_TIME_ZONE, FILL_FIELDS, FIXED_RANGE_VOLUME_PROFILE, FLAG_MARK, FONT_FIELDS, FONT_OPTIONS, FORECAST, type FibLevel, type FieldGroup, type FieldKind, type FixedRangeVolumeProfileOptions, type FixedRangeVolumeProfileResult, GANN_BOX, GANN_FAN, HIGHLIGHTER, HORIZONTAL_LINE, HORIZONTAL_RAY, type HitContext, ICON_ATTRS, ICON_STROKE, ICON_SYMBOL_PREFIX, ICON_VIEWBOX, INTERVAL_FIELDS, type IconAttrs, type IconSvgOptions, type InputAnchorStep, InstrumentDrawings, type InstrumentDrawingsChart, type InstrumentDrawingsError, type InstrumentDrawingsOptions, LEVEL_FIELDS, LEVEL_NEUTRAL, LINE_FIELDS, LINE_STYLE_FIELD, LINE_STYLE_OPTIONS, LINE_WIDTH_FIELD, LONG_POSITION, MEASURE, type MagnetMode, NOTE, NUDGE_STEP_PX, NUDGE_STEP_SHIFT_PX, PARALLEL_CHANNEL, PATH, PATTERN_DRAWING_TOOLS, PLATE_TEXT_FIELDS, POLYLINE, PRICE_LABEL, PRICE_NOTE, PRICE_RANGE, RAY, RECTANGLE, ROTATED_RECTANGLE, SHAPE_TEXT_FIELDS, SHORT_POSITION, SHOW_LABELS_FIELD, SIGNPOST, SINE_LINE, SPACE_FIELD, SPACE_OPTIONS, type ScreenPoint, type SettingsField, type SettingsSchema, type ShortcutEvent, type StudyInputTarget, TABLE, TEXT, TEXT_FIELDS, TEXT_POSITION_OPTIONS, TEXT_VALUE_FIELD, TIME_CYCLES, TREND_LINE, TRIANGLE, type ToolCursorOptions, VALIGN_OPTIONS, VERTICAL_LINE, type ViewportPoint, anchoredVwapAnalysis, applyDrawingSettings, boundsOf, catmullRom, chromeIcon, chromeIconAccent, chromeIconIds, chromeIconSvg, clearMemoryClipboard, cloneDrawing, cloneLevels, coerceSettingValue, composeSettings, createDrawingLinkGroup, createInstrumentDrawings, cycleColor, decodeClipboardPayload, distToEllipse, distToLine, distToPolyline, distToRect, distToSegment, drawingSettingsSchema, drawingShortcuts, drawingShownOnInterval, drawingToolAccent, drawingToolIcon, drawingToolIconIds, encodeClipboardPayload, extendSegment, fixedRangeVolumeProfileAnalysis, formatRatio, gannLabel, getDrawingTool, hasDrawingTool, iconSprite, iconSvg, iconUse, instrumentDrawingsKey, keyToDrawingAction, levelColor, matchDrawingShortcut, memoryDrawingStore, migrateDrawings, migrateUnscopedDrawings, pressureWidth, rdpSimplify, readDrawingSetting, readDrawingSettings, rectOf, registerBuiltinDrawingTools, registerDrawingTool, registeredDrawingTools, sanitizeDrawing, sortByZIndex, studyInputTarget, systemClipboard, toolCursor, webStorageDrawingStore };