lightweight-charts-drawing 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,4017 @@
+/**
+ * lightweight-charts-drawing
+ *
+ * Drawing tools plugin for TradingView's lightweight-charts library.
+ * Provides professional-grade drawing tools including trend lines,
+ * Fibonacci retracements, channels, and more.
+ *
+ * @packageDocumentation
+ */
+
+import { AutoscaleInfo } from 'lightweight-charts';
+import { Coordinate } from 'lightweight-charts';
+import { IChartApi } from 'lightweight-charts';
+import { IPrimitivePaneRenderer } from 'lightweight-charts';
+import { IPrimitivePaneView } from 'lightweight-charts';
+import { ISeriesApi } from 'lightweight-charts';
+import { Logical } from 'lightweight-charts';
+import { PrimitiveHoveredItem } from 'lightweight-charts';
+import { SeriesType } from 'lightweight-charts';
+import { Time } from 'lightweight-charts';
+
+/**
+ * Anchor point in chart coordinates (time/price)
+ */
+export declare interface Anchor {
+    time: Time;
+    price: number;
+}
+
+/**
+ * Anchored Text - Text anchored to a specific point with a connector line.
+ *
+ * Features:
+ * - Two anchor points: anchor position and text position
+ * - Connector line between anchor and text
+ * - Customizable text styling
+ */
+export declare class AnchoredText extends Drawing {
+    readonly type = "anchored-text";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _textOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<AnchoredTextOptions>);
+    get textOptions(): AnchoredTextOptions;
+    setTextOptions(options: Partial<AnchoredTextOptions>): void;
+    setText(text: string): void;
+    getText(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, anchorPoint: Anchor, textPoint: Anchor, text: string, style?: Partial<DrawingStyle>, options?: Partial<AnchoredTextOptions>): AnchoredText;
+}
+
+/**
+ * Anchored Text options
+ */
+export declare interface AnchoredTextOptions extends DrawingOptions {
+    text?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: string;
+    textAlign?: CanvasTextAlign;
+    showConnector?: boolean;
+    connectorLength?: number;
+}
+
+export declare class AnchoredTextPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: AnchoredText);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * AndrewsPitchfork - Andrews' Pitchfork pattern for channel analysis.
+ *
+ * Features:
+ * - Three anchor points (pivot, and two swing points)
+ * - Median line from pivot through midpoint of swings
+ * - Parallel outer lines through swing points
+ * - Optional fill between lines
+ */
+export declare class AndrewsPitchfork extends Drawing {
+    readonly type = "andrews-pitchfork";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _pitchforkOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<AndrewsPitchforkOptions>);
+    get pitchforkOptions(): AndrewsPitchforkOptions;
+    setPitchforkOptions(options: Partial<AndrewsPitchforkOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pivot: Anchor, swing1: Anchor, swing2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<AndrewsPitchforkOptions>): AndrewsPitchfork;
+}
+
+/**
+ * AndrewsPitchfork options
+ */
+export declare interface AndrewsPitchforkOptions extends DrawingOptions {
+    showMedianLine?: boolean;
+    showOuterLines?: boolean;
+    extendLines?: boolean;
+    filled?: boolean;
+}
+
+export declare class AndrewsPitchforkPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: AndrewsPitchfork);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Set up canvas context with drawing style
+ */
+export declare function applyStyle(ctx: CanvasRenderingContext2D, style: DrawingStyle, pixelRatio?: number): void;
+
+/**
+ * Arc - A circular arc defined by three points.
+ *
+ * Features:
+ * - Three anchor points: center, start point (defines radius and start angle), end point (defines end angle)
+ * - Optional fill (pie slice)
+ * - Draws the shorter arc between start and end angles
+ */
+export declare class Arc extends Drawing {
+    readonly type = "arc";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _arcOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ArcOptions>);
+    get arcOptions(): ArcOptions;
+    setArcOptions(options: Partial<ArcOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get arc parameters from the three anchor points
+     */
+    getArcParams(viewport: Viewport): {
+        center: Point;
+        radius: number;
+        startAngle: number;
+        endAngle: number;
+    } | null;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, center: Anchor, startPoint: Anchor, endPoint: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ArcOptions>): Arc;
+}
+
+/**
+ * Arc/circle geometry
+ */
+export declare interface ArcGeometry {
+    type: 'arc';
+    center: Point;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    counterClockwise?: boolean;
+}
+
+/**
+ * Arc options
+ */
+export declare interface ArcOptions extends DrawingOptions {
+    filled?: boolean;
+}
+
+export declare class ArcPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Arc);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Arrow - A line with an arrowhead at the end.
+ *
+ * Features:
+ * - Two anchor points
+ * - Arrowhead at the end point
+ * - Optional arrowhead at both ends
+ * - Configurable arrow size
+ */
+export declare class Arrow extends BaseLine {
+    readonly type = "arrow";
+    private _arrowOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ArrowOptions>);
+    get arrowOptions(): ArrowOptions;
+    setArrowOptions(options: Partial<ArrowOptions>): void;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    clone(newId: string): IDrawing;
+    static create(id: string, startAnchor: Anchor, endAnchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ArrowOptions>): Arrow;
+}
+
+/**
+ * Arrow direction
+ */
+export declare type ArrowDirection = 'up' | 'down' | 'left' | 'right';
+
+/**
+ * Arrow Mark Down - A downward pointing arrow marker (bearish signal).
+ *
+ * Features:
+ * - Single anchor point
+ * - Always points down
+ * - Typically placed above price bars
+ * - Red color by default
+ */
+export declare class ArrowMarkDown extends Drawing {
+    readonly type = "arrow-mark-down";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _arrowOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ArrowMarkDownOptions>);
+    get arrowOptions(): ArrowMarkDownOptions;
+    setArrowOptions(options: Partial<ArrowMarkDownOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get arrow vertices (always points down)
+     */
+    getArrowVertices(viewport: Viewport): Point[] | null;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private pointInTriangle;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ArrowMarkDownOptions>): ArrowMarkDown;
+}
+
+/**
+ * Arrow Mark Down options
+ */
+export declare interface ArrowMarkDownOptions extends DrawingOptions {
+    size?: number;
+}
+
+export declare class ArrowMarkDownPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: ArrowMarkDown);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Arrow Marker - A directional arrow placed at a single point.
+ *
+ * Features:
+ * - Single anchor point
+ * - Configurable direction (up, down, left, right)
+ * - Configurable size
+ * - Optional fill
+ */
+export declare class ArrowMarker extends Drawing {
+    readonly type = "arrow-marker";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _arrowOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ArrowMarkerOptions>);
+    get arrowOptions(): ArrowMarkerOptions;
+    setArrowOptions(options: Partial<ArrowMarkerOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get arrow vertices based on position and direction
+     */
+    getArrowVertices(viewport: Viewport): Point[] | null;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private pointInTriangle;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ArrowMarkerOptions>): ArrowMarker;
+}
+
+/**
+ * Arrow marker options
+ */
+export declare interface ArrowMarkerOptions extends DrawingOptions {
+    direction?: ArrowDirection;
+    size?: number;
+    filled?: boolean;
+}
+
+export declare class ArrowMarkerPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: ArrowMarker);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Arrow Mark Up - An upward pointing arrow marker (bullish signal).
+ *
+ * Features:
+ * - Single anchor point
+ * - Always points up
+ * - Typically placed below price bars
+ * - Green color by default
+ */
+export declare class ArrowMarkUp extends Drawing {
+    readonly type = "arrow-mark-up";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _arrowOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ArrowMarkUpOptions>);
+    get arrowOptions(): ArrowMarkUpOptions;
+    setArrowOptions(options: Partial<ArrowMarkUpOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get arrow vertices (always points up)
+     */
+    getArrowVertices(viewport: Viewport): Point[] | null;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private pointInTriangle;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ArrowMarkUpOptions>): ArrowMarkUp;
+}
+
+/**
+ * Arrow Mark Up options
+ */
+export declare interface ArrowMarkUpOptions extends DrawingOptions {
+    size?: number;
+}
+
+export declare class ArrowMarkUpPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: ArrowMarkUp);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Arrow options
+ */
+export declare interface ArrowOptions extends DrawingOptions {
+    arrowSize?: number;
+    showBothEnds?: boolean;
+}
+
+export declare class ArrowPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Arrow);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * BarsPattern - Pattern projection tool.
+ *
+ * Features:
+ * - Three anchor points: pattern start (A), pattern end (B), projection start (C)
+ * - Copies the price pattern from A-B and projects it from C
+ * - Shows the projected pattern zone
+ */
+export declare class BarsPattern extends Drawing {
+    readonly type = "bars-pattern";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _barsPatternOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<BarsPatternOptions>);
+    get barsPatternOptions(): BarsPatternOptions;
+    setBarsPatternOptions(options: Partial<BarsPatternOptions>): void;
+    /**
+     * Get pattern info.
+     * A = pattern start, B = pattern end, C = projection start.
+     * The pattern from A-B is projected starting at C.
+     */
+    getPatternInfo(): {
+        priceRange: number;
+        timeSpan: number;
+        projectedEndPrice: number;
+    };
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pointA: Anchor, pointB: Anchor, pointC: Anchor, style?: Partial<DrawingStyle>, options?: Partial<BarsPatternOptions>): BarsPattern;
+}
+
+/**
+ * Bars Pattern options
+ */
+export declare interface BarsPatternOptions extends DrawingOptions {
+    showLabels?: boolean;
+    filled?: boolean;
+    patternColor?: string;
+}
+
+export declare class BarsPatternPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: BarsPattern);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Base class for two-point line drawings.
+ * Provides common functionality for trend lines, rays, arrows, etc.
+ */
+export declare abstract class BaseLine extends Drawing {
+    protected static readonly HIT_THRESHOLD = 5;
+    protected static readonly REQUIRED_ANCHORS = 2;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DrawingOptions>);
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    /**
+     * Convert a Time value to epoch seconds.
+     * Handles numeric timestamps, "YYYY-MM-DD" strings, and BusinessDay objects.
+     */
+    protected static timeToSeconds(time: any): number;
+    /**
+     * Get the angle of the line in degrees
+     */
+    getAngle(): number;
+    /**
+     * Get the price change between anchors
+     */
+    getPriceChange(): {
+        absolute: number;
+        percentage: number;
+    };
+    /**
+     * Get the time span between anchors in bars (calendar days)
+     */
+    getTimeSpan(): number;
+}
+
+/**
+ * Brush - Freehand drawing tool.
+ *
+ * Features:
+ * - Multiple anchor points forming a path
+ * - Variable brush size
+ * - Smooth line rendering
+ */
+export declare class Brush extends Drawing {
+    readonly type = "brush";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _brushOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<BrushOptions>);
+    get brushOptions(): BrushOptions;
+    setBrushOptions(options: Partial<BrushOptions>): void;
+    /**
+     * Add a point to the brush path
+     */
+    addPoint(anchor: Anchor): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, points: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<BrushOptions>): Brush;
+}
+
+/**
+ * Brush options
+ */
+export declare interface BrushOptions extends DrawingOptions {
+    brushSize?: number;
+    smoothing?: number;
+}
+
+export declare class BrushPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Brush);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Calculate price change percentage between two prices
+ */
+export declare function calculatePriceChange(startPrice: number, endPrice: number): {
+    change: number;
+    percentage: number;
+};
+
+/**
+ * Callout - A text box with a pointer to a specific point.
+ *
+ * Features:
+ * - Two anchor points (target and box position)
+ * - Text box with pointer/arrow to target
+ * - Customizable appearance
+ */
+export declare class Callout extends Drawing {
+    readonly type = "callout";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _calloutOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<CalloutOptions>);
+    get calloutOptions(): CalloutOptions;
+    setCalloutOptions(options: Partial<CalloutOptions>): void;
+    setText(text: string): void;
+    getText(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(_viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, target: Anchor, boxPosition: Anchor, text: string, style?: Partial<DrawingStyle>, options?: Partial<CalloutOptions>): Callout;
+}
+
+/**
+ * Callout options
+ */
+export declare interface CalloutOptions extends DrawingOptions {
+    text?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+    padding?: number;
+    pointerSize?: number;
+}
+
+export declare class CalloutPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Callout);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Chart to pixel coordinate conversion function
+ */
+export declare type ChartToPixelFn = (anchor: Anchor) => Point | null;
+
+/**
+ * Circle - A circular shape defined by center and edge point.
+ *
+ * Features:
+ * - Two anchor points (center and edge)
+ * - Radius determined by distance between points
+ * - Optional fill
+ */
+export declare class Circle extends Drawing {
+    readonly type = "circle";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _circleOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<CircleOptions>);
+    get circleOptions(): CircleOptions;
+    setCircleOptions(options: Partial<CircleOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    /**
+     * Get the radius in pixels (requires viewport)
+     */
+    getRadius(viewport: Viewport): number;
+    clone(newId: string): IDrawing;
+    static create(id: string, center: Anchor, edge: Anchor, style?: Partial<DrawingStyle>, options?: Partial<CircleOptions>): Circle;
+}
+
+/**
+ * Circle options
+ */
+export declare interface CircleOptions extends DrawingOptions {
+    filled?: boolean;
+}
+
+export declare class CirclePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Circle);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Comment - A speech-bubble style comment marker.
+ *
+ * Features:
+ * - Single anchor point
+ * - Speech bubble with text
+ * - Customizable colors
+ */
+declare class Comment_2 extends Drawing {
+    readonly type = "comment";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 15;
+    private _commentOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<CommentOptions>);
+    get commentOptions(): CommentOptions;
+    setCommentOptions(options: Partial<CommentOptions>): void;
+    setText(text: string): void;
+    getText(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, text: string, style?: Partial<DrawingStyle>, options?: Partial<CommentOptions>): Comment_2;
+}
+export { Comment_2 as Comment }
+
+/**
+ * Comment options
+ */
+export declare interface CommentOptions extends DrawingOptions {
+    text?: string;
+    fontSize?: number;
+    backgroundColor?: string;
+    textColor?: string;
+}
+
+export declare class CommentPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Comment_2);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Control point for anchor manipulation
+ */
+export declare interface ControlPoint {
+    index: number;
+    x: number;
+    y: number;
+    radius: number;
+}
+
+/**
+ * CrossLine - A crosshair at a specific point (horizontal + vertical lines).
+ *
+ * Features:
+ * - Single anchor point
+ * - Horizontal and vertical lines through the point
+ * - Optional price and time labels
+ */
+export declare class CrossLine extends Drawing {
+    readonly type = "cross-line";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _crossLineOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<CrossLineOptions>);
+    get crossLineOptions(): CrossLineOptions;
+    setCrossLineOptions(options: Partial<CrossLineOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, anchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<CrossLineOptions>): CrossLine;
+}
+
+/**
+ * CrossLine options
+ */
+export declare interface CrossLineOptions extends DrawingOptions {
+    showPrice?: boolean;
+    showTime?: boolean;
+}
+
+export declare class CrossLinePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: CrossLine);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Curve - Cubic Bezier curve with two endpoints and two control points.
+ *
+ * Features:
+ * - Four anchor points: start, control1, control2, end
+ * - Smooth curve using cubic bezier interpolation
+ * - Optional control line visualization
+ */
+export declare class Curve extends Drawing {
+    readonly type = "curve";
+    protected static readonly REQUIRED_ANCHORS = 4;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _curveOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<CurveOptions>);
+    get curveOptions(): CurveOptions;
+    setCurveOptions(options: Partial<CurveOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get points along the bezier curve
+     */
+    getCurvePoints(viewport: Viewport): Point[] | null;
+    /**
+     * Get the control points for visualization
+     */
+    getControlPointsPixels(viewport: Viewport): {
+        start: Point;
+        control1: Point;
+        control2: Point;
+        end: Point;
+    } | null;
+    private cubicBezier;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private distanceToSegment;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, control1: Anchor, control2: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<CurveOptions>): Curve;
+}
+
+/**
+ * Curve options
+ */
+export declare interface CurveOptions extends DrawingOptions {
+    showControlLines?: boolean;
+    resolution?: number;
+}
+
+export declare class CurvePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Curve);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * DatePriceRange - Combined date and price measurement tool.
+ *
+ * Features:
+ * - Two anchor points (diagonal corners)
+ * - Shows price change (absolute and percentage)
+ * - Shows time change (bars and days)
+ * - Rectangular measurement zone
+ */
+export declare class DatePriceRange extends Drawing {
+    readonly type = "date-price-range";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _measureOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DatePriceRangeOptions>);
+    get measureOptions(): DatePriceRangeOptions;
+    setMeasureOptions(options: Partial<DatePriceRangeOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get measurement info
+     */
+    getMeasureInfo(): {
+        startPrice: number;
+        endPrice: number;
+        priceChange: number;
+        priceChangePercent: number;
+        startTime: any;
+        endTime: any;
+        days: number;
+        bars: number;
+        isUp: boolean;
+    };
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<DatePriceRangeOptions>): DatePriceRange;
+}
+
+/**
+ * DatePriceRange options
+ */
+export declare interface DatePriceRangeOptions extends DrawingOptions {
+    showPrices?: boolean;
+    showPercentage?: boolean;
+    showBars?: boolean;
+    showDays?: boolean;
+    filled?: boolean;
+}
+
+export declare class DatePriceRangePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: DatePriceRange);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * DateRange - Time measurement tool.
+ *
+ * Features:
+ * - Two anchor points for start and end time
+ * - Shows number of bars between points
+ * - Shows number of calendar days
+ * - Highlighted time zone
+ */
+export declare class DateRange extends Drawing {
+    readonly type = "date-range";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _dateRangeOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DateRangeOptions>);
+    get dateRangeOptions(): DateRangeOptions;
+    setDateRangeOptions(options: Partial<DateRangeOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get date range info
+     */
+    getDateRangeInfo(): {
+        startTime: any;
+        endTime: any;
+        days: number;
+        bars: number;
+    };
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<DateRangeOptions>): DateRange;
+}
+
+/**
+ * DateRange options
+ */
+export declare interface DateRangeOptions extends DrawingOptions {
+    showBars?: boolean;
+    showDays?: boolean;
+    showDates?: boolean;
+    filled?: boolean;
+}
+
+export declare class DateRangePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: DateRange);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Default drawing style
+ */
+export declare const DEFAULT_DRAWING_STYLE: DrawingStyle;
+
+/**
+ * DisjointChannel - A channel with two independent lines that don't have to be parallel.
+ *
+ * Features:
+ * - Four anchor points: two for upper line, two for lower line
+ * - Lines can be at any angle (not necessarily parallel)
+ * - Optional fill between lines
+ * - Optional middle line
+ * - Optional line extensions
+ *
+ * Points:
+ * - Anchor 0-1: First line
+ * - Anchor 2-3: Second line
+ */
+export declare class DisjointChannel extends Drawing {
+    readonly type = "disjoint-channel";
+    protected static readonly REQUIRED_ANCHORS = 4;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _channelOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DisjointChannelOptions>);
+    get channelOptions(): DisjointChannelOptions;
+    setChannelOptions(options: Partial<DisjointChannelOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private isPointInPolygon;
+    clone(newId: string): IDrawing;
+    static create(id: string, line1Start: Anchor, line1End: Anchor, line2Start: Anchor, line2End: Anchor, style?: Partial<DrawingStyle>, options?: Partial<DisjointChannelOptions>): DisjointChannel;
+}
+
+/**
+ * DisjointChannel options
+ */
+export declare interface DisjointChannelOptions extends DrawingOptions {
+    filled?: boolean;
+    extendLines?: boolean;
+    showMiddleLine?: boolean;
+}
+
+export declare class DisjointChannelPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: DisjointChannel);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Calculate distance between two points
+ */
+export declare function distanceBetweenPoints(p1: Point, p2: Point): number;
+
+/**
+ * Calculate distance from point to infinite line
+ */
+export declare function distanceToLine(point: Point, lineStart: Point, lineEnd: Point): number;
+
+/**
+ * Calculate distance from point to line segment
+ */
+export declare function distanceToLineSegment(point: Point, lineStart: Point, lineEnd: Point): number;
+
+/**
+ * DoubleCurve - S-curve with two control points creating an S-shape.
+ *
+ * Features:
+ * - Three anchor points: start, middle (inflection), end
+ * - Automatic control point calculation for smooth S-curve
+ * - Adjustable curvature
+ */
+export declare class DoubleCurve extends Drawing {
+    readonly type = "double-curve";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _doubleCurveOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DoubleCurveOptions>);
+    get doubleCurveOptions(): DoubleCurveOptions;
+    setDoubleCurveOptions(options: Partial<DoubleCurveOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get the three main points
+     */
+    getMainPoints(viewport: Viewport): {
+        start: Point;
+        middle: Point;
+        end: Point;
+    } | null;
+    /**
+     * Calculate bezier control points for the S-curve
+     */
+    getBezierControlPoints(viewport: Viewport): {
+        cp1: Point;
+        cp2: Point;
+        cp3: Point;
+        cp4: Point;
+    } | null;
+    /**
+     * Get points along the S-curve
+     */
+    getCurvePoints(viewport: Viewport): Point[] | null;
+    private cubicBezier;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private distanceToSegment;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, middle: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<DoubleCurveOptions>): DoubleCurve;
+}
+
+/**
+ * Double Curve options
+ */
+export declare interface DoubleCurveOptions extends DrawingOptions {
+    showControlPoints?: boolean;
+    curvature?: number;
+    resolution?: number;
+}
+
+export declare class DoubleCurvePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: DoubleCurve);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Draw an arrow head at the end of a line
+ */
+export declare function drawArrowHead(ctx: CanvasRenderingContext2D, from: Point, to: Point, size?: number, pixelRatio?: number): void;
+
+/**
+ * Draw a circle
+ */
+export declare function drawCircle(ctx: CanvasRenderingContext2D, center: Point, radius: number, fill?: boolean, pixelRatio?: number): void;
+
+/**
+ * Draw a control point (anchor handle) in TradingView style:
+ * dark filled center with a colored ring.
+ */
+export declare function drawControlPoint(ctx: CanvasRenderingContext2D, point: ControlPoint, isActive?: boolean, pixelRatio?: number, lineColor?: string): void;
+
+/**
+ * Draw all control points for a drawing
+ */
+export declare function drawControlPoints(ctx: CanvasRenderingContext2D, points: ControlPoint[], activeIndex?: number | null, pixelRatio?: number, lineColor?: string): void;
+
+/**
+ * Draw a dashed line between two points
+ */
+export declare function drawDashedLine(ctx: CanvasRenderingContext2D, start: Point, end: Point, dashPattern?: number[], pixelRatio?: number): void;
+
+/**
+ * Draw a filled arrow head
+ */
+export declare function drawFilledArrowHead(ctx: CanvasRenderingContext2D, from: Point, to: Point, size?: number, pixelRatio?: number): void;
+
+/**
+ * Abstract base class for all drawing tools.
+ * Implements ISeriesPrimitive for integration with lightweight-charts.
+ */
+export declare abstract class Drawing implements IDrawing {
+    readonly id: string;
+    abstract readonly type: string;
+    protected _anchors: Anchor[];
+    protected _style: DrawingStyle;
+    protected _options: DrawingOptions;
+    protected _state: DrawingState;
+    protected _series: ISeriesApi<SeriesType> | null;
+    protected _chart: IChartApi | null;
+    protected _container: HTMLElement | null;
+    protected _requestUpdateFn: (() => void) | null;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DrawingOptions>);
+    get anchors(): Anchor[];
+    get style(): DrawingStyle;
+    get options(): DrawingOptions;
+    get state(): DrawingState;
+    set anchors(value: Anchor[]);
+    set style(value: DrawingStyle);
+    set options(value: DrawingOptions);
+    set state(value: DrawingState);
+    attach(series: ISeriesApi<SeriesType>, chart: IChartApi, container?: HTMLElement): void;
+    detach(): void;
+    isAttached(): boolean;
+    requestUpdate(): void;
+    attached(params: {
+        chart: IChartApi;
+        series: ISeriesApi<SeriesType>;
+        requestUpdate: () => void;
+    }): void;
+    detached(): void;
+    /**
+     * Returns pane views for rendering. Must be implemented by subclasses.
+     */
+    abstract paneViews(): IPrimitivePaneView[];
+    /**
+     * Optional: Provide hit testing for the primitive (lightweight-charts interface)
+     */
+    hitTest(x: number, y: number): PrimitiveHoveredItem | null;
+    /**
+     * Optional: Provide autoscale info
+     */
+    autoscaleInfo(): AutoscaleInfo | null;
+    setAnchors(anchors: Anchor[]): void;
+    updateAnchor(index: number, anchor: Anchor): void;
+    updateStyle(style: Partial<DrawingStyle>): void;
+    updateOptions(options: Partial<DrawingOptions>): void;
+    setState(state: DrawingState): void;
+    /**
+     * Test if point hits the drawing. Must be implemented by subclasses.
+     */
+    abstract testHit(point: Point, viewport: Viewport): boolean;
+    /**
+     * Test if point hits an anchor control point
+     */
+    hitTestAnchor(point: Point, viewport: Viewport): number | null;
+    /**
+     * Get control points for anchor manipulation
+     */
+    getControlPoints(viewport: Viewport): ControlPoint[];
+    anchorToPixel(anchor: Anchor, viewport: Viewport): Point | null;
+    protected pixelToAnchor(point: Point, viewport: Viewport): Anchor | null;
+    getViewport(): Viewport | null;
+    /**
+     * Compute geometry for rendering. Must be implemented by subclasses.
+     */
+    abstract computeGeometry(viewport: Viewport): Geometry[];
+    /**
+     * Check if drawing is valid (has required anchors). Must be implemented by subclasses.
+     */
+    abstract isValid(): boolean;
+    toJSON(): SerializedDrawing;
+    fromJSON(data: SerializedDrawing): void;
+    /**
+     * Create a clone of this drawing. Must be implemented by subclasses.
+     */
+    abstract clone(newId: string): IDrawing;
+}
+
+/**
+ * Drawing categories for organization
+ */
+export declare type DrawingCategory = 'line' | 'channel' | 'fibonacci' | 'gann' | 'pitchfork' | 'shape' | 'annotation' | 'trading' | 'forecasting' | 'measurement';
+
+/**
+ * Drawing event payload
+ */
+export declare interface DrawingEvent {
+    type: DrawingEventType;
+    drawingId?: string;
+    drawing?: IDrawing;
+    toolType?: string;
+}
+
+/**
+ * Event callback type
+ */
+export declare type DrawingEventCallback = (event: DrawingEvent) => void;
+
+/**
+ * Event types emitted by DrawingManager
+ */
+export declare type DrawingEventType = 'drawing:added' | 'drawing:removed' | 'drawing:selected' | 'drawing:deselected' | 'drawing:updated' | 'drawing:cleared' | 'tool:changed';
+
+/**
+ * DrawingManager - Central orchestration system for managing drawings.
+ *
+ * Responsibilities:
+ * - Creating, storing, removing drawings
+ * - Attaching/detaching to chart series
+ * - Hit detection and selection
+ * - Interaction state management
+ * - JSON import/export
+ * - Event emission
+ */
+export declare class DrawingManager {
+    private _drawings;
+    private _selectedId;
+    private _chart;
+    private _series;
+    private _container;
+    private _listeners;
+    private _isAttached;
+    private _activeTool;
+    private _isDragging;
+    private _dragAnchorIndex;
+    constructor();
+    /**
+     * Attach manager to a chart and series
+     */
+    attach(chart: IChartApi, series: ISeriesApi<SeriesType>, container: HTMLElement): void;
+    /**
+     * Detach manager from chart
+     */
+    detach(): void;
+    /**
+     * Check if manager is attached
+     */
+    isAttached(): boolean;
+    /**
+     * Add a drawing to the manager
+     */
+    addDrawing(drawing: IDrawing): void;
+    /**
+     * Remove a drawing by id
+     */
+    removeDrawing(id: string): void;
+    /**
+     * Get a drawing by id
+     */
+    getDrawing(id: string): IDrawing | undefined;
+    /**
+     * Get all drawings
+     */
+    getAllDrawings(): IDrawing[];
+    /**
+     * Clear all drawings
+     */
+    clearAll(): void;
+    /**
+     * Select a drawing by id
+     */
+    selectDrawing(id: string): void;
+    /**
+     * Deselect all drawings
+     */
+    deselectAll(): void;
+    /**
+     * Get selected drawing
+     */
+    getSelectedDrawing(): IDrawing | null;
+    /**
+     * Set the active drawing tool
+     */
+    setActiveTool(toolType: string | null): void;
+    /**
+     * Get the active drawing tool
+     */
+    getActiveTool(): string | null;
+    /**
+     * Find drawing at point
+     */
+    hitTest(point: Point): IDrawing | null;
+    /**
+     * Find anchor at point for selected drawing
+     */
+    hitTestAnchor(point: Point): number | null;
+    private handleClick;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private getPointFromEvent;
+    private getViewport;
+    /**
+     * Export all drawings as JSON
+     */
+    exportDrawings(): SerializedDrawing[];
+    /**
+     * Import drawings from JSON (requires a factory function)
+     */
+    importDrawings(data: SerializedDrawing[], factory: (type: string, data: SerializedDrawing) => IDrawing | null): void;
+    /**
+     * Subscribe to an event
+     */
+    on(event: DrawingEventType, callback: DrawingEventCallback): () => void;
+    /**
+     * Emit an event
+     */
+    private emit;
+}
+
+/**
+ * Drawing options beyond style
+ */
+export declare interface DrawingOptions {
+    visible?: boolean;
+    locked?: boolean;
+    zIndex?: number;
+    extendLeft?: boolean;
+    extendRight?: boolean;
+}
+
+/**
+ * Pane view implementation for Drawing primitives
+ */
+export declare class DrawingPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Drawing);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Drawing state for selection/editing
+ */
+export declare type DrawingState = 'normal' | 'hovered' | 'selected' | 'editing';
+
+/**
+ * Visual style for drawings
+ */
+export declare interface DrawingStyle {
+    lineColor: string;
+    lineWidth: number;
+    lineDash?: number[];
+    fillColor?: string;
+    fillOpacity?: number;
+    showLabels?: boolean;
+    labelFont?: string;
+    labelColor?: string;
+}
+
+/**
+ * Drawing tool metadata for registration
+ */
+export declare interface DrawingToolDefinition {
+    type: string;
+    name: string;
+    category: DrawingCategory;
+    icon?: string;
+    shortcut?: string;
+    requiredAnchors: number;
+    defaultStyle?: Partial<DrawingStyle>;
+    defaultOptions?: Partial<DrawingOptions>;
+}
+
+/**
+ * Draw a label with background
+ */
+export declare function drawLabel(ctx: CanvasRenderingContext2D, text: string, position: Point, style?: {
+    font?: string;
+    textColor?: string;
+    backgroundColor?: string;
+    padding?: number;
+    borderRadius?: number;
+}, pixelRatio?: number): void;
+
+/**
+ * Draw a line between two points
+ */
+export declare function drawLine(ctx: CanvasRenderingContext2D, start: Point, end: Point, pixelRatio?: number): void;
+
+/**
+ * Draw a rectangle
+ */
+export declare function drawRect(ctx: CanvasRenderingContext2D, topLeft: Point, width: number, height: number, fill?: boolean, pixelRatio?: number): void;
+
+/**
+ * Draw text at a position
+ */
+export declare function drawText(ctx: CanvasRenderingContext2D, text: string, position: Point, font?: string, color?: string, align?: CanvasTextAlign, baseline?: CanvasTextBaseline, pixelRatio?: number): void;
+
+/**
+ * Ellipse - An elliptical shape defined by two corner points of bounding box.
+ *
+ * Features:
+ * - Two anchor points (opposite corners of bounding rectangle)
+ * - Optional fill
+ * - Axis-aligned ellipse
+ */
+export declare class Ellipse extends Drawing {
+    readonly type = "ellipse";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _ellipseOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<EllipseOptions>);
+    get ellipseOptions(): EllipseOptions;
+    setEllipseOptions(options: Partial<EllipseOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get ellipse parameters
+     */
+    getEllipseParams(viewport: Viewport): {
+        center: Point;
+        radiusX: number;
+        radiusY: number;
+    } | null;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, corner1: Anchor, corner2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<EllipseOptions>): Ellipse;
+}
+
+/**
+ * Ellipse options
+ */
+export declare interface EllipseOptions extends DrawingOptions {
+    filled?: boolean;
+}
+
+export declare class EllipsePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Ellipse);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * ExtendedLine - A line that extends infinitely in both directions.
+ *
+ * Features:
+ * - Two anchor points define the line
+ * - Extends infinitely in both directions
+ * - Optional angle display
+ */
+export declare class ExtendedLine extends BaseLine {
+    readonly type = "extended-line";
+    private _extendedLineOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ExtendedLineOptions>);
+    get extendedLineOptions(): ExtendedLineOptions;
+    setExtendedLineOptions(options: Partial<ExtendedLineOptions>): void;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    clone(newId: string): IDrawing;
+    static create(id: string, startAnchor: Anchor, endAnchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ExtendedLineOptions>): ExtendedLine;
+}
+
+/**
+ * ExtendedLine options
+ */
+export declare interface ExtendedLineOptions extends DrawingOptions {
+    showAngle?: boolean;
+}
+
+export declare class ExtendedLinePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: ExtendedLine);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Extend line to viewport boundaries
+ */
+export declare function extendLineToViewport(start: Point, end: Point, viewportWidth: number, viewportHeight: number, extendLeft: boolean, extendRight: boolean): {
+    start: Point;
+    end: Point;
+};
+
+/**
+ * Fibonacci arc levels
+ */
+export declare const FIB_ARC_LEVELS: number[];
+
+/**
+ * Standard Fibonacci channel levels
+ */
+export declare const FIB_CHANNEL_LEVELS: number[];
+
+/**
+ * Fibonacci circle levels
+ */
+export declare const FIB_CIRCLE_LEVELS: number[];
+
+/**
+ * Standard Fibonacci extension levels
+ */
+export declare const FIB_EXTENSION_LEVELS: number[];
+
+/**
+ * Fibonacci speed fan ratios
+ */
+export declare const FIB_SPEED_RATIOS: number[];
+
+/**
+ * Fibonacci time extension levels
+ */
+export declare const FIB_TIME_EXTENSION_LEVELS: number[];
+
+/**
+ * Fibonacci time zone intervals (0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89...)
+ */
+export declare const FIB_TIME_INTERVALS: number[];
+
+/**
+ * Fibonacci wedge levels
+ */
+export declare const FIB_WEDGE_LEVELS: number[];
+
+/**
+ * FibArcs - Speed/Resistance arcs at Fibonacci ratios.
+ *
+ * Features:
+ * - Two anchor points (pivot and extent)
+ * - Semi-circular or full arcs at Fibonacci distances
+ * - Optional labels showing level
+ * - Can show half or full circles
+ */
+export declare class FibArcs extends Drawing {
+    readonly type = "fib-arcs";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibArcsOptions>);
+    get fibOptions(): FibArcsOptions;
+    setFibOptions(options: Partial<FibArcsOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pivot: Anchor, extent: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibArcsOptions>): FibArcs;
+}
+
+/**
+ * FibArcs options
+ */
+export declare interface FibArcsOptions extends DrawingOptions {
+    levels?: number[];
+    showLabels?: boolean;
+    fullCircle?: boolean;
+}
+
+export declare class FibArcsPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibArcs);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibChannel - Fibonacci Channel with parallel trend lines at Fibonacci ratios.
+ *
+ * Features:
+ * - Three anchor points (two for baseline, one for channel width)
+ * - Multiple parallel lines at Fibonacci levels
+ * - Optional fill between levels
+ * - Optional line extensions
+ */
+export declare class FibChannel extends Drawing {
+    readonly type = "fib-channel";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibChannelOptions>);
+    get fibOptions(): FibChannelOptions;
+    setFibOptions(options: Partial<FibChannelOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Calculate the perpendicular offset from baseline to p3
+     */
+    calculateOffset(p1: Point, p2: Point, p3: Point): Point;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, width: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibChannelOptions>): FibChannel;
+}
+
+/**
+ * FibChannel options
+ */
+export declare interface FibChannelOptions extends DrawingOptions {
+    levels?: number[];
+    showPrices?: boolean;
+    showPercentages?: boolean;
+    extendLines?: boolean;
+    filled?: boolean;
+}
+
+export declare class FibChannelPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibChannel);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibCircles - Concentric circles at Fibonacci ratios.
+ *
+ * Features:
+ * - Two anchor points (center and radius point)
+ * - Concentric circles at Fibonacci ratio distances
+ * - Optional labels showing level
+ * - Optional fill between circles
+ */
+export declare class FibCircles extends Drawing {
+    readonly type = "fib-circles";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibCirclesOptions>);
+    get fibOptions(): FibCirclesOptions;
+    setFibOptions(options: Partial<FibCirclesOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, center: Anchor, radiusPoint: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibCirclesOptions>): FibCircles;
+}
+
+/**
+ * FibCircles options
+ */
+export declare interface FibCirclesOptions extends DrawingOptions {
+    levels?: number[];
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class FibCirclesPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibCircles);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibExtension - Fibonacci extension levels based on three points.
+ *
+ * Features:
+ * - Three anchor points (A, B, C - swing high/low/retracement)
+ * - Extension levels projected from point C
+ * - Optional price and percentage labels
+ */
+export declare class FibExtension extends Drawing {
+    readonly type = "fib-extension";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibExtensionOptions>);
+    get fibOptions(): FibExtensionOptions;
+    setFibOptions(options: Partial<FibExtensionOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    /**
+     * Get price at a specific extension level
+     */
+    getPriceAtLevel(level: number): number;
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pointA: Anchor, pointB: Anchor, pointC: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibExtensionOptions>): FibExtension;
+}
+
+/**
+ * FibExtension options
+ */
+export declare interface FibExtensionOptions extends DrawingOptions {
+    levels?: number[];
+    showPrices?: boolean;
+    showPercentages?: boolean;
+    extendLines?: boolean;
+}
+
+export declare class FibExtensionPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibExtension);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Standard Fibonacci ratios
+ */
+export declare const FIBONACCI_LEVELS: number[];
+
+/**
+ * FibRetracement - Fibonacci retracement levels between two price points.
+ *
+ * Features:
+ * - Two anchor points (high and low)
+ * - Multiple Fibonacci level lines
+ * - Optional price and percentage labels
+ * - Optional line extensions
+ * - Customizable levels
+ */
+export declare class FibRetracement extends Drawing {
+    readonly type = "fib-retracement";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibRetracementOptions>);
+    get fibOptions(): FibRetracementOptions;
+    setFibOptions(options: Partial<FibRetracementOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    /**
+     * Calculate price at a specific Fibonacci level
+     */
+    getPriceAtLevel(level: number): number;
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibRetracementOptions>): FibRetracement;
+}
+
+/**
+ * FibRetracement options
+ */
+export declare interface FibRetracementOptions extends DrawingOptions {
+    levels?: number[];
+    showPrices?: boolean;
+    showPercentages?: boolean;
+    extendLines?: boolean;
+    reverseDirection?: boolean;
+}
+
+export declare class FibRetracementPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibRetracement);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibSpeedFan - Speed/Resistance fan lines at Fibonacci ratios.
+ *
+ * Features:
+ * - Two anchor points define the main trend
+ * - Fan lines emanating from first point at Fibonacci slope ratios
+ * - Optional labels showing ratio
+ * - Optional line extensions
+ */
+export declare class FibSpeedFan extends Drawing {
+    readonly type = "fib-speed-fan";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibSpeedFanOptions>);
+    get fibOptions(): FibSpeedFanOptions;
+    setFibOptions(options: Partial<FibSpeedFanOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Calculate fan line endpoint for a given ratio
+     */
+    getFanLineEnd(p1: Point, p2: Point, ratio: number, viewportWidth: number): Point;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibSpeedFanOptions>): FibSpeedFan;
+}
+
+/**
+ * FibSpeedFan options
+ */
+export declare interface FibSpeedFanOptions extends DrawingOptions {
+    ratios?: number[];
+    showLabels?: boolean;
+    extendLines?: boolean;
+    filled?: boolean;
+}
+
+export declare class FibSpeedFanPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibSpeedFan);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibSpiral - Golden spiral based on Fibonacci sequence.
+ *
+ * Features:
+ * - Two anchor points (center and size reference)
+ * - Logarithmic spiral with golden ratio growth
+ * - Optional Fibonacci squares overlay
+ * - Configurable rotation direction
+ */
+export declare class FibSpiral extends Drawing {
+    readonly type = "fib-spiral";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 8;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibSpiralOptions>);
+    get fibOptions(): FibSpiralOptions;
+    setFibOptions(options: Partial<FibSpiralOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Generate points along the golden spiral
+     */
+    getSpiralPoints(center: Point, startRadius: number, rotations: number, clockwise: boolean): Point[];
+    computeGeometry(_viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, center: Anchor, sizeRef: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibSpiralOptions>): FibSpiral;
+}
+
+/**
+ * FibSpiral options
+ */
+export declare interface FibSpiralOptions extends DrawingOptions {
+    rotations?: number;
+    clockwise?: boolean;
+    showSquares?: boolean;
+}
+
+export declare class FibSpiralPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibSpiral);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibTimeExtension - Trend-Based Fibonacci Time extension.
+ *
+ * Features:
+ * - Three anchor points (start, end of trend, extension point)
+ * - Vertical lines at Fibonacci time projections
+ * - Optional labels showing level
+ * - Optional fill between zones
+ */
+export declare class FibTimeExtension extends Drawing {
+    readonly type = "fib-time-extension";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibTimeExtensionOptions>);
+    get fibOptions(): FibTimeExtensionOptions;
+    setFibOptions(options: Partial<FibTimeExtensionOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, extension: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibTimeExtensionOptions>): FibTimeExtension;
+}
+
+/**
+ * FibTimeExtension options
+ */
+export declare interface FibTimeExtensionOptions extends DrawingOptions {
+    levels?: number[];
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class FibTimeExtensionPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibTimeExtension);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibTimeZone - Vertical lines at Fibonacci time intervals.
+ *
+ * Features:
+ * - Two anchor points define the unit interval
+ * - Vertical lines at Fibonacci sequence positions
+ * - Optional labels showing interval number
+ * - Optional fill between zones
+ */
+export declare class FibTimeZone extends Drawing {
+    readonly type = "fib-time-zone";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibTimeZoneOptions>);
+    get fibOptions(): FibTimeZoneOptions;
+    setFibOptions(options: Partial<FibTimeZoneOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibTimeZoneOptions>): FibTimeZone;
+}
+
+/**
+ * FibTimeZone options
+ */
+export declare interface FibTimeZoneOptions extends DrawingOptions {
+    intervals?: number[];
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class FibTimeZonePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibTimeZone);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FibWedge - Wedge pattern with Fibonacci level lines.
+ *
+ * Features:
+ * - Three anchor points (apex and two boundary points)
+ * - Lines radiating from apex at Fibonacci angle divisions
+ * - Optional labels showing level
+ * - Optional fill between lines
+ */
+export declare class FibWedge extends Drawing {
+    readonly type = "fib-wedge";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FibWedgeOptions>);
+    get fibOptions(): FibWedgeOptions;
+    setFibOptions(options: Partial<FibWedgeOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get the endpoint for a wedge line at a given level
+     */
+    getWedgeLineEnd(_apex: Point, p1: Point, p2: Point, level: number): Point;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, apex: Anchor, boundary1: Anchor, boundary2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FibWedgeOptions>): FibWedge;
+}
+
+/**
+ * FibWedge options
+ */
+export declare interface FibWedgeOptions extends DrawingOptions {
+    levels?: number[];
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class FibWedgePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FibWedge);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Flag mark color type
+ */
+export declare type FlagColor = 'red' | 'green' | 'blue' | 'yellow' | 'purple' | 'custom';
+
+/**
+ * Flag Mark - A flag marker placed on the chart.
+ *
+ * Features:
+ * - Single anchor point
+ * - Various preset colors
+ * - Optional label
+ * - Configurable size
+ */
+export declare class FlagMark extends Drawing {
+    readonly type = "flag-mark";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 15;
+    private _flagOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FlagMarkOptions>);
+    get flagOptions(): FlagMarkOptions;
+    setFlagOptions(options: Partial<FlagMarkOptions>): void;
+    getFlagColor(): string;
+    setLabel(label: string): void;
+    getLabel(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, flagColor?: FlagColor, label?: string, style?: Partial<DrawingStyle>, options?: Partial<FlagMarkOptions>): FlagMark;
+}
+
+/**
+ * Flag Mark options
+ */
+export declare interface FlagMarkOptions extends DrawingOptions {
+    flagColor?: FlagColor;
+    customColor?: string;
+    label?: string;
+    size?: number;
+}
+
+export declare class FlagMarkPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FlagMark);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * FlatTopBottom - A channel where one side is flat (horizontal) and the other follows a trend.
+ *
+ * Features:
+ * - Three anchor points: two for the trend line, one for the flat line level
+ * - One horizontal line (flat)
+ * - One diagonal line (trend)
+ * - Optional fill between lines
+ * - Optional line extensions
+ */
+export declare class FlatTopBottom extends Drawing {
+    readonly type = "flat-top-bottom";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _channelOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<FlatTopBottomOptions>);
+    get channelOptions(): FlatTopBottomOptions;
+    setChannelOptions(options: Partial<FlatTopBottomOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, flatLevel: Anchor, style?: Partial<DrawingStyle>, options?: Partial<FlatTopBottomOptions>): FlatTopBottom;
+}
+
+/**
+ * FlatTopBottom options
+ */
+export declare interface FlatTopBottomOptions extends DrawingOptions {
+    filled?: boolean;
+    extendLines?: boolean;
+    flatPosition?: 'top' | 'bottom';
+}
+
+export declare class FlatTopBottomPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: FlatTopBottom);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Forecast - Price forecast projection tool.
+ *
+ * Features:
+ * - Two anchor points defining a price range and time range
+ * - Anchor 1: start price/time
+ * - Anchor 2: target forecast price/time
+ * - Shows projected zone with target price/percentage labels
+ */
+export declare class Forecast extends Drawing {
+    readonly type = "forecast";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _forecastOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ForecastOptions>);
+    get forecastOptions(): ForecastOptions;
+    setForecastOptions(options: Partial<ForecastOptions>): void;
+    getForecastInfo(): {
+        startPrice: number;
+        targetPrice: number;
+        priceChange: number;
+        percentChange: number;
+        isUp: boolean;
+    };
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, startAnchor: Anchor, targetAnchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ForecastOptions>): Forecast;
+}
+
+/**
+ * Forecast options
+ */
+export declare interface ForecastOptions extends DrawingOptions {
+    showPrices?: boolean;
+    showPercentage?: boolean;
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class ForecastPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Forecast);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Format percentage for display
+ */
+export declare function formatPercentage(percentage: number, precision?: number): string;
+
+/**
+ * Format price for display
+ */
+export declare function formatPrice(price: number, precision?: number): string;
+
+/**
+ * Standard Gann fan angles (rise/run ratios)
+ */
+export declare const GANN_FAN_ANGLES: {
+    ratio: number;
+    label: string;
+}[];
+
+/**
+ * Gann price levels
+ */
+export declare const GANN_LEVELS: number[];
+
+/**
+ * Gann square divisions for the "Square of Nine" pattern
+ */
+export declare const GANN_SQUARE_DIVISIONS = 8;
+
+/**
+ * Gann square levels (cardinal and ordinal)
+ */
+export declare const GANN_SQUARE_LEVELS: number[];
+
+/**
+ * GannBox - Gann grid/box for price and time analysis.
+ *
+ * Features:
+ * - Two anchor points (corners)
+ * - Horizontal price levels
+ * - Vertical time levels
+ * - Optional diagonal lines
+ */
+export declare class GannBox extends Drawing {
+    readonly type = "gann-box";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _gannOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<GannBoxOptions>);
+    get gannOptions(): GannBoxOptions;
+    setGannOptions(options: Partial<GannBoxOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, corner1: Anchor, corner2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<GannBoxOptions>): GannBox;
+}
+
+/**
+ * GannBox options
+ */
+export declare interface GannBoxOptions extends DrawingOptions {
+    priceLevels?: number[];
+    timeLevels?: number[];
+    showDiagonals?: boolean;
+    filled?: boolean;
+}
+
+export declare class GannBoxPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: GannBox);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * GannFan - Gann fan lines radiating from a point.
+ *
+ * Features:
+ * - Two anchor points (origin and direction)
+ * - Multiple fan lines at Gann angles
+ * - Optional labels for each angle
+ */
+export declare class GannFan extends Drawing {
+    readonly type = "gann-fan";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _gannOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<GannFanOptions>);
+    get gannOptions(): GannFanOptions;
+    setGannOptions(options: Partial<GannFanOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, origin: Anchor, direction: Anchor, style?: Partial<DrawingStyle>, options?: Partial<GannFanOptions>): GannFan;
+}
+
+/**
+ * GannFan options
+ */
+export declare interface GannFanOptions extends DrawingOptions {
+    angles?: {
+        ratio: number;
+        label: string;
+    }[];
+    showLabels?: boolean;
+    extendLines?: boolean;
+}
+
+export declare class GannFanPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: GannFan);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * GannSquare - Resizable Gann square with "Square of Nine" pattern.
+ *
+ * Features:
+ * - Two anchor points (center and corner)
+ * - Concentric squares at regular intervals
+ * - Cardinal cross (vertical/horizontal through center)
+ * - Ordinal cross (45-degree diagonals)
+ * - Optional spiral pattern
+ */
+export declare class GannSquare extends Drawing {
+    readonly type = "gann-square";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _gannOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<GannSquareOptions>);
+    get gannOptions(): GannSquareOptions;
+    setGannOptions(options: Partial<GannSquareOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get the square size from center to corner
+     */
+    getSquareRadius(viewport: Viewport): number;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, center: Anchor, corner: Anchor, style?: Partial<DrawingStyle>, options?: Partial<GannSquareOptions>): GannSquare;
+}
+
+/**
+ * GannSquareFixed - Fixed-size Gann square for price/time analysis.
+ *
+ * Features:
+ * - Single anchor point (center)
+ * - Fixed square size based on price units
+ * - Cardinal cross (vertical/horizontal)
+ * - Ordinal cross (45-degree diagonals)
+ * - Optional arcs at corners
+ */
+export declare class GannSquareFixed extends Drawing {
+    readonly type = "gann-square-fixed";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _gannOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<GannSquareFixedOptions>);
+    get gannOptions(): GannSquareFixedOptions;
+    setGannOptions(options: Partial<GannSquareFixedOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get the square size based on price scale
+     */
+    getSquarePixelSize(viewport: Viewport): number;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, center: Anchor, style?: Partial<DrawingStyle>, options?: Partial<GannSquareFixedOptions>): GannSquareFixed;
+}
+
+/**
+ * GannSquareFixed options
+ */
+export declare interface GannSquareFixedOptions extends DrawingOptions {
+    squareSize?: number;
+    levels?: number[];
+    showDiagonals?: boolean;
+    showArcs?: boolean;
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class GannSquareFixedPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: GannSquareFixed);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * GannSquare options
+ */
+export declare interface GannSquareOptions extends DrawingOptions {
+    divisions?: number;
+    showDiagonals?: boolean;
+    showCardinalCross?: boolean;
+    showSpiral?: boolean;
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class GannSquarePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: GannSquare);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Union of all geometry types
+ */
+export declare type Geometry = LineGeometry | ArcGeometry | RectangleGeometry | PolygonGeometry | TextGeometry;
+
+/**
+ * Get angle of line in radians
+ */
+export declare function getLineAngle(start: Point, end: Point): number;
+
+/**
+ * Get angle of line in degrees
+ */
+export declare function getLineAngleDegrees(start: Point, end: Point): number;
+
+export declare function getToolRegistry(): ToolRegistry;
+
+/**
+ * Golden ratio for spiral
+ */
+export declare const GOLDEN_RATIO = 1.618033988749895;
+
+/**
+ * Highlighter - Semi-transparent highlight drawing tool.
+ *
+ * Features:
+ * - Multiple anchor points forming a path
+ * - Wide, semi-transparent stroke
+ * - Ideal for marking important areas
+ */
+export declare class Highlighter extends Drawing {
+    readonly type = "highlighter";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 15;
+    private _highlighterOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<HighlighterOptions>);
+    get highlighterOptions(): HighlighterOptions;
+    setHighlighterOptions(options: Partial<HighlighterOptions>): void;
+    /**
+     * Add a point to the highlighter path
+     */
+    addPoint(anchor: Anchor): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, points: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<HighlighterOptions>): Highlighter;
+}
+
+/**
+ * Highlighter options
+ */
+export declare interface HighlighterOptions extends DrawingOptions {
+    highlighterWidth?: number;
+    opacity?: number;
+}
+
+export declare class HighlighterPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Highlighter);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * HorizontalLine - A horizontal line at a specific price level.
+ *
+ * Features:
+ * - Single anchor point (price level)
+ * - Extends across entire viewport
+ * - Optional price label
+ * - Optional custom label text
+ */
+export declare class HorizontalLine extends Drawing {
+    readonly type = "horizontal-line";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _horizontalLineOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<HorizontalLineOptions>);
+    get horizontalLineOptions(): HorizontalLineOptions;
+    setHorizontalLineOptions(options: Partial<HorizontalLineOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, price: number, time: number | string, style?: Partial<DrawingStyle>, options?: Partial<HorizontalLineOptions>): HorizontalLine;
+}
+
+/**
+ * HorizontalLine options
+ */
+export declare interface HorizontalLineOptions extends DrawingOptions {
+    showPrice?: boolean;
+    showLabel?: boolean;
+    labelText?: string;
+}
+
+export declare class HorizontalLinePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: HorizontalLine);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Preview renderer for horizontal line (single point)
+ */
+export declare class HorizontalLinePreviewRenderer extends PreviewRenderer {
+    render(ctx: CanvasRenderingContext2D, anchors: Anchor[], previewAnchor: Anchor | null, viewport: Viewport, style: DrawingStyle, pixelRatio: number): void;
+}
+
+/**
+ * HorizontalRay - A horizontal ray extending from a single point.
+ *
+ * Features:
+ * - Single anchor point (price level)
+ * - Extends horizontally to the right (or left) edge
+ * - Optional price label
+ * - Useful for support/resistance levels with direction
+ */
+export declare class HorizontalRay extends Drawing {
+    readonly type = "horizontal-ray";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _horizontalRayOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<HorizontalRayOptions>);
+    get horizontalRayOptions(): HorizontalRayOptions;
+    setHorizontalRayOptions(options: Partial<HorizontalRayOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, time: number | string, price: number, style?: Partial<DrawingStyle>, options?: Partial<HorizontalRayOptions>): HorizontalRay;
+}
+
+/**
+ * HorizontalRay options
+ */
+export declare interface HorizontalRayOptions extends DrawingOptions {
+    showPrice?: boolean;
+    direction?: 'right' | 'left';
+}
+
+export declare class HorizontalRayPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: HorizontalRay);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Base drawing interface
+ */
+export declare interface IDrawing {
+    readonly id: string;
+    readonly type: string;
+    anchors: Anchor[];
+    style: DrawingStyle;
+    options: DrawingOptions;
+    state: DrawingState;
+    attach(series: ISeriesApi<SeriesType>, chart: IChartApi, container?: HTMLElement): void;
+    detach(): void;
+    isAttached(): boolean;
+    isValid(): boolean;
+    setAnchors(anchors: Anchor[]): void;
+    updateAnchor(index: number, anchor: Anchor): void;
+    updateStyle(style: Partial<DrawingStyle>): void;
+    updateOptions(options: Partial<DrawingOptions>): void;
+    setState(state: DrawingState): void;
+    testHit(point: Point, viewport: Viewport): boolean;
+    hitTestAnchor(point: Point, viewport: Viewport): number | null;
+    getControlPoints(viewport: Viewport): ControlPoint[];
+    toJSON(): SerializedDrawing;
+    fromJSON(data: SerializedDrawing): void;
+    clone(newId: string): IDrawing;
+    getViewport(): Viewport | null;
+    requestUpdate(): void;
+    paneViews(): IPrimitivePaneView[];
+}
+
+/**
+ * Interface for interaction handlers
+ */
+export declare interface IInteractionHandler {
+    getState(): InteractionState;
+    getAnchors(): Anchor[];
+    getPreviewAnchor(): Anchor | null;
+    onMouseDown(data: MouseEventData): void;
+    onMouseMove(data: MouseEventData): void;
+    onMouseUp(data: MouseEventData): void;
+    onKeyDown(key: string): void;
+    isComplete(): boolean;
+    reset(): void;
+}
+
+/**
+ * InfoLine - A line that displays measurement information.
+ *
+ * Features:
+ * - Two anchor points
+ * - Shows distance, angle, price/percent change
+ * - Shows bar count and time duration
+ * - Comprehensive measurement tool
+ */
+export declare class InfoLine extends BaseLine {
+    readonly type = "info-line";
+    private _infoLineOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<InfoLineOptions>);
+    get infoLineOptions(): InfoLineOptions;
+    setInfoLineOptions(options: Partial<InfoLineOptions>): void;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    private computeLabelGeometry;
+    /**
+     * Get all measurement info as an object
+     */
+    getMeasurements(viewport: Viewport): {
+        distance: number;
+        angle: number;
+        priceChange: number;
+        percentChange: number;
+        bars: number;
+    } | null;
+    clone(newId: string): IDrawing;
+    static create(id: string, startAnchor: Anchor, endAnchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<InfoLineOptions>): InfoLine;
+}
+
+/**
+ * InfoLine options
+ */
+export declare interface InfoLineOptions extends DrawingOptions {
+    showDistance?: boolean;
+    showAngle?: boolean;
+    showPriceChange?: boolean;
+    showPercentChange?: boolean;
+    showBars?: boolean;
+    showTime?: boolean;
+}
+
+export declare class InfoLinePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: InfoLine);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * InsidePitchfork - Inside Pitchfork variant.
+ *
+ * The Inside Pitchfork differs from Andrews' Pitchfork in that the outer
+ * lines converge toward the median line rather than running parallel to it.
+ * The outer lines start from the swing points (p1, p2) and converge toward
+ * a point on the extended median line.
+ *
+ * Features:
+ * - Three anchor points (pivot, and two swing points)
+ * - Median line from pivot through midpoint of swings
+ * - Converging outer lines from swing points toward median
+ * - Optional fill between lines
+ */
+export declare class InsidePitchfork extends Drawing {
+    readonly type = "inside-pitchfork";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _pitchforkOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<InsidePitchforkOptions>);
+    get pitchforkOptions(): InsidePitchforkOptions;
+    setPitchforkOptions(options: Partial<InsidePitchforkOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Calculate the convergence point on the median line where outer lines meet.
+     * This is a point further along the median line.
+     */
+    getConvergencePoint(p0: Point, mid: Point, factor?: number): Point;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pivot: Anchor, swing1: Anchor, swing2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<InsidePitchforkOptions>): InsidePitchfork;
+}
+
+/**
+ * InsidePitchfork options
+ */
+export declare interface InsidePitchforkOptions extends DrawingOptions {
+    showMedianLine?: boolean;
+    showOuterLines?: boolean;
+    extendLines?: boolean;
+    filled?: boolean;
+}
+
+export declare class InsidePitchforkPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: InsidePitchfork);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Configuration for interaction handler
+ */
+export declare interface InteractionConfig {
+    requiredAnchors: number;
+    pixelToChart: PixelToChartFn;
+    snapConfig?: SnapConfig;
+    onAnchorAdded?: (anchor: Anchor, index: number) => void;
+    onAnchorUpdated?: (anchor: Anchor, index: number) => void;
+    onPreviewMove?: (previewAnchor: Anchor) => void;
+    onComplete?: () => void;
+    onCancel?: () => void;
+}
+
+/**
+ * Base interaction handler implementing FSM for drawing placement.
+ * Handles the state machine for placing anchors and completing drawings.
+ */
+export declare class InteractionHandler implements IInteractionHandler {
+    protected _state: InteractionState;
+    protected _anchors: Anchor[];
+    protected _previewAnchor: Anchor | null;
+    protected _editingAnchorIndex: number | null;
+    protected _config: InteractionConfig;
+    constructor(config: InteractionConfig);
+    getState(): InteractionState;
+    getAnchors(): Anchor[];
+    getPreviewAnchor(): Anchor | null;
+    onMouseDown(data: MouseEventData): void;
+    onMouseMove(data: MouseEventData): void;
+    onMouseUp(_data: MouseEventData): void;
+    onKeyDown(key: string): void;
+    isComplete(): boolean;
+    reset(): void;
+    /**
+     * Start editing a specific anchor
+     */
+    startEditingAnchor(index: number): void;
+    /**
+     * Set anchors externally (for loading from saved data)
+     */
+    setAnchors(anchors: Anchor[]): void;
+    protected pointToAnchor(point: Point): Anchor | null;
+    protected applySnap(anchor: Anchor, _point: Point): Anchor;
+    protected cancel(): void;
+    protected notifyAnchorAdded(anchor: Anchor, index: number): void;
+    protected notifyAnchorUpdated(anchor: Anchor, index: number): void;
+    protected notifyPreviewMove(anchor: Anchor): void;
+    protected notifyComplete(): void;
+}
+
+/**
+ * Interaction states for the FSM
+ */
+export declare type InteractionState = 'idle' | 'placing' | 'editing' | 'complete';
+
+/**
+ * Interface for preview renderers
+ */
+export declare interface IPreviewRenderer {
+    render(ctx: CanvasRenderingContext2D, anchors: Anchor[], previewAnchor: Anchor | null, viewport: Viewport, style: DrawingStyle, pixelRatio: number): void;
+}
+
+/**
+ * Check if point is within distance of another point
+ */
+export declare function isPointNear(p1: Point, p2: Point, threshold: number): boolean;
+
+/**
+ * Linear interpolation between two points
+ */
+export declare function lerp(p1: Point, p2: Point, t: number): Point;
+
+/**
+ * Line geometry with optional extensions
+ */
+export declare interface LineGeometry {
+    type: 'line';
+    start: Point;
+    end: Point;
+    extendLeft?: boolean;
+    extendRight?: boolean;
+}
+
+/**
+ * Preview renderer for two-point line drawings
+ */
+export declare class LinePreviewRenderer extends PreviewRenderer {
+    render(ctx: CanvasRenderingContext2D, anchors: Anchor[], previewAnchor: Anchor | null, viewport: Viewport, style: DrawingStyle, pixelRatio: number): void;
+}
+
+/**
+ * LongPosition - Trade visualization for long positions.
+ *
+ * Features:
+ * - Three anchor points: entry, stop loss, take profit
+ * - Shows risk (red) and reward (green) zones
+ * - Displays P&L, percentage change, and risk/reward ratio
+ */
+export declare class LongPosition extends Drawing {
+    readonly type = "long-position";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _positionOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<LongPositionOptions>);
+    get positionOptions(): LongPositionOptions;
+    setPositionOptions(options: Partial<LongPositionOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get position info
+     * Anchors: [0] = entry, [1] = stop loss, [2] = take profit
+     */
+    getPositionInfo(): {
+        entry: number;
+        stopLoss: number;
+        takeProfit: number;
+        risk: number;
+        reward: number;
+        riskRewardRatio: number;
+        riskPercent: number;
+        rewardPercent: number;
+    };
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, entry: Anchor, stopLoss: Anchor, takeProfit: Anchor, style?: Partial<DrawingStyle>, options?: Partial<LongPositionOptions>): LongPosition;
+}
+
+/**
+ * LongPosition options
+ */
+export declare interface LongPositionOptions extends DrawingOptions {
+    showPrices?: boolean;
+    showPercentage?: boolean;
+    showRiskReward?: boolean;
+    showPnL?: boolean;
+    quantity?: number;
+    accountSize?: number;
+}
+
+export declare class LongPositionPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: LongPosition);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Calculate midpoint between two points
+ */
+export declare function midpoint(p1: Point, p2: Point): Point;
+
+/**
+ * ModifiedSchiffPitchfork - Modified Schiff Pitchfork variant.
+ *
+ * The Modified Schiff Pitchfork differs from the standard Schiff in that
+ * the median line starts from the midpoint of a vertical line drawn from
+ * the pivot point (p0) down/up to the price level of the first swing point (p1).
+ * This creates a more horizontal median line than both Andrews' and Schiff.
+ *
+ * Features:
+ * - Three anchor points (pivot, and two swing points)
+ * - Median line from modified pivot through midpoint of swings
+ * - Parallel outer lines through swing points
+ * - Optional fill between lines
+ */
+export declare class ModifiedSchiffPitchfork extends Drawing {
+    readonly type = "modified-schiff-pitchfork";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _pitchforkOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ModifiedSchiffPitchforkOptions>);
+    get pitchforkOptions(): ModifiedSchiffPitchforkOptions;
+    setPitchforkOptions(options: Partial<ModifiedSchiffPitchforkOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Calculate the Modified Schiff pivot point.
+     * It's the midpoint between p0 and a point directly below/above p0 at p1's y-level.
+     */
+    getModifiedSchiffPivot(p0: Point, p1: Point): Point;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pivot: Anchor, swing1: Anchor, swing2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ModifiedSchiffPitchforkOptions>): ModifiedSchiffPitchfork;
+}
+
+/**
+ * ModifiedSchiffPitchfork options
+ */
+export declare interface ModifiedSchiffPitchforkOptions extends DrawingOptions {
+    showMedianLine?: boolean;
+    showOuterLines?: boolean;
+    extendLines?: boolean;
+    filled?: boolean;
+}
+
+export declare class ModifiedSchiffPitchforkPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: ModifiedSchiffPitchfork);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Mouse event data passed to interaction handlers
+ */
+export declare interface MouseEventData {
+    point: Point;
+    time: Time | null;
+    price: number | null;
+    srcEvent: MouseEvent;
+}
+
+/**
+ * Note - A sticky note style annotation.
+ *
+ * Features:
+ * - Single anchor point
+ * - Note icon with expandable text
+ * - Customizable background and icon color
+ * - Fixed or auto-width
+ */
+export declare class Note extends Drawing {
+    readonly type = "note";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 15;
+    private _noteOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<NoteOptions>);
+    get noteOptions(): NoteOptions;
+    setNoteOptions(options: Partial<NoteOptions>): void;
+    setText(text: string): void;
+    getText(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, text: string, style?: Partial<DrawingStyle>, options?: Partial<NoteOptions>): Note;
+}
+
+/**
+ * Note options
+ */
+export declare interface NoteOptions extends DrawingOptions {
+    text?: string;
+    fontSize?: number;
+    backgroundColor?: string;
+    iconColor?: string;
+    width?: number;
+    showIcon?: boolean;
+}
+
+export declare class NotePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Note);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * ParallelChannel - Two parallel lines forming a channel.
+ *
+ * Features:
+ * - Three anchor points (two for baseline, one for channel width)
+ * - Optional fill between lines
+ * - Optional middle line
+ * - Optional line extensions
+ */
+export declare class ParallelChannel extends Drawing {
+    readonly type = "parallel-channel";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _channelOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ParallelChannelOptions>);
+    get channelOptions(): ParallelChannelOptions;
+    setChannelOptions(options: Partial<ParallelChannelOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    private calculateOffset;
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, width: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ParallelChannelOptions>): ParallelChannel;
+}
+
+/**
+ * ParallelChannel options
+ */
+export declare interface ParallelChannelOptions extends DrawingOptions {
+    filled?: boolean;
+    showMiddleLine?: boolean;
+    extendLines?: boolean;
+}
+
+export declare class ParallelChannelPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: ParallelChannel);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Path - Freeform path drawing with straight line segments.
+ *
+ * Features:
+ * - Multiple anchor points connected by straight lines
+ * - Optional closed path
+ * - Optional fill (when closed)
+ */
+export declare class Path extends Drawing {
+    readonly type = "path";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _pathOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PathOptions>);
+    get pathOptions(): PathOptions;
+    setPathOptions(options: Partial<PathOptions>): void;
+    /**
+     * Add a point to the path
+     */
+    addPoint(anchor: Anchor): void;
+    /**
+     * Close or open the path
+     */
+    setClosed(closed: boolean): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private pointInPolygon;
+    clone(newId: string): IDrawing;
+    static create(id: string, points: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PathOptions>): Path;
+}
+
+/**
+ * Path options
+ */
+export declare interface PathOptions extends DrawingOptions {
+    closed?: boolean;
+    filled?: boolean;
+}
+
+export declare class PathPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Path);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Pin - A simple pin/map marker annotation.
+ *
+ * Features:
+ * - Single anchor point
+ * - Teardrop/pin shape
+ * - Optional short label
+ */
+export declare class Pin extends Drawing {
+    readonly type = "pin";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 15;
+    private _pinOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PinOptions>);
+    get pinOptions(): PinOptions;
+    setPinOptions(options: Partial<PinOptions>): void;
+    setLabel(label: string): void;
+    getLabel(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, style?: Partial<DrawingStyle>, options?: Partial<PinOptions>): Pin;
+}
+
+/**
+ * Pin options
+ */
+export declare interface PinOptions extends DrawingOptions {
+    color?: string;
+    size?: number;
+    label?: string;
+}
+
+export declare class PinPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Pin);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Pitchfan - Fan lines from a pitchfork-style base at Fibonacci levels.
+ *
+ * Features:
+ * - Three anchor points (pivot and two swing points)
+ * - Fan lines radiating from pivot through Fibonacci divisions
+ * - Similar to pitchfork but with multiple fan lines
+ * - Optional line extensions
+ */
+export declare class Pitchfan extends Drawing {
+    readonly type = "pitchfan";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _fibOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PitchfanOptions>);
+    get fibOptions(): PitchfanOptions;
+    setFibOptions(options: Partial<PitchfanOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get the fan line endpoint for a given level
+     */
+    getFanLineEnd(pivot: Point, p1: Point, p2: Point, level: number): Point;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pivot: Anchor, swing1: Anchor, swing2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<PitchfanOptions>): Pitchfan;
+}
+
+/**
+ * Pitchfan levels (Fibonacci-based)
+ */
+export declare const PITCHFAN_LEVELS: number[];
+
+/**
+ * Pitchfan options
+ */
+export declare interface PitchfanOptions extends DrawingOptions {
+    levels?: number[];
+    showLabels?: boolean;
+    extendLines?: boolean;
+    filled?: boolean;
+}
+
+export declare class PitchfanPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Pitchfan);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Pixel to chart coordinate conversion function
+ */
+export declare type PixelToChartFn = (point: Point) => Anchor | null;
+
+/**
+ * Point in pixel coordinates
+ */
+export declare interface Point {
+    x: number;
+    y: number;
+}
+
+/**
+ * Polygon geometry (closed or open path)
+ */
+export declare interface PolygonGeometry {
+    type: 'polygon';
+    points: Point[];
+    closed: boolean;
+}
+
+/**
+ * Polyline - Multi-point connected line with vertex markers.
+ *
+ * Features:
+ * - Multiple anchor points connected by straight lines
+ * - Optional vertex markers at each point
+ * - Interactive point adding during creation
+ */
+export declare class Polyline extends Drawing {
+    readonly type = "polyline";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _polylineOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PolylineOptions>);
+    get polylineOptions(): PolylineOptions;
+    setPolylineOptions(options: Partial<PolylineOptions>): void;
+    /**
+     * Add a point to the polyline
+     */
+    addPoint(anchor: Anchor): void;
+    /**
+     * Insert a point at a specific index
+     */
+    insertPoint(index: number, anchor: Anchor): void;
+    /**
+     * Remove a point at a specific index
+     */
+    removePoint(index: number): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    /**
+     * Get total length of the polyline
+     */
+    getTotalLength(viewport: Viewport): number;
+    clone(newId: string): IDrawing;
+    static create(id: string, points: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PolylineOptions>): Polyline;
+}
+
+/**
+ * Polyline options
+ */
+export declare interface PolylineOptions extends DrawingOptions {
+    showVertices?: boolean;
+    vertexRadius?: number;
+}
+
+export declare class PolylinePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Polyline);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Base preview renderer with common functionality
+ */
+export declare abstract class PreviewRenderer implements IPreviewRenderer {
+    abstract render(ctx: CanvasRenderingContext2D, anchors: Anchor[], previewAnchor: Anchor | null, viewport: Viewport, style: DrawingStyle, pixelRatio: number): void;
+    protected anchorToPixel(anchor: Anchor, viewport: Viewport): Point | null;
+    protected drawAnchorPoint(ctx: CanvasRenderingContext2D, point: Point, pixelRatio: number): void;
+}
+
+/**
+ * Price Label - A simple price label with arrow pointer.
+ *
+ * Features:
+ * - Single anchor point
+ * - Shows price value in a badge
+ * - Arrow pointer to the price level
+ * - Extends to the right edge
+ */
+export declare class PriceLabel extends Drawing {
+    readonly type = "price-label";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _labelOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PriceLabelOptions>);
+    get labelOptions(): PriceLabelOptions;
+    setLabelOptions(options: Partial<PriceLabelOptions>): void;
+    getPrice(): number;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, style?: Partial<DrawingStyle>, options?: Partial<PriceLabelOptions>): PriceLabel;
+}
+
+/**
+ * Price Label options
+ */
+export declare interface PriceLabelOptions extends DrawingOptions {
+    fontSize?: number;
+    backgroundColor?: string;
+    textColor?: string;
+    showArrow?: boolean;
+    arrowDirection?: 'left' | 'right';
+    decimals?: number;
+}
+
+export declare class PriceLabelPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: PriceLabel);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Price Note - Displays price and optional note at a specific point.
+ *
+ * Features:
+ * - Single anchor point
+ * - Shows price value
+ * - Optional note text
+ * - Customizable colors
+ */
+export declare class PriceNote extends Drawing {
+    readonly type = "price-note";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _noteOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PriceNoteOptions>);
+    get noteOptions(): PriceNoteOptions;
+    setNoteOptions(options: Partial<PriceNoteOptions>): void;
+    setNote(note: string): void;
+    getNote(): string;
+    getPrice(): number;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, note?: string, style?: Partial<DrawingStyle>, options?: Partial<PriceNoteOptions>): PriceNote;
+}
+
+/**
+ * Price Note options
+ */
+export declare interface PriceNoteOptions extends DrawingOptions {
+    note?: string;
+    showPrice?: boolean;
+    showTime?: boolean;
+    fontSize?: number;
+    backgroundColor?: string;
+    priceColor?: string;
+    noteColor?: string;
+}
+
+export declare class PriceNotePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: PriceNote);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * PriceRange - A highlighted price zone between two price levels.
+ *
+ * Features:
+ * - Two anchor points (top and bottom of range)
+ * - Shows price range and percentage change
+ * - Spans full viewport width
+ */
+export declare class PriceRange extends Drawing {
+    readonly type = "price-range";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _priceRangeOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<PriceRangeOptions>);
+    get priceRangeOptions(): PriceRangeOptions;
+    setPriceRangeOptions(options: Partial<PriceRangeOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    /**
+     * Get the price range information
+     */
+    getRangeInfo(): {
+        min: number;
+        max: number;
+        range: number;
+        percentage: number;
+    };
+    clone(newId: string): IDrawing;
+    static create(id: string, price1: number, price2: number, time: number | string, style?: Partial<DrawingStyle>, options?: Partial<PriceRangeOptions>): PriceRange;
+}
+
+/**
+ * PriceRange options
+ */
+export declare interface PriceRangeOptions extends DrawingOptions {
+    showPrices?: boolean;
+    showRange?: boolean;
+    showPercentage?: boolean;
+}
+
+export declare class PriceRangePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: PriceRange);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Projection - Price projection tool.
+ *
+ * Features:
+ * - Three anchor points: initial move (A to B), projection start (C)
+ * - Projects the A-B move from point C
+ * - Shows target price and percentage
+ */
+export declare class Projection extends Drawing {
+    readonly type = "projection";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _projectionOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ProjectionOptions>);
+    get projectionOptions(): ProjectionOptions;
+    setProjectionOptions(options: Partial<ProjectionOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get projection info
+     * Anchors: [0] = A (start of reference move)
+     *          [1] = B (end of reference move)
+     *          [2] = C (projection start point)
+     */
+    getProjectionInfo(): {
+        priceA: number;
+        priceB: number;
+        priceC: number;
+        targetPrice: number;
+        moveSize: number;
+        movePercent: number;
+        isUp: boolean;
+    };
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pointA: Anchor, pointB: Anchor, pointC: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ProjectionOptions>): Projection;
+}
+
+/**
+ * Projection options
+ */
+export declare interface ProjectionOptions extends DrawingOptions {
+    showPrices?: boolean;
+    showPercentage?: boolean;
+    showLabels?: boolean;
+    filled?: boolean;
+}
+
+export declare class ProjectionPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Projection);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Ray - A line that extends infinitely in one direction from the first anchor.
+ *
+ * Features:
+ * - Two anchor points define the direction
+ * - Extends infinitely from first anchor through second anchor
+ * - Optional angle display
+ */
+export declare class Ray extends BaseLine {
+    readonly type = "ray";
+    private _rayOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<RayOptions>);
+    get rayOptions(): RayOptions;
+    setRayOptions(options: Partial<RayOptions>): void;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    clone(newId: string): IDrawing;
+    static create(id: string, startAnchor: Anchor, endAnchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<RayOptions>): Ray;
+}
+
+/**
+ * Ray options
+ */
+export declare interface RayOptions extends DrawingOptions {
+    showAngle?: boolean;
+}
+
+export declare class RayPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Ray);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Rectangle - A rectangular shape defined by two corner points.
+ *
+ * Features:
+ * - Two anchor points (opposite corners)
+ * - Optional fill
+ * - Optional dimension labels
+ */
+export declare class Rectangle extends Drawing {
+    readonly type = "rectangle";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _rectangleOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<RectangleOptions>);
+    get rectangleOptions(): RectangleOptions;
+    setRectangleOptions(options: Partial<RectangleOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    /**
+     * Get price range of the rectangle
+     */
+    getPriceRange(): {
+        min: number;
+        max: number;
+        range: number;
+    };
+    clone(newId: string): IDrawing;
+    static create(id: string, corner1: Anchor, corner2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<RectangleOptions>): Rectangle;
+}
+
+/**
+ * Rectangle geometry
+ */
+export declare interface RectangleGeometry {
+    type: 'rectangle';
+    topLeft: Point;
+    width: number;
+    height: number;
+    rotation?: number;
+}
+
+/**
+ * Rectangle options
+ */
+export declare interface RectangleOptions extends DrawingOptions {
+    filled?: boolean;
+    showDimensions?: boolean;
+}
+
+export declare class RectanglePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Rectangle);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * RegressionTrend - Linear regression channel with standard deviation bands.
+ *
+ * Features:
+ * - Two anchor points define the regression range
+ * - Linear regression calculates the best-fit line
+ * - Channel width based on standard deviation
+ * - Optional fill between lines
+ * - Optional line extensions
+ */
+export declare class RegressionTrend extends Drawing {
+    readonly type = "regression-trend";
+    protected static readonly REQUIRED_ANCHORS = 2;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _channelOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<RegressionTrendOptions>);
+    get channelOptions(): RegressionTrendOptions;
+    setChannelOptions(options: Partial<RegressionTrendOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Calculate linear regression parameters
+     */
+    calculateRegression(p1: Point, p2: Point): {
+        slope: number;
+        intercept: number;
+        stdDev: number;
+    };
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, start: Anchor, end: Anchor, style?: Partial<DrawingStyle>, options?: Partial<RegressionTrendOptions>): RegressionTrend;
+}
+
+/**
+ * RegressionTrend options
+ */
+export declare interface RegressionTrendOptions extends DrawingOptions {
+    filled?: boolean;
+    showMiddleLine?: boolean;
+    extendLines?: boolean;
+    standardDeviations?: number;
+}
+
+export declare class RegressionTrendPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: RegressionTrend);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * RotatedRectangle - A rectangular shape that can be rotated to any angle.
+ *
+ * Features:
+ * - Three anchor points: first two define one edge, third defines height
+ * - Rotation determined by the angle of the first edge
+ * - Optional fill
+ * - Optional dimension labels
+ */
+export declare class RotatedRectangle extends Drawing {
+    readonly type = "rotated-rectangle";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _rotatedRectangleOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<RotatedRectangleOptions>);
+    get rotatedRectangleOptions(): RotatedRectangleOptions;
+    setRotatedRectangleOptions(options: Partial<RotatedRectangleOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get the four corners of the rotated rectangle
+     */
+    getCorners(viewport: Viewport): Point[] | null;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private pointInPolygon;
+    clone(newId: string): IDrawing;
+    static create(id: string, p1: Anchor, p2: Anchor, p3: Anchor, style?: Partial<DrawingStyle>, options?: Partial<RotatedRectangleOptions>): RotatedRectangle;
+}
+
+/**
+ * Rotated Rectangle options
+ */
+export declare interface RotatedRectangleOptions extends DrawingOptions {
+    filled?: boolean;
+    showDimensions?: boolean;
+}
+
+export declare class RotatedRectanglePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: RotatedRectangle);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Rotate point around center
+ */
+export declare function rotatePoint(point: Point, center: Point, angle: number): Point;
+
+/**
+ * SchiffPitchfork - Schiff Pitchfork variant.
+ *
+ * The Schiff Pitchfork differs from Andrews' Pitchfork in that the median line
+ * starts from the midpoint between the pivot (p0) and the first swing point (p1),
+ * rather than from the pivot itself. This creates a less steep median line.
+ *
+ * Features:
+ * - Three anchor points (pivot, and two swing points)
+ * - Median line from midpoint(p0,p1) through midpoint of swings
+ * - Parallel outer lines through swing points
+ * - Optional fill between lines
+ */
+export declare class SchiffPitchfork extends Drawing {
+    readonly type = "schiff-pitchfork";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _pitchforkOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<SchiffPitchforkOptions>);
+    get pitchforkOptions(): SchiffPitchforkOptions;
+    setPitchforkOptions(options: Partial<SchiffPitchforkOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Calculate the Schiff pivot point (midpoint between p0 and p1)
+     */
+    getSchiffPivot(p0: Point, p1: Point): Point;
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, pivot: Anchor, swing1: Anchor, swing2: Anchor, style?: Partial<DrawingStyle>, options?: Partial<SchiffPitchforkOptions>): SchiffPitchfork;
+}
+
+/**
+ * SchiffPitchfork options
+ */
+export declare interface SchiffPitchforkOptions extends DrawingOptions {
+    showMedianLine?: boolean;
+    showOuterLines?: boolean;
+    extendLines?: boolean;
+    filled?: boolean;
+}
+
+export declare class SchiffPitchforkPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: SchiffPitchfork);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Serialized drawing data for persistence
+ */
+export declare interface SerializedDrawing {
+    id: string;
+    type: string;
+    anchors: Anchor[];
+    style: DrawingStyle;
+    options: DrawingOptions;
+}
+
+/**
+ * ShortPosition - Trade visualization for short positions.
+ *
+ * Features:
+ * - Three anchor points: entry, stop loss, take profit
+ * - Shows risk (red) and reward (green) zones
+ * - Displays P&L, percentage change, and risk/reward ratio
+ */
+export declare class ShortPosition extends Drawing {
+    readonly type = "short-position";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _positionOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<ShortPositionOptions>);
+    get positionOptions(): ShortPositionOptions;
+    setPositionOptions(options: Partial<ShortPositionOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    /**
+     * Get position info
+     * Anchors: [0] = entry, [1] = stop loss (above entry), [2] = take profit (below entry)
+     */
+    getPositionInfo(): {
+        entry: number;
+        stopLoss: number;
+        takeProfit: number;
+        risk: number;
+        reward: number;
+        riskRewardRatio: number;
+        riskPercent: number;
+        rewardPercent: number;
+    };
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, entry: Anchor, stopLoss: Anchor, takeProfit: Anchor, style?: Partial<DrawingStyle>, options?: Partial<ShortPositionOptions>): ShortPosition;
+}
+
+/**
+ * ShortPosition options
+ */
+export declare interface ShortPositionOptions extends DrawingOptions {
+    showPrices?: boolean;
+    showPercentage?: boolean;
+    showRiskReward?: boolean;
+    showPnL?: boolean;
+    quantity?: number;
+    accountSize?: number;
+}
+
+export declare class ShortPositionPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: ShortPosition);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Signpost - A directional signpost marker.
+ *
+ * Features:
+ * - Single anchor point
+ * - Directional arrow-shaped sign (left/right)
+ * - Text label on the sign
+ */
+export declare class Signpost extends Drawing {
+    readonly type = "signpost";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 15;
+    private _signpostOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<SignpostOptions>);
+    get signpostOptions(): SignpostOptions;
+    setSignpostOptions(options: Partial<SignpostOptions>): void;
+    setText(text: string): void;
+    getText(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, text: string, style?: Partial<DrawingStyle>, options?: Partial<SignpostOptions>): Signpost;
+}
+
+/**
+ * Signpost options
+ */
+export declare interface SignpostOptions extends DrawingOptions {
+    text?: string;
+    fontSize?: number;
+    backgroundColor?: string;
+    textColor?: string;
+    direction?: 'left' | 'right';
+}
+
+export declare class SignpostPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Signpost);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Single-point interaction handler for vertical/horizontal lines
+ */
+export declare class SinglePointInteractionHandler extends InteractionHandler {
+    constructor(config: Omit<InteractionConfig, 'requiredAnchors'>);
+}
+
+/**
+ * Snap configuration for interaction
+ */
+export declare interface SnapConfig {
+    snapToPrice: boolean;
+    snapToBar: boolean;
+    snapThreshold: number;
+}
+
+/**
+ * Table - A data table annotation.
+ *
+ * Features:
+ * - Single anchor point (top-left corner)
+ * - Configurable rows and columns
+ * - Optional header row with distinct styling
+ */
+export declare class Table extends Drawing {
+    readonly type = "table";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _tableOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<TableOptions>);
+    get tableOptions(): TableOptions;
+    setTableOptions(options: Partial<TableOptions>): void;
+    setRows(rows: string[][]): void;
+    getRows(): string[][];
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, rows?: string[][], style?: Partial<DrawingStyle>, options?: Partial<TableOptions>): Table;
+}
+
+/**
+ * Table options
+ */
+export declare interface TableOptions extends DrawingOptions {
+    rows?: string[][];
+    headerRow?: boolean;
+    fontSize?: number;
+    backgroundColor?: string;
+    headerColor?: string;
+    textColor?: string;
+    borderColor?: string;
+    cellPadding?: number;
+}
+
+export declare class TablePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Table);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * TextAnnotation - A text label placed on the chart.
+ *
+ * Features:
+ * - Single anchor point (position)
+ * - Customizable text, font, alignment
+ * - Optional background and border
+ */
+export declare class TextAnnotation extends Drawing {
+    readonly type = "text-annotation";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 10;
+    private _textOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<TextAnnotationOptions>);
+    get textOptions(): TextAnnotationOptions;
+    setTextOptions(options: Partial<TextAnnotationOptions>): void;
+    setText(text: string): void;
+    getText(): string;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, position: Anchor, text: string, style?: Partial<DrawingStyle>, options?: Partial<TextAnnotationOptions>): TextAnnotation;
+}
+
+/**
+ * TextAnnotation options
+ */
+export declare interface TextAnnotationOptions extends DrawingOptions {
+    text?: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: string;
+    textAlign?: CanvasTextAlign;
+    backgroundColor?: string;
+    borderColor?: string;
+    padding?: number;
+}
+
+export declare class TextAnnotationPaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: TextAnnotation);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Text geometry
+ */
+export declare interface TextGeometry {
+    type: 'text';
+    position: Point;
+    text: string;
+    font?: string;
+    color?: string;
+    align?: CanvasTextAlign;
+    baseline?: CanvasTextBaseline;
+    rotation?: number;
+}
+
+/**
+ * Three-point interaction handler for channel/pitchfork drawings
+ */
+export declare class ThreePointInteractionHandler extends InteractionHandler {
+    constructor(config: Omit<InteractionConfig, 'requiredAnchors'>);
+}
+
+/**
+ * Preview renderer for three-point drawings (channels, pitchforks)
+ */
+export declare class ThreePointPreviewRenderer extends PreviewRenderer {
+    render(ctx: CanvasRenderingContext2D, anchors: Anchor[], previewAnchor: Anchor | null, viewport: Viewport, style: DrawingStyle, pixelRatio: number): void;
+}
+
+/**
+ * All registered drawing tools
+ */
+export declare const TOOL_DEFINITIONS: ToolRegistryEntry[];
+
+/**
+ * Tool Registry - Central registry for all drawing tools.
+ */
+export declare class ToolRegistry {
+    private static _instance;
+    private _tools;
+    private constructor();
+    static getInstance(): ToolRegistry;
+    /**
+     * Register a custom tool
+     */
+    register(entry: ToolRegistryEntry): void;
+    /**
+     * Get tool definition by type
+     */
+    get(type: string): ToolRegistryEntry | undefined;
+    /**
+     * Get all tool definitions
+     */
+    getAll(): ToolRegistryEntry[];
+    /**
+     * Get tools by category
+     */
+    getByCategory(category: DrawingCategory): ToolRegistryEntry[];
+    /**
+     * Get all categories
+     */
+    getCategories(): DrawingCategory[];
+    /**
+     * Create a drawing instance
+     */
+    createDrawing(type: string, id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DrawingOptions>): IDrawing | null;
+    /**
+     * Check if a tool type is registered
+     */
+    has(type: string): boolean;
+}
+
+/**
+ * Tool definition with factory function
+ */
+declare interface ToolRegistryEntry extends DrawingToolDefinition {
+    factory: (id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<DrawingOptions>) => IDrawing;
+}
+
+/**
+ * TrendAngle - A line that displays its angle with a visual arc indicator.
+ *
+ * Features:
+ * - Two anchor points
+ * - Visual arc showing the angle from horizontal
+ * - Degree label display
+ * - Useful for measuring trend slopes
+ */
+export declare class TrendAngle extends BaseLine {
+    readonly type = "trend-angle";
+    private _trendAngleOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<TrendAngleOptions>);
+    get trendAngleOptions(): TrendAngleOptions;
+    setTrendAngleOptions(options: Partial<TrendAngleOptions>): void;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    /**
+     * Get the angle in radians (from horizontal)
+     */
+    private getAngleRadians;
+    /**
+     * Get the angle in degrees
+     */
+    getAngle(): number;
+    clone(newId: string): IDrawing;
+    static create(id: string, startAnchor: Anchor, endAnchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<TrendAngleOptions>): TrendAngle;
+}
+
+/**
+ * TrendAngle options
+ */
+export declare interface TrendAngleOptions extends DrawingOptions {
+    showArc?: boolean;
+    arcRadius?: number;
+    showDegrees?: boolean;
+}
+
+export declare class TrendAnglePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: TrendAngle);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * TrendLine - The most advanced line drawing tool.
+ *
+ * Features:
+ * - Two-point line drawing
+ * - Optional line extensions (left/right)
+ * - Optional angle display
+ * - Optional price/percentage change display
+ * - Optional bar count display
+ * - Hit testing for selection
+ * - Anchor manipulation
+ */
+export declare class TrendLine extends BaseLine {
+    readonly type = "trend-line";
+    private _trendLineOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<TrendLineOptions>);
+    get trendLineOptions(): TrendLineOptions;
+    setTrendLineOptions(options: Partial<TrendLineOptions>): void;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    private computeLabelGeometry;
+    clone(newId: string): IDrawing;
+    toJSON(): {
+        options: {
+            showAngle?: boolean;
+            showPriceChange?: boolean;
+            showPercentChange?: boolean;
+            showBars?: boolean;
+            visible?: boolean;
+            locked?: boolean;
+            zIndex?: number;
+            extendLeft?: boolean;
+            extendRight?: boolean;
+        };
+        id: string;
+        type: string;
+        anchors: Anchor[];
+        style: DrawingStyle;
+    };
+    fromJSON(data: any): void;
+    static create(id: string, startAnchor: Anchor, endAnchor: Anchor, style?: Partial<DrawingStyle>, options?: Partial<TrendLineOptions>): TrendLine;
+}
+
+/**
+ * TrendLine options beyond base drawing options
+ */
+export declare interface TrendLineOptions extends DrawingOptions {
+    showAngle?: boolean;
+    showPriceChange?: boolean;
+    showPercentChange?: boolean;
+    showBars?: boolean;
+}
+
+/**
+ * Specialized pane view for TrendLine with label support
+ */
+export declare class TrendLinePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: TrendLine);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Triangle - A triangular shape defined by three points.
+ *
+ * Features:
+ * - Three anchor points (vertices)
+ * - Optional fill
+ */
+export declare class Triangle extends Drawing {
+    readonly type = "triangle";
+    protected static readonly REQUIRED_ANCHORS = 3;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _triangleOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<TriangleOptions>);
+    get triangleOptions(): TriangleOptions;
+    setTriangleOptions(options: Partial<TriangleOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    private isPointInTriangle;
+    clone(newId: string): IDrawing;
+    static create(id: string, p1: Anchor, p2: Anchor, p3: Anchor, style?: Partial<DrawingStyle>, options?: Partial<TriangleOptions>): Triangle;
+}
+
+/**
+ * Triangle options
+ */
+export declare interface TriangleOptions extends DrawingOptions {
+    filled?: boolean;
+}
+
+export declare class TrianglePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: Triangle);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Two-point interaction handler for line-based drawings
+ */
+export declare class TwoPointInteractionHandler extends InteractionHandler {
+    constructor(config: Omit<InteractionConfig, 'requiredAnchors'>);
+}
+
+export declare const VERSION = "0.1.0";
+
+/**
+ * VerticalLine - A vertical line at a specific time.
+ *
+ * Features:
+ * - Single anchor point (time)
+ * - Extends across entire viewport height
+ * - Optional time label
+ * - Optional custom label text
+ */
+export declare class VerticalLine extends Drawing {
+    readonly type = "vertical-line";
+    protected static readonly REQUIRED_ANCHORS = 1;
+    protected static readonly HIT_THRESHOLD = 5;
+    private _verticalLineOptions;
+    constructor(id: string, anchors?: Anchor[], style?: Partial<DrawingStyle>, options?: Partial<VerticalLineOptions>);
+    get verticalLineOptions(): VerticalLineOptions;
+    setVerticalLineOptions(options: Partial<VerticalLineOptions>): void;
+    isValid(): boolean;
+    paneViews(): IPrimitivePaneView[];
+    computeGeometry(viewport: Viewport): Geometry[];
+    testHit(point: Point, viewport: Viewport): boolean;
+    clone(newId: string): IDrawing;
+    static create(id: string, time: number | string, price: number, style?: Partial<DrawingStyle>, options?: Partial<VerticalLineOptions>): VerticalLine;
+}
+
+/**
+ * VerticalLine options
+ */
+export declare interface VerticalLineOptions extends DrawingOptions {
+    showTime?: boolean;
+    showLabel?: boolean;
+    labelText?: string;
+}
+
+export declare class VerticalLinePaneView implements IPrimitivePaneView {
+    private _renderer;
+    constructor(drawing: VerticalLine);
+    zOrder(): 'bottom' | 'normal' | 'top';
+    renderer(): IPrimitivePaneRenderer;
+}
+
+/**
+ * Preview renderer for vertical line (single point)
+ */
+export declare class VerticalLinePreviewRenderer extends PreviewRenderer {
+    render(ctx: CanvasRenderingContext2D, anchors: Anchor[], previewAnchor: Anchor | null, viewport: Viewport, style: DrawingStyle, pixelRatio: number): void;
+}
+
+/**
+ * Viewport information for rendering
+ */
+export declare interface Viewport {
+    width: number;
+    height: number;
+    timeScale: {
+        coordinateToTime(x: number): Time | null;
+        timeToCoordinate(time: Time): Coordinate | null;
+        logicalToCoordinate(logical: Logical): Coordinate | null;
+    };
+    priceScale: {
+        coordinateToPrice(y: number): number | null;
+        priceToCoordinate(price: number): Coordinate | null;
+    };
+}
+
+export { }