@jigonzalez930209/scichart-engine 0.1.0 → 0.2.0

package/README.md

@@ -8,11 +8,13 @@ A high-performance, WebGL-powered scientific charting engine built for precision
 ## ✨ Features
 
 -   **🚀 High Performance**: Render millions of data points with ease using a specialized raw WebGL renderer.
--   **📊 Scientific Precision**: Tailored for electrochemical (CV, DPV, etc.) and scientific data.
--   **🖱️ Deep Interactivity**: Smooth panning, wheel zoom, and precise box-selection zoom.
--   **⚛️ React Ready**: Native React hooks and components included.
--   **📈 Advanced Analysis**: Built-in cycle detection, peak detection, and real-time smoothing.
--   **🎨 Theming**: Fully customizable visual themes with premium defaults.
+-   **📈 Advanced Analysis**: Built-in peak detection, integration, baseline correction, and customizable curve fitting (linear/poly/exp).
+-   **📊 Specialized Series**: Support for Lines, Scatter (SDF symbols), Step charts, Band series, and Area charts.
+-   **↕️ Multi-Axis Engine**: Independent scales and units with axis-specific scrolling and zooming.
+-   **📏 Professional Tooling**: Real-time Statistics panel (Min/Max/Mean/Area), Annotations (Lines/Shapes/Text), and Data Export.
+-   **⚛️ Framework First**: Native React support via hooks and high-level components.
+-   **🎨 Dynamic Theming**: Sleek built-in themes (Light/Midnight) with support for custom CSS-based skins.
+-   **🏗️ Modular Core**: Built on a modern, decoupled architecture for maximum extendability.
 
 ## 🛠️ Installation
 
