candleview 1.0.0

package/dist/components/CandleView/MarkManager/StaticMarkManager.d.ts

@@ -0,0 +1,46 @@
+import { ChartSeries } from "../ChartLayer/ChartTypeManager";
+export declare enum StaticMarkDirection {
+    Top = "Top",
+    Bottom = "Bottom"
+}
+export declare enum StaticMarkType {
+    Text = "Text",
+    Arrow = "Arrow"
+}
+export interface IStaticMarkData {
+    time: number;
+    type: string;
+    data: {
+        direction: string;
+        text: string;
+        fontSize?: number;
+        textColor?: string;
+        backgroundColor?: string;
+        isCircular?: boolean;
+        padding?: number;
+    }[];
+}
+export declare class StaticMarkManager {
+    private _marks;
+    private _tolerance;
+    private _timeframe;
+    private _chartSeries;
+    constructor();
+    private autoDetectTimeframe;
+    private median;
+    private calculateTolerance;
+    private findClosestBarTime;
+    private isInSameTimeUnit;
+    private getWeekNumber;
+    addMark(data: IStaticMarkData[], chartSeries: ChartSeries): void;
+    recalculateMarks(): void;
+    refreshTimeframe(): void;
+    private addTopMark;
+    private addBottomMark;
+    removeAllMark(): void;
+    getTolerance(): number;
+    getTimeframe(): string;
+    getMarkCount(): number;
+    clearAllMarks(chartSeries?: ChartSeries): void;
+    destroy(): void;
+}

package/dist/components/CandleView/MarkManager/Text/BubbleBoxMarkManager.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { BubbleBoxMark } from "../../Mark/Text/BubbleBoxMark";
+import { Point } from "../../types";
+export interface BubbleBoxMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface BubbleBoxMarkState {
+    isBubbleBoxMarkMode: boolean;
+    bubbleBoxMarkPoints: Point[] | null;
+    currentBubbleBoxMark: BubbleBoxMark | null;
+    isDragging: boolean;
+    dragTarget: BubbleBoxMark | null;
+    dragType: 'controlPoint' | 'bubble' | 'connection' | null;
+}
+export declare class BubbleBoxMarkManager implements IMarkManager<BubbleBoxMark> {
+    private props;
+    private state;
+    private previewBubbleBoxMark;
+    private bubbleBoxMarks;
+    private dragStartData;
+    private isOperating;
+    private isCreatingNewBubble;
+    private creationStep;
+    constructor(props: BubbleBoxMarkManagerProps);
+    private _addEventListeners;
+    private _removeEventListeners;
+    private _handleBubbleBoxMarkDragStart;
+    clearState(): void;
+    getMarkAtPoint(point: Point): BubbleBoxMark | null;
+    getMarkAtPointWithType(point: Point): {
+        mark: BubbleBoxMark;
+        type: 'controlPoint' | 'bubble' | 'connection';
+    } | null;
+    getCurrentDragTarget(): BubbleBoxMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): BubbleBoxMark | null;
+    getAllMarks(): BubbleBoxMark[];
+    cancelOperationMode(): BubbleBoxMarkState;
+    setBubbleBoxMarkMode: () => BubbleBoxMarkState;
+    cancelBubbleBoxMarkMode: () => BubbleBoxMarkState;
+    handleMouseDown: (point: Point) => BubbleBoxMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => BubbleBoxMarkState;
+    handleKeyDown: (event: KeyboardEvent) => BubbleBoxMarkState;
+    getState(): BubbleBoxMarkState;
+    updateProps(newProps: Partial<BubbleBoxMarkManagerProps>): void;
+    destroy(): void;
+    getBubbleBoxMarks(): BubbleBoxMark[];
+    removeBubbleBoxMark(mark: BubbleBoxMark): void;
+    isOperatingOnChart(): boolean;
+    updateBubbleText(mark: BubbleBoxMark, text: string): void;
+    private hiddenBubbleBoxMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: BubbleBoxMark): void;
+    showMark(mark: BubbleBoxMark): void;
+}

