@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/widget/components/drawing/DrawingListPanel.d.ts

@@ -0,0 +1,62 @@
+import type { DrawingObject } from "@vninvestcharts/engine-drawing";
+export interface DrawingListPanelLabels {
+    title: string;
+    empty: string;
+    visible: string;
+    hidden: string;
+    locked: string;
+    unlocked: string;
+    selected: string;
+    delete: string;
+    /** Optional search input placeholder; renders a search box when provided. */
+    search?: string;
+    /** CE25: Bulk operations */
+    bulkDelete?: string;
+    bulkGroup?: string;
+    bulkLock?: string;
+    bulkUnlock?: string;
+    bulkHide?: string;
+    bulkShow?: string;
+    groupBy?: string;
+    groupByType?: string;
+    groupByGroupId?: string;
+    selectAll?: string;
+    deselectAll?: string;
+}
+export interface DrawingListPanelProps {
+    drawings: DrawingObject[];
+    selectedId: string | null;
+    labels: DrawingListPanelLabels;
+    embedded?: boolean;
+    position?: {
+        x: number;
+        y: number;
+    };
+    onSelect: (id: string) => void;
+    onToggleVisible: (id: string) => void;
+    onToggleLocked: (id: string) => void;
+    onDelete: (id: string) => void;
+    /** GAP-10: Optional callback to reorder drawings (enables drag-and-drop). */
+    onReorderDrawings?: (reorderedDrawings: DrawingObject[]) => void;
+    /** CE25: Bulk operations */
+    selectedIds?: Set<string>;
+    onSelectMultiple?: (ids: Set<string>) => void;
+    onBulkDelete?: (ids: string[]) => void;
+    onBulkGroup?: (ids: string[], groupId: string) => void;
+    onBulkLock?: (ids: string[], locked: boolean) => void;
+    onBulkHide?: (ids: string[], hidden: boolean) => void;
+    /** P1.3: Inline rename callback */
+    onRename?: (id: string, label: string) => void;
+    /** P1.4: Z-order callbacks */
+    onBringToFront?: (id: string) => void;
+    onSendToBack?: (id: string) => void;
+    /** P1.4: Z-order labels */
+    bringToFrontLabel?: string;
+    sendToBackLabel?: string;
+}
+export declare function generateDrawingLabel(drawing: DrawingObject, t?: (key: string) => string): string;
+/** GAP-10: Filter drawings by case-insensitive match on tool label or custom label. */
+export declare function filterDrawings(drawings: DrawingObject[], query: string, t?: (key: string) => string): DrawingObject[];
+/** GAP-10: Immutably reorder drawings by moving fromId to the position of toId. */
+export declare function reorderDrawings(drawings: DrawingObject[], fromId: string, toId: string): DrawingObject[];
+export default function DrawingListPanel({ drawings, selectedId, labels, embedded, position, onSelect, onToggleVisible, onToggleLocked, onDelete, onReorderDrawings, selectedIds: propSelectedIds, onSelectMultiple, onBulkDelete, onBulkGroup, onBulkLock, onBulkHide, onRename, onBringToFront, onSendToBack, bringToFrontLabel, sendToBackLabel, }: DrawingListPanelProps): import("react").JSX.Element;

package/dist/dts/widget/components/drawing/DrawingSemanticPointLegend.d.ts

@@ -0,0 +1,14 @@
+import type { DrawingObject } from "@vninvestcharts/engine-drawing";
+export interface DrawingSemanticPointLegendLabels {
+    title: string;
+    empty: string;
+    hint: string;
+    clear: string;
+}
+export interface DrawingSemanticPointLegendProps {
+    drawing: DrawingObject | null;
+    labels: DrawingSemanticPointLegendLabels;
+    activePointIndex: number | null;
+    onPointFocusChange: (index: number | null) => void;
+}
+export default function DrawingSemanticPointLegend({ drawing, labels, activePointIndex, onPointFocusChange }: DrawingSemanticPointLegendProps): import("react").JSX.Element;

package/dist/dts/widget/components/drawing/FloatingDrawingInspector.d.ts

