@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/chart/_shared/core/brush/brush-interaction.d.ts

@@ -0,0 +1,63 @@
+import { type CartesianBrushAreaInput, type CartesianBrushChangeEventDetail, type CartesianBrushEndEventDetail, type CartesianBrushMoveEventDetail, type CartesianBrushSelectedSeries, type CartesianBrushSource, type CartesianBrushSpec, type CartesianBrushStartEventDetail, type CartesianBrushState } from './brush-contract';
+import { type BrushPixelPoint, type BrushPixelShape, type BrushRect, type BrushScale } from './brush-geometry';
+export declare const BRUSH_LASSO_STEP_PX = 2;
+export interface BrushHostFrame {
+    plot: BrushRect;
+    xScale: BrushScale;
+    yScale: BrushScale;
+}
+export interface BrushInteractionHost {
+    frame(): BrushHostFrame | undefined;
+    spec(): CartesianBrushSpec;
+    state(): CartesianBrushState | null;
+    apply(next: CartesianBrushState | null): void;
+    emit(detail: CartesianBrushChangeEventDetail): void;
+    preview(shape: BrushPixelShape | null): void;
+    standDown(): void;
+    points(): BrushPixelPoint[];
+    start?(detail: CartesianBrushStartEventDetail): void;
+    move?(detail: CartesianBrushMoveEventDetail): void;
+    end?(detail: CartesianBrushEndEventDetail): void;
+    now?(): number;
+}
+export interface BrushPointerInput {
+    pointerId: number;
+    x: number;
+    y: number;
+    button?: number;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    pointerType?: string;
+}
+export interface BrushKeyInput {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+}
+export declare class BrushInteraction {
+    private readonly host;
+    private drag;
+    private previewShown;
+    private suppressClick;
+    constructor(host: BrushInteractionHost);
+    get isPending(): boolean;
+    get isActive(): boolean;
+    selection(): CartesianBrushSelectedSeries[];
+    private detail;
+    transition(next: CartesianBrushState | null, source: CartesianBrushSource): CartesianBrushChangeEventDetail | null;
+    setAreas(areas: ReadonlyArray<CartesianBrushAreaInput> | null | undefined, source?: CartesianBrushSource): CartesianBrushChangeEventDetail | null;
+    clear(source?: CartesianBrushSource): CartesianBrushChangeEventDetail | null;
+    private modifierHeld;
+    pointerDown(input: BrushPointerInput): boolean;
+    private activate;
+    private reportMove;
+    pointerMove(input: BrushPointerInput): boolean;
+    pointerUp(input: BrushPointerInput): void;
+    pointerCancel(): void;
+    private hidePreview;
+    consumeSuppressedClick(): boolean;
+    keyDown(event: BrushKeyInput): boolean;
+    dispose(): void;
+}

package/dist/types/components/chart/_shared/core/brush/index.d.ts

@@ -0,0 +1,6 @@
+export { BRUSH_LASSO_MIN_POINTS, CARTESIAN_BRUSH_DEFAULTS, isCartesianBrushType, normalizeBrushArea, resolveCartesianBrushSpec, sameBrushArea, sameBrushState, } from './brush-contract';
+export type { CartesianBrushArea, CartesianBrushAreaInput, CartesianBrushBandArea, CartesianBrushChangeEventDetail, CartesianBrushCoverage, CartesianBrushEndEventDetail, CartesianBrushInput, CartesianBrushLassoArea, CartesianBrushMode, CartesianBrushModifier, CartesianBrushMoveEventDetail, CartesianBrushPoint, CartesianBrushRange, CartesianBrushRectArea, CartesianBrushSelectedPoint, CartesianBrushSelectedSeries, CartesianBrushSource, CartesianBrushSpec, CartesianBrushStartEventDetail, CartesianBrushState, CartesianBrushType, } from './brush-contract';
+export { areaFromPixelPolygon, areaFromPixelRect, bandFromPixelRect, bandRectForPlot, brushRectFromDrag, brushSelectionCount, clipRectToPlot, isMeaningfulBand, isMeaningfulBrush, lassoAcceptsVertex, pixelBandFromArea, pixelPolygonFromArea, pixelRectFromArea, pixelShapeFromArea, pointInBrushRect, pointInPolygon, polygonBounds, selectBrushPoints, } from './brush-geometry';
+export type { BrushPixelPoint, BrushPixelShape, BrushPoint, BrushRect, BrushScale } from './brush-geometry';
+export { BRUSH_LASSO_STEP_PX, BrushInteraction } from './brush-interaction';
+export type { BrushHostFrame, BrushInteractionHost, BrushKeyInput, BrushPointerInput } from './brush-interaction';

