@dwlf/charting 1.0.0 → 1.1.1

package/dist/components/overlays/ArrowAnnotationView.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { ArrowAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface ArrowAnnotationViewProps {
+    annotation: ArrowAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<ArrowAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+    onDoubleClick?: (id: string) => void;
+}
+declare const ArrowAnnotationView: React.FC<ArrowAnnotationViewProps>;
+export default ArrowAnnotationView;

package/dist/components/overlays/BosLineAnnotationView.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { BosLineAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface BosLineAnnotationViewProps {
+    annotation: BosLineAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onDoubleClick?: (id: string) => void;
+    onMove?: (id: string, newPrice: number) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const BosLineAnnotationView: React.FC<BosLineAnnotationViewProps>;
+export default BosLineAnnotationView;

package/dist/components/overlays/BrushAnnotationView.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { BrushAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface BrushAnnotationViewProps {
+    annotation: BrushAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onDoubleClick?: (id: string) => void;
+    onMove?: (id: string, update: Partial<BrushAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const BrushAnnotationView: React.FC<BrushAnnotationViewProps>;
+export default BrushAnnotationView;

package/dist/components/overlays/ChannelAnnotationView.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { ChannelAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface ChannelAnnotationViewProps {
+    annotation: ChannelAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<ChannelAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const ChannelAnnotationView: React.FC<ChannelAnnotationViewProps>;
+export default ChannelAnnotationView;

package/dist/components/overlays/CrossLineAnnotationView.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { CrossLineAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface CrossLineAnnotationViewProps {
+    annotation: CrossLineAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, newTime: number, newPrice: number) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+    /** Custom time formatter (defaults to MM/DD HH:MM) */
+    timeFormatter?: (t: number) => string;
+}
+/**
+ * Cross Line annotation — draws a horizontal + vertical line intersection
+ * at a single (time, price) point, showing both price and date.
+ */
+declare const CrossLineAnnotationView: React.FC<CrossLineAnnotationViewProps>;
+export default CrossLineAnnotationView;

package/dist/components/overlays/DiagonalLineOverlay.d.ts

@@ -0,0 +1,31 @@
+export default DiagonalLineOverlay;
+/**
+ * DiagonalLineOverlay
+ * Draws a straight line from (start.date, start.value) to (end.date, end.value).
+ *
+ * @param {Object} props
+ * @param {{ date: string | Date, value: number }} props.start - Start position
+ * @param {{ date: string | Date, value: number }} props.end - End position
+ * @param {Function} props.xScale - D3 time scale (date -> px)
+ * @param {Function} props.yScale - D3 linear scale (price -> px)
+ * @param {number} props.xBandwidth - Width of one candlestick band (used to center the line on the candle)
+ * @param {string} [props.stroke='purple'] - Line color
+ * @param {number} [props.strokeWidth=1.5] - Line thickness
+ * @param {string} [props.strokeDasharray] - Dash pattern (e.g., '5,5' for dashed)
+ */
+declare function DiagonalLineOverlay({ start, end, xScale, yScale, xBandwidth, stroke, strokeWidth, strokeDasharray, }: {
+    start: {
+        date: string | Date;
+        value: number;
+    };
+    end: {
+        date: string | Date;
+        value: number;
+    };
+    xScale: Function;
+    yScale: Function;
+    xBandwidth: number;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/overlays/EmojiAnnotationView.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { EmojiAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface EmojiAnnotationViewProps {
+    annotation: EmojiAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, newTime: number, newPrice: number) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points (required for closest index search when compressGaps enabled) */
+    dataLength?: number;
+    /** Precomputed array of raw timestamps for each compressed index */
+    compressedTimes?: number[];
+}
+declare const EmojiAnnotationView: React.FC<EmojiAnnotationViewProps>;
+export default EmojiAnnotationView;

package/dist/components/overlays/FairValueGapAnnotationView.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { FairValueGapAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface FairValueGapAnnotationViewProps {
+    annotation: FairValueGapAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<FairValueGapAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const FairValueGapAnnotationView: React.FC<FairValueGapAnnotationViewProps>;
+export default FairValueGapAnnotationView;

package/dist/components/overlays/FibExtensionAnnotationView.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { FibExtensionAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface FibExtensionAnnotationViewProps {
+    annotation: FibExtensionAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<FibExtensionAnnotation>) => void;
+    timeToIndex?: (time: number) => number | undefined;
+    indexToTime?: (index: number) => number;
+    dataLength?: number;
+    compressedTimes?: number[];
+}
+declare const FibExtensionAnnotationView: React.FC<FibExtensionAnnotationViewProps>;
+export default FibExtensionAnnotationView;

package/dist/components/overlays/FibRetracementAnnotationView.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { FibRetracementAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface FibRetracementAnnotationViewProps {
+    annotation: FibRetracementAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<FibRetracementAnnotation>) => void;
+    timeToIndex?: (time: number) => number | undefined;
+    indexToTime?: (index: number) => number;
+    dataLength?: number;
+    compressedTimes?: number[];
+}
+declare const FibRetracementAnnotationView: React.FC<FibRetracementAnnotationViewProps>;
+export default FibRetracementAnnotationView;

package/dist/components/overlays/HLineAnnotationView.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { HLineAnnotation, PaneComputedScale } from '../../charting/types';
+export interface HLineAnnotationViewProps {
+    annotation: HLineAnnotation;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onDoubleClick?: (id: string) => void;
+    onMove?: (id: string, newPrice: number) => void;
+}
+declare const HLineAnnotationView: React.FC<HLineAnnotationViewProps>;
+export default HLineAnnotationView;

package/dist/components/overlays/HorizontalLineOverlay.d.ts

@@ -0,0 +1,23 @@
+export default HorizontalLineOverlay;
+/**
+ * HorizontalLineOverlay
+ * @param {Object} props
+ * @param {number} props.value - The price level to draw the horizontal line at
+ * @param {Function} props.yScale - D3 scale for y-axis (value -> px)
+ * @param {number} props.width - Width of the chart area
+ * @param {string} [props.stroke='red'] - Line color
+ * @param {number} [props.strokeWidth=1.5] - Line thickness
+ * @param {string} [props.strokeDasharray] - Dash pattern (e.g., '5,5' for dashed line)
+ * @param {string} [props.label] - Optional label to display
+ * @param {boolean} [props.showLabel=true] - Whether to show the label
+ */
+declare function HorizontalLineOverlay({ value, yScale, width, stroke, strokeWidth, strokeDasharray, label, showLabel }: {
+    value: number;
+    yScale: Function;
+    width: number;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+    strokeDasharray?: string | undefined;
+    label?: string | undefined;
+    showLabel?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/overlays/MarkerOverlay.d.ts

@@ -0,0 +1,66 @@
+import { default as PropTypes } from 'prop-types';
+/**
+ * MarkerOverlay renders symbols (arrows, circles, etc.) at specific date/price points on the chart.
+ *
+ * props:
+ * - points : Array<{ date: string | Date, price: number, tooltip?: string }>
+ * - xScale : d3 scaleTime – maps dates => x coord
+ * - yScale : d3 scaleLinear – maps prices => y coord
+ * - xBandwidth : number – candle width, used to centre markers over candlesticks
+ * - shape : 'arrow-up' | 'arrow-down' | 'circle' | 'none'
+ * - size : number – base size of the marker in px
+ * - color : string – fill / stroke colour
+ * - offsetY : number – Y-offset in px to fine-tune vertical placement (positive => down)
+ * - text : string – optional text label for the marker
+ * - fontSize : number – optional font size for the text label
+ * - textColor : string – optional text color for the label
+ * - textOffsetY : number – optional Y-offset for the text label
+ * - onMarkerClick : function – optional click handler (receives point data)
+ * - animationPhase : string – current animation phase for drop-in effects
+ * - staggerDelay : number – delay in ms between each marker animation
+ * - staggerStartIndex : number – base index offset for staggered animation
+ */
+declare function MarkerOverlay({ points, xScale, yScale, xBandwidth, shape, size, color, offsetY, text, fontSize, textColor, textOffsetY, onMarkerClick, animationPhase, staggerDelay, staggerStartIndex, }: {
+    points?: never[] | undefined;
+    xScale: any;
+    yScale: any;
+    xBandwidth?: number | undefined;
+    shape?: string | undefined;
+    size?: number | undefined;
+    color?: string | undefined;
+    offsetY?: number | undefined;
+    text: any;
+    fontSize?: number | undefined;
+    textColor?: any;
+    textOffsetY?: number | undefined;
+    onMarkerClick: any;
+    animationPhase: any;
+    staggerDelay?: number | undefined;
+    staggerStartIndex?: number | undefined;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare namespace MarkerOverlay {
+    namespace propTypes {
+        let points: PropTypes.Requireable<(PropTypes.InferProps<{
+            date: PropTypes.Validator<NonNullable<NonNullable<string | number | Date | null | undefined>>>;
+            price: PropTypes.Validator<number>;
+            text: PropTypes.Requireable<string>;
+            tooltip: PropTypes.Requireable<string>;
+        }> | null | undefined)[]>;
+        let xScale: PropTypes.Validator<(...args: any[]) => any>;
+        let yScale: PropTypes.Validator<(...args: any[]) => any>;
+        let xBandwidth: PropTypes.Requireable<number>;
+        let shape: PropTypes.Requireable<string>;
+        let size: PropTypes.Requireable<number>;
+        let color: PropTypes.Requireable<string>;
+        let offsetY: PropTypes.Requireable<number>;
+        let text: PropTypes.Requireable<string>;
+        let fontSize: PropTypes.Requireable<number>;
+        let textColor: PropTypes.Requireable<string>;
+        let textOffsetY: PropTypes.Requireable<number>;
+        let onMarkerClick: PropTypes.Requireable<(...args: any[]) => any>;
+        let animationPhase: PropTypes.Requireable<string>;
+        let staggerDelay: PropTypes.Requireable<number>;
+        let staggerStartIndex: PropTypes.Requireable<number>;
+    }
+}
+export default MarkerOverlay;

package/dist/components/overlays/MeasureAnnotationView.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { MeasureAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface MeasureAnnotationViewProps {
+    annotation: MeasureAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<MeasureAnnotation>) => void;
+    /** Current chart timeframe for bar count estimation */
+    currentTimeframe?: string;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const MeasureAnnotationView: React.FC<MeasureAnnotationViewProps>;
+export default MeasureAnnotationView;

package/dist/components/overlays/MessageBubbleOverlay.d.ts

@@ -0,0 +1,55 @@
+import { default as PropTypes } from 'prop-types';
+/**
+ * MessageBubbleOverlay
+ * Renders text bubbles that optionally point at a specific candle (date / price).
+ *
+ * props:
+ * - messages : Array<{
+ *     date: string | Date,
+ *     price: number,
+ *     text: string,
+ *   }>
+ * - xScale : d3 scaleTime – maps dates => x coord
+ * - yScale : d3 scaleLinear – maps prices => y coord
+ * - xBandwidth : number – candle width, used to centre pointer over candlesticks
+ * - chartWidth : number – inner drawing width of the chart (excluding margins)
+ * - chartHeight : number – inner drawing height of the chart (excluding margins)
+ * - bubbleColor : string – background colour of the bubble
+ * - textColor : string – colour of the text inside the bubble
+ * - fontSize : number – font size of the text
+ * - pointer : boolean – whether to draw a pointer/line towards the candle (default true)
+ * - padding : number – inner padding of the text inside the bubble (in px)
+ */
+declare function MessageBubbleOverlay({ messages, xScale, yScale, xBandwidth, chartWidth, chartHeight, bubbleColor, textColor, fontSize, pointer, padding, }: {
+    messages?: never[] | undefined;
+    xScale: any;
+    yScale: any;
+    xBandwidth?: number | undefined;
+    chartWidth: any;
+    chartHeight: any;
+    bubbleColor?: string | undefined;
+    textColor?: string | undefined;
+    fontSize?: number | undefined;
+    pointer?: boolean | undefined;
+    padding?: number | undefined;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare namespace MessageBubbleOverlay {
+    namespace propTypes {
+        let messages: PropTypes.Requireable<(PropTypes.InferProps<{
+            date: PropTypes.Validator<NonNullable<NonNullable<string | number | Date | null | undefined>>>;
+            price: PropTypes.Validator<number>;
+            text: PropTypes.Validator<string>;
+        }> | null | undefined)[]>;
+        let xScale: PropTypes.Validator<(...args: any[]) => any>;
+        let yScale: PropTypes.Validator<(...args: any[]) => any>;
+        let xBandwidth: PropTypes.Requireable<number>;
+        let chartWidth: PropTypes.Validator<number>;
+        let chartHeight: PropTypes.Validator<number>;
+        let bubbleColor: PropTypes.Requireable<string>;
+        let textColor: PropTypes.Requireable<string>;
+        let fontSize: PropTypes.Requireable<number>;
+        let pointer: PropTypes.Requireable<boolean>;
+        let padding: PropTypes.Requireable<number>;
+    }
+}
+export default MessageBubbleOverlay;

package/dist/components/overlays/OrderBlockAnnotationView.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { OrderBlockAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface OrderBlockAnnotationViewProps {
+    annotation: OrderBlockAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<OrderBlockAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const OrderBlockAnnotationView: React.FC<OrderBlockAnnotationViewProps>;
+export default OrderBlockAnnotationView;

package/dist/components/overlays/PitchforkAnnotationView.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { PitchforkAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface PitchforkAnnotationViewProps {
+    annotation: PitchforkAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<PitchforkAnnotation>) => void;
+    timeToIndex?: (time: number) => number | undefined;
+    indexToTime?: (index: number) => number;
+    dataLength?: number;
+    compressedTimes?: number[];
+}
+declare const PitchforkAnnotationView: React.FC<PitchforkAnnotationViewProps>;
+export default PitchforkAnnotationView;

package/dist/components/overlays/PositionOverlay.d.ts

@@ -0,0 +1,52 @@
+import { default as PropTypes } from 'prop-types';
+/**
+ * PositionOverlay draws two semi-transparent rectangles to visualise
+ * risk (entry ⇒ stop-loss) and reward (entry ⇒ take-profit).
+ */
+declare function PositionOverlay({ startDate, endDate, entryPrice, stopPrice, takePrice, xScale, yScale, riskColor, rewardColor, messages, xBandwidth, chartWidth, chartHeight, bubbleColor, textColor, fontSize, pointer, padding, }: {
+    startDate: any;
+    endDate: any;
+    entryPrice: any;
+    stopPrice: any;
+    takePrice: any;
+    xScale: any;
+    yScale: any;
+    riskColor?: string | undefined;
+    rewardColor?: string | undefined;
+    messages?: never[] | undefined;
+    xBandwidth?: number | undefined;
+    chartWidth: any;
+    chartHeight: any;
+    bubbleColor?: string | undefined;
+    textColor?: string | undefined;
+    fontSize?: number | undefined;
+    pointer?: boolean | undefined;
+    padding?: number | undefined;
+}): import("react/jsx-runtime").JSX.Element | null;
+declare namespace PositionOverlay {
+    namespace propTypes {
+        let startDate: PropTypes.Validator<NonNullable<NonNullable<string | number | Date | null | undefined>>>;
+        let endDate: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        let entryPrice: PropTypes.Validator<number>;
+        let stopPrice: PropTypes.Validator<number>;
+        let takePrice: PropTypes.Validator<number>;
+        let xScale: PropTypes.Validator<(...args: any[]) => any>;
+        let yScale: PropTypes.Validator<(...args: any[]) => any>;
+        let riskColor: PropTypes.Requireable<string>;
+        let rewardColor: PropTypes.Requireable<string>;
+        let messages: PropTypes.Requireable<(PropTypes.InferProps<{
+            date: PropTypes.Validator<NonNullable<NonNullable<string | number | Date | null | undefined>>>;
+            price: PropTypes.Validator<number>;
+            text: PropTypes.Validator<string>;
+        }> | null | undefined)[]>;
+        let xBandwidth: PropTypes.Requireable<number>;
+        let chartWidth: PropTypes.Requireable<number>;
+        let chartHeight: PropTypes.Requireable<number>;
+        let bubbleColor: PropTypes.Requireable<string>;
+        let textColor: PropTypes.Requireable<string>;
+        let fontSize: PropTypes.Requireable<number>;
+        let pointer: PropTypes.Requireable<boolean>;
+        let padding: PropTypes.Requireable<number>;
+    }
+}
+export default PositionOverlay;

package/dist/components/overlays/RayAnnotationView.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { RayAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface RayAnnotationViewProps {
+    annotation: RayAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<RayAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+/**
+ * Ray annotation — a two-point line that starts at point 1 and extends
+ * infinitely through and beyond point 2.
+ *
+ * Internally delegates to TrendLineAnnotationView with extendRight=true
+ * and extendLeft=false, avoiding code duplication.
+ */
+declare const RayAnnotationView: React.FC<RayAnnotationViewProps>;
+export default RayAnnotationView;

package/dist/components/overlays/RectangleAnnotationView.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { RectangleAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface RectangleAnnotationViewProps {
+    annotation: RectangleAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<RectangleAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const RectangleAnnotationView: React.FC<RectangleAnnotationViewProps>;
+export default RectangleAnnotationView;

package/dist/components/overlays/SMAOverlay.d.ts

@@ -0,0 +1,20 @@
+export default SMAOverlay;
+/**
+ * SMAOverlay
+ * @param {Object} props
+ * @param {Array<{ date: string, value: number }>} props.data
+ * @param {Function} props.xScale - D3 scale for x-axis (date -> px)
+ * @param {Function} props.yScale - D3 scale for y-axis (value -> px)
+ * @param {string} [props.stroke='orange'] - Line color
+ * @param {number} [props.strokeWidth=1.5] - Line thickness
+ */
+declare function SMAOverlay({ data, xScale, yScale, stroke, strokeWidth }: {
+    data: Array<{
+        date: string;
+        value: number;
+    }>;
+    xScale: Function;
+    yScale: Function;
+    stroke?: string | undefined;
+    strokeWidth?: number | undefined;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/overlays/TextAnnotationView.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+import { TextAnnotation, PaneComputedScale, XScale } from '../../charting/types';
+export interface TextAnnotationViewProps {
+    annotation: TextAnnotation;
+    xScale: XScale;
+    yScale: PaneComputedScale;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onDoubleClick?: (id: string) => void;
+    onMove?: (id: string, newTime: number, newPrice: number) => void;
+    onTextEdit?: (id: string) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points (required for closest index search when compressGaps enabled) */
+    dataLength?: number;
+    /** Precomputed array of raw timestamps for each compressed index */
+    compressedTimes?: number[];
+}
+declare const TextAnnotationView: React.FC<TextAnnotationViewProps>;
+export default TextAnnotationView;

package/dist/components/overlays/TimeRangeAnnotationView.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { TimeRangeAnnotation, XScale } from '../../charting/types';
+export interface TimeRangeAnnotationViewProps {
+    annotation: TimeRangeAnnotation;
+    xScale: XScale;
+    chartWidth: number;
+    paneHeight: number;
+    darkMode?: boolean;
+    selected?: boolean;
+    onSelect?: (id: string | null) => void;
+    onMove?: (id: string, update: Partial<TimeRangeAnnotation>) => void;
+    /** Convert raw timestamp to index when compressGaps is enabled */
+    timeToIndex?: (time: number) => number | undefined;
+    /** Convert index back to raw timestamp when compressGaps is enabled */
+    indexToTime?: (index: number) => number;
+    /** Number of data points */
+    dataLength?: number;
+    /** Pre-computed compressed times array */
+    compressedTimes?: number[];
+}
+declare const TimeRangeAnnotationView: React.FC<TimeRangeAnnotationViewProps>;
+export default TimeRangeAnnotationView;