package/dist/components/CandleView/MarkManager/Text/EmojiMarkManager.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { EmojiMark } from "../../Mark/Text/EmojiMark";
+import { Point } from "../../types";
+export interface EmojiMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface EmojiMarkState {
+    isEmojiMarkMode: boolean;
+    emojiMarkStartPoint: Point | null;
+    currentEmojiMark: EmojiMark | null;
+    isDragging: boolean;
+    dragTarget: EmojiMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+    selectedEmoji: string | undefined;
+}
+export declare class EmojiMarkManager implements IMarkManager<EmojiMark> {
+    private props;
+    private state;
+    private previewEmojiMark;
+    private emojiMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: EmojiMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): EmojiMark | null;
+    getCurrentDragTarget(): EmojiMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): EmojiMark | null;
+    getAllMarks(): EmojiMark[];
+    cancelOperationMode(): EmojiMarkState;
+    setEmojiMarkMode: (emoji: string) => EmojiMarkState;
+    cancelEmojiMarkMode: () => EmojiMarkState;
+    handleMouseDown: (point: Point) => EmojiMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => EmojiMarkState;
+    handleKeyDown: (event: KeyboardEvent) => EmojiMarkState;
+    getState(): EmojiMarkState;
+    updateProps(newProps: Partial<EmojiMarkManagerProps>): void;
+    destroy(): void;
+    getEmojiMarks(): EmojiMark[];
+    removeEmojiMark(mark: EmojiMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenEmojiMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: EmojiMark): void;
+    showMark(mark: EmojiMark): void;
+}

package/dist/components/CandleView/MarkManager/Text/FlagMarkManager.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { FlagMark } from "../../Mark/Text/FlagMark";
+import { Point } from "../../types";
+export interface FlagMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FlagMarkState {
+    isFlagMarkMode: boolean;
+    flagMarkPoint: Point | null;
+    currentFlagMark: FlagMark | null;
+    isDragging: boolean;
+    dragTarget: FlagMark | null;
+}
+export declare class FlagMarkManager implements IMarkManager<FlagMark> {
+    private props;
+    private state;
+    private previewFlagMark;
+    private flagMarks;
+    private dragStartData;
+    private isOperating;
+    private isCreatingNewFlag;
+    constructor(props: FlagMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FlagMark | null;
+    getCurrentDragTarget(): FlagMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FlagMark | null;
+    getAllMarks(): FlagMark[];
+    cancelOperationMode(): FlagMarkState;
+    setFlagMarkMode: () => FlagMarkState;
+    cancelFlagMarkMode: () => FlagMarkState;
+    handleMouseDown: (point: Point) => FlagMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => FlagMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FlagMarkState;
+    getState(): FlagMarkState;
+    updateProps(newProps: Partial<FlagMarkManagerProps>): void;
+    destroy(): void;
+    getFlagMarks(): FlagMark[];
+    removeFlagMark(mark: FlagMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenFlagMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FlagMark): void;
+    showMark(mark: FlagMark): void;
+}

package/dist/components/CandleView/MarkManager/Text/PinMarkManager.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { PinMark } from "../../Mark/Text/PinMark";
+import { Point } from "../../types";
+export interface PinMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface PinMarkState {
+    isPinMarkMode: boolean;
+    pinMarkPoint: Point | null;
+    currentPinMark: PinMark | null;
+    isDragging: boolean;
+    dragTarget: PinMark | null;
+}
+export declare class PinMarkManager implements IMarkManager<PinMark> {
+    private props;
+    private state;
+    private previewPinMark;
+    private pinMarks;
+    private dragStartData;
+    private isOperating;
+    private isCreatingNewPin;
+    constructor(props: PinMarkManagerProps);
+    private _addEventListeners;
+    private _removeEventListeners;
+    private _handlePinMarkDragStart;
+    clearState(): void;
+    getMarkAtPoint(point: Point): PinMark | null;
+    getCurrentDragTarget(): PinMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): PinMark | null;
+    getAllMarks(): PinMark[];
+    cancelOperationMode(): PinMarkState;
+    setPinMarkMode: () => PinMarkState;
+    cancelPinMarkMode: () => PinMarkState;
+    handleMouseDown: (point: Point) => PinMarkState;
+    private hideAllBubbles;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => PinMarkState;
+    handleKeyDown: (event: KeyboardEvent) => PinMarkState;
+    getState(): PinMarkState;
+    updateProps(newProps: Partial<PinMarkManagerProps>): void;
+    destroy(): void;
+    getPinMarks(): PinMark[];
+    removePinMark(mark: PinMark): void;
+    isOperatingOnChart(): boolean;
+    updatePinText(mark: PinMark, text: string): void;
+    private hiddenPinMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: PinMark): void;
+    showMark(mark: PinMark): void;
+}