package/dist/types/components/chart/_shared/core/color/heatmap-color.d.ts

@@ -0,0 +1,28 @@
+import { type ContinuousVisualMapSpec, type VisualMapPalette, type VisualMapSnapshot } from '../visual-map/visual-map-contract.ts';
+import type { HeatmapColorInput, HeatmapValueExtent } from '../contract/heatmap-contract.ts';
+import type { ChartRgba } from './rgba.ts';
+export declare const HEATMAP_LUT_WIDTH = 256;
+export interface HeatmapColorScale {
+    readonly spec: ContinuousVisualMapSpec;
+    readonly palette: VisualMapPalette;
+    readonly lut: Uint32Array;
+    readonly key: string;
+    readonly min: number;
+    readonly max: number;
+    readonly outOfRange?: ChartRgba;
+}
+export interface ResolveHeatmapColorScaleInput {
+    readonly colors?: HeatmapColorInput | null;
+    readonly min?: number | null;
+    readonly max?: number | null;
+    readonly extent?: HeatmapValueExtent | null;
+}
+export declare function packRgba8(r: number, g: number, b: number, a: number): number;
+export declare function heatmapRgbaOf(css: string | null | undefined): ChartRgba | null;
+export declare function resolveHeatmapDomain(input: Pick<ResolveHeatmapColorScaleInput, 'min' | 'max' | 'extent'>): {
+    min: number;
+    max: number;
+};
+export declare function resolveHeatmapColorScale(input: ResolveHeatmapColorScaleInput): HeatmapColorScale;
+export declare function heatmapVisualMapKey(snapshot: VisualMapSnapshot): string;
+export declare function resolveHeatmapVisualMapScale(snapshot: VisualMapSnapshot): HeatmapColorScale;

package/dist/types/components/chart/_shared/core/color/index.d.ts

@@ -0,0 +1,5 @@
+export * from './parse';
+export * from './interpolate';
+export { type ColorScheme, categorical, sequential, diverging, makeColorScale, discretize, } from './scheme';
+export { NAMED_COLORS } from './named-colors';
+export { type ColorInput, normalizeColorList, resolveSingleColor, resolvePairColors, resolveColorList, normalizeList, resolvePair, resolveTokenList, } from './resolve';

package/dist/types/components/chart/_shared/core/color/interpolate.d.ts

@@ -0,0 +1,33 @@
+import type { ParsedColor } from '../types';
+export type ColorSpace = 'rgb' | 'hsl' | 'lab' | 'lch';
+export interface InterpolateOptions {
+    space?: ColorSpace;
+    hue?: 'short' | 'long';
+}
+declare function rgbByteToLab(r: number, g: number, b: number): [
+    number,
+    number,
+    number
+];
+declare function labToRgbByte(L: number, a: number, b: number): [
+    number,
+    number,
+    number
+];
+declare function rgbByteToLch(r: number, g: number, b: number): [
+    number,
+    number,
+    number
+];
+declare function hueDelta(a: number, b: number, arc: 'short' | 'long'): number;
+export declare function interpolateRgb(a: ParsedColor, b: ParsedColor): (t: number) => ParsedColor;
+export declare function interpolateHsl(a: ParsedColor, b: ParsedColor, hueArc?: 'short' | 'long'): (t: number) => ParsedColor;
+export declare function interpolateLab(a: ParsedColor, b: ParsedColor): (t: number) => ParsedColor;
+export declare function interpolateLch(a: ParsedColor, b: ParsedColor, hueArc?: 'short' | 'long'): (t: number) => ParsedColor;
+export declare function interpolate(a: ParsedColor, b: ParsedColor, options?: InterpolateOptions): (t: number) => ParsedColor;
+export declare const _rgbToLab: typeof rgbByteToLab;
+export declare const _rgbToLch: typeof rgbByteToLch;
+export declare const _labToRgb: typeof labToRgbByte;
+export declare const _hueDelta: typeof hueDelta;
+export declare function mix(a: ParsedColor, b: ParsedColor, t: number, options?: InterpolateOptions): ParsedColor;
+export {};

