candleview 1.0.0

package/dist/components/CandleView/MarkManager/Elliott/ElliottImpulseMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { ElliottImpulseMark } from "../../Mark/Pattern/ElliottImpulseMark";
+import { Point } from "../../types";
+export interface ElliottImpulseMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ElliottImpulseMarkState {
+    isElliottImpulseMode: boolean;
+    currentPoints: Point[];
+    currentElliottImpulseMark: ElliottImpulseMark | null;
+    isDragging: boolean;
+    dragTarget: ElliottImpulseMark | null;
+    dragPoint: number | null;
+}
+export declare class ElliottImpulseMarkManager implements IMarkManager<ElliottImpulseMark> {
+    private props;
+    private state;
+    private previewMark;
+    private elliottImpulseMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: ElliottImpulseMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ElliottImpulseMark | null;
+    getCurrentDragTarget(): ElliottImpulseMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ElliottImpulseMark | null;
+    getAllMarks(): ElliottImpulseMark[];
+    cancelOperationMode(): ElliottImpulseMarkState;
+    setElliottImpulseMode: () => ElliottImpulseMarkState;
+    cancelElliottImpulseMode: () => ElliottImpulseMarkState;
+    handleMouseDown: (point: Point) => ElliottImpulseMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ElliottImpulseMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ElliottImpulseMarkState;
+    getState(): ElliottImpulseMarkState;
+    updateProps(newProps: Partial<ElliottImpulseMarkManagerProps>): void;
+    destroy(): void;
+    getElliottImpulseMarks(): ElliottImpulseMark[];
+    removeElliottImpulseMark(mark: ElliottImpulseMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ElliottImpulseMark): void;
+    showMark(mark: ElliottImpulseMark): void;
+}

package/dist/components/CandleView/MarkManager/Elliott/ElliottTriangleMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { ElliottTriangleMark } from "../../Mark/Pattern/ElliottTriangleMark";
+import { Point } from "../../types";
+export interface ElliottTriangleMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ElliottTriangleMarkState {
+    isElliottTriangleMode: boolean;
+    currentPoints: Point[];
+    currentElliottTriangleMark: ElliottTriangleMark | null;
+    isDragging: boolean;
+    dragTarget: ElliottTriangleMark | null;
+    dragPoint: number | null;
+}
+export declare class ElliottTriangleMarkManager implements IMarkManager<ElliottTriangleMark> {
+    private props;
+    private state;
+    private previewMark;
+    private elliottTriangleMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: ElliottTriangleMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ElliottTriangleMark | null;
+    getCurrentDragTarget(): ElliottTriangleMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ElliottTriangleMark | null;
+    getAllMarks(): ElliottTriangleMark[];
+    cancelOperationMode(): ElliottTriangleMarkState;
+    setElliottTriangleMode: () => ElliottTriangleMarkState;
+    cancelElliottTriangleMode: () => ElliottTriangleMarkState;
+    handleMouseDown: (point: Point) => ElliottTriangleMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ElliottTriangleMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ElliottTriangleMarkState;
+    getState(): ElliottTriangleMarkState;
+    updateProps(newProps: Partial<ElliottTriangleMarkManagerProps>): void;
+    destroy(): void;
+    getElliottTriangleMarks(): ElliottTriangleMark[];
+    removeElliottTriangleMark(mark: ElliottTriangleMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ElliottTriangleMark): void;
+    showMark(mark: ElliottTriangleMark): void;
+}

