import { default as default_2 } from 'react';
import { NiceBaseProps } from '@nice2dev/ui-core';
import { NiceSize } from '@nice2dev/ui-core';
import { ReactNode } from 'react';

/**
 * Axis configuration.
 */
declare interface AxisConfig {
    /** Axis title */
    title?: string;
    /** Format function */
    format?: (value: number | Date) => string;
    /** Min value (auto if not set) */
    min?: number;
    /** Max value (auto if not set) */
    max?: number;
    /** Grid lines */
    showGrid?: boolean;
    /** Tick count hint */
    tickCount?: number;
}

/**
 * Cash runway indicator configuration.
 */
declare interface CashRunwayConfig {
    /** Enable cash runway indicator */
    enabled?: boolean;
    /** Threshold value (default: 0) - when forecast crosses this value */
    threshold?: number;
    /** Line color */
    color?: string;
    /** Label text */
    label?: string;
    /** Scenario ID to track (uses first visible scenario if not specified) */
    scenarioId?: string;
    /** Show label at top */
    showLabel?: boolean;
    /** Show exact date in label */
    showDate?: boolean;
}

export declare const CHART_COLORS: string[];

declare interface ChartSuggestion {
    type: SuggestedChartType;
    reason: string;
    config: Record<string, unknown>;
}

/**
 * Confidence band configuration.
 */
declare interface ConfidenceBandConfig {
    /** Confidence level (e.g., 80, 95) */
    level: number;
    /** Fill color */
    color?: string;
    /** Fill opacity (0-1) */
    opacity?: number;
}

/**
 * Annotation marker on the chart.
 */
declare interface ForecastAnnotation {
    /** Unique ID */
    id: string;
    /** Date position */
    date: Date | string | number;
    /** Annotation type */
    type: 'event' | 'anomaly' | 'note' | 'milestone' | 'custom';
    /** Label text */
    label: string;
    /** Description (shown in tooltip) */
    description?: string;
    /** Icon or emoji */
    icon?: string;
    /** Color */
    color?: string;
    /** Show vertical line */
    showLine?: boolean;
}

/**
 * Custom labels for localization.
 */
declare interface ForecastChartLabels {
    actual?: string;
    forecast?: string;
    confidence?: string;
    annotations?: string;
    noData?: string;
    zoomIn?: string;
    zoomOut?: string;
    resetZoom?: string;
    export?: string;
    cashRunsOut?: string;
}

/**
 * Imperative handle for NiceForecastChart.
 */
declare interface ForecastChartRef {
    /** Get current scenarios */
    getScenarios(): ForecastScenario[];
    /** Update scenario data */
    updateScenario(id: string, data: ForecastDataPoint[]): void;
    /** Toggle scenario visibility */
    toggleScenario(id: string): void;
    /** Set zoom range */
    setZoomRange(startDate: Date, endDate: Date): void;
    /** Reset zoom */
    resetZoom(): void;
    /** Export as image */
    exportImage(format: 'png' | 'svg'): string | null;
    /** Get data at date */
    getDataAtDate(date: Date): TooltipData | null;
}

/**
 * Single data point in time series.
 */
declare interface ForecastDataPoint {
    /** Date or timestamp */
    date: Date | string | number;
    /** Actual/historical value */
    value?: number;
    /** Forecast value (if in forecast period) */
    forecast?: number;
    /** Lower confidence bound */
    lowerBound?: number;
    /** Upper confidence bound */
    upperBound?: number;
    /** Additional metadata */
    metadata?: Record<string, any>;
}

/**
 * A forecast scenario for comparison.
 */
declare interface ForecastScenario {
    /** Unique ID */
    id: string;
    /** Display name */
    name: string;
    /** Data points */
    data: ForecastDataPoint[];
    /** Line color */
    color?: string;
    /** Is this the base/main scenario */
    isBase?: boolean;
    /** Confidence interval percentage (e.g., 95) */
    confidenceLevel?: number;
    /** Show confidence band */
    showConfidenceBand?: boolean;
    /** Visible */
    visible?: boolean;
}

