scichart-engine 0.4.1

package/dist/core/annotations/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Annotation Types
+ *
+ * Type definitions for all annotation types supported by SciChart Engine.
+ */
+export type AnnotationType = 'horizontal-line' | 'vertical-line' | 'rectangle' | 'band' | 'text' | 'arrow';
+export interface BaseAnnotation {
+    /** Unique identifier (auto-generated if not provided) */
+    id?: string;
+    /** Annotation type */
+    type: AnnotationType;
+    /** Visibility */
+    visible?: boolean;
+    /** Allow user interaction (dragging) */
+    interactive?: boolean;
+    /** Z-index for layering */
+    zIndex?: number;
+    /** Tooltip text or configuration */
+    tooltip?: string | any;
+}
+export interface HorizontalLineAnnotation extends BaseAnnotation {
+    type: 'horizontal-line';
+    /** Y value in data coordinates */
+    y: number;
+    /** Optional: limit line extent to X range */
+    xMin?: number;
+    xMax?: number;
+    /** Line color (hex or rgba) */
+    color?: string;
+    /** Line width in pixels */
+    lineWidth?: number;
+    /** Dash pattern [dash, gap] - empty for solid */
+    lineDash?: number[];
+    /** Label text */
+    label?: string;
+    /** Label position along the line */
+    labelPosition?: 'left' | 'right' | 'center';
+    /** Label background color */
+    labelBackground?: string;
+}
+export interface VerticalLineAnnotation extends BaseAnnotation {
+    type: 'vertical-line';
+    /** X value in data coordinates */
+    x: number;
+    /** Optional: limit line extent to Y range */
+    yMin?: number;
+    yMax?: number;
+    /** Line color */
+    color?: string;
+    /** Line width in pixels */
+    lineWidth?: number;
+    /** Dash pattern */
+    lineDash?: number[];
+    /** Label text */
+    label?: string;
+    /** Label position */
+    labelPosition?: 'top' | 'bottom' | 'center';
+    /** Label background color */
+    labelBackground?: string;
+}
+export interface RectangleAnnotation extends BaseAnnotation {
+    type: 'rectangle';
+    /** Rectangle bounds in data coordinates */
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+    /** Fill color (use alpha for transparency) */
+    fillColor?: string;
+    /** Border color */
+    strokeColor?: string;
+    /** Border width */
+    strokeWidth?: number;
+    /** Border dash pattern */
+    strokeDash?: number[];
+    /** Label text */
+    label?: string;
+}
+export interface BandAnnotation extends BaseAnnotation {
+    type: 'band';
+    /** Band bounds - vertical band if only x specified, horizontal if only y */
+    xMin?: number;
+    xMax?: number;
+    yMin?: number;
+    yMax?: number;
+    /** Fill color */
+    fillColor?: string;
+    /** Border color */
+    strokeColor?: string;
+    /** Border width */
+    strokeWidth?: number;
+    /** Label text */
+    label?: string;
+    /** Label position */
+    labelPosition?: 'center' | 'top' | 'bottom' | 'left' | 'right';
+}
+export interface TextAnnotation extends BaseAnnotation {
+    type: 'text';
+    /** Position in data coordinates */
+    x: number;
+    y: number;
+    /** Text content */
+    text: string;
+    /** Font size in pixels */
+    fontSize?: number;
+    /** Font family */
+    fontFamily?: string;
+    /** Font weight */
+    fontWeight?: 'normal' | 'bold';
+    /** Text color */
+    color?: string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Background padding */
+    padding?: number;
+    /** Rotation in degrees */
+    rotation?: number;
+    /** Anchor point for positioning */
+    anchor?: 'center' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'top-center' | 'bottom-center' | 'left-center' | 'right-center';
+}
+export interface ArrowAnnotation extends BaseAnnotation {
+    type: 'arrow';
+    /** Start point in data coordinates */
+    x1: number;
+    y1: number;
+    /** End point (arrow head) in data coordinates */
+    x2: number;
+    y2: number;
+    /** Line color */
+    color?: string;
+    /** Line width */
+    lineWidth?: number;
+    /** Arrow head size in pixels */
+    headSize?: number;
+    /** Arrow head style */
+    headStyle?: 'filled' | 'open' | 'none';
+    /** Show tail arrow */
+    showTail?: boolean;
+    /** Label text */
+    label?: string;
+}
+export type Annotation = HorizontalLineAnnotation | VerticalLineAnnotation | RectangleAnnotation | BandAnnotation | TextAnnotation | ArrowAnnotation;
+export interface ResolvedAnnotation extends BaseAnnotation {
+    id: string;
+}
+export interface AnnotationEvent {
+    annotation: Annotation;
+    originalEvent?: MouseEvent;
+}
+export interface AnnotationDragEvent extends AnnotationEvent {
+    deltaX: number;
+    deltaY: number;
+    newPosition: {
+        x: number;
+        y: number;
+    };
+}

