@itssumitrai/fin-charter 0.2.0

package/dist/core/symbol-resolver.d.ts

@@ -0,0 +1,32 @@
+export interface SymbolInfo {
+    /** Ticker symbol, e.g. "AAPL" */
+    symbol: string;
+    /** Human-readable name, e.g. "Apple Inc." */
+    name: string;
+    /** Instrument type, e.g. "stock", "crypto", "forex" */
+    type: string;
+    /** Exchange identifier, e.g. "NASDAQ" */
+    exchange: string;
+    /** IANA timezone, e.g. "America/New_York" */
+    timezone: string;
+    /** Decimal places for price display */
+    pricePrecision: number;
+    /** Minimum price movement (e.g. 1 for whole-cent, 0.5 for half-tick) */
+    minMov: number;
+}
+export interface ISymbolResolver {
+    /** Resolve a ticker string to full symbol information. */
+    resolveSymbol(ticker: string): Promise<SymbolInfo>;
+    /** Search symbols by query string, optionally filtered by instrument type. */
+    searchSymbols(query: string, type?: string): Promise<SymbolInfo[]>;
+}
+/**
+ * A simple in-memory symbol resolver that searches a pre-loaded map of symbols
+ * using fuzzy matching on both the ticker symbol and the human-readable name.
+ */
+export declare class SimpleSymbolResolver implements ISymbolResolver {
+    private readonly _symbols;
+    constructor(symbols: Map<string, SymbolInfo>);
+    resolveSymbol(ticker: string): Promise<SymbolInfo>;
+    searchSymbols(query: string, type?: string): Promise<SymbolInfo[]>;
+}

package/dist/core/text-label.d.ts

@@ -0,0 +1,72 @@
+import { IPaneView } from './types';
+export interface TextLabelOptions {
+    /** Text content. */
+    text: string;
+    /** Background color (set to 'transparent' for no background). */
+    backgroundColor: string;
+    /** Text color. */
+    textColor: string;
+    /** Border color (set to 'transparent' for no border). */
+    borderColor: string;
+    /** Border width in pixels. */
+    borderWidth: number;
+    /** Border radius in pixels. */
+    borderRadius: number;
+    /** Font size in pixels. */
+    fontSize: number;
+    /** Font family. */
+    fontFamily: string;
+    /** Box anchor relative to the time/price coordinate: 'left' = box starts at anchor, 'center' = centered, 'right' = box ends at anchor. */
+    boxAnchor: 'left' | 'center' | 'right';
+    /** Padding inside the box (pixels). */
+    padding: number;
+    /** Whether to draw an arrow/connector line from the box to the anchor point. */
+    showConnector: boolean;
+    /** Connector line color. */
+    connectorColor: string;
+    /** Y offset of the label box from the anchor point (pixels). */
+    yOffset: number;
+}
+export declare const DEFAULT_TEXT_LABEL_OPTIONS: TextLabelOptions;
+/**
+ * TextLabel — a lightweight text annotation anchored to a time/price coordinate.
+ *
+ * Unlike the drawing tool's text annotation, TextLabels are programmatic
+ * (e.g., for annotating earnings dates, dividends) and don't require
+ * user interaction to place. They survive zoom/pan and are included in
+ * screenshot exports.
+ */
+export declare class TextLabel {
+    readonly id: string;
+    /** Bar index (not timestamp). Use DataLayer.findIndex(timestamp) to convert. */
+    private _time;
+    private _price;
+    private _options;
+    private _requestRepaint;
+    constructor(id: string, time: number, price: number, options: Partial<TextLabelOptions>, requestRepaint?: () => void);
+    get time(): number;
+    get price(): number;
+    get options(): Readonly<TextLabelOptions>;
+    applyOptions(opts: Partial<TextLabelOptions>): void;
+    setPosition(time: number, price: number): void;
+    /**
+     * Create an IPaneView for rendering this label on the chart canvas.
+     */
+    createPaneView(indexToX: (i: number) => number, priceToY: (p: number) => number): IPaneView;
+    /** Serialize for persistence. */
+    serialize(): {
+        id: string;
+        time: number;
+        price: number;
+        options: TextLabelOptions;
+    };
+}
+/**
+ * Batch-create text labels (e.g., for annotating earnings dates).
+ */
+export declare function createTextLabels(entries: Array<{
+    time: number;
+    price: number;
+    text: string;
+    options?: Partial<TextLabelOptions>;
+}>, requestRepaint?: () => void): TextLabel[];