/**
 * Legend configuration.
 */
declare interface LegendConfig {
    /** Show legend */
    enabled?: boolean;
    /** Position */
    position?: 'top' | 'bottom' | 'left' | 'right';
    /** Interactive (click to toggle) */
    interactive?: boolean;
}

/** Live data source interface. */
declare interface LiveChartDataSource {
    /** Subscribe to data stream. Returns unsubscribe function. */
    subscribe(onData: (data: LiveDataPoint | LiveDataBatch) => void): () => void;
    /** Optional: fetch historical data for initial load. */
    fetchHistory?(count: number): Promise<LiveDataPoint[]>;
    /** Optional: connection status callback. */
    onStatusChange?(callback: (connected: boolean) => void): () => void;
}

/** Batch of data points (for efficiency). */
declare interface LiveDataBatch {
    points: LiveDataPoint[];
}

/** A single data point from the live source. */
declare interface LiveDataPoint {
    /** Series name this point belongs to. */
    series: string;
    /** The numeric value. */
    value: number;
    /** Timestamp (ISO string or epoch ms). Optional. */
    timestamp?: string | number;
    /** Optional category label (for x-axis). */
    category?: string;
}

export declare const NiceBarGauge: default_2.FC<NiceBarGaugeProps>;

/** An individual bar segment in the {@link NiceBarGauge}. */
declare interface NiceBarGaugeItem {
    /** Numeric value. */
    value: number;
    /** Segment color. */
    color?: string;
    /** Segment label. */
    label?: string;
}

/** Props for the {@link NiceBarGauge} component — a circular segmented bar gauge. */
export declare interface NiceBarGaugeProps extends NiceBaseProps {
    /** Gauge items. */
    items: NiceBarGaugeItem[];
    /** Minimum scale value. */
    min?: number;
    /** Maximum scale value. */
    max?: number;
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Arc start angle in degrees. */
    startAngle?: number;
    /** Arc end angle in degrees. */
    endAngle?: number;
    /** Custom value formatter. */
    formatValue?: (v: number) => string;
    /** Gauge title. */
    title?: string;
}

export declare const NiceBullet: default_2.FC<NiceBulletProps>;

/** Label placement relative to the chart. */
declare type NiceBulletLabelPlacement = 'top' | 'left' | 'right' | 'bottom' | 'none';

/** Props for the {@link NiceBullet} component — a horizontal bullet chart comparing actual vs. target. */
export declare interface NiceBulletProps extends NiceBaseProps {
    /** Actual value. */
    value: number;
    /** Target / goal value. */
    target?: number;
    /** Minimum scale value. */
    min?: number;
    /** Maximum scale value. */
    max?: number;
    /** Chart width in px (overrides size preset). */
    width?: number;
    /** Chart height in px (overrides size preset). */
    height?: number;
    /** Bar color. */
    color?: string;
    /** Target marker color. */
    targetColor?: string;
    /** Size preset (sm/md/lg). Default: `md`. */
    size?: NiceBulletSize;
    /** Optional descriptive label rendered next to the chart. */
    label?: default_2.ReactNode;
    /** Label placement (default `top`). */
    labelPlacement?: NiceBulletLabelPlacement;
    /** Show numeric value text near the bar. */
    showValue?: boolean;
    /** Show target value text near the marker. */
    showTarget?: boolean;
    /** Format the displayed value/target (defaults to `n.toString()`). */
    formatValue?: (n: number) => string;
    /** Visual state. `loading` shows a shimmer, `error` shows the error message. */
    state?: NiceBulletState;
    /** Error text shown when `state="error"`. */
    errorMessage?: string;
}

/** Size variants for {@link NiceBullet}. */
declare type NiceBulletSize = 'sm' | 'md' | 'lg';

/** Visual state of the chart. */
declare type NiceBulletState = 'normal' | 'loading' | 'error';