package/dist/types/components/chart/_shared/core/color/named-colors.d.ts

@@ -0,0 +1 @@
+export { NAMED_COLORS } from './parse';

package/dist/types/components/chart/_shared/core/color/parse.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedColor } from '../types';
+export declare const NAMED_COLORS: Readonly<Record<string, readonly [
+    number,
+    number,
+    number,
+    number
+]>>;
+export declare function parseColor(input: string): ParsedColor | null;

package/dist/types/components/chart/_shared/core/color/resolve.d.ts

@@ -0,0 +1,20 @@
+export type ColorInput = string | ReadonlyArray<string> | null | undefined;
+export declare function normalizeColorList(color: ColorInput): string[];
+export declare function resolveSingleColor(color: ColorInput, fallback: string): string;
+export declare function resolvePairColors(color: ColorInput, defaults: readonly [
+    string,
+    string
+]): [
+    string,
+    string
+];
+export declare function resolveColorList(color: ColorInput, n: number, defaults?: ReadonlyArray<string>, palette?: ReadonlyArray<string>): string[];
+export declare const normalizeList: typeof normalizeColorList;
+export declare function resolvePair(value: ColorInput, defaults: readonly [
+    string,
+    string
+]): [
+    string,
+    string
+];
+export declare function resolveTokenList(value: ColorInput, n: number, fallback: string): string[];

package/dist/types/components/chart/_shared/core/color/rgba.d.ts

@@ -0,0 +1,6 @@
+export type ChartRgba = readonly [
+    number,
+    number,
+    number,
+    number
+];

package/dist/types/components/chart/_shared/core/color/scheme.d.ts

@@ -0,0 +1,43 @@
+import type { ParsedColor } from '../types';
+export type ColorSpace = 'rgb' | 'hsl' | 'lab' | 'lch';
+export interface ColorScheme {
+    readonly name: string;
+    readonly type: 'categorical' | 'sequential' | 'diverging';
+    readonly stops: readonly ParsedColor[];
+    readonly recommendedSpace?: ColorSpace;
+}
+export declare const categorical: {
+    readonly tableau10: ColorScheme;
+    readonly tableau20: ColorScheme;
+    readonly observable10: ColorScheme;
+    readonly paired12: ColorScheme;
+    readonly set3_12: ColorScheme;
+};
+export declare const sequential: {
+    readonly viridis: ColorScheme;
+    readonly inferno: ColorScheme;
+    readonly magma: ColorScheme;
+    readonly plasma: ColorScheme;
+    readonly cividis: ColorScheme;
+    readonly blues: ColorScheme;
+    readonly greens: ColorScheme;
+    readonly oranges: ColorScheme;
+    readonly reds: ColorScheme;
+    readonly purples: ColorScheme;
+    readonly greys: ColorScheme;
+};
+export declare const diverging: {
+    readonly rdbu: ColorScheme;
+    readonly spectral: ColorScheme;
+    readonly piyg: ColorScheme;
+    readonly brbg: ColorScheme;
+    readonly puor: ColorScheme;
+    readonly rdylbu: ColorScheme;
+};
+export declare function makeColorScale(scheme: ColorScheme | readonly ParsedColor[], options?: {
+    space?: ColorSpace;
+    hue?: 'short' | 'long';
+}): (t: number) => ParsedColor;
+export declare function discretize(scheme: ColorScheme, n: number, options?: {
+    space?: ColorSpace;
+}): ParsedColor[];

package/dist/types/components/chart/_shared/core/contract/bar3d-contract.d.ts