package/dist/components/CandleView/MarkManager/Text/PriceLabelMarkManager.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { PriceLabelMark } from "../../Mark/Text/PriceLabelMark";
+import { Point } from "../../types";
+export interface PriceLabelMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface PriceLabelMarkState {
+    isPriceLabelMarkMode: boolean;
+    priceLabelMarkPoint: Point | null;
+    currentPriceLabelMark: PriceLabelMark | null;
+    isDragging: boolean;
+    dragTarget: PriceLabelMark | null;
+}
+export declare class PriceLabelMarkManager implements IMarkManager<PriceLabelMark> {
+    private props;
+    private state;
+    private previewPriceLabelMark;
+    private priceLabelMarks;
+    private dragStartData;
+    private isOperating;
+    private isCreatingNewLabel;
+    constructor(props: PriceLabelMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): PriceLabelMark | null;
+    getCurrentDragTarget(): PriceLabelMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): PriceLabelMark | null;
+    getAllMarks(): PriceLabelMark[];
+    cancelOperationMode(): PriceLabelMarkState;
+    setPriceLabelMarkMode: () => PriceLabelMarkState;
+    cancelPriceLabelMarkMode: () => PriceLabelMarkState;
+    handleMouseDown: (point: Point) => PriceLabelMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => PriceLabelMarkState;
+    handleKeyDown: (event: KeyboardEvent) => PriceLabelMarkState;
+    getState(): PriceLabelMarkState;
+    updateProps(newProps: Partial<PriceLabelMarkManagerProps>): void;
+    destroy(): void;
+    getPriceLabelMarks(): PriceLabelMark[];
+    removePriceLabelMark(mark: PriceLabelMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenPriceLabelMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: PriceLabelMark): void;
+    showMark(mark: PriceLabelMark): void;
+}

package/dist/components/CandleView/MarkManager/Text/PriceNoteMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { PriceNoteMark } from "../../Mark/Text/PriceNoteMark";
+import { Point } from "../../types";
+export interface PriceNoteMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface PriceNoteMarkState {
+    isPriceNoteMarkMode: boolean;
+    priceNoteMarkStartPoint: Point | null;
+    currentPriceNoteMark: PriceNoteMark | null;
+    isDragging: boolean;
+    dragTarget: PriceNoteMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class PriceNoteMarkManager implements IMarkManager<PriceNoteMark> {
+    private props;
+    private state;
+    private previewPriceNoteMark;
+    private priceNoteMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    constructor(props: PriceNoteMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): PriceNoteMark | null;
+    getCurrentDragTarget(): PriceNoteMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): PriceNoteMark | null;
+    getAllMarks(): PriceNoteMark[];
+    cancelOperationMode(): PriceNoteMarkState;
+    setPriceNoteMarkMode: () => PriceNoteMarkState;
+    cancelPriceNoteMarkMode: () => PriceNoteMarkState;
+    handleMouseDown: (point: Point) => PriceNoteMarkState;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => PriceNoteMarkState;
+    handleKeyDown: (event: KeyboardEvent) => PriceNoteMarkState;
+    getState(): PriceNoteMarkState;
+    updateProps(newProps: Partial<PriceNoteMarkManagerProps>): void;
+    destroy(): void;
+    getPriceNoteMarks(): PriceNoteMark[];
+    removePriceNoteMark(mark: PriceNoteMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenPriceNoteMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: PriceNoteMark): void;
+    showMark(mark: PriceNoteMark): void;
+}

package/dist/components/CandleView/MarkManager/Text/SignPostMarkManager.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { SignPostMark } from "../../Mark/Text/SignPostMark";
+import { Point } from "../../types";
+export interface SignPostMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface SignPostMarkState {
+    isSignPostMarkMode: boolean;
+    signPostMarkPoint: Point | null;
+    currentSignPostMark: SignPostMark | null;
+    isDragging: boolean;
+    dragTarget: SignPostMark | null;
+}
+export declare class SignPostMarkManager implements IMarkManager<SignPostMark> {
+    private props;
+    private state;
+    private previewSignPostMark;
+    private landmarkLabelMarks;
+    private dragStartData;
+    private isOperating;
+    private isCreatingNewLabel;
+    constructor(props: SignPostMarkManagerProps);
+    private _addEventListeners;
+    private _removeEventListeners;
+    private _handleSignPostMarkDragStart;
+    clearState(): void;
+    getMarkAtPoint(point: Point): SignPostMark | null;
+    getCurrentDragTarget(): SignPostMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): SignPostMark | null;
+    getAllMarks(): SignPostMark[];
+    cancelOperationMode(): SignPostMarkState;
+    setSignPostMarkMode: () => SignPostMarkState;
+    cancelSignPostMarkMode: () => SignPostMarkState;
+    handleMouseDown: (point: Point) => SignPostMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => SignPostMarkState;
+    handleKeyDown: (event: KeyboardEvent) => SignPostMarkState;
+    getState(): SignPostMarkState;
+    updateProps(newProps: Partial<SignPostMarkManagerProps>): void;
+    destroy(): void;
+    getSignPostMarks(): SignPostMark[];
+    removeSignPostMark(mark: SignPostMark): void;
+    isOperatingOnChart(): boolean;
+    updateSignPostText(mark: SignPostMark, text: string): void;
+    private hiddenSignPostMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: SignPostMark): void;
+    showMark(mark: SignPostMark): void;
+}

