@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/chart/sy-chart.d.ts

@@ -0,0 +1,1552 @@
+import type { ChartPointEventDetail, ChartLegendItemEventDetail, ChartTooltipActionEventDetail, ChartAppendedEventDetail, ChartDataValidationErrorDetail } from './facade-types';
+import type { ChartTypeLoadDetail } from './_shared/core/loading/chart-element-loader';
+import type { ChartEngineStatus } from './_shared/core/engine/types';
+import type { FlowLinesData, FlowLinesRouteInput, FlowLinesId, FlowLinesStreamSource, FlowLinesStyle, FlowLinesHitDetail, FlowLinesSelection, FlowLinesSelectionChangeEventDetail, FlowLinesDiagnostics, FlowLinesLayout } from './_shared/core/contract/flow-lines-contract';
+import type { ThemeRiverData, ThemeRiverRow, ThemeRiverId, ThemeRiverStreamSource, ThemeRiverLayout, ThemeRiverDiagnostics, ThemeRiverAxesOptions, ThemeRiverOffset, ThemeRiverOrder, ThemeRiverHitDetail, ThemeRiverSelection, ThemeRiverSelectionChangeEventDetail, ThemeRiverCrosshairDetail } from './_shared/core/contract/theme-river-contract';
+import type { Bar3DData, Bar3DDatum, Bar3DStreamSource, Bar3DGeometry, Bar3DDiagnostics, Bar3DAxesOptions, Bar3DDomain, Bar3DCategory, Bar3DCrosshairShowRequest, Bar3DHitDetail, Bar3DSelection, Bar3DSelectionChangeEventDetail, Bar3DCrosshairDetail } from './_shared/core/contract/bar3d-contract';
+import type { Scatter3DData, Scatter3DDatum, Scatter3DStreamSource, Scatter3DGeometry, Scatter3DDiagnostics, Scatter3DAxesOptions, Scatter3DDomain, Scatter3DMarker, Scatter3DHitDetail, Scatter3DSelection, Scatter3DSelectionChangeEventDetail, Scatter3DCrosshairDetail } from './_shared/core/contract/scatter3d-contract';
+import type { Surface3DData, Surface3DGrid, Surface3DRowInput, Surface3DStreamSource, Surface3DGeometry, Surface3DDiagnostics, Surface3DAxesOptions, Surface3DDomain, Surface3DHitDetail, Surface3DSelection, Surface3DSelectionChangeEventDetail, Surface3DCrosshairDetail, Surface3DCameraChangeEventDetail } from './_shared/core/contract/surface3d-contract';
+import type { Scene3DCameraOptions, Scene3DProjection, Scene3DVector } from './_shared/core/contract/scene3d-camera-contract';
+import type { Orbit3DOptions } from './_shared/core/contract/scene3d-orbit-contract';
+import type { Scene3DMaterialOptions, Scene3DLightingOptions } from './_shared/core/contract/scene3d-lighting-contract';
+import type { ParallelCoordinatesAxisBrush, ParallelCoordinatesBrushInput, ParallelCoordinatesBrushChangeEventDetail, ParallelCoordinatesBrushGestureEventDetail, ParallelCoordinatesBrushModel } from './_shared/core/contract/parallel-coordinates-contract';
+import type { ParallelCoordinatesLineModel, ParallelCoordinatesAxesInput, ParallelCoordinatesAxisModel, ParallelCoordinatesData, ParallelCoordinatesRowInput, ParallelCoordinatesRow, ParallelCoordinatesDimensionInput, ParallelCoordinatesDiagnostics, ParallelCoordinatesAxis, ParallelCoordinatesLayoutResult, ParallelCoordinatesHitDetail, ParallelCoordinatesSelection, ParallelCoordinatesSelectionChangeEventDetail, ParallelCoordinatesStreamSource, ParallelCoordinatesCrosshairDetail } from './_shared/core/contract/parallel-coordinates-contract';
+import type { GanttDiagnostics, GanttBaselineStyleInput, GanttBaselineComparison, GanttTaskEditingInput, GanttTaskEdit, GanttTaskEditEventDetail, GanttCriticalPathInput, GanttCriticalPathResult, GanttDependencyInput, GanttDependencyDataset, GanttDependencyStyleInput, GanttDependencyPath, GanttDependencyHitDetail, GanttDependencySelection, GanttDependencySelectionChange, GanttData, GanttTaskInput, GanttTask, GanttExtent, GanttLayoutResult, GanttLabel, GanttLabelMode, GanttTimeAxisInput, GanttTimeAxisModel, GanttCrosshairTimeUnit, GanttHitDetail, GanttSelection, GanttSelectionChangeEventDetail, GanttStreamSource } from './_shared/core/contract/gantt-contract';
+import type { DendrogramDirection, DendrogramData, DendrogramNodeInput, DendrogramNode, DendrogramHitDetail, DendrogramSelection, DendrogramSelectionChangeEventDetail, DendrogramDrillChangeEventDetail } from './_shared/core/contract/dendrogram-contract';
+import type { GeoMapConnectionPath, GeoMapHeatInput, GeoMapLabelView, GeoMapFitOptions, GeoMapFitDetail, GeoMapViewDetail, GeoMapHeatDetail, GeoMapHeatPointDetail, GeoMapBubbleInput, GeoMapBubbleScaleDetail, GeoMapColorAxisInput, GeoMapColorAxisDetail, GeoMapPickDetail, GeoMapFeatureHitDetail, GeoMapFeatureSelection, GeoMapFeatureSelectionChangeEventDetail, GeoMapFeatureCollection, GeoMapViewChangeEventDetail, GeoMapRegion, GeoMapBackground, GeoMapProjection, GeoMapData, GeoMapPointInput, GeoMapLabelMode, GeoMapHitDetail, GeoMapSelection, GeoMapSelectionChangeEventDetail } from './_shared/core/contract/geo-map-contract';
+import type { IcicleDirection, IcicleData, IcicleNodeInput, IcicleNode, IcicleHitDetail, IcicleSelection, IcicleSelectionChangeEventDetail, IcicleDrillChangeEventDetail } from './_shared/core/contract/icicle-contract';
+import type { SunburstData, SunburstNodeInput, SunburstNode, SunburstHitDetail, SunburstSelection, SunburstSelectionChangeEventDetail, SunburstDrillChangeEventDetail } from './_shared/core/contract/sunburst-contract';
+import type { TreemapData, TreemapNodeInput, TreemapNode, TreemapHitDetail, TreemapSelection, TreemapSelectionChangeEventDetail, TreemapDrillChangeEventDetail } from './_shared/core/contract/treemap-contract';
+import { EventEmitter } from '../../stencil-public-runtime';
+import type { CartesianZoomChangeEventDetail, CartesianZoomInput, CartesianZoomRequest, CartesianZoomExtentDetail, CartesianZoomExtentRequest, CartesianZoomState, ZoomConnectOptions } from './_shared/core/zoom';
+import type { CartesianBrushArea, CartesianBrushAreaInput, CartesianBrushChangeEventDetail, CartesianBrushEndEventDetail, CartesianBrushInput, CartesianBrushMoveEventDetail, CartesianBrushSelectedSeries, CartesianBrushStartEventDetail } from './_shared/core/brush';
+import type { ChartDrawing, ChartDrawingInput, ChartDrawingsInput, DrawingLayerSnapshot, DrawingModeInput, DrawingSelectionChangeEventDetail, DrawingSpace, DrawingsChangeEventDetail } from './_shared/core/drawing';
+import type { VisualMapBinding, VisualMapExtent, VisualMapExtentRequest } from './_shared/core/visual-map/visual-map-binding';
+import type { Dataset, DatasetRow, DatasetSourceInput } from './_shared/core/data/dataset';
+import type { DatasetTransform } from './_shared/core/data/transforms';
+import type { DatasetEncode, EncodedDataset } from './_shared/core/data/encode';
+import type { ChartAction, ChartActionEventDetail, ChartActionResult } from './_shared/core/action/action-contract';
+import type { LineChartEngineMode, LineChartMarker, LineChartMarkerActiveTrigger, LineChartMarkerFilter, LineChartSmooth, LineChartStep, LineChartSeries, LineChartSeriesStateOptions, LineChartUnavailableBehaviour, LineChartValues } from './line-chart/core/types';
+import type { LineChartEasing } from './line-chart/core/animation';
+import type { LineChartStreamSource } from './line-chart/core/streaming';
+import type { LineChartLegendPosition, LineChartPointEventDetail } from './line-chart/sy-line-chart';
+import type { LegendItem } from './_shared/core/layout';
+import type { CartesianAxisInput, CartesianCrosshairEventDetail, CartesianCrosshairInput, CartesianGridLinesInput, CartesianSeriesBorderDashStyle, CartesianSeriesCornerRadiusValue, CartesianSeriesOutsideClickEventDetail, CartesianSeriesStackingMode, CartesianTooltipEventDetail, CartesianTooltipInput } from './_shared/core/contract';
+import type { AreaChartPatternKind } from './area-chart/core/types';
+import type { AreaChartStreamSource } from './area-chart/core/streaming';
+import type { BarChartStreamSource } from './bar-chart/core/streaming';
+import type { ColumnChartStreamSource } from './column-chart/core/streaming';
+import type { ScatterChartDatum, ScatterChartMarkerSymbol, ScatterChartSeries, ScatterChartValues } from './scatter-chart/core/types';
+import type { ScatterChartStreamSource } from './scatter-chart/core/streaming';
+import type { PieChartDatum, PieChartLabelContent, PieChartLabelMode, PieChartResolvedSlice, PieChartSelectedEventDetail, PieChartSizeBy, PieChartSliceEventDetail } from './pie-chart/core/types';
+import type { PieChartStreamSource } from './pie-chart/core/pie-stream-source';
+import type { PieChartPaletteName } from './pie-chart/sy-pie-chart';
+import type { PieChartTooltipInput, PieChartTooltipShowEventDetail } from './pie-chart/core/pie-tooltip';
+import type { ItemChartDatum, ItemChartPointEventDetail, ItemChartSymbol } from './item-chart/core/types';
+import type { WordCloudDatum, WordCloudPointEventDetail, WordCloudSpiral, WordCloudWeightScale } from './word-cloud-chart/core/types';
+import type { TilemapColorAxisInput, TilemapDatum, TilemapPointEventDetail, TilemapTileShape } from './tilemap-chart/core/types';
+import type { HeatmapCategoriesInput, HeatmapColorInput, HeatmapData, HeatmapLodMode, HeatmapMatrixInput, HeatmapRenderPath } from './_shared/core/contract/heatmap-contract';
+import type { DensityMapBandwidthInput, DensityMapBandwidthUnit, DensityMapComputePathInput, DensityMapInput, DensityMapKernel, DensityMapUnitInput } from './_shared/core/contract/density-map-contract';
+import type { SpectrogramInput, SpectrogramValueScale, SpectrogramWindowKind, SpectrogramAppendSamplesResult } from './_shared/core/contract/spectrogram-contract';
+import type { CalendarAggregate, CalendarHeatmapData, CalendarWeekStart, CalendarWeekdayLabels } from './_shared/core/contract/calendar-heatmap-contract';
+import type { CandlestickBodyStyle, CandlestickData, CandlestickOverlayInput, CandlestickSessionInput, CandlestickTimeScale, CandlestickVolumeMode } from './_shared/core/contract/candlestick-contract';
+import type { BoxPlotData } from './_shared/core/contract/box-plot-contract';
+import type { BubbleData } from './_shared/core/contract/bubble-contract';
+import type { WaterfallData } from './_shared/core/contract/waterfall-contract';
+import type { ErrorBarData } from './_shared/core/contract/error-bar-contract';
+import type { SankeyAlign, SankeyData, SankeyLabelMode, SankeyLinkEventDetail, SankeyNodeEventDetail, SankeySelection, SankeySelectionChangeEventDetail } from './_shared/core/contract/sankey-contract';
+import type { ChordData, ChordHitDetail, ChordLinkEventDetail, ChordLinkInput, ChordNodeEventDetail, ChordSelection, ChordSelectionChangeEventDetail, ChordStreamSource } from './_shared/core/contract/chord-contract';
+import type { NetworkGraphNodeDragEventDetail, NetworkGraphPinnedNode, NetworkGraphData, NetworkGraphHitDetail, NetworkGraphLinkEventDetail, NetworkGraphLinkInput, NetworkGraphNodeEventDetail, NetworkGraphSelection, NetworkGraphSelectionChangeEventDetail, NetworkGraphStreamSource } from './_shared/core/contract/network-graph-contract';
+import type { StemLeafPointEventDetail } from './stem-leaf-chart/core/types';
+import type { HistogramBinsRule } from './histogram-chart/core/types';
+import type { WaferMapMode } from './wafer-map-chart/core/types';
+import type { WaferIndicator, WaferOrientation } from './wafer-map-chart/core/wafer-geometry';
+import type { DieIndexEntry, DieIndexOrigin } from './wafer-map-chart/core/wafer-die-index';
+import type { PolarChartPointEventDetail } from './polar-chart/core/types';
+import type { GaugeActivityRingSpec, GaugeChartPointerEventDetail, GaugeChartVariant, GaugeColorStop, GaugeNeedleShape, GaugeNeedleSpec, GaugePlotBand, GaugeValueDisplay } from './gauge-chart/core/types';
+import type { GaugeChartStreamSource } from './gauge-chart/core/gauge-stream-source';
+import type { GaugeChartTooltipInput, GaugeChartTooltipShowEventDetail } from './gauge-chart/core/gauge-tooltip';
+import type { RadarChartData, RadarChartPointerEventDetail, RadarGridShape } from './radar-chart/core/types';
+import type { RadarChartStreamSource, RadarStreamFrame } from './radar-chart/core/radar-stream-source';
+import type { RadarChartTooltipInput, RadarChartTooltipShowEventDetail } from './radar-chart/core/radar-tooltip';
+import type { FunnelChartData, FunnelChartPointerEventDetail, FunnelLabelPlacement, FunnelSectionSpec } from './funnel-chart/core/types';
+import type { FunnelChartStreamSource } from './funnel-chart/core/funnel-stream-source';
+import type { FunnelChartTooltipInput, FunnelChartTooltipShowEventDetail } from './funnel-chart/core/funnel-tooltip';
+import type { DumbbellDatum } from './dumbbell-chart/core/types';
+import type { VariwideDatum } from './variwide-chart/core/types';
+import type { TornadoDatum } from './tornado-chart/core/types';
+import type { DotPlotDatum } from './dot-plot-chart/core/types';
+import { type ChartDataTable } from './_shared/core/export';
+import { type ChartMenuItem } from './_shared/core/menu';
+import type { ChartContextMenuEventDetail, ChartContextMenuItemEventDetail, ChartEngineTier, ChartRenderResult, ChartSeriesToggledEventDetail } from './facade-types';
+import { type ChartPointContextMenuEventDetail } from './_shared/core/event';
+import { type ChartTheme, type ChartThemeName } from './_shared/core/theme';
+import { type ChartLocale, type ChartLocaleName } from './_shared/core/locale';
+export type ChartStreamSource = Scatter3DStreamSource | FlowLinesStreamSource | ThemeRiverStreamSource | Bar3DStreamSource | Surface3DStreamSource | GanttStreamSource | ParallelCoordinatesStreamSource | LineChartStreamSource | AreaChartStreamSource | ColumnChartStreamSource | BarChartStreamSource | ScatterChartStreamSource | PieChartStreamSource | GaugeChartStreamSource | RadarChartStreamSource | FunnelChartStreamSource | ChordStreamSource | NetworkGraphStreamSource;
+import type { GeoMapLayer, GeoMapLayersInput, GeoMapLayerDetail, GeoMapLayerChangeEventDetail, GeoMapDiagnostics, GeoMapAvailabilityDetail } from './_shared/core/contract/geo-map-contract';
+export type ChartType = 'flow-lines' | 'theme-river' | 'bar-3d' | 'scatter-3d' | 'surface-3d' | 'line' | 'area' | 'column' | 'bar' | 'scatter' | 'pie' | 'item' | 'polar' | 'gauge' | 'radar' | 'funnel' | 'pyramid' | 'pareto' | 'lollipop' | 'dumbbell' | 'variwide' | 'tornado' | 'marimekko' | 'dot-plot' | 'word-cloud' | 'pictorial' | 'tilemap' | 'stem-leaf' | 'histogram' | 'wafer-map' | 'heatmap' | 'density-map' | 'spectrogram' | 'calendar-heatmap' | 'candlestick' | 'ohlc' | 'box-plot' | 'bubble' | 'waterfall' | 'error-bar' | 'sankey' | 'chord' | 'network-graph' | 'treemap' | 'sunburst' | 'icicle' | 'gantt' | 'parallel-coordinates' | 'dendrogram' | 'geo-map' | (string & {});
+export type ChartAnimationType = 'initial' | 'update';
+export interface ChartContextMenuOpenOptions {
+    x?: number;
+    y?: number;
+}
+export declare class SyChart {
+    host: HTMLElement;
+    type: ChartType;
+    typeLoadTimeout: number;
+    brandLogo?: string;
+    brandPosition: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    typeLoadChange: EventEmitter<ChartTypeLoadDetail>;
+    private typeLoad?;
+    private readonly loadController;
+    series?: LineChartSeries[] | ScatterChartSeries[];
+    activeSeriesIndex?: number;
+    seriesState?: LineChartSeriesStateOptions;
+    values: LineChartValues | ScatterChartValues;
+    width: number;
+    height: number;
+    color: string | ReadonlyArray<string>;
+    thickness: number;
+    marker: LineChartMarker | ScatterChartMarkerSymbol | string | ReadonlyArray<string>;
+    markerSize: number;
+    markerLineWidth: number;
+    hitTolerance: number;
+    markerFilter?: LineChartMarkerFilter;
+    markerClickable: boolean;
+    markerActiveTrigger: LineChartMarkerActiveTrigger;
+    seriesActiveTrigger?: LineChartMarkerActiveTrigger;
+    lineDash: number[];
+    connectNulls: boolean;
+    smooth: LineChartSmooth;
+    smoothTension: number;
+    step: LineChartStep;
+    engine: LineChartEngineMode;
+    proThreshold: number;
+    unavailable: LineChartUnavailableBehaviour;
+    streamSource?: ChartStreamSource;
+    streamWindow?: number;
+    streamMax?: number;
+    frameBudget?: number;
+    streamWindowMs?: number;
+    streamTimestamps?: 'on' | 'off';
+    animated: boolean;
+    animationDuration: number;
+    animationEasing: LineChartEasing;
+    animationType?: ChartAnimationType;
+    legend?: boolean;
+    legendPosition: LineChartLegendPosition;
+    legendItems?: LegendItem[];
+    seriesName?: string;
+    legendFloatAlign: 'start' | 'center' | 'end';
+    legendFloatVerticalAlign: 'top' | 'middle' | 'bottom';
+    legendDraggable: boolean;
+    rendered: EventEmitter<ChartRenderResult & {
+        type: ChartType;
+        tier: ChartEngineTier;
+    }>;
+    appended: EventEmitter<ChartAppendedEventDetail>;
+    windowSlid: EventEmitter<{
+        dropped: number;
+    }>;
+    chartAnimationStart: EventEmitter<void>;
+    chartAnimationEnd: EventEmitter<void>;
+    chartAnimationInterrupted: EventEmitter<void>;
+    pointHover: EventEmitter<ChartPointEventDetail | null>;
+    dependencyClick: EventEmitter<GanttDependencyHitDetail>;
+    taskEditStart: EventEmitter<GanttTaskEditEventDetail>;
+    taskEditMove: EventEmitter<GanttTaskEditEventDetail>;
+    taskEditEnd: EventEmitter<GanttTaskEditEventDetail>;
+    taskEditCancel: EventEmitter<GanttTaskEditEventDetail>;
+    dependencyHover: EventEmitter<GanttDependencyHitDetail | null>;
+    dependencySelectionChange: EventEmitter<GanttDependencySelectionChange>;
+    pointClick: EventEmitter<ChartPointEventDetail>;
+    pointContextMenu: EventEmitter<ChartPointContextMenuEventDetail>;
+    pointChange: EventEmitter<RadarChartPointerEventDetail>;
+    pointDragStart: EventEmitter<NetworkGraphNodeDragEventDetail>;
+    pointDragMove: EventEmitter<NetworkGraphNodeDragEventDetail>;
+    pointDragEnd: EventEmitter<NetworkGraphNodeDragEventDetail>;
+    seriesClick: EventEmitter<{
+        cssX: number;
+        cssY: number;
+    }>;
+    seriesOutsideClick: EventEmitter<CartesianSeriesOutsideClickEventDetail>;
+    legendItemClick: EventEmitter<ChartLegendItemEventDetail>;
+    seriesToggled: EventEmitter<ChartSeriesToggledEventDetail>;
+    fillColor?: string;
+    fillOpacity?: number;
+    fillGradient?: unknown;
+    fillPattern?: unknown;
+    patternKind?: AreaChartPatternKind;
+    patternColor?: string;
+    patternBackground?: string;
+    patternSize?: number;
+    patternThickness?: number;
+    barPadding: number;
+    seriesPadding: number;
+    baseline: number;
+    stacking?: CartesianSeriesStackingMode;
+    borderRadius?: CartesianSeriesCornerRadiusValue;
+    borderScope?: 'point' | 'stack' | 'outline';
+    borderColor?: string;
+    borderWidth?: number;
+    borderDashStyle?: CartesianSeriesBorderDashStyle;
+    inactiveOtherPoints: boolean;
+    inactivePointOpacity: number;
+    xAxis?: CartesianAxisInput | ReadonlyArray<CartesianAxisInput>;
+    source?: Dataset | DatasetSourceInput | ReadonlyArray<DatasetRow> | null;
+    sourceTransforms?: ReadonlyArray<DatasetTransform>;
+    encode?: DatasetEncode | ReadonlyArray<DatasetEncode>;
+    progressive?: number | boolean;
+    progressiveThreshold: number;
+    yAxis?: CartesianAxisInput;
+    chartTitle?: string;
+    chartSubtitle?: string;
+    tooltip?: CartesianTooltipInput | PieChartTooltipInput | GaugeChartTooltipInput | RadarChartTooltipInput | FunnelChartTooltipInput;
+    crosshair?: CartesianCrosshairInput;
+    gridLines?: CartesianGridLinesInput;
+    zoom?: CartesianZoomInput;
+    brush?: CartesianBrushInput;
+    drawings?: ChartDrawingsInput;
+    drawingMode?: DrawingModeInput;
+    drawingTool?: string;
+    drawingSpace?: DrawingSpace;
+    visualMap?: VisualMapBinding | null;
+    xLabelMode?: 'auto' | 'all' | 'thin' | 'rotate' | 'none';
+    xLabelRotation?: number;
+    xLabelMaxCount?: number;
+    crosshairMove: EventEmitter<CartesianCrosshairEventDetail | ParallelCoordinatesCrosshairDetail | null | Surface3DCrosshairDetail | Scatter3DCrosshairDetail | ThemeRiverCrosshairDetail | Bar3DCrosshairDetail>;
+    tooltipShow: EventEmitter<CartesianTooltipEventDetail | PieChartTooltipShowEventDetail | GaugeChartTooltipShowEventDetail | RadarChartTooltipShowEventDetail | FunnelChartTooltipShowEventDetail>;
+    tooltipHide: EventEmitter<void>;
+    zoomChange: EventEmitter<CartesianZoomChangeEventDetail>;
+    mapViewChange: EventEmitter<GeoMapViewChangeEventDetail>;
+    mapLayerChange: EventEmitter<GeoMapLayerChangeEventDetail>;
+    featureClick: EventEmitter<GeoMapFeatureHitDetail>;
+    featureHover: EventEmitter<GeoMapFeatureHitDetail | null>;
+    featureSelectionChange: EventEmitter<GeoMapFeatureSelectionChangeEventDetail>;
+    axisBrushChange: EventEmitter<ParallelCoordinatesBrushChangeEventDetail>;
+    axisBrushStart: EventEmitter<ParallelCoordinatesBrushGestureEventDetail>;
+    axisBrushMove: EventEmitter<ParallelCoordinatesBrushGestureEventDetail>;
+    axisBrushEnd: EventEmitter<ParallelCoordinatesBrushGestureEventDetail>;
+    brushChange: EventEmitter<CartesianBrushChangeEventDetail>;
+    actionDispatched: EventEmitter<ChartActionEventDetail>;
+    renderProgress: EventEmitter<{
+        drawn: number;
+        total: number;
+        done: boolean;
+    }>;
+    brushStart: EventEmitter<CartesianBrushStartEventDetail>;
+    brushMove: EventEmitter<CartesianBrushMoveEventDetail>;
+    brushEnd: EventEmitter<CartesianBrushEndEventDetail>;
+    drawingsChange: EventEmitter<DrawingsChangeEventDetail>;
+    drawingSelectionChange: EventEmitter<DrawingSelectionChangeEventDetail>;
+    tooltipAction: EventEmitter<ChartTooltipActionEventDetail>;
+    sliceClick: EventEmitter<PieChartSliceEventDetail>;
+    sliceHover: EventEmitter<PieChartSliceEventDetail | null>;
+    sliceSelected: EventEmitter<PieChartSelectedEventDetail>;
+    sliceToggled: EventEmitter<{
+        index: number;
+        sliceId: string;
+        disabled: boolean;
+    }>;
+    selectionChanged: EventEmitter<SankeySelectionChangeEventDetail | ChordSelectionChangeEventDetail | NetworkGraphSelectionChangeEventDetail | TreemapSelectionChangeEventDetail | SunburstSelectionChangeEventDetail | IcicleSelectionChangeEventDetail | GanttSelectionChangeEventDetail | ParallelCoordinatesSelectionChangeEventDetail | DendrogramSelectionChangeEventDetail | GeoMapSelectionChangeEventDetail | Surface3DSelectionChangeEventDetail | Scatter3DSelectionChangeEventDetail | FlowLinesSelectionChangeEventDetail | ThemeRiverSelectionChangeEventDetail | Bar3DSelectionChangeEventDetail>;
+    drillChange: EventEmitter<TreemapDrillChangeEventDetail | SunburstDrillChangeEventDetail | IcicleDrillChangeEventDetail | DendrogramDrillChangeEventDetail>;
+    gaugeClick: EventEmitter<GaugeChartPointerEventDetail>;
+    gaugeHover: EventEmitter<GaugeChartPointerEventDetail | null>;
+    valueChange: EventEmitter<{
+        value: number;
+        fraction: number;
+    }>;
+    needleToggled: EventEmitter<{
+        index: number;
+        needleId: string;
+        disabled: boolean;
+    }>;
+    sectionClick: EventEmitter<FunnelChartPointerEventDetail>;
+    sectionHover: EventEmitter<FunnelChartPointerEventDetail | null>;
+    sectionToggled: EventEmitter<{
+        index: number;
+        sectionId: string;
+        disabled: boolean;
+    }>;
+    private lineChart?;
+    private boundLineChart?;
+    private areaChart?;
+    private columnChart?;
+    private barChart?;
+    private scatterChart?;
+    private pieChart?;
+    private boundPieChart?;
+    private gaugeChart?;
+    private boundGaugeChart?;
+    private radarChart?;
+    private boundRadarChart?;
+    private funnelChart?;
+    private boundFunnelChart?;
+    private itemChart?;
+    private boundItemChart?;
+    private wordCloud?;
+    private boundWordCloud?;
+    private tilemap?;
+    private boundTilemap?;
+    private heatmap?;
+    private densityMap?;
+    private spectrogram?;
+    private calendarHeatmap?;
+    private candlestick?;
+    private boxPlot?;
+    private bubble?;
+    private waterfall?;
+    private errorBar?;
+    private sankey?;
+    private chord?;
+    private networkGraph?;
+    private dendrogram?;
+    private geoMap?;
+    private icicle?;
+    private gantt?;
+    private parallelCoordinates?;
+    private flowLines?;
+    private themeRiver?;
+    private bar3d?;
+    private scatter3d?;
+    private surface3d?;
+    private get scene3d();
+    private sunburst?;
+    private treemap?;
+    private stemLeafChart?;
+    private boundStemLeafChart?;
+    private histogramChart?;
+    private waferMap?;
+    private polarChart?;
+    private lastSyncedPolarData?;
+    private lastSyncedPolarCategories?;
+    private readonly lastSyncedRefs;
+    private forwardIfChanged;
+    private boundPolarChart?;
+    private paretoChart?;
+    private lollipopChart?;
+    private pictorialChart?;
+    private dumbbellChart?;
+    private variwideChart?;
+    private tornadoChart?;
+    private marimekkoChart?;
+    private dotPlotChart?;
+    innerSize?: number | string;
+    startAngleProp?: number;
+    endAngleProp?: number;
+    centerText?: string;
+    centerSubtext?: string;
+    slicedOffset?: number;
+    palette?: PieChartPaletteName;
+    colors?: ReadonlyArray<string>;
+    labelsMode?: PieChartLabelMode;
+    labelsContent?: PieChartLabelContent;
+    labelsDistance?: number;
+    labelsFontSize?: number;
+    labelsMinSweep?: number;
+    labelsConnector?: boolean;
+    allowSelect?: boolean;
+    inactiveOtherSlices?: boolean;
+    inactiveSliceOpacity?: number;
+    activeSliceIndex?: number;
+    labelsFontWeight?: number;
+    labelsColor?: string;
+    labelsConnectorColor?: string;
+    labelsConnectorWidth?: number;
+    labelsConnectorPadding?: number;
+    labelsConnectorShape?: 'crooked' | 'straight';
+    labelsAllowOverlap?: boolean;
+    tooltipEnabled?: boolean;
+    tooltipFormat?: ((slice: PieChartResolvedSlice) => string) | ((detail: ChordHitDetail) => string) | ((detail: NetworkGraphHitDetail) => string) | ((detail: TreemapHitDetail) => string) | ((detail: SunburstHitDetail) => string) | ((detail: IcicleHitDetail) => string) | ((detail: GanttHitDetail) => string) | ((detail: ParallelCoordinatesHitDetail) => string) | ((detail: DendrogramHitDetail) => string) | ((detail: GeoMapHitDetail) => string);
+    enableMouseTracking?: boolean;
+    stickyTracking?: boolean;
+    size?: number | string;
+    centerX?: number | string;
+    centerY?: number | string;
+    minSize?: number;
+    donutThickness?: number;
+    symbol?: ItemChartSymbol;
+    rows?: number;
+    itemPadding?: number;
+    minFontSize?: number;
+    maxFontSize?: number;
+    weightScale?: WordCloudWeightScale;
+    spiral?: WordCloudSpiral;
+    orientations?: number;
+    rotationFrom?: number;
+    rotationTo?: number;
+    wordPadding?: number;
+    paths?: ReadonlyArray<string>;
+    iconPadding?: number;
+    trackOpacity?: number;
+    tileShape?: TilemapTileShape;
+    showLabels?: boolean;
+    labelColor?: string;
+    colorAxis?: TilemapColorAxisInput;
+    colorLegend?: boolean;
+    matrix?: HeatmapMatrixInput;
+    xCategories?: HeatmapCategoriesInput;
+    yCategories?: HeatmapCategoriesInput;
+    emptyColor?: string;
+    padding?: number;
+    headerHeight?: number;
+    drilldown: boolean;
+    dendrogramDirection: DendrogramDirection;
+    icicleDirection: IcicleDirection;
+    parallelCoordinatesAxes?: ParallelCoordinatesAxesInput;
+    parallelCoordinatesBrush?: ParallelCoordinatesBrushInput;
+    parallelCoordinatesDimensions?: ReadonlyArray<ParallelCoordinatesDimensionInput>;
+    parallelCoordinatesLineWidth: number;
+    parallelCoordinatesLineOpacity: number;
+    parallelCoordinatesInactiveRowOpacity: number;
+    parallelCoordinatesAxisLabels: boolean;
+    camera3d?: Scene3DCameraOptions | string;
+    orbit3d?: Orbit3DOptions | boolean | string;
+    lighting3d?: Scene3DLightingOptions;
+    material3d?: Scene3DMaterialOptions;
+    flowLinesStyle?: FlowLinesStyle;
+    flowLinesPath: GeoMapConnectionPath;
+    flowLinesLocationLabels: GeoMapLabelMode;
+    flowLinesLabels: GeoMapLabelMode;
+    flowLinesLabelValue: boolean;
+    themeRiverAxes?: ThemeRiverAxesOptions;
+    themeRiverOffset: ThemeRiverOffset;
+    themeRiverOrder: ThemeRiverOrder;
+    themeRiverColors?: ReadonlyArray<string>;
+    themeRiverOpacity: number;
+    themeRiverHiddenSeries: ReadonlyArray<ThemeRiverId>;
+    bar3dAxes?: Bar3DAxesOptions | boolean | string;
+    scatter3dAxes?: Scatter3DAxesOptions | boolean | string;
+    bar3dSize?: Scene3DVector;
+    scatter3dSize?: Scene3DVector;
+    bar3dColors?: HeatmapColorInput;
+    scatter3dColors?: HeatmapColorInput;
+    bar3dColorDomain?: Bar3DDomain;
+    scatter3dColorDomain?: Scatter3DDomain;
+    bar3dMissingColor?: string;
+    scatter3dMissingColor?: string;
+    bar3dOpacity: number;
+    bar3dWidth: number;
+    bar3dDepth: number;
+    bar3dXCategories?: ReadonlyArray<Bar3DCategory>;
+    bar3dYCategories?: ReadonlyArray<Bar3DCategory>;
+    scatter3dOpacity: number;
+    scatter3dMarker: Scatter3DMarker;
+    scatter3dMarkerRadius: number;
+    scatter3dMarkerDetail: 0 | 1 | 2;
+    surface3dAxes?: Surface3DAxesOptions | boolean | string;
+    surface3dSize?: Scene3DVector;
+    surface3dColors?: HeatmapColorInput;
+    surface3dColorDomain?: Surface3DDomain;
+    surface3dMissingColor?: string;
+    surface3dOpacity: number;
+    surface3dWireframe: boolean;
+    surface3dWireWidth: number;
+    surface3dWireColor?: string;
+    cameraChange: EventEmitter<Surface3DCameraChangeEventDetail>;
+    dataValidationError: EventEmitter<ChartDataValidationErrorDetail>;
+    ganttBarHeight: number;
+    ganttRowGap: number;
+    ganttTimeDomain?: readonly [
+        number,
+        number
+    ];
+    ganttCriticalPath?: GanttCriticalPathInput;
+    ganttTaskEditing?: GanttTaskEditingInput;
+    ganttBaseline?: GanttBaselineStyleInput;
+    ganttDependencies?: ReadonlyArray<GanttDependencyInput>;
+    ganttDependencyStyle?: GanttDependencyStyleInput;
+    ganttTimeAxis?: GanttTimeAxisInput;
+    ganttCrosshairTimeUnit: GanttCrosshairTimeUnit;
+    ganttBarRadius: number;
+    ganttProgressShow: boolean;
+    ganttProgressColor: string;
+    taskLabelFormat?: (task: GanttTask) => string;
+    taskLabels?: GanttLabelMode;
+    kernel?: DensityMapKernel;
+    bandwidth?: DensityMapBandwidthInput;
+    bandwidthUnit?: DensityMapBandwidthUnit;
+    cellSize?: number;
+    threshold?: number;
+    computePath?: DensityMapComputePathInput;
+    fade?: number;
+    densityUnit?: DensityMapUnitInput;
+    sampleRate?: number;
+    freqMin?: number;
+    freqMax?: number;
+    hopSeconds?: number;
+    timeOrigin?: number;
+    valueScale?: SpectrogramValueScale;
+    dbFloor?: number;
+    year?: number;
+    startDate?: string;
+    endDate?: string;
+    weekStart?: CalendarWeekStart;
+    aggregate?: CalendarAggregate;
+    noDataValue?: number | 'nan';
+    monthLabels?: boolean;
+    weekdayLabels?: CalendarWeekdayLabels;
+    monthLines?: boolean;
+    upColor?: string;
+    downColor?: string;
+    flatColor?: string;
+    candleWidth?: number;
+    wickWidth?: number;
+    bodyStyle?: CandlestickBodyStyle;
+    wickColor?: string;
+    timeScale?: CandlestickTimeScale;
+    session?: CandlestickSessionInput | string;
+    volume?: CandlestickVolumeMode;
+    volumeHeight?: number;
+    volumeUpColor?: string;
+    volumeDownColor?: string;
+    volumeAlpha?: number;
+    barStyle?: string;
+    overlays?: CandlestickOverlayInput | string;
+    boxColor?: string;
+    boxFillAlpha?: number;
+    medianColor?: string;
+    whiskerColor?: string;
+    outlierColor?: string;
+    boxWidth?: number;
+    whiskerRule?: string;
+    quantileMethod?: string;
+    whiskerPercentile?: number;
+    notched?: boolean;
+    showMean?: boolean;
+    meanColor?: string;
+    capWidth?: number;
+    whiskerWidth?: number;
+    medianWidth?: number;
+    outlierRadius?: number;
+    boxMinPx?: number;
+    boxMaxPx?: number;
+    notchWidth?: number;
+    meanSize?: number;
+    fillAlpha?: number;
+    minRadius?: number;
+    maxRadius?: number;
+    sizeScale?: string;
+    layout?: string;
+    clustering?: string;
+    bundling?: string;
+    bundleStrength?: number;
+    nodeDrag?: boolean;
+    packPadding?: number;
+    packFit?: string;
+    shading?: string;
+    shadeStrength?: number;
+    totalColor?: string;
+    connectorColor?: string;
+    connectorWidth?: number;
+    showConnectors?: boolean;
+    barWidth?: number;
+    barMinPx?: number;
+    barMaxPx?: number;
+    showTotal?: boolean;
+    totalLabel?: string;
+    detectResult?: boolean;
+    lastResult?: boolean;
+    labelMode?: string;
+    labelFormat?: (bar: unknown) => string;
+    errorColor?: string;
+    nodeRadius?: number;
+    projection?: GeoMapProjection;
+    features?: GeoMapFeatureCollection;
+    polygonColor?: string;
+    polygonOpacity?: number;
+    mapColorAxis?: GeoMapColorAxisInput;
+    mapBubble?: GeoMapBubbleInput;
+    mapHeat?: GeoMapHeatInput;
+    mapLayers?: GeoMapLayersInput;
+    mapLegend: boolean;
+    featureLabels?: GeoMapLabelMode;
+    featureLabelValue?: boolean;
+    featureTooltipFormat?: (detail: GeoMapFeatureHitDetail) => string;
+    connectionWidth?: number;
+    connectionColor?: string;
+    connectionOpacity?: number;
+    connectionPath: GeoMapConnectionPath;
+    crosshairSnapDistance: number;
+    mapRegion?: GeoMapRegion;
+    mapBackground?: GeoMapBackground;
+    mapFixed?: boolean;
+    linkWidth?: number;
+    linkDistance?: number;
+    repulsion?: number;
+    padAngle?: number;
+    nodeWidth?: number;
+    nodePadding?: number;
+    nodeAlign?: SankeyAlign;
+    linkColor?: string;
+    linkOpacity?: number;
+    layoutIterations?: number;
+    linkCurvature?: number;
+    nodeLabels?: SankeyLabelMode;
+    nodeLabelValue?: boolean;
+    neighbourDim?: number;
+    showBars?: boolean;
+    showCaps?: boolean;
+    samples?: ArrayLike<number>;
+    fftSize?: number;
+    fftHop?: number;
+    fftWindow?: SpectrogramWindowKind;
+    renderPath?: HeatmapRenderPath;
+    lod?: HeatmapLodMode;
+    areaReduce?: 'mean' | 'max';
+    stemUnit?: number;
+    stemSplit?: 1 | 2;
+    activeColor?: string;
+    showKey?: boolean;
+    bins?: HistogramBinsRule;
+    measure?: 'count' | 'percent' | 'density';
+    cumulative?: boolean;
+    barGap?: number;
+    binWidth?: number;
+    domainMin?: number;
+    domainMax?: number;
+    edgeColor?: string;
+    diameter?: number;
+    edgeExclusion?: number;
+    indicator?: WaferIndicator;
+    waferOrientation?: WaferOrientation;
+    dieWidth?: number;
+    dieHeight?: number;
+    scribeX?: number;
+    scribeY?: number;
+    showPartial?: boolean;
+    dieIndexOrigin?: DieIndexOrigin;
+    dieIndexBase?: number;
+    showDieIndex?: boolean;
+    mode?: WaferMapMode;
+    binColors?: Readonly<Record<string, string>>;
+    passBin?: number | string;
+    passColor?: string;
+    failColor?: string;
+    showStats?: boolean;
+    overlay?: 'none' | 'defect';
+    defects?: ReadonlyArray<{
+        x: number;
+        y: number;
+        class?: number | string;
+        size?: number;
+    }>;
+    defectColor?: string;
+    grid?: 'die' | 'shot';
+    shotCols?: number;
+    shotRows?: number;
+    shotOffsetX?: number;
+    shotOffsetY?: number;
+    shotColor?: string;
+    binLegend?: boolean;
+    sectorPadding?: number;
+    variableRadius?: boolean;
+    sizeBy?: PieChartSizeBy;
+    zMin?: number;
+    zMax?: number;
+    minPointSize?: number | string;
+    maxPointSize?: number | string;
+    data?: RadarChartData | FunnelChartData | ReadonlyArray<DumbbellDatum> | ReadonlyArray<DotPlotDatum> | ReadonlyArray<TornadoDatum> | ReadonlyArray<VariwideDatum> | ChordData | NetworkGraphData | TreemapData | SankeyData | ErrorBarData | WaterfallData | BubbleData | BoxPlotData | CandlestickData | CalendarHeatmapData | SpectrogramInput | DensityMapInput | HeatmapData | SunburstData | IcicleData | GanttData | ParallelCoordinatesData | DendrogramData | GeoMapData | Surface3DData | Scatter3DData | FlowLinesData | ThemeRiverData | Bar3DData;
+    categories?: string[];
+    gridShape?: RadarGridShape;
+    gridColor?: string;
+    lineWidth?: number;
+    showMarkers?: boolean;
+    markerRadius?: number;
+    showRingLabels?: boolean;
+    ringLabelColor?: string;
+    ringLabelFontSize?: number;
+    ringLabelFormat?: string;
+    categoryLabelColor?: string;
+    categoryLabelFontSize?: number;
+    editable?: boolean;
+    neckWidth?: number;
+    neckHeight?: number;
+    gap?: number;
+    labelPlacement?: FunnelLabelPlacement;
+    showPercent?: boolean;
+    inactiveOtherSections?: boolean;
+    inactiveSectionOpacity?: number;
+    activeSectionIndex?: number;
+    lineColor?: string;
+    referenceValue?: number;
+    showReference?: boolean;
+    referenceColor?: string;
+    sortDescending?: boolean;
+    valueAxisLabel?: string;
+    cumulativeAxisLabel?: string;
+    markerColor?: string;
+    orientation?: 'vertical' | 'horizontal';
+    lowName?: string;
+    highName?: string;
+    lowColor?: string;
+    highColor?: string;
+    weights?: Float32Array | Array<number | null | undefined>;
+    colorful?: boolean;
+    columnGap?: number;
+    leftValues?: Float32Array | Array<number | null | undefined>;
+    rightValues?: Float32Array | Array<number | null | undefined>;
+    leftColor?: string;
+    rightColor?: string;
+    leftLabel?: string;
+    rightLabel?: string;
+    showColumnShare?: boolean;
+    groups?: ReadonlyArray<string>;
+    showRowLines?: boolean;
+    value?: number;
+    min?: number;
+    max?: number;
+    needles?: GaugeNeedleSpec[];
+    rings?: GaugeActivityRingSpec[];
+    time?: string;
+    showSeconds?: boolean;
+    variant?: GaugeChartVariant;
+    innerRadius?: number | string;
+    stops?: GaugeColorStop[];
+    needleShape?: GaugeNeedleShape;
+    needleLength?: number | string;
+    needleRearLength?: number | string;
+    needleWidth?: number;
+    pivotRadius?: number;
+    pivotColor?: string;
+    plotBands?: GaugePlotBand[] | 'auto';
+    bandThickness?: number;
+    bandTrackColor?: string;
+    valueDisplay?: GaugeValueDisplay;
+    rounded?: boolean;
+    trackColor?: string;
+    showTicks?: boolean;
+    tickInterval?: number | 'auto';
+    minorTicks?: number;
+    tickLength?: number;
+    minorTickLength?: number;
+    tickWidth?: number;
+    minorTickWidth?: number;
+    tickColor?: string;
+    showTickLabels?: boolean;
+    tickLabelDistance?: number;
+    tickLabelColor?: string;
+    tickLabelFontSize?: number;
+    tickLabelFormat?: string;
+    showValue?: boolean;
+    valueFormat?: string;
+    valueColor?: string;
+    valueFontSize?: number;
+    unit?: string;
+    analogDamping?: number;
+    analogFrequency?: number;
+    analogOvershootAngle?: number;
+    loading: boolean;
+    loadingText?: string;
+    emptyText?: string;
+    showEmpty: boolean;
+    private imperativeFeed;
+    error?: boolean | string;
+    errorText?: string;
+    contextmenu: boolean;
+    contextMenuItems?: ChartMenuItem[];
+    exportFilename?: string;
+    exportScale: number;
+    exportBackground?: string;
+    theme?: ChartThemeName | ChartTheme;
+    private themeRedrawPending;
+    handleChartThemeChange(): void;
+    locale?: ChartLocaleName | Partial<ChartLocale>;
+    private contextMenuOpen;
+    private dataTableOpen;
+    private pendingDataTableFocus;
+    private frameAriaPointCount?;
+    resetFrameAriaPointCount(): void;
+    private dataTableReturnFocus?;
+    private normalizedDataTable?;
+    private normalizedTableVersion;
+    resetNormalizedDataTable(): void;
+    private normalizedDataTableTarget;
+    private refreshNormalizedDataTable;
+    private sankeyDataTable?;
+    private sankeyTableVersion;
+    private chordDataTable?;
+    private chordTableVersion;
+    private networkGraphDataTable?;
+    private dendrogramDataTable?;
+    private geoMapDataTable?;
+    private icicleDataTable?;
+    private ganttDataTable?;
+    private parallelCoordinatesDataTable?;
+    private flowLinesDataTable?;
+    private flowLinesPointCount?;
+    private flowLinesHasPaintedRoutes;
+    private flowLinesUnavailable;
+    private flowLinesTableVersion;
+    resetFlowLinesDataState(): void;
+    private themeRiverDataTable?;
+    private themeRiverPointCount?;
+    private themeRiverHasPaintedBands;
+    private themeRiverUnavailable;
+    private themeRiverTableVersion;
+    resetThemeRiverDataState(): void;
+    private bar3dDataTable?;
+    private scatter3dDataTable?;
+    private bar3dPointCount?;
+    private scatter3dPointCount?;
+    private bar3dHasPaintedPoints;
+    private scatter3dHasPaintedPoints;
+    private bar3dTableVersion;
+    private scatter3dTableVersion;
+    resetBar3DDataState(): void;
+    resetScatter3DDataState(): void;
+    private surface3dDataTable?;
+    private surface3dPointCount?;
+    private surface3dHasPaintedCells;
+    private surface3dTableVersion;
+    resetSurface3DDataState(): void;
+    private sunburstDataTable?;
+    private treemapDataTable?;
+    private dendrogramTableVersion;
+    private geoMapTableVersion;
+    private icicleTableVersion;
+    private ganttTableVersion;
+    private parallelCoordinatesTableVersion;
+    private sunburstTableVersion;
+    private treemapTableVersion;
+    private dendrogramPointCount?;
+    private geoMapPointCount?;
+    private iciclePointCount?;
+    private ganttPointCount?;
+    private parallelCoordinatesPointCount?;
+    private dendrogramHasPaintedRects;
+    private geoMapHasPaintedRects;
+    private icicleHasPaintedRects;
+    private ganttHasPaintedRects;
+    private parallelCoordinatesHasPaintedLines;
+    private sunburstPointCount?;
+    private treemapPointCount?;
+    private networkGraphTableVersion;
+    private networkGraphPointCount?;
+    resetSankeyDataState(): void;
+    resetNetworkGraphDataState(): void;
+    resetDendrogramDataState(): void;
+    resetGeoMapDataState(): void;
+    resetIcicleDataState(): void;
+    resetParallelCoordinatesDataState(): void;
+    resetGanttDataState(): void;
+    resetSunburstDataState(): void;
+    resetTreemapDataState(): void;
+    private contextMenuFocusIndex;
+    private contextMenuClientX;
+    private contextMenuClientY;
+    private contextMenuDisplayX;
+    private contextMenuDisplayY;
+    private resolvedThemePalette;
+    private resolvedThemeText;
+    private resolvedThemeBackground;
+    private contextMenuLocalX;
+    private contextMenuLocalY;
+    contextMenuOpened: EventEmitter<ChartContextMenuEventDetail>;
+    contextMenuClosed: EventEmitter<void>;
+    contextMenuItemSelect: EventEmitter<ChartContextMenuItemEventDetail>;
+    exported: EventEmitter<{
+        format: 'png' | 'svg' | 'csv' | 'json';
+        filename: string;
+    }>;
+    dataTableToggled: EventEmitter<{
+        open: boolean;
+    }>;
+    private renderCtx?;
+    private pendingContextMenuFocus;
+    private contextMenuReturnFocus?;
+    componentWillLoad(): void;
+    requestTypeLoad(): void;
+    parseValuesAttribute(next: unknown): void;
+    parseCategoriesAttribute(next: unknown): void;
+    connectedCallback(): void;
+    private hasRendered;
+    private rerenderAfterReconnect;
+    disconnectedCallback(): void;
+    componentShouldUpdate(_newValue: unknown, _oldValue: unknown, propName: string): boolean;
+    handleConnectNullsChange(): void;
+    componentWillRender(): void;
+    private ctx;
+    private isStreamingActive;
+    private computeRenderCtx;
+    private chartDataPayload;
+    private chartSeriesNames;
+    private sourceDataTable;
+    private dataTableInput;
+    private surfaceElement;
+    private exportBg;
+    private exportBaseName;
+    private isContextMenuEnabled;
+    private effectiveAnimated;
+    private effectiveAnimationDuration;
+    private themeHostClass;
+    private resolveColorToken;
+    private updateResolvedThemeTokens;
+    private hasExplicitColor;
+    private effectiveColor;
+    private heatmapDataPayload;
+    private densityMapDataPayload;
+    private spectrogramDataPayload;
+    private childNoticeShown;
+    private renderTypeGate;
+    private currentTypeLoad;
+    private renderTypeNotice;
+    private onTypeLoadChange;
+    private reportedTypeLoads;
+    private reportTypeLoad;
+    private bubbleEngineProps;
+    private childUnavailable;
+    private handleHeatmapPointClick;
+    private handleHeatmapPointHover;
+    private handleDensityMapPointClick;
+    private handleDensityMapPointHover;
+    private handleSpectrogramPointClick;
+    private handleSpectrogramPointHover;
+    private handleCalendarHeatmapPointClick;
+    private handleCalendarHeatmapPointHover;
+    private handleCandlestickPointClick;
+    private handleCandlestickPointHover;
+    private handleBoxPlotPointClick;
+    private handleBoxPlotPointHover;
+    private handleBubblePointClick;
+    private handleBubblePointHover;
+    private handleWaterfallPointClick;
+    private handleWaterfallPointHover;
+    private handleErrorBarPointClick;
+    private handleErrorBarPointHover;
+    private handleSankeyClick;
+    private handleSankeyHover;
+    private handleSankeySelectionChange;
+    private handleChordClick;
+    private handleChordHover;
+    private handleChordSelectionChange;
+    private handleNetworkGraphClick;
+    private handleDendrogramClick;
+    private handleGeoMapClick;
+    private handleIcicleClick;
+    private forwardGanttTaskEdit;
+    private handleGanttTaskEditStart;
+    private handleGanttTaskEditMove;
+    private handleGanttTaskEditEnd;
+    private handleGanttTaskEditCancel;
+    private handleGanttDependencyClick;
+    private handleGanttDependencyHover;
+    private handleGanttDependencySelection;
+    private handleFlowLinesClick;
+    private handleFlowLinesHover;
+    private handleFlowLinesSelection;
+    private handleFlowLinesValidation;
+    private handleThemeRiverClick;
+    private handleThemeRiverHover;
+    private handleThemeRiverSelection;
+    private handleThemeRiverValidation;
+    getFlowLinesData(): Promise<FlowLinesData | null>;
+    getFlowLinesLayout(): Promise<FlowLinesLayout | null>;
+    getFlowLinesDiagnostics(): Promise<FlowLinesDiagnostics | null>;
+    selectFlowLines(id: FlowLinesId, kind?: 'flow' | 'location'): Promise<FlowLinesHitDetail | null>;
+    showFlowLinesTooltip(index: number, kind?: 'flow' | 'location'): Promise<CartesianTooltipEventDetail | null>;
+    clearFlowLinesStream(): Promise<void>;
+    recycleFlowLinesGpu(): Promise<void>;
+    getThemeRiverData(): Promise<ThemeRiverData | null>;
+    getThemeRiverLayout(): Promise<ThemeRiverLayout | null>;
+    getThemeRiverDiagnostics(): Promise<ThemeRiverDiagnostics | null>;
+    selectThemeRiverPoint(series: number, column: number): Promise<ThemeRiverHitDetail | null>;
+    showThemeRiverTooltip(series: number, column: number): Promise<CartesianTooltipEventDetail | null>;
+    showThemeRiverCrosshair(series: number, column: number): Promise<boolean>;
+    clearThemeRiverStream(): Promise<void>;
+    recycleThemeRiverGpu(): Promise<void>;
+    private handleBar3DClick;
+    private handleScatter3DClick;
+    private handleSurface3DClick;
+    private handleBar3DHover;
+    private handleScatter3DHover;
+    private handleSurface3DHover;
+    private handleBar3DSelection;
+    private handleScatter3DSelection;
+    private handleSurface3DSelection;
+    private handleCamera3DChange;
+    private handleBar3DValidation;
+    private handleScatter3DValidation;
+    private handleSurface3DValidation;
+    getBar3DData(): Promise<Bar3DDatum[] | null>;
+    getScatter3DData(): Promise<Scatter3DDatum[] | null>;
+    getBar3DLayout(): Promise<Bar3DGeometry | null>;
+    getScatter3DLayout(): Promise<Scatter3DGeometry | null>;
+    getBar3DDiagnostics(): Promise<Bar3DDiagnostics | null>;
+    getScatter3DDiagnostics(): Promise<Scatter3DDiagnostics | null>;
+    selectBar3DPoint(index: number): Promise<Bar3DHitDetail | null>;
+    selectScatter3DPoint(index: number): Promise<Scatter3DHitDetail | null>;
+    showBar3DTooltip(index: number): Promise<CartesianTooltipEventDetail | null>;
+    showScatter3DTooltip(index: number): Promise<CartesianTooltipEventDetail | null>;
+    showBar3DCrosshair(index: number): Promise<boolean>;
+    showScatter3DCrosshair(index: number): Promise<boolean>;
+    getSurface3DData(): Promise<Surface3DGrid | null>;
+    getSurface3DLayout(): Promise<Surface3DGeometry | null>;
+    getSurface3DDiagnostics(): Promise<Surface3DDiagnostics | null>;
+    selectSurface3DPoint(row: number, column: number): Promise<Surface3DHitDetail | null>;
+    showSurface3DTooltip(row: number, column: number): Promise<CartesianTooltipEventDetail | null>;
+    showSurface3DCrosshair(row: number, column: number): Promise<boolean>;
+    getCamera3D(): Promise<Scene3DCameraOptions | null>;
+    setCamera3D(options: Scene3DCameraOptions): Promise<void>;
+    setProjection3D(projection: Scene3DProjection): Promise<void>;
+    fitCamera3D(padding?: number): Promise<void>;
+    resetCamera3D(): Promise<void>;
+    saveCamera3D(): Promise<void>;
+    rotate3D(azimuth: number, polar?: number): Promise<void>;
+    pan3D(x: number, y: number): Promise<void>;
+    recycleGpu3D(): Promise<void>;
+    clearBar3DStream(): Promise<void>;
+    clearScatter3DStream(): Promise<void>;
+    clearSurface3DStream(): Promise<void>;
+    private handleParallelCoordinatesClick;
+    private handleGanttClick;
+    private handleSunburstClick;
+    private handleTreemapClick;
+    private handleNetworkGraphHover;
+    private handleDendrogramHover;
+    private handleGeoMapHover;
+    private handleIcicleHover;
+    private handleParallelCoordinatesHover;
+    private handleGanttHover;
+    private handleSunburstHover;
+    private handleTreemapHover;
+    private handleNetworkGraphSelectionChange;
+    private handleDendrogramSelectionChange;
+    private handleGeoMapSelectionChange;
+    private handleGeoMapViewChange;
+    private handleFeatureClick;
+    private handleMapLayerChange;
+    private handleFeatureHover;
+    private handleFeatureSelectionChange;
+    private handleIcicleSelectionChange;
+    private handleParallelCoordinatesSelectionChange;
+    private handleGanttSelectionChange;
+    private handleSunburstSelectionChange;
+    private handleTreemapSelectionChange;
+    private handleDendrogramDrillChange;
+    private handleIcicleDrillChange;
+    private handleSunburstDrillChange;
+    private handleTreemapDrillChange;
+    private handleNetworkGraphDragStart;
+    private handleNetworkGraphDragMove;
+    private handleNetworkGraphDragEnd;
+    private variantColor;
+    private variantMarker;
+    private effectiveColors;
+    private themedSeries;
+    getDataTable(): Promise<ChartDataTable>;
+    getCSV(): Promise<string>;
+    getSVG(): Promise<string | null>;
+    private exportSvgDocument;
+    private brandExportLayer;
+    private baseSvgMarkup;
+    private hasExportChrome;
+    private siblingSvgLayers;
+    private collectHtmlOverlayItems;
+    private surfaceFrame;
+    private withDrawingLayer;
+    exportCSV(): Promise<void>;
+    exportSVG(): Promise<void>;
+    exportPNG(): Promise<void>;
+    private toPngBlob;
+    private printFrame?;
+    print(): Promise<void>;
+    private removePrintFrame;
+    private settledTypeLoad;
+    private typeLoadRefused;
+    private typeDrawableNow;
+    private isDrawableTypeLoad;
+    private exportReadyType;
+    private renderWaiters;
+    private nextRender;
+    private mountedTypeChild;
+    private proChildTable;
+    setContextMenuEnabled(enabled: boolean): Promise<void>;
+    openContextMenu(options?: ChartContextMenuOpenOptions): Promise<void>;
+    closeContextMenu(): Promise<void>;
+    showDataTable(): Promise<void>;
+    hideDataTable(): Promise<void>;
+    private resolvedContextMenuItems;
+    private setContextMenuOpen;
+    private setDataTableOpen;
+    private focusDataTable;
+    private onDataTableKeyDown;
+    private refreshSankeyDataTable;
+    private refreshChordDataTable;
+    private refreshNetworkGraphDataTable;
+    private refreshDendrogramDataTable;
+    private refreshGeoMapDataTable;
+    private refreshIcicleDataTable;
+    private refreshFlowLinesDataTable;
+    private refreshThemeRiverDataTable;
+    private refreshBar3DDataTable;
+    private refreshScatter3DDataTable;
+    private refreshSurface3DDataTable;
+    private refreshParallelCoordinatesDataTable;
+    private refreshGanttDataTable;
+    private refreshSunburstDataTable;
+    private refreshTreemapDataTable;
+    private runContextMenuAction;
+    private reportedMenuRefusals;
+    private settleMenuAction;
+    private onContextMenuListKeyDown;
+    private onDocPointerDown;
+    private onDocKeyDown;
+    private attachContextMenuDismiss;
+    private detachContextMenuDismiss;
+    private contextMenuDetail;
+    private contextMenuItemLabel;
+    private contextMenuStyle;
+    private estimatedContextMenuHeight;
+    private clampContextMenuPosition;
+    private openContextMenuAtClient;
+    private chartLocalPoint;
+    private isContextMenuEmptyArea;
+    private openContextMenuFromEvent;
+    private onHostContextMenu;
+    private onHostKeyDown;
+    private renderHost;
+    private renderChrome;
+    private renderContextMenu;
+    private renderLoading;
+    private renderEmpty;
+    private renderError;
+    private renderDataTable;
+    redraw(): Promise<ChartRenderResult>;
+    getYield(): Promise<{
+        pass: number;
+        fail: number;
+        probed: number;
+        yield: number;
+    } | null>;
+    getValueStats(): Promise<{
+        count: number;
+        min: number;
+        max: number;
+        mean: number;
+        stdDev: number;
+        median: number;
+    } | null>;
+    getDefectSummary(): Promise<{
+        total: number;
+        offWafer: number;
+        byClass: Array<{
+            key: string;
+            count: number;
+        }>;
+    } | null>;
+    getShotOf(col: number, row: number): Promise<{
+        shotCol: number;
+        shotRow: number;
+    } | null>;
+    hitTestDie(cssX: number, cssY: number): Promise<unknown | null>;
+    selectDie(col: number, row: number): Promise<unknown | null>;
+    clearDieSelection(): Promise<void>;
+    getSelectedDie(): Promise<unknown | null>;
+    appendDie(datum: {
+        col: number;
+        row: number;
+        bin?: number | string;
+        value?: number;
+    }): Promise<void>;
+    updateDie(col: number, row: number, patch: {
+        bin?: number | string;
+        value?: number;
+    }): Promise<unknown | null>;
+    getDieIndex(col: number, row: number): Promise<DieIndexEntry | null>;
+    getDieByIndex(ix: number, iy: number): Promise<DieIndexEntry | null>;
+    getRunningTotal(): Promise<number | undefined>;
+    getTypeLoadState(): Promise<ChartTypeLoadDetail>;
+    whenTypeReady(): Promise<ChartTypeLoadDetail>;
+    retryTypeLoad(): Promise<ChartTypeLoadDetail>;
+    getEngineStatus(): Promise<ChartEngineStatus | null>;
+    private typeChildElement;
+    getActiveTier(): Promise<ChartEngineTier>;
+    setData(data: RadarChartData | FunnelChartData | ReadonlyArray<VariwideDatum> | HeatmapData | DensityMapInput | SpectrogramInput | CalendarHeatmapData | CandlestickData | BoxPlotData | BubbleData | WaterfallData | ErrorBarData | SankeyData | ChordData | NetworkGraphData | TreemapData | SunburstData | IcicleData | GanttData | ParallelCoordinatesData | DendrogramData | GeoMapData | Surface3DData | Scatter3DData | FlowLinesData | ThemeRiverData | Bar3DData): Promise<void>;
+    addSeries(options: LineChartSeries | ScatterChartSeries, opts?: {
+        redraw?: boolean;
+        insertAt?: number;
+    }): Promise<number>;
+    removeSeries(idOrIndex: string | number, opts?: {
+        redraw?: boolean;
+    }): Promise<boolean>;
+    updateSeries(idOrIndex: string | number, patch: Partial<LineChartSeries | ScatterChartSeries>, opts?: {
+        redraw?: boolean;
+    }): Promise<boolean>;
+    updatePoint(seriesIdOrIndex: string | number, categoryIdOrIndex: string | number, value: number | null): Promise<boolean>;
+    setSeriesData(idOrIndex: string | number, data: LineChartValues | ScatterChartValues, opts?: {
+        redraw?: boolean;
+    }): Promise<boolean>;
+    addPointToSeries(idOrIndex: string | number, point: number | ScatterChartDatum, opts?: {
+        shift?: boolean;
+        redraw?: boolean;
+    }): Promise<boolean>;
+    showSeries(idOrIndex: string | number, opts?: {
+        redraw?: boolean;
+    }): Promise<boolean>;
+    hideSeries(idOrIndex: string | number, opts?: {
+        redraw?: boolean;
+    }): Promise<boolean>;
+    appendPoint(value: number | ScatterChartDatum | PieChartDatum | RadarStreamFrame | FunnelSectionSpec | ChordLinkInput | NetworkGraphLinkInput | TreemapNodeInput | SunburstNodeInput | IcicleNodeInput | GanttTaskInput | ParallelCoordinatesRowInput | DendrogramNodeInput | GeoMapPointInput | Surface3DRowInput | Scatter3DDatum | FlowLinesRouteInput | ThemeRiverRow | Bar3DDatum): Promise<void>;
+    appendBatch(values: ReadonlyArray<number> | Float32Array | ScatterChartValues | ReadonlyArray<PieChartDatum> | ReadonlyArray<RadarStreamFrame> | ReadonlyArray<FunnelSectionSpec | number> | ReadonlyArray<ChordLinkInput> | ReadonlyArray<NetworkGraphLinkInput> | ReadonlyArray<TreemapNodeInput> | ReadonlyArray<SunburstNodeInput> | ReadonlyArray<IcicleNodeInput> | ReadonlyArray<GanttTaskInput> | ReadonlyArray<ParallelCoordinatesRowInput> | ReadonlyArray<DendrogramNodeInput> | ReadonlyArray<GeoMapPointInput> | ReadonlyArray<Surface3DRowInput> | ReadonlyArray<Scatter3DDatum> | ReadonlyArray<FlowLinesRouteInput | ThemeRiverRow> | ReadonlyArray<Bar3DDatum>): Promise<void>;
+    shift(count: number): Promise<void>;
+    replace(values: ReadonlyArray<number> | Float32Array | ScatterChartValues | ReadonlyArray<PieChartDatum> | ReadonlyArray<RadarStreamFrame> | ReadonlyArray<FunnelSectionSpec | number> | ReadonlyArray<ChordLinkInput> | ReadonlyArray<NetworkGraphLinkInput> | ReadonlyArray<TreemapNodeInput> | ReadonlyArray<SunburstNodeInput> | ReadonlyArray<IcicleNodeInput> | ReadonlyArray<GanttTaskInput> | ReadonlyArray<ParallelCoordinatesRowInput> | ReadonlyArray<DendrogramNodeInput> | ReadonlyArray<GeoMapPointInput> | ReadonlyArray<Surface3DRowInput> | ReadonlyArray<Scatter3DDatum> | ReadonlyArray<FlowLinesRouteInput | ThemeRiverRow> | ReadonlyArray<Bar3DDatum>): Promise<void>;
+    getStreamSource(): Promise<ChartStreamSource | undefined>;
+    setAnimation(options: {
+        duration?: number;
+        easing?: LineChartEasing;
+        enabled?: boolean;
+        type?: ChartAnimationType;
+    }): Promise<void>;
+    pauseAnimation(): Promise<void>;
+    resumeAnimation(): Promise<void>;
+    replayAnimation(): Promise<void>;
+    setValue(value: number): Promise<void>;
+    getValue(): Promise<number>;
+    addNeedle(needle: GaugeNeedleSpec, opts?: {
+        insertAt?: number;
+    }): Promise<number>;
+    removeNeedle(idOrIndex: string | number): Promise<boolean>;
+    updateNeedle(idOrIndex: string | number, patch: Partial<GaugeNeedleSpec>): Promise<boolean>;
+    addSection(section: FunnelSectionSpec | number, opts?: {
+        insertAt?: number;
+    }): Promise<number>;
+    removeSection(idOrIndex: string | number): Promise<boolean>;
+    updateSection(idOrIndex: string | number, patch: Partial<FunnelSectionSpec>): Promise<boolean>;
+    hitTest(cssX: number, cssY: number): Promise<RadarChartPointerEventDetail | FunnelChartPointerEventDetail | ChordHitDetail | NetworkGraphHitDetail | TreemapHitDetail | null | SunburstHitDetail | IcicleHitDetail | GanttHitDetail | ParallelCoordinatesHitDetail | DendrogramHitDetail | GeoMapPickDetail | Surface3DHitDetail | Scatter3DHitDetail | FlowLinesHitDetail | ThemeRiverHitDetail | Bar3DHitDetail>;
+    showRadarTooltipAt(seriesIndex: number, categoryIndex: number): Promise<RadarChartPointerEventDetail | null>;
+    showSectionTooltipAt(idOrIndex: string | number): Promise<FunnelChartPointerEventDetail | null>;
+    hitTestGauge(cssX: number, cssY: number): Promise<GaugeChartPointerEventDetail | null>;
+    showGaugeTooltip(): Promise<GaugeChartPointerEventDetail | null>;
+    showTooltipAtValue(value: number): Promise<GaugeChartPointerEventDetail | null>;
+    setRings(rings: GaugeActivityRingSpec[]): Promise<void>;
+    setRingValue(idOrIndex: string | number, value: number): Promise<boolean>;
+    selectNodeAt(index: number): Promise<SankeyNodeEventDetail | ChordNodeEventDetail | NetworkGraphNodeEventDetail | TreemapHitDetail | null | SunburstHitDetail | IcicleHitDetail | GanttHitDetail | ParallelCoordinatesHitDetail | DendrogramHitDetail | GeoMapHitDetail>;
+    selectRowAt(index: number): Promise<ParallelCoordinatesHitDetail | null>;
+    getRows(): Promise<ParallelCoordinatesRow[]>;
+    getRow(index: number): Promise<ParallelCoordinatesRow | null>;
+    getRowById(id: string): Promise<ParallelCoordinatesRow | null>;
+    getRowCount(): Promise<number>;
+    getParallelCoordinatesLayout(): Promise<ParallelCoordinatesLayoutResult | null>;
+    setParallelCoordinatesBrushes(brushes: ReadonlyArray<ParallelCoordinatesAxisBrush> | null): Promise<ParallelCoordinatesBrushChangeEventDetail | null>;
+    setParallelCoordinatesAxisBrush(dimensionId: string, range: readonly [
+        number,
+        number
+    ] | null): Promise<ParallelCoordinatesBrushChangeEventDetail | null>;
+    clearParallelCoordinatesBrushes(dimensionId?: string): Promise<ParallelCoordinatesBrushChangeEventDetail | null>;
+    getParallelCoordinatesBrushes(): Promise<ParallelCoordinatesAxisBrush[]>;
+    getParallelCoordinatesBrushedRows(): Promise<ParallelCoordinatesRow[]>;
+    getParallelCoordinatesBrushModels(): Promise<ParallelCoordinatesBrushModel[]>;
+    getParallelCoordinatesLineModels(): Promise<ParallelCoordinatesLineModel[]>;
+    getParallelCoordinatesAxisModels(): Promise<ParallelCoordinatesAxisModel[]>;
+    getParallelCoordinatesAxes(): Promise<ParallelCoordinatesAxis[]>;
+    getParallelCoordinatesDiagnostics(): Promise<ParallelCoordinatesDiagnostics | null>;
+    selectTaskAt(index: number): Promise<GanttHitDetail | null>;
+    getTasks(): Promise<GanttTask[]>;
+    getTask(index: number): Promise<GanttTask | null>;
+    getTaskById(id: string): Promise<GanttTask | null>;
+    getTaskCount(): Promise<number>;
+    getGanttExtent(): Promise<GanttExtent | null>;
+    getGanttLayout(): Promise<GanttLayoutResult | null>;
+    getGanttDiagnostics(): Promise<GanttDiagnostics | null>;
+    getGanttLabels(): Promise<GanttLabel[]>;
+    getGanttBaselines(): Promise<GanttBaselineComparison[]>;
+    getGanttTaskEdits(): Promise<GanttTaskEdit[]>;
+    resetGanttTaskEdits(id?: string): Promise<void>;
+    cancelGanttTaskEdit(): Promise<boolean>;
+    getGanttCriticalPath(): Promise<GanttCriticalPathResult | null>;
+    getGanttDependencies(): Promise<GanttDependencyDataset | null>;
+    getGanttDependencyPaths(): Promise<GanttDependencyPath[]>;
+    getGanttDependencySelection(): Promise<GanttDependencySelection | null>;
+    selectGanttDependencyAt(index: number): Promise<GanttDependencyHitDetail | null>;
+    hitTestGanttDependency(x: number, y: number): Promise<GanttDependencyHitDetail | null>;
+    showGanttDependencyTooltipAtIndex(index: number): Promise<CartesianTooltipEventDetail | null>;
+    getGanttTimeAxis(): Promise<GanttTimeAxisModel | null>;
+    drillTo(rootId: string | null): Promise<TreemapDrillChangeEventDetail | null | SunburstDrillChangeEventDetail | IcicleDrillChangeEventDetail | DendrogramDrillChangeEventDetail>;
+    drillDown(nodeIndex: number): Promise<TreemapDrillChangeEventDetail | null | SunburstDrillChangeEventDetail | IcicleDrillChangeEventDetail | DendrogramDrillChangeEventDetail>;
+    drillUp(): Promise<TreemapDrillChangeEventDetail | null | SunburstDrillChangeEventDetail | IcicleDrillChangeEventDetail | DendrogramDrillChangeEventDetail>;
+    getDrillRoot(): Promise<TreemapNode | null | SunburstNode | IcicleNode | DendrogramNode>;
+    selectLinkAt(index: number): Promise<SankeyLinkEventDetail | ChordLinkEventDetail | NetworkGraphLinkEventDetail | DendrogramHitDetail | null>;
+    clearSelection(): Promise<void>;
+    pinNode(id: string, x: number, y: number): Promise<NetworkGraphPinnedNode | null>;
+    unpinNode(id: string): Promise<boolean>;
+    clearPinnedNodes(): Promise<number>;
+    getPinnedNodes(): Promise<NetworkGraphPinnedNode[]>;
+    getSelection(): Promise<SankeySelection | ChordSelection | NetworkGraphSelection | TreemapSelection | null | SunburstSelection | IcicleSelection | GanttSelection | ParallelCoordinatesSelection | DendrogramSelection | GeoMapSelection | Surface3DSelection | Scatter3DSelection | FlowLinesSelection | ThemeRiverSelection | Bar3DSelection>;
+    selectSlice(idOrIndex: string | number, selected?: boolean): Promise<boolean>;
+    deselectSlice(idOrIndex: string | number): Promise<boolean>;
+    getSelectedSlices(): Promise<string[]>;
+    hitTestSlice(cssX: number, cssY: number): Promise<{
+        sliceIndex: number;
+        sliceId: string;
+    } | null>;
+    showTooltipAtSlice(idOrIndex: string | number): Promise<PieChartSliceEventDetail | null>;
+    addParty(datum: ItemChartDatum, opts?: {
+        insertAt?: number;
+    }): Promise<number>;
+    removeParty(idOrIndex: string | number): Promise<boolean>;
+    updateParty(idOrIndex: string | number, patch: Partial<Exclude<ItemChartDatum, number>>): Promise<boolean>;
+    setPartySeats(idOrIndex: string | number, value: number): Promise<boolean>;
+    hitTestSeat(cssX: number, cssY: number): Promise<{
+        partyIndex: number;
+        partyId: string;
+        seatIndex: number;
+        seatInParty: number;
+    } | null>;
+    showTooltipAtParty(idOrIndex: string | number): Promise<ItemChartPointEventDetail | null>;
+    addWord(datum: WordCloudDatum, opts?: {
+        insertAt?: number;
+    }): Promise<number>;
+    removeWord(idOrIndex: string | number): Promise<boolean>;
+    updateWord(idOrIndex: string | number, patch: Partial<Exclude<WordCloudDatum, readonly [
+        string,
+        number
+    ]>>): Promise<boolean>;
+    setWordWeight(idOrIndex: string | number, weight: number): Promise<boolean>;
+    hitTestWord(cssX: number, cssY: number): Promise<{
+        index: number;
+        id: string;
+        name: string;
+    } | null>;
+    getDroppedWords(): Promise<Array<{
+        index: number;
+        id: string;
+        name: string;
+        weight: number;
+    }>>;
+    showTooltipAtWord(idOrIndex: string | number): Promise<WordCloudPointEventDetail | null>;
+    addTile(datum: TilemapDatum): Promise<number>;
+    removeTile(idOrCell: string | number | {
+        x: number;
+        y: number;
+    }): Promise<boolean>;
+    updateTile(idOrCell: string | number | {
+        x: number;
+        y: number;
+    }, patch: Partial<TilemapDatum>): Promise<boolean>;
+    setTileValue(idOrCell: string | number | {
+        x: number;
+        y: number;
+    }, value: number): Promise<boolean>;
+    hitTestTile(cssX: number, cssY: number): Promise<{
+        index: number;
+        id: string;
+        col: number;
+        row: number;
+        name: string;
+    } | null>;
+    showTooltipAtTile(idOrCell: string | number | {
+        x: number;
+        y: number;
+    }): Promise<TilemapPointEventDetail | null>;
+    hitTestLeaf(cssX: number, cssY: number): Promise<{
+        sourceIndex: number;
+        value: number;
+        stemLabel: string;
+        digit: number;
+    } | null>;
+    showTooltipAtLeaf(sourceIndex: number): Promise<StemLeafPointEventDetail | null>;
+    hitTestSegment(cssX: number, cssY: number): Promise<PolarChartPointEventDetail | null>;
+    showTooltipAtSegment(categoryIndex: number, seriesIdOrIndex: string | number): Promise<PolarChartPointEventDetail | null>;
+    hitTestMarker(clientX: number, clientY: number): Promise<LineChartPointEventDetail | null>;
+    hitTestMarkers(clientX: number, clientY: number): Promise<LineChartPointEventDetail[]>;
+    showTooltipAtPoint(pointIndex: number, seriesIndex?: number | 'left' | 'right'): Promise<CartesianTooltipEventDetail | null>;
+    zoomTo(request: CartesianZoomRequest): Promise<CartesianZoomChangeEventDetail | null>;
+    zoomBy(factor: number, anchorFraction?: number): Promise<CartesianZoomChangeEventDetail | null>;
+    panBy(delta: {
+        x?: number;
+        y?: number;
+    }): Promise<CartesianZoomChangeEventDetail | null>;
+    resetZoom(): Promise<CartesianZoomChangeEventDetail | null>;
+    resetMapView(): Promise<void>;
+    parseTopoJSON(input: unknown, objectName?: string): Promise<GeoMapFeatureCollection | null>;
+    parseGeoJSON(input: unknown): Promise<GeoMapFeatureCollection | null>;
+    setFeatures(features?: GeoMapFeatureCollection): Promise<void>;
+    getFeatures(): Promise<GeoMapFeatureCollection | null>;
+    getMapHeat(): Promise<GeoMapHeatDetail | null>;
+    getMapLayers(): Promise<GeoMapLayerDetail[]>;
+    setMapLayerVisible(layer: GeoMapLayer, visible: boolean): Promise<GeoMapLayerDetail | null>;
+    fitMap(options?: GeoMapFitOptions): Promise<GeoMapFitDetail | null>;
+    getMapLabels(): Promise<GeoMapLabelView | null>;
+    getMapView(): Promise<GeoMapViewDetail | null>;
+    getMapHeatAt(cssX: number, cssY: number): Promise<GeoMapHeatPointDetail | null>;
+    getMapHeatAtCoordinate(longitude: number, latitude: number): Promise<GeoMapHeatPointDetail | null>;
+    getMapBubbleScale(): Promise<GeoMapBubbleScaleDetail | null>;
+    getMapColorAxis(): Promise<GeoMapColorAxisDetail | null>;
+    getMapDiagnostics(): Promise<GeoMapDiagnostics | null>;
+    getMapAvailability(): Promise<GeoMapAvailabilityDetail | null>;
+    selectFeatureAt(index: number): Promise<GeoMapFeatureHitDetail | null>;
+    getFeatureSelection(): Promise<GeoMapFeatureSelection | null>;
+    showTooltipAtFeature(index: number): Promise<CartesianTooltipEventDetail | null>;
+    getZoom(): Promise<CartesianZoomState | null>;
+    getZoomExtent(request?: CartesianZoomExtentRequest): Promise<CartesianZoomExtentDetail | null>;
+    private zoomConnection;
+    connect(charts: ReadonlyArray<HTMLElement | string>, options?: ZoomConnectOptions): Promise<number>;
+    disconnect(): Promise<void>;
+    showCrosshairAt(request: Bar3DCrosshairShowRequest): Promise<boolean>;
+    hideCrosshair(): Promise<void>;
+    setBrush(areas: ReadonlyArray<CartesianBrushAreaInput> | null): Promise<CartesianBrushChangeEventDetail | null>;
+    clearBrush(): Promise<CartesianBrushChangeEventDetail | null>;
+    getBrush(): Promise<CartesianBrushArea[]>;
+    getBrushSelection(): Promise<CartesianBrushSelectedSeries[]>;
+    getDrawings(): Promise<ChartDrawing[]>;
+    setDrawings(drawings: ReadonlyArray<ChartDrawingInput> | null): Promise<DrawingsChangeEventDetail | null>;
+    addDrawing(drawing: ChartDrawingInput): Promise<ChartDrawing | null>;
+    updateDrawing(id: string, patch: Partial<Omit<ChartDrawing, 'id'>>): Promise<ChartDrawing | null>;
+    removeDrawing(id: string): Promise<boolean>;
+    removeDrawings(ids: ReadonlyArray<string>): Promise<DrawingsChangeEventDetail | null>;
+    setDrawingSpace(id: string, space: DrawingSpace): Promise<ChartDrawing | null>;
+    clearDrawings(): Promise<DrawingsChangeEventDetail | null>;
+    undoDrawing(): Promise<DrawingsChangeEventDetail | null>;
+    redoDrawing(): Promise<DrawingsChangeEventDetail | null>;
+    exportDrawings(): Promise<string>;
+    importDrawings(input: ChartDrawingsInput): Promise<DrawingsChangeEventDetail | null>;
+    getDrawingLayer(): Promise<DrawingLayerSnapshot | null>;
+    exportDrawingsFile(): Promise<void>;
+    importDrawingsFile(file: Blob | string): Promise<DrawingsChangeEventDetail | null>;
+    selectDrawings(ids: ReadonlyArray<string> | null): Promise<DrawingSelectionChangeEventDetail | null>;
+    getDrawingSelection(): Promise<string[]>;
+    setVisualMap(binding: VisualMapBinding | null): Promise<VisualMapBinding | null>;
+    getVisualMap(): Promise<VisualMapBinding | null>;
+    getVisualExtent(request?: VisualMapExtentRequest): Promise<VisualMapExtent | null>;
+    private datasetVersion;
+    private datasetMemo;
+    protected onDatasetChange(): void;
+    private isDatasetValue;
+    private encodeFamily;
+    private datasetState;
+    private encodedDataset;
+    private seriesForFamilies;
+    private valuesForFamilies;
+    private xAxisForFamilies;
+    getDataset(): Promise<{
+        id: string | undefined;
+        dimensions: ReadonlyArray<{
+            index: number;
+            name: string;
+            type: string;
+        }>;
+        rows: ReadonlyArray<ReadonlyArray<unknown>>;
+    } | null>;
+    getEncodedSeries(): Promise<EncodedDataset | null>;
+    private actionActiveSeriesIndex;
+    private activeSeriesIndexForFamilies;
+    dispatchAction(action: ChartAction | string): Promise<ChartActionResult>;
+    appendSamples(samples: ArrayLike<number>): Promise<SpectrogramAppendSamplesResult>;
+    hideTooltip(): Promise<void>;
+    hitTestScatterPoint(cssX: number, cssY: number): Promise<{
+        pointIndex: number;
+        seriesIndex: number;
+    } | null>;
+    private effectiveRectChartThickness;
+    private handleRendered;
+    private handleAppended;
+    private handleWindowSlid;
+    private handleAnimationStart;
+    private handleAnimationEnd;
+    private handleAnimationInterrupted;
+    private handlePointHover;
+    private handlePointClick;
+    private handlePointContextMenu;
+    private handlePointChange;
+    private handleSeriesClick;
+    private handleSeriesOutsideClick;
+    private handleLegendItemClick;
+    private handleSeriesToggled;
+    private handlePieSliceClick;
+    private handlePieSliceHover;
+    private handlePieSliceSelected;
+    private handlePieSliceToggled;
+    private handleGaugeClick;
+    private handleGaugeHover;
+    private handleValueChange;
+    private handleNeedleToggled;
+    private handleSectionClick;
+    private handleSectionHover;
+    private handleSectionToggled;
+    private syncLineChartObjectProps;
+    private bindLineChartEvents;
+    private unbindLineChartEvents;
+    componentDidRender(): void;
+    private renderedTypeChild;
+    private syncPieChartObjectProps;
+    private bindPieChartEvents;
+    private unbindPieChartEvents;
+    private syncItemChartObjectProps;
+    private bindItemChartEvents;
+    private unbindItemChartEvents;
+    private handleItemPointClick;
+    private handleItemPointHover;
+    private handleItemPointToggled;
+    private syncWordCloudObjectProps;
+    private bindWordCloudEvents;
+    private unbindWordCloudEvents;
+    private handleWordCloudPointClick;
+    private handleWordCloudPointHover;
+    private syncTilemapObjectProps;
+    private bindTilemapEvents;
+    private unbindTilemapEvents;
+    private handleTilemapPointClick;
+    private handleTilemapPointHover;
+    private syncStemLeafObjectProps;
+    private bindStemLeafEvents;
+    private unbindStemLeafEvents;
+    private handleStemLeafPointClick;
+    private handleStemLeafPointHover;
+    private syncPolarChartObjectProps;
+    private bindPolarChartEvents;
+    private unbindPolarChartEvents;
+    private handlePolarPointClick;
+    private handlePolarPointHover;
+    private handlePolarSeriesToggled;
+    private gaugeAnimationEasing;
+    private syncGaugeChartObjectProps;
+    private bindGaugeChartEvents;
+    private unbindGaugeChartEvents;
+    private syncRadarChartObjectProps;
+    private bindRadarChartEvents;
+    private unbindRadarChartEvents;
+    private syncFunnelChartObjectProps;
+    private bindFunnelChartEvents;
+    private unbindFunnelChartEvents;
+    private syncCartesianFrameProps;
+    private zoomTarget;
+    private boundCartesianTarget?;
+    private handleCrosshairMove;
+    private handleTooltipShow;
+    private handleTooltipHide;
+    private handleTooltipAction;
+    private handleZoomChange;
+    private handleParallelCoordinatesBrushChange;
+    private handleParallelCoordinatesBrushStart;
+    private handleParallelCoordinatesBrushMove;
+    private handleParallelCoordinatesBrushEnd;
+    private handleBrushChange;
+    private handleBrushStart;
+    private handleBrushMove;
+    private handleBrushEnd;
+    private handleDrawingsChange;
+    private handleDrawingSelectionChange;
+    private bindCartesianFrameEvents;
+    private unbindCartesianFrameEvents;
+    private boundCartesianPointTarget?;
+    private bindCartesianPointEvents;
+    private unbindCartesianPointEvents;
+    private syncAreaChartObjectProps;
+    private syncColumnChartObjectProps;
+    private boundAreaChart?;
+    private bindAreaChartEvents;
+    private unbindAreaChartEvents;
+    private boundColumnChart?;
+    private bindColumnChartEvents;
+    private unbindColumnChartEvents;
+    private syncBarChartObjectProps;
+    private boundBarChart?;
+    private bindBarChartEvents;
+    private unbindBarChartEvents;
+    private syncScatterChartObjectProps;
+    private boundScatterChart?;
+    private bindScatterChartEvents;
+    private unbindScatterChartEvents;
+    render(): any;
+}