@@ -0,0 +1,18 @@
+import type { DrawingObject } from "@vninvestcharts/engine-drawing";
+import type { DrawingInspectorTextEditorProps } from "./DrawingInspector";
+export interface FloatingDrawingInspectorProps {
+    drawing: DrawingObject;
+    isDark: boolean;
+    t: (key: string) => string;
+    textEditor?: DrawingInspectorTextEditorProps;
+    onClose: () => void;
+    onUpdate: (patch: any) => void;
+    onDelete: () => void;
+    onClone: () => void;
+    onToggleLock: () => void;
+    onToggleVisible: () => void;
+    onBringToFront: () => void;
+    onSendToBack: () => void;
+    plotData?: readonly any[];
+}
+export default function FloatingDrawingInspector({ drawing, isDark, t, textEditor, onClose, onUpdate, onDelete, onClone, onToggleLock, onToggleVisible, onBringToFront, onSendToBack, plotData, }: FloatingDrawingInspectorProps): import("react").JSX.Element;

package/dist/dts/widget/components/drawing/IconPickerPanel.d.ts

@@ -0,0 +1,5 @@
+export interface IconPickerPanelProps {
+    value?: string;
+    onSelect: (icon: string) => void;
+}
+export default function IconPickerPanel({ value, onSelect }: IconPickerPanelProps): import("react").JSX.Element;

package/dist/dts/widget/components/drawing/InlineTextEditor.d.ts

@@ -0,0 +1,20 @@
+import type { DrawingObject } from "@vninvestcharts/engine-drawing";
+import type { WidgetPaneRuntimeSnapshot } from "../../utils/widgetHelpers";
+import type { EnrichedDatum } from "../../../lib/core/calculators/types";
+export interface InlineTextEditorProps {
+    selectedDrawing: DrawingObject | null;
+    paneSnapshots: readonly WidgetPaneRuntimeSnapshot[];
+    isEditingText: boolean;
+    drawingTextDraft: string;
+    setDrawingTextDraft: (value: string) => void;
+    handleCommitTextEdit: (commitCallback: (draft: string) => void) => void;
+    handleCancelTextEdit: () => void;
+    handleUpdateDrawing: (id: string, patch: any) => void;
+    plotData: readonly EnrichedDatum[];
+    visibleDomainRef: React.MutableRefObject<[Date, Date] | null>;
+    shellSize: {
+        width: number;
+        height: number;
+    };
+}
+export default function InlineTextEditor({ selectedDrawing, paneSnapshots, isEditingText, drawingTextDraft, setDrawingTextDraft, handleCommitTextEdit, handleCancelTextEdit, handleUpdateDrawing, plotData, visibleDomainRef, shellSize, }: InlineTextEditorProps): import("react").JSX.Element | null;

package/dist/dts/widget/components/drawing/PatternScanPanel.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A10 — the pattern picker.
+ *
+ * PLAN_FRONTEND_PROPLUS_TRACKA_2026-09-28 §3.9. A panel the user opens
+ * deliberately, which is what makes §3.9.4 hold: the scan runs when the user
+ * asks for it, never in the background while they pan or zoom.
+ *
+ * The tier and device gate is not re-implemented here. `auto_pattern` is
+ * already `pro`-gated and already in `DEVICE_HEAVY` in `CapabilityResolver`,
+ * so `CapabilityGate` gives the plan's §3.9.3 (off at `free`, off on mobile)
+ * and §9.1.8 (`LockedFeature`, not a silent hide) for free — and gives them
+ * in the one place they are auditable.
+ *
+ * Every string goes through `t()`. The shape names and the detail line are
+ * the only user-visible text and both are resolved by the host's dictionary.
+ */
+import type { DetectedPattern, PatternBar } from "@vninvestcharts/engine-core";
+export interface PatternScanPanelProps {
+    readonly bars: readonly PatternBar[];
+    /** How many trailing bars are still forming; 1 on a live chart. */
+    readonly formingBars?: number;
+    /** Called with the scan result so the host can create the drawings. */
+    readonly onDraw: (patterns: readonly DetectedPattern[]) => void;
+    /** `false` while the user is panning or zooming — plan §3.9.4. */
+    readonly idle?: boolean;
+}
+export declare function PatternScanPanel({ bars, formingBars, onDraw, idle }: PatternScanPanelProps): React.ReactNode;