export declare const NiceChart: default_2.FC<NiceChartProps>;

export declare const NiceChartAI: default_2.ForwardRefExoticComponent<NiceChartAIProps & default_2.RefAttributes<NiceChartAIRef>>;

export declare interface NiceChartAIProps extends Omit<NiceChartProps, 'ref'> {
    /** Raw data for AI analysis (will be converted to series) */
    rawData?: Record<string, unknown>[];
    /** Enable AI features (requires NiceAIProvider) */
    enableAI?: boolean;
    /** AI model to use */
    aiModel?: string;
    /** Enable automatic chart type suggestion */
    enableAutoType?: boolean;
    /** Enable AI-powered insights */
    enableInsights?: boolean;
    /** Description of the data for better AI suggestions */
    dataDescription?: string;
    /** Callback when AI suggests a chart type */
    onChartSuggestion?: (suggestion: ChartSuggestion) => void;
    /** Callback when AI generates insights */
    onInsights?: (insights: string[]) => void;
    /** Show AI toolbar */
    showAIToolbar?: boolean;
    /** Initially show insights */
    showInsightsOnLoad?: boolean;
}

declare interface NiceChartAIRef {
    /** Get suggested chart type */
    getSuggestion: () => Promise<ChartSuggestion>;
    /** Generate insights */
    generateInsights: () => Promise<string[]>;
    /** Get current chart type */
    getCurrentType: () => SuggestedChartType;
}

/** An annotation (reference line or label) overlaid on a {@link NiceChart}. */
declare interface NiceChartAnnotation {
    type: 'line' | 'label';
    /** For 'line': y-value to draw horizontal line at. For 'label': x-index. */
    value: number;
    label?: string;
    color?: string;
    dash?: string;
}

/**
 * Props for the NiceChart component — an SVG-based bar, line, and area chart
 * with stacking, zoom, crosshair, annotations, legend interaction and PNG export.
 */
export declare interface NiceChartProps extends NiceBaseProps {
    series: NiceChartSeries[];
    categories?: string[];
    width?: number;
    height?: number;
    title?: string;
    showLegend?: boolean;
    /** Show gridlines (horizontal lines at Y ticks). Defaults to true. */
    showGrid?: boolean;
    /** Show axis tick labels (Y values, X categories). Defaults to true. */
    axisLabels?: boolean;
    showTooltip?: boolean;
    yAxisLabel?: string;
    xAxisLabel?: string;
    stacked?: boolean;
    /** Animate series on initial render. */
    animated?: boolean;
    /** Enable zoom/pan via mouse wheel and drag. */
    zoomable?: boolean;
    /** Show crosshair line at mouse position. */
    crosshair?: boolean;
    /** Annotations: horizontal lines, labels on chart. */
    annotations?: NiceChartAnnotation[];
    /** Click legend items to toggle series visibility. */
    legendInteractive?: boolean;
    /** Called when a data point is clicked for drill-down. */
    onDataPointClick?: (seriesName: string, dataIndex: number, value: number) => void;
    /** Show export button to download chart as PNG. */
    exportable?: boolean;
}

/** A single data series in a {@link NiceChart}. */
declare interface NiceChartSeries {
    name: string;
    data: number[];
    color?: string;
    type?: 'bar' | 'line' | 'area' | 'scatter' | 'radar';
}

export declare const NiceCircularGauge: default_2.FC<NiceCircularGaugeProps>;

/** Props for the {@link NiceCircularGauge} component — an arc-based circular gauge with configurable ranges. */
export declare interface NiceCircularGaugeProps extends NiceBaseProps {
    /** Current gauge value. */
    value: number;
    /** Minimum scale value. */
    min?: number;
    /** Maximum scale value. */
    max?: number;
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Arc start angle in degrees. */
    startAngle?: number;
    /** Arc end angle in degrees. */
    endAngle?: number;
    /** Active arc color. */
    color?: string;
    /** Background track color. */
    trackColor?: string;
    /** Center label text. */
    label?: string;
    /** Custom value formatter. */
    formatValue?: (v: number) => string;
    /** Colored range segments. */
    ranges?: {
        start: number;
        end: number;
        color: string;
    }[];
}

