@candleview/core 2.9.5 → 2.9.8

package/dist/index.d.ts

@@ -728,8 +728,43 @@ declare interface BubbleBoxMarkState {
 }
 
 export declare class CandleView {
-    private core;
+    private dom;
+    private theme;
+    private i18n;
+    private dataManager;
+    private candleViewChart;
+    private panels;
+    private priceEvents;
+    marks: CandleViewMark | null;
+    private brushHint;
+    private config;
+    private container;
+    private isOwnContainer;
+    private currentTheme;
+    private topPanelState;
+    private leftPanelState;
+    private currentTimeframe;
+    private currentTimezone;
+    private chartType;
+    private onTimeframeChangeCallback;
     constructor(config: CandleViewConfig);
+    private resolveContainer;
+    private createAutoContainer;
+    private initDOM;
+    private initPanels;
+    private handleTimeframeChange;
+    private handleChartTypeChange;
+    private handleThemeToggle;
+    private handleTimezoneSelect;
+    private handleResize;
+    setData(data: ICandleViewDataPoint[]): void;
+    updateData(newData: ICandleViewDataPoint[]): void;
+    setTheme(themeType: 'light' | 'dark'): void;
+    setLocale(locale: 'en' | 'zh-cn'): void;
+    setOnTimeframeChangeCallback(callback: (candleView: CandleView, timeframe: TimeframeEnum) => void): void;
+    getOnTimeframeChangeCallback(): ((candleView: CandleView, timeframe: TimeframeEnum) => void) | null;
+    setChartType(type: MainChartType): void;
+    getCurrentTheme(): ThemeConfig;
     getTopPanelState(): {
         isTimeframeModalOpen: boolean;
         isIndicatorModalOpen: boolean;
@@ -743,7 +778,7 @@ export declare class CandleView {
         isMobileMenuOpen: boolean;
         activeTimeframe: TimeframeEnum;
         currentMainChartType: MainChartType;
-        currentTimezone: string;
+        currentTimezone: TimezoneEnum;
         selectedSubChartIndicators: SubChartIndicatorType[];
         selectedMainChartIndicator: MainChartIndicatorInfo | null;
         mainIndicatorsSearch: string;
@@ -822,63 +857,22 @@ export declare class CandleView {
     clearAllMarks(): void;
     clearCurrentTool(): void;
     getCurrentTool(): string | null;
-    setData(data: ICandleViewDataPoint[]): void;
-    updateData(newData: ICandleViewDataPoint[]): void;
-    getCurrentTheme(): ThemeConfig;
-    setTheme(themeType: 'light' | 'dark'): void;
-    setLocale(locale: 'en' | 'zh-cn'): void;
-    setChartType(type: MainChartType): void;
     registerPriceEvents(events: PriceEvent[]): void;
     removePriceEventMarker(price: number): void;
     clearAllPriceEventMarkers(): void;
     getPriceEvents(): PriceEvent[];
-    getChart(): Chart | null;
-    destroy(): void;
-    /**
-     * Add a single static mark
-     * @param time Timestamp
-     * @param text Mark text
-     * @param direction Mark direction (StaticMarkDirection.Top or StaticMarkDirection.Bottom)
-     * @param type Mark type (StaticMarkType.Text or StaticMarkType.Arrow)
-     * @param options Optional configuration
-     */
     addStaticMark(time: number, text: string, direction: StaticMarkDirection, type: StaticMarkType, options?: IStaticMarkOptions): void;
-    /**
-     * Add multiple static marks in batch
-     * @param marks Array of marks
-     */
     addStaticMarks(marks: IStaticMarkItem[]): void;
-    /**
-     * Add a text mark (convenience method)
-     * @param time Timestamp
-     * @param text Mark text
-     * @param direction Mark direction
-     * @param options Optional configuration
-     */
     addTextMark(time: number, text: string, direction: StaticMarkDirection, options?: IStaticMarkOptions): void;
-    /**
-     * Add an arrow mark (convenience method)
-     * @param time Timestamp
-     * @param direction Mark direction
-     * @param options Optional configuration
-     */
     addArrowMark(time: number, direction: StaticMarkDirection, options?: IStaticMarkOptions & {
         label?: string;
     }): void;
-    /**
-     * Add multiple text marks in batch
-     * @param marks Array of text marks
-     */
     addTextMarks(marks: Array<{
         time: number;
         text: string;
         direction: StaticMarkDirection;
         options?: IStaticMarkOptions;
     }>): void;
-    /**
-     * Add multiple arrow marks in batch
-     * @param marks Array of arrow marks
-     */
     addArrowMarks(marks: Array<{
         time: number;
         direction: StaticMarkDirection;
@@ -886,14 +880,40 @@ export declare class CandleView {
             label?: string;
         };
     }>): void;
-    /**
-     * Clear all static marks
-     */
     clearAllStaticMarks(): void;
-    /**
-     * Get the count of static marks
-     */
     getStaticMarkCount(): number;
+    getChart(): Chart | null;
+    setTitle(title: string): void;
+    openMainChartIndicator(indicatorType: MainChartIndicatorType, params?: Record<string, any>): void;
+    closeMainChartIndicator(indicatorType: MainChartIndicatorType): void;
+    closeAllMainChartIndicators(): void;
+    openSubChartIndicator(indicatorType: SubChartIndicatorType, onOpenModal?: (type: SubChartIndicatorType) => void, onClose?: (type: SubChartIndicatorType) => void): void;
+    closeSubChartIndicator(indicatorType: SubChartIndicatorType): void;
+    closeAllSubChartIndicators(): void;
+    private syncSubChartIndicatorState;
+    isMainChartIndicatorEnabled(indicatorType: MainChartIndicatorType): boolean;
+    isSubChartIndicatorEnabled(indicatorType: SubChartIndicatorType): boolean;
+    getEnabledMainChartIndicators(): MainChartIndicatorType[];
+    getEnabledSubChartIndicators(): SubChartIndicatorType[];
+    captureScreenshot(watermark?: string, watermarkOpacity?: number): Promise<string>;
+    destroy(): void;
+}
+
+declare class CandleViewChart {
+    private chart;
+    private container;
+    private theme;
+    private i18n;
+    private chartType;
+    private title;
+    constructor(container: HTMLElement, theme: Theme, i18n: I18n, chartType: MainChartType, title: string);
+    init(preprocessedData: DataPreprocessResult): void;
+    getChart(): Chart | null;
+    setData(data: DataPreprocessResult): void;
+    updateChartType(type: MainChartType): void;
+    updateTheme(theme: Theme): void;
+    updateI18n(i18n: I18n): void;
+    destroy(): void;
 }
 
 export declare interface CandleViewConfig {
@@ -902,7 +922,7 @@ export declare interface CandleViewConfig {
     parent?: HTMLElement;
     parentSelector?: string;
     id?: string;
-    title?: string;
+    title: string;
     data?: ICandleViewDataPoint[];
     theme?: 'light' | 'dark';
     locale?: 'en' | 'zh-cn';
@@ -910,23 +930,99 @@ export declare interface CandleViewConfig {
     showLeftPanel?: boolean;
     chartType?: MainChartType;
     activeTimeframe?: TimeframeEnum;
-    currentTimezone?: string;
+    currentTimezone?: TimezoneEnum;
     onToolSelect?: (tool: string) => void;
-    onTimeframeChange?: (timeframe: string) => void;
+    onTimeframeChange?: (timeframe: TimeframeEnum) => void;
     onChartTypeChange?: (type: MainChartType) => void;
     onMainChartIndicatorSelect?: (indicator: MainChartIndicatorInfo) => void;
     onSubChartIndicatorSelect?: (indicators: SubChartIndicatorType[]) => void;
     onThemeToggle?: (theme: string) => void;
     onCameraClick?: () => void;
     onFullscreenClick?: () => void;
-    onTimezoneSelect?: (timezone: string) => void;
+    onTimezoneSelect?: (timezone: TimezoneEnum) => void;
+    onTimeframeChangeCallback?: (candleView: CandleView, timeframe: TimeframeEnum) => void;
+}
+
+declare class CandleViewMark {
+    private chartManager;
+    private staticMarkManager;
+    private storedMarks;
+    private timezone;
+    constructor(chartManager: CandleViewChart);
+    setTimezone(timezone: TimezoneEnum): void;
+    private initStaticMarkManager;
+    private ensureManager;
+    reapplyMarks(): void;
+    getStoredMarks(): IStaticMarkItem[];
+    private convertToChartTime;
+    addStaticMark(time: number, text: string, direction: StaticMarkDirection, type: StaticMarkType, options?: IStaticMarkOptions): void;
+    addStaticMarks(marks: IStaticMarkItem[], shouldStore?: boolean): void;
+    addTextMark(time: number, text: string, direction: StaticMarkDirection, options?: IStaticMarkOptions): void;
+    addArrowMark(time: number, direction: StaticMarkDirection, options?: IStaticMarkOptions & {
+        label?: string;
+    }): void;
+    addTextMarks(marks: Array<{
+        time: number;
+        text: string;
+        direction: StaticMarkDirection;
+        options?: IStaticMarkOptions;
+    }>): void;
+    addArrowMarks(marks: Array<{
+        time: number;
+        direction: StaticMarkDirection;
+        options?: IStaticMarkOptions & {
+            label?: string;
+        };
+    }>): void;
+    clearAllStaticMarks(): void;
+    getStaticMarkCount(): number;
+    refreshMarks(): void;
+    destroy(): void;
+}
+
+declare class ChannelMarkersManager implements MarkManagerModule {
+    parallelChannelMarkManager: ParallelChannelMarkManager | null;
+    linearRegressionChannelMarkManager: LinearRegressionChannelMarkManager | null;
+    equidistantChannelMarkManager: EquidistantChannelMarkManager | null;
+    disjointChannelMarkManager: DisjointChannelMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setParallelChannelMarkMode(chart: Chart): any;
+    setLinearRegressionChannelMode(chart: Chart): any;
+    setEquidistantChannelMarkMode(chart: Chart): any;
+    setDisjointChannelMarkMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
 }
 
 declare class Chart {
-    private container;
+    container: HTMLElement;
     originalData: ICandleViewDataPoint[];
     preprocessedData: DataPreprocessResult | null;
     private theme;
+    private title;
     currentTheme: ThemeConfig;
     private chartType;
     private resizeObserver;
@@ -936,72 +1032,80 @@ declare class Chart {
     containerRef: {
         current: HTMLDivElement | null;
     };
-    drawingManager: DrawingManager | null;
-    chartMarkManager: ChartMarkManager | null;
-    currentDrawingType: DrawingType | null;
     onCloseDrawing?: () => void;
     private chartInfo;
     private chartInfoContainer;
-    currentMarkSettingsStyle: IMarkStyle | null;
     private currentOHLC;
     private mousePosition;
     private showOHLC;
-    private indicators;
-    private visibleIndicatorTypes;
-    private maIndicatorValues;
-    private emaIndicatorValues;
-    private bollingerBandsValues;
-    private ichimokuValues;
-    private donchianChannelValues;
-    private envelopeValues;
-    private vwapValue;
     private originalChartOptions;
-    textMarkToolBar: TextMarkToolBar | null;
-    graphMarkToolBar: GraphMarkToolBar | null;
-    chartPanesManager: ChartPanesManager | null;
     private i18n;
-    mainChartTechnicalIndicatorManager: MainChartTechnicalIndicatorManager | null;
     private chartEventManager;
+    private marketProfile;
+    private volumeHeatMap;
+    mainChartManager: MainChartManager | null;
+    private indicatorUpdateTimer;
+    private panesUpdateTimer;
+    private marketProfileUpdateTimer;
+    private heatMapUpdateTimer;
+    indicatorsManager: ChartIndicatorsManager;
+    modalsManager: ChartModalsManager;
+    tools: ChartTools;
+    get drawingManager(): DrawingManager | null;
+    get chartMarkManager(): ChartMarkManager | null;
+    get currentDrawingType(): DrawingType | null;
+    set currentDrawingType(v: DrawingType | null);
+    get textMarkToolBar(): TextMarkToolBar | null;
+    get graphMarkToolBar(): GraphMarkToolBar | null;
+    get currentMarkSettingsStyle(): IMarkStyle | null;
+    set currentMarkSettingsStyle(v: IMarkStyle | null);
+    get chartPanesManager(): ChartPanesManager | null;
+    get leftPanel(): LeftPanel | null;
+    set leftPanel(v: LeftPanel | null);
+    get onExitBrushMode(): (() => void) | undefined;
+    set onExitBrushMode(v: (() => void) | undefined);
+    get indicators(): MainChartIndicatorInfo[];
+    get visibleIndicatorTypes(): MainChartIndicatorType[];
+    get mainChartTechnicalIndicatorManager(): MainChartTechnicalIndicatorManager | null;
+    get maIndicatorValues(): {
+        [key: string]: number;
+    };
+    get emaIndicatorValues(): {
+        [key: string]: number;
+    };
+    get bollingerBandsValues(): {
+        [key: string]: number;
+    };
+    get ichimokuValues(): {
+        [key: string]: number;
+    };
+    get donchianChannelValues(): {
+        [key: string]: number;
+    };
+    get envelopeValues(): {
+        [key: string]: number;
+    };
+    get vwapValue(): number | null;
+    get imageUploadModal(): ImageUploadModal | null;
+    get mainChartIndicatorsModal(): MainChartIndicatorsSettingModal | null;
+    get subChartIndicatorsModal(): SubChartIndicatorsSettingModal | null;
+    get textMarkEditorModal(): TextMarkEditorModal | null;
+    get currentSubChartType(): SubChartIndicatorType | null;
+    set currentSubChartType(v: SubChartIndicatorType | null);
     private onToggleOHLCCallback?;
     private onOpenIndicatorsModalCallback?;
     private onRemoveIndicatorCallback?;
     private onToggleIndicatorCallback?;
     private onEditIndicatorParamsCallback?;
     private onOpenIndicatorSettingsCallback?;
-    private isDraggingToolbar;
-    private toolbarDragStartPoint;
-    private toolbarDragStartPosition;
-    private imageUploadModal;
-    private mainChartIndicatorsModal;
-    private subChartIndicatorsModal;
-    private textMarkEditorModal;
-    private isImageUploadModalOpen;
-    private isMainChartIndicatorsModalOpen;
-    private isSubChartIndicatorsModalOpen;
-    private isTextMarkEditorModalOpen;
-    private onImageConfirmCallback?;
-    private onMainChartIndicatorConfirmCallback?;
-    private onSubChartIndicatorConfirmCallback?;
-    private onTextMarkEditorSaveCallback?;
-    private onTextMarkEditorCancelCallback?;
-    private marketProfile;
-    private volumeHeatMap;
-    mainChartManager: MainChartManager | null;
-    private pendingImageUrl;
-    private editingIndicator;
-    private editingSubChartParams;
-    currentSubChartType: SubChartIndicatorType | null;
-    private textMarkEditorPosition;
-    private textMarkEditorData;
-    onExitBrushMode?: () => void;
-    leftPanel: LeftPanel | null;
     constructor(options: {
         container: HTMLElement;
         data: ICandleViewDataPoint[];
         theme: Theme;
         chartType: MainChartType;
-        preprocessedData?: DataPreprocessResult;
+        preprocessedData: DataPreprocessResult;
         i18n: I18n;
+        title: string;
         onReady?: () => void;
         onCloseDrawing?: () => void;
         onToggleOHLC?: () => void;
@@ -1022,7 +1126,6 @@ declare class Chart {
     hideMarketProfile(): void;
     showHeatMap(): void;
     hideHeatMap(): void;
-    private initMainChartTechnicalIndicatorManager;
     private initPanesManager;
     private initEventManager;
     private setupContainerEvents;
@@ -1042,22 +1145,18 @@ declare class Chart {
     getI18n(): I18n;
     openImageUploadModal(): void;
     closeImageUploadModal(): void;
-    private updateImageUploadModal;
     openMainChartIndicatorsModal(indicator?: MainChartIndicatorInfo | null): void;
     closeMainChartIndicatorsModal(): void;
-    private updateMainChartIndicatorsModal;
     openSubChartIndicatorsModal(params: IIndicatorInfo[], indicatorType: SubChartIndicatorType): void;
     closeSubChartIndicatorsModal(): void;
-    private updateSubChartIndicatorsModal;
     openTextMarkEditorModal(position: {
         x: number;
         y: number;
     }, text: string, color: string, fontSize: number, isBold: boolean, isItalic: boolean): void;
     closeTextMarkEditorModal(): void;
-    private updateTextMarkEditorModal;
     updateModalsTheme(): void;
     updateModalsI18n(i18n: I18n): void;
-    private updateChartInfoData;
+    updateChartInfoData(): void;
     setTitle(title: string): void;
     setIndicators(indicators: MainChartIndicatorInfo[], visibleTypes: MainChartIndicatorType[]): void;
     setIndicatorValues(values: {
@@ -1093,18 +1192,14 @@ declare class Chart {
     private createHiddenBaseSeries;
     addOrUpdateMainChartIndicator(indicator: MainChartIndicatorInfo): void;
     removeMainChartIndicator(type: MainChartIndicatorType): void;
+    toggleIndicatorVisibility(type: MainChartIndicatorType): void;
+    updateIndicatorParams(indicatorId: string, newParams: MainChartIndicatorParam[]): void;
     getMainChartIndicators(): MainChartIndicatorInfo[];
     getVisibleIndicatorTypes(): MainChartIndicatorType[];
-    updateIndicatorParams(indicatorId: string, newParams: MainChartIndicatorParam[]): void;
-    toggleIndicatorVisibility(type: MainChartIndicatorType): void;
     private setupResizeObserver;
     handleResize(): void;
     getChart(): IChartApi | null;
-    private indicatorUpdateTimer;
-    private panesUpdateTimer;
-    private marketProfileUpdateTimer;
-    private heatMapUpdateTimer;
-    setData(preprocessedData?: DataPreprocessResult): void;
+    setData(preprocessedData: DataPreprocessResult): void;
     updateChartType(type: MainChartType): void;
     getCurrentTheme(): ThemeConfig;
     setTheme(themeType: 'light' | 'dark'): void;
@@ -1186,7 +1281,6 @@ declare class Chart {
     closeTextMarkToolBar(): void;
     closeGraphMarkToolBar(): void;
     closeTableMarkToolBar(): void;
-    private movementDisableCount;
     disableChartMovement(): void;
     enableChartMovement(): void;
     handleViewportShiftLeft(): void;
@@ -1195,152 +1289,292 @@ declare class Chart {
     handleZoomOut(): void;
     addSubChart(indicatorType: SubChartIndicatorType, onSettingsClick: (type: SubChartIndicatorType) => void, onCloseClick: (type: SubChartIndicatorType) => void): void;
     removeSubChart(indicatorType: SubChartIndicatorType): void;
+    getEnabledMainChartIndicators(): MainChartIndicatorType[];
+    getEnabledSubChartIndicators(): SubChartIndicatorType[];
+    isMainChartIndicatorEnabled(indicatorType: MainChartIndicatorType): boolean;
+    isSubChartIndicatorEnabled(indicatorType: SubChartIndicatorType): boolean;
     private cleanupEvents;
     destroy(): void;
 }
 
+declare class ChartIndicatorsManager {
+    private chart;
+    indicators: MainChartIndicatorInfo[];
+    visibleIndicatorTypes: MainChartIndicatorType[];
+    mainChartTechnicalIndicatorManager: MainChartTechnicalIndicatorManager | null;
+    maIndicatorValues: {
+        [key: string]: number;
+    };
+    emaIndicatorValues: {
+        [key: string]: number;
+    };
+    bollingerBandsValues: {
+        [key: string]: number;
+    };
+    ichimokuValues: {
+        [key: string]: number;
+    };
+    donchianChannelValues: {
+        [key: string]: number;
+    };
+    envelopeValues: {
+        [key: string]: number;
+    };
+    vwapValue: number | null;
+    constructor(chart: Chart);
+    init(currentTheme: ThemeConfig): void;
+    addOrUpdateIndicator(indicator: MainChartIndicatorInfo): void;
+    removeIndicator(type: MainChartIndicatorType): void;
+    toggleVisibility(type: MainChartIndicatorType): void;
+    updateParams(indicatorId: string, newParams: MainChartIndicatorParam[]): void;
+    updateAllIndicatorsData(displayData: any[]): void;
+    setIndicatorValues(values: {
+        ma?: {
+            [key: string]: number;
+        };
+        ema?: {
+            [key: string]: number;
+        };
+        bollinger?: {
+            [key: string]: number;
+        };
+        ichimoku?: {
+            [key: string]: number;
+        };
+        donchian?: {
+            [key: string]: number;
+        };
+        envelope?: {
+            [key: string]: number;
+        };
+        vwap?: number | null;
+    }): void;
+    private updateVisibleTypes;
+    getIndicators(): MainChartIndicatorInfo[];
+    getVisibleTypes(): MainChartIndicatorType[];
+    updateTheme(theme: ThemeConfig): void;
+    destroy(): void;
+    getEnabledIndicators(): MainChartIndicatorType[];
+    isIndicatorEnabled(indicatorType: MainChartIndicatorType): boolean;
+}
+
 declare class ChartMarkManager {
-    lineSegmentMarkManager: LineSegmentMarkManager | null;
-    axisLineMarkManager: AxisLineMarkManager | null;
-    arrowLineMarkManager: ArrowLineMarkManager | null;
-    parallelChannelMarkManager: ParallelChannelMarkManager | null;
-    currentOperationDrawingType: DrawingType | null;
-    linearRegressionChannelMarkManager: LinearRegressionChannelMarkManager | null;
-    equidistantChannelMarkManager: EquidistantChannelMarkManager | null;
-    disjointChannelMarkManager: DisjointChannelMarkManager | null;
-    andrewPitchforkMarkManager: AndrewPitchforkMarkManager | null;
-    enhancedAndrewPitchforkMarkManager: EnhancedAndrewPitchforkMarkManager | null;
-    rectangleMarkManager: RectangleMarkManager | null;
-    circleMarkManager: CircleMarkManager | null;
-    ellipseMarkManager: EllipseMarkManager | null;
-    triangleMarkManager: TriangleMarkManager | null;
-    gannFanMarkManager: GannFanMarkManager | null;
-    gannBoxMarkManager: GannBoxMarkManager | null;
-    gannRectangleMarkManager: GannRectangleMarkManager | null;
-    fibonacciTimeZoonMarkManager: FibonacciTimeZoonMarkManager | null;
-    fibonacciRetracementMarkManager: FibonacciRetracementMarkManager | null;
-    fibonacciArcMarkManager: FibonacciArcMarkManager | null;
-    fibonacciCircleMarkManager: FibonacciCircleMarkManager | null;
-    fibonacciSpiralMarkManager: FibonacciSpiralMarkManager | null;
-    fibonacciWedgeMarkManager: FibonacciWedgeMarkManager | null;
-    fibonacciFanMarkManager: FibonacciFanMarkManager | null;
-    fibonacciChannelMarkManager: FibonacciChannelMarkManager | null;
-    fibonacciExtensionBasePriceMarkManager: FibonacciExtensionBasePriceMarkManager | null;
-    fibonacciExtensionBaseTimeMarkManager: FibonacciExtensionBaseTimeMarkManager | null;
-    sectorMarkManager: SectorMarkManager | null;
-    curveMarkManager: CurveMarkManager | null;
-    doubleCurveMarkManager: DoubleCurveMarkManager | null;
-    xabcdMarkManager: XABCDMarkManager | null;
-    headAndShouldersMarkManager: HeadAndShouldersMarkManager | null;
-    abcdMarkManager: ABCDMarkManager | null;
-    triangleABCDMarkManager: TriangleABCDMarkManager | null;
-    elliottImpulseMarkManager: ElliottImpulseMarkManager | null;
-    elliottCorrectiveMarkManager: ElliottCorrectiveMarkManager | null;
-    elliottTriangleMarkManager: ElliottTriangleMarkManager | null;
-    elliottDoubleCombinationMarkManager: ElliottDoubleCombinationMarkManager | null;
-    elliottTripleCombinationMarkManager: ElliottTripleCombinationMarkManager | null;
-    timeRangeMarkManager: TimeRangeMarkManager | null;
-    priceRangeMarkManager: PriceRangeMarkManager | null;
-    timePriceRangeMarkManager: TimePriceRangeMarkManager | null;
-    pencilMarkManager: PencilMarkManager | null;
-    penMarkManager: PenMarkManager | null;
-    brushMarkManager: BrushMarkManager | null;
-    markerPenMarkManager: MarkerPenMarkManager | null;
-    eraserMarkManager: EraserMarkManager | null;
-    thickArrowLineMarkManager: ThickArrowLineMarkManager | null;
-    imageMarkManager: ImageMarkManager | null;
-    longPositionMarkManager: LongPositionMarkManager | null;
-    shortPositionMarkManager: ShortPositionMarkManager | null;
-    priceLabelMarkManager: PriceLabelMarkManager | null;
-    flagMarkManager: FlagMarkManager | null;
-    priceNoteMarkManager: PriceNoteMarkManager | null;
-    signpostMarkManager: SignPostMarkManager | null;
-    emojiMarkManager: EmojiMarkManager | null;
-    pinMarkManager: PinMarkManager | null;
-    bubbleBoxMarkManager: BubbleBoxMarkManager | null;
-    textEditMarkManager: TextEditMarkManager | null;
-    mockKLineMarkManager: MockKLineMarkManager | null;
-    heatMapMarkManager: HeatMapMarkManager | null;
-    schiffPitchforkMarkManager: SchiffPitchforkMarkManager | null;
-    timeEventMarkManager: TimeEventMarkManager | null;
-    priceEventMarkManager: PriceEventMarkManager | null;
+    lineMarkers: LineMarkersManager;
+    channelMarkers: ChannelMarkersManager;
+    forkMarkers: ForkMarkersManager;
+    shapeMarkers: ShapeMarkersManager;
+    gannMarkers: GannMarkersManager;
+    fibonacciMarkers: FibonacciMarkersManager;
+    patternMarkers: PatternMarkersManager;
+    elliottMarkers: ElliottMarkersManager;
+    rangeMarkers: RangeMarkersManager;
+    penMarkers: PenMarkersManager;
+    textMarkers: TextMarkersManager;
+    contentMarkers: ContentMarkersManager;
+    scriptMarkers: ScriptMarkersManager;
+    specialMarkers: SpecialMarkersManager;
+    get lineSegmentMarkManager(): LineSegmentMarkManager | null;
+    get axisLineMarkManager(): AxisLineMarkManager | null;
+    get arrowLineMarkManager(): ArrowLineMarkManager | null;
+    get thickArrowLineMarkManager(): ThickArrowLineMarkManager | null;
+    get parallelChannelMarkManager(): ParallelChannelMarkManager | null;
+    get linearRegressionChannelMarkManager(): LinearRegressionChannelMarkManager | null;
+    get equidistantChannelMarkManager(): EquidistantChannelMarkManager | null;
+    get disjointChannelMarkManager(): DisjointChannelMarkManager | null;
+    get andrewPitchforkMarkManager(): AndrewPitchforkMarkManager | null;
+    get enhancedAndrewPitchforkMarkManager(): EnhancedAndrewPitchforkMarkManager | null;
+    get schiffPitchforkMarkManager(): SchiffPitchforkMarkManager | null;
+    get rectangleMarkManager(): RectangleMarkManager | null;
+    get circleMarkManager(): CircleMarkManager | null;
+    get ellipseMarkManager(): EllipseMarkManager | null;
+    get triangleMarkManager(): TriangleMarkManager | null;
+    get sectorMarkManager(): SectorMarkManager | null;
+    get curveMarkManager(): CurveMarkManager | null;
+    get doubleCurveMarkManager(): DoubleCurveMarkManager | null;
+    get gannFanMarkManager(): GannFanMarkManager | null;
+    get gannBoxMarkManager(): GannBoxMarkManager | null;
+    get gannRectangleMarkManager(): GannRectangleMarkManager | null;
+    get fibonacciTimeZoonMarkManager(): FibonacciTimeZoonMarkManager | null;
+    get fibonacciRetracementMarkManager(): FibonacciRetracementMarkManager | null;
+    get fibonacciArcMarkManager(): FibonacciArcMarkManager | null;
+    get fibonacciCircleMarkManager(): FibonacciCircleMarkManager | null;
+    get fibonacciSpiralMarkManager(): FibonacciSpiralMarkManager | null;
+    get fibonacciWedgeMarkManager(): FibonacciWedgeMarkManager | null;
+    get fibonacciFanMarkManager(): FibonacciFanMarkManager | null;
+    get fibonacciChannelMarkManager(): FibonacciChannelMarkManager | null;
+    get fibonacciExtensionBasePriceMarkManager(): FibonacciExtensionBasePriceMarkManager | null;
+    get fibonacciExtensionBaseTimeMarkManager(): FibonacciExtensionBaseTimeMarkManager | null;
+    get xabcdMarkManager(): XABCDMarkManager | null;
+    get headAndShouldersMarkManager(): HeadAndShouldersMarkManager | null;
+    get abcdMarkManager(): ABCDMarkManager | null;
+    get triangleABCDMarkManager(): TriangleABCDMarkManager | null;
+    get elliottImpulseMarkManager(): ElliottImpulseMarkManager | null;
+    get elliottCorrectiveMarkManager(): ElliottCorrectiveMarkManager | null;
+    get elliottTriangleMarkManager(): ElliottTriangleMarkManager | null;
+    get elliottDoubleCombinationMarkManager(): ElliottDoubleCombinationMarkManager | null;
+    get elliottTripleCombinationMarkManager(): ElliottTripleCombinationMarkManager | null;
+    get timeRangeMarkManager(): TimeRangeMarkManager | null;
+    get priceRangeMarkManager(): PriceRangeMarkManager | null;
+    get timePriceRangeMarkManager(): TimePriceRangeMarkManager | null;
+    get longPositionMarkManager(): LongPositionMarkManager | null;
+    get shortPositionMarkManager(): ShortPositionMarkManager | null;
+    get pencilMarkManager(): PencilMarkManager | null;
+    get penMarkManager(): PenMarkManager | null;
+    get brushMarkManager(): BrushMarkManager | null;
+    get markerPenMarkManager(): MarkerPenMarkManager | null;
+    get eraserMarkManager(): EraserMarkManager | null;
+    get priceLabelMarkManager(): PriceLabelMarkManager | null;
+    get flagMarkManager(): FlagMarkManager | null;
+    get priceNoteMarkManager(): PriceNoteMarkManager | null;
+    get signpostMarkManager(): SignPostMarkManager | null;
+    get emojiMarkManager(): EmojiMarkManager | null;
+    get pinMarkManager(): PinMarkManager | null;
+    get bubbleBoxMarkManager(): BubbleBoxMarkManager | null;
+    get textEditMarkManager(): TextEditMarkManager | null;
+    get imageMarkManager(): ImageMarkManager | null;
+    get timeEventMarkManager(): TimeEventMarkManager | null;
+    get priceEventMarkManager(): PriceEventMarkManager | null;
+    get mockKLineMarkManager(): MockKLineMarkManager | null;
+    get heatMapMarkManager(): HeatMapMarkManager | null;
     constructor();
-    initializeEraserMarkManager(chart: Chart): void;
+    initializeMarkManager(chart: Chart): void;
+    initializeMarkManagerProps(chart: Chart): void;
+    destroyMarkManager(): void;
+    clearAllMarkManagerState(): void;
     registerAllDeletableMarks(): void;
-    initializeMarkManager: (chart: Chart) => void;
-    initializeMarkManagerProps: (chart: Chart) => void;
-    destroyMarkManager: () => void;
-    setMockKLineMarkMode: (chart: Chart) => void;
-    setTextEditMarkMode: (chart: Chart) => void;
-    setBubbleBoxMarkMode: (chart: Chart) => void;
-    setPinMarkMode: (chart: Chart) => void;
-    setEmojiMarkMode: (chart: Chart, emoji: string) => void;
-    setSignpostMarkMode: (chart: Chart) => void;
-    setPriceNoteMarkMode: (chart: Chart) => void;
-    setFlagMarkMode: (chart: Chart) => void;
-    setPriceLabelMode: (chart: Chart) => void;
-    setShortPositionMarkMode: (chart: Chart) => void;
-    setLongPositionMarkMode: (chart: Chart) => void;
-    setThickArrowLineMode: (chart: Chart) => void;
-    setEraserMode: (chart: Chart) => void;
-    setMarkerPenMode: (chart: Chart) => void;
-    setBrushMode: (chart: Chart) => void;
-    setPenMode: (chart: Chart) => void;
-    setPencilMode: (chart: Chart) => void;
-    setTimePriceRangeMarkMode: (chart: Chart) => void;
-    setPriceRangeMarkMode: (chart: Chart) => void;
-    setTimeRangeMarkMode: (chart: Chart) => void;
-    setElliottTripleCombinationMode: (chart: Chart) => void;
-    setElliottDoubleCombinationMode: (chart: Chart) => void;
-    setElliottTriangleMode: (chart: Chart) => void;
-    setElliottCorrectiveMode: (chart: Chart) => void;
-    setElliottImpulseMode: (chart: Chart) => void;
-    setTriangleABCDMode: (chart: Chart) => void;
-    setABCDMode: (chart: Chart) => void;
-    setHeadAndShouldersMode: (chart: Chart) => void;
-    setXABCDMode: (chart: Chart) => void;
-    setDoubleCurveMode: (chart: Chart) => void;
-    setCurveMode: (chart: Chart) => void;
-    setSectorMode: (chart: Chart) => void;
-    setFibonacciExtensionBaseTimeMode: (chart: Chart) => void;
-    setFibonacciExtensionBasePriceMode: (chart: Chart) => void;
-    setFibonacciChannelMode: (chart: Chart) => void;
-    setFibonacciFanMode: (chart: Chart) => void;
-    setFibonacciWedgeMode: (chart: Chart) => void;
-    setFibonacciSpiralMode: (chart: Chart) => void;
-    setFibonacciCircleMode: (chart: Chart) => void;
-    setFibonacciArcMode: (chart: Chart) => void;
-    setFibonacciRetracementMode: (chart: Chart) => void;
-    setFibonacciTimeZoonMode: (chart: Chart) => void;
-    setGannRectangleMode: (chart: Chart) => void;
-    setGannBoxMode: (chart: Chart) => void;
-    setGannFanMode: (chart: Chart) => void;
-    setTriangleMarkMode: (chart: Chart) => void;
-    setEllipseMarkMode: (chart: Chart) => void;
-    setCircleMarkMode: (chart: Chart) => void;
-    setRectangleMarkMode: (chart: Chart) => void;
-    setEnhancedAndrewPitchforkMode: (chart: Chart) => void;
-    setAndrewPitchforkMode: (chart: Chart) => void;
-    setDisjointChannelMarkMode: (chart: Chart) => void;
-    setEquidistantChannelMarkMode: (chart: Chart) => void;
-    setLinearRegressionChannelMode: (chart: Chart) => void;
-    setLineSegmentMarkMode: (chart: Chart) => void;
-    setHorizontalLineMode: (chart: Chart) => void;
-    setVerticalLineMode: (chart: Chart) => void;
-    setArrowLineMarkMode: (chart: Chart) => void;
-    setParallelChannelMarkMode: (chart: Chart) => void;
-    clearAllMarkManagerState: () => void;
-    setPriceEventMode: (chart: Chart) => void;
-    setTimeEventMode: (chart: Chart) => void;
-    setSchiffPitchforkMode: (chart: Chart) => void;
-    setHeatMapMode: (chart: Chart) => void;
-    clearAllMarkMode: (chart: Chart) => void;
-    getDrawingStepFromPhase: (phase: "firstPoint" | "secondPoint" | "widthAdjust" | "none") => number;
-    deleteMark: (drawingType: DrawingType, iGraph: IGraph) => void;
-    deleteAllMark: () => void;
+    initializeEraserMarkManager(chart: Chart): void;
+    closeAllBrushTools(chart: Chart): void;
+    getDrawingStepFromPhase(phase: 'firstPoint' | 'secondPoint' | 'widthAdjust' | 'none'): number;
+    deleteMark(drawingType: DrawingType, iGraph: IGraph): void;
+    deleteAllMark(): void;
     showAllMarks(): void;
     hideAllMarks(): void;
-    closeAllBrushTools: (chart: Chart) => void;
+    setLineSegmentMarkMode(chart: Chart): void;
+    setArrowLineMarkMode(chart: Chart): void;
+    setThickArrowLineMode(chart: Chart): void;
+    setHorizontalLineMode(chart: Chart): void;
+    setVerticalLineMode(chart: Chart): void;
+    setParallelChannelMarkMode(chart: Chart): void;
+    setLinearRegressionChannelMode(chart: Chart): void;
+    setEquidistantChannelMarkMode(chart: Chart): void;
+    setDisjointChannelMarkMode(chart: Chart): void;
+    setAndrewPitchforkMode(chart: Chart): void;
+    setEnhancedAndrewPitchforkMode(chart: Chart): void;
+    setSchiffPitchforkMode(chart: Chart): void;
+    setRectangleMarkMode(chart: Chart): void;
+    setCircleMarkMode(chart: Chart): void;
+    setEllipseMarkMode(chart: Chart): void;
+    setTriangleMarkMode(chart: Chart): void;
+    setSectorMode(chart: Chart): void;
+    setCurveMode(chart: Chart): void;
+    setDoubleCurveMode(chart: Chart): void;
+    setGannFanMode(chart: Chart): void;
+    setGannBoxMode(chart: Chart): void;
+    setGannRectangleMode(chart: Chart): void;
+    setFibonacciTimeZoonMode(chart: Chart): void;
+    setFibonacciRetracementMode(chart: Chart): void;
+    setFibonacciArcMode(chart: Chart): void;
+    setFibonacciCircleMode(chart: Chart): void;
+    setFibonacciSpiralMode(chart: Chart): void;
+    setFibonacciWedgeMode(chart: Chart): void;
+    setFibonacciFanMode(chart: Chart): void;
+    setFibonacciChannelMode(chart: Chart): void;
+    setFibonacciExtensionBasePriceMode(chart: Chart): void;
+    setFibonacciExtensionBaseTimeMode(chart: Chart): void;
+    setXABCDMode(chart: Chart): void;
+    setHeadAndShouldersMode(chart: Chart): void;
+    setABCDMode(chart: Chart): void;
+    setTriangleABCDMode(chart: Chart): void;
+    setElliottImpulseMode(chart: Chart): void;
+    setElliottCorrectiveMode(chart: Chart): void;
+    setElliottTriangleMode(chart: Chart): void;
+    setElliottDoubleCombinationMode(chart: Chart): void;
+    setElliottTripleCombinationMode(chart: Chart): void;
+    setTimeRangeMarkMode(chart: Chart): void;
+    setPriceRangeMarkMode(chart: Chart): void;
+    setTimePriceRangeMarkMode(chart: Chart): void;
+    setLongPositionMarkMode(chart: Chart): void;
+    setShortPositionMarkMode(chart: Chart): void;
+    setMockKLineMarkMode(chart: Chart): void;
+    setTextEditMarkMode(chart: Chart): void;
+    setBubbleBoxMarkMode(chart: Chart): void;
+    setPinMarkMode(chart: Chart): void;
+    setEmojiMarkMode(chart: Chart, emoji: string): void;
+    setSignpostMarkMode(chart: Chart): void;
+    setPriceNoteMarkMode(chart: Chart): void;
+    setFlagMarkMode(chart: Chart): void;
+    setPriceLabelMode(chart: Chart): void;
+    setImageMarkMode(chart: Chart): void;
+    setHeatMapMode(chart: Chart): void;
+    setPriceEventMode(chart: Chart): void;
+    setTimeEventMode(chart: Chart): void;
+    setPencilMode(chart: Chart): void;
+    setPenMode(chart: Chart): void;
+    setBrushMode(chart: Chart): void;
+    setMarkerPenMode(chart: Chart): void;
+    setEraserMode(chart: Chart): void;
+    clearAllMarkMode: (chart: Chart) => void;
+}
+
+declare class ChartModalsManager {
+    private chart;
+    private container;
+    private currentTheme;
+    private i18n;
+    imageUploadModal: ImageUploadModal | null;
+    mainChartIndicatorsModal: MainChartIndicatorsSettingModal | null;
+    subChartIndicatorsModal: SubChartIndicatorsSettingModal | null;
+    textMarkEditorModal: TextMarkEditorModal | null;
+    isImageUploadModalOpen: boolean;
+    isMainChartIndicatorsModalOpen: boolean;
+    isSubChartIndicatorsModalOpen: boolean;
+    isTextMarkEditorModalOpen: boolean;
+    onImageConfirmCallback?: (imageUrl: string) => void;
+    onMainChartIndicatorConfirmCallback?: (indicator: MainChartIndicatorInfo) => void;
+    onSubChartIndicatorConfirmCallback?: (params: IIndicatorInfo[]) => void;
+    onTextMarkEditorSaveCallback?: (text: string, color: string, fontSize: number, isBold: boolean, isItalic: boolean) => void;
+    onTextMarkEditorCancelCallback?: () => void;
+    editingIndicator: MainChartIndicatorInfo | null;
+    editingSubChartParams: IIndicatorInfo[];
+    currentSubChartType: SubChartIndicatorType | null;
+    pendingImageUrl: string;
+    textMarkEditorPosition: {
+        x: number;
+        y: number;
+    };
+    textMarkEditorData: {
+        text: string;
+        color: string;
+        fontSize: number;
+        isBold: boolean;
+        isItalic: boolean;
+    };
+    constructor(chart: Chart, container: HTMLElement, currentTheme: ThemeConfig, i18n: I18n);
+    setCallbacks(callbacks: {
+        onImageConfirm?: (imageUrl: string) => void;
+        onMainChartIndicatorConfirm?: (indicator: MainChartIndicatorInfo) => void;
+        onSubChartIndicatorConfirm?: (params: IIndicatorInfo[]) => void;
+        onTextMarkEditorSave?: (text: string, color: string, fontSize: number, isBold: boolean, isItalic: boolean) => void;
+        onTextMarkEditorCancel?: () => void;
+    }): void;
+    openImageUploadModal(): void;
+    closeImageUploadModal(): void;
+    private updateImageUploadModal;
+    openMainChartIndicatorsModal(indicator?: MainChartIndicatorInfo | null): void;
+    closeMainChartIndicatorsModal(): void;
+    private updateMainChartIndicatorsModal;
+    openSubChartIndicatorsModal(params: IIndicatorInfo[], indicatorType: SubChartIndicatorType): void;
+    closeSubChartIndicatorsModal(): void;
+    private updateSubChartIndicatorsModal;
+    openTextMarkEditorModal(position: {
+        x: number;
+        y: number;
+    }, text: string, color: string, fontSize: number, isBold: boolean, isItalic: boolean): void;
+    closeTextMarkEditorModal(): void;
+    private updateTextMarkEditorModal;
+    updateTheme(theme: ThemeConfig): void;
+    updateI18n(i18n: I18n): void;
+    destroy(): void;
 }
 
 declare class ChartPanesManager {
@@ -1367,6 +1601,8 @@ declare class ChartPanesManager {
     handleMouseMove(poin: Point): void;
     handleMouseUp(poin: Point): void;
     handleCrosshairMoveEvent(event: MouseEventParams): void;
+    getEnabledSubChartIndicators(): SubChartIndicatorType[];
+    isSubChartIndicatorEnabled(indicatorType: SubChartIndicatorType): boolean;
 }
 
 declare interface ChartSeries {
@@ -1374,6 +1610,115 @@ declare interface ChartSeries {
     type: string;
 }
 
+declare class ChartTools {
+    private chart;
+    drawingManager: DrawingManager | null;
+    chartMarkManager: ChartMarkManager | null;
+    chartPanesManager: ChartPanesManager | null;
+    currentDrawingType: DrawingType | null;
+    textMarkToolBar: TextMarkToolBar | null;
+    graphMarkToolBar: GraphMarkToolBar | null;
+    currentMarkSettingsStyle: IMarkStyle | null;
+    leftPanel: LeftPanel | null;
+    onCloseDrawing?: () => void;
+    onExitBrushMode?: () => void;
+    isDraggingToolbar: boolean;
+    toolbarDragStartPoint: Point | null;
+    toolbarDragStartPosition: Point | null;
+    private movementDisableCount;
+    private originalChartOptions;
+    constructor(chart: Chart);
+    initDrawingManager(): void;
+    initPanesManager(): void;
+    addSubChart(indicatorType: SubChartIndicatorType, onSettingsClick: (type: SubChartIndicatorType) => void, onCloseClick: (type: SubChartIndicatorType) => void): void;
+    removeSubChart(indicatorType: SubChartIndicatorType): void;
+    getDrawingState(): DrawingManagerState | null;
+    setCursorType(cursorType: CursorType): void;
+    setLineSegmentMarkMode(): void;
+    setArrowLineMarkMode(): void;
+    setThickArrowLineMode(): void;
+    setHorizontalLineMode(): void;
+    setVerticalLineMode(): void;
+    setParallelChannelMarkMode(): void;
+    setLinearRegressionChannelMode(): void;
+    setEquidistantChannelMarkMode(): void;
+    setDisjointChannelMarkMode(): void;
+    setAndrewPitchforkMode(): void;
+    setEnhancedAndrewPitchforkMode(): void;
+    setSchiffPitchforkMode(): void;
+    setRectangleMarkMode(): void;
+    setCircleMarkMode(): void;
+    setEllipseMarkMode(): void;
+    setTriangleMarkMode(): void;
+    setSectorMode(): void;
+    setCurveMode(): void;
+    setDoubleCurveMode(): void;
+    setGannFanMode(): void;
+    setGannBoxMode(): void;
+    setGannRectangleMode(): void;
+    setFibonacciTimeZoonMode(): void;
+    setFibonacciRetracementMode(): void;
+    setFibonacciArcMode(): void;
+    setFibonacciCircleMode(): void;
+    setFibonacciSpiralMode(): void;
+    setFibonacciWedgeMode(): void;
+    setFibonacciFanMode(): void;
+    setFibonacciChannelMode(): void;
+    setFibonacciExtensionBasePriceMode(): void;
+    setFibonacciExtensionBaseTimeMode(): void;
+    setXABCDMode(): void;
+    setHeadAndShouldersMode(): void;
+    setABCDMode(): void;
+    setTriangleABCDMode(): void;
+    setElliottImpulseMode(): void;
+    setElliottCorrectiveMode(): void;
+    setElliottTriangleMode(): void;
+    setElliottDoubleCombinationMode(): void;
+    setElliottTripleCombinationMode(): void;
+    setTimeRangeMarkMode(): void;
+    setPriceRangeMarkMode(): void;
+    setTimePriceRangeMarkMode(): void;
+    setHeatMapMode(): void;
+    setLongPositionMarkMode(): void;
+    setShortPositionMarkMode(): void;
+    setMockKLineMarkMode(): void;
+    setPencilMode(): void;
+    setPenMode(): void;
+    setBrushMode(): void;
+    setMarkerPenMode(): void;
+    setEraserMode(): void;
+    setTextEditMarkMode(): void;
+    setPriceNoteMarkMode(): void;
+    setBubbleBoxMarkMode(): void;
+    setPinMarkMode(): void;
+    setSignpostMarkMode(): void;
+    setPriceLabelMode(): void;
+    setFlagMarkMode(): void;
+    setImageMarkMode(): void;
+    setEmojiMarkMode(emoji: string): void;
+    setPriceEventMode(): void;
+    setTimeEventMode(): void;
+    showAllMark(): void;
+    hideAllMark(): void;
+    clearAllMark(): void;
+    showTableMarkToolBar(drawing: MarkDrawing): void;
+    showTextEditMarkToolBar(drawing: MarkDrawing, isShowGrapTool: boolean): void;
+    showGraphMarkToolBar(drawing: MarkDrawing): void;
+    private setupToolbarDrag;
+    closeTextMarkToolBar(): void;
+    closeGraphMarkToolBar(): void;
+    closeTableMarkToolBar(): void;
+    disableChartMovement(): void;
+    enableChartMovement(): void;
+    handleViewportShiftLeft(): void;
+    handleViewportShiftRight(): void;
+    handleZoomIn(): void;
+    handleZoomOut(): void;
+    updateTheme(theme: ThemeConfig): void;
+    updateI18n(i18n: I18n): void;
+    destroy(): void;
+}
+
 export declare enum ChartType {
     MainChart = "MainChart",
     SubChart = "SubChart"
@@ -1507,6 +1852,37 @@ declare interface CircleMarkState {
     isDrawing: boolean;
 }
 
+declare class ContentMarkersManager implements MarkManagerModule {
+    imageMarkManager: ImageMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setImageMarkMode(chart: Chart): void;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 export declare enum CursorType {
     Default = "default",
     Crosshair = "crosshair",
@@ -2024,6 +2400,8 @@ declare class DrawingManager {
     startToolbarDrag(startPoint: Point, type: 'text' | 'graph'): void;
     updateToolbarPosition(deltaX: number, deltaY: number): void;
     endToolbarDrag(type: 'text' | 'graph'): void;
+    updateTheme(theme: ThemeConfig): void;
+    updateI18n(i18n: I18n): void;
     destroy(): void;
 }
 
@@ -2693,6 +3071,45 @@ declare interface ElliottImpulseMarkState {
     dragPoint: number | null;
 }
 
+declare class ElliottMarkersManager implements MarkManagerModule {
+    elliottImpulseMarkManager: ElliottImpulseMarkManager | null;
+    elliottCorrectiveMarkManager: ElliottCorrectiveMarkManager | null;
+    elliottTriangleMarkManager: ElliottTriangleMarkManager | null;
+    elliottDoubleCombinationMarkManager: ElliottDoubleCombinationMarkManager | null;
+    elliottTripleCombinationMarkManager: ElliottTripleCombinationMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setElliottImpulseMode(chart: Chart): any;
+    setElliottCorrectiveMode(chart: Chart): any;
+    setElliottTriangleMode(chart: Chart): any;
+    setElliottDoubleCombinationMode(chart: Chart): any;
+    setElliottTripleCombinationMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class ElliottTriangleMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -4328,6 +4745,55 @@ declare interface FibonacciFanMarkState {
     isDrawing: boolean;
 }
 
+declare class FibonacciMarkersManager implements MarkManagerModule {
+    fibonacciTimeZoonMarkManager: FibonacciTimeZoonMarkManager | null;
+    fibonacciRetracementMarkManager: FibonacciRetracementMarkManager | null;
+    fibonacciArcMarkManager: FibonacciArcMarkManager | null;
+    fibonacciCircleMarkManager: FibonacciCircleMarkManager | null;
+    fibonacciSpiralMarkManager: FibonacciSpiralMarkManager | null;
+    fibonacciWedgeMarkManager: FibonacciWedgeMarkManager | null;
+    fibonacciFanMarkManager: FibonacciFanMarkManager | null;
+    fibonacciChannelMarkManager: FibonacciChannelMarkManager | null;
+    fibonacciExtensionBasePriceMarkManager: FibonacciExtensionBasePriceMarkManager | null;
+    fibonacciExtensionBaseTimeMarkManager: FibonacciExtensionBaseTimeMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setFibonacciTimeZoonMode(chart: Chart): any;
+    setFibonacciRetracementMode(chart: Chart): any;
+    setFibonacciArcMode(chart: Chart): any;
+    setFibonacciCircleMode(chart: Chart): any;
+    setFibonacciSpiralMode(chart: Chart): any;
+    setFibonacciWedgeMode(chart: Chart): any;
+    setFibonacciFanMode(chart: Chart): any;
+    setFibonacciChannelMode(chart: Chart): any;
+    setFibonacciExtensionBasePriceMode(chart: Chart): any;
+    setFibonacciExtensionBaseTimeMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class FibonacciRetracementMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -4987,6 +5453,41 @@ declare interface FlagMarkState {
     dragTarget: FlagMark | null;
 }
 
+declare class ForkMarkersManager implements MarkManagerModule {
+    andrewPitchforkMarkManager: AndrewPitchforkMarkManager | null;
+    enhancedAndrewPitchforkMarkManager: EnhancedAndrewPitchforkMarkManager | null;
+    schiffPitchforkMarkManager: SchiffPitchforkMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setAndrewPitchforkMode(chart: Chart): any;
+    setEnhancedAndrewPitchforkMode(chart: Chart): any;
+    setSchiffPitchforkMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class GannBoxMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -5277,6 +5778,41 @@ declare interface GannFanMarkState {
     isDrawing: boolean;
 }
 
+declare class GannMarkersManager implements MarkManagerModule {
+    gannFanMarkManager: GannFanMarkManager | null;
+    gannBoxMarkManager: GannBoxMarkManager | null;
+    gannRectangleMarkManager: GannRectangleMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setGannFanMode(chart: Chart): any;
+    setGannBoxMode(chart: Chart): any;
+    setGannRectangleMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class GannRectangleMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -5458,9 +5994,12 @@ declare class GraphMarkToolBar {
     private createColorPanel;
     private createLineSizePanel;
     private createLineStylePanel;
+    private adjustPanelPosition;
     private bindEvents;
     private bindPanelEvents;
     updatePosition(position: Point): void;
+    updateTheme(theme: ThemeConfig): void;
+    updateI18n(i18n: I18n): void;
     destroy(): void;
 }
 
@@ -6468,6 +7007,51 @@ declare interface ImageMarkState {
     selectedImageUrl: string;
 }
 
+declare class ImageUploadModal {
+    private container;
+    private options;
+    private imageUrl;
+    private modalPosition;
+    private isDragging;
+    private dragOffset;
+    private fileInput;
+    private modalRef;
+    private headerRef;
+    private boundHandleMouseMove;
+    private boundHandleMouseUp;
+    constructor(options: ImageUploadModalOptions);
+    private calculateInitialPosition;
+    private handleFileSelect;
+    private handleUrlChange;
+    private handleConfirm;
+    private handleFileButtonClick;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleOverlayClick;
+    private handleKeyPress;
+    private updatePreview;
+    private updateModalPosition;
+    private getMaxModalHeight;
+    private adjustModalPosition;
+    private getStyles;
+    private applyStyles;
+    private createElement;
+    private injectScrollbarStyles;
+    private render;
+    update(options: Partial<ImageUploadModalOptions>): void;
+    destroy(): void;
+}
+
+declare interface ImageUploadModalOptions {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (imageUrl: string) => void;
+    theme: ThemeConfig;
+    i18n: I18n;
+    parentRef?: HTMLElement | null;
+}
+
 declare interface IMarkManager<T = any> {
     getCurrentDragTarget(): T | null;
     getCurrentDragPoint(): string | null;
@@ -6572,6 +7156,7 @@ declare class LeftPanel {
     destroy(): void;
     updateState(updates: Partial<LeftPanelState>): void;
     isMarkLocked(): boolean;
+    private getContainerRect;
     getState(): LeftPanelState;
 }
 
@@ -6759,6 +7344,44 @@ declare interface LinearRegressionChannelMarkState {
     } | null;
 }
 
+declare class LineMarkersManager implements MarkManagerModule {
+    lineSegmentMarkManager: LineSegmentMarkManager | null;
+    axisLineMarkManager: AxisLineMarkManager | null;
+    arrowLineMarkManager: ArrowLineMarkManager | null;
+    thickArrowLineMarkManager: ThickArrowLineMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setLineSegmentMarkMode(chart: Chart): any;
+    setHorizontalLineMode(chart: Chart): any;
+    setVerticalLineMode(chart: Chart): any;
+    setArrowLineMarkMode(chart: Chart): any;
+    setThickArrowLineMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class LineSegmentMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -7024,6 +7647,60 @@ declare interface MainChartIndicatorParam {
     paramValue: number;
 }
 
+declare class MainChartIndicatorsSettingModal {
+    private container;
+    private options;
+    private indicator;
+    private modalPosition;
+    private isDragging;
+    private dragOffset;
+    private modalRef;
+    private headerRef;
+    private boundHandleMouseMove;
+    private boundHandleMouseUp;
+    private paramsListRef;
+    constructor(options: MainChartIndicatorsSettingModalOptions);
+    private getRandomColor;
+    private getDefaultIndicatorByType;
+    private canModifyItems;
+    private addIndicatorParam;
+    private removeIndicatorParam;
+    private updateIndicatorValue;
+    private updateIndicatorColor;
+    private updateIndicatorLineWidth;
+    private shouldShowNumberInput;
+    private handleConfirm;
+    private handleCancel;
+    private getIndicatorTypeName;
+    private getIndicatorItemLabel;
+    private calculatePosition;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleOverlayClick;
+    private handleKeyPress;
+    private updateModalPosition;
+    private renderParamsList;
+    private getStyles;
+    private applyStyles;
+    private createElement;
+    private injectScrollbarStyles;
+    private render;
+    update(options: Partial<MainChartIndicatorsSettingModalOptions>): void;
+    destroy(): void;
+}
+
+declare interface MainChartIndicatorsSettingModalOptions {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (indicator: MainChartIndicatorInfo) => void;
+    initialIndicator?: MainChartIndicatorInfo | null;
+    theme?: ThemeConfig;
+    parentRef?: HTMLElement | null;
+    indicatorType?: MainChartIndicatorType | null;
+    i18n: I18n;
+}
+
 export declare enum MainChartIndicatorType {
     MA = "MA",
     EMA = "EMA",
@@ -7048,6 +7725,7 @@ declare class MainChartManager {
     getCurrentSeries(): any;
     getCurrentType(): MainChartType | null;
     private destroyCurrentChart;
+    updateTheme(theme: ThemeConfig): void;
     destroy(): void;
 }
 
@@ -7243,6 +7921,35 @@ declare interface MarkerPenMarkState {
     dragTarget: MarkerPenMark | null;
 }
 
+declare interface MarkManagerContext {
+    chart: Chart;
+}
+
+declare interface MarkManagerModule {
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+}
+
 declare class MockKLineMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -7492,6 +8199,43 @@ declare interface ParallelChannelMarkState {
     } | null;
 }
 
+declare class PatternMarkersManager implements MarkManagerModule {
+    xabcdMarkManager: XABCDMarkManager | null;
+    headAndShouldersMarkManager: HeadAndShouldersMarkManager | null;
+    abcdMarkManager: ABCDMarkManager | null;
+    triangleABCDMarkManager: TriangleABCDMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setXABCDMode(chart: Chart): any;
+    setHeadAndShouldersMode(chart: Chart): any;
+    setABCDMode(chart: Chart): any;
+    setTriangleABCDMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class PencilMark implements IGraph, IMarkStyle, IDeletableMark {
     private _chart;
     private _series;
@@ -7663,6 +8407,47 @@ declare class PenMark implements IGraph, IMarkStyle, IDeletableMark {
     getPointCount(): number;
 }
 
+declare class PenMarkersManager implements MarkManagerModule {
+    pencilMarkManager: PencilMarkManager | null;
+    penMarkManager: PenMarkManager | null;
+    brushMarkManager: BrushMarkManager | null;
+    markerPenMarkManager: MarkerPenMarkManager | null;
+    eraserMarkManager: EraserMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    registerAllDeletableMarks(): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setPencilMode(chart: Chart): any;
+    setPenMode(chart: Chart): any;
+    setBrushMode(chart: Chart): any;
+    setMarkerPenMode(chart: Chart): any;
+    setEraserMode(chart: Chart): any;
+    closeAllBrushTools(chart: Chart): void;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class PenMarkManager implements IMarkManager<PenMark> {
     private props;
     private state;
@@ -8460,6 +9245,45 @@ declare interface PriceRangeMarkState {
     } | null;
 }
 
+declare class RangeMarkersManager implements MarkManagerModule {
+    timeRangeMarkManager: TimeRangeMarkManager | null;
+    priceRangeMarkManager: PriceRangeMarkManager | null;
+    timePriceRangeMarkManager: TimePriceRangeMarkManager | null;
+    longPositionMarkManager: LongPositionMarkManager | null;
+    shortPositionMarkManager: ShortPositionMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setTimeRangeMarkMode(chart: Chart): any;
+    setPriceRangeMarkMode(chart: Chart): any;
+    setTimePriceRangeMarkMode(chart: Chart): any;
+    setLongPositionMarkMode(chart: Chart): any;
+    setShortPositionMarkMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class RectangleMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -8732,6 +9556,39 @@ declare interface SchiffPitchforkMarkState {
     } | null;
 }
 
+declare class ScriptMarkersManager implements MarkManagerModule {
+    timeEventMarkManager: TimeEventMarkManager | null;
+    priceEventMarkManager: PriceEventMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setPriceEventMode(chart: Chart): any;
+    setTimeEventMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 export declare enum ScriptType {
     Time = "time",
     Price = "price",
@@ -8873,6 +9730,49 @@ declare interface SectorMarkState {
 
 export declare function setLocale(locale: 'en' | 'zh-cn'): void;
 
+declare class ShapeMarkersManager implements MarkManagerModule {
+    rectangleMarkManager: RectangleMarkManager | null;
+    circleMarkManager: CircleMarkManager | null;
+    ellipseMarkManager: EllipseMarkManager | null;
+    triangleMarkManager: TriangleMarkManager | null;
+    sectorMarkManager: SectorMarkManager | null;
+    curveMarkManager: CurveMarkManager | null;
+    doubleCurveMarkManager: DoubleCurveMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setRectangleMarkMode(chart: Chart): any;
+    setCircleMarkMode(chart: Chart): any;
+    setEllipseMarkMode(chart: Chart): any;
+    setTriangleMarkMode(chart: Chart): any;
+    setSectorMode(chart: Chart): any;
+    setCurveMode(chart: Chart): any;
+    setDoubleCurveMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class ShortPositionMark implements IGraph, IMarkStyle {
     private _chart;
     private _series;
@@ -9174,6 +10074,39 @@ declare interface SignPostMarkState {
     dragTarget: SignPostMark | null;
 }
 
+declare class SpecialMarkersManager implements MarkManagerModule {
+    mockKLineMarkManager: MockKLineMarkManager | null;
+    heatMapMarkManager: HeatMapMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setMockKLineMarkMode(chart: Chart): any;
+    setHeatMapMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 export declare enum StaticMarkDirection {
     Top = "Top",
     Bottom = "Bottom"
@@ -9184,6 +10117,58 @@ export declare enum StaticMarkType {
     Arrow = "Arrow"
 }
 
+declare class SubChartIndicatorsSettingModal {
+    private container;
+    private options;
+    private params;
+    private modalPosition;
+    private isDragging;
+    private dragOffset;
+    private modalRef;
+    private headerRef;
+    private boundHandleMouseMove;
+    private boundHandleMouseUp;
+    private paramsListRef;
+    constructor(options: SubChartIndicatorsSettingModalOptions);
+    private getIndicatorTitle;
+    private getRandomColor;
+    private getIndicatorConstraints;
+    private addIndicatorParam;
+    private removeIndicatorParam;
+    private updateIndicatorName;
+    private updateIndicatorValue;
+    private updateIndicatorColor;
+    private updateIndicatorLineWidth;
+    private handleConfirm;
+    private handleCancel;
+    private calculatePosition;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleOverlayClick;
+    private handleKeyPress;
+    private updateModalPosition;
+    private renderParamsList;
+    private getStyles;
+    private applyStyles;
+    private createElement;
+    private injectScrollbarStyles;
+    private render;
+    update(options: Partial<SubChartIndicatorsSettingModalOptions>): void;
+    destroy(): void;
+}
+
+declare interface SubChartIndicatorsSettingModalOptions {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: (params: IIndicatorInfo[]) => void;
+    initialParams: IIndicatorInfo[];
+    theme?: ThemeConfig;
+    parentRef?: HTMLElement | null;
+    indicatorType: SubChartIndicatorType | null;
+    i18n: I18n;
+}
+
 export declare enum SubChartIndicatorType {
     RSI = "RSI",
     MACD = "MACD",
@@ -9365,6 +10350,105 @@ declare interface TextEditMarkState {
     dragType: 'bubble' | null;
 }
 
+declare class TextMarkEditorModal {
+    private container;
+    private options;
+    private text;
+    private color;
+    private fontSize;
+    private isBold;
+    private isItalic;
+    private modalPosition;
+    private isDragging;
+    private dragOffset;
+    private modalRef;
+    private headerRef;
+    private textareaRef;
+    private boundHandleMouseMove;
+    private boundHandleMouseUp;
+    constructor(options: TextMarkEditorModalOptions);
+    private handleSave;
+    private handleCancel;
+    private handleMouseDown;
+    private handleMouseMove;
+    private handleMouseUp;
+    private handleOverlayClick;
+    private handleKeyPress;
+    private updateModalPosition;
+    private getStyles;
+    private applyStyles;
+    private createElement;
+    private getMaxModalHeight;
+    private render;
+    private adjustModalPosition;
+    private injectScrollbarStyles;
+    update(options: Partial<TextMarkEditorModalOptions>): void;
+    destroy(): void;
+}
+
+declare interface TextMarkEditorModalOptions {
+    isOpen: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    parentRef?: HTMLElement | null;
+    theme: ThemeConfig;
+    initialText: string;
+    initialColor: string;
+    initialFontSize: number;
+    initialIsBold: boolean;
+    initialIsItalic: boolean;
+    onSave: (text: string, color: string, fontSize: number, isBold: boolean, isItalic: boolean) => void;
+    onCancel: () => void;
+    i18n: I18n;
+}
+
+declare class TextMarkersManager implements MarkManagerModule {
+    priceLabelMarkManager: PriceLabelMarkManager | null;
+    flagMarkManager: FlagMarkManager | null;
+    priceNoteMarkManager: PriceNoteMarkManager | null;
+    signpostMarkManager: SignPostMarkManager | null;
+    emojiMarkManager: EmojiMarkManager | null;
+    pinMarkManager: PinMarkManager | null;
+    bubbleBoxMarkManager: BubbleBoxMarkManager | null;
+    textEditMarkManager: TextEditMarkManager | null;
+    initialize(context: MarkManagerContext): void;
+    updateProps(context: MarkManagerContext): void;
+    destroy(): void;
+    clearState(): void;
+    isOperatingOnChart(): boolean;
+    getMarkAtPoint(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseDown(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseMove(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleMouseUp(point: {
+        x: number;
+        y: number;
+    }): any;
+    handleKeyDown(event: KeyboardEvent): any;
+    setPriceLabelMode(chart: Chart): any;
+    setFlagMarkMode(chart: Chart): any;
+    setPriceNoteMarkMode(chart: Chart): any;
+    setSignpostMarkMode(chart: Chart): any;
+    setEmojiMarkMode(chart: Chart, emoji: string): any;
+    setPinMarkMode(chart: Chart): any;
+    setBubbleBoxMarkMode(chart: Chart): any;
+    setTextEditMarkMode(chart: Chart): any;
+    deleteMark(drawingType: DrawingType, iGraph: any): void;
+    deleteAllMarks(): void;
+    showAllMarks(): void;
+    hideAllMarks(): void;
+}
+
 declare class TextMarkToolBar {
     container: HTMLElement | null;
     private options;
@@ -9390,6 +10474,7 @@ declare class TextMarkToolBar {
     private getGraphLineStylePanelInnerHTML;
     private createColorPanel;
     private createFontSizePanel;
+    private adjustPanelPosition;
     private createGraphColorPanel;
     private createGraphLineSizePanel;
     private createGraphLineStylePanel;
@@ -9400,6 +10485,8 @@ declare class TextMarkToolBar {
     private updateItalicButton;
     private bindPanelEvents;
     updatePosition(position: Point): void;
+    updateTheme(theme: ThemeConfig): void;
+    updateI18n(i18n: I18n): void;
     destroy(): void;
 }