@sia.soul/sia-react-ui 0.1.0

package/dist/chart.d.ts

@@ -0,0 +1,2061 @@
+import * as react from 'react';
+import { ReactNode, CSSProperties, HTMLAttributes, SVGAttributes, PointerEvent } from 'react';
+
+interface ChartWhirlingLoadingProps {
+    width?: number;
+    height?: number;
+    text?: string;
+    /** Measured text width in viewBox units; omitted uses a CJK-aware estimate. */
+    textWidth?: number;
+    /** Deterministic frame for previews/tests. Live mode advances every 50 ms. */
+    frame?: number;
+}
+/** A native SVG chart loading layer: ring, rotating droplet and fixed inner dot. */
+declare function ChartWhirlingLoading({ width, height, text, textWidth, frame }: ChartWhirlingLoadingProps): react.JSX.Element;
+
+type Point = readonly [number, number];
+interface SvgMapPlotProps {
+    source: string;
+    name: string;
+    data: readonly {
+        name: string;
+        value?: number;
+        hoverable?: boolean;
+        showLabel?: boolean;
+    }[];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    domain: readonly [number, number];
+    range?: readonly [number, number];
+    colors: readonly string[];
+    labelOffsets?: Readonly<Record<string, readonly number[]>>;
+    hoverRange?: readonly [number, number];
+    onHoverValue?: (value: number | undefined) => void;
+    roam?: boolean;
+    resetKey?: number;
+    children?: ReactNode;
+    lineAnimation?: boolean;
+    tooltipNameOnly?: boolean;
+    showLabels?: boolean;
+    pointAnimation?: boolean;
+    pointEntrance?: boolean;
+    pointAnimationEasing?: 'linear' | 'exponential-out';
+    markPoints?: readonly {
+        id?: string;
+        name: string;
+        value?: number | string;
+        coordinate: Point;
+        label?: string;
+        labelColor?: string;
+        fontSize?: number;
+        borderWidth?: number;
+        size?: number;
+        effectColor?: string;
+        effect?: boolean;
+        color?: string;
+        symbol?: 'pin' | 'circle' | 'emptyCircle';
+    }[];
+    markLines?: readonly {
+        id?: string;
+        name: string;
+        value?: number;
+        source: Point;
+        target: Point;
+        period?: number;
+        effectColor?: string;
+        shadowBlur?: number;
+        color?: string;
+        effectRadius?: number;
+        endpointSymbols?: readonly string[];
+    }[];
+}
+/** SVG-native map geometry, without geographic projection or source markup insertion. */
+declare function SvgMapPlot({ source, name, data, x, y, width, height, domain, range, colors, labelOffsets, hoverRange, onHoverValue, roam, resetKey, children, markPoints, markLines, lineAnimation, tooltipNameOnly, showLabels, pointAnimation, pointEntrance, pointAnimationEasing }: SvgMapPlotProps): react.JSX.Element;
+
+interface ChartRoamControllerProps {
+    x?: number;
+    y?: number;
+    onPan: (x: number, y: number) => void;
+    onZoom: (factor: number) => void;
+}
+/** Independent SVG controls; deliberately separate from direct map gestures. */
+declare function ChartRoamController({ x, y, onPan, onZoom }: ChartRoamControllerProps): react.JSX.Element;
+
+interface ChartBrushProps {
+    selectionShape?: 'band' | 'rectangle';
+    selectionStyle?: CSSProperties;
+    /** Minimum accepted width and height in SVG coordinates. Omitted preserves the 4px horizontal gesture threshold. */
+    minSelectionSize?: readonly [number, number];
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    onSelect: (range: readonly [number, number]) => void;
+    onCancel?: () => void;
+}
+
+declare function svgArcPath(cx: number, cy: number, outerRadius: number, startAngle: number, endAngle: number, innerRadius?: number, clockwise?: boolean): string;
+
+declare const CHART_VIEWBOX_WIDTH = 720;
+declare const CHART_VIEWBOX_HEIGHT = 360;
+declare const DEFAULT_CHART_PALETTE: readonly ["#1677ff", "#36cfc9", "#52c41a", "#faad14", "#ff7a45", "#722ed1", "#eb2f96", "#13c2c2", "#2f54eb", "#a0d911"];
+interface ChartLegendItem {
+    image?: string;
+    textStyle?: CSSProperties;
+    /** Optional measured label width in SVG coordinates. */
+    textWidth?: number;
+    /** Override the group's symbol for mixed-series legends. */
+    symbol?: 'rect' | 'line' | 'sector';
+    fillGradient?: {
+        start: readonly [number, number];
+        end: readonly [number, number];
+        stops: readonly {
+            offset: number;
+            color: string;
+        }[];
+    };
+    borderColor?: string;
+    name: string;
+    color: string;
+    disabled?: boolean;
+}
+interface ChartDataClickInfo<T = unknown> {
+    name: string;
+    value: number | readonly number[];
+    seriesName?: string;
+    data: T;
+    nativeEvent: PointerEvent<SVGGElement>;
+}
+interface SiaChartRef {
+    getElement: () => SVGSVGElement | null;
+    focus: () => void;
+    toSvgString: () => string | null;
+    toDataUrl: () => string | null;
+}
+interface SiaChartProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    titleAlign?: "left" | "center" | "right";
+    titleVerticalAlign?: "top" | "bottom";
+    viewBoxSize?: readonly [number, number];
+    children?: ReactNode;
+    /** Additional SVG content above chart series and below interaction overlays. */
+    svgOverlay?: ReactNode;
+    width?: number | string;
+    height?: number | string;
+    title?: ReactNode;
+    description?: ReactNode;
+    ariaLabel?: string;
+    palette?: readonly string[];
+    loading?: boolean;
+    empty?: boolean;
+    emptyContent?: ReactNode;
+    animation?: boolean;
+    animationDuration?: number;
+    toolbox?: boolean | ChartToolboxOptions;
+    timeline?: ChartTimelineProps;
+    brush?: ChartBrushProps;
+    tooltipProps?: Omit<ChartTooltipProps, "open" | "left" | "top" | "children">;
+    /** undefined uses local marks; null hides; a value synchronizes an external tooltip. */
+    controlledTooltip?: {
+        content: ReactNode;
+        point: readonly [number, number];
+    } | null;
+    svgProps?: Omit<SVGAttributes<SVGSVGElement>, "children" | "width" | "height">;
+}
+interface ChartCompositeLayer {
+    key?: string;
+    content: ReactNode;
+    left?: number | string;
+    top?: number | string;
+    width?: number | string;
+    height?: number | string;
+    zIndex?: number;
+    pointerEvents?: CSSProperties["pointerEvents"];
+}
+interface ChartCompositeRef {
+    toSvgString: () => string | null;
+    saveAsImage: (filename?: string) => Promise<void>;
+}
+interface ChartCompositeProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    layers: readonly ChartCompositeLayer[];
+    width?: number | string;
+    height?: number | string;
+    ariaLabel?: string;
+}
+type ChartToolboxFeature = "dataZoom" | "mark" | "dataView" | "restore" | "saveAsImage";
+interface ChartToolboxOptions {
+    verticalAlign?: 'top' | 'bottom';
+    onSaveAsImage?: () => void;
+    show?: boolean;
+    orientation?: "horizontal" | "vertical";
+    features?: readonly ChartToolboxFeature[];
+    magicTypes?: readonly string[];
+    activeMagicType?: string;
+    /** Selected options across independent mode groups; takes precedence for button display. */
+    activeMagicTypes?: readonly string[];
+    filename?: string;
+    dataView?: ReactNode;
+    dataViewReadOnly?: boolean;
+    onZoom?: () => void;
+    onZoomBack?: () => void;
+    zoomBackDisabled?: boolean;
+    zoomActive?: boolean;
+    onMark?: () => void;
+    onMagicTypeChange?: (type: string) => void;
+    onRestore?: () => void;
+}
+interface ChartToolboxProps extends ChartToolboxOptions {
+    markActive?: boolean;
+    markCount?: number;
+    onMarkUndo?: () => void;
+    onMarkClear?: () => void;
+    onDataView: () => void;
+    onSaveAsImage: () => void;
+}
+declare const ChartComposite: react.ForwardRefExoticComponent<ChartCompositeProps & react.RefAttributes<ChartCompositeRef>>;
+interface ChartTooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Axis placement follows category x / pointer y and applies measured edge corrections. */
+    placement?: 'above' | 'axis';
+    /** Let semantic title/value elements inherit the tooltip's font and color. */
+    inheritTextStyle?: boolean;
+    /** Keep item details available for pointer and keyboard interaction. */
+    enterable?: boolean;
+    open: boolean;
+    left: number;
+    top: number;
+    children: ReactNode;
+}
+declare function ChartTooltip({ open, left, top, children, enterable, inheritTextStyle, placement, className, style, ...props }: ChartTooltipProps): react.JSX.Element | null;
+declare function ChartToolbox({ show, orientation, verticalAlign, features, magicTypes, activeMagicType, activeMagicTypes, markActive, markCount, onMarkUndo, onMarkClear, onMark, onZoom, onZoomBack, zoomBackDisabled, zoomActive, onMagicTypeChange, onRestore, onDataView, onSaveAsImage, }: ChartToolboxProps): react.JSX.Element | null;
+declare const SiaChart: react.ForwardRefExoticComponent<SiaChartProps & react.RefAttributes<SiaChartRef>>;
+interface ChartMarkProps extends SVGAttributes<SVGGElement> {
+    tooltip?: ReactNode;
+    tooltipPoint?: readonly [number, number];
+    label: string;
+}
+declare function ChartMark({ tooltip, tooltipPoint, label, onPointerMove, onPointerLeave, onFocus, onBlur, ...props }: ChartMarkProps): react.JSX.Element;
+interface ChartLegendProps {
+    iconWidth?: number;
+    iconHeight?: number;
+    textGap?: number;
+    textStyle?: CSSProperties;
+    inactiveColor?: string;
+    background?: {
+        fill?: string;
+        stroke?: string;
+        strokeWidth?: number;
+        padding?: number;
+    };
+    maxWidth?: number;
+    rowGap?: number;
+    symbol?: "rect" | "line" | "sector";
+    items: readonly ChartLegendItem[];
+    x?: number;
+    y?: number;
+    align?: "start" | "center" | "end";
+    itemGap?: number;
+    orientation?: "horizontal" | "vertical";
+    selected?: Readonly<Record<string, boolean>>;
+    onItemClick?: (name: string) => void;
+}
+declare function ChartLegend({ items, symbol, x, y, align, itemGap, orientation, selected, onItemClick, maxWidth, rowGap, iconWidth, iconHeight, textGap, textStyle, inactiveColor, background }: ChartLegendProps): react.JSX.Element;
+interface ChartAxisProps {
+    /** Split axis strokes from bands/ticks/labels when a chart needs explicit layer ordering. */
+    layer?: 'all' | 'base' | 'line';
+    splitAreaColors?: readonly string[];
+    /** Normalized band boundaries; defaults to evenly spaced intervals. */
+    splitAreaPositions?: readonly number[];
+    lineStyle?: CSSProperties;
+    tickStyle?: CSSProperties;
+    gridStyle?: CSSProperties;
+    labelStyle?: CSSProperties;
+    labelStyles?: readonly (CSSProperties | undefined)[];
+    /** Distance from the axis line to the label (independent of tick length). */
+    labelMargin?: number;
+    labelAnchor?: 'start' | 'middle' | 'end';
+    labelBaseline?: 'top' | 'middle' | 'bottom';
+    boundaryGap?: boolean;
+    orientation: "top" | "bottom" | "left" | "right";
+    x: number;
+    y: number;
+    length: number;
+    labels: readonly string[];
+    /** Normalized positions for nonuniform numeric/calendar ticks. */
+    positions?: readonly number[];
+    tickPositions?: readonly number[];
+    gridPositions?: readonly number[];
+    /** Snap line centers to whole/half pixels according to their stroke width. Labels and bands are unaffected. */
+    pixelAlign?: boolean;
+    /** Outward distance of the axis stroke and tick origin from the logical axis. */
+    lineOffset?: number;
+    tickOffset?: number;
+    tickSize?: number;
+    gridLength?: number;
+    formatter?: (label: string, index: number) => string;
+    inverse?: boolean;
+    tickInterval?: number;
+    labelRotate?: number;
+    showLine?: boolean;
+    showTicks?: boolean;
+    showLabels?: boolean;
+    showGrid?: boolean;
+    name?: string;
+    axisColor?: string;
+    gridColor?: string;
+    dashedGrid?: boolean;
+}
+declare function ChartAxis({ layer, orientation, x, y, length, labels, positions, tickPositions, gridPositions, pixelAlign, lineOffset, tickOffset, boundaryGap, tickSize, gridLength, formatter, inverse, tickInterval, labelRotate, showLine, showTicks, showLabels, showGrid, name, axisColor, gridColor, dashedGrid, lineStyle, tickStyle, gridStyle, labelStyle, labelStyles, labelMargin, labelAnchor, labelBaseline, splitAreaColors, splitAreaPositions }: ChartAxisProps): react.JSX.Element;
+interface ChartVisualMapProps {
+    realtime?: boolean;
+    onHoverRange?: (range: readonly [number, number] | undefined) => void;
+    indicatorValue?: number;
+    svgHandles?: boolean;
+    endLabels?: readonly [string, string];
+    min: number;
+    max: number;
+    colors?: readonly string[];
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    label?: string;
+    orientation?: "horizontal" | "vertical";
+    calculable?: boolean;
+    value?: number;
+    onChange?: (value: number) => void;
+    range?: readonly [number, number];
+    onRangeChange?: (range: [number, number]) => void;
+    pieces?: readonly {
+        min?: number;
+        max?: number;
+        label?: string;
+        color: string;
+    }[];
+    selectedPieces?: readonly boolean[];
+    onPieceToggle?: (index: number) => void;
+}
+declare function ChartVisualMap({ min, max, colors, x, y, width, height, label, endLabels, indicatorValue, onHoverRange, realtime, svgHandles, orientation, calculable, value, onChange, range, onRangeChange, pieces, selectedPieces, onPieceToggle }: ChartVisualMapProps): react.JSX.Element;
+interface ChartDataZoomProps {
+    handleLabels?: readonly [ReactNode, ReactNode];
+    shadowBounds?: {
+        width: number;
+        height: number;
+    };
+    panEnabled?: boolean;
+    value: readonly [number, number];
+    min?: number;
+    max?: number;
+    ariaLabel?: string;
+    orientation?: "horizontal" | "vertical";
+    dataShadow?: readonly number[];
+    showDetail?: boolean;
+    minSpan?: number;
+    formatter?: (value: number) => ReactNode;
+    onChange: (value: [number, number]) => void;
+}
+declare function ChartDataZoom({ value, min, max, ariaLabel, orientation, dataShadow, showDetail, minSpan, formatter, onChange, panEnabled, shadowBounds, handleLabels }: ChartDataZoomProps): react.JSX.Element;
+interface ChartTimelineProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    renderer?: 'html' | 'nodes';
+    dates?: readonly string[];
+    x?: number;
+    y?: number;
+    width?: number;
+    labels: readonly string[];
+    value: number;
+    onChange: (index: number) => void;
+    autoPlay?: boolean;
+    playInterval?: number;
+    loop?: boolean;
+}
+declare function ChartTimeline({ labels, value, onChange, autoPlay, playInterval, loop, className, ...props }: ChartTimelineProps): react.JSX.Element;
+declare function chartColor(index: number, palette?: readonly string[]): string;
+declare function formatChartNumber(value: number): string;
+declare function niceChartDomain(values: readonly number[], includeZero?: boolean, splitNumber?: number, preferredSteps?: readonly number[]): [number, number, number];
+declare function chartTicks(domain: readonly [number, number, number]): number[];
+declare function linearScale(value: number, domain: readonly [number, number], range: readonly [number, number]): number;
+
+declare function smoothSvgPath(points: readonly (readonly [number, number])[]): string;
+
+interface LineShareChartProps extends Omit<SiaChartProps, 'children'> {
+    data: readonly {
+        name: string;
+        value: number;
+    }[];
+    lineColor?: string;
+    shareColor?: string;
+}
+/** A shifted area line and a masked share ring retain distinct displayed/raw values. */
+declare const LineShareChart: react.ForwardRefExoticComponent<LineShareChartProps & react.RefAttributes<SiaChartRef>>;
+
+interface ChartValueAddress {
+    chart: string;
+    series: number;
+    index: number;
+}
+type ChartValueTransferHandler = (source: ChartValueAddress, target: ChartValueAddress) => boolean;
+interface ChartValueChannel {
+    id: string;
+    series: readonly {
+        name: string;
+        data: readonly (number | null)[];
+    }[];
+    nonNegative?: boolean;
+}
+/** Validate and calculate both sides before publishing either chart's new state. */
+declare function transferCompositeValue(channels: readonly ChartValueChannel[], source: ChartValueAddress, target: ChartValueAddress): {
+    series: (Omit<{
+        name: string;
+        data: readonly (number | null)[];
+    }, "data"> & {
+        data: (number | null)[];
+    })[];
+    id: string;
+    nonNegative?: boolean;
+}[];
+
+interface ChartValueIslandProps {
+    name: string;
+    value: number;
+    x: number;
+    y: number;
+    color?: string;
+    onDrop: (target: ChartValueAddress | null, point: readonly [number, number]) => void;
+    resolveTarget?: (element: SVGGElement, x: number, y: number) => ChartValueAddress | null;
+}
+/** SVG island representing a value already removed from its source series. */
+declare function ChartValueIsland({ name, value, x, y, color, onDrop, resolveTarget }: ChartValueIslandProps): react.JSX.Element;
+
+/** Stacked chart panels retain their actual document positions and inter-panel gaps. */
+declare function serializeChartStack(host: HTMLElement): string | null;
+declare function saveCompositeImage(source: string | null, filename?: string): Promise<void>;
+
+/** Finite data extent plus proportional padding, before nice-tick rounding. */
+declare function paddedValueExtent(values: readonly number[], padding?: number): readonly [number, number];
+
+interface ChartDataEditorProps<T extends number | null = number> {
+    series: readonly {
+        name: string;
+        data: readonly T[];
+    }[];
+    onApply: (values: T[][]) => void;
+    allowNull?: boolean;
+    readOnly?: boolean;
+}
+/** Numeric data editor. JSON is parsed as data, never evaluated as JavaScript. */
+declare function ChartDataEditor<T extends number | null = number>({ series, onApply, readOnly, allowNull }: ChartDataEditorProps<T>): react.JSX.Element;
+
+type XYPoint = readonly [number, number, number?];
+interface XYSeries {
+    name: string;
+    data: readonly XYPoint[];
+    curve?: "smooth" | "straight";
+    symbolRadius?: number | ((point: XYPoint) => number);
+    color?: string;
+    geometry?: "line" | "bar";
+    barOrientation?: "vertical" | "horizontal";
+    barSize?: number;
+    statistics?: boolean;
+}
+interface XYChartProps extends Omit<SiaChartProps, "children"> {
+    series: readonly XYSeries[];
+    xDomain?: readonly [number, number, number];
+    yDomain?: readonly [number, number, number];
+    animationProgress?: number;
+    calculable?: boolean;
+    xAxisType?: "value" | "time";
+    xFormatter?: (value: number) => string;
+    tooltipFormatter?: (point: XYPoint, series: XYSeries) => ReactNode;
+    dataZoom?: boolean;
+    defaultZoom?: readonly [number, number];
+    onZoomChange?: (value: readonly [number, number]) => void;
+    onDataChange?: (series: readonly XYSeries[]) => void;
+}
+/** Two genuinely numeric axes; bar direction belongs to the series, not the chart. */
+declare const XYChart: react.ForwardRefExoticComponent<XYChartProps & react.RefAttributes<SiaChartRef>>;
+
+type MapOverlayEvent = 'moving' | 'moveend' | 'zoomend' | 'resize';
+interface MapOverlaySnapshot {
+    width: number;
+    height: number;
+    project: (coordinate: readonly [number, number]) => readonly [number, number];
+    offset?: readonly [number, number];
+}
+/** A host adapter owns only the map instance it creates, never a shared map. */
+interface MapOverlayHost {
+    snapshot: () => MapOverlaySnapshot;
+    subscribe: (event: MapOverlayEvent, listener: () => void) => () => void;
+    destroy: () => void;
+}
+
+interface ChartMapOverlayProps {
+    /** Keep this factory stable. It must return an adapter for a newly owned host instance. */
+    createHost: (element: HTMLDivElement) => MapOverlayHost;
+    children: (snapshot: MapOverlaySnapshot) => ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    ariaLabel?: string;
+    onError?: (error: unknown) => void;
+}
+/** Mounts the external base map separately from the Sia chart's transparent overlay. */
+declare function ChartMapOverlay({ createHost, children, className, style, ariaLabel, onError }: ChartMapOverlayProps): react.JSX.Element;
+
+interface BaiduMapPoint {
+    lng: number;
+    lat: number;
+}
+interface BaiduMapInstance {
+    centerAndZoom: (point: BaiduMapPoint, zoom: number) => void;
+    enableScrollWheelZoom: () => void;
+    disableScrollWheelZoom: () => void;
+    disableDragging: () => void;
+    disableAutoResize: () => void;
+    clearOverlays: () => void;
+    getSize: () => {
+        width: number;
+        height: number;
+    };
+    pointToPixel: (point: BaiduMapPoint) => {
+        x: number;
+        y: number;
+    };
+    setMapStyle: (style: {
+        styleJson: readonly unknown[];
+    }) => void;
+    addEventListener: (event: string, listener: () => void) => void;
+    removeEventListener: (event: string, listener: () => void) => void;
+}
+interface BaiduMapNamespace {
+    Map: new (element: HTMLElement, options: {
+        enableMapClick: boolean;
+    }) => BaiduMapInstance;
+    Point: new (longitude: number, latitude: number) => BaiduMapPoint;
+}
+interface BaiduMapHostOptions {
+    center: readonly [number, number];
+    zoom: number;
+    styleJson?: readonly unknown[];
+    /** Optional SDK-version-specific cleanup. v2 has no documented Map.destroy API. */
+    releaseMap?: (map: BaiduMapInstance) => void;
+}
+/** Uses a caller-provided SDK; never loads scripts, keys or a chart runtime. */
+declare function createBaiduMapHost(element: HTMLElement, sdk: BaiduMapNamespace, options: BaiduMapHostOptions): MapOverlayHost;
+
+interface ChartPulseRingProps {
+    center: readonly [number, number];
+    radius: number;
+    scaleSize?: number;
+    color?: string;
+    shadowBlur?: number;
+    period?: number;
+    progress?: number;
+    enabled?: boolean;
+}
+
+interface MixedBarSpacing {
+    /** Fraction of each category band reserved between category groups. */
+    categoryGap: number;
+    /** Gap between series, as a fraction of the automatic bar width. */
+    seriesGap: number;
+    /** Use two-decimal layout measurements and integer rectangle bounds. */
+    pixelAlign?: boolean;
+}
+
+interface MixedValueDomainOptions {
+    boundaryGap?: readonly [number, number];
+    splitNumber?: number;
+    /** Select a readable step near this count without forcing exactly that many sections. */
+    targetSplitNumber?: number;
+    /** Positive, ascending decimal step mantissas; 10 is always available as a fallback. */
+    preferredSteps?: readonly number[];
+}
+
+interface LargeMapPointCanvasGroup {
+    name: string;
+    color: string;
+    size: number;
+    symbol: 'rect' | 'diamond';
+    points: readonly (readonly [number, number])[];
+}
+
+interface MatrixChordAppearance {
+    borderColor?: string;
+    borderWidth?: number;
+    hoverBorderColor?: string;
+    hoverBorderWidth?: number;
+    labelDistance?: number;
+    markers?: readonly {
+        name: string;
+        value: number;
+        x: number;
+        y: number;
+        size: number;
+        color?: string;
+    }[];
+}
+
+/** Parameters of the native solver, not a promise of ECharts physics equivalence. */
+interface ForceLayoutOptions {
+    stepsPerFrame?: number;
+    model?: 'native' | 'legacy';
+    width?: number;
+    height?: number;
+    coolDown?: number;
+    minRadius?: number;
+    maxRadius?: number;
+    seed?: number;
+    center?: {
+        x: number;
+        y: number;
+    };
+    gravity?: number;
+    scaling?: number;
+    linkDistance?: number;
+    iterations?: number;
+    weightedLinks?: boolean;
+    maxNodes?: number;
+}
+
+interface HeatGradientStop {
+    offset: number;
+    color: readonly [number, number, number];
+}
+interface HeatRasterOptions {
+    radius?: number;
+    blur?: number;
+    minAlpha?: number;
+    valueScale?: number;
+    opacity?: number;
+    gradient?: readonly HeatGradientStop[];
+}
+
+interface CloudBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+interface TreeItemStyle {
+    color?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    brushType?: 'fill' | 'stroke' | 'both';
+    label?: {
+        show?: boolean;
+        position?: 'inside' | 'right' | 'left' | 'top' | 'bottom';
+        formatter?: string;
+        color?: string;
+        fontSize?: number;
+        fontWeight?: string | number;
+    };
+}
+
+/** Per-region overrides are resolved independently for normal and emphasized states. */
+interface MapRegionAppearance {
+    regionStyle?: CSSProperties;
+    emphasisRegionStyle?: CSSProperties;
+    labelStyle?: CSSProperties;
+    emphasisLabelStyle?: CSSProperties;
+    showLabels?: boolean;
+    showEmphasisLabels?: boolean;
+}
+
+type BundlePoint = readonly [number, number];
+interface BundleEdge {
+    source: BundlePoint;
+    target: BundlePoint;
+}
+
+interface BundledMapLines {
+    edges: readonly BundleEdge[];
+    points?: readonly BundlePoint[];
+    smoothness?: number;
+    color?: string;
+    opacity?: number;
+    lineWidth?: number;
+    pointColor?: string;
+    pointRadius?: number;
+    effect?: {
+        period?: number;
+        color?: string;
+        radius?: number;
+        shadowBlur?: number;
+        shadowColor?: string;
+        alpha?: number;
+    };
+}
+
+type MapSpecialArea = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+
+interface TreemapLayoutBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+interface CartesianIsland {
+    name: string;
+    value: number;
+    seriesName: string;
+}
+
+declare function useBarValueTransfer(series: readonly BarSeries[], initial: readonly BarSeries[], categories: readonly string[], enabled: boolean, publish: (next: readonly BarSeries[]) => void, onError?: (message: string) => void): {
+    islands: (CartesianIsland & {
+        x: number;
+        y: number;
+    })[];
+    props: (row: number, index: number) => {
+        'data-bar-transfer-series'?: undefined;
+        'data-bar-transfer-index'?: undefined;
+        style?: undefined;
+        transform?: undefined;
+        onPointerDown?: undefined;
+        onPointerMove?: undefined;
+        onPointerCancel?: undefined;
+        onPointerUp?: undefined;
+    } | {
+        'data-bar-transfer-series': number;
+        'data-bar-transfer-index': number;
+        style: {
+            cursor: string;
+            touchAction: string;
+            pointerEvents: "none" | undefined;
+        };
+        transform: string | undefined;
+        onPointerDown: (event: PointerEvent<SVGGElement>) => void;
+        onPointerMove: (event: PointerEvent<SVGGElement>) => void;
+        onPointerCancel: () => void;
+        onPointerUp: (event: PointerEvent<SVGGElement>) => void;
+    };
+    reset: () => void;
+};
+
+interface ChartSeries {
+    name: string;
+    data: readonly number[];
+    color?: string;
+}
+interface CartesianChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    categories: readonly string[];
+    series: readonly ChartSeries[];
+    showLegend?: boolean;
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    valueFormatter?: (value: number) => ReactNode;
+    onDataClick?: (info: ChartDataClickInfo<number>) => void;
+}
+type LinePoint = readonly [number | string | Date, number];
+interface LineSeries extends Omit<ChartSeries, "data"> {
+    labelStyle?: CSSProperties;
+    emphasisLabelStyle?: CSSProperties;
+    showEmphasisLabels?: boolean;
+    labelFormatter?: (value: number, category: string, index: number) => ReactNode;
+    emphasisLabelFormatter?: (value: number, category: string, index: number) => ReactNode;
+    pointStyles?: readonly {
+        color?: string;
+        emphasisColor?: string;
+        symbolSize?: number;
+        symbol?: LineSeries['symbol'];
+        symbolImage?: string;
+        symbolRotate?: number;
+        labelPosition?: 'inside' | 'top';
+        emphasisLabelPosition?: 'inside' | 'top';
+        showLabel?: boolean;
+        showEmphasisLabel?: boolean;
+        labelStyle?: CSSProperties;
+        emphasisLabelStyle?: CSSProperties;
+    }[];
+    emphasisColor?: string;
+    fillGradient?: BarLinearGradient;
+    areaGradient?: BarLinearGradient;
+    lineShadow?: {
+        color: string;
+        blur: number;
+        offsetX?: number;
+        offsetY?: number;
+    };
+    statisticLines?: readonly ('average' | 'min' | 'max')[];
+    data: readonly (number | LinePoint)[];
+    stack?: string;
+    curve?: "straight" | "smooth" | "step";
+    area?: boolean;
+    showPoints?: boolean;
+    markAverage?: boolean;
+    markMin?: boolean;
+    markMax?: boolean;
+    showLabels?: boolean;
+    lineStyle?: "solid" | "dashed" | "dotted";
+    lineWidth?: number;
+    symbol?: "circle" | "square" | "diamond" | "none" | "star" | "star6" | "heart" | "emptyHeart" | "droplet" | "pin" | "emptyPin" | "arrow" | "emptyCircle" | "image";
+    symbolImage?: string;
+    symbolRotate?: number;
+    symbolSize?: number;
+    hollowSymbol?: boolean;
+    markPoints?: readonly {
+        name: string;
+        index: number;
+        value: number;
+        label?: string;
+    }[];
+}
+interface LineChartProps extends Omit<CartesianChartProps, "series"> {
+    calculableMode?: 'resize' | 'transfer';
+    onTransferError?: (message: string) => void;
+    grid?: {
+        left?: number;
+        top?: number;
+        right?: number;
+        bottom?: number;
+    };
+    /** Shared value-transfer controller for composed chart mode switches. */
+    valueTransfer?: ReturnType<typeof useBarValueTransfer>;
+    categoryLabelInterval?: number | 'auto';
+    boundaryGap?: boolean;
+    showCategorySplitLine?: boolean;
+    categoryAxisName?: string;
+    valueAxisName?: string;
+    legendLayout?: {
+        x?: number;
+        y?: number;
+        align?: "start" | "center" | "end";
+    };
+    logBase?: number;
+    logExponentStep?: number;
+    appearance?: "sia" | "macarons";
+    animationProgress?: number;
+    animationDurationUpdate?: number;
+    valueDomain?: readonly [number, number, number];
+    axisLabelFormatter?: (value: number) => string;
+    series: readonly LineSeries[];
+    stacked?: boolean;
+    orientation?: "vertical" | "horizontal";
+    xAxisType?: "category" | "value" | "time";
+    valueAxisType?: "value" | "log";
+    valueAxisInverse?: boolean;
+    tooltipTrigger?: "item" | "axis";
+    dataZoom?: boolean;
+    /** Percentage windows can address array slices rather than point-to-point distances. */
+    zoomIndexMode?: 'points' | 'slice';
+    zoomPosition?: 'top' | 'bottom';
+    zoomControlBounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    zoomPan?: boolean;
+    zoomSelectionShape?: 'band' | 'rectangle';
+    zoomSelectionStyle?: CSSProperties;
+    zoomMinSelectionSize?: readonly [number, number];
+    calculable?: boolean;
+    zoom?: readonly [number, number];
+    defaultZoom?: readonly [number, number];
+    onZoomChange?: (value: [number, number]) => void;
+    onDataChange?: (series: readonly LineSeries[]) => void;
+}
+declare const LineChart: react.ForwardRefExoticComponent<LineChartProps & react.RefAttributes<SiaChartRef>>;
+interface BarLinearGradient {
+    start: readonly [number, number];
+    end: readonly [number, number];
+    stops: readonly {
+        offset: number;
+        color: string;
+    }[];
+}
+interface BarDatum {
+    /** Radius used by the corresponding point after switching to a line chart. */
+    symbolSize?: number;
+    showLabel?: boolean;
+    showEmphasisLabel?: boolean;
+    labelStyle?: CSSProperties;
+    emphasisLabelStyle?: CSSProperties;
+    emphasisLabelPosition?: BarDatum['labelPosition'];
+    fillGradient?: BarLinearGradient;
+    emphasisFillGradient?: BarLinearGradient;
+    emphasisColor?: string;
+    emphasisBorderColor?: string;
+    emphasisBorderWidth?: number;
+    value: number;
+    start?: number;
+    color?: string;
+    opacity?: number;
+    label?: ReactNode;
+    hidden?: boolean;
+    borderColor?: string;
+    borderWidth?: number;
+    labelPosition?: "top" | "bottom" | "left" | "right" | "inside" | "insideTop" | "insideRight" | "insideLeft";
+}
+interface BarSeries extends Omit<ChartSeries, "data"> {
+    statisticLines?: readonly ('average' | 'min' | 'max')[];
+    showEmphasisLabels?: boolean;
+    labelStyle?: CSSProperties;
+    emphasisLabelStyle?: CSSProperties;
+    emphasisLabelPosition?: BarDatum['labelPosition'];
+    emphasisLabelFormatter?: (value: number, category: string, index: number) => ReactNode;
+    fillGradient?: BarLinearGradient;
+    emphasisFillGradient?: BarLinearGradient;
+    emphasisColor?: string;
+    emphasisBorderColor?: string;
+    emphasisBorderWidth?: number;
+    /** Share a category slot without stacking values (overlapping comparison bars). */
+    overlayGroup?: string;
+    data: readonly (number | BarDatum)[];
+    radius?: number;
+    stack?: string;
+    showLabels?: boolean;
+    opacity?: number;
+    barWidth?: number;
+    markAverage?: boolean;
+    markMin?: boolean;
+    markMax?: boolean;
+    showInLegend?: boolean;
+    borderColor?: string;
+    borderWidth?: number;
+    labelColor?: string;
+    labelFormatter?: (value: number, category: string, index: number) => ReactNode;
+    labelPosition?: BarDatum["labelPosition"];
+    markRange?: boolean;
+    markPoints?: readonly {
+        index: number;
+        value: number;
+        label?: string;
+    }[];
+}
+interface BarChartProps extends Omit<CartesianChartProps, "series"> {
+    /** Shared data/island owner when composed as another Cartesian chart's mode. */
+    valueTransfer?: ReturnType<typeof useBarValueTransfer>;
+    calculableMode?: 'resize' | 'transfer';
+    onTransferError?: (message: string) => void;
+    legendOrder?: readonly string[];
+    legendLayout?: {
+        x?: number;
+        y?: number;
+        itemGap?: number;
+        rows?: number;
+    };
+    barCategoryGap?: number;
+    valuePadding?: number;
+    grid?: {
+        left?: number;
+        top?: number;
+        right?: number;
+        bottom?: number;
+    };
+    valueAxisPosition?: "top" | "bottom";
+    appearance?: "sia" | "macarons";
+    animationProgress?: number;
+    animationDurationUpdate?: number;
+    valueDomain?: readonly [number, number, number];
+    axisLabelFormatter?: (value: number) => string;
+    showValueAxis?: boolean;
+    showCategoryAxis?: boolean;
+    showCategorySplitLine?: boolean;
+    tooltipTrigger?: "item" | "axis";
+    tooltipFormatter?: (name: string, values: readonly {
+        name: string;
+        value: number;
+        color: string;
+    }[]) => ReactNode;
+    series: readonly BarSeries[];
+    stacked?: boolean;
+    orientation?: "vertical" | "horizontal";
+    minBarSize?: number;
+    calculable?: boolean;
+    onDataChange?: (series: readonly BarSeries[]) => void;
+}
+declare const BarChart: react.ForwardRefExoticComponent<BarChartProps & react.RefAttributes<SiaChartRef>>;
+interface ScatterDatum {
+    emphasisColor?: string;
+    emphasisBorderWidth?: number;
+    symbolFill?: string;
+    showLabel?: boolean;
+    showEmphasisLabel?: boolean;
+    label?: ReactNode;
+    labelFormatter?: (item: ScatterDatum) => ReactNode;
+    labelStyle?: CSSProperties;
+    symbolImage?: string;
+    symbolRotate?: number;
+    borderWidth?: number;
+    /** Optional third data dimension, independent of the rendered symbol radius. */
+    value?: number;
+    name?: string;
+    x: number;
+    y: number;
+    size?: number;
+    color?: string;
+    category?: string;
+    symbol?: "circle" | "square" | "diamond" | "emptyCircle" | "emptyTriangle" | "image";
+}
+interface ScatterVisualMap {
+    calculable?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    selectable?: boolean;
+    dimension: "x" | "y" | "size" | "value";
+    pieces?: readonly {
+        min: number;
+        max: number;
+        color: string;
+        label?: string;
+    }[];
+    x?: number;
+    y?: number;
+    width?: number;
+    min?: number;
+    max?: number;
+    colors?: readonly [string, string];
+    label?: string;
+}
+interface ScatterChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    symbolAnimation?: boolean;
+    animationProgress?: number;
+    animationDurationUpdate?: number;
+    statisticPoints?: readonly {
+        name: string;
+        dimension: 'x' | 'y';
+        kind: 'min' | 'max';
+        category?: string;
+        symbol?: 'pin' | 'arrow';
+        color?: string;
+        borderColor?: string;
+        size?: number;
+    }[];
+    statisticLines?: readonly {
+        name: string;
+        dimension: 'x' | 'y';
+        category?: string;
+        color?: string;
+    }[];
+    /** Fixed coordinate annotations, separate from editable scatter values. */
+    annotations?: readonly {
+        name: string;
+        x: number;
+        y: number;
+        value: number;
+        category?: string;
+        radius?: number;
+        color?: string;
+    }[];
+    showXAxis?: boolean;
+    showXSplitLine?: boolean;
+    showYSplitLine?: boolean;
+    tooltipFormatter?: (item: ScatterDatum) => ReactNode;
+    markColor?: string;
+    xDomain?: readonly [number, number, number];
+    yDomain?: readonly [number, number, number];
+    showPointLabels?: boolean;
+    yAxisPosition?: 'left' | 'right';
+    xCategories?: readonly number[];
+    xFormatter?: (value: number) => string;
+    crosshair?: boolean;
+    /** Pin extrema and value-only mean labels used by legacy reference charts. */
+    markAppearance?: 'label' | 'pin';
+    xSplitNumber?: number;
+    ySplitNumber?: number;
+    symbolSize?: (item: ScatterDatum) => number;
+    markByCategory?: boolean;
+    xUnit?: string;
+    yUnit?: string;
+    minSymbolRadius?: number;
+    plotBounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    data: readonly ScatterDatum[];
+    xLabel?: string;
+    yLabel?: string;
+    xAxisType?: "value" | "time";
+    showLegend?: boolean;
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    dataZoom?: boolean;
+    zoom?: readonly [number, number];
+    defaultZoom?: readonly [number, number];
+    onZoomChange?: (value: [number, number]) => void;
+    visualMap?: ScatterVisualMap;
+    markAverage?: "x" | "y" | "both";
+    markExtremes?: boolean;
+    largeThreshold?: number;
+    onDataClick?: (info: ChartDataClickInfo<ScatterDatum>) => void;
+}
+declare const ScatterChart: react.ForwardRefExoticComponent<ScatterChartProps & react.RefAttributes<SiaChartRef>>;
+interface CandlestickDatum {
+    name: string;
+    open: number;
+    close: number;
+    low: number;
+    high: number;
+    volume?: number;
+    color?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    emphasisColor?: string;
+}
+interface CandlestickChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    /** Hide axes when sharing a plot with another chart layer. */
+    showAxes?: boolean;
+    valueDomain?: readonly [number, number, number];
+    axisLabelFormatter?: (value: number) => string;
+    /** Index into the full input data; null explicitly clears a controlled highlight. */
+    activeIndex?: number | null;
+    onActiveIndexChange?: (index: number | null) => void;
+    seriesVisible?: boolean;
+    onSeriesVisibilityChange?: (visible: boolean) => void;
+    showLegend?: boolean;
+    showCategoryLabels?: boolean;
+    plotBounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    markPoints?: readonly {
+        name: string;
+        date: string;
+        value: number;
+        y: number;
+        color?: string;
+    }[];
+    seriesName?: string;
+    risingBorderColor?: string;
+    fallingBorderColor?: string;
+    borderWidth?: number;
+    risingEmphasisColor?: string;
+    fallingEmphasisColor?: string;
+    maxBarWidth?: number;
+    appearance?: 'sia' | 'macarons';
+    data: readonly CandlestickDatum[];
+    risingColor?: string;
+    fallingColor?: string;
+    hollowRising?: boolean;
+    dataZoom?: boolean;
+    zoom?: readonly [number, number];
+    defaultZoom?: readonly [number, number];
+    onZoomChange?: (value: [number, number]) => void;
+    markExtremes?: boolean;
+    onDataClick?: (info: ChartDataClickInfo<CandlestickDatum>) => void;
+}
+declare const CandlestickChart: react.ForwardRefExoticComponent<CandlestickChartProps & react.RefAttributes<SiaChartRef>>;
+interface PieRadialGradient {
+    center: readonly [number, number];
+    innerRadius?: number;
+    outerRadius: number;
+    stops: readonly {
+        offset: number;
+        color: string;
+    }[];
+}
+interface PieLabelOptions {
+    labelFormatter?: (item: PieDatum, percent: number) => string;
+    emphasisLabelFormatter?: (item: PieDatum, percent: number) => string;
+    labelStyle?: CSSProperties;
+    emphasisLabelStyle?: CSSProperties;
+    showEmphasisLabel?: boolean;
+    labelLine?: {
+        show?: boolean;
+        length?: number;
+        style?: CSSProperties;
+    };
+    emphasisLabelLine?: {
+        show?: boolean;
+        length?: number;
+        style?: CSSProperties;
+    };
+}
+interface PieDatum extends PieLabelOptions {
+    /** Missing source slot after a calculable transfer; not a zero-valued slice. */
+    missing?: boolean;
+    showLabel?: boolean;
+    gradient?: PieRadialGradient;
+    emphasisGradient?: PieRadialGradient;
+    emphasisColor?: string;
+    name: string;
+    value: number;
+    color?: string;
+    selected?: boolean;
+    showInLegend?: boolean;
+    interactive?: boolean;
+}
+interface PieSeries extends PieLabelOptions {
+    emphasisGradient?: PieRadialGradient;
+    /** SVG degrees; overrides the chart angle for this ring only. */
+    startAngle?: number;
+    centerLabel?: ReactNode;
+    name?: string;
+    data: readonly PieDatum[];
+    innerRadius?: number;
+    outerRadius?: number;
+    rose?: boolean | "radius" | "area";
+    showLabels?: boolean;
+    center?: readonly [number, number];
+    labelPosition?: "outside" | "inside";
+    emphasisLabel?: "center" | "outside";
+    selectedMode?: false | "single" | "multiple";
+    clockwise?: boolean;
+}
+interface PieChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    pulseRing?: ChartPulseRingProps;
+    calculable?: boolean;
+    /** Fixed-position star annotations; percentage coordinates use the SVG viewport. */
+    markPoints?: readonly {
+        name: string;
+        value: number;
+        x: number | `${number}%`;
+        y: number | `${number}%`;
+        radius?: number;
+        color?: string;
+    }[];
+    onValueDragOut?: (seriesIndex: number, dataIndex: number, point: readonly [number, number]) => void;
+    outsideLabelLayout?: {
+        top: number;
+        bottom: number;
+        gap?: number;
+        left?: number;
+        right?: number;
+    };
+    /** Controlled data transfer between charts in the same ChartComposite. */
+    transferId?: string;
+    onValueTransfer?: ChartValueTransferHandler;
+    onTransferError?: (message: string) => void;
+    showGuideRings?: boolean;
+    appearance?: "sia" | "macarons";
+    animationProgress?: number;
+    animationDurationUpdate?: number;
+    legendLayout?: {
+        x?: number;
+        y?: number;
+        orientation?: "horizontal" | "vertical";
+        align?: "start" | "center" | "end";
+        itemGap?: number;
+    };
+    onDataChange?: (series: readonly PieSeries[]) => void;
+    data?: readonly PieDatum[];
+    series?: readonly PieSeries[];
+    innerRadius?: number;
+    outerRadius?: number;
+    rose?: boolean | "radius" | "area";
+    center?: readonly [number, number];
+    startAngle?: number;
+    clockwise?: boolean;
+    padAngle?: number;
+    showLegend?: boolean;
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    showLabels?: boolean;
+    showLabelLines?: boolean;
+    centerLabel?: ReactNode;
+    selectedMode?: false | "single" | "multiple";
+    selected?: readonly string[];
+    defaultSelected?: readonly string[];
+    selectedOffset?: number;
+    onSelectionChange?: (names: string[]) => void;
+    onDataClick?: (info: ChartDataClickInfo<PieDatum>) => void;
+}
+declare const PieChart: react.ForwardRefExoticComponent<PieChartProps & react.RefAttributes<SiaChartRef>>;
+interface RadarIndicator {
+    name: string;
+    max?: number;
+    min?: number;
+}
+interface RadarSeries extends ChartSeries {
+    areaGradient?: {
+        center: readonly [number, number];
+        radius: number;
+        focus?: readonly [number, number];
+        stops: readonly {
+            offset: number;
+            color: string;
+        }[];
+    };
+    pointSymbol?: 'circle' | 'star';
+    pointRadius?: number;
+    pointColor?: (value: number, index: number) => string | undefined;
+    showValueLabels?: boolean;
+    valueLabelFormatter?: (value: number, index: number) => string;
+    emphasisLineWidth?: number;
+    emphasisAreaColor?: string;
+    data: readonly number[];
+    areaOpacity?: number;
+    lineStyle?: "solid" | "dashed" | "dotted";
+    lineWidth?: number;
+    showPoints?: boolean;
+}
+interface RadarPanel {
+    autoScale?: boolean;
+    scale?: boolean;
+    boundaryGap?: readonly [number, number];
+    axisColor?: string;
+    axisWidth?: number;
+    splitLineColor?: string;
+    splitLineWidth?: number;
+    splitAreaColors?: readonly string[];
+    indicatorColor?: string;
+    indicatorFormatter?: (name: string) => string;
+    showAxisLabels?: boolean;
+    axisLabelColor?: string;
+    indicators: readonly RadarIndicator[];
+    series: readonly RadarSeries[];
+    center?: readonly [number, number];
+    radius?: number;
+    levels?: number;
+    shape?: "polygon" | "circle";
+    startAngle?: number;
+}
+interface RadarChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    calculable?: boolean;
+    onTransferError?: (message: string) => void;
+    markers?: readonly {
+        name: string;
+        value: number;
+        x: number;
+        y: number;
+        size?: number;
+        color?: string;
+        hollow?: boolean;
+    }[];
+    appearance?: "sia" | "macarons";
+    animationProgress?: number;
+    legendOrder?: readonly string[];
+    legendLayout?: {
+        x?: number;
+        y?: number;
+        orientation?: "horizontal" | "vertical";
+        align?: "start" | "center" | "end";
+    };
+    onDataChange?: (panels: readonly RadarPanel[]) => void;
+    indicators?: readonly RadarIndicator[];
+    series?: readonly RadarSeries[];
+    radars?: readonly RadarPanel[];
+    levels?: number;
+    showLegend?: boolean;
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    onDataClick?: (info: ChartDataClickInfo<RadarSeries>) => void;
+}
+declare const RadarChart: react.ForwardRefExoticComponent<RadarChartProps & react.RefAttributes<SiaChartRef>>;
+interface ChordNode {
+    nodeSymbol?: 'circle' | 'star';
+    id: string;
+    name: string;
+    value?: number;
+    color?: string;
+}
+interface ChordLink {
+    label?: string;
+    source: string;
+    target: string;
+    value: number;
+    color?: string;
+}
+interface ChordChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    matrixAppearance?: MatrixChordAppearance;
+    nodeGeometry?: {
+        center: readonly [number, number];
+        orbitRadius: number;
+        minRadius: number;
+        maxRadius: number;
+        startAngle?: number;
+    };
+    matrixSeries?: readonly {
+        name: string;
+        color: string;
+        matrix: readonly (readonly number[])[];
+    }[];
+    showNodeLabels?: boolean;
+    rotateNodeLabels?: boolean;
+    matrixLinkLabel?: (source: number, target: number) => string;
+    matrixGeometry?: {
+        center: readonly [number, number];
+        innerRadius: number;
+        outerRadius: number;
+        startAngle?: number;
+    };
+    legacySubSort?: boolean;
+    showScale?: boolean;
+    matrix?: readonly (readonly number[])[];
+    sortSub?: 'none' | 'ascending' | 'descending';
+    nodes: readonly ChordNode[];
+    links: readonly ChordLink[];
+    padAngle?: number;
+    ribbon?: boolean;
+    clockwise?: boolean;
+    sort?: "ascending" | "descending" | "none";
+    onNodeClick?: (info: ChartDataClickInfo<ChordNode>) => void;
+    onLinkClick?: (info: ChartDataClickInfo<ChordLink>) => void;
+}
+declare const ChordChart: react.ForwardRefExoticComponent<ChordChartProps & react.RefAttributes<SiaChartRef>>;
+interface GraphNode {
+    imageSource?: string;
+    imageSize?: readonly [number, number];
+    labelPosition?: 'inside' | 'left' | 'right' | 'top' | 'bottom';
+    draggable?: boolean;
+    fixX?: boolean;
+    fixY?: boolean;
+    labelColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    radius?: number;
+    label?: string;
+    id: string;
+    name: string;
+    value?: number;
+    category?: string;
+    color?: string;
+    x?: number;
+    y?: number;
+    fixed?: boolean;
+    symbol?: "circle" | "square" | "diamond" | "star";
+}
+interface GraphLink {
+    arrow?: boolean;
+    arrowSize?: readonly [number, number];
+    offset?: number;
+    curvature?: number;
+    source: string;
+    target: string;
+    value?: number;
+    label?: string;
+    color?: string;
+    width?: number;
+    dashed?: boolean;
+}
+interface GraphChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    progressiveForce?: boolean;
+    chordOptions?: Pick<ChordChartProps, 'ribbon' | 'nodeGeometry' | 'rotateNodeLabels'>;
+    roam?: boolean | 'move';
+    forceOptions?: ForceLayoutOptions;
+    nodes: readonly GraphNode[];
+    links: readonly GraphLink[];
+    layout?: "force" | "circular";
+    showLabels?: boolean;
+    draggable?: boolean;
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    onNodeClick?: (info: ChartDataClickInfo<GraphNode>) => void;
+}
+declare const GraphChart: react.ForwardRefExoticComponent<GraphChartProps & react.RefAttributes<SiaChartRef>>;
+declare const ForceGraphChart: react.ForwardRefExoticComponent<Omit<GraphChartProps, "layout"> & react.RefAttributes<SiaChartRef>>;
+declare const ForceChart: react.ForwardRefExoticComponent<Omit<GraphChartProps, "layout"> & react.RefAttributes<SiaChartRef>>;
+interface GeoJsonPolygonGeometry {
+    type: "Polygon";
+    coordinates: readonly (readonly (readonly [number, number])[])[];
+}
+interface GeoJsonMultiPolygonGeometry {
+    type: "MultiPolygon";
+    coordinates: readonly (readonly (readonly (readonly [number, number])[])[])[];
+}
+interface GeoJsonFeature {
+    type: "Feature";
+    properties: Readonly<Record<string, unknown>> & {
+        name?: string;
+    };
+    geometry: GeoJsonPolygonGeometry | GeoJsonMultiPolygonGeometry;
+}
+interface GeoJsonFeatureCollection {
+    type: "FeatureCollection";
+    features: readonly GeoJsonFeature[];
+}
+interface MapDatum extends MapRegionAppearance {
+    legendSymbols?: readonly {
+        name: string;
+        color: string;
+    }[];
+    name: string;
+    value: number;
+    color?: string;
+    selected?: boolean;
+}
+interface MapMarkPoint {
+    entrance?: boolean;
+    pinShape?: 'curved' | 'arc';
+    /** SVG coordinates bypass geographic projection (and still follow the map group transform). */
+    coordinateSpace?: 'geographic' | 'svg';
+    imageSrc?: string;
+    label?: ReactNode;
+    labelStyle?: CSSProperties;
+    showEmphasisLabel?: boolean;
+    scaleEffect?: {
+        duration: number;
+        scaleSize?: number;
+    };
+    visualMap?: boolean;
+    symbol?: 'circle' | 'emptyCircle' | 'pin';
+    seriesName?: string;
+    style?: CSSProperties;
+    emphasisStyle?: CSSProperties;
+    name: string;
+    coordinate: readonly [number, number];
+    value?: number;
+    color?: string;
+    size?: number;
+    effect?: boolean;
+}
+interface MapMarkLine {
+    reveal?: {
+        initialDuration?: number;
+        updateDuration?: number;
+    };
+    lineStyle?: CSSProperties;
+    shadowBlur?: number;
+    endpointStyle?: CSSProperties;
+    endpointSymbols?: readonly ['none' | 'circle', 'circle' | 'arrow'];
+    visualMap?: boolean;
+    curveMode?: 'directional';
+    movingEffect?: {
+        period?: number;
+        color?: string;
+        radius?: number;
+        shadowBlur?: number;
+        shadowColor?: string;
+        trailAlpha?: number;
+    };
+    seriesName?: string;
+    dashed?: boolean;
+    endpointSizes?: readonly [number, number];
+    tooltip?: ReactNode;
+    name?: string;
+    source: readonly [number, number];
+    target: readonly [number, number];
+    value?: number;
+    color?: string;
+    width?: number;
+    curveness?: number;
+    effect?: boolean;
+}
+interface MapChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    /** Host map projection into overlay pixels. Re-render when the host viewport changes. */
+    overlayProjection?: {
+        project: (coordinate: readonly [number, number]) => readonly [number, number];
+        offset?: readonly [number, number];
+    };
+    bundledLines?: BundledMapLines;
+    markLineEffectRenderer?: 'svg' | 'canvas';
+    /** Batched point groups; points are geographic longitude/latitude pairs. */
+    largeMarkPoints?: readonly LargeMapPointCanvasGroup[];
+    insetStyle?: CSSProperties;
+    insetLabelStyle?: CSSProperties;
+    regionHoverable?: boolean;
+    markPointTooltipFormatter?: (point: MapMarkPoint) => ReactNode;
+    clampVisualValues?: boolean;
+    wheelZoomFactors?: readonly [number, number];
+    /** Hide the map series while retaining title and value-range controls. */
+    showMap?: boolean;
+    outOfRangeColor?: string;
+    roamController?: boolean;
+    visualMapLayout?: {
+        realtime?: boolean;
+        svgHandles?: boolean;
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+        orientation?: 'horizontal' | 'vertical';
+        label?: string;
+        endLabels?: readonly [string, string];
+    };
+    labelStyle?: CSSProperties;
+    emphasisLabelStyle?: CSSProperties;
+    regionStyle?: CSSProperties;
+    emphasisRegionStyle?: CSSProperties;
+    /** Omit for .65–5; null removes limits; an object sets optional bounds. */
+    scaleLimit?: {
+        min?: number;
+        max?: number;
+    } | null;
+    tooltipFormatter?: (name: string, datum: MapDatum | undefined) => ReactNode;
+    showEmphasisLabels?: boolean;
+    longitudeRatio?: number;
+    geographicInsets?: readonly {
+        name: string;
+        coordinate: readonly [number, number];
+        polygons: readonly (readonly (readonly [number, number])[])[];
+        label: readonly [number, number];
+        unitsPerLongitude: number;
+    }[];
+    plotBounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    valueDomain?: readonly [number, number];
+    showVisualMap?: boolean;
+    seriesName?: string;
+    map?: string;
+    geoJson?: GeoJsonFeatureCollection;
+    data: readonly MapDatum[];
+    colors?: readonly string[];
+    nameProperty?: string;
+    nameMap?: Readonly<Record<string, string>>;
+    labelCoordinates?: Readonly<Record<string, readonly [number, number]>>;
+    labelOffsets?: Readonly<Record<string, readonly [number, number]>>;
+    specialAreas?: Readonly<Record<string, MapSpecialArea>>;
+    /** Normalize coordinates before calculating bounds and projecting; source GeoJSON is unchanged. */
+    coordinateTransform?: (point: readonly [number, number]) => readonly [number, number];
+    emphasisValueRange?: readonly [number, number];
+    onRegionHover?: (datum: MapDatum | undefined) => void;
+    showLabels?: boolean;
+    roam?: boolean | "move" | "scale";
+    selectedMode?: false | "single" | "multiple";
+    selected?: readonly string[];
+    defaultSelected?: readonly string[];
+    onSelectionChange?: (names: string[]) => void;
+    calculableVisualMap?: boolean;
+    visualRange?: readonly [number, number];
+    defaultVisualRange?: readonly [number, number];
+    onVisualRangeChange?: (range: [number, number]) => void;
+    markPoints?: readonly MapMarkPoint[];
+    markLines?: readonly MapMarkLine[];
+    onRegionClick?: (info: ChartDataClickInfo<MapDatum | GeoJsonFeature>) => void;
+}
+declare function registerChartMap(name: string, geoJson: GeoJsonFeatureCollection): void;
+declare function getChartMap(name: string): GeoJsonFeatureCollection | undefined;
+declare const MapChart: react.ForwardRefExoticComponent<MapChartProps & react.RefAttributes<SiaChartRef>>;
+interface GaugeDatum {
+    zIndex?: number;
+    labelFontWeight?: string | number;
+    nameFontWeight?: string | number;
+    detailFontWeight?: string | number;
+    nameFontStyle?: string;
+    detailBox?: {
+        width: number;
+        height: number;
+        background?: string;
+        borderColor?: string;
+        borderWidth?: number;
+    };
+    axisWidth?: number;
+    splitNumber?: number;
+    tickCount?: number;
+    tickLength?: number;
+    tickColor?: string;
+    showTicks?: boolean;
+    splitLength?: number;
+    splitColor?: string;
+    splitWidth?: number;
+    labelColor?: string;
+    labelFontSize?: number;
+    labelFormatter?: (value: number) => ReactNode;
+    nameOffset?: readonly [number, number];
+    detailPosition?: readonly [number, number];
+    showName?: boolean;
+    showDetail?: boolean;
+    nameFontSize?: number;
+    detailFontSize?: number;
+    nameColor?: string;
+    detailColor?: string;
+    pointerColor?: string;
+    glow?: boolean;
+    name: string;
+    value: number;
+    color?: string;
+    min?: number;
+    max?: number;
+    startAngle?: number;
+    endAngle?: number;
+    center?: readonly [number, number];
+    radius?: number;
+    segments?: readonly {
+        until: number;
+        color: string;
+    }[];
+    pointerWidth?: number;
+    pointerLength?: number;
+    unit?: string;
+}
+interface GaugeChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    tooltipFormatter?: (item: GaugeDatum) => ReactNode;
+    appearance?: "sia" | "macarons";
+    animationProgress?: number;
+    data: readonly GaugeDatum[];
+    min?: number;
+    max?: number;
+    startAngle?: number;
+    endAngle?: number;
+    segments?: readonly {
+        until: number;
+        color: string;
+    }[];
+    splitNumber?: number;
+    showAxisLabels?: boolean;
+    showProgress?: boolean;
+    detailOffset?: number;
+    valueFormatter?: (value: number) => ReactNode;
+    onDataClick?: (info: ChartDataClickInfo<GaugeDatum>) => void;
+}
+declare const GaugeChart: react.ForwardRefExoticComponent<GaugeChartProps & react.RefAttributes<SiaChartRef>>;
+interface FunnelDatum extends PieDatum {
+}
+interface FunnelSeries {
+    tooltipFormatter?: (item: FunnelDatum) => ReactNode;
+    emphasisLabelPosition?: "inside" | "left" | "right";
+    emphasisLabelFormatter?: (item: FunnelDatum) => ReactNode;
+    min?: number;
+    max?: number;
+    minSize?: number;
+    maxSize?: number;
+    labelPosition?: "inside" | "left" | "right";
+    labelFormatter?: (item: FunnelDatum) => ReactNode;
+    showLabelLines?: boolean;
+    borderColor?: string;
+    borderWidth?: number;
+    pieCenter?: [number, number];
+    name?: string;
+    data: readonly FunnelDatum[];
+    left?: number;
+    top?: number;
+    width?: number;
+    height?: number;
+    sort?: "descending" | "ascending" | "none";
+    gap?: number;
+    align?: "center" | "left" | "right";
+    orientation?: "vertical" | "horizontal";
+}
+interface FunnelChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    appearance?: "sia" | "macarons";
+    animationProgress?: number;
+    legendOrder?: readonly string[];
+    legendLayout?: {
+        x?: number;
+        y?: number;
+        orientation?: "horizontal" | "vertical";
+    };
+    onDataChange?: (series: readonly FunnelSeries[]) => void;
+    data?: readonly FunnelDatum[];
+    series?: readonly FunnelSeries[];
+    sort?: "descending" | "ascending" | "none";
+    gap?: number;
+    align?: "center" | "left" | "right";
+    orientation?: "vertical" | "horizontal";
+    showLegend?: boolean;
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    onDataClick?: (info: ChartDataClickInfo<FunnelDatum>) => void;
+}
+declare const FunnelChart: react.ForwardRefExoticComponent<FunnelChartProps & react.RefAttributes<SiaChartRef>>;
+interface HeatmapPoint {
+    x: number;
+    y: number;
+    value: number;
+    name?: string;
+}
+interface HeatmapChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    /** Native pixel-coordinate density mode (no automatic coordinate normalization). */
+    raster?: HeatRasterOptions & {
+        width: number;
+        height: number;
+        backgroundImage?: string;
+    };
+    xLabels?: readonly string[];
+    yLabels?: readonly string[];
+    data?: readonly (readonly number[])[];
+    points?: readonly HeatmapPoint[];
+    colors?: readonly [string, string];
+    showValues?: boolean;
+    pointRadius?: number;
+    blur?: number;
+    minAlpha?: number;
+    maxAlpha?: number;
+    valueFormatter?: (value: number) => ReactNode;
+    onDataClick?: (info: ChartDataClickInfo<number | HeatmapPoint>) => void;
+}
+declare const HeatmapChart: react.ForwardRefExoticComponent<HeatmapChartProps & react.RefAttributes<SiaChartRef>>;
+interface ThemeRiverSeries extends ChartSeries {
+}
+interface ThemeRiverChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    categories: readonly string[];
+    series: readonly ThemeRiverSeries[];
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    onDataClick?: (info: ChartDataClickInfo<number>) => void;
+}
+declare const ThemeRiverChart: react.ForwardRefExoticComponent<ThemeRiverChartProps & react.RefAttributes<SiaChartRef>>;
+interface EventRiverEvolution {
+    time: string | number | Date;
+    value: number;
+    detail?: ReactNode;
+}
+interface EventRiverEvent {
+    name: string;
+    id?: string;
+    weight?: number;
+    evolution: readonly EventRiverEvolution[];
+}
+interface EventRiverSeries {
+    name: string;
+    weight?: number;
+    data: readonly EventRiverEvent[];
+    color?: string;
+}
+interface EventRiverChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    series: readonly EventRiverSeries[];
+    showLabels?: boolean;
+    draggable?: boolean;
+    appearance?: 'sia' | 'macarons';
+    plot?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    animationProgress?: number;
+    /** Time-axis fractional padding before and after the observed data. */
+    boundaryGap?: readonly [number, number];
+    legendInteractive?: boolean;
+    legendSelected?: Readonly<Record<string, boolean>>;
+    onLegendSelectionChange?: (selected: Record<string, boolean>) => void;
+    onDataClick?: (info: ChartDataClickInfo<EventRiverEvent>) => void;
+}
+declare const EventRiverChart: react.ForwardRefExoticComponent<EventRiverChartProps & react.RefAttributes<SiaChartRef>>;
+interface VennSet {
+    name: string;
+    value: number;
+    color?: string;
+}
+interface VennIntersection {
+    value: number;
+    name?: string;
+    color?: string;
+}
+interface VennChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    appearance?: "sia" | "macarons";
+    emphasisColor?: string;
+    emphasisBorderColor?: string;
+    emphasisBorderWidth?: number;
+    sets: readonly [VennSet, VennSet];
+    intersection: VennIntersection;
+    onDataClick?: (info: ChartDataClickInfo<VennSet | VennIntersection>) => void;
+}
+declare const VennChart: react.ForwardRefExoticComponent<VennChartProps & react.RefAttributes<SiaChartRef>>;
+interface TreemapItemStyle {
+    color?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    label?: {
+        show?: boolean;
+        formatter?: string;
+        x?: number;
+        y?: number;
+        color?: string;
+        fontSize?: number;
+        fontFamily?: string;
+        fontStyle?: "normal" | "italic";
+        fontWeight?: string | number;
+    };
+}
+interface TreemapDatum {
+    name: string;
+    value?: number;
+    color?: string;
+    children?: readonly TreemapDatum[];
+    style?: TreemapItemStyle;
+    emphasis?: TreemapItemStyle;
+}
+interface TreemapChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    data: readonly TreemapDatum[];
+    gap?: number;
+    maxDepth?: number;
+    drilldown?: boolean;
+    showBreadcrumb?: boolean;
+    bounds?: TreemapLayoutBox;
+    itemStyle?: TreemapItemStyle;
+    emphasis?: TreemapItemStyle;
+    cornerRadius?: number;
+    showChildBoundaries?: boolean;
+    breadcrumbPosition?: "top" | "bottom";
+    breadcrumbRootName?: string;
+    valueFormatter?: (value: number) => ReactNode;
+    onDataClick?: (info: ChartDataClickInfo<TreemapDatum>) => void;
+}
+declare const TreemapChart: react.ForwardRefExoticComponent<TreemapChartProps & react.RefAttributes<SiaChartRef>>;
+interface TreeDatum {
+    name: string;
+    value?: number;
+    color?: string;
+    children?: readonly TreeDatum[];
+    collapsed?: boolean;
+    symbol?: "circle" | "square" | "diamond" | `image://${string}`;
+    itemStyle?: TreeItemStyle;
+    emphasis?: TreeItemStyle;
+    symbolSize?: number | readonly [number, number];
+}
+interface TreeChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    itemStyle?: TreeItemStyle;
+    emphasis?: TreeItemStyle;
+    data: TreeDatum;
+    orientation?: "horizontal" | "vertical";
+    radial?: boolean;
+    nodeSize?: number;
+    rootPosition?: readonly [number, number];
+    nodePadding?: number;
+    layerPadding?: number;
+    showLabels?: boolean;
+    emphasisShowLabels?: boolean;
+    nodeColor?: string;
+    edgeColor?: string;
+    edgeWidth?: number;
+    edgeShadow?: {
+        color: string;
+        blur: number;
+        offsetX: number;
+        offsetY: number;
+    };
+    roam?: boolean;
+    hoverable?: boolean;
+    labelFontSize?: number;
+    labelColor?: string;
+    linkStyle?: "curve" | "broken" | "straight";
+    collapsible?: boolean;
+    onToggle?: (node: TreeDatum, collapsed: boolean) => void;
+    onDataClick?: (info: ChartDataClickInfo<TreeDatum>) => void;
+}
+declare const TreeChart: react.ForwardRefExoticComponent<TreeChartProps & react.RefAttributes<SiaChartRef>>;
+interface WordCloudDatum {
+    name: string;
+    value: number;
+    color?: string;
+    rotation?: number;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: number | string;
+}
+interface WordCloudChartProps extends Omit<SiaChartProps, "children" | "empty"> {
+    areaSizing?: boolean;
+    bounds?: CloudBounds;
+    autoFit?: boolean;
+    onLayout?: (result: {
+        placed: number;
+        unplaced: readonly string[];
+    }) => void;
+    data: readonly WordCloudDatum[];
+    minFontSize?: number;
+    maxFontSize?: number;
+    rotations?: readonly number[];
+    spiralStep?: number;
+    shape?: "ellipse" | "circle" | "square" | "diamond";
+    padding?: number;
+    fontFamily?: string;
+    fontWeight?: number | string;
+    onDataClick?: (info: ChartDataClickInfo<WordCloudDatum>) => void;
+}
+declare const WordCloudChart: react.ForwardRefExoticComponent<WordCloudChartProps & react.RefAttributes<SiaChartRef>>;
+interface MixedSeries extends Omit<ChartSeries, 'data'> {
+    /** Distinct co-located category axes own separate bar groups and stacking totals. */
+    categoryAxisIndex?: number;
+    /** Diameter in chart coordinates; defaults to the existing 9px marker. */
+    symbolSize?: number;
+    hollowSymbol?: boolean;
+    areaOpacity?: number;
+    sampling?: 'pixel';
+    markSymbol?: 'arrow' | 'none';
+    showMarkLabel?: boolean;
+    tooltipTrigger?: 'item' | 'axis';
+    data: readonly (number | null)[];
+    stack?: string;
+    barWidth?: number;
+    barRadius?: number;
+    pointColors?: readonly (string | undefined)[];
+    showPoints?: boolean;
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+    lineWidth?: number;
+    markAverage?: boolean;
+    markColor?: string;
+    markFormatter?: (value: number) => ReactNode;
+    /** Index into valueAxes; distinct units must never share an inferred range. */
+    valueAxisIndex?: number;
+    type: "line" | "bar";
+    curve?: LineSeries["curve"];
+    area?: boolean;
+}
+interface MixedChartProps extends Omit<CartesianChartProps, "series"> {
+    axisPointer?: boolean | {
+        color?: string;
+        width?: number;
+        lineStyle?: 'solid' | 'dashed' | 'dotted';
+        pixelAlign?: boolean;
+        linkedEmphasis?: boolean;
+    };
+    /** Labels for co-located category axes, used by axis-specific tooltips and accessible marks. */
+    categoryAxisLabels?: readonly (readonly string[])[];
+    barSpacing?: MixedBarSpacing;
+    /** With overlay enabled, renderAxes is called for base content and then foreground strokes. */
+    axisLayering?: 'inline' | 'overlay';
+    renderAxes?: (context: {
+        layer: 'all' | 'base' | 'line';
+        plot: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        categoryPositions: readonly number[];
+        valueDomains: readonly (readonly [number, number, number])[];
+    }) => ReactNode;
+    coordinateAnimation?: boolean;
+    animationProgress?: number;
+    animationDurationUpdate?: number;
+    /** Leave half a category slot at either end; bars always require category slots. */
+    boundaryGap?: boolean;
+    /** Clip series geometry and hit targets to the plot (fixed domains). */
+    clipPlot?: boolean;
+    activeIndex?: number | null;
+    onActiveIndexChange?: (index: number | null) => void;
+    showCategoryLabels?: boolean;
+    categoryLabelInterval?: number | "auto";
+    transferId?: string;
+    onValueTransfer?: ChartValueTransferHandler;
+    calculable?: boolean;
+    onTransferError?: (message: string) => void;
+    tooltipTrigger?: 'item' | 'axis';
+    legendNames?: readonly string[];
+    axisTooltipFormatter?: (index: number, series: readonly MixedSeries[], categoryAxisIndex?: number) => ReactNode;
+    legendLayout?: {
+        x?: number;
+        y?: number;
+        maxWidth?: number;
+        symbol?: 'rect' | 'line' | 'sector' | 'auto';
+    };
+    plotBounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    onDataChange?: (series: readonly MixedSeries[]) => void;
+    stacked?: boolean;
+    valueAxes?: readonly {
+        autoDomain?: MixedValueDomainOptions;
+        name?: string;
+        domain?: readonly [number, number, number];
+        position?: 'left' | 'right';
+        formatter?: (value: number) => string;
+        axisColor?: string;
+        gridColor?: string;
+        showTicks?: boolean;
+        nameStyle?: CSSProperties;
+    }[];
+    series: readonly MixedSeries[];
+    onDataClick?: (info: ChartDataClickInfo<number>) => void;
+}
+declare const MixedChart: react.ForwardRefExoticComponent<MixedChartProps & react.RefAttributes<SiaChartRef>>;
+/** ECharts 2 文档中的 KLine 命名兼容别名。 */
+declare const KLineChart: react.ForwardRefExoticComponent<CandlestickChartProps & react.RefAttributes<SiaChartRef>>;
+
+export { type BaiduMapHostOptions, type BaiduMapInstance, type BaiduMapNamespace, type BaiduMapPoint, BarChart, type BarChartProps, type BarDatum, type BarSeries, CHART_VIEWBOX_HEIGHT, CHART_VIEWBOX_WIDTH, CandlestickChart, type CandlestickChartProps, type CandlestickDatum, type CartesianChartProps, ChartAxis, type ChartAxisProps, ChartComposite, type ChartCompositeLayer, type ChartCompositeProps, type ChartCompositeRef, type ChartDataClickInfo, ChartDataEditor, type ChartDataEditorProps, ChartDataZoom, type ChartDataZoomProps, ChartLegend, type ChartLegendItem, type ChartLegendProps, ChartMapOverlay, type ChartMapOverlayProps, ChartMark, type ChartMarkProps, ChartRoamController, type ChartRoamControllerProps, type ChartSeries, ChartTimeline, type ChartTimelineProps, ChartToolbox, type ChartToolboxFeature, type ChartToolboxOptions, type ChartToolboxProps, ChartTooltip, type ChartTooltipProps, type ChartValueAddress, type ChartValueChannel, ChartValueIsland, type ChartValueIslandProps, type ChartValueTransferHandler, ChartVisualMap, type ChartVisualMapProps, ChartWhirlingLoading, type ChartWhirlingLoadingProps, ChordChart, type ChordChartProps, type ChordLink, type ChordNode, DEFAULT_CHART_PALETTE, EventRiverChart, type EventRiverChartProps, type EventRiverEvent, type EventRiverEvolution, type EventRiverSeries, ForceChart, ForceGraphChart, FunnelChart, type FunnelChartProps, type FunnelDatum, type FunnelSeries, GaugeChart, type GaugeChartProps, type GaugeDatum, type GeoJsonFeature, type GeoJsonFeatureCollection, type GeoJsonMultiPolygonGeometry, type GeoJsonPolygonGeometry, GraphChart, type GraphChartProps, type GraphLink, type GraphNode, HeatmapChart, type HeatmapChartProps, type HeatmapPoint, KLineChart, LineChart, type LineChartProps, type LinePoint, type LineSeries, LineShareChart, type LineShareChartProps, MapChart, type MapChartProps, type MapDatum, type MapMarkLine, type MapMarkPoint, type MapOverlayEvent, type MapOverlayHost, type MapOverlaySnapshot, MixedChart, type MixedChartProps, type MixedSeries, PieChart, type PieChartProps, type PieDatum, type PieSeries, RadarChart, type RadarChartProps, type RadarIndicator, type RadarPanel, type RadarSeries, ScatterChart, type ScatterChartProps, type ScatterDatum, type ScatterVisualMap, SiaChart, type SiaChartProps, type SiaChartRef, SvgMapPlot, type SvgMapPlotProps, ThemeRiverChart, type ThemeRiverChartProps, type ThemeRiverSeries, TreeChart, type TreeChartProps, type TreeDatum, TreemapChart, type TreemapChartProps, type TreemapDatum, type TreemapItemStyle, VennChart, type VennChartProps, type VennIntersection, type VennSet, WordCloudChart, type WordCloudChartProps, type WordCloudDatum, XYChart, type XYChartProps, type XYSeries, chartColor, chartTicks, createBaiduMapHost, formatChartNumber, getChartMap, linearScale, niceChartDomain, paddedValueExtent, registerChartMap, saveCompositeImage, serializeChartStack, smoothSvgPath, svgArcPath, transferCompositeValue };