package/dist/core/time-scale.d.ts

@@ -0,0 +1,109 @@
+import { VisibleRange } from './types';
+export interface TimeScaleOptions {
+    barSpacing: number;
+    rightOffset: number;
+    minBarSpacing: number;
+    maxBarSpacing: number;
+}
+/**
+ * TimeScale managing horizontal bar layout and coordinate mapping.
+ *
+ * - `_rightOffset` = bars of empty space to the right of the last bar.
+ *   Default 0 means the last bar sits at the right edge.
+ * - `_barSpacing` controls zoom level.
+ * - Visible range: rightBorder = baseIndex + rightOffset,
+ *   leftBorder = rightBorder - width/barSpacing + 1
+ * - indexToCoordinate: deltaFromRight = baseIndex + rightOffset - index;
+ *   x = width - (deltaFromRight + 0.5) * barSpacing
+ * - Scrolling modifies rightOffset.
+ * - Auto-scroll on new data: rightOffset stays constant, so new bars
+ *   naturally appear if the last bar was visible.
+ */
+export declare class TimeScale {
+    private static readonly MIN_VISIBLE_BARS;
+    private _options;
+    /** Canvas width in pixels. */
+    private _width;
+    /** Total number of data bars. */
+    private _dataLength;
+    /** Bars of space to the right of the last bar. */
+    private _rightOffset;
+    /** Bar spacing (zoom level). Stored separately from options so zoomAt can mutate it without cloning options. */
+    private _barSpacing;
+    constructor(options?: Partial<TimeScaleOptions>);
+    private get _baseIndex();
+    setOptions(options: Partial<TimeScaleOptions>): void;
+    setWidth(width: number): void;
+    /**
+     * Set data length.
+     * Auto-scroll: rightOffset stays constant, so if the last bar was visible
+     * before new data arrived, the new bar naturally appears.
+     */
+    setDataLength(length: number): void;
+    get barSpacing(): number;
+    get minBarSpacing(): number;
+    get maxBarSpacing(): number;
+    /** Set bar spacing directly (clamped to min/max). */
+    setBarSpacing(spacing: number): void;
+    /** Scroll by pixels (positive = scroll right, negative = scroll left). */
+    scrollBy(deltaX: number): void;
+    get rightOffset(): number;
+    get dataLength(): number;
+    /**
+     * Compute the visible bar index range.
+     * rightBorder = baseIndex + rightOffset
+     * leftBorder = rightBorder - width/barSpacing + 1
+     */
+    visibleRange(): VisibleRange;
+    /**
+     * Convert a bar index to the x-pixel of its center.
+     * deltaFromRight = baseIndex + rightOffset - index
+     * x = width - (deltaFromRight + 0.5) * barSpacing
+     */
+    indexToX(index: number): number;
+    /**
+     * Convert an x-pixel coordinate back to the nearest bar index (not clamped).
+     * Inverse of indexToX.
+     */
+    xToIndex(x: number): number;
+    /**
+     * Return the fractional (float) index at an x coordinate.
+     * Used internally for zoom stabilization.
+     */
+    private _floatIndexAtX;
+    /**
+     * Called by the pan handler. Computes the shift in logical bars from the
+     * start position and applies it to the saved right offset.
+     *
+     * Dragging right → x increases → shift is negative → rightOffset decreases
+     * → chart moves toward future/recent data.
+     */
+    scrollTo(startX: number, currentX: number, savedRightOffset: number): void;
+    /** Direct offset setter for kinetic scrolling etc. */
+    setRightOffset(offset: number): void;
+    /** Scroll so the last bar is visible at the right edge (reset to configured rightOffset). */
+    scrollToEnd(): void;
+    /**
+     * Scroll by pixel amount. Kept for backwards compatibility with
+     * axis-drag, keyboard-nav, and kinetic scrolling.
+     *
+     * Positive deltaX → rightOffset increases → chart shifts to show older data.
+     */
+    scrollByPixels(deltaX: number): void;
+    /**
+     * Set scroll offset directly in bars.
+     * Kept for backwards compatibility with keyboard-nav (Home key).
+     */
+    scrollToPosition(position: number): void;
+    /**
+     * Zoom keeping the point under cursor stable.
+     * TV model: record float index under cursor, change barSpacing by
+     * `scale * (barSpacing / 10)`, then adjust rightOffset so that index
+     * stays at the same screen x.
+     */
+    zoomAt(x: number, scale: number): void;
+    /** Adjust barSpacing so all data bars fit exactly in the current width. */
+    fitContent(): void;
+    correctOffset(): void;
+    private _clampBarSpacing;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,144 @@
+export interface Bar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+/** Same fields as Bar but stored as typed arrays (column-oriented). */
+export interface ColumnData {
+    time: Float64Array;
+    open: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    close: Float64Array;
+    volume: Float64Array;
+}
+export interface ColumnStore {
+    time: Float64Array;
+    open: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    close: Float64Array;
+    volume: Float64Array;
+    length: number;
+    capacity: number;
+}
+export declare function createColumnStore(capacity: number): ColumnStore;
+export declare function barsToColumnStore(bars: Bar[]): ColumnStore;
+export declare const InvalidationLevel: {
+    readonly None: 0;
+    readonly Cursor: 1;
+    readonly Light: 2;
+    readonly Full: 3;
+};
+export type InvalidationLevelValue = (typeof InvalidationLevel)[keyof typeof InvalidationLevel];
+export interface VisibleRange {
+    fromIdx: number;
+    toIdx: number;
+}
+export interface TimeRange {
+    from: number;
+    to: number;
+}
+export type PathCommand = {
+    cmd: 'M';
+    x: number;
+    y: number;
+} | {
+    cmd: 'L';
+    x: number;
+    y: number;
+} | {
+    cmd: 'Z';
+} | {
+    cmd: 'Q';
+    cpx: number;
+    cpy: number;
+    x: number;
+    y: number;
+} | {
+    cmd: 'C';
+    cp1x: number;
+    cp1y: number;
+    cp2x: number;
+    cp2y: number;
+    x: number;
+    y: number;
+};
+export interface GradientStop {
+    offset: number;
+    color: string;
+}
+export interface Gradient {
+    type: 'linear' | 'radial';
+    stops: GradientStop[];
+}
+export type RenderStyle = string | Gradient;
+export declare const PrimitiveZOrder: {
+    readonly Bottom: 0;
+    readonly Normal: 1;
+    readonly Top: 2;
+};
+export type PrimitiveZOrderValue = (typeof PrimitiveZOrder)[keyof typeof PrimitiveZOrder];
+export type DataUpdateScope = 'full' | 'update';
+export interface AttachedParams {
+    requestUpdate(): void;
+}
+export interface IRenderTarget {
+    readonly canvas: HTMLCanvasElement;
+    readonly context: CanvasRenderingContext2D;
+    readonly width: number;
+    readonly height: number;
+    readonly pixelRatio: number;
+}
+export interface IPaneRenderer {
+    draw(target: IRenderTarget): void;
+    drawBackground?(target: IRenderTarget): void;
+}
+export interface IPaneView {
+    renderer(): IPaneRenderer | null;
+    zOrder?(): PrimitiveZOrderValue;
+}
+export interface IPriceAxisView {
+    text(): string;
+    textColor(): string;
+    backColor(): string;
+    coordinate(): number;
+}
+export interface ITimeAxisView {
+    text(): string;
+    coordinate(): number;
+}
+export interface PrimitiveHitTestResult {
+    cursorStyle?: string;
+    externalId?: string;
+}
+export interface ISeriesPrimitive {
+    /** Called when the primitive is attached to a series. */
+    attached?(params: AttachedParams): void;
+    /** Called when the primitive is detached. */
+    detached?(): void;
+    /** Notifies the primitive of a data scope update. */
+    updateAllViews?(): void;
+    /** Returns pane views for this primitive. */
+    paneViews?(): readonly IPaneView[];
+    /** Returns price axis views. */
+    priceAxisViews?(): readonly IPriceAxisView[];
+    /** Returns time axis views. */
+    timeAxisViews?(): readonly ITimeAxisView[];
+    /** Hit-test at the given canvas coordinate. */
+    hitTest?(x: number, y: number): PrimitiveHitTestResult | null;
+}
+export interface IPanePrimitive {
+    attached?(params: AttachedParams): void;
+    detached?(): void;
+    updateAllViews?(): void;
+    paneViews?(): readonly IPaneView[];
+    hitTest?(x: number, y: number): PrimitiveHitTestResult | null;
+}
+export type SeriesType = 'candlestick' | 'bar' | 'line' | 'area' | 'histogram' | 'baseline' | 'hollow-candle' | 'heikin-ashi' | 'step-line' | 'colored-line' | 'colored-mountain' | 'hlc-area' | 'high-low' | 'column' | 'volume-candle' | 'baseline-delta-mountain' | 'renko' | 'kagi' | 'line-break' | 'point-figure';
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};