package/dist/dts/widget/components/drawing/TemplateManagerPanel.d.ts

@@ -0,0 +1,18 @@
+import type { DrawingObject, DrawingToolType } from "@vninvestcharts/engine-drawing";
+export interface TemplateManagerLabels {
+    loadTemplate?: string;
+    saveAs?: string;
+    deleteTemplate?: string;
+    load?: string;
+    save?: string;
+    delete?: string;
+    namePlaceholder?: string;
+}
+export interface TemplateManagerPanelProps {
+    drawingType: DrawingToolType;
+    drawing?: DrawingObject;
+    locked?: boolean;
+    onUpdate?: (updates: Partial<DrawingObject>) => void;
+    labels?: TemplateManagerLabels;
+}
+export default function TemplateManagerPanel({ drawingType, drawing, locked, onUpdate, labels, }: TemplateManagerPanelProps): import("react").JSX.Element;

package/dist/dts/widget/components/events/CorporateEventsOverlay.d.ts

@@ -0,0 +1,23 @@
+export interface CorporateEvent {
+    id: string;
+    type: "D" | "E" | "N" | "S";
+    timeIndex: number;
+    timestamp: number;
+    date: string;
+    label: string;
+    title: string;
+    description: string;
+    data: Record<string, any>;
+}
+export interface CorporateEventsOverlayProps {
+    events?: readonly CorporateEvent[];
+    showEvents?: boolean;
+    isMobile?: boolean;
+    /**
+     * UI-B: clearance (px) above the X-axis strip so badges stay fully inside
+     * the plot area. Defaults to axis-strip height + 4px gap.
+     */
+    axisClearancePx?: number;
+    onEventClick?: (event: CorporateEvent) => void;
+}
+export declare function CorporateEventsOverlay({ events, showEvents, isMobile, axisClearancePx, onEventClick, }: CorporateEventsOverlayProps): import("react").JSX.Element | null;

package/dist/dts/widget/components/events/EventMarkerIcon.d.ts

@@ -0,0 +1,6 @@
+import React from "react";
+export interface EventMarkerIconProps {
+    type: "D" | "E" | "N" | "S";
+    size?: number;
+}
+export declare const EventMarkerIcon: React.FC<EventMarkerIconProps>;

package/dist/dts/widget/components/footer/ChartFooter.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from "react";
+import type { Timeframe } from "../../../lib/types/adapter";
+import { type ScaleMode } from "./TimeframeFooter";
+export type BottomTabId = "pine_editor" | "strategy_tester" | "paper_trade";
+export interface ChartFooterProps {
+    showFooter?: boolean;
+    renderFooter?: (ctx: {
+        timeframe?: string;
+        range?: string;
+    }) => ReactNode;
+    timeframe: Timeframe;
+    localRange: string | undefined;
+    onTimeframeChange: (tf: Timeframe) => void;
+    onRangeChange: (range: string) => void;
+    scaleMode: ScaleMode;
+    onScaleModeChange: (mode: ScaleMode) => void;
+    timezone: string;
+    t: (key: string) => string | undefined;
+    activeBottomTab: BottomTabId | null;
+    onBottomTabChange: (tab: BottomTabId | null) => void;
+}
+/**
+ * BL-03B extraction from VNInvestCharts.tsx (behavior-identical move).
+ * Footer with timeframe/range/scale controls + bottom-tab toggles.
+ */
+export declare function ChartFooter({ showFooter, renderFooter, timeframe, localRange, onTimeframeChange, onRangeChange, scaleMode, onScaleModeChange, timezone, t, activeBottomTab, onBottomTabChange, }: ChartFooterProps): import("react").JSX.Element;