@@ -67,11 +69,11 @@ chart.addSeries({
 
 ## 📖 Documentation
 
-Visit [scichart-engine.js.org](https://scichart-engine.js.org) for:
--   [Getting Started Guide](https://scichart-engine.js.org/guide/)
--   [Core Concepts](https://scichart-engine.js.org/guide/concepts)
--   [API Reference](https://scichart-engine.js.org/api/chart)
--   [Interactive Examples](https://github.com/jigonzalez930209/scichart-engine/tree/main/examples)
+Visit [SciChart Engine Docs](https://jigonzalez930209.github.io/scichart-engine/) for:
+-   [Getting Started Guide](https://jigonzalez930209.github.io/scichart-engine/guide/)
+-   [Core Concepts](https://jigonzalez930209.github.io/scichart-engine/guide/concepts)
+-   [API Reference](https://jigonzalez930209.github.io/scichart-engine/api/chart)
+-   [Interactive Examples](https://jigonzalez930209.github.io/scichart-engine/examples/)
 
 ## 📄 License
 

package/dist/analysis/fitting.d.ts

@@ -0,0 +1,24 @@
+export type FitType = 'linear' | 'polynomial' | 'exponential' | 'logarithmic' | 'power';
+export interface FitOptions {
+    /** Degree for polynomial fit (default: 2) */
+    degree?: number;
+    /** Custom label for the equation */
+    label?: string;
+    /** Number of decimals in equation string */
+    precision?: number;
+}
+export interface FitResult {
+    type: FitType;
+    /** Coefficients (a, b, c...) */
+    coefficients: number[];
+    /** Formatted equation string */
+    equation: string;
+    /** Coefficient of determination */
+    rSquared: number;
+    /** Function to calculate value at X */
+    predict: (x: number) => number;
+}
+/**
+ * Perform regression on a dataset
+ */
+export declare function fitData(x: number[] | Float32Array, y: number[] | Float32Array, type: FitType, options?: FitOptions): FitResult;

package/dist/analysis/index.d.ts

@@ -4,5 +4,8 @@
  * General-purpose utilities for data formatting, cycle detection,
  * peak detection, and data validation.
  */
-export { formatWithPrefix, formatValue, formatScientific, getBestPrefix, detectCycles, generateCycleColors, detectPeaks, validateData, calculateStats, movingAverage, downsampleLTTB, } from './utils';
+export { formatWithPrefix, formatValue, formatScientific, getBestPrefix, detectCycles, generateCycleColors, detectPeaks, validateData, calculateStats, movingAverage, downsampleLTTB, subtractBaseline, } from './utils';
+export { solveLinearSystem, calculateR2, integrate, derivative, cumulativeIntegral, } from './math';
+export { fitData, } from './fitting';
 export type { CycleInfo, Peak, PrefixInfo, ValidationResult, DataStats, } from './utils';
+export type { FitType, FitOptions, FitResult, } from './fitting';

package/dist/analysis/math.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Mathematical utilities for numerical analysis and regression.
+ */
+/**
+ * Solve a system of linear equations Ax = B using Gaussian elimination with partial pivoting.
+ *
+ * @param A - Matrix coefficients
+ * @param B - Right hand side vector
+ * @returns Solution vector x
+ */
+export declare function solveLinearSystem(A: number[][], B: number[]): number[];
+/**
+ * Calculate R² (coefficient of determination)
+ */
+export declare function calculateR2(x: number[] | Float32Array, y: number[] | Float32Array, fitFn: (x: number) => number): number;
+/**
+ * Numerical integration using the trapezoidal rule.
+ *
+ * @param x - X values (must be sorted)
+ * @param y - Y values
+ * @param xMin - Optional start of integration range
+ * @param xMax - Optional end of integration range
+ */
+export declare function integrate(x: number[] | Float32Array, y: number[] | Float32Array, xMin?: number, xMax?: number): number;
+/**
+ * Calculate numerical derivative dy/dx
+ */
+export declare function derivative(x: number[] | Float32Array, y: number[] | Float32Array): Float32Array;
+/**
+ * Calculate cumulative integral (area array)
+ */
+export declare function cumulativeIntegral(x: number[] | Float32Array, y: number[] | Float32Array): Float32Array;

package/dist/analysis/utils.d.ts

@@ -138,4 +138,13 @@ export declare function downsampleLTTB(x: Float32Array | Float64Array, y: Float3
     x: Float32Array;
     y: Float32Array;
 };
+/**
+ * Subtract a linear baseline from data
+ *
+ * @param x - X data
+ * @param y - Y data
+ * @param x1 - Start of baseline segment
+ * @param x2 - End of baseline segment
+ */
+export declare function subtractBaseline(x: Float32Array | number[], y: Float32Array | number[], x1: number, x2: number): Float32Array;
 export {};

package/dist/core/Chart.d.ts

@@ -1,26 +1,14 @@
-import { ChartOptions, SeriesOptions, SeriesUpdateData, ZoomOptions, CursorOptions, ChartEventMap, Bounds } from '../types';
-import { Series } from './Series';
-
-export interface Chart {
-    addSeries(options: SeriesOptions): void;
-    removeSeries(id: string): void;
-    updateSeries(id: string, data: SeriesUpdateData): void;
-    getSeries(id: string): Series | undefined;
-    getAllSeries(): Series[];
-    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;
-}
-export declare function createChart(options: ChartOptions): Chart;
-export { ChartOptions };
+/**
+ * Chart - Main SciChart Engine Entry Point
+ *
+ * This file re-exports the chart API from the modular implementation.
+ * For the core implementation, see ./chart/ChartCore.ts
+ */
+export type { Chart, ExportOptions } from './chart/types';
+export { MARGINS } from './chart/types';
+export { createChart, ChartImpl } from './chart/ChartCore';
+export { exportToCSV, exportToJSON, exportToImage } from './chart/ChartExporter';
+export { applyZoom, applyPan, autoScaleAll } from './chart/ChartNavigation';
+export type { NavigationContext } from './chart/ChartNavigation';
+export type { RenderContext } from './chart/ChartRenderer';
+export type { ChartOptions } from '../types';

package/dist/core/ChartControls.d.ts

@@ -7,6 +7,7 @@ export interface ChartControlsCallbacks {
     onTogglePan: (active: boolean) => void;
     onExport: () => void;
     onAutoScale: () => void;
+    onToggleLegend: (visible: boolean) => void;
 }
 export declare class ChartControls {
     private container;
@@ -15,6 +16,7 @@ export declare class ChartControls {
     private theme;
     private isSmoothing;
     private isPanMode;
+    private isLegendVisible;
     private currentType;
     constructor(parent: HTMLElement, theme: ChartTheme, callbacks: ChartControlsCallbacks);
     private isDarkTheme;

package/dist/core/ChartLegend.d.ts

@@ -24,7 +24,12 @@ export declare class ChartLegend {
     private initDragging;
     update(series: Series[]): void;
     private render;
+    /**
+     * Internal symbol drawing logic (shared with canvas export)
+     */
+    private drawSymbol;
     draw(ctx: CanvasRenderingContext2D, dpr: number): void;
     updateTheme(theme: ChartTheme): void;
+    setVisible(visible: boolean): void;
     destroy(): void;
 }

package/dist/core/ChartStatistics.d.ts

@@ -0,0 +1,18 @@
+import { ChartTheme } from '../theme';
+import { Series } from './Series';
+import { Bounds } from '../types';
+
+export declare class ChartStatistics {
+    private container;
+    private content;
+    private theme;
+    private series;
+    private isExpanded;
+    constructor(parent: HTMLElement, theme: ChartTheme, series: Map<string, Series>);
+    private isDarkTheme;
+    private updateContainerStyle;
+    update(viewBounds: Bounds): void;
+    toggle(): void;
+    updateTheme(theme: ChartTheme): void;
+    destroy(): void;
+}

package/dist/core/InteractionManager.d.ts

@@ -1,8 +1,13 @@
 import { Bounds } from '../types';
 
+export interface AxisLayout {
+    id: string;
+    position: 'left' | 'right';
+    offset: number;
+}
 export interface InteractionCallbacks {
-    onZoom: (bounds: Bounds) => void;
-    onPan: (deltaX: number, deltaY: number) => void;
+    onZoom: (bounds: Bounds, axisId?: string) => void;
+    onPan: (deltaX: number, deltaY: number, axisId?: string) => void;
     onBoxZoom: (rect: {
         x: number;
         y: number;
@@ -21,14 +26,19 @@ export interface PlotAreaGetter {
     };
 }
 export interface BoundsGetter {
-    (): Bounds;
+    (axisId?: string): Bounds;
+}
+export interface AxisLayoutGetter {
+    (): AxisLayout[];
 }
 export declare class InteractionManager {
     private container;
     private callbacks;
     private getPlotArea;
     private getBounds;
+    private getAxesLayout;
     private isDragging;
+    private panningAxisId?;
     private isBoxSelecting;
     private selectionStart;
     private lastMousePos;
@@ -41,7 +51,7 @@ export declare class InteractionManager {
     private boundTouchStart;
     private boundTouchMove;
     private boundTouchEnd;
-    constructor(container: HTMLElement, callbacks: InteractionCallbacks, getPlotArea: PlotAreaGetter, getBounds: BoundsGetter);
+    constructor(container: HTMLElement, callbacks: InteractionCallbacks, getPlotArea: PlotAreaGetter, getBounds: BoundsGetter, getAxesLayout: AxisLayoutGetter);
     private attachListeners;
     private detachListeners;
     setPanMode(enabled: boolean): void;

package/dist/core/OverlayRenderer.d.ts

@@ -42,7 +42,7 @@ export declare class OverlayRenderer {
     /**
      * Draw Y axis with ticks and labels
      */
-    drawYAxis(plotArea: PlotArea, yScale: Scale, label?: string): void;
+    drawYAxis(plotArea: PlotArea, yScale: Scale, label?: string, position?: "left" | "right", offset?: number): void;
     /**
      * Draw plot area border
      */
@@ -51,6 +51,10 @@ export declare class OverlayRenderer {
      * Draw legend
      */
     drawLegend(plotArea: PlotArea, series: Series[]): void;
+    /**
+     * Helper to draw a symbol in the legend
+     */
+    private drawLegendSymbol;
     /**
      * Draw cursor/crosshair
      */
@@ -68,6 +72,10 @@ export declare class OverlayRenderer {
         width: number;
         height: number;
     }): void;
+    /**
+     * Draw error bars for a series
+     */
+    drawErrorBars(plotArea: PlotArea, series: Series, xScale: Scale, yScale: Scale): void;
     private generateMinorTicks;
     private formatXTick;
     private formatYTick;

package/dist/core/Series.d.ts

@@ -3,10 +3,13 @@ import { SeriesOptions, SeriesData, SeriesStyle, SeriesUpdateData, Bounds, Serie
 export declare class Series {
     private id;
     private type;
+    private yAxisId?;
     private data;
     private style;
     private visible;
     private cycle?;
+    private maxPoints?;
+    private lastAppendCount;
     private cachedBounds;
     private boundsNeedsUpdate;
     private _needsBufferUpdate;
@@ -15,6 +18,8 @@ export declare class Series {
     constructor(options: SeriesOptions);
     getId(): string;
     getType(): SeriesType;
+    getYAxisId(): string | undefined;
+    getVisible(): boolean;
     getData(): SeriesData;
     private getSmoothedData;
     private applySmoothing;
@@ -22,6 +27,22 @@ export declare class Series {
     isVisible(): boolean;
     getCycle(): number | undefined;
     getPointCount(): number;
+    getLastAppendCount(): number;
+    resetLastAppendCount(): void;
+    /**
+     * Check if series has error bar data
+     */
+    hasErrorData(): boolean;
+    /**
+     * Get Y error values for a data point
+     * Returns [errorMinus, errorPlus] for the point at index i
+     */
+    getYError(i: number): [number, number] | null;
+    /**
+     * Get X error values for a data point
+     * Returns [errorMinus, errorPlus] for the point at index i
+     */
+    getXError(i: number): [number, number] | null;
     getBounds(): Bounds | null;
     private calculateBounds;
     /**
@@ -34,11 +55,12 @@ export declare class Series {
     /**
      * Replace all data at once
      */
-    setData(x: Float32Array | Float64Array, y: Float32Array | Float64Array): void;
+    setData(x: Float32Array | Float64Array, y: Float32Array | Float64Array, y2?: Float32Array | Float64Array): void;
     setStyle(style: Partial<SeriesStyle>): void;
     get needsBufferUpdate(): boolean;
     set needsBufferUpdate(val: boolean);
     setVisible(visible: boolean): void;
     setType(type: SeriesType): void;
+    setMaxPoints(maxPoints: number | undefined): void;
     destroy(): void;
 }

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

@@ -0,0 +1,57 @@
+import { Bounds } from '../../types';
+import { Annotation } from './types';
+
+export interface PlotArea {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare class AnnotationManager {
+    private annotations;
+    private idCounter;
+    /**
+     * Add a new annotation
+     * @returns The annotation ID
+     */
+    add(annotation: Annotation): string;
+    /**
+     * Remove an annotation by ID
+     */
+    remove(id: string): boolean;
+    /**
+     * Update an annotation
+     */
+    update(id: string, updates: Partial<Annotation>): void;
+    /**
+     * Get an annotation by ID
+     */
+    get(id: string): Annotation | undefined;
+    /**
+     * Get all annotations
+     */
+    getAll(): Annotation[];
+    /**
+     * Clear all annotations
+     */
+    clear(): void;
+    /**
+     * Get count of annotations
+     */
+    get count(): number;
+    /**
+     * Render all annotations
+     */
+    render(ctx: CanvasRenderingContext2D, plotArea: PlotArea, bounds: Bounds): void;
+    private renderAnnotation;
+    private dataToPixelX;
+    private dataToPixelY;
+    private renderHorizontalLine;
+    private renderVerticalLine;
+    private renderRectangle;
+    private renderBand;
+    private renderText;
+    private renderArrow;
+    private renderLineLabel;
+    private renderCenteredLabel;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Annotations module exports
+ */
+export { AnnotationManager, type PlotArea } from './AnnotationManager';
+export type { Annotation, AnnotationType, BaseAnnotation, HorizontalLineAnnotation, VerticalLineAnnotation, RectangleAnnotation, BandAnnotation, TextAnnotation, ArrowAnnotation, AnnotationEvent, AnnotationDragEvent, } from './types';

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

@@ -0,0 +1,155 @@
+/**
+ * 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;
+}
+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,93 @@
+import { ChartOptions, SeriesOptions, 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 { 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 needsRender;
+    private isDestroyed;
+    private autoScroll;
+    private showStatistics;
+    private stats;
+    private selectionRect;
+    private annotationManager;
+    readonly analysis: typeof analysis;
+    constructor(options: ChartOptions);
+    private initControls;
+    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): 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;
+    resize(): void;
+    requestRender(): void;
+    render(): 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;