semiotic 2.0.3 → 3.0.0-beta.2

package/dist/stream/renderers/networkEdgeRenderer.d.ts

@@ -0,0 +1,10 @@
+import type { NetworkSceneEdge } from "../networkTypes";
+/**
+ * Canvas painter for all network edge types.
+ *
+ * - bezier: Sankey flow bands (Path2D from SVG path string)
+ * - line: Force-directed straight edges
+ * - ribbon: Chord diagram ribbons
+ * - curved: Tree/cluster curved edges
+ */
+export declare function networkEdgeRenderer(ctx: CanvasRenderingContext2D, edges: NetworkSceneEdge[]): void;

package/dist/stream/renderers/networkParticleRenderer.d.ts

@@ -0,0 +1,11 @@
+import type { ParticlePool } from "../ParticlePool";
+import type { RealtimeEdge, ParticleStyle } from "../networkTypes";
+/**
+ * Canvas particle renderer for sankey — ported directly from realtime-network.
+ * Called each rAF frame.
+ */
+export declare function renderNetworkParticles(ctx: CanvasRenderingContext2D, pool: ParticlePool, edges: RealtimeEdge[], style: ParticleStyle, edgeColorFn: (edge: RealtimeEdge) => string): void;
+/**
+ * Spawn particles for all edges proportional to their value.
+ */
+export declare function spawnNetworkParticles(pool: ParticlePool, edges: RealtimeEdge[], deltaTime: number, style: ParticleStyle): void;

package/dist/stream/renderers/networkRectRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkSceneNode } from "../networkTypes";
+/**
+ * Canvas painter for NetworkRectNode (sankey nodes, treemap cells, partition blocks).
+ */
+export declare function networkRectRenderer(ctx: CanvasRenderingContext2D, nodes: NetworkSceneNode[]): void;

package/dist/stream/renderers/pointCanvasRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { StreamRendererFn } from "./types";
+/**
+ * Canvas point renderer.
+ * Renders PointSceneNode as circles. Used for Scatterplot, BubbleChart, and SwarmChart.
+ * Supports pulse glow effect via _pulseIntensity/_pulseColor fields.
+ */
+export declare const pointCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/swarmCanvasRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { StreamRendererFn } from "./types";
+/**
+ * Canvas swarm renderer.
+ * Identical to point renderer — swarm data points are pre-computed as PointSceneNodes.
+ * Separated for semantic clarity and potential future swarm-specific logic.
+ */
+export declare const swarmCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/types.d.ts

@@ -0,0 +1,7 @@
+import type { SceneNode, StreamScales, StreamLayout } from "../types";
+/**
+ * A canvas renderer function takes pre-computed SceneNodes and paints them.
+ * Unlike the realtime RendererFn which receives raw data + scales,
+ * the StreamXYFrame renderers receive already-projected scene graph nodes.
+ */
+export type StreamRendererFn = (ctx: CanvasRenderingContext2D, nodes: SceneNode[], scales: StreamScales, layout: StreamLayout) => void;

package/dist/stream/renderers/violinCanvasRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { OrdinalSceneNode, OrdinalScales, OrdinalLayout } from "../ordinalTypes";
+export declare const violinCanvasRenderer: (ctx: CanvasRenderingContext2D, nodes: OrdinalSceneNode[], _scales: OrdinalScales, _layout: OrdinalLayout) => void;

package/dist/stream/renderers/waterfallCanvasRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { StreamRendererFn } from "./types";
+/**
+ * Canvas waterfall renderer.
+ * Waterfall bars are pre-computed as RectSceneNodes by PipelineStore,
+ * so the rendering is identical to the bar renderer.
+ * Connector lines between bars are handled separately if needed.
+ */
+export declare const waterfallCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/wedgeCanvasRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { OrdinalSceneNode, OrdinalScales, OrdinalLayout } from "../ordinalTypes";
+export declare const wedgeCanvasRenderer: (ctx: CanvasRenderingContext2D, nodes: OrdinalSceneNode[], _scales: OrdinalScales, _layout: OrdinalLayout) => void;