package/dist/dts/widget/components/footer/MultiChartsFooter.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { LayoutPreset } from '../../grid/types';
+import { BottomTab } from '../BottomPanelHost';
+interface MultiChartsFooterProps {
+    currentLayout: LayoutPreset;
+    onLayoutChange: (preset: LayoutPreset) => void;
+    chartCount: number;
+    activeTab?: BottomTab;
+    onTabChange?: (tab: BottomTab) => void;
+    /** UI-D2: Solo/Grid toggle for the focused chart (shown when provided). */
+    isMaximized?: boolean;
+    onToggleMaximize?: () => void;
+    syncSettings: {
+        visibleRange: boolean;
+        crosshair: boolean;
+        drawings: boolean;
+        symbolLinks: boolean;
+        timeframe: boolean;
+        chartType: boolean;
+        replay: boolean;
+    };
+    onSyncChange: (settings: Partial<MultiChartsFooterProps['syncSettings']>) => void;
+    className?: string;
+    autoHide?: boolean;
+    isChartFocused?: boolean;
+    onSystemMenuOpen?: () => void;
+    activeIndex?: number;
+    onActiveIndexChange?: (index: number) => void;
+    chartsData?: Array<{
+        id: string;
+        symbol: string;
+        timeframe: string;
+    }>;
+    isMobile?: boolean;
+}
+export declare const MultiChartsFooter: React.FC<MultiChartsFooterProps>;
+export default MultiChartsFooter;

package/dist/dts/widget/components/footer/TimeframeFooter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * WE2 P2-04: TimeframeFooter
+ *
+ * Bottom bar with timeframe chips and range selectors.
+ * Uses .vnsc- CSS prefix.
+ */
+import { type ReactNode } from "react";
+import type { Timeframe } from "../../../lib/types/adapter";
+export type ScaleMode = "auto" | "log" | "percent";
+export interface TimeframeFooterProps {
+    timeframe?: Timeframe;
+    onTimeframeChange?: (tf: Timeframe) => void;
+    range?: string;
+    onRangeChange?: (range: string) => void;
+    children?: ReactNode;
+    /** Price scale mode (UI-only until engine log/percent lands in Phase 5b). */
+    scaleMode?: ScaleMode;
+    onScaleModeChange?: (mode: ScaleMode) => void;
+    /** IANA timezone shown as badge (e.g. "Asia/Ho_Chi_Minh" -> "UTC+7"). */
+    timezone?: string;
+    showClock?: boolean;
+    /** UI-AUDIT: trailing node inside the right cluster (e.g. shortcut hint). */
+    trailingNode?: ReactNode;
+}
+export declare function TimeframeFooter({ timeframe, onTimeframeChange, range, onRangeChange, children, scaleMode, onScaleModeChange, timezone, showClock, trailingNode, }: TimeframeFooterProps): import("react").JSX.Element;

package/dist/dts/widget/components/footer/useBarCountdown.d.ts

@@ -0,0 +1,5 @@
+export declare function parseTimeframeIntervalMs(timeframe: string | undefined | null): number | null;
+export declare function formatCountdown(remainingMs: number, intervalMs: number): string;
+export declare function useNow(enabled?: boolean): number;
+/** Remaining time in the current bar as "mm:ss" / "h:mm:ss", or null when N/A. */
+export declare function useBarCountdown(timeframe: string | undefined, now: number): string | null;

package/dist/dts/widget/components/header/OHLCHeader.d.ts