/**
 * NiceForecastChart — Time series chart with forecast and confidence intervals.
 *
 * @example
 * ```tsx
 * <NiceForecastChart
 *   scenarios={[
 *     {
 *       id: 'base',
 *       name: 'Base Forecast',
 *       isBase: true,
 *       data: historicalAndForecastData,
 *       showConfidenceBand: true,
 *       confidenceLevel: 95,
 *     },
 *     {
 *       id: 'optimistic',
 *       name: 'Optimistic',
 *       data: optimisticData,
 *     },
 *   ]}
 *   forecastStartDate={new Date('2026-01-01')}
 *   annotations={[
 *     { id: '1', date: '2025-06-15', type: 'event', label: 'Product Launch' }
 *   ]}
 * />
 * ```
 */
export declare const NiceForecastChart: default_2.ForwardRefExoticComponent<NiceForecastChartProps & default_2.RefAttributes<ForecastChartRef>>;

/**
 * Props for NiceForecastChart component.
 */
export declare interface NiceForecastChartProps extends NiceBaseProps {
    /** Scenarios to display */
    scenarios?: ForecastScenario[];
    /** Convenience flat data series — wrapped into a single scenario when `scenarios` is omitted. */
    data?: ForecastDataPoint[];
    /** Annotations */
    annotations?: ForecastAnnotation[];
    /** Reference lines */
    referenceLines?: ReferenceLine[];
    /** Forecast start date (where dashed line begins) */
    forecastStartDate?: Date | string | number;
    /** Cash runway indicator (shows where cash runs out) */
    cashRunway?: CashRunwayConfig;
    /** X-axis config */
    xAxis?: AxisConfig;
    /** Y-axis config */
    yAxis?: AxisConfig;
    /** Default confidence bands */
    confidenceBands?: ConfidenceBandConfig[];
    /** Tooltip config */
    tooltip?: TooltipConfig;
    /** Legend config */
    legend?: LegendConfig;
    /** Chart height */
    height?: number | string;
    /** Show forecast region shading */
    showForecastRegion?: boolean;
    /** Forecast region color */
    forecastRegionColor?: string;
    /** Line width */
    lineWidth?: number;
    /** Show data points */
    showPoints?: boolean;
    /** Point radius */
    pointRadius?: number;
    /** Enable zoom */
    enableZoom?: boolean;
    /** Alias for `enableZoom`. */
    zoomEnabled?: boolean;
    /** Enable pan */
    enablePan?: boolean;
    /** Animation duration (ms) */
    animationDuration?: number;
    /** Show the legend (alias affecting `legend.visible`). */
    showLegend?: boolean;
    /** Responsive */
    responsive?: boolean;
    /** Called when a point is clicked */
    onPointClick?: (point: ForecastDataPoint, scenario: ForecastScenario) => void;
    /** Called when an annotation is clicked */
    onAnnotationClick?: (annotation: ForecastAnnotation) => void;
    /** Called when scenario visibility changes */
    onScenarioToggle?: (scenarioId: string, visible: boolean) => void;
    /** Called when zoom/pan changes */
    onViewportChange?: (startDate: Date, endDate: Date) => void;
    /** Component size */
    size?: NiceSize;
    /** Disabled state */
    disabled?: boolean;
    /** Custom labels */
    labels?: ForecastChartLabels;
    /** Locale for formatting */
    locale?: string;
    /** Additional class name */
    className?: string;
    /** Inline styles */
    style?: default_2.CSSProperties;
}

export declare const NiceFunnel: default_2.FC<NiceFunnelProps>;

/** A stage in the {@link NiceFunnel} chart. */
declare interface NiceFunnelItem {
    /** Stage label. */
    label: string;
    /** Stage value. */
    value: number;
    /** Stage color. */
    color?: string;
}