@@ -0,0 +1,140 @@
+import type { Scene3DVector, Scene3DBounds } from './scene3d-camera-contract';
+import type { Scene3DDataSpace, Scene3DDomain, Scene3DAxesOptions } from './scene3d-chart-contract';
+import type { HeatmapColorInput, HeatmapEngineMode, HeatmapEngineTier, HeatmapUnavailableBehaviour } from './heatmap-contract';
+export type Bar3DCategory = string | number;
+export interface Bar3DDatum {
+    id?: string | number;
+    label?: string;
+    x: Bar3DCategory | null;
+    y: Bar3DCategory | null;
+    z: number | null;
+    base?: number;
+    value?: number | null;
+    color?: string;
+    width?: number;
+    depth?: number;
+}
+export type Bar3DTuple = readonly [
+    Bar3DCategory | null,
+    Bar3DCategory | null,
+    number | null,
+    number?
+];
+export type Bar3DData = ReadonlyArray<Bar3DDatum | Bar3DTuple>;
+export interface Bar3DPoint extends Bar3DDatum {
+    index: number;
+    key: string;
+    valid: boolean;
+    base: number;
+    value: number | null;
+}
+export interface Bar3DDiagnostics {
+    points: number;
+    validPoints: number;
+    missingCoordinates: number;
+    invalidCoordinates: number;
+    missingValues: number;
+    zeroHeight: number;
+}
+export interface Bar3DDataset {
+    points: ReadonlyArray<Bar3DPoint>;
+    diagnostics: Bar3DDiagnostics;
+}
+export interface Bar3DLayoutOptions {
+    size?: Scene3DVector;
+    width?: number;
+    depth?: number;
+    xCategories?: ReadonlyArray<Bar3DCategory>;
+    yCategories?: ReadonlyArray<Bar3DCategory>;
+    colors?: HeatmapColorInput;
+    colorDomain?: Scene3DDomain;
+    missingColor?: string;
+}
+export interface Bar3DGeometry extends Scene3DDataSpace {
+    points: number;
+    drawn: number;
+    triangles: number;
+    positions: Float32Array;
+    normals: Float32Array;
+    colors: Float32Array;
+    indices: Uint32Array;
+    pointIndices: Uint32Array;
+    trianglePoints: Uint32Array;
+    categories: {
+        x: Bar3DCategory[];
+        y: Bar3DCategory[];
+    };
+    colorDomain: Scene3DDomain;
+    bounds: Scene3DBounds;
+}
+export interface Bar3DHitDetail {
+    kind: 'bar3d';
+    point: Bar3DPoint;
+    pointIndex: number;
+    world: Scene3DVector;
+    center: Scene3DVector;
+    cssX: number;
+    cssY: number;
+    depth: number;
+    triangle: number;
+}
+export interface Bar3DSelection {
+    point: Bar3DPoint | null;
+}
+export type Bar3DSelectionSource = 'pointer' | 'keyboard' | 'method' | 'data';
+export interface Bar3DSelectionChangeEventDetail extends Bar3DSelection {
+    by: Bar3DSelectionSource;
+}
+export interface Bar3DCrosshairDetail {
+    cssX: number;
+    cssY: number;
+    dataX: Bar3DCategory;
+    dataY: Bar3DCategory;
+    dataZ: number;
+    point: Bar3DPoint;
+    snapped: boolean;
+}
+export interface Bar3DStreamEvent {
+    type: 'push' | 'pushBatch' | 'shift' | 'replace';
+    count: number;
+    replaced: number;
+    entries: Bar3DDatum[];
+}
+export interface Bar3DStreamSource {
+    readonly length: number;
+    readonly capacity: number;
+    readonly dropped: number;
+    push(point: Bar3DDatum): void;
+    pushBatch(points: ReadonlyArray<Bar3DDatum>): void;
+    shift(count: number): void;
+    replace(points: ReadonlyArray<Bar3DDatum>): void;
+    setCapacity(capacity: number): void;
+    snapshot(): Bar3DDatum[];
+    subscribe(listener: (event: Bar3DStreamEvent) => void): () => void;
+}
+export interface Bar3DRenderResult {
+    points: number;
+    drawn: number;
+    renderMs: number;
+    bar3d?: {
+        triangles: number;
+        vertices: number;
+        chunks: number;
+        drawCalls: number;
+        uploadedBytes: number;
+    };
+}
+export interface Bar3DAxesOptions extends Omit<Scene3DAxesOptions, 'format'> {
+    format?: (value: Bar3DCategory, axis: 'x' | 'y' | 'z') => string;
+}
+export type Bar3DEngineMode = HeatmapEngineMode;
+export type Bar3DEngineTier = HeatmapEngineTier;
+export type Bar3DUnavailableBehaviour = HeatmapUnavailableBehaviour;
+export type Bar3DDomain = Scene3DDomain;
+export type Bar3DEasing = import('./heatmap-contract').HeatmapEasing;
+export type Bar3DCameraChangeEventDetail = import('./scene3d-chart-contract').Scene3DCameraChangeEventDetail;
+export interface Bar3DCrosshairShowRequest {
+    dataX?: Bar3DCategory;
+    dataY?: Bar3DCategory;
+    dataZ?: number;
+}