@@ -0,0 +1,72 @@
+import type { ReplayAnalyticsStats } from "../../../lib/core/replay/ReplaySessionAnalytics";
+import type { CrosshairMode } from "@vninvestcharts/engine-core";
+export interface OHLCHeaderProps {
+    symbol?: string;
+    timeframe?: string;
+    chartType?: string;
+    onChartTypeChange?: (chartType: string) => void;
+    replayPlaying?: boolean;
+    replaySpeed?: number;
+    replayCurrentBar?: number;
+    replayTotalBars?: number;
+    onReplayPlay?: () => void;
+    onReplayPause?: () => void;
+    onReplayStop?: () => void;
+    onReplayStepForward?: () => void;
+    onReplayStepBack?: () => void;
+    onReplayRewind?: () => void;
+    onReplaySpeedChange?: (speed: number) => void;
+    onReplaySeek?: (barIndex: number) => void;
+    replayAwaitingStartBar?: boolean;
+    showReplayBar?: boolean;
+    onShowReplayBarChange?: (show: boolean) => void;
+    replayInterval?: string;
+    onReplayStartBarSelect?: (date: Date | number) => void;
+    onReplayEnterSelectionMode?: () => void;
+    onReplayCancelSelection?: () => void;
+    onReplayIntervalChange?: (interval: string) => void;
+    replayTotalPnl?: number;
+    replayAnalytics?: ReplayAnalyticsStats;
+    compareOpen?: boolean;
+    onCompareToggle?: () => void;
+    crosshairMode?: CrosshairMode;
+    onCrosshairModeChange?: (mode: CrosshairMode) => void;
+    showMenu?: boolean;
+    isFullscreen?: boolean;
+    searchOpen?: boolean;
+    onSearchToggle?: () => void;
+    onSettingsClick?: () => void;
+    onFullscreenClick?: () => void;
+    onSnapshotClick?: () => void;
+    onCsvExportClick?: () => void;
+    onAlertsClick?: () => void;
+    onSaveTemplate?: () => void;
+    onLoadTemplate?: () => void;
+    onSystemMenuOpen?: () => void;
+    showLogo?: boolean;
+    showOHLCV?: boolean;
+    showTicker?: boolean;
+    /**
+     * AUTH-03: replay entitlement, resolved by the host widget from the same
+     * feature flag that gates the imperative replay API. Defaults to true so the
+     * header stays a pure presentational component that renders standalone.
+     */
+    canUseReplay?: boolean;
+    showBarChange?: boolean;
+    ohlcData?: {
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume?: number;
+        change?: number;
+        changePercent?: number;
+    };
+    onTimeframeChange?: (timeframe: string) => void;
+    upgradeUrl?: string;
+    quickTimeframes?: string[];
+    isMobile?: boolean;
+    /** Tier PAT đã xác minh — cổng cho chart type pro (`chart_baseline`/`chart_exotic`). */
+    patTier?: string;
+}
+export declare function OHLCHeader({ symbol, timeframe, chartType, onChartTypeChange, replayPlaying, replaySpeed, replayCurrentBar, replayTotalBars, onReplayPlay, onReplayPause, onReplayStop, onReplayStepForward, onReplayStepBack, onReplayRewind, onReplaySpeedChange, onReplaySeek, replayAwaitingStartBar, showReplayBar, onShowReplayBarChange, onReplayStartBarSelect, onReplayEnterSelectionMode, onReplayCancelSelection, replayInterval, onReplayIntervalChange, replayTotalPnl, replayAnalytics, showMenu, isFullscreen, compareOpen, onCompareToggle, crosshairMode, onCrosshairModeChange, searchOpen, onSearchToggle, onSettingsClick, onFullscreenClick, onSnapshotClick, onCsvExportClick, onAlertsClick, onSaveTemplate, onLoadTemplate, onSystemMenuOpen, showLogo, showOHLCV, showTicker, showBarChange, ohlcData, onTimeframeChange, upgradeUrl, quickTimeframes, isMobile, canUseReplay, patTier, }: OHLCHeaderProps): import("react").JSX.Element;

package/dist/dts/widget/components/layout/DrawingConflictNotice.d.ts

@@ -0,0 +1,4 @@
+export interface DrawingConflictNoticeProps {
+    onDismiss: () => void;
+}
+export declare function DrawingConflictNotice({ onDismiss }: DrawingConflictNoticeProps): import("react").JSX.Element;

package/dist/dts/widget/components/layout/GridContainer.d.ts