package/dist/core/undo-redo.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Command pattern undo/redo stack.
+ *
+ * Each command has an `execute()` and `undo()` method. Commands are pushed
+ * onto the undo stack when executed, and moved between undo/redo stacks
+ * as the user navigates history.
+ */
+export interface Command {
+    /** Human-readable description for UI. */
+    readonly label: string;
+    /** Execute (or re-execute) the command. */
+    execute(): void;
+    /** Reverse the command. */
+    undo(): void;
+}
+export type UndoRedoChangeCallback = () => void;
+export declare class UndoRedoManager {
+    private _undoStack;
+    private _redoStack;
+    private _maxDepth;
+    private _changeCallbacks;
+    constructor(maxDepth?: number);
+    /** Push and execute a command. Clears the redo stack. */
+    execute(command: Command): void;
+    /** Undo the last command. */
+    undo(): boolean;
+    /** Redo the last undone command. */
+    redo(): boolean;
+    /** Whether undo is available. */
+    canUndo(): boolean;
+    /** Whether redo is available. */
+    canRedo(): boolean;
+    /** Clear both stacks (e.g., on symbol change). */
+    clear(): void;
+    /** Number of undo-able commands. */
+    get undoSize(): number;
+    /** Number of redo-able commands. */
+    get redoSize(): number;
+    /** Get the configured max depth. */
+    get maxDepth(): number;
+    /** Subscribe to changes in undo/redo availability. */
+    onChange(callback: UndoRedoChangeCallback): void;
+    /** Unsubscribe from changes. */
+    offChange(callback: UndoRedoChangeCallback): void;
+    private _notifyChange;
+}