/** Props for the {@link NiceFunnel} component — an SVG funnel / pyramid chart. */
export declare interface NiceFunnelProps extends NiceBaseProps {
    /** Funnel stage data. */
    data: NiceFunnelItem[];
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Invert to pyramid (narrow at top). */
    inverted?: boolean;
    /** Show labels. */
    showLabels?: boolean;
    /** Show numeric values. */
    showValues?: boolean;
    /** Chart title. */
    title?: string;
}

export declare const NiceHeatMap: default_2.ForwardRefExoticComponent<NiceHeatMapProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceHeatMap} component — a 2D color-intensity grid with optional cell click. */
export declare interface NiceHeatMapProps extends NiceBaseProps {
    /** 2D data matrix (rows × cols). */
    data: number[][];
    /** Column header labels. */
    xLabels?: string[];
    /** Row header labels. */
    yLabels?: string[];
    /** Color scale as [min color, max color]. */
    colors?: [string, string];
    /** Called when a cell is clicked. */
    onCellClick?: (row: number, col: number, value: number) => void;
    /** Cell size in px. */
    cellSize?: number;
    /** Show numeric values inside cells. */
    showValues?: boolean;
}

export declare const NiceLinearGauge: default_2.FC<NiceLinearGaugeProps>;

/** Props for the {@link NiceLinearGauge} component — a horizontal or vertical bar gauge with ticks and colored ranges. */
export declare interface NiceLinearGaugeProps extends NiceBaseProps {
    /** Current gauge value. */
    value: number;
    /** Minimum scale value. */
    min?: number;
    /** Maximum scale value. */
    max?: number;
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Gauge orientation. */
    orientation?: 'horizontal' | 'vertical';
    /** Bar color. */
    color?: string;
    /** Label text. */
    label?: string;
    /** Custom value formatter. */
    formatValue?: (v: number) => string;
    /** Colored range segments. */
    ranges?: {
        start: number;
        end: number;
        color: string;
    }[];
    /** Show tick marks. */
    showTicks?: boolean;
    /** Number of tick marks. */
    tickCount?: number;
}

export declare const NiceLiveChart: default_2.ForwardRefExoticComponent<NiceLiveChartProps & default_2.RefAttributes<NiceLiveChartRef>>;

/** Props for NiceLiveChart component. */
export declare interface NiceLiveChartProps extends NiceBaseProps {
    /** Series configuration. Each series receives its own data stream. */
    series: NiceLiveChartSeriesConfig[];
    /** Maximum number of data points to keep per series. Default: 100. */
    maxPoints?: number;
    /** Enable sliding window (auto-remove old points). Default: true. */
    slidingWindow?: boolean;
    /** Target refresh rate in ms. Default: 16 (60fps). */
    refreshRate?: number;
    /** Data source for live updates. */
    dataSource?: LiveChartDataSource;
    /** Chart width. Default: 600. */
    width?: number;
    /** Chart height. Default: 400. */
    height?: number;
    /** Chart title. */
    title?: string;
    /** Show legend. Default: true. */
    showLegend?: boolean;
    /** Show grid lines. Default: true. */
    showGrid?: boolean;
    /** Y-axis label. */
    yAxisLabel?: string;
    /** X-axis label. */
    xAxisLabel?: string;
    /** Enable stacked chart. */
    stacked?: boolean;
    /** Enable zoom/pan. */
    zoomable?: boolean;
    /** Show crosshair. */
    crosshair?: boolean;
    /** Annotations overlay. */
    annotations?: NiceChartAnnotation[];
    /** Interactive legend. */
    legendInteractive?: boolean;
    /** Data point click callback. */
    onDataPointClick?: (seriesName: string, dataIndex: number, value: number) => void;
    /** Enable PNG export. */
    exportable?: boolean;
    /** Show play/pause button. Default: true. */
    showControls?: boolean;
    /** Show connection status indicator. Default: true. */
    showStatus?: boolean;
    /** Initial paused state. Default: false. */
    initialPaused?: boolean;
    /** Called when new data arrives. */
    onDataReceived?: (point: LiveDataPoint) => void;
    /** Called when buffer is full and old data is dropped. */
    onDataDropped?: (droppedCount: number, seriesName: string) => void;
    /** Time format for x-axis categories. Default: "HH:mm:ss". */
    timeFormat?: 'HH:mm:ss' | 'HH:mm' | 'mm:ss' | 'ss.SSS' | 'ISO';
    /** Show statistics overlay (min, max, avg, current). */
    showStats?: boolean;
    /** Threshold lines for visual indicators. */
    thresholds?: Array<{
        value: number;
        color: string;
        label?: string;
        style?: 'solid' | 'dashed' | 'dotted';
    }>;
}

