chartgpu-angular 21.0.0 → 22.0.1

package/types/chartgpu-angular.d.ts

@@ -1,222 +1,267 @@
-import * as _angular_core from '@angular/core';
-import { OnDestroy, ElementRef, DestroyRef } from '@angular/core';
-import * as chartgpu from 'chartgpu';
-import { ChartGPUInstance, DataPoint, OHLCDataPoint, RenderMode, ChartGPUOptions, ChartGPUHitTestResult, AnimationConfig, AnnotationConfig, AxisConfig, ChartGPUEventPayload, ChartGPUCrosshairMovePayload, ChartGPUCreateContext, PipelineCache, SeriesConfig, SeriesType, ChartSyncOptions, ThemeConfig, TooltipConfig, DataZoomConfig } from 'chartgpu';
-export { ChartGPUCreateContext, ChartGPUCrosshairMovePayload, ChartGPUDeviceLostPayload, ChartGPUEventPayload, ChartGPUHitTestResult, ChartGPUInstance, ChartSyncOptions, DataPoint, OHLCDataPoint, PipelineCache, RenderMode } from 'chartgpu';
-
-type ChartgpuOptions = ChartGPUOptions;
-type ChartgpuSeriesType = SeriesType;
-type ChartgpuSeriesData = Extract<SeriesConfig, {
-    type: 'line';
+import * as i0 from "@angular/core";
+import { DestroyRef, ElementRef, OnDestroy } from "@angular/core";
+import { AnimationConfig, AnnotationConfig, AxisConfig, ChartGPUCreateContext, ChartGPUCrosshairMovePayload, ChartGPUDeviceLostPayload, ChartGPUEventPayload, ChartGPUHitTestResult, ChartGPUInstance, ChartGPUInstance as ChartGPUInstance$1, ChartGPUOptions, ChartSyncOptions, DataPoint, DataZoomConfig, OHLCDataPoint, OHLCDataPoint as OHLCDataPoint$1, PipelineCache, RenderMode, SeriesConfig, SeriesType, ThemeConfig, TooltipConfig } from "chartgpu";
+export type ChartgpuOptions = ChartGPUOptions;
+export type ChartgpuSeriesType = SeriesType;
+export type ChartgpuSeriesData = Extract<SeriesConfig, {
+  type: 'line';
 }>['data'];
-type ChartgpuSeriesOptions = SeriesConfig;
-type ChartgpuAxisOptions = AxisConfig;
-type ChartgpuZoomOptions = DataZoomConfig;
-type ChartgpuTooltipOptions = TooltipConfig;
-type ChartgpuAnimationOptions = AnimationConfig | boolean;
-type ChartgpuThemeOptions = ThemeConfig | 'light' | 'dark';
-type ChartgpuAnnotationOptions = AnnotationConfig;
-type ChartgpuThreeDOptions = Pick<ChartGPUOptions, 'coordinateSystem' | 'camera' | 'interaction3d' | 'axes3d'>;
-type ChartgpuStreamingOptions = Pick<ChartGPUOptions, 'autoScroll'>;
-type ChartgpuInteractionOptions = Pick<ChartGPUOptions, 'dataZoom' | 'tooltip'>;
-type ChartgpuChartInstance = ChartGPUInstance;
-type ChartgpuGPUContext = ChartGPUCreateContext;
-type ChartgpuStyle = Record<string, string | number | null | undefined>;
-type ChartgpuZoomRange = NonNullable<ReturnType<ChartGPUInstance['getZoomRange']>>;
-type ChartgpuClickParams = ChartGPUEventPayload;
-type ChartgpuMouseOverParams = ChartGPUEventPayload;
-type ChartgpuCrosshairMoveParams = ChartGPUCrosshairMovePayload;
-type ChartgpuHitTestResult = ChartGPUHitTestResult;
-type ChartgpuRenderMode = RenderMode;
-type ChartgpuSyncOptions = ChartSyncOptions;
-type ChartgpuXYArraysData = Readonly<{
-    x: ArrayLike<number>;
-    y: ArrayLike<number>;
-    size?: ArrayLike<number>;
+export type ChartgpuSeriesOptions = SeriesConfig;
+export type ChartgpuAxisOptions = AxisConfig;
+export type ChartgpuZoomOptions = DataZoomConfig;
+export type ChartgpuTooltipOptions = TooltipConfig;
+export type ChartgpuAnimationOptions = AnimationConfig | boolean;
+export type ChartgpuThemeOptions = ThemeConfig | 'light' | 'dark';
+export type ChartgpuAnnotationOptions = AnnotationConfig;
+export type ChartgpuThreeDOptions = Pick<ChartGPUOptions, 'coordinateSystem' | 'camera' | 'interaction3d' | 'axes3d'>;
+export type ChartgpuStreamingOptions = Pick<ChartGPUOptions, 'autoScroll'>;
+export type ChartgpuInteractionOptions = Pick<ChartGPUOptions, 'dataZoom' | 'tooltip'>;
+export type ChartgpuChartInstance = ChartGPUInstance;
+export type ChartgpuGPUContext = ChartGPUCreateContext;
+export type ChartgpuStyle = Record<string, string | number | null | undefined>;
+export type ChartgpuZoomRange = NonNullable<ReturnType<ChartGPUInstance['getZoomRange']>>;
+export type ChartgpuClickParams = ChartGPUEventPayload;
+export type ChartgpuMouseOverParams = ChartGPUEventPayload;
+export type ChartgpuCrosshairMoveParams = ChartGPUCrosshairMovePayload;
+export type ChartgpuHitTestResult = ChartGPUHitTestResult;
+export type ChartgpuRenderMode = RenderMode;
+export type ChartgpuSyncOptions = ChartSyncOptions;
+export type ChartgpuXYArraysData = Readonly<{
+  x: ArrayLike<number>;
+  y: ArrayLike<number>;
+  size?: ArrayLike<number>;
 }>;
-type ChartgpuInterleavedXYData = ArrayBufferView;
-type ChartgpuCartesianSeriesData = ReadonlyArray<DataPoint | null> | ChartgpuXYArraysData | ChartgpuInterleavedXYData;
-type ChartgpuAppendDataOptions = Readonly<{
-    maxPoints?: number;
+export type ChartgpuInterleavedXYData = ArrayBufferView;
+export type ChartgpuCartesianSeriesData = ReadonlyArray<DataPoint | null> | ChartgpuXYArraysData | ChartgpuInterleavedXYData;
+export type ChartgpuAppendDataOptions = Readonly<{
+  maxPoints?: number;
 }>;
-interface ChartgpuDataAppendEvent {
-    seriesIndex: number;
-    count: number;
-    xExtent: {
-        min: number;
-        max: number;
-    };
-}
-interface ChartgpuReadyEvent {
-    container: HTMLDivElement;
+export interface ChartgpuDataAppendEvent {
+  seriesIndex: number;
+  count: number;
+  xExtent: {
+    min: number;
+    max: number;
+  };
 }
-interface ChartgpuResizeEvent {
-    width: number;
-    height: number;
-    container: HTMLDivElement;
+export interface ChartgpuReadyEvent {
+  container: HTMLDivElement;
 }
-interface ChartgpuClickEvent {
-    x: number;
-    y: number;
+export interface ChartgpuResizeEvent {
+  width: number;
+  height: number;
+  container: HTMLDivElement;
 }
-interface ChartgpuZoomChangeEvent {
-    range: {
-        start: number;
-        end: number;
-    };
+export interface ChartgpuClickEvent {
+  x: number;
+  y: number;
 }
-interface ChartgpuZoomRangeChangeEvent {
+export interface ChartgpuZoomChangeEvent {
+  range: {
     start: number;
     end: number;
+  };
 }
-interface ChartgpuGPUContextState {
-    adapter: ChartGPUCreateContext['adapter'] | null;
-    device: ChartGPUCreateContext['device'] | null;
-    pipelineCache: PipelineCache | null;
-    error: Error | null;
-    isReady: boolean;
+export interface ChartgpuZoomRangeChangeEvent {
+  start: number;
+  end: number;
 }
-interface ChartgpuChartHandle {
-    getChart(): ChartGPUInstance | null;
-    getContainer(): HTMLDivElement | null;
-    appendData(seriesIndex: number, newPoints: ChartgpuCartesianSeriesData | OHLCDataPoint[], options?: ChartgpuAppendDataOptions): void;
-    renderFrame(): boolean;
-    needsRender(): boolean;
-    getRenderMode(): RenderMode;
-    setRenderMode(mode: RenderMode): void;
-    setOption(options: ChartgpuOptions): void;
-    setZoomRange(start: number, end: number, source?: unknown): void;
-    setInteractionX(x: number | null, source?: unknown): void;
-    getInteractionX(): number | null;
-    hitTest(event: PointerEvent | MouseEvent): ChartGPUHitTestResult | null;
+export interface ChartgpuGPUContextState {
+  adapter: ChartGPUCreateContext['adapter'] | null;
+  device: ChartGPUCreateContext['device'] | null;
+  pipelineCache: PipelineCache | null;
+  error: Error | null;
+  isReady: boolean;
 }
-
-declare class ChartGpuAngularComponent implements ChartgpuChartHandle, OnDestroy {
-    private readonly destroyRef;
-    readonly options: _angular_core.InputSignal<chartgpu.ChartGPUOptions>;
-    readonly gpuContext: _angular_core.InputSignal<Readonly<{
-        readonly device: GPUDevice;
-        readonly adapter: GPUAdapter;
-        readonly pipelineCache?: chartgpu.PipelineCache;
-    }>>;
-    readonly theme: _angular_core.InputSignal<chartgpu.ThemeConfig | "light" | "dark">;
-    readonly className: _angular_core.InputSignal<string>;
-    readonly style: _angular_core.InputSignal<ChartgpuStyle>;
-    readonly ready: _angular_core.OutputEmitterRef<ChartgpuReadyEvent>;
-    readonly chartReady: _angular_core.OutputEmitterRef<ChartGPUInstance>;
-    readonly chartDispose: _angular_core.OutputEmitterRef<void>;
-    readonly resize: _angular_core.OutputEmitterRef<ChartgpuResizeEvent>;
-    readonly click: _angular_core.OutputEmitterRef<ChartgpuClickEvent>;
-    readonly chartClick: _angular_core.OutputEmitterRef<Readonly<{
-        readonly seriesIndex: number | null;
-        readonly dataIndex: number | null;
-        readonly value: readonly [number, number] | null;
-        readonly seriesName: string | null;
-        readonly event: PointerEvent;
-    }>>;
-    readonly mouseOver: _angular_core.OutputEmitterRef<Readonly<{
-        readonly seriesIndex: number | null;
-        readonly dataIndex: number | null;
-        readonly value: readonly [number, number] | null;
-        readonly seriesName: string | null;
-        readonly event: PointerEvent;
-    }>>;
-    readonly mouseOut: _angular_core.OutputEmitterRef<Readonly<{
-        readonly seriesIndex: number | null;
-        readonly dataIndex: number | null;
-        readonly value: readonly [number, number] | null;
-        readonly seriesName: string | null;
-        readonly event: PointerEvent;
-    }>>;
-    readonly crosshairMove: _angular_core.OutputEmitterRef<Readonly<{
-        readonly x: number | null;
-        readonly source?: unknown;
-    }>>;
-    readonly dataAppend: _angular_core.OutputEmitterRef<ChartgpuDataAppendEvent>;
-    readonly zoomChange: _angular_core.OutputEmitterRef<ChartgpuZoomChangeEvent>;
-    readonly zoomRangeChange: _angular_core.OutputEmitterRef<ChartgpuZoomRangeChangeEvent>;
-    readonly deviceLost: _angular_core.OutputEmitterRef<Readonly<{
-        readonly reason: GPUDeviceLostReason;
-        readonly message: string;
-    }>>;
-    readonly chartError: _angular_core.OutputEmitterRef<Error>;
-    readonly host: _angular_core.Signal<ElementRef<HTMLDivElement>>;
-    readonly canvasHost: _angular_core.Signal<ElementRef<HTMLDivElement>>;
-    private readonly chartInstance;
-    readonly initializationError: _angular_core.WritableSignal<Error>;
-    private chartContainer?;
-    private createdWithOptions?;
-    private resizeTimeout?;
-    private resizeObserver?;
-    private removeChartListeners?;
-    private destroying;
-    constructor(destroyRef: DestroyRef);
-    protected emitClick(event: MouseEvent): void;
-    ngOnDestroy(): void;
-    getChart(): ChartGPUInstance | null;
-    getContainer(): HTMLDivElement | null;
-    appendData(seriesIndex: number, newPoints: ChartgpuCartesianSeriesData | OHLCDataPoint[], options?: ChartgpuAppendDataOptions): void;
-    renderFrame(): boolean;
-    needsRender(): boolean;
-    getRenderMode(): 'auto' | 'external';
-    setRenderMode(mode: 'auto' | 'external'): void;
-    setOption(options: ChartgpuOptions): void;
-    setZoomRange(start: number, end: number, source?: unknown): void;
-    setInteractionX(x: number | null, source?: unknown): void;
-    getInteractionX(): number | null;
-    hitTest(event: PointerEvent | MouseEvent): Readonly<{
-        readonly isInGrid: boolean;
-        readonly canvasX: number;
-        readonly canvasY: number;
-        readonly gridX: number;
-        readonly gridY: number;
-        readonly match: chartgpu.ChartGPUHitTestMatch | null;
-    }>;
-    private getEffectiveOptions;
-    private listenToChart;
-    private emitZoomRange;
-    private observeResize;
-    private reportError;
-    private disposeChart;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartGpuAngularComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartGpuAngularComponent, "lib-chartgpu-angular", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "gpuContext": { "alias": "gpuContext"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "style": { "alias": "style"; "required": false; "isSignal": true; }; }, { "ready": "ready"; "chartReady": "chartReady"; "chartDispose": "chartDispose"; "resize": "resize"; "click": "click"; "chartClick": "chartClick"; "mouseOver": "mouseOver"; "mouseOut": "mouseOut"; "crosshairMove": "crosshairMove"; "dataAppend": "dataAppend"; "zoomChange": "zoomChange"; "zoomRangeChange": "zoomRangeChange"; "deviceLost": "deviceLost"; "chartError": "chartError"; }, never, never, true, never>;
+export interface ChartgpuChartHandle {
+  getChart(): ChartGPUInstance | null;
+  getContainer(): HTMLDivElement | null;
+  appendData(seriesIndex: number, newPoints: ChartgpuCartesianSeriesData | OHLCDataPoint[], options?: ChartgpuAppendDataOptions): void;
+  renderFrame(): boolean;
+  needsRender(): boolean;
+  getRenderMode(): RenderMode;
+  setRenderMode(mode: RenderMode): void;
+  setOption(options: ChartgpuOptions): void;
+  setZoomRange(start: number, end: number, source?: unknown): void;
+  setInteractionX(x: number | null, source?: unknown): void;
+  getInteractionX(): number | null;
+  hitTest(event: PointerEvent | MouseEvent): ChartGPUHitTestResult | null;
 }
-
-declare class ChartgpuConnectChartsDirective {
-    readonly charts: _angular_core.InputSignal<readonly ChartGPUInstance[]>;
-    readonly syncOptions: _angular_core.InputSignal<Readonly<{
-        readonly syncCrosshair?: boolean;
-        readonly syncZoom?: boolean;
-    }>>;
-    readonly connectionError: _angular_core.OutputEmitterRef<Error>;
-    private readonly ids;
-    private nextId;
-    private signature;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartgpuConnectChartsDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ChartgpuConnectChartsDirective, "[libChartgpuConnectCharts]", never, { "charts": { "alias": "libChartgpuConnectCharts"; "required": false; "isSignal": true; }; "syncOptions": { "alias": "syncOptions"; "required": false; "isSignal": true; }; }, { "connectionError": "connectionError"; }, never, never, true, never>;
+export declare class ChartGpuAngularComponent implements ChartgpuChartHandle, OnDestroy {
+  private readonly destroyRef;
+  readonly options: import("@angular/core").InputSignal<import("chartgpu").ChartGPUOptions>;
+  readonly gpuContext: import("@angular/core").InputSignal<Readonly<{
+    readonly device: GPUDevice;
+    readonly adapter: GPUAdapter;
+    readonly pipelineCache?: import("chartgpu").PipelineCache;
+  }> | null>;
+  readonly theme: import("@angular/core").InputSignal<import("chartgpu").ThemeConfig | "light" | "dark" | undefined>;
+  readonly className: import("@angular/core").InputSignal<string | undefined>;
+  readonly style: import("@angular/core").InputSignal<ChartgpuStyle | undefined>;
+  readonly ready: import("@angular/core").OutputEmitterRef<ChartgpuReadyEvent>;
+  readonly chartReady: import("@angular/core").OutputEmitterRef<ChartGPUInstance$1>;
+  readonly chartDispose: import("@angular/core").OutputEmitterRef<void>;
+  readonly resize: import("@angular/core").OutputEmitterRef<ChartgpuResizeEvent>;
+  readonly click: import("@angular/core").OutputEmitterRef<ChartgpuClickEvent>;
+  readonly chartClick: import("@angular/core").OutputEmitterRef<Readonly<{
+    readonly seriesIndex: number | null;
+    readonly dataIndex: number | null;
+    readonly value: readonly [number, number] | null;
+    readonly seriesName: string | null;
+    readonly event: PointerEvent;
+  }>>;
+  readonly mouseOver: import("@angular/core").OutputEmitterRef<Readonly<{
+    readonly seriesIndex: number | null;
+    readonly dataIndex: number | null;
+    readonly value: readonly [number, number] | null;
+    readonly seriesName: string | null;
+    readonly event: PointerEvent;
+  }>>;
+  readonly mouseOut: import("@angular/core").OutputEmitterRef<Readonly<{
+    readonly seriesIndex: number | null;
+    readonly dataIndex: number | null;
+    readonly value: readonly [number, number] | null;
+    readonly seriesName: string | null;
+    readonly event: PointerEvent;
+  }>>;
+  readonly crosshairMove: import("@angular/core").OutputEmitterRef<Readonly<{
+    readonly x: number | null;
+    readonly source?: unknown;
+  }>>;
+  readonly dataAppend: import("@angular/core").OutputEmitterRef<ChartgpuDataAppendEvent>;
+  readonly zoomChange: import("@angular/core").OutputEmitterRef<ChartgpuZoomChangeEvent>;
+  readonly zoomRangeChange: import("@angular/core").OutputEmitterRef<ChartgpuZoomRangeChangeEvent>;
+  readonly deviceLost: import("@angular/core").OutputEmitterRef<Readonly<{
+    readonly reason: GPUDeviceLostReason;
+    readonly message: string;
+  }>>;
+  readonly chartError: import("@angular/core").OutputEmitterRef<Error>;
+  readonly host: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
+  readonly canvasHost: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
+  private readonly chartInstance;
+  readonly initializationError: import("@angular/core").WritableSignal<Error | null>;
+  private chartContainer?;
+  private createdWithOptions?;
+  private resizeTimeout?;
+  private resizeObserver?;
+  private removeChartListeners?;
+  private destroying;
+  constructor(destroyRef: DestroyRef);
+  protected emitClick(event: MouseEvent): void;
+  ngOnDestroy(): void;
+  getChart(): ChartGPUInstance$1 | null;
+  getContainer(): HTMLDivElement | null;
+  appendData(seriesIndex: number, newPoints: ChartgpuCartesianSeriesData | OHLCDataPoint$1[], options?: ChartgpuAppendDataOptions): void;
+  renderFrame(): boolean;
+  needsRender(): boolean;
+  getRenderMode(): 'auto' | 'external';
+  setRenderMode(mode: 'auto' | 'external'): void;
+  setOption(options: ChartgpuOptions): void;
+  setZoomRange(start: number, end: number, source?: unknown): void;
+  setInteractionX(x: number | null, source?: unknown): void;
+  getInteractionX(): number | null;
+  hitTest(event: PointerEvent | MouseEvent): Readonly<{
+    readonly isInGrid: boolean;
+    readonly canvasX: number;
+    readonly canvasY: number;
+    readonly gridX: number;
+    readonly gridY: number;
+    readonly match: import("chartgpu").ChartGPUHitTestMatch | null;
+  }> | null;
+  private getEffectiveOptions;
+  private listenToChart;
+  private emitZoomRange;
+  private observeResize;
+  private reportError;
+  private disposeChart;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartGpuAngularComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ChartGpuAngularComponent, "lib-chartgpu-angular", never, {
+    "options": {
+      "alias": "options";
+      "required": true;
+      "isSignal": true;
+    };
+    "gpuContext": {
+      "alias": "gpuContext";
+      "required": false;
+      "isSignal": true;
+    };
+    "theme": {
+      "alias": "theme";
+      "required": false;
+      "isSignal": true;
+    };
+    "className": {
+      "alias": "className";
+      "required": false;
+      "isSignal": true;
+    };
+    "style": {
+      "alias": "style";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "ready": "ready";
+    "chartReady": "chartReady";
+    "chartDispose": "chartDispose";
+    "resize": "resize";
+    "click": "click";
+    "chartClick": "chartClick";
+    "mouseOver": "mouseOver";
+    "mouseOut": "mouseOut";
+    "crosshairMove": "crosshairMove";
+    "dataAppend": "dataAppend";
+    "zoomChange": "zoomChange";
+    "zoomRangeChange": "zoomRangeChange";
+    "deviceLost": "deviceLost";
+    "chartError": "chartError";
+  }, never, never, true, never>;
+}
+export declare class ChartgpuConnectChartsDirective {
+  readonly charts: import("@angular/core").InputSignal<readonly (ChartGPUInstance$1 | null | undefined)[]>;
+  readonly syncOptions: import("@angular/core").InputSignal<Readonly<{
+    readonly syncCrosshair?: boolean;
+    readonly syncZoom?: boolean;
+  }> | undefined>;
+  readonly connectionError: import("@angular/core").OutputEmitterRef<Error>;
+  private readonly ids;
+  private nextId;
+  private signature;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartgpuConnectChartsDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ChartgpuConnectChartsDirective, "[libChartgpuConnectCharts]", never, {
+    "charts": {
+      "alias": "libChartgpuConnectCharts";
+      "required": false;
+      "isSignal": true;
+    };
+    "syncOptions": {
+      "alias": "syncOptions";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "connectionError": "connectionError";
+  }, never, never, true, never>;
 }
-
-declare function provideChartGpuContext(): _angular_core.EnvironmentProviders;
-
+export declare function provideChartGpuContext(): import("@angular/core").EnvironmentProviders;
 /**
  * Creates one shared WebGPU context and pipeline cache for charts in a dashboard.
  * The device is intentionally not destroyed with the service so charts can share it
  * for the lifetime of the application.
  */
-declare class ChartgpuGPUContextService {
-    readonly state: _angular_core.WritableSignal<ChartgpuGPUContextState>;
-    readonly context: _angular_core.Signal<Readonly<{
-        readonly device: GPUDevice;
-        readonly adapter: GPUAdapter;
-        readonly pipelineCache?: chartgpu.PipelineCache;
-    }>>;
-    private initialization?;
-    initialize(): Promise<ChartgpuGPUContextState>;
-    private createContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartgpuGPUContextService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartgpuGPUContextService>;
+export declare class ChartgpuGPUContextService {
+  readonly state: import("@angular/core").WritableSignal<ChartgpuGPUContextState>;
+  readonly context: import("@angular/core").Signal<Readonly<{
+    readonly device: GPUDevice;
+    readonly adapter: GPUAdapter;
+    readonly pipelineCache?: import("chartgpu").PipelineCache;
+  }> | null>;
+  private initialization?;
+  initialize(): Promise<ChartgpuGPUContextState>;
+  private createContext;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ChartgpuGPUContextService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
-
-export { ChartGpuAngularComponent, ChartgpuConnectChartsDirective, ChartgpuGPUContextService, provideChartGpuContext };
-export type { ChartgpuAnimationOptions, ChartgpuAnnotationOptions, ChartgpuAppendDataOptions, ChartgpuAxisOptions, ChartgpuCartesianSeriesData, ChartgpuChartHandle, ChartgpuChartInstance, ChartgpuClickEvent, ChartgpuClickParams, ChartgpuCrosshairMoveParams, ChartgpuDataAppendEvent, ChartgpuGPUContext, ChartgpuGPUContextState, ChartgpuHitTestResult, ChartgpuInteractionOptions, ChartgpuInterleavedXYData, ChartgpuMouseOverParams, ChartgpuOptions, ChartgpuReadyEvent, ChartgpuRenderMode, ChartgpuResizeEvent, ChartgpuSeriesData, ChartgpuSeriesOptions, ChartgpuSeriesType, ChartgpuStreamingOptions, ChartgpuStyle, ChartgpuSyncOptions, ChartgpuThemeOptions, ChartgpuThreeDOptions, ChartgpuTooltipOptions, ChartgpuXYArraysData, ChartgpuZoomChangeEvent, ChartgpuZoomOptions, ChartgpuZoomRange, ChartgpuZoomRangeChangeEvent };
+export type { ChartGPUCreateContext, ChartGPUCrosshairMovePayload, ChartGPUDeviceLostPayload, ChartGPUEventPayload, ChartGPUHitTestResult, ChartGPUInstance, ChartSyncOptions, DataPoint, OHLCDataPoint, PipelineCache, RenderMode };