package/dist/types/components/chart/_shared/core/contract/box-plot-contract.d.ts

@@ -0,0 +1,138 @@
+import type { HeatmapAnimationType, HeatmapEasing, HeatmapEngineMode, HeatmapEngineTier, HeatmapUnavailableBehaviour } from './heatmap-contract';
+export interface BoxPlotSamplesInput {
+    category: string;
+    values: ReadonlyArray<number>;
+}
+export interface BoxPlotSummaryInput {
+    category: string;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    outliers?: ReadonlyArray<number>;
+    mean?: number;
+    count?: number;
+}
+export type BoxPlotSamplesTupleInput = readonly [
+    category: string,
+    values: ReadonlyArray<number>
+];
+export type BoxPlotSummaryTupleInput = readonly [
+    category: string,
+    min: number,
+    q1: number,
+    median: number,
+    q3: number,
+    max: number,
+    outliers?: ReadonlyArray<number>
+];
+export type BoxPlotDatumInput = BoxPlotSamplesInput | BoxPlotSummaryInput | BoxPlotSamplesTupleInput | BoxPlotSummaryTupleInput;
+export type BoxPlotData = ReadonlyArray<BoxPlotDatumInput>;
+export type BoxPlotWhiskerRule = 'tukey' | 'min-max' | 'percentile' | number;
+export type BoxPlotQuantileMethod = 'linear' | 'exclusive' | 'nearest' | 'lower' | 'higher' | 'midpoint';
+export interface BoxPlotNotch {
+    low: number;
+    high: number;
+}
+export interface BoxPlotBox {
+    index: number;
+    category: string;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    outliers: number[];
+    farOutliers: number[];
+    count: number;
+    mean: number | null;
+    stddev: number | null;
+    notch: BoxPlotNotch | null;
+    fences: {
+        low: number;
+        high: number;
+    } | null;
+    source: 'samples' | 'summary';
+}
+export interface BoxPlotStatistics extends BoxPlotBox {
+    iqr: number;
+    variance: number | null;
+    whisker: {
+        rule: BoxPlotWhiskerRule;
+        low: number;
+        high: number;
+    };
+    method: BoxPlotQuantileMethod;
+}
+export interface BoxPlotExtent {
+    boxes: number;
+    valueMin: number;
+    valueMax: number;
+    outliers: number;
+}
+export interface BoxPlotDomain {
+    yMin: number;
+    yMax: number;
+}
+export type BoxPlotEngineMode = HeatmapEngineMode;
+export type BoxPlotEngineTier = HeatmapEngineTier;
+export type BoxPlotEasing = HeatmapEasing;
+export type BoxPlotAnimationType = HeatmapAnimationType;
+export type BoxPlotUnavailableBehaviour = HeatmapUnavailableBehaviour;
+export interface BoxPlotPointEventDetail {
+    index: number;
+    category: string;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    iqr: number;
+    outliers: number[];
+    count: number;
+    mean: number | null;
+    cssX: number;
+    cssY: number;
+}
+export type BoxPlotOrientation = 'vertical' | 'horizontal';
+export interface BoxPlotDrawStats {
+    boxes: number;
+    drawn: number;
+    instances: number;
+    outliers: number;
+    bytes: number;
+    uploaded: number;
+    full: boolean;
+    version: number;
+    pitchPx: number;
+    boxPx: number;
+    whiskerPx: number;
+    parts: number;
+    orientation: BoxPlotOrientation;
+    notched: boolean;
+    showMean: boolean;
+}
+export interface BoxPlotRenderResult {
+    boxes: number;
+    drawn: number;
+    renderMs: number;
+    boxPlot?: BoxPlotDrawStats;
+}
+export interface BoxPlotStreamEvent {
+    type: 'push' | 'pushBatch' | 'shift' | 'replace';
+    count: number;
+    entries: BoxPlotDatumInput[];
+    replaced: number;
+}
+export interface BoxPlotStreamSource {
+    readonly length: number;
+    readonly capacity: number;
+    readonly dropped: number;
+    push(datum: BoxPlotDatumInput): void;
+    pushBatch(data: ReadonlyArray<BoxPlotDatumInput>): void;
+    shift(count: number): void;
+    replace(data: ReadonlyArray<BoxPlotDatumInput>): void;
+    snapshot(): BoxPlotDatumInput[];
+    subscribe(listener: (event: BoxPlotStreamEvent) => void): () => void;
+}