/** Ref methods exposed by NiceLiveChart. */
declare interface NiceLiveChartRef {
    /** Pause live updates. */
    pause(): void;
    /** Resume live updates. */
    resume(): void;
    /** Check if currently paused. */
    isPaused(): boolean;
    /** Clear all data. */
    clear(): void;
    /** Add a data point manually. */
    addPoint(point: LiveDataPoint): void;
    /** Add multiple points at once. */
    addPoints(points: LiveDataPoint[]): void;
    /** Get current data for a series. */
    getData(seriesName: string): number[];
    /** Get all categories (timestamps). */
    getCategories(): string[];
    /** Export current data as JSON. */
    exportData(): {
        series: NiceChartSeries[];
        categories: string[];
    };
    /** Get statistics for a series. */
    getStats(seriesName: string): {
        min: number;
        max: number;
        avg: number;
        current: number;
        count: number;
    } | null;
}

/** Configuration for a live data series. */
declare interface NiceLiveChartSeriesConfig {
    /** Series identifier (used to match incoming data). */
    name: string;
    /** Display color. */
    color?: string;
    /** Chart type for this series. */
    type?: 'bar' | 'line' | 'area';
    /** Initial data points (optional). */
    initialData?: number[];
}

/** A geographic region rendered by the {@link NiceVectorMap}. */
declare interface NiceMapRegion {
    /** Unique region identifier (e.g. ISO code). */
    id: string;
    /** Display name. */
    name: string;
    /** SVG path data. */
    path: string;
    /** Data value (drives color intensity). */
    value?: number;
}

export declare const NiceOrganizationChart: default_2.ForwardRefExoticComponent<NiceOrganizationChartProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceOrganizationChart} component — a hierarchical org chart with optional node selection and collapsible branches. */
export declare interface NiceOrganizationChartProps extends NiceBaseProps {
    /** Root node. */
    data: NiceOrgNode;
    /** Custom node renderer. */
    renderNode?: (node: NiceOrgNode) => default_2.ReactNode;
    /** Enable node selection. */
    selectable?: boolean;
    /** Currently selected node key. */
    selectedKey?: string;
    /** Called when a node is selected. */
    onSelect?: (key: string) => void;
    /** Tree layout direction. */
    direction?: 'top-down' | 'left-right';
    /** Allow branches to be collapsed. */
    collapsible?: boolean;
}

/** A node in the {@link NiceOrganizationChart} hierarchy. */
declare interface NiceOrgNode {
    /** Unique key. */
    key: string;
    /** Node label. */
    label: string;
    /** Child nodes. */
    children?: NiceOrgNode[];
    /** Additional data fields. */
    [x: string]: any;
}

export declare const NicePieChart: default_2.FC<NicePieChartProps>;

/** Props for the {@link NicePieChart} component — an SVG pie / donut chart with legend and labels. */
export declare interface NicePieChartProps extends NiceBaseProps {
    /** Slice data. */
    data: NicePieSlice[];
    /** Chart width in px. */
    width?: number;
    /** Chart height in px. */
    height?: number;
    /** Inner radius (> 0 → donut). */
    innerRadius?: number;
    /** Chart title. */
    title?: string;
    /** Show the legend. */
    showLegend?: boolean;
    /** Show percentage labels on slices. */
    showLabels?: boolean;
}