package/dist/currency/currency.d.ts

@@ -0,0 +1,8 @@
+export interface CurrencyInfo {
+    code: string;
+    symbol: string;
+    decimals: number;
+}
+export declare const CURRENCIES: Record<string, CurrencyInfo>;
+export declare function getCurrencyInfo(code: string): CurrencyInfo;
+export declare function formatCurrency(value: number, currencyCode: string, locale?: string): string;

package/dist/currency/index.d.ts

@@ -0,0 +1,2 @@
+export { getCurrencyInfo, formatCurrency, CURRENCIES } from './currency';
+export type { CurrencyInfo } from './currency';

package/dist/drawings/arrow.d.ts

@@ -0,0 +1,10 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class ArrowDrawing extends BaseDrawing {
+    readonly drawingType = "arrow";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createArrow(id: string, points: AnchorPoint[], options: DrawingOptions): ArrowDrawing;

package/dist/drawings/base.d.ts

@@ -0,0 +1,79 @@
+import { ISeriesPrimitive, IPaneView, PrimitiveHitTestResult } from '../core/types';
+import { TimeScale } from '../core/time-scale';
+import { PriceScale } from '../core/price-scale';
+export declare const HIT_THRESHOLD = 6;
+export interface AnchorPoint {
+    time: number;
+    price: number;
+}
+export interface DrawingOptions {
+    color?: string;
+    lineWidth?: number;
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+    fillColor?: string;
+    text?: string;
+    fontSize?: number;
+    /** Whether to show labels on fibonacci and measurement tools. Defaults to true. */
+    showLabels?: boolean;
+}
+export interface SerializedDrawing {
+    type: string;
+    id: string;
+    points: AnchorPoint[];
+    options: DrawingOptions;
+}
+export interface DrawingHitTestResult {
+    drawingId: string;
+    part: 'body' | 'handle1' | 'handle2' | 'handle3' | 'edge';
+    cursorStyle: string;
+}
+export interface DrawingPrimitive {
+    readonly drawingType: string;
+    readonly requiredPoints: number;
+    points: AnchorPoint[];
+    options: DrawingOptions;
+    selected: boolean;
+    serialize(): SerializedDrawing;
+    drawingHitTest(x: number, y: number): DrawingHitTestResult | null;
+}
+/** Coordinate converters passed to drawings so they can map time/price to pixels. */
+export interface DrawingContext {
+    timeScale: TimeScale;
+    priceScale: PriceScale;
+    chartWidth: number;
+    chartHeight: number;
+    requestUpdate(): void;
+}
+/** Distance from point (px,py) to the closest point on segment (x1,y1)-(x2,y2). */
+export declare function distToSegment(px: number, py: number, x1: number, y1: number, x2: number, y2: number): number;
+/** Returns true if (px,py) is inside the axis-aligned rectangle defined by two corners. */
+export declare function pointInRect(px: number, py: number, x1: number, y1: number, x2: number, y2: number): boolean;
+export type DrawingFactory = (id: string, points: AnchorPoint[], options: DrawingOptions) => ISeriesPrimitive & DrawingPrimitive;
+export declare function applyLineStyle(ctx: CanvasRenderingContext2D, style: DrawingOptions['lineStyle']): void;
+/**
+ * Abstract base that implements common ISeriesPrimitive + DrawingPrimitive plumbing.
+ * Subclasses only override _createPaneView().
+ */
+export declare abstract class BaseDrawing implements ISeriesPrimitive, DrawingPrimitive {
+    abstract readonly drawingType: string;
+    abstract readonly requiredPoints: number;
+    points: AnchorPoint[];
+    options: DrawingOptions;
+    selected: boolean;
+    readonly id: string;
+    protected _ctx: DrawingContext | null;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    attached(params: {
+        requestUpdate(): void;
+    }): void;
+    detached(): void;
+    updateAllViews(): void;
+    paneViews(): readonly IPaneView[];
+    hitTest(x: number, y: number): PrimitiveHitTestResult | null;
+    drawingHitTest(x: number, y: number): DrawingHitTestResult | null;
+    serialize(): SerializedDrawing;
+    /** Externally accessible hit-test returning DrawingHitTestResult. */
+    abstract _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    setContext(ctx: DrawingContext): void;
+    protected abstract _createPaneView(): IPaneView;
+}

package/dist/drawings/channel.d.ts

@@ -0,0 +1,10 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class ChannelDrawing extends BaseDrawing {
+    readonly drawingType = "channel";
+    readonly requiredPoints = 3;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createChannel(id: string, points: AnchorPoint[], options: DrawingOptions): ChannelDrawing;

package/dist/drawings/crossline.d.ts

@@ -0,0 +1,10 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class CrosslineDrawing extends BaseDrawing {
+    readonly drawingType = "crossline";
+    readonly requiredPoints = 1;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createCrossline(id: string, points: AnchorPoint[], options: DrawingOptions): CrosslineDrawing;

package/dist/drawings/ellipse.d.ts

@@ -0,0 +1,10 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class EllipseDrawing extends BaseDrawing {
+    readonly drawingType = "ellipse";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createEllipse(id: string, points: AnchorPoint[], options: DrawingOptions): EllipseDrawing;

package/dist/drawings/fib-arc.d.ts

@@ -0,0 +1,10 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class FibArcDrawing extends BaseDrawing {
+    readonly drawingType = "fib-arc";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createFibArc(id: string, points: AnchorPoint[], options: DrawingOptions): FibArcDrawing;

package/dist/drawings/fib-fan.d.ts

@@ -0,0 +1,12 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class FibFanDrawing extends BaseDrawing {
+    readonly drawingType = "fib-fan";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    /** Extend a line from (x1,y1) through (tx,ty) to the chart edge. */
+    private _extendToEdge;
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createFibFan(id: string, points: AnchorPoint[], options: DrawingOptions): FibFanDrawing;

package/dist/drawings/fib-projection.d.ts

@@ -0,0 +1,11 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class FibProjectionDrawing extends BaseDrawing {
+    readonly drawingType = "fib-projection";
+    readonly requiredPoints = 3;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    private _getLevelYs;
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createFibProjection(id: string, points: AnchorPoint[], options: DrawingOptions): FibProjectionDrawing;

package/dist/drawings/fibonacci.d.ts

@@ -0,0 +1,11 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class FibonacciDrawing extends BaseDrawing {
+    readonly drawingType = "fibonacci";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    private _getLevelYs;
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createFibonacci(id: string, points: AnchorPoint[], options: DrawingOptions): FibonacciDrawing;

package/dist/drawings/horizontal-line.d.ts

@@ -0,0 +1,10 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class HorizontalLineDrawing extends BaseDrawing {
+    readonly drawingType = "horizontal-line";
+    readonly requiredPoints = 1;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createHorizontalLine(id: string, points: AnchorPoint[], options: DrawingOptions): HorizontalLineDrawing;

package/dist/drawings/index.d.ts

@@ -0,0 +1,7 @@
+import { ISeriesPrimitive } from '../core/types';
+import { DrawingFactory, AnchorPoint, DrawingOptions, DrawingPrimitive } from './base';
+export type { AnchorPoint, DrawingOptions, DrawingHitTestResult, SerializedDrawing, DrawingPrimitive, DrawingContext, DrawingFactory } from './base';
+export { distToSegment, pointInRect, HIT_THRESHOLD, BaseDrawing } from './base';
+export declare const DRAWING_REGISTRY: Map<string, DrawingFactory>;
+export declare function registerBuiltinDrawings(): void;
+export declare function createBuiltinDrawing(type: string, id: string, points: AnchorPoint[], options: DrawingOptions): (ISeriesPrimitive & DrawingPrimitive) | null;

package/dist/drawings/measurement.d.ts

@@ -0,0 +1,11 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class MeasurementDrawing extends BaseDrawing {
+    readonly drawingType = "measurement";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    private _buildLabel;
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createMeasurement(id: string, points: AnchorPoint[], options: DrawingOptions): MeasurementDrawing;

package/dist/drawings/pitchfork.d.ts

@@ -0,0 +1,12 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class PitchforkDrawing extends BaseDrawing {
+    readonly drawingType = "pitchfork";
+    readonly requiredPoints = 3;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    /** Given pivot (px,py), midpoint (mx,my), and extension factor, return end point. */
+    private _extendLine;
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createPitchfork(id: string, points: AnchorPoint[], options: DrawingOptions): PitchforkDrawing;

package/dist/drawings/ray.d.ts

@@ -0,0 +1,12 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class RayDrawing extends BaseDrawing {
+    readonly drawingType = "ray";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    /** Compute the point where the ray exits the chart bounds. */
+    private _extendedEnd;
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createRay(id: string, points: AnchorPoint[], options: DrawingOptions): RayDrawing;

package/dist/drawings/rectangle.d.ts

@@ -0,0 +1,10 @@
+import { IPaneView } from '../core/types';
+import { BaseDrawing, AnchorPoint, DrawingOptions, DrawingHitTestResult } from './base';
+export declare class RectangleDrawing extends BaseDrawing {
+    readonly drawingType = "rectangle";
+    readonly requiredPoints = 2;
+    constructor(id: string, points: AnchorPoint[], options: DrawingOptions);
+    _hitTestDrawing(x: number, y: number): DrawingHitTestResult | null;
+    protected _createPaneView(): IPaneView;
+}
+export declare function createRectangle(id: string, points: AnchorPoint[], options: DrawingOptions): RectangleDrawing;