candleview 1.0.4 → 1.0.5

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

@@ -0,0 +1,61 @@
+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,52 @@
+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,51 @@
+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,56 @@
+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,51 @@
+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,53 @@
+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,55 @@
+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,61 @@
+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,23 @@
+import { CandleViewTopPanelState } from '.';
+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: keyof CandleViewTopPanelState["timeframeSections"];
+    values: TimeframeEnum[];
+}[];

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

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

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

@@ -0,0 +1,104 @@
+import { default as React } from 'react';
+import { ThemeConfig } from '../Theme';
+import { MainChartIndicatorInfo } from '../Indicators/MainChart/MainChartIndicatorInfo';
+import { MainChartType, SubChartIndicatorType } from '../types';
+import { I18n } from '../I18n';
+interface CandleViewTopPanelProps {
+    currentTheme: ThemeConfig;
+    activeTimeframe: string;
+    activeMainChartType: MainChartType;
+    isDarkTheme: boolean;
+    isTimeframeModalOpen: boolean;
+    isIndicatorModalOpen: boolean;
+    isChartTypeModalOpen: boolean;
+    isSubChartModalOpen: boolean;
+    isTimezoneModalOpen: boolean;
+    isTimeFormatModalOpen: boolean;
+    isCloseTimeModalOpen: boolean;
+    isTradingDayModalOpen: boolean;
+    isMobileMenuOpen: boolean;
+    onMobileMenuToggle: () => void;
+    onThemeToggle: () => void;
+    onTimeframeClick: () => void;
+    onIndicatorClick: () => void;
+    onChartTypeClick: () => void;
+    onCompareClick: () => void;
+    onFullscreenClick: () => void;
+    onReplayClick: () => void;
+    onTimezoneClick: () => void;
+    onTimeFormatClick: () => void;
+    onCloseTimeClick: () => void;
+    onTradingDayClick: () => void;
+    onTimeframeSelect: (timeframe: string) => void;
+    onChartTypeSelect: (mainChartType: MainChartType) => void;
+    onTimezoneSelect: (timezone: string) => void;
+    handleSelectedMainChartIndicator: (indicators: MainChartIndicatorInfo) => void;
+    handleSelectedSubChartIndicator: (indicators: SubChartIndicatorType[]) => void;
+    showToolbar?: boolean;
+    onCloseModals?: () => void;
+    onSubChartClick?: () => void;
+    selectedSubChartIndicators?: SubChartIndicatorType[];
+    onCameraClick: () => void;
+    i18n: I18n;
+    currentTimezone: string;
+    currentCloseTime: string;
+    currentTradingDayType: string;
+}
+export interface CandleViewTopPanelState {
+    mainIndicatorsSearch: string;
+    subChartIndicatorsSearch: string;
+    chartTypeSearch: string;
+    selectedMainIndicator: MainChartIndicatorInfo | null;
+    selectedSubChartIndicators: SubChartIndicatorType[];
+    timeframeSections: {
+        Second: boolean;
+        Minute: boolean;
+        Hour: boolean;
+        Day: boolean;
+        Week: boolean;
+        Month: boolean;
+    };
+    timezoneSearch: string;
+    indicatorSections: {
+        technicalIndicators: boolean;
+        chart: boolean;
+        subChartIndicators: boolean;
+    };
+    windowWidth: number;
+}
+declare class CandleViewTopPanel extends React.Component<CandleViewTopPanelProps> {
+    private timeframeModalRef;
+    private chartTypeModalRef;
+    private indicatorModalRef;
+    private timezoneModalRef;
+    private mobileMenuModalRef;
+    state: CandleViewTopPanelState;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: CandleViewTopPanelProps): void;
+    private handleResize;
+    private isMobileView;
+    private toggleMobileMenu;
+    private closeMobileMenu;
+    private handleTimeframeSelect;
+    private handleChartTypeSelect;
+    private handleTimezoneSelect;
+    private handleMainIndicatorsSearch;
+    private handleTimezoneSearch;
+    private filteredMaps;
+    private filteredMainIndicators;
+    private filteredSubChartIndicators;
+    private toggleTimeframeSection;
+    private toggleIndicatorSection;
+    private getChartTypeLabel;
+    private getCurrentTimezoneDisplayName;
+    private handleMenuItemClick;
+    private renderMobileMenuModal;
+    private renderTimeframeModal;
+    private handleChartTypeSearch;
+    private renderChartTypeModal;
+    private renderIndicatorModal;
+    private renderTimezoneModal;
+    render(): import("react/jsx-runtime").JSX.Element | null;
+}
+export default CandleViewTopPanel;