/** A slice in the {@link NicePieChart}. */
declare interface NicePieSlice {
    /** Slice label. */
    label: string;
    /** Numeric value. */
    value: number;
    /** Slice fill color. */
    color?: string;
}

export declare const NicePolarChart: default_2.FC<NicePolarChartProps>;

/** Props for the {@link NicePolarChart} component — an SVG radar / spider chart. */
export declare interface NicePolarChartProps extends NiceBaseProps {
    /** Series definitions. */
    series: NicePolarChartSeries[];
    /** Axis category labels. */
    categories: string[];
    /** Chart width in px. */
    width?: number;
    /** Chart height in px. */
    height?: number;
    /** Max axis value (auto-calculated if omitted). */
    maxValue?: number;
    /** Chart title. */
    title?: string;
    /** Show the legend. */
    showLegend?: boolean;
}

/** A data series in the {@link NicePolarChart} (radar / spider chart). */
declare interface NicePolarChartSeries {
    /** Series name. */
    name: string;
    /** Data values (one per category). */
    data: number[];
    /** Series color. */
    color?: string;
    /** Fill the area under the series line. */
    fill?: boolean;
}

export declare const NiceRangeSelector: default_2.FC<NiceRangeSelectorProps>;

/** Props for the {@link NiceRangeSelector} component — a dual-handle range slider with optional sparkline background. */
export declare interface NiceRangeSelectorProps extends NiceBaseProps {
    /** Sparkline data rendered behind the handles. */
    data?: number[];
    /** Minimum selectable value. */
    min: number;
    /** Maximum selectable value. */
    max: number;
    /** Current start of the selected range. */
    start: number;
    /** Current end of the selected range. */
    end: number;
    /** Called when the range changes. */
    onChange: (start: number, end: number) => void;
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Step increment. */
    step?: number;
    /** Custom value formatter. */
    formatValue?: (v: number) => string;
    /** Sparkline fill color. */
    chartColor?: string;
}

export declare const NiceSankey: default_2.FC<NiceSankeyProps>;

/** A flow link between two {@link NiceSankeyNode} entries. */
declare interface NiceSankeyLink {
    /** Source node id. */
    source: string;
    /** Target node id. */
    target: string;
    /** Flow magnitude. */
    value: number;
}

/** A node in the {@link NiceSankey} diagram. */
declare interface NiceSankeyNode {
    /** Unique identifier. */
    id: string;
    /** Node label. */
    label: string;
    /** Node color. */
    color?: string;
}

/** Props for the {@link NiceSankey} component — an SVG Sankey flow diagram. */
export declare interface NiceSankeyProps extends NiceBaseProps {
    /** Node definitions. */
    nodes: NiceSankeyNode[];
    /** Link definitions. */
    links: NiceSankeyLink[];
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Node rectangle width in px. */
    nodeWidth?: number;
    /** Vertical padding between nodes. */
    nodePadding?: number;
    /** Chart title. */
    title?: string;
}

export declare const NiceSparkline: default_2.FC<NiceSparklineProps>;

/** Props for the {@link NiceSparkline} component — a compact inline chart (line, bar, or area). */
export declare interface NiceSparklineProps extends NiceBaseProps {
    /** Data values. */
    data: number[];
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Chart type. */
    type?: 'line' | 'bar' | 'area';
    /** Line / bar color. */
    color?: string;
    /** Highlight min and max points. */
    showMinMax?: boolean;
    /** Highlight the last data point. */
    showLastPoint?: boolean;
}

export declare const NiceStockChart: default_2.ForwardRefExoticComponent<NiceStockChartProps & default_2.RefAttributes<HTMLDivElement>>;