package/dist/components/CandleView/MarkManager/Text/TextEditMarkManager.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { TextEditMark } from "../../Mark/Text/TextEditMark";
+import { Point } from "../../types";
+export interface TextEditMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface TextEditMarkState {
+    isTextEditMarkMode: boolean;
+    textEditMarkPoints: Point[] | null;
+    currentTextEditMark: TextEditMark | null;
+    isDragging: boolean;
+    dragTarget: TextEditMark | null;
+    dragType: 'bubble' | null;
+}
+export declare class TextEditMarkManager implements IMarkManager<TextEditMark> {
+    private props;
+    private state;
+    private previewTextEditMark;
+    private textEditMarks;
+    private dragStartData;
+    private isOperating;
+    private isCreatingNewText;
+    private creationStep;
+    constructor(props: TextEditMarkManagerProps);
+    private _addEventListeners;
+    private _removeEventListeners;
+    private _handleTextEditMarkDragStart;
+    clearState(): void;
+    getMarkAtPoint(point: Point): TextEditMark | null;
+    getMarkAtPointWithType(point: Point): {
+        mark: TextEditMark;
+        type: 'bubble';
+    } | null;
+    getCurrentDragTarget(): TextEditMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): TextEditMark | null;
+    getAllMarks(): TextEditMark[];
+    cancelOperationMode(): TextEditMarkState;
+    setTextEditMarkMode: () => TextEditMarkState;
+    cancelTextEditMarkMode: () => TextEditMarkState;
+    handleMouseDown: (point: Point) => TextEditMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => TextEditMarkState;
+    handleKeyDown: (event: KeyboardEvent) => TextEditMarkState;
+    getState(): TextEditMarkState;
+    updateProps(newProps: Partial<TextEditMarkManagerProps>): void;
+    destroy(): void;
+    getTextEditMarks(): TextEditMark[];
+    removeTextEditMark(mark: TextEditMark): void;
+    isOperatingOnChart(): boolean;
+    updateTextEditText(mark: TextEditMark, text: string): void;
+    private hiddenTextEditMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: TextEditMark): void;
+    showMark(mark: TextEditMark): void;
+}

package/dist/components/CandleView/Theme.d.ts

@@ -0,0 +1,59 @@
+export interface ThemeConfig {
+    panel: {
+        backgroundColor: string;
+        borderColor: string;
+    };
+    modal: {
+        textColor: string;
+    };
+    layout: {
+        background: {
+            color: string;
+        };
+        textColor: string;
+        attributionLogo: boolean;
+    };
+    grid: {
+        vertLines: {
+            visible: boolean;
+            color?: string;
+        };
+        horzLines: {
+            visible: boolean;
+            color?: string;
+        };
+    };
+    chart: {
+        candleUpColor: string;
+        candleDownColor: string;
+        lineColor: string;
+        topColor: string;
+        bottomColor: string;
+        lineWidth: number;
+        upColor: string;
+        downColor: string;
+        background: string;
+        baseLineColor: string;
+        histogramColor: string;
+        stepLineColor: string;
+        areaTopColor: string;
+        areaBottomColor: string;
+        areaLineColor: string;
+        volumeColor: string;
+    };
+    toolbar: {
+        background: string;
+        border: string;
+        button: {
+            backgroundColor: string;
+            background: string;
+            hover: string;
+            active: string;
+            color: string;
+            activeTextColor: string;
+            boxShadow: string;
+        };
+    };
+}
+export declare const Dark: ThemeConfig;
+export declare const Light: ThemeConfig;

package/dist/components/CandleView/TopPanel/Config.d.ts

@@ -0,0 +1,22 @@
+import { I18n } from "../I18n";
+import { MainChartIndicatorType, SubChartIndicatorType, TimeframeEnum } from "../types";
+export declare const mainIndicators: {
+    id: string;
+    name: string;
+    type: MainChartIndicatorType;
+}[];
+export declare const mainChartMaps: {
+    id: string;
+    name: string;
+    type: MainChartIndicatorType;
+}[];
+export declare const subChartIndicators: {
+    id: string;
+    name: string;
+    type: SubChartIndicatorType;
+}[];
+export declare function getAllTimeframes(i18n: I18n): {
+    type: string;
+    sectionKey: "Second" | "Minute" | "Hour" | "Day" | "Week" | "Month";
+    values: TimeframeEnum[];
+}[];

package/dist/components/CandleView/TopPanel/IndicatorProcessing.d.ts

@@ -0,0 +1,4 @@
+import CandleViewTopPanel from ".";
+import { SubChartIndicatorType } from "../types";
+export declare function handleMainIndicatorToggle(candleViewTopPanel: CandleViewTopPanel, indicatorId: string): void;
+export declare function handleSubChartIndicatorToggle(candleViewTopPanel: CandleViewTopPanel, indicatorType: SubChartIndicatorType): void;