package/dist/stream/types.d.ts

@@ -0,0 +1,307 @@
+import type { ReactNode } from "react";
+import type { ScaleLinear } from "d3-scale";
+import type { ArrowOfTime, WindowMode, LineStyle, BarStyle, WaterfallStyle, SwarmStyle, HoverAnnotationConfig, HoverData, AnnotationContext } from "../realtime/types";
+export interface DecayConfig {
+    type: "linear" | "exponential" | "step";
+    /** Exponential: half-life in buffer positions (default: bufferSize/2) */
+    halfLife?: number;
+    /** Minimum opacity floor (default: 0.1) */
+    minOpacity?: number;
+    /** Step: positions from newest before fading (default: bufferSize*0.5) */
+    stepThreshold?: number;
+}
+export interface PulseConfig {
+    /** Duration of the pulse glow in ms (default: 500) */
+    duration?: number;
+    /** Glow color (default: "rgba(255,255,255,0.6)") */
+    color?: string;
+    /** Extra px radius for glow ring on points (default: 4) */
+    glowRadius?: number;
+}
+export interface TransitionConfig {
+    /** Animation duration in ms (default: 300) */
+    duration?: number;
+    /** Easing function (default: "ease-out") */
+    easing?: "ease-out" | "linear";
+}
+export interface StalenessConfig {
+    /** ms without data before "stale" (default: 5000) */
+    threshold?: number;
+    /** Canvas alpha when stale (default: 0.5) */
+    dimOpacity?: number;
+    /** Render LIVE/STALE badge (default: false) */
+    showBadge?: boolean;
+    /** Badge position (default: "top-right") */
+    badgePosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+}
+export type MarginalType = "histogram" | "violin" | "ridgeline" | "boxplot";
+export interface MarginalConfig {
+    type: MarginalType;
+    /** Number of bins for histogram/violin/ridgeline @default 20 */
+    bins?: number;
+    /** Fill color @default "#4e79a7" */
+    fill?: string;
+    /** Fill opacity @default 0.5 */
+    fillOpacity?: number;
+    /** Stroke color @default "none" */
+    stroke?: string;
+    /** Stroke width @default 1 */
+    strokeWidth?: number;
+}
+export interface MarginalGraphicsConfig {
+    top?: MarginalConfig | MarginalType;
+    bottom?: MarginalConfig | MarginalType;
+    left?: MarginalConfig | MarginalType;
+    right?: MarginalConfig | MarginalType;
+}
+export type StreamChartType = "line" | "area" | "stackedarea" | "scatter" | "bubble" | "heatmap" | "bar" | "swarm" | "waterfall" | "candlestick";
+export type RuntimeMode = "bounded" | "streaming";
+export interface Style {
+    stroke?: string;
+    strokeWidth?: number;
+    strokeDasharray?: string;
+    fill?: string;
+    fillOpacity?: number;
+    opacity?: number;
+    /** For icon/isotype bars: an image to stamp instead of filling */
+    icon?: HTMLImageElement | HTMLCanvasElement;
+    /** Padding between stamped icons */
+    iconPadding?: number;
+}
+export type SceneNode = LineSceneNode | AreaSceneNode | PointSceneNode | RectSceneNode | HeatcellSceneNode | CandlestickSceneNode;
+export interface LineColorThreshold {
+    value: number;
+    color: string;
+    thresholdType: "greater" | "lesser";
+}
+export interface LineSceneNode {
+    type: "line";
+    path: [number, number][];
+    /** Raw y-values corresponding to each path point (for threshold coloring) */
+    rawValues?: number[];
+    /** Threshold-based color segments */
+    colorThresholds?: LineColorThreshold[];
+    style: Style;
+    datum: any;
+    group?: string;
+}
+export interface AreaSceneNode {
+    type: "area";
+    topPath: [number, number][];
+    bottomPath: [number, number][];
+    style: Style;
+    datum: any;
+    group?: string;
+    /** When false, skip hit testing (used for decorative bounds areas) */
+    interactive?: boolean;
+}
+export interface PointSceneNode {
+    type: "point";
+    x: number;
+    y: number;
+    r: number;
+    style: Style;
+    datum: any;
+    /** Pulse glow intensity 0–1 (set by PipelineStore when pulse is active) */
+    _pulseIntensity?: number;
+    /** Pulse glow color */
+    _pulseColor?: string;
+    /** Animation target fields (set during transitions) */
+    _targetX?: number;
+    _targetY?: number;
+    _targetR?: number;
+    _decayOpacity?: number;
+}
+export interface RectSceneNode {
+    type: "rect";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    style: Style;
+    datum: any;
+    group?: string;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    /** Animation target fields (set during transitions) */
+    _targetX?: number;
+    _targetY?: number;
+    _targetW?: number;
+    _targetH?: number;
+    _decayOpacity?: number;
+}
+export interface HeatcellSceneNode {
+    type: "heatcell";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fill: string;
+    datum: any;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    /** Animation target fields (set during transitions) */
+    _targetX?: number;
+    _targetY?: number;
+    _targetW?: number;
+    _targetH?: number;
+    _decayOpacity?: number;
+}
+export interface CandlestickSceneNode {
+    type: "candlestick";
+    x: number;
+    openY: number;
+    closeY: number;
+    highY: number;
+    lowY: number;
+    bodyWidth: number;
+    upColor: string;
+    downColor: string;
+    wickColor: string;
+    wickWidth: number;
+    isUp: boolean;
+    datum: any;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+}
+export interface CandlestickStyle {
+    upColor?: string;
+    downColor?: string;
+    wickColor?: string;
+    bodyWidth?: number;
+    wickWidth?: number;
+}
+export interface Changeset<T = Record<string, any>> {
+    inserts: T[];
+    bounded: boolean;
+    /** Hint: total dataset size when progressively chunking bounded data */
+    totalSize?: number;
+}
+export interface StreamScales {
+    x: ScaleLinear<number, number>;
+    y: ScaleLinear<number, number>;
+}
+export interface StreamLayout {
+    width: number;
+    height: number;
+}
+export type CurveType = "linear" | "monotoneX" | "monotoneY" | "step" | "stepAfter" | "stepBefore" | "basis" | "cardinal" | "catmullRom";
+export interface StreamXYFrameProps<T = Record<string, any>> {
+    chartType: StreamChartType;
+    runtimeMode?: RuntimeMode;
+    data?: T[];
+    xAccessor?: string | ((d: T) => number);
+    yAccessor?: string | ((d: T) => number);
+    colorAccessor?: string | ((d: T) => string);
+    sizeAccessor?: string | ((d: T) => number);
+    groupAccessor?: string | ((d: T) => string);
+    lineDataAccessor?: string;
+    curve?: CurveType;
+    normalize?: boolean;
+    /**
+     * Accessor returning a symmetric uncertainty offset per datum.
+     * When set, an uncertainty band is drawn ± this offset from the line.
+     */
+    boundsAccessor?: string | ((d: T) => number);
+    /**
+     * Style for bounds/uncertainty areas.
+     * If omitted, defaults to the line color at 0.2 opacity.
+     */
+    boundsStyle?: Style | ((d: T, group?: string) => Style);
+    openAccessor?: string | ((d: T) => number);
+    highAccessor?: string | ((d: T) => number);
+    lowAccessor?: string | ((d: T) => number);
+    closeAccessor?: string | ((d: T) => number);
+    candlestickStyle?: CandlestickStyle;
+    binSize?: number;
+    valueAccessor?: string | ((d: T) => number);
+    arrowOfTime?: ArrowOfTime;
+    windowMode?: WindowMode;
+    windowSize?: number;
+    timeAccessor?: string | ((d: T) => number);
+    xExtent?: [number | undefined, number | undefined] | [number];
+    yExtent?: [number | undefined, number | undefined] | [number];
+    extentPadding?: number;
+    sizeRange?: [number, number];
+    size?: [number, number];
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    className?: string;
+    background?: string;
+    lineStyle?: LineStyle | ((d: T, group?: string) => Style);
+    pointStyle?: (d: T) => Style & {
+        r?: number;
+    };
+    areaStyle?: (d: T) => Style;
+    barStyle?: BarStyle;
+    waterfallStyle?: WaterfallStyle;
+    swarmStyle?: SwarmStyle;
+    barColors?: Record<string, string>;
+    colorScheme?: string | string[];
+    showAxes?: boolean;
+    xLabel?: string;
+    yLabel?: string;
+    xFormat?: (d: any) => string;
+    yFormat?: (d: any) => string;
+    tickFormatTime?: (value: number) => string;
+    tickFormatValue?: (value: number) => string;
+    hoverAnnotation?: boolean | HoverAnnotationConfig;
+    tooltipContent?: (d: HoverData) => ReactNode;
+    customHoverBehavior?: (d: HoverData | null) => void;
+    enableHover?: boolean;
+    /** Brush configuration — when provided, an SVG brush overlay is rendered */
+    brush?: {
+        /** Which dimension(s) to brush: "x", "y", or "xy" (default "xy") */
+        dimension?: "x" | "y" | "xy";
+    };
+    /** Callback when brush selection changes. Called with data-space extent, or null when cleared. */
+    onBrush?: (extent: {
+        x: [number, number];
+        y: [number, number];
+    } | null) => void;
+    annotations?: Record<string, any>[];
+    svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
+    showGrid?: boolean;
+    legend?: ReactNode | {
+        legendGroups: any[];
+    };
+    /** SVG elements rendered behind the canvas (in pixel space) */
+    backgroundGraphics?: ReactNode;
+    /** SVG elements rendered on top of everything (in SVG overlay) */
+    foregroundGraphics?: ReactNode;
+    title?: string | ReactNode;
+    categoryAccessor?: string | ((d: T) => string);
+    /** Configurable opacity decay for older data points */
+    decay?: DecayConfig;
+    /** Flash effect on newly inserted data points */
+    pulse?: PulseConfig;
+    /** Smooth position transitions on data change */
+    transition?: TransitionConfig;
+    /** Frame-level data liveness indicator */
+    staleness?: StalenessConfig;
+    /** Marginal distribution plots in axis margins (histogram, violin, ridgeline, boxplot) */
+    marginalGraphics?: MarginalGraphicsConfig;
+    /** Aggregation mode for streaming heatmap (count, sum, mean) */
+    heatmapAggregation?: "count" | "sum" | "mean";
+    /** Number of x-axis bins for streaming heatmap (default: 20) */
+    heatmapXBins?: number;
+    /** Number of y-axis bins for streaming heatmap (default: 20) */
+    heatmapYBins?: number;
+}
+export interface StreamXYFrameHandle<T = Record<string, any>> {
+    push(datum: T): void;
+    pushMany(data: T[]): void;
+    clear(): void;
+    getData(): T[];
+    getScales(): StreamScales | null;
+    getExtents(): {
+        x: [number, number];
+        y: [number, number];
+    } | null;
+}
+export type CanvasRendererFn = (ctx: CanvasRenderingContext2D, nodes: SceneNode[], scales: StreamScales, layout: StreamLayout) => void;
+export type { ArrowOfTime, WindowMode, LineStyle, BarStyle, WaterfallStyle, SwarmStyle, HoverAnnotationConfig, HoverData, AnnotationContext };