@@ -0,0 +1,70 @@
+import React from "react";
+import { GridLayout } from "../../grid/types";
+import { type VNInvestChartsProps } from "../../VNInvestCharts";
+import { type CorporateEvent } from "../events/CorporateEventsOverlay";
+import type { FullChartHandle } from "../../types/fullChartHandle";
+import type { DrawingWorkspaceController } from "@vninvestcharts/engine-react";
+import type { MultiChartConfig } from "../../VNInvestMultiCharts";
+/**
+ * TRADEMARK_FIX: style contract for the price-pane header wrapper.
+ * Keeps the left axis/rail clearance from `paneHeaderStyle` but forces the
+ * designed full-bleed right side (⚙ margin-right:88px + trademark absolute
+ * right:12px overlay the right Y gutter). Insetting the right side dragged
+ * the trademark ~48px off the edge in multi-chart cells.
+ */
+export declare function resolvePriceHeaderWrapStyle(paneHeaderStyle: React.CSSProperties | undefined): React.CSSProperties;
+interface GridContainerProps {
+    charts: MultiChartConfig[];
+    layout: GridLayout;
+    activeChartId: string | null;
+    syncSettings: {
+        visibleRange: boolean;
+        crosshair: boolean;
+        drawings: boolean;
+        symbolLinks: boolean;
+        timeframe: boolean;
+        chartType: boolean;
+        replay: boolean;
+        time: boolean;
+    };
+    defaultChartProps: Partial<VNInvestChartsProps>;
+    resizeAdapter?: VNInvestChartsProps["resizeAdapter"];
+    keyboardAdapter?: VNInvestChartsProps["keyboardAdapter"];
+    clockAdapter?: VNInvestChartsProps["clockAdapter"];
+    storageAdapter?: VNInvestChartsProps["storageAdapter"];
+    portalAdapter?: VNInvestChartsProps["portalAdapter"];
+    registryAdapter?: VNInvestChartsProps["registryAdapter"];
+    portalRoot?: HTMLElement | null;
+    shadowRoot?: ShadowRoot | null;
+    chartRefs: React.MutableRefObject<Map<string, React.RefObject<FullChartHandle | null>>>;
+    chartHandles: React.MutableRefObject<Map<string, FullChartHandle>>;
+    setActiveChart: (chartId: string) => void;
+    addChart: (config: MultiChartConfig, row?: number, col?: number) => void;
+    hoverEmitterRefs?: React.MutableRefObject<Map<string, React.RefObject<{
+        current: unknown;
+    } | null>> | {
+        emitterMap?: Map<string, unknown>;
+    }>;
+    onDrawingWorkspaceChange?: (chartId: string, workspace: DrawingWorkspaceController) => void;
+    onLayoutChange?: (layout: GridLayout) => void;
+    onChartConfigChange?: (chartId: string, updates: Partial<MultiChartConfig>) => void;
+    onSymbolSearchClick?: (chartId: string) => void;
+    onComparisonChange?: (chartId: string, overlays: any[]) => void;
+    showSymbolBadges?: boolean;
+    renderRightPanel?: (context: {
+        chartId: string;
+        activeChartHandle: any;
+    }) => React.ReactNode;
+    syncOverrideMap?: Record<string, Record<string, boolean>>;
+    onToggleSyncOverride?: (chartId: string, type: string) => void;
+    showCorporateEvents?: boolean;
+    corporateEvents?: readonly CorporateEvent[];
+    activeTool?: string;
+    /** Khi true, Alt+click luôn chọn replay start bar (truyền từ showReplayBar của multi-chart). */
+    replaySelectionEnabled?: boolean;
+    /** UI-D2: controlled maximize. Khi undefined, GridContainer tự quản lý nội bộ. */
+    maximizedChartId?: string | null;
+    onMaximizedChange?: (chartId: string | null) => void;
+}
+export declare const GridContainer: React.FC<GridContainerProps>;
+export default GridContainer;

package/dist/dts/widget/components/layout/GridSlotErrorBoundary.d.ts

