/**
 * 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 { }