package/dist/components/CandleView/MarkManager/Elliott/ElliottTripleCombinationMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { ElliottTripleCombinationMark } from "../../Mark/Pattern/ElliottTripleCombinationMark";
+import { Point } from "../../types";
+export interface ElliottTripleCombinationMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ElliottTripleCombinationMarkState {
+    isElliottTripleCombinationMode: boolean;
+    currentPoints: Point[];
+    currentElliottTripleCombinationMark: ElliottTripleCombinationMark | null;
+    isDragging: boolean;
+    dragTarget: ElliottTripleCombinationMark | null;
+    dragPoint: number | null;
+}
+export declare class ElliottTripleCombinationMarkManager implements IMarkManager<ElliottTripleCombinationMark> {
+    private props;
+    private state;
+    private previewMark;
+    private ElliottTripleCombinationMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: ElliottTripleCombinationMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ElliottTripleCombinationMark | null;
+    getCurrentDragTarget(): ElliottTripleCombinationMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ElliottTripleCombinationMark | null;
+    getAllMarks(): ElliottTripleCombinationMark[];
+    cancelOperationMode(): ElliottTripleCombinationMarkState;
+    setElliottTripleCombinationMode: () => ElliottTripleCombinationMarkState;
+    cancelElliottTripleCombinationMode: () => ElliottTripleCombinationMarkState;
+    handleMouseDown: (point: Point) => ElliottTripleCombinationMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ElliottTripleCombinationMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ElliottTripleCombinationMarkState;
+    getState(): ElliottTripleCombinationMarkState;
+    updateProps(newProps: Partial<ElliottTripleCombinationMarkManagerProps>): void;
+    destroy(): void;
+    getElliottTripleCombinationMarks(): ElliottTripleCombinationMark[];
+    removeElliottTripleCombinationMark(mark: ElliottTripleCombinationMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ElliottTripleCombinationMark): void;
+    showMark(mark: ElliottTripleCombinationMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciArcMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciArcMark } from "../../Mark/Fibonacci/FibonacciArcMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciArcMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciArcMarkState {
+    isFibonacciArcMode: boolean;
+    fibonacciArcStartPoint: Point | null;
+    currentFibonacciArc: FibonacciArcMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciArcMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class FibonacciArcMarkManager implements IMarkManager<FibonacciArcMark> {
+    private props;
+    private state;
+    private previewFibonacciArcMark;
+    private fibonacciArcMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciArcMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciArcMark | null;
+    getCurrentDragTarget(): FibonacciArcMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciArcMark | null;
+    getAllMarks(): FibonacciArcMark[];
+    cancelOperationMode(): FibonacciArcMarkState;
+    setFibonacciArcMode: () => FibonacciArcMarkState;
+    cancelFibonacciArcMode: () => FibonacciArcMarkState;
+    handleMouseDown: (point: Point) => FibonacciArcMarkState;
+    private coordinateToPriceFallback;
+    private priceToCoordinateFallback;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciArcMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciArcMarkState;
+    getState(): FibonacciArcMarkState;
+    updateProps(newProps: Partial<FibonacciArcMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciArcMarks(): FibonacciArcMark[];
+    removeFibonacciArcMark(mark: FibonacciArcMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciArcMark): void;
+    showMark(mark: FibonacciArcMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciChannelMarkManager.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciChannelMark } from "../../Mark/Fibonacci/FibonacciChannelMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciChannelMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciChannelMarkState {
+    isFibonacciChannelMarkMode: boolean;
+    fibonacciChannelMarkStartPoint: Point | null;
+    currentFibonacciChannelMark: FibonacciChannelMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciChannelMark | null;
+    dragPoint: 'start' | 'end' | 'channel' | 'line' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'widthAdjust' | 'none';
+    adjustingMode: 'start' | 'end' | 'channel' | null;
+    adjustStartData: {
+        time: number;
+        price: number;
+        channelHeight: number;
+    } | null;
+}
+export declare class FibonacciChannelMarkManager implements IMarkManager<FibonacciChannelMark> {
+    private props;
+    private state;
+    private previewFibonacciChannelMark;
+    private channelMarks;
+    private mouseDownPoint;
+    private isOperating;
+    private firstPointTime;
+    private firstPointPrice;
+    private secondPointTime;
+    private secondPointPrice;
+    constructor(props: FibonacciChannelMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciChannelMark | null;
+    getCurrentDragTarget(): FibonacciChannelMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciChannelMark | null;
+    getAllMarks(): FibonacciChannelMark[];
+    cancelOperationMode(): FibonacciChannelMarkState;
+    setFibonacciChannelMarkMode: () => FibonacciChannelMarkState;
+    cancelFibonacciChannelMarkMode: () => FibonacciChannelMarkState;
+    handleMouseDown: (point: Point) => FibonacciChannelMarkState;
+    private handleDrawingPhaseMouseDown;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciChannelMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciChannelMarkState;
+    getState(): FibonacciChannelMarkState;
+    updateProps(newProps: Partial<FibonacciChannelMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciChannelMarks(): FibonacciChannelMark[];
+    removeFibonacciChannelMark(mark: FibonacciChannelMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciChannelMark): void;
+    showMark(mark: FibonacciChannelMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciCircleMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciCircleMark } from "../../Mark/Fibonacci/FibonacciCircleMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciCircleMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciCircleMarkState {
+    isFibonacciCircleMode: boolean;
+    fibonacciCircleCenterPoint: Point | null;
+    currentFibonacciCircle: FibonacciCircleMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciCircleMark | null;
+    dragPoint: 'center' | 'radius' | 'circle' | null;
+}
+export declare class FibonacciCircleMarkManager implements IMarkManager<FibonacciCircleMark> {
+    private props;
+    private state;
+    private previewFibonacciCircleMark;
+    private fibonacciCircleMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciCircleMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciCircleMark | null;
+    getCurrentDragTarget(): FibonacciCircleMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciCircleMark | null;
+    getAllMarks(): FibonacciCircleMark[];
+    cancelOperationMode(): FibonacciCircleMarkState;
+    setFibonacciCircleMode: () => FibonacciCircleMarkState;
+    cancelFibonacciCircleMode: () => FibonacciCircleMarkState;
+    handleMouseDown: (point: Point) => FibonacciCircleMarkState;
+    private coordinateToPriceFallback;
+    private priceToCoordinateFallback;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciCircleMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciCircleMarkState;
+    getState(): FibonacciCircleMarkState;
+    updateProps(newProps: Partial<FibonacciCircleMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciCircleMarks(): FibonacciCircleMark[];
+    removeFibonacciCircleMark(mark: FibonacciCircleMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciCircleMark): void;
+    showMark(mark: FibonacciCircleMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciExtensionBasePriceMarkManager.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciExtensionBasePriceMark } from "../../Mark/Fibonacci/FibonacciExtensionBasePriceMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciExtensionBasePriceMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciExtensionBasePriceMarkState {
+    isFibonacciExtensionBasePriceMode: boolean;
+    fibonacciExtensionBasePricePoints: Point[];
+    currentFibonacciExtensionBasePrice: FibonacciExtensionBasePriceMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciExtensionBasePriceMark | null;
+    dragPoint: 'start' | 'end' | 'extension' | 'line' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'extensionPoint' | 'none';
+}
+export declare class FibonacciExtensionBasePriceMarkManager implements IMarkManager<FibonacciExtensionBasePriceMark> {
+    private props;
+    private state;
+    private previewFibonacciExtensionBasePriceMark;
+    private FibonacciExtensionBasePriceMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciExtensionBasePriceMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciExtensionBasePriceMark | null;
+    getCurrentDragTarget(): FibonacciExtensionBasePriceMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciExtensionBasePriceMark | null;
+    getAllMarks(): FibonacciExtensionBasePriceMark[];
+    cancelOperationMode(): FibonacciExtensionBasePriceMarkState;
+    setFibonacciExtensionBasePriceMode: () => FibonacciExtensionBasePriceMarkState;
+    cancelFibonacciExtensionMode: () => FibonacciExtensionBasePriceMarkState;
+    handleMouseDown: (point: Point) => FibonacciExtensionBasePriceMarkState;
+    private coordinateToPriceFallback;
+    private priceToCoordinateFallback;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciExtensionBasePriceMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciExtensionBasePriceMarkState;
+    getState(): FibonacciExtensionBasePriceMarkState;
+    updateProps(newProps: Partial<FibonacciExtensionBasePriceMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciExtensionBasePriceMarks(): FibonacciExtensionBasePriceMark[];
+    removeFibonacciExtensionBasePriceMark(mark: FibonacciExtensionBasePriceMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciExtensionBasePriceMark): void;
+    showMark(mark: FibonacciExtensionBasePriceMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciExtensionBaseTimeMarkManager.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciExtensionBaseTimeMark } from "../../Mark/Fibonacci/FibonacciExtensionBaseTimeMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciExtensionBaseTimeMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciExtensionBaseTimeMarkState {
+    isFibonacciExtensionBaseTimeMode: boolean;
+    fibonacciExtensionBaseTimePoints: Point[];
+    currentFibonacciExtensionBaseTime: FibonacciExtensionBaseTimeMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciExtensionBaseTimeMark | null;
+    dragPoint: 'start' | 'end' | 'extension' | 'line' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'extensionPoint' | 'none';
+}
+export declare class FibonacciExtensionBaseTimeMarkManager implements IMarkManager<FibonacciExtensionBaseTimeMark> {
+    private props;
+    private state;
+    private previewFibonacciExtensionBaseTimeMark;
+    private FibonacciExtensionBaseTimeMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciExtensionBaseTimeMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciExtensionBaseTimeMark | null;
+    getCurrentDragTarget(): FibonacciExtensionBaseTimeMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciExtensionBaseTimeMark | null;
+    getAllMarks(): FibonacciExtensionBaseTimeMark[];
+    cancelOperationMode(): FibonacciExtensionBaseTimeMarkState;
+    setFibonacciExtensionBaseTimeMode: () => FibonacciExtensionBaseTimeMarkState;
+    cancelFibonacciExtensionMode: () => FibonacciExtensionBaseTimeMarkState;
+    handleMouseDown: (point: Point) => FibonacciExtensionBaseTimeMarkState;
+    private coordinateToPriceFallback;
+    private priceToCoordinateFallback;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciExtensionBaseTimeMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciExtensionBaseTimeMarkState;
+    getState(): FibonacciExtensionBaseTimeMarkState;
+    updateProps(newProps: Partial<FibonacciExtensionBaseTimeMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciExtensionBaseTimeMarks(): FibonacciExtensionBaseTimeMark[];
+    removeFibonacciExtensionBaseTimeMark(mark: FibonacciExtensionBaseTimeMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciExtensionBaseTimeMark): void;
+    showMark(mark: FibonacciExtensionBaseTimeMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciFanMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciFanMark } from "../../Mark/Fibonacci/FibonacciFanMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciFanMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciFanMarkState {
+    isFibonacciFanMode: boolean;
+    fibonacciFanStartPoint: Point | null;
+    currentFibonacciFan: FibonacciFanMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciFanMark | null;
+    dragPoint: 'start' | 'center' | 'fan' | null;
+    isDrawing: boolean;
+}
+export declare class FibonacciFanMarkManager implements IMarkManager<FibonacciFanMark> {
+    private props;
+    private state;
+    private previewFibonacciFan;
+    private fibonacciFans;
+    private isOperating;
+    private dragStartData;
+    constructor(props: FibonacciFanMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciFanMark | null;
+    getCurrentDragTarget(): FibonacciFanMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciFanMark | null;
+    getAllMarks(): FibonacciFanMark[];
+    cancelOperationMode(): FibonacciFanMarkState;
+    setFibonacciFanMode: () => FibonacciFanMarkState;
+    cancelFibonacciFanMode: () => FibonacciFanMarkState;
+    private getValidTimeFromCoordinate;
+    handleMouseDown: (point: Point) => FibonacciFanMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciFanMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciFanMarkState;
+    getState(): FibonacciFanMarkState;
+    updateProps(newProps: Partial<FibonacciFanMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciFans(): FibonacciFanMark[];
+    removeFibonacciFan(mark: FibonacciFanMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciFanMark): void;
+    showMark(mark: FibonacciFanMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciRetracementMarkManager.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciRetracementMark } from "../../Mark/Fibonacci/FibonacciRetracementMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciRetracementMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciRetracementMarkState {
+    isFibonacciRetracementMode: boolean;
+    fibonacciRetracementStartPoint: Point | null;
+    currentFibonacciRetracement: FibonacciRetracementMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciRetracementMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class FibonacciRetracementMarkManager implements IMarkManager<FibonacciRetracementMark> {
+    private props;
+    private state;
+    private previewFibonacciRetracementMark;
+    private fibonacciRetracementMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciRetracementMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciRetracementMark | null;
+    getCurrentDragTarget(): FibonacciRetracementMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciRetracementMark | null;
+    getAllMarks(): FibonacciRetracementMark[];
+    cancelOperationMode(): FibonacciRetracementMarkState;
+    setFibonacciRetracementMode: () => FibonacciRetracementMarkState;
+    cancelFibonacciRetracementMode: () => FibonacciRetracementMarkState;
+    handleMouseDown: (point: Point) => FibonacciRetracementMarkState;
+    private coordinateToPriceFallback;
+    private priceToCoordinateFallback;
+    private getPriceRange;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciRetracementMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciRetracementMarkState;
+    getState(): FibonacciRetracementMarkState;
+    updateProps(newProps: Partial<FibonacciRetracementMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciRetracementMarks(): FibonacciRetracementMark[];
+    removeFibonacciRetracementMark(mark: FibonacciRetracementMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciRetracementMark): void;
+    showMark(mark: FibonacciRetracementMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciSpiralMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciSpiralMark } from "../../Mark/Fibonacci/FibonacciSpiralMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciSpiralMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciSpiralMarkState {
+    isFibonacciSpiralMode: boolean;
+    fibonacciSpiralCenterPoint: Point | null;
+    currentFibonacciSpiral: FibonacciSpiralMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciSpiralMark | null;
+    dragPoint: 'center' | 'radius' | 'spiral' | null;
+}
+export declare class FibonacciSpiralMarkManager implements IMarkManager<FibonacciSpiralMark> {
+    private props;
+    private state;
+    private previewFibonacciSpiralMark;
+    private fibonacciSpiralMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciSpiralMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciSpiralMark | null;
+    getCurrentDragTarget(): FibonacciSpiralMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciSpiralMark | null;
+    getAllMarks(): FibonacciSpiralMark[];
+    cancelOperationMode(): FibonacciSpiralMarkState;
+    setFibonacciSpiralMode: () => FibonacciSpiralMarkState;
+    cancelFibonacciSpiralMode: () => FibonacciSpiralMarkState;
+    handleMouseDown: (point: Point) => FibonacciSpiralMarkState;
+    private coordinateToPriceFallback;
+    private priceToCoordinateFallback;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciSpiralMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciSpiralMarkState;
+    getState(): FibonacciSpiralMarkState;
+    updateProps(newProps: Partial<FibonacciSpiralMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciSpiralMarks(): FibonacciSpiralMark[];
+    removeFibonacciSpiralMark(mark: FibonacciSpiralMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciSpiralMark): void;
+    showMark(mark: FibonacciSpiralMark): void;
+}

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciTimeZoonMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { FibonacciTimeZoonMark } from "../../Mark/Fibonacci/FibonacciTimeZoonMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface FibonacciTimeZoonMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciTimeZoonMarkState {
+    isFibonacciTimeZoneMode: boolean;
+    fibonacciTimeZoonStartPoint: Point | null;
+    currentFibonacciTimeZoon: FibonacciTimeZoonMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciTimeZoonMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class FibonacciTimeZoonMarkManager implements IMarkManager<FibonacciTimeZoonMark> {
+    private props;
+    private state;
+    private previewFibonacciTimeZoonMark;
+    private fibonacciTimeZoneMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciTimeZoonMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciTimeZoonMark | null;
+    getCurrentDragTarget(): FibonacciTimeZoonMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciTimeZoonMark | null;
+    getAllMarks(): FibonacciTimeZoonMark[];
+    cancelOperationMode(): FibonacciTimeZoonMarkState;
+    setFibonacciTimeZoneMode: () => FibonacciTimeZoonMarkState;
+    cancelFibonacciTimeZoneMode: () => FibonacciTimeZoonMarkState;
+    handleMouseDown: (point: Point) => FibonacciTimeZoonMarkState;
+    private isPointNearVerticalLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FibonacciTimeZoonMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciTimeZoonMarkState;
+    getState(): FibonacciTimeZoonMarkState;
+    updateProps(newProps: Partial<FibonacciTimeZoonMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciTimeZoonMarks(): FibonacciTimeZoonMark[];
+    removeFibonacciTimeZoonMark(mark: FibonacciTimeZoonMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciTimeZoonMark): void;
+    showMark(mark: FibonacciTimeZoonMark): void;
+}