@@ -0,0 +1,17 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+interface GridSlotErrorBoundaryProps {
+    children: ReactNode;
+    chartId: string;
+}
+interface GridSlotErrorBoundaryState {
+    hasError: boolean;
+}
+export declare class GridSlotErrorBoundary extends Component<GridSlotErrorBoundaryProps, GridSlotErrorBoundaryState> {
+    state: GridSlotErrorBoundaryState;
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+export {};

package/dist/dts/widget/components/layout/Splitter.d.ts

@@ -0,0 +1,23 @@
+import React, { type CSSProperties } from "react";
+export type SplitterDirection = "horizontal" | "vertical";
+export interface SplitterProps {
+    direction: SplitterDirection;
+    minSize: number;
+    maxSize: number;
+    onResize: (sizes: number[]) => void;
+    keyboardStep?: number;
+    initialSizes?: number[];
+    className?: string;
+    style?: CSSProperties;
+    "aria-label"?: string;
+    "aria-valuemin"?: number;
+    "aria-valuemax"?: number;
+    "aria-valuenow"?: number;
+    children?: React.ReactNode;
+}
+/**
+ * @deprecated Use `useGridSplitterDrag` for multi-chart grid layouts or `ChartSplitter` for pane layouts.
+ * Generic percentage-based container splitter. Maintained for backwards compatibility.
+ */
+export declare const Splitter: React.FC<SplitterProps>;
+export default Splitter;

package/dist/dts/widget/components/layout/gridSplitterMath.d.ts

@@ -0,0 +1,40 @@
+export declare const MIN_TRACK_PX = 100;
+/**
+ * Resolve a grid-track token ("1fr"/"120px"/"20%") to rendered px so the dragged track can be sized in px even with fr units.
+ */
+export declare function resolveTrackPx(token: string, containerSize: number, allTokens: string[], gap?: number): number;
+/**
+ * Get the current computed or approximated pixel size for a track.
+ */
+export declare function getTrackPixelValue(trackSizes: {
+    rows: string[];
+    cols: string[];
+}, type: 'row' | 'col', index: number, containerEl: HTMLDivElement | null): number;
+export interface NeighborDeltaOptions {
+    baseTracksPx: number[];
+    index: number;
+    deltaPx: number;
+    minPx?: number;
+}
+/**
+ * Zero-sum neighbor compensation:
+ * Track `index` changes by deltaPx, while the adjacent neighbor `nextIndex` absorbs -deltaPx.
+ * Both tracks are clamped to `>= minPx`.
+ * All other tracks remain exactly at their base size. Total px across all tracks is strictly preserved.
+ */
+export declare function applyNeighborDeltaPx({ baseTracksPx, index, deltaPx, minPx, }: NeighborDeltaOptions): number[];
+/**
+ * Convert pixel track sizes to normalized `fr` strings with fixed 2 decimal places.
+ * Uses largest-remainder apportionment (integer hundredths) so the parsed sum
+ * is exactly totalTracks — plain per-track toFixed(2) can drift (e.g. 3.01).
+ */
+export declare function convertPxToFr(tracksPx: number[], totalTracks: number): string[];
+/**
+ * Calculate standard ARIA values (0-100%) for a track splitter separator.
+ */
+export declare function calculateAriaValues(trackPx: number, totalPx: number, minPx?: number): {
+    valueNow: number;
+    valueMin: number;
+    valueMax: number;
+    valueText: string;
+};

package/dist/dts/widget/components/layout/useGridSplitterDrag.d.ts

@@ -0,0 +1,18 @@
+import { type PointerEvent as ReactPointerEvent, type KeyboardEvent as ReactKeyboardEvent } from 'react';
+import type { GridLayout } from '../../grid/types';
+export interface UseGridSplitterDragOptions {
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    layout: GridLayout;
+    onLayoutChange?: (layout: GridLayout) => void;
+    minTrackPx?: number;
+}
+export declare function useGridSplitterDrag({ containerRef, layout, onLayoutChange, minTrackPx, }: UseGridSplitterDragOptions): {
+    trackSizes: {
+        rows: string[];
+        cols: string[];
+    };
+    handlePointerDown: (e: ReactPointerEvent<HTMLDivElement>, type: "row" | "col", index: number) => void;
+    handleKeyDown: (e: ReactKeyboardEvent<HTMLDivElement>, type: "row" | "col", index: number) => void;
+    handleDoubleClick: (type: "row" | "col") => void;
+    isDragging: boolean;
+};

package/dist/dts/widget/components/mobile/MobileChartCarousel.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { MultiChartConfig } from "../../VNInvestMultiCharts";
+interface MobileChartCarouselProps {
+    charts: MultiChartConfig[];
+    activeIndex: number;
+    onChange: (index: number) => void;
+    renderChart: (config: MultiChartConfig, isActive: boolean) => React.ReactNode;
+    activeTool?: string;
+}
+export declare function MobileChartCarousel({ charts, activeIndex, onChange, renderChart, activeTool, }: MobileChartCarouselProps): React.JSX.Element;
+export {};

package/dist/dts/widget/components/mobile/MobileToolbar.d.ts

@@ -0,0 +1,29 @@
+import React from "react";
+import type { PatTier } from "@vninvestcharts/engine-core";
+interface MobileToolbarProps {
+    isOpen: boolean;
+    onClose: () => void;
+    activeTool: string;
+    onToolSelect: (tool: string) => void;
+    timeframes?: string[];
+    activeTimeframe?: string;
+    onTimeframeChange?: (tf: string) => void;
+    portalRoot?: HTMLElement | null;
+    charts?: Array<{
+        id: string;
+        symbol: string;
+        timeframe: string;
+    }>;
+    activeChartId?: string | null;
+    onChartSelect?: (id: string) => void;
+    onSaveWorkspace?: () => void;
+    onThemeToggle?: () => void;
+    isDark?: boolean;
+    activeTab?: "strategy_tester" | "pine_editor" | null;
+    onTabChange?: (tab: "strategy_tester" | "pine_editor" | null) => void;
+    isChartFocused?: boolean;
+    patTier?: PatTier;
+    onPremiumToolClick?: (tool: string) => void;
+}
+export declare function MobileToolbar({ isOpen, onClose, activeTool, onToolSelect, timeframes, activeTimeframe, onTimeframeChange, portalRoot, activeTab, onTabChange, isChartFocused, charts, activeChartId, onChartSelect, patTier, onPremiumToolClick, }: MobileToolbarProps): React.ReactPortal | null;
+export {};

package/dist/dts/widget/components/overlays/AdvisoryPanel.d.ts

@@ -0,0 +1,25 @@
+/**
+ * WE2 P3a-03: AdvisoryPanel (moved from src/lib/advisory/AdvisoryPanel.tsx)
+ *
+ * Pure-presentational panel displaying AI advisory session results.
+ * Data is fetched externally (demo shell → VNInvestClient) and passed
+ * via props so this component has zero API dependency (testable).
+ * All text goes through useWidgetI18n().t() — no hardcoded Vietnamese.
+ *
+ * Layout: vertical card — decision badge + confidence + 4 agent rows + explanation.
+ */
+import type { AdvisoryResult, AdvisorySessionV2 } from "../../../lib/types/vninvest";
+export interface AdvisoryPanelProps {
+    show: boolean;
+    result: AdvisoryResult | null;
+    isLoading: boolean;
+    symbol?: string;
+    onRefresh?: () => void;
+    onClose?: () => void;
+    /**
+     * Follow-up advisory V2: native session from GET .../ai-advisory-session/.
+     * When provided (even empty), the V2 view renders instead of the legacy result view.
+     */
+    session?: AdvisorySessionV2 | null;
+}
+export declare function AdvisoryPanel({ show, result, isLoading, symbol, onRefresh, onClose, session, }: AdvisoryPanelProps): import("react").JSX.Element | null;

package/dist/dts/widget/components/overlays/TapePanel.d.ts

@@ -0,0 +1,25 @@
+/**
+ * WE2 P3a-02: TapePanel (moved from src/lib/tape/TapePanel.tsx)
+ *
+ * Pure-presentational Time-and-Sales (tape) panel.
+ * Data is fetched externally (demo shell) and passed via props.
+ * All text goes through useWidgetI18n().t() — no hardcoded Vietnamese.
+ *
+ * Layout: vertical scrollable list — each row is 22px:
+ *   [time] [price] [volume] [value] [side badge]
+ * Whale rows get a yellow background.
+ * Auto-scrolls to the bottom when new entries arrive.
+ */
+import type { TapeEntry } from "../../../lib/types/vninvest";
+export interface TapePanelProps {
+    show: boolean;
+    /** Ordered list of tape entries — most recent last (appended to bottom). */
+    entries: readonly TapeEntry[];
+    isLoading: boolean;
+    symbol?: string;
+    /** Filter threshold in billion VND — entries below this are hidden (0 = show all). */
+    filterBillions: number;
+    onFilterChange?: (billions: number) => void;
+    onClose?: () => void;
+}
+export declare function TapePanel({ show, entries, isLoading, symbol, filterBillions, onFilterChange, onClose, }: TapePanelProps): import("react").JSX.Element | null;