/** Props for the {@link NiceStockChart} component — an SVG candlestick / OHLC / line stock chart with optional volume bars. */
export declare interface NiceStockChartProps extends NiceBaseProps {
    /** OHLC data points. */
    data: NiceStockDataPoint[];
    /** Chart type. */
    type?: NiceStockChartType;
    /** Show volume bars below the price chart. */
    showVolume?: boolean;
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Color for bullish candles. */
    bullColor?: string;
    /** Color for bearish candles. */
    bearColor?: string;
}

/** Chart type for the {@link NiceStockChart}. */
declare type NiceStockChartType = 'candlestick' | 'ohlc' | 'line';

/** A single OHLC data point in the {@link NiceStockChart}. */
declare interface NiceStockDataPoint {
    /** Date string (e.g. "2024-01-15"). */
    date: string;
    /** Opening price. */
    open: number;
    /** Highest price. */
    high: number;
    /** Lowest price. */
    low: number;
    /** Closing price. */
    close: number;
    /** Optional trading volume. */
    volume?: number;
}

export declare const NiceTreeMap: default_2.ForwardRefExoticComponent<NiceTreeMapProps & default_2.RefAttributes<HTMLDivElement>>;

/** A hierarchical node in the {@link NiceTreeMap}. */
declare interface NiceTreeMapNode {
    /** Unique key. */
    key: string;
    /** Node label. */
    label: string;
    /** Numeric weight (determines area). */
    value: number;
    /** Node color. */
    color?: string;
    /** Child nodes. */
    children?: NiceTreeMapNode[];
}

/** Props for the {@link NiceTreeMap} component — a squarified treemap visualization. */
export declare interface NiceTreeMapProps extends NiceBaseProps {
    /** Root node. */
    data: NiceTreeMapNode;
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** Called when a leaf node is clicked. */
    onNodeClick?: (node: NiceTreeMapNode) => void;
    /** Color palette. */
    colors?: string[];
}

export declare const NiceVectorMap: default_2.FC<NiceVectorMapProps>;

/** Props for the {@link NiceVectorMap} component — an SVG choropleth map with region selection and tooltips. */
export declare interface NiceVectorMapProps extends NiceBaseProps {
    /** Region definitions. */
    regions: NiceMapRegion[];
    /** SVG width in px. */
    width?: number;
    /** SVG height in px. */
    height?: number;
    /** SVG viewBox (overrides width/height). */
    viewBox?: string;
    /** Color scale as [min color, max color]. */
    colorRange?: [string, string];
    /** Maximum data value (for color interpolation). */
    maxValue?: number;
    /** Called when a region is clicked. */
    onRegionClick?: (region: NiceMapRegion) => void;
    /** Currently selected region id. */
    selectedRegionId?: string;
    /** Map title. */
    title?: string;
    /** Show tooltip on hover. */
    showTooltip?: boolean;
}

/**
 * Reference line.
 */
declare interface ReferenceLine {
    /** Unique ID */
    id: string;
    /** Y value */
    value: number;
    /** Label */
    label?: string;
    /** Color */
    color?: string;
    /** Dash pattern */
    dashArray?: string;
}

declare type SuggestedChartType = 'line' | 'bar' | 'area' | 'pie' | 'donut' | 'scatter';

/**
 * Tooltip configuration.
 */
declare interface TooltipConfig {
    /** Show tooltip */
    enabled?: boolean;
    /** Custom renderer */
    render?: (data: TooltipData) => ReactNode;
    /** Date format */
    dateFormat?: string;
    /** Value format */
    valueFormat?: (value: number) => string;
}

/**
 * Data passed to tooltip renderer.
 */
declare interface TooltipData {
    /** Date */
    date: Date;
    /** Values by scenario */
    values: Array<{
        scenario: ForecastScenario;
        value: number | undefined;
        forecast: number | undefined;
        lowerBound: number | undefined;
        upperBound: number | undefined;
    }>;
    /** Annotations at this date */
    annotations: ForecastAnnotation[];
}

export { }
