@liberfi.io/ui-tradingview 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,938 @@
+import * as react from 'react';
+import { PropsWithChildren, ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Store } from 'jotai/vanilla/store';
+import * as jotai_vanilla_utils_atomFamily from 'jotai/vanilla/utils/atomFamily';
+import * as jotai from 'jotai';
+
+/**
+ * Minimal TradingView Charting Library type declarations.
+ * These mirror the official TradingView API so that this package
+ * can compile without bundling the proprietary library.
+ * Consumers must provide the actual charting_library at runtime.
+ */
+type ResolutionString = string & {
+    __brand?: "ResolutionString";
+};
+type Timezone = string;
+type TimezoneId = string;
+type LanguageCode = string;
+type ThemeName = "Light" | "Dark";
+type LayoutType = string;
+type ChartingLibraryFeatureset = string;
+interface Bar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+interface Mark {
+    id: string | number;
+    time: number;
+    color: string | MarkColor;
+    text: string;
+    label: string;
+    labelFontColor: string;
+    minSize: number;
+}
+type MarkColor = "red" | "green" | "blue" | "yellow";
+interface LibrarySymbolInfo {
+    name: string;
+    full_name: string;
+    ticker?: string;
+    description: string;
+    type: string;
+    session: string;
+    exchange: string;
+    listed_exchange: string;
+    timezone: Timezone;
+    format: string;
+    pricescale: number;
+    minmov: number;
+    has_intraday?: boolean;
+    has_seconds?: boolean;
+    has_ticks?: boolean;
+    has_no_volume?: boolean;
+    supported_resolutions?: ResolutionString[];
+    currency_code?: string;
+    [key: string]: any;
+}
+interface SymbolResolveExtension {
+    currencyCode?: string;
+    unitId?: string;
+}
+interface PeriodParams {
+    from: number;
+    to: number;
+    countBack: number;
+    firstDataRequest: boolean;
+}
+interface HistoryMetaInfo {
+    noData?: boolean;
+    nextTime?: number;
+}
+type HistoryCallback = (bars: Bar[], meta: HistoryMetaInfo) => void;
+type ResolveCallback = (symbolInfo: LibrarySymbolInfo) => void;
+type SubscribeBarsCallback = (bar: Bar) => void;
+type GetMarksCallback<T> = (marks: T[]) => void;
+type SeriesType = number;
+interface SeriesFormatterFactory {
+    (symbolInfo: LibrarySymbolInfo | null, minTick: string): {
+        format: (price: number) => string;
+    };
+}
+interface ChartingLibraryWidgetOptions {
+    container: string | HTMLElement;
+    autosize?: boolean;
+    debug?: boolean;
+    load_last_chart?: boolean;
+    auto_save_delay?: number;
+    timezone?: Timezone;
+    library_path?: string;
+    custom_css_url?: string;
+    theme?: ThemeName;
+    custom_font_family?: string;
+    symbol?: string;
+    interval?: ResolutionString;
+    locale?: LanguageCode;
+    datafeed: any;
+    save_load_adapter?: any;
+    settings_adapter?: any;
+    custom_formatters?: any;
+    overrides?: Record<string, any>;
+    studies_overrides?: Record<string, any>;
+    disabled_features?: ChartingLibraryFeatureset[];
+    enabled_features?: ChartingLibraryFeatureset[];
+    broker_config?: any;
+    [key: string]: any;
+}
+type TradingTerminalWidgetOptions = ChartingLibraryWidgetOptions;
+interface VisibleTimeRange {
+    from: number;
+    to: number;
+}
+interface CrossHairMovedEventParams {
+    time: number;
+    price: number;
+}
+interface ISubscription<T = void> {
+    subscribe(obj: any, handler: (value: T) => void): void;
+    unsubscribe(obj: any, handler: (value: T) => void): void;
+}
+interface ITimeScaleApi {
+    rightOffset(): number;
+    setRightOffset(offset: number): void;
+    barSpacing(): number;
+    setBarSpacing(spacing: number): void;
+    width(): number;
+    rightOffsetChanged(): ISubscription<number>;
+    barSpacingChanged(): ISubscription<number>;
+}
+interface IPaneApi {
+    getMainSourcePriceScale(): {
+        setAutoScale(auto: boolean): void;
+    } | null;
+}
+interface IChartWidgetApi {
+    symbol(): string;
+    resolution(): ResolutionString;
+    setSymbol(symbol: string, options?: any): void;
+    setResolution(resolution: ResolutionString, options?: any): Promise<void>;
+    setChartType(type: SeriesType): void;
+    chartType(): SeriesType;
+    getTimeScale(): ITimeScaleApi;
+    getVisibleRange(): VisibleTimeRange;
+    onSymbolChanged(): ISubscription;
+    onIntervalChanged(): ISubscription<ResolutionString>;
+    onVisibleRangeChanged(): ISubscription<VisibleTimeRange>;
+    crossHairMoved(): ISubscription<CrossHairMovedEventParams>;
+    dataReady(callback: () => void): void;
+    getPanes(): IPaneApi[];
+    priceFormatter(): {
+        format(price: number): string;
+    } | null;
+    executeActionById(actionId: string): void;
+    getTimezoneApi(): {
+        setTimezone(timezone: TimezoneId): void;
+    } | null;
+    resetData(): void;
+    getAllStudies(): any[];
+}
+interface IChartingLibraryWidget {
+    onChartReady(callback: () => void): void;
+    chart(index?: number): IChartWidgetApi;
+    activeChart(): IChartWidgetApi;
+    activeChartIndex(): number | undefined;
+    chartsCount(): number;
+    setActiveChart(index: number): void;
+    layout(): LayoutType;
+    setLayout(layout: LayoutType): void;
+    saveChartToServer(onComplete?: () => void, onFail?: () => void, options?: {
+        defaultChartName?: string;
+    }): void;
+    changeTheme(theme: ThemeName, options?: {
+        disableUndo?: boolean;
+    }): Promise<void>;
+    applyOverrides(overrides: Record<string, any>): void;
+    applyStudiesOverrides(overrides: Record<string, any>): void;
+    setCSSCustomProperty(key: string, value: string): void;
+    subscribe(event: string, callback: (...args: any[]) => void): void;
+    unsubscribe(event: string, callback: (...args: any[]) => void): void;
+    onContextMenu(callback: (...args: any[]) => any): void;
+    takeClientScreenshot(): Promise<HTMLCanvasElement>;
+    symbolSync(): {
+        setValue(v: boolean): void;
+    } | null;
+    intervalSync(): {
+        setValue(v: boolean): void;
+    } | null;
+    unloadUnusedCharts(): void;
+    remove(): void;
+}
+type WidgetConstructor = new (options: ChartingLibraryWidgetOptions | TradingTerminalWidgetOptions) => IChartingLibraryWidget;
+
+/**
+ * Persists chart settings, shapes, and drawing data to localStorage.
+ * All keys are scoped by `storageId` to support multiple instances.
+ */
+declare class ChartSettingsStore {
+    private storageId;
+    constructor(storageId: string);
+    private get settingsKey();
+    private get shapesKey();
+    getSettings(): any;
+    getChartStoreData(): any;
+    setChartStoreData(data: any): void;
+    saveSettings(data: any): Promise<void>;
+    getShapes(key: string): Promise<any[]>;
+    saveShapes(key: string, updated: any): Promise<void>;
+    private getLocalData;
+    private setLocalData;
+    private getLocalSettingsData;
+    private getLocalShapesData;
+    private setLocalShapesData;
+}
+
+/**
+ * Manages chart-level settings via jotai atoms (keyed by prefix).
+ * Replaces the BehaviorSubject-based TvChartSettings.
+ */
+declare class ChartSettings {
+    readonly prefix: string;
+    private store;
+    supportedResolutions: ResolutionString[];
+    supportedLayouts: TvChartLayout[];
+    supportedChartTypes: TvChartType[];
+    chartNames: Record<string, string>;
+    priceFormatterFactory: SeriesFormatterFactory | null;
+    saveLoadAdapter: ChartSettingsStore;
+    constructor(prefix: string, store: Store);
+    get layout(): TvChartLayout;
+    get chartType(): TvChartType;
+    get theme(): string;
+    get reverseColor(): boolean;
+    get locale(): string;
+    get timezone(): string;
+    get tickerSymbol(): string;
+    get storageId(): string;
+    get backgroundColor(): string | null;
+    get enabledFeatures(): string[];
+    get disabledFeatures(): string[];
+    updateValue(key: string, value: any): void;
+    isFeatureEnabled(feature: TvChartFeature): boolean;
+    setFeature(feature: string, enabled: boolean): void;
+    resetFeature(feature: string): void;
+    get enableMultiCharts(): boolean;
+    get enableCreateVolumeIndicatorByDefault(): boolean;
+    get enableHideDrawingToolsByDefault(): boolean;
+    get enableLegendSeriesTitle(): boolean;
+    get enableLegendVolume(): boolean;
+    get enableTimeframesToolbar(): boolean;
+    get enableVolumeForceOverlay(): boolean;
+    /**
+     * Subscribe to a specific atom change. Returns unsubscribe function.
+     */
+    sub(key: string, callback: () => void): () => void;
+}
+
+type Listener<T = any> = (value: T) => void;
+/**
+ * Lightweight typed event emitter for internal bridge-level events.
+ * Replaces rxjs Subject for non-React event passing.
+ */
+declare class EventEmitter<TEvents extends Record<string, any> = Record<string, any>> {
+    private listeners;
+    on<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): () => void;
+    emit<K extends keyof TEvents>(event: K, value: TEvents[K]): void;
+    off<K extends keyof TEvents>(event: K, listener: Listener<TEvents[K]>): void;
+    clear(): void;
+}
+
+interface BridgeEvents {
+    symbolChanged: [number, string];
+    resolutionChanged: [number, string];
+    visibleRangeChanged: [number, VisibleTimeRange];
+    crosshairMoved: [number, CrossHairMovedEventParams];
+    domEvent: [number, string, Event];
+}
+/**
+ * Bridge between our React/jotai layer and the TradingView charting library widget.
+ * Manages widget lifecycle, chart subscriptions, and module orchestration.
+ */
+declare class ChartWidgetBridge {
+    readonly settings: ChartSettings;
+    readonly chartManager: ChartManager;
+    private WidgetCtor;
+    private moduleInstances;
+    private symbolIntervalSubs;
+    private abortController;
+    private widgetReadyPromise;
+    private readyPromise;
+    widget: IChartingLibraryWidget | null;
+    container: HTMLDivElement | null;
+    ready: boolean;
+    layoutReady: boolean;
+    readonly events: EventEmitter<BridgeEvents>;
+    private libraryPath;
+    private customCssUrl;
+    constructor(settings: ChartSettings, chartManager: ChartManager, widgetConstructor: WidgetConstructor, options?: {
+        libraryPath?: string;
+        customCssUrl?: string;
+    });
+    getWidget(): IChartingLibraryWidget | null;
+    init(container: HTMLDivElement): Promise<void>;
+    destroy(): Promise<void>;
+    onReady(): Promise<void>;
+    asyncWidgetMethodContext(callback: (widget: IChartingLibraryWidget, done: () => void) => void): Promise<void>;
+    getModule(name: string): any;
+    applyColorPaletteOverrides(): void;
+    private getWidgetOptions;
+    private handleChartReady;
+    private onAutoSaveNeeded;
+    private activeChartChanged;
+    private layoutWillChange;
+    private layoutChanged;
+    private syncChartsChanges;
+    private subscribeChartsChanges;
+    private installEventHooks;
+    private resetTimezone;
+    private get localTimezone();
+    private waitForLayout;
+    private getSettingsOverrides;
+    private getColorPaletteOverrides;
+    private getColorPaletteStudiesOverrides;
+    private initModules;
+}
+
+/**
+ * Per-area widget wrapper that proxies operations to the TradingView chart API.
+ */
+declare class ChartWidget {
+    private settings;
+    private chartManager;
+    private bridge;
+    readonly chartIndex: number;
+    constructor(settings: ChartSettings, chartManager: ChartManager, bridge: ChartWidgetBridge, index: number);
+    get chartAreaManager(): ChartAreaManager | null;
+    get widget(): IChartingLibraryWidget | null;
+    get chartWidget(): IChartWidgetApi | null;
+    setChartStyle(chartType: SeriesType): void;
+    getChartStyle(): SeriesType;
+    handleSymbolChange(symbol: string, _prevSymbol: string): Promise<void>;
+    handleResolutionChange(resolution: TvChartResolution, _prevResolution: string): Promise<void>;
+    setPrecision(precision: number | null): void;
+    dataReady(): Promise<void>;
+    timeScaleWidth(): number;
+    rightOffset(): number;
+    setRightOffset(offset: number): void;
+    barSpacing(): number;
+    setBarSpacing(spacing: number): void;
+}
+
+/**
+ * Manages the state of a single chart area (pane).
+ * Reads/writes the corresponding index in chartAreasFamily(prefix).
+ */
+declare class ChartAreaManager {
+    readonly settings: ChartSettings;
+    readonly chartManager: ChartManager;
+    readonly chartIndex: number;
+    private store;
+    private prefix;
+    pendingTickerSymbol: string | null;
+    pendingResolution: string | null;
+    constructor(settings: ChartSettings, manager: ChartManager, index: number, store: Store, prefix: string, areaSettings?: Partial<ChartAreaState>);
+    get state(): ChartAreaState;
+    private patchArea;
+    setState(key: keyof ChartAreaState, value: any): void;
+    get tickerSymbol(): string;
+    get symbol(): string;
+    get resolution(): TvChartResolution;
+    get chartStyle(): SeriesType;
+    get rightOffset(): number;
+    get barSpacing(): number;
+    get dataReady(): boolean;
+    get internalChartWidget(): ChartWidget | undefined;
+    setChartStyle(chartStyle: SeriesType): void;
+    setSymbol(symbol: string): Promise<void>;
+    setResolution(resolution: TvChartResolution): Promise<void>;
+    toJSON(): ChartAreaState;
+    widgetReady(): void;
+    get active(): boolean;
+    get selected(): boolean;
+    get symbolInfo(): LibrarySymbolInfo | null;
+    destroy(): void;
+    private handleChartReady;
+}
+
+/**
+ * High-level wrapper around the TradingView IChartingLibraryWidget.
+ * Provides convenience methods for theme, layout, screenshots, etc.
+ */
+declare class ChartLibraryWidget {
+    private settings;
+    private chartManager;
+    readonly bridge: ChartWidgetBridge;
+    constructor(settings: ChartSettings, chartManager: ChartManager, bridge: ChartWidgetBridge);
+    get widget(): IChartingLibraryWidget | null;
+    chartByIndex(index: number): ChartWidget;
+    activeChart(): ChartWidget | undefined;
+    openIndicatorSettingsDialog(): void;
+    openSettingsDialog(): void;
+    takeClientScreenshot(): Promise<HTMLCanvasElement> | undefined;
+    onLayoutChange(layout: TvChartLayout): void;
+    onThemeChange(theme: string, _reverseColor: boolean): Promise<void>;
+}
+
+/**
+ * Core chart manager that orchestrates areas, settings, and widget lifecycle.
+ * State is backed by jotai atoms keyed by prefix (storageId).
+ */
+declare class ChartManager {
+    readonly prefix: string;
+    readonly settings: ChartSettings;
+    private store;
+    initialized: boolean;
+    focused: boolean;
+    reloadId: number;
+    internalWidget: ChartLibraryWidget | null;
+    datafeed: ITvChartDataFeedModule | null;
+    symbolResolver: ITvChartSymbolResolver | null;
+    private unsubAutoSave;
+    constructor(prefix: string, store: Store, settings: ChartSettings);
+    get loading(): boolean;
+    get fullscreen(): boolean;
+    set fullscreen(v: boolean);
+    get selectedIndex(): number;
+    set selectedIndex(idx: number);
+    get pinnedResolutions(): TvChartResolution[];
+    set pinnedResolutions(v: TvChartResolution[]);
+    get showDrawingToolbar(): boolean;
+    get chartCount(): number;
+    get areas(): ChartAreaManager[];
+    private _areaManagers;
+    areaByIndex(index: number): ChartAreaManager | null;
+    get activeArea(): ChartAreaManager | null;
+    init(): Promise<void>;
+    destroy(): void;
+    setLoading(loading: boolean): void;
+    setLocale(locale: string): void;
+    setTimezone(timezone: string): void;
+    setFocused(focused: boolean): void;
+    setShowDrawingToolbar(show: boolean): void;
+    setInternalWidget(widget: ChartLibraryWidget | null): void;
+    onInternalWidgetReady(): void;
+    setChartType(chartType: string): void;
+    setTheme(theme: string): void;
+    setReverseColor(reverseColor: boolean): void;
+    setLayout(layout: TvChartLayout): void;
+    reloadChart(): void;
+    updateChartContents(): void;
+    get settingsData(): {
+        layout: TvChartLayout;
+        chartType: TvChartType;
+        selectedIndex: number;
+        pinnedResolutions: TvChartResolution[];
+        showDrawingToolbar: boolean;
+        areaContents: ChartAreaState[];
+    };
+    getAllCharts(): ChartAreaManager[];
+}
+
+declare enum TvChartType {
+    TradingView = "TradingView",
+    Original = "Original"
+}
+declare enum TvChartPriceType {
+    Price = "price",
+    MarketCap = "market_cap"
+}
+declare enum TvChartQuoteType {
+    USD = "USD",
+    SOL = "SOL",
+    ETH = "ETH",
+    TRX = "TRX",
+    BNB = "BNB"
+}
+type TvChartResolution = "1s" | "5s" | "15s" | "30s" | "1m" | "5m" | "15m" | "30m" | "1h" | "4h" | "12h" | "1d";
+declare enum TvChartKlineStyle {
+    Bars = 0,
+    Candles = 1,
+    Line = 2,
+    Area = 3,
+    HeikenAshi = 8,
+    HollowCandles = 9,
+    Baseline = 10,
+    HiLo = 12,
+    Column = 13,
+    LineWithMarkers = 14,
+    Stepline = 15,
+    HLCArea = 16,
+    VolCandle = 19,
+    Renko = 4,
+    Kagi = 5,
+    PointAndFigure = 6,
+    LineBreak = 7
+}
+declare enum TvChartTheme {
+    Light = "light",
+    Dark = "dark"
+}
+declare enum TvChartFeature {
+    HeaderWidget = "header_widget",
+    HeaderCandleStyleMenu = "header_candle_style_menu",
+    HeaderFullscreenButton = "header_fullscreen_button",
+    MultiCharts = "multi_charts",
+    CreateVolumeIndicatorByDefault = "create_volume_indicator_by_default",
+    VolumeForceOverlay = "volume_force_overlay",
+    HideDrawingToolsByDefault = "hide_drawing_tools_by_default",
+    LegendSeriesTitle = "legend_series_title",
+    LegendVolume = "legend_volume",
+    TimeframesToolbar = "timeframes_toolbar",
+    SaveDrawingToServer = "save_drawing_to_server"
+}
+declare enum TvChartLayout {
+    Layout1A = "1A",
+    Layout2A = "2A",
+    Layout2B = "2B",
+    Layout3A = "3A",
+    Layout3B = "3B",
+    Layout3C = "3C",
+    Layout3D = "3D",
+    Layout3E = "3E",
+    Layout3F = "3F",
+    Layout4A = "4A",
+    Layout4B = "4B",
+    Layout4C = "4C",
+    Layout4D = "4D",
+    Layout4E = "4E",
+    Layout4F = "4F",
+    Layout5A = "5A",
+    Layout5B = "5B",
+    Layout5C = "5C",
+    Layout5D = "5D",
+    Layout6A = "6A",
+    Layout6B = "6B",
+    Layout6C = "6C",
+    Layout7A = "7A",
+    Layout8A = "8A",
+    Layout8B = "8B",
+    Layout8C = "8C"
+}
+interface TvChartSymbol {
+    chain: string;
+    address: string;
+    quote?: TvChartQuoteType;
+    priceType?: TvChartPriceType;
+}
+interface TvChartSymbolChange {
+    index?: number;
+    tickerSymbol: string;
+    libTickerSymbol: string;
+}
+interface TvChartSymbolInfo extends LibrarySymbolInfo {
+    symbol: string;
+    full_name: string;
+    address: string;
+    priceType: TvChartPriceType;
+    quote: TvChartQuoteType;
+    precision: number;
+}
+interface ITvChartDataFeedModule {
+    onReady(options: {
+        setting: ChartSettings;
+        chartManager: ChartManager;
+        instance: ChartWidgetBridge;
+    }): Promise<void>;
+    onDestroy(): void;
+    resolveSymbol(symbolName: string, extension?: SymbolResolveExtension): Promise<LibrarySymbolInfo | null>;
+    getBars(symbolInfo: LibrarySymbolInfo, resolution: ResolutionString, periodParams: PeriodParams): Promise<Bar[]>;
+    subscribeBars(symbolInfo: LibrarySymbolInfo, resolution: ResolutionString, onTick: SubscribeBarsCallback, listenerGuid: string, onResetCacheNeededCallback: () => void): void;
+    unsubscribeBars(listenerGuid: string): void;
+    getMarks?(symbolInfo: LibrarySymbolInfo, from: number, to: number, onDataCallback: GetMarksCallback<Mark>, resolution: ResolutionString): void;
+    getFirstBarTime?(symbolInfo: LibrarySymbolInfo, resolution: string, options: {
+        timezone: Timezone;
+    }): Promise<void>;
+}
+interface ITvChartSymbolResolver {
+    resolveSymbolInfo(symbol: string): Promise<LibrarySymbolInfo | null>;
+    resolveSymbolInfos(symbols: string[]): Promise<LibrarySymbolInfo[]>;
+    getSymbolInfo(symbol: string): LibrarySymbolInfo | null;
+}
+interface ChartAreaState {
+    tickerSymbol: string;
+    symbol: string;
+    resolution: TvChartResolution;
+    chartStyle: TvChartKlineStyle;
+    rightOffset: number;
+    barSpacing: number;
+    dataReady: boolean;
+    crosshair?: {
+        time: number;
+        price: number;
+    };
+    firstBarTime?: number;
+}
+declare enum TvChartErrorResetType {
+    None = 0,
+    ResetData = 1,
+    ResetChart = 2
+}
+
+interface TvChartConfig {
+    storageId: string;
+    tickerSymbol: string;
+    datafeed: ITvChartDataFeedModule;
+    resolution: TvChartResolution;
+    supportedResolutions?: TvChartResolution[];
+    layout: TvChartLayout;
+    supportedLayouts?: TvChartLayout[];
+    chartType: TvChartType;
+    supportedChartTypes?: TvChartType[];
+    chartNames?: Record<string, string>;
+    kLineStyle: TvChartKlineStyle;
+    theme: TvChartTheme;
+    reverseColor?: boolean;
+    backgroundColor?: string;
+    timezone: Timezone;
+    locale: LanguageCode;
+    enabledFeatures?: TvChartFeature[];
+    disabledFeatures?: TvChartFeature[];
+    priceFormatterFactory?: SeriesFormatterFactory;
+}
+interface TradingViewConfigProps {
+    initConfig: TvChartConfig;
+    widgetConstructor: WidgetConstructor;
+    libraryPath?: string;
+    customCssUrl?: string;
+}
+declare const TradingViewConfig: ({ initConfig, children, }: PropsWithChildren<{
+    initConfig: TvChartConfig;
+}>) => react_jsx_runtime.JSX.Element | null;
+
+interface TvChartContextValue {
+    prefix: string;
+    chartSettings: ChartSettings;
+    chartManager: ChartManager;
+    widgetConstructor: WidgetConstructor;
+    libraryPath?: string;
+    customCssUrl?: string;
+}
+declare function useTvChartContext(): TvChartContextValue;
+declare function useTvChartManager(): ChartManager;
+declare function useTvChartPrefix(): string;
+declare class TvChartHandle {
+    readonly setting: ChartSettings;
+    readonly chartManager: ChartManager;
+    constructor(setting: ChartSettings, chartManager: ChartManager);
+    get internalWidget(): ChartLibraryWidget | null;
+    chartCount(): number;
+    setActiveChart(index: number): void;
+    layout(): TvChartLayout;
+    setLayout(layout: TvChartLayout): void;
+    theme(): string;
+    setTheme(theme: string): void;
+    setChartType(chartType: TvChartType): void;
+    getSetting(): ChartSettings;
+    getChartManager(): ChartManager;
+}
+interface TradingViewProviderProps extends PropsWithChildren<TradingViewConfigProps> {
+}
+declare const TradingViewProvider: react.ForwardRefExoticComponent<TradingViewProviderProps & react.RefAttributes<TvChartHandle>>;
+
+interface TradingViewToolbarProps {
+    /** Extra elements to render before the default toolbar items */
+    prefix?: ReactNode;
+    /** Extra elements to render after the default toolbar items */
+    suffix?: ReactNode;
+    /** Override the default toolbar items entirely */
+    children?: ReactNode;
+    /** Show/hide resolution buttons (default: true) */
+    showResolutions?: boolean;
+    /** Show/hide kline style selector (default: true) */
+    showKlineStyleSelect?: boolean;
+    /** Show/hide indicator button (default: true) */
+    showOpenIndicator?: boolean;
+    /** Show/hide settings button (default: true) */
+    showOpenSettings?: boolean;
+    /** Show/hide fullscreen button (default: true) */
+    showFullscreen?: boolean;
+    /** Show/hide snapshot button (default: true) */
+    showSnapshot?: boolean;
+}
+declare const TradingViewToolbar: react.MemoExoticComponent<({ children, prefix: prefixSlot, suffix, showResolutions, showKlineStyleSelect, showOpenIndicator, showOpenSettings, showFullscreen, showSnapshot, }: TradingViewToolbarProps) => react_jsx_runtime.JSX.Element>;
+
+interface TradingViewInstance {
+    handle: TvChartHandle;
+}
+interface TradingViewProps {
+    /** Chart configuration */
+    initConfig: TvChartConfig;
+    /** TradingView Widget constructor (injected by consumer) */
+    widgetConstructor: WidgetConstructor;
+    /** Path to charting library static files */
+    libraryPath?: string;
+    /** Custom CSS URL for the charting library */
+    customCssUrl?: string;
+    /** Toolbar configuration; pass false to hide */
+    toolbar?: TradingViewToolbarProps | false;
+    /** Optional loading overlay */
+    loadingOverlay?: ReactNode;
+    /** Called when chart widget is ready */
+    onReady?: () => void;
+    /** Additional children rendered below the chart */
+    children?: ReactNode;
+    /** Class name for the outer container */
+    className?: string;
+}
+/**
+ * Main TradingView K-line chart component.
+ * Wraps the TradingView Charting Library with jotai-based state management
+ * and multi-instance support via storageId.
+ */
+declare const TradingView: react.ForwardRefExoticComponent<TradingViewProps & react.RefAttributes<TvChartHandle>>;
+
+interface TradingViewWidgetProviderProps {
+    onReady?: () => void;
+}
+declare const TradingViewWidgetProvider: react.MemoExoticComponent<({ onReady }: TradingViewWidgetProviderProps) => react_jsx_runtime.JSX.Element>;
+
+interface TradingViewWidgetContainerProps {
+    onReady?: () => void;
+}
+declare const TradingViewWidgetContainer: react.ForwardRefExoticComponent<TradingViewWidgetContainerProps & react.RefAttributes<ChartLibraryWidget | undefined>>;
+
+interface TvChartToolbarContextValue {
+    activeAreaManager: ChartAreaManager | null;
+    symbolInfo: LibrarySymbolInfo | null;
+}
+declare function useTvChartToolbarContext(): TvChartToolbarContextValue;
+declare const TradingViewToolbarProvider: ({ children }: PropsWithChildren) => react_jsx_runtime.JSX.Element;
+
+declare const TradingViewResolutions: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+declare const TradingViewKlineStyleSelect: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+declare const TradingViewOpenIndicator: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+declare const TradingViewOpenSettings: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+declare const TradingViewFullscreen: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+declare const TradingViewSnapshot: react.MemoExoticComponent<() => react_jsx_runtime.JSX.Element>;
+
+/**
+ * Placeholder for multi-chart layout area title injection.
+ * The TradingView charting library renders charts into its own iframes,
+ * so layout-level customization is done via the bridge's installEventHooks.
+ *
+ * This component can be extended to inject custom UI above or around
+ * individual chart panes when multi-chart layouts are active.
+ */
+declare const TradingViewLayout: react.MemoExoticComponent<() => null>;
+
+interface TradingViewAreaTitleProps {
+    index?: number;
+}
+/**
+ * Displays the symbol/resolution title for a chart area.
+ * Useful when rendering custom headers in multi-chart layouts.
+ */
+declare const TradingViewAreaTitle: react.MemoExoticComponent<({ index }: TradingViewAreaTitleProps) => react_jsx_runtime.JSX.Element | null>;
+
+/**
+ * Returns the ChartManager instance for the current TradingView context.
+ */
+declare function useChartManager(): ChartManager;
+
+/**
+ * Returns the ChartAreaManager for the currently active chart area.
+ */
+declare function useActiveAreaManager(): ChartAreaManager | null;
+
+/**
+ * Returns the resolved symbol info for the active chart area.
+ */
+declare function useSymbolInfo(): LibrarySymbolInfo | null;
+
+/**
+ * DataFeed adapter that conforms to the TradingView Datafeed API.
+ * Delegates actual data fetching to the injectable ITvChartDataFeedModule.
+ */
+declare class ChartDataFeed {
+    private settings;
+    private chartManager;
+    private bridge;
+    private abortController;
+    constructor(settings: ChartSettings, chartManager: ChartManager, bridge: ChartWidgetBridge);
+    onReady(callback: (data: any) => void): Promise<void>;
+    destroy(): void;
+    resolveSymbol(symbolName: string, onResolve: ResolveCallback, onError: ErrorCallback, extension?: SymbolResolveExtension): Promise<void>;
+    getBars(symbolInfo: LibrarySymbolInfo, resolution: ResolutionString, periodParams: PeriodParams, onResult: HistoryCallback, onError: ErrorCallback): Promise<void>;
+    subscribeBars(symbolInfo: LibrarySymbolInfo, resolution: ResolutionString, onTick: SubscribeBarsCallback, listenerGuid: string, onResetCacheNeededCallback: () => void): void;
+    unsubscribeBars(listenerGuid: string): void;
+    getMarks(symbolInfo: LibrarySymbolInfo, from: number, to: number, onDataCallback: GetMarksCallback<Mark>, resolution: ResolutionString): Promise<void>;
+}
+
+/**
+ * Resolves and caches symbol info via the injected DataFeedModule.
+ */
+declare class ChartSymbolResolver implements ITvChartSymbolResolver {
+    private datafeed;
+    private cache;
+    private pendingRequests;
+    constructor(datafeed: ITvChartDataFeedModule);
+    resolveSymbolInfo(symbol: string): Promise<LibrarySymbolInfo | null>;
+    resolveSymbolInfos(symbols: string[]): Promise<LibrarySymbolInfo[]>;
+    getSymbolInfo(symbol: string): LibrarySymbolInfo | null;
+}
+
+/**
+ * Adapter for TradingView save_load_adapter — persists chart layout and
+ * drawing data to localStorage, keyed by storageId for multi-instance support.
+ */
+declare class ChartSaveLoadAdapter {
+    private settings;
+    private chartManager;
+    private bridge;
+    private data;
+    private drawings;
+    constructor(settings: ChartSettings, chartManager: ChartManager, bridge: ChartWidgetBridge);
+    get layoutId(): string;
+    get shouldResetColorPalette(): boolean;
+    getAllCharts(): Promise<any[]>;
+    removeChart(_index: number): void;
+    saveChart(chart: any): Promise<string>;
+    getChartContent(_: any): Promise<string>;
+    saveLineToolsAndGroups(_storageId: string, chartIndex: string, data: any): Promise<void>;
+    loadLineToolsAndGroups(_storageId: string, chartIndex: string, _tool: string, symbolToLoad?: {
+        symbol?: string;
+    }): Promise<any | null>;
+    private getLayoutKey;
+    private getDrawingKey;
+    private loadDataFromLocalStorage;
+    private saveDataToLocalStorage;
+}
+
+/**
+ * Adapter for TradingView settings_adapter — reads/writes per-instance
+ * chart settings to localStorage with a scoped prefix.
+ */
+declare class ChartSettingsAdapter {
+    private storagePrefix;
+    initialSettings: Record<string, any>;
+    constructor(settings: ChartSettings, _chartManager: ChartManager, _bridge: ChartWidgetBridge);
+    toJSON(): null;
+    removeValue(key: string): void;
+    setValue(key: string, value: any): void;
+}
+
+declare const chartLoadingFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+declare const chartFullscreenFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+declare const chartSelectedIndexFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<number> & {
+    init: number;
+}>;
+declare const chartPinnedResolutionsFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<TvChartResolution[]> & {
+    init: TvChartResolution[];
+}>;
+declare const chartAreasFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<ChartAreaState[]> & {
+    init: ChartAreaState[];
+}>;
+declare const chartShowDrawingToolbarFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+declare const settingsLayoutFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<TvChartLayout> & {
+    init: TvChartLayout;
+}>;
+declare const settingsChartTypeFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<TvChartType> & {
+    init: TvChartType;
+}>;
+declare const settingsThemeFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string> & {
+    init: string;
+}>;
+declare const settingsLocaleFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string> & {
+    init: string;
+}>;
+declare const settingsTimezoneFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string> & {
+    init: string;
+}>;
+declare const settingsTickerSymbolFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string> & {
+    init: string;
+}>;
+declare const settingsStorageIdFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string> & {
+    init: string;
+}>;
+declare const settingsReverseColorFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+declare const settingsBackgroundColorFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string | null> & {
+    init: string | null;
+}>;
+declare const settingsEnabledFeaturesFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string[]> & {
+    init: string[];
+}>;
+declare const settingsDisabledFeaturesFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<string[]> & {
+    init: string[];
+}>;
+declare const widgetReadyFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.PrimitiveAtom<boolean> & {
+    init: boolean;
+}>;
+declare const settingsDataFamily: jotai_vanilla_utils_atomFamily.AtomFamily<string, jotai.Atom<{
+    layout: TvChartLayout;
+    chartType: TvChartType;
+    selectedIndex: number;
+    pinnedResolutions: TvChartResolution[];
+    showDrawingToolbar: boolean;
+    areaContents: ChartAreaState[];
+}>>;
+
+declare const ENABLED_TV_CHART_FEATURES: TvChartFeature[];
+declare const DEFAULT_TV_CHART_RESOLUTIONS: TvChartResolution[];
+declare const ALL_TV_CHART_RESOLUTIONS: TvChartResolution[];
+declare const SUPPORTED_TV_CHART_LAYOUTS: TvChartLayout[];
+declare const TV_CHART_THEME_COLORS: {
+    decrease: string;
+    increase: string;
+    chartBg: string;
+    card: string;
+};
+
+declare function parseSymbol(symbol: string): TvChartSymbol;
+declare function stringifySymbol(symbol: TvChartSymbol): string;
+declare function stringifySymbolShort(symbol: TvChartSymbol): string;
+declare function getTvChartLibraryTheme(theme: string): ThemeName;
+declare function getTvChartLibraryResolution(resolution?: TvChartResolution): ResolutionString;
+declare function getTvChartResolutionReverse(resolution: string): TvChartResolution;
+declare function getTvChartLibraryLocale(locale: string): LanguageCode;
+declare function getTvChartLibraryLayout(layout: TvChartLayout): LayoutType;
+declare function getTvChartLayoutReverse(layout: LayoutType): TvChartLayout;
+declare function getTvChartResolutionFrame(resolution: TvChartResolution): number;
+declare function getTvChartTickTimestamp(time: number, timeframe: number): number;
+
+export { ALL_TV_CHART_RESOLUTIONS, type Bar, ChartAreaManager, type ChartAreaState, ChartDataFeed, ChartLibraryWidget, ChartManager, ChartSaveLoadAdapter, ChartSettings, ChartSettingsAdapter, ChartSettingsStore, ChartSymbolResolver, ChartWidget, ChartWidgetBridge, type ChartingLibraryWidgetOptions, DEFAULT_TV_CHART_RESOLUTIONS, ENABLED_TV_CHART_FEATURES, EventEmitter, type HistoryMetaInfo, type IChartWidgetApi, type IChartingLibraryWidget, type ITvChartDataFeedModule, type ITvChartSymbolResolver, type LanguageCode, type LibrarySymbolInfo, type Mark, type PeriodParams, type ResolutionString, SUPPORTED_TV_CHART_LAYOUTS, type SeriesFormatterFactory, type SubscribeBarsCallback, type SymbolResolveExtension, TV_CHART_THEME_COLORS, type ThemeName, type Timezone, TradingView, TradingViewAreaTitle, TradingViewConfig, type TradingViewConfigProps, TradingViewFullscreen, type TradingViewInstance, TradingViewKlineStyleSelect, TradingViewLayout, TradingViewOpenIndicator, TradingViewOpenSettings, type TradingViewProps, TradingViewProvider, type TradingViewProviderProps, TradingViewResolutions, TradingViewSnapshot, TradingViewToolbar, type TradingViewToolbarProps, TradingViewToolbarProvider, TradingViewWidgetContainer, TradingViewWidgetProvider, type TvChartConfig, type TvChartContextValue, TvChartErrorResetType, TvChartFeature, TvChartHandle, TvChartKlineStyle, TvChartLayout, TvChartPriceType, TvChartQuoteType, type TvChartResolution, type TvChartSymbol, type TvChartSymbolChange, type TvChartSymbolInfo, TvChartTheme, TvChartType, type WidgetConstructor, chartAreasFamily, chartFullscreenFamily, chartLoadingFamily, chartPinnedResolutionsFamily, chartSelectedIndexFamily, chartShowDrawingToolbarFamily, getTvChartLayoutReverse, getTvChartLibraryLayout, getTvChartLibraryLocale, getTvChartLibraryResolution, getTvChartLibraryTheme, getTvChartResolutionFrame, getTvChartResolutionReverse, getTvChartTickTimestamp, parseSymbol, settingsBackgroundColorFamily, settingsChartTypeFamily, settingsDataFamily, settingsDisabledFeaturesFamily, settingsEnabledFeaturesFamily, settingsLayoutFamily, settingsLocaleFamily, settingsReverseColorFamily, settingsStorageIdFamily, settingsThemeFamily, settingsTickerSymbolFamily, settingsTimezoneFamily, stringifySymbol, stringifySymbolShort, useActiveAreaManager, useChartManager, useSymbolInfo, useTvChartContext, useTvChartManager, useTvChartPrefix, useTvChartToolbarContext, widgetReadyFamily };