package/dist/types/components/chart/_shared/core/contract/bubble-contract.d.ts

@@ -0,0 +1,118 @@
+import type { HeatmapAnimationType, HeatmapEasing, HeatmapEngineMode, HeatmapUnavailableBehaviour } from './heatmap-contract';
+export interface BubbleDatumObject {
+    x: number;
+    y: number;
+    z: number;
+    name?: string;
+    color?: string;
+}
+export type BubbleDatumTuple = readonly [
+    x: number,
+    y: number,
+    z: number,
+    name?: string
+];
+export type BubbleDatumInput = BubbleDatumObject | BubbleDatumTuple;
+export type BubbleData = ReadonlyArray<BubbleDatumInput>;
+export type BubbleSizeScale = 'area' | 'radius';
+export interface BubblePoint {
+    index: number;
+    x: number;
+    y: number;
+    z: number;
+    name: string | null;
+    color: string | null;
+    source: 'data' | 'stream';
+}
+export interface BubbleExtent {
+    points: number;
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+    zMin: number;
+    zMax: number;
+}
+export interface BubbleDomain {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+}
+export type BubbleLayoutMode = 'xy' | 'pack';
+export type BubblePackFit = 'contain' | 'fill';
+export type BubbleShading = 'flat' | 'sphere';
+export interface BubblePackCircle {
+    index: number;
+    x: number;
+    y: number;
+    r: number;
+}
+export interface BubblePackLayout {
+    scale: number;
+    enclosing: {
+        x: number;
+        y: number;
+        r: number;
+    };
+    circles: BubblePackCircle[];
+}
+export interface BubbleRadiusScale {
+    zMin: number;
+    zMax: number;
+    minPx: number;
+    maxPx: number;
+    scale: BubbleSizeScale;
+}
+export interface BubblePointEventDetail {
+    index: number;
+    x: number;
+    y: number;
+    z: number;
+    name: string | null;
+    radiusPx: number;
+    cssX: number;
+    cssY: number;
+}
+export interface BubbleDrawStats {
+    points: number;
+    drawn: number;
+    bytes: number;
+    uploaded: number;
+    full: boolean;
+    version: number;
+    minRadiusPx: number;
+    maxRadiusPx: number;
+    activeIndex: number;
+    layout?: BubbleLayoutMode;
+    packScale?: number;
+    shading?: BubbleShading;
+    colored?: number;
+}
+export interface BubbleRenderResult {
+    points: number;
+    drawn: number;
+    renderMs: number;
+    bubble?: BubbleDrawStats;
+}
+export type BubbleEngineMode = HeatmapEngineMode;
+export type BubbleEngineTier = 'standard' | 'pro';
+export type BubbleUnavailableBehaviour = HeatmapUnavailableBehaviour;
+export type BubbleEasing = HeatmapEasing;
+export type BubbleAnimationType = HeatmapAnimationType;
+export interface BubbleStreamEvent {
+    type: 'push' | 'pushBatch' | 'shift' | 'replace';
+    count: number;
+    entries: BubbleDatumInput[];
+}
+export interface BubbleStreamSource {
+    readonly length: number;
+    readonly capacity: number;
+    readonly dropped: number;
+    push(datum: BubbleDatumInput): void;
+    pushBatch(data: ReadonlyArray<BubbleDatumInput>): void;
+    shift(count: number): void;
+    replace(data: ReadonlyArray<BubbleDatumInput>): void;
+    snapshot(): BubbleDatumInput[];
+    subscribe(listener: (event: BubbleStreamEvent) => void): () => void;
+}