package/dist/core/chart/ChartCore.d.ts

@@ -0,0 +1,103 @@
+import { ChartOptions, SeriesOptions, HeatmapOptions, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Bounds } from '../../types';
+import { FitType, FitOptions } from '../../analysis';
+import { Series } from '../Series';
+import { ChartTheme } from '../../theme';
+import { Annotation } from '../annotations';
+import { TooltipManager } from '../tooltip';
+import { Chart, ExportOptions } from './types';
+
+import * as analysis from "../../analysis";
+export declare class ChartImpl implements Chart {
+    private container;
+    private webglCanvas;
+    private overlayCanvas;
+    private overlayCtx;
+    private series;
+    private events;
+    private viewBounds;
+    private xAxisOptions;
+    private yAxisOptionsMap;
+    private primaryYAxisId;
+    private dpr;
+    private backgroundColor;
+    private renderer;
+    private overlay;
+    private interaction;
+    private xScale;
+    private yScales;
+    private get yScale();
+    private theme;
+    private cursorOptions;
+    private cursorPosition;
+    private showLegend;
+    private legend;
+    private showControls;
+    private controls;
+    private animationFrameId;
+    private needsFullRender;
+    private needsOverlayRender;
+    private isDestroyed;
+    private autoScroll;
+    private showStatistics;
+    private stats;
+    private selectionRect;
+    private annotationManager;
+    readonly tooltip: TooltipManager;
+    private pluginManager;
+    private initialOptions;
+    readonly analysis: typeof analysis;
+    constructor(options: ChartOptions);
+    private initControls;
+    private toggleLegend;
+    private initLegend;
+    setTheme(theme: string | ChartTheme): void;
+    getPlotArea(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    private getInteractedBounds;
+    exportImage(type?: "png" | "jpeg"): string;
+    private getSeriesContext;
+    addSeries(options: SeriesOptions | HeatmapOptions): void;
+    addBar(options: Omit<SeriesOptions, "type">): void;
+    addHeatmap(options: HeatmapOptions): void;
+    removeSeries(id: string): void;
+    updateSeries(id: string, data: SeriesUpdateData): void;
+    appendData(id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+    setAutoScroll(enabled: boolean): void;
+    setMaxPoints(id: string, maxPoints: number): void;
+    addFitLine(seriesId: string, type: FitType, options?: FitOptions): string;
+    getSeries(id: string): Series | undefined;
+    getAllSeries(): Series[];
+    private getNavContext;
+    zoom(options: ZoomOptions): void;
+    pan(deltaX: number, deltaY: number, axisId?: string): void;
+    resetZoom(): void;
+    getViewBounds(): Bounds;
+    autoScale(): void;
+    private handleBoxZoom;
+    enableCursor(options: CursorOptions): void;
+    disableCursor(): void;
+    addAnnotation(annotation: Annotation): string;
+    removeAnnotation(id: string): boolean;
+    updateAnnotation(id: string, updates: Partial<Annotation>): void;
+    getAnnotation(id: string): Annotation | undefined;
+    getAnnotations(): Annotation[];
+    clearAnnotations(): void;
+    exportCSV(options?: ExportOptions): string;
+    exportJSON(options?: ExportOptions): string;
+    use(plugin: any): void;
+    resize(): void;
+    requestRender(): void;
+    requestOverlayRender(): void;
+    render(full?: boolean): void;
+    private pixelToDataX;
+    private pixelToDataY;
+    private startRenderLoop;
+    on<K extends keyof ChartEventMap>(e: K, h: (d: ChartEventMap[K]) => void): void;
+    off<K extends keyof ChartEventMap>(e: K, h: (d: ChartEventMap[K]) => void): void;
+    destroy(): void;
+}
+export declare function createChart(options: ChartOptions): Chart;

package/dist/core/chart/ChartExporter.d.ts

@@ -0,0 +1,18 @@
+import { Series } from '../Series';
+import { Bounds } from '../../types';
+import { ExportOptions } from './types';
+
+/**
+ * Export series data to CSV format
+ */
+export declare function exportToCSV(series: Series[], options?: ExportOptions): string;
+/**
+ * Export series data to JSON format
+ */
+export declare function exportToJSON(series: Series[], viewBounds: Bounds, options?: ExportOptions): string;
+/**
+ * Export chart to image
+ */
+export declare function exportToImage(webglCanvas: HTMLCanvasElement, overlayCanvas: HTMLCanvasElement, backgroundColor: [number, number, number, number], legend: {
+    draw: (ctx: CanvasRenderingContext2D, dpr: number) => void;
+} | null, showLegend: boolean, dpr: number, type?: "png" | "jpeg"): string;

package/dist/core/chart/ChartNavigation.d.ts

@@ -0,0 +1,33 @@
+import { Bounds, ZoomOptions, AxisOptions, ChartEventMap } from '../../types';
+import { Scale } from '../../scales';
+import { EventEmitter } from '../EventEmitter';
+
+export interface NavigationContext {
+    viewBounds: Bounds;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    getPlotArea: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    events: EventEmitter<ChartEventMap>;
+    requestRender: () => void;
+    series: Map<string, {
+        isVisible(): boolean;
+        getBounds(): Bounds | null;
+        getYAxisId(): string | undefined;
+        getType(): string;
+    }>;
+}
+/**
+ * Apply zoom to the chart
+ */
+export declare function applyZoom(ctx: NavigationContext, options: ZoomOptions): void;
+/**
+ * Apply pan to the chart
+ */
+export declare function applyPan(ctx: NavigationContext, deltaX: number, deltaY: number, axisId?: string): void;

package/dist/core/chart/ChartRenderer.d.ts

@@ -0,0 +1,53 @@
+import { Bounds, CursorOptions, AxisOptions, PlotArea, ChartEventMap } from '../../types';
+import { Series } from '../Series';
+import { Scale } from '../../scales';
+import { NativeWebGLRenderer, NativeSeriesRenderData as SeriesRenderData } from '../../renderer/NativeWebGLRenderer';
+import { OverlayRenderer } from '../OverlayRenderer';
+import { AnnotationManager } from '../annotations';
+import { ChartStatistics } from '../ChartStatistics';
+import { EventEmitter } from '../EventEmitter';
+
+export interface RenderContext {
+    webglCanvas: HTMLCanvasElement;
+    overlayCanvas: HTMLCanvasElement;
+    overlayCtx: CanvasRenderingContext2D;
+    container: HTMLDivElement;
+    series: Map<string, Series>;
+    viewBounds: Bounds;
+    xScale: Scale;
+    yScales: Map<string, Scale>;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    xAxisOptions: AxisOptions;
+    primaryYAxisId: string;
+    renderer: NativeWebGLRenderer;
+    overlay: OverlayRenderer;
+    annotationManager: AnnotationManager;
+    backgroundColor: [number, number, number, number];
+    cursorOptions: CursorOptions | null;
+    cursorPosition: {
+        x: number;
+        y: number;
+    } | null;
+    selectionRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    stats: ChartStatistics | null;
+    showStatistics: boolean;
+    events: EventEmitter<ChartEventMap>;
+    updateSeriesBuffer: (s: Series) => void;
+    getPlotArea: () => PlotArea;
+    pixelToDataX: (px: number) => number;
+    pixelToDataY: (py: number) => number;
+    tooltip: import('../tooltip').TooltipManager;
+}
+/**
+ * Prepare series data for WebGL rendering
+ */
+export declare function prepareSeriesData(ctx: RenderContext, plotArea: PlotArea): SeriesRenderData[];
+/**
+ * Render overlay elements (axes, grid, annotations, etc.)
+ */
+export declare function renderOverlay(ctx: RenderContext, plotArea: PlotArea, primaryYScale: Scale): void;

package/dist/core/chart/ChartScaling.d.ts

@@ -0,0 +1,26 @@
+import { NavigationContext } from './ChartNavigation';
+import { ZoomOptions } from '../../types';
+
+/**
+ * Auto-scale all axes to fit data
+ */
+export declare function autoScaleAll(ctx: NavigationContext): void;
+/**
+ * Handle box zoom selection
+ */
+export declare function handleBoxZoom(ctx: NavigationContext, selectionRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, currentRect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null, zoom: (options: ZoomOptions) => void): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;

package/dist/core/chart/ChartSeries.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Chart Series Redirect
+ */
+export * from './series/index';

package/dist/core/chart/ChartSetup.d.ts

@@ -0,0 +1,64 @@
+import { ChartOptions, AxisOptions } from '../../types';
+import { Scale } from '../../scales';
+import { ChartTheme } from '../../theme';
+
+export interface SetupResult {
+    theme: ChartTheme;
+    backgroundColor: [number, number, number, number];
+    showLegend: boolean;
+    showControls: boolean;
+    autoScroll: boolean;
+    showStatistics: boolean;
+    dpr: number;
+    xAxisOptions: AxisOptions;
+    xScale: Scale;
+    yAxisOptionsMap: Map<string, AxisOptions>;
+    yScales: Map<string, Scale>;
+    primaryYAxisId: string;
+    webglCanvas: HTMLCanvasElement;
+    overlayCanvas: HTMLCanvasElement;
+    overlayCtx: CanvasRenderingContext2D;
+}
+/**
+ * Initialize chart configuration from options
+ */
+export declare function initializeChart(container: HTMLDivElement, options: ChartOptions): SetupResult;
+/**
+ * Create a canvas element
+ */
+export declare function createCanvas(type: "webgl" | "overlay"): HTMLCanvasElement;
+/**
+ * Calculate the plot area based on container size and margins
+ */
+export declare function getPlotArea(container: HTMLDivElement, yAxisOptionsMap: Map<string, AxisOptions>): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Get axes layout for interaction manager
+ */
+export declare function getAxesLayout(yAxisOptionsMap: Map<string, AxisOptions>): Array<{
+    id: string;
+    position: 'left' | 'right';
+    offset: number;
+}>;
+/**
+ * Resize canvases to match container
+ */
+export declare function resizeCanvases(container: HTMLDivElement, webglCanvas: HTMLCanvasElement, overlayCanvas: HTMLCanvasElement, overlayCtx: CanvasRenderingContext2D, dpr: number): boolean;
+export declare function pixelToDataX(px: number, plotArea: {
+    x: number;
+    width: number;
+}, viewBounds: {
+    xMin: number;
+    xMax: number;
+}): number;
+export declare function pixelToDataY(py: number, plotArea: {
+    y: number;
+    height: number;
+}, viewBounds: {
+    yMin: number;
+    yMax: number;
+}): number;

package/dist/core/chart/ChartUI.d.ts

@@ -0,0 +1,22 @@
+import { ChartControls } from '../ChartControls';
+import { ChartLegend } from '../ChartLegend';
+import { ChartTheme } from '../../theme';
+import { ChartOptions } from '../../types';
+import { Series } from '../Series';
+
+export interface UIContext {
+    container: HTMLDivElement;
+    theme: ChartTheme;
+    showControls: boolean;
+    showLegend: boolean;
+    series: Map<string, Series>;
+    autoScale: () => void;
+    resetZoom: () => void;
+    requestRender: () => void;
+    exportImage: () => string;
+    setPanMode: (active: boolean) => void;
+    onLegendMove: (x: number, y: number) => void;
+    toggleLegend: () => void;
+}
+export declare function initControls(ctx: UIContext): ChartControls | null;
+export declare function initLegend(ctx: UIContext, options: ChartOptions): ChartLegend | null;

package/dist/core/chart/exporter/SVGExporter.d.ts

@@ -0,0 +1,6 @@
+import { Series } from '../../Series';
+import { Bounds, PlotArea } from '../../../types';
+import { Scale } from '../../../scales';
+import { ChartTheme } from '../../../theme';
+
+export declare function exportToSVG(series: Series[], _viewBounds: Bounds, plotArea: PlotArea, xAxis: Scale, yAxes: Map<string, Scale>, theme: ChartTheme, width: number, height: number): string;

package/dist/core/chart/exporter/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Chart Exporter Modular Logic
+ */
+export * from '../ChartExporter';
+export * from './SVGExporter';

package/dist/core/chart/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Chart barrel export
+ *
+ * Re-exports all chart submodules for clean imports.
+ */
+export type { Chart, ExportOptions } from './types';
+export { MARGINS } from './types';
+export { exportToCSV, exportToJSON, exportToImage } from './ChartExporter';
+export { applyZoom, applyPan, } from './ChartNavigation';
+export { autoScaleAll, handleBoxZoom } from './ChartScaling';
+export type { NavigationContext } from './ChartNavigation';
+export { prepareSeriesData, renderOverlay } from './ChartRenderer';
+export type { RenderContext } from './ChartRenderer';
+export { ChartImpl, createChart } from './ChartCore';

package/dist/core/chart/plugins/PluginManager.d.ts

@@ -0,0 +1,13 @@
+import { ChartPlugin, PluginManager as IPluginManager } from './types';
+import { Chart } from '../types';
+
+export declare class PluginManagerImpl implements IPluginManager {
+    private plugins;
+    private chart;
+    constructor(chart: Chart);
+    use(plugin: ChartPlugin): void;
+    remove(name: string): boolean;
+    get(name: string): ChartPlugin | undefined;
+    notify(hook: keyof Omit<ChartPlugin, 'name' | 'init'>, ...args: any[]): void;
+    destroy(): void;
+}

package/dist/core/chart/plugins/types.d.ts

@@ -0,0 +1,13 @@
+import { Chart, ChartPlugin } from '../types';
+
+export type { Chart, ChartPlugin };
+export interface PluginManager {
+    /** Attach a plugin */
+    use(plugin: ChartPlugin): void;
+    /** Remove a plugin by name */
+    remove(name: string): boolean;
+    /** Get a plugin by name */
+    get(name: string): ChartPlugin | undefined;
+    /** Notify all plugins of an event */
+    notify(hook: keyof Omit<ChartPlugin, 'name' | 'init'>, ...args: any[]): void;
+}

package/dist/core/chart/series/SeriesActions.d.ts

@@ -0,0 +1,7 @@
+import { SeriesOptions, HeatmapOptions, SeriesUpdateData } from '../../../types';
+
+export declare function addSeries(ctx: any, options: SeriesOptions | HeatmapOptions): void;
+export declare function removeSeries(ctx: any, id: string): void;
+export declare function updateSeries(ctx: any, id: string, data: SeriesUpdateData): void;
+export declare function appendData(ctx: any, id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+export declare function setMaxPoints(ctx: any, id: string, maxPoints: number): void;

package/dist/core/chart/series/SeriesBuffer.d.ts

@@ -0,0 +1,4 @@
+import { Series } from '../../Series';
+
+export declare function updateSeriesBuffer(ctx: any, s: Series): void;
+export declare function refreshStack(ctx: any, stackId: string): void;

package/dist/core/chart/series/SeriesFit.d.ts

@@ -0,0 +1,3 @@
+import { FitType, FitOptions } from '../../../analysis';
+
+export declare function addFitLine(ctx: any, seriesId: string, type: FitType, options?: FitOptions): string;

package/dist/core/chart/series/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Chart Series Barrel Export
+ */
+export * from './SeriesActions';
+export * from './SeriesBuffer';
+export * from './SeriesFit';
+export * from './types';

package/dist/core/chart/series/types.d.ts

@@ -0,0 +1,22 @@
+import { Series } from '../../Series';
+import { NativeWebGLRenderer } from '../../../renderer';
+import { Bounds } from '../../../types';
+import { Annotation } from '../../annotations';
+
+export interface SeriesManagerContext {
+    series: Map<string, Series>;
+    renderer: NativeWebGLRenderer;
+    viewBounds: Bounds;
+    autoScale: () => void;
+    requestRender: () => void;
+    addAnnotation: (annotation: Annotation) => string;
+    xAxisOptions: {
+        auto?: boolean;
+    };
+    yAxisOptionsMap: Map<string, {
+        auto?: boolean;
+    }>;
+    autoScrollEnabled: boolean;
+    updateLegend?: () => void;
+    addSeries: (options: any) => void;
+}

package/dist/core/chart/types.d.ts

@@ -0,0 +1,72 @@
+import { SeriesOptions, HeatmapOptions, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Bounds } from '../../types';
+import { Series } from '../Series';
+import { FitType, FitOptions } from '../../analysis';
+import { Annotation } from '../annotations';
+
+import * as analysis from "../../analysis";
+export interface Chart {
+    addSeries(options: SeriesOptions | HeatmapOptions): void;
+    addBar(options: Omit<SeriesOptions, "type">): void;
+    addHeatmap(options: Omit<HeatmapOptions, "type">): void;
+    removeSeries(id: string): void;
+    updateSeries(id: string, data: SeriesUpdateData): void;
+    getSeries(id: string): Series | undefined;
+    getAllSeries(): Series[];
+    appendData(id: string, x: number[] | Float32Array, y: number[] | Float32Array): void;
+    setAutoScroll(enabled: boolean): void;
+    setMaxPoints(id: string, maxPoints: number): void;
+    addFitLine(seriesId: string, type: FitType, options?: FitOptions): string;
+    zoom(options: ZoomOptions): void;
+    pan(deltaX: number, deltaY: number): void;
+    resetZoom(): void;
+    getViewBounds(): Bounds;
+    enableCursor(options: CursorOptions): void;
+    disableCursor(): void;
+    resize(width?: number, height?: number): void;
+    render(): void;
+    on<K extends keyof ChartEventMap>(event: K, handler: (data: ChartEventMap[K]) => void): void;
+    off<K extends keyof ChartEventMap>(event: K, handler: (data: ChartEventMap[K]) => void): void;
+    destroy(): void;
+    exportImage(type?: "png" | "jpeg"): string;
+    autoScale(): void;
+    setTheme(theme: string | object): void;
+    /** Access to data analysis utilities */
+    readonly analysis: typeof analysis;
+    addAnnotation(annotation: Annotation): string;
+    removeAnnotation(id: string): boolean;
+    updateAnnotation(id: string, updates: Partial<Annotation>): void;
+    getAnnotation(id: string): Annotation | undefined;
+    getAnnotations(): Annotation[];
+    clearAnnotations(): void;
+    exportCSV(options?: ExportOptions): string;
+    exportJSON(options?: ExportOptions): string;
+    /** Attach a plugin to extend chart functionality */
+    use(plugin: ChartPlugin): void;
+    /** Access to the tooltip system */
+    readonly tooltip: import('../tooltip').TooltipManager;
+}
+export interface ChartPlugin {
+    name: string;
+    init?: (chart: Chart) => void;
+    onBeforeRender?: (chart: Chart) => void;
+    onAfterRender?: (chart: Chart) => void;
+    onSeriesAdded?: (series: Series) => void;
+    destroy?: () => void;
+}
+/** Options for data export */
+export interface ExportOptions {
+    /** Series IDs to export (default: all) */
+    seriesIds?: string[];
+    /** Include headers in CSV (default: true) */
+    includeHeaders?: boolean;
+    /** Decimal precision (default: 6) */
+    precision?: number;
+    /** CSV delimiter (default: ',') */
+    delimiter?: string;
+}
+export declare const MARGINS: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};