package/dist/types/annotationTypes.d.ts

@@ -1,8 +1,8 @@
-import { RawPoint, GenericObject, MarginType, AxisSummaryTypeSettings, OrdinalSummaryTypes } from "./generalTypes";
-import { NodeType } from "./networkTypes";
+import { RawPoint, MarginType, AxisSummaryTypeSettings, OrdinalSummaryTypes } from "./generalTypes";
+import { NodeType, EdgeType } from "./networkTypes";
 import { ScaleLinear } from "d3-scale";
-export declare type AnnotationType = {
-    type?: string | Function;
+export type AnnotationType = {
+    type?: string;
     column?: {
         name: string;
     };
@@ -16,9 +16,9 @@ export declare type AnnotationType = {
     coordinates?: object[];
     key?: string;
     percent?: number;
-    style?: GenericObject | ((arg?: GenericObject, index?: number) => GenericObject);
+    style?: Record<string, any> | ((arg?: Record<string, any>, index?: number) => Record<string, any>);
     ids?: string[];
-    edge?: any;
+    edge?: EdgeType;
     source?: NodeType;
     target?: NodeType;
     id?: string;
@@ -27,8 +27,8 @@ export declare type AnnotationType = {
     neighbors?: object[];
     isColumnAnnotation?: boolean;
 };
-export declare type CustomHoverType = boolean | Array<AnnotationType | Function> | object | Function | "all" | "edge" | "node" | "area";
-export declare type AnnotationTypes = "marginalia" | "bump" | false;
+export type CustomHoverType = boolean | Array<AnnotationType | Function> | object | Function | "all" | "edge" | "node" | "area";
+export type AnnotationTypes = "marginalia" | "bump" | false;
 interface AnnotationLayout {
     type: AnnotationTypes;
     orient?: "nearest" | "left" | "right" | "top" | "bottom" | Array<string>;
@@ -57,11 +57,7 @@ export interface AnnotationProps {
     noteData: {
         eventListeners?: object;
         events?: object;
-        onDragEnd?: Function;
-        onDragStart?: Function;
-        onDrag?: Function;
-        type: string | Function;
-        editMode?: boolean;
+        type: string;
         screenCoordinates?: Array<Array<number>>;
         coordinates?: boolean;
         noteHeight?: Function | number;
@@ -81,12 +77,12 @@ export interface AnnotationProps {
         label?: string;
     };
 }
-declare type GlyphProps = {
+type GlyphProps = {
     lineHeight: number;
     lineWidth: number;
     value: number;
 };
-declare type AxisPart = {
+type AxisPart = {
     value: number;
 };
 export interface AxisProps {
@@ -114,11 +110,10 @@ export interface AxisProps {
     ticks?: number;
     footer?: boolean;
     tickSize?: number;
-    tickLineGenerator?: ({ xy, orient, i, baseMarkProps, className }: {
+    tickLineGenerator?: ({ xy, orient, i, className }: {
         xy?: object;
         orient?: string;
         i?: number;
-        baseMarkProps?: object;
         className?: string;
     }) => SVGElement;
     baseline?: boolean | "under";
@@ -136,5 +131,5 @@ export interface AxisProps {
     marginalSummaryType?: AxisSummaryTypeSettings | OrdinalSummaryTypes;
     showOutboundTickLines?: boolean;
 }
-export declare type AxisGeneratingFunction = (args: object) => AxisProps;
+export type AxisGeneratingFunction = (args: object) => AxisProps;
 export {};

package/dist/types/canvasTypes.d.ts

@@ -1,4 +1,4 @@
-export declare type ContextType = {
+export type ContextType = {
     getContext: Function;
     width: number;
     height: number;

package/dist/types/generalTypes.d.ts

@@ -1,20 +1,21 @@
-/// <reference types="react" />
 import { CustomHoverType, AnnotationHandling } from "./annotationTypes";
-import { TitleType } from "../svg/frameFunctions";
 import { Interactivity, AdvancedInteractionSettings } from "./interactionTypes";
+export type TitleType = string | Element | {
+    title?: string | Element;
+    orient?: string;
+};
 import { LegendProps } from "./legendTypes";
 import { AxisProps } from "./annotationTypes";
-export declare type GenericObject = {
-    [key: string]: any;
-};
+/** @deprecated Use Record<string, any> instead */
+export type GenericObject = Record<string, any>;
 export interface MarginType {
     top: number;
     bottom: number;
     left: number;
     right: number;
 }
-export declare type ProjectionTypes = "vertical" | "horizontal" | "radial";
-export declare type ExtentType = number[] | {
+export type ProjectionTypes = "vertical" | "horizontal" | "radial";
+export type ExtentType = number[] | {
     extent?: number[];
     onChange?: Function;
     includeAnnotations?: boolean;
@@ -37,13 +38,13 @@ export interface ProjectedPoint {
     class?: Function | string;
     coordinates?: object[];
 }
-export declare type PieceLayoutType = (args: {
+export type PieceLayoutType = (args: {
     type: string | {
         type: string;
     };
-    data: any;
-    renderMode: (d?: GenericObject, i?: number) => string | GenericObject;
-    eventListenersGenerator: any;
+    data: Record<string, any>;
+    renderMode: (d?: Record<string, any>, i?: number) => string | Record<string, any>;
+    eventListenersGenerator: (d: object, i: number) => Record<string, Function>;
     styleFn: (d: object) => object;
     projection: string;
     classFn: (d: object) => string;
@@ -51,8 +52,7 @@ export declare type PieceLayoutType = (args: {
     chartSize: number[];
     margin: MarginType;
     rScale?: Function;
-    baseMarkProps: object;
-}) => GenericObject[];
+}) => Record<string, any>[];
 export interface ProjectedLine {
     data: ProjectedPoint[];
     key: string | number;
@@ -69,7 +69,7 @@ export interface ProjectedSummary {
     data: object[];
     y: number;
     x: number;
-    parentSummary?: GenericObject;
+    parentSummary?: Record<string, any>;
     bounds: object[] | number[];
     customMark?: Function;
     type?: string;
@@ -77,27 +77,28 @@ export interface ProjectedSummary {
     processedData?: boolean;
     binMax?: number;
 }
-export declare type RoughType = {
+export type RoughType = {
     canvas: Function;
     generator: Function;
 };
-export declare type CanvasPostProcessTypes = Function;
-export declare type ExtentSettingsType = {
+export type CanvasPostProcessTypes = Function;
+export type ExtentSettingsType = {
     extent?: Array<number>;
     onChange?: Function;
 };
-export declare type accessorType<ReturnValue> = string | ((args?: unknown, index?: number) => ReturnValue);
+export type accessorType<ReturnValue> = string | ((args?: unknown, index?: number) => ReturnValue);
+export type DataAccessor<TDatum, ReturnValue> = (keyof TDatum & string) | ((datum: TDatum, index?: number) => ReturnValue);
 export interface AccessorFnType {
-    <T>(arg: GenericObject): T;
+    <T>(arg: Record<string, any>): T;
 }
-export declare type BasicLineTypes = "line" | "area" | "summary" | "cumulative" | "cumulative-reverse" | "linepercent" | "stackedarea" | "stackedarea-invert" | "stackedpercent" | "bumparea" | "bumparea-invert" | "bumpline" | "stackedpercent-invert" | "difference";
+export type BasicLineTypes = "line" | "area" | "summary" | "cumulative" | "cumulative-reverse" | "linepercent" | "stackedarea" | "stackedarea-invert" | "stackedpercent" | "bumparea" | "bumparea-invert" | "bumpline" | "stackedpercent-invert" | "difference";
 export interface LineTypeSettings {
     type: BasicLineTypes | Function;
     simpleLine?: boolean;
     y1?: (d?: ProjectedPoint, index?: number) => number;
     interpolator: string | Function;
 }
-export declare type BasicSummaryTypes = "basic" | "contour" | "hexbin" | "heatmap" | "trendline" | "linebounds";
+export type BasicSummaryTypes = "basic" | "contour" | "hexbin" | "heatmap" | "trendline" | "linebounds";
 export interface SummaryTypeSettings {
     showSlope?: boolean;
     type: BasicSummaryTypes | Function;
@@ -112,19 +113,18 @@ export interface SummaryTypeSettings {
     binMax?: number;
     customMark?: Function;
 }
-export interface RawLine {
-    coordinates?: object[];
+export interface RawLine<TDatum = Record<string, any>> {
+    coordinates?: TDatum[];
 }
-export interface RawSummary {
-    processedData?: object[];
-    coordinates?: object[];
+export interface RawSummary<TDatum = Record<string, any>> {
+    processedData?: TDatum[];
+    coordinates?: TDatum[];
     preprocess?: boolean;
 }
-export interface RawPoint {
+export interface RawPoint<TDatum = Record<string, any>> {
 }
 export interface CustomAreaMarkProps {
     d: object;
-    baseMarkProps: object;
     margin: object;
     styleFn: Function;
     classFn: Function;
@@ -144,11 +144,11 @@ export interface ProjectedBin {
     parentSummary: object;
     centroid: boolean;
 }
-export declare type GenericAccessor<GenericValue> = (args?: GenericObject, index?: number) => GenericValue;
-export declare type VizLayerTypes = "pieces" | "summaries" | "connectors" | "edges" | "nodes" | "lines" | "points";
-export declare type RenderPipelineType = {
+export type GenericAccessor<GenericValue> = (args?: Record<string, any>, index?: number) => GenericValue;
+export type VizLayerTypes = "pieces" | "summaries" | "connectors" | "edges" | "nodes" | "lines" | "points";
+export type RenderPipelineType = {
     [key in VizLayerTypes]?: {
-        data?: any;
+        data?: object[];
         ariaLabel?: {
             chart?: string;
             items?: string;
@@ -157,8 +157,8 @@ export declare type RenderPipelineType = {
         styleFn?: Function;
     };
 };
-export declare type OrdinalSummaryTypes = "none" | "histogram" | "heatmap" | "violin" | "joy" | "ridgeline" | "boxplot" | "contour";
-export declare type OrdinalSummaryTypeSettings = {
+export type OrdinalSummaryTypes = "none" | "histogram" | "heatmap" | "violin" | "joy" | "ridgeline" | "boxplot" | "contour";
+export type OrdinalSummaryTypeSettings = {
     type: OrdinalSummaryTypes;
     amplitude?: number;
     eventListenersGenerator?: Function;
@@ -175,8 +175,13 @@ export interface AxisSummaryTypeSettings extends OrdinalSummaryTypeSettings {
     showPoints?: boolean;
     filter?: Function;
 }
+export interface TransitionConfig {
+    /** Duration in milliseconds. @default 300 */
+    duration?: number;
+    /** CSS easing function. @default "ease" */
+    ease?: string;
+}
 export interface GeneralFrameProps {
-    useSpans?: boolean;
     title?: string | object;
     margin?: number | {
         top?: number;
@@ -207,7 +212,6 @@ export interface GeneralFrameProps {
     tooltipContent?: Function;
     optimizeCustomTooltipPosition?: boolean;
     annotations?: object[];
-    baseMarkProps?: object;
     backgroundGraphics?: React.ReactNode | Function;
     foregroundGraphics?: React.ReactNode | Function;
     beforeElements?: React.ReactNode;
@@ -222,6 +226,7 @@ export interface GeneralFrameProps {
     disableCanvasInteraction?: boolean;
     interactionSettings?: AdvancedInteractionSettings;
     disableProgressiveRendering?: boolean;
+    transition?: boolean | TransitionConfig;
 }
 export interface GeneralFrameState {
     dataVersion?: string;