katucharts.js 0.2.1

package/dist/series/bioinformatics/circos/CircosHeatmapChart.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Circular Heatmap following circlize convention:
+ * rows distribute in the CIRCULAR direction (angular sectors),
+ * columns distribute in the RADIAL direction (concentric sub-rings).
+ * Each cell is an arc at (row's angular sector, column's radial band).
+ */
+import 'd3-transition';
+import { BaseSeries } from '../../BaseSeries';
+import type { InternalSeriesConfig } from '../../../types/options';
+export declare class CircosHeatmapChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    /**
+     * Row labels around the outer edge (circular direction),
+     * rotated like chromosome labels in standard circos.
+     */
+    private renderRowLabels;
+    /**
+     * Column labels as small text at the innermost ring edge,
+     * positioned radially to indicate which radial band = which column.
+     */
+    private renderColumnLabels;
+    private attachCellEvents;
+    private resolvePercent;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/bioinformatics/circos/CircosLayoutEngine.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared circular coordinate system and ideogram rendering engine.
+ * Used by all circos series variants. Handles chromosome arc computation,
+ * angle↔position mapping, polar↔cartesian conversion, and ideogram rendering.
+ */
+import 'd3-transition';
+import type { ChromosomeDef, ChromosomeArc, CircosLayoutConfig } from './CircosTypes';
+export declare class CircosLayoutEngine {
+    chrArcs: ChromosomeArc[];
+    chrArcMap: Map<string, ChromosomeArc>;
+    outerR: number;
+    innerR: number;
+    cx: number;
+    cy: number;
+    private chromosomes;
+    constructor(chromosomes: ChromosomeDef[], plotWidth: number, plotHeight: number, config: Partial<CircosLayoutConfig>);
+    private computeChromosomeArcs;
+    getAngleForPosition(chr: string, pos: number): number;
+    getAngleRange(chr: string, start: number, end: number): {
+        startAngle: number;
+        endAngle: number;
+    };
+    polarToCartesian(angle: number, r: number): {
+        x: number;
+        y: number;
+    };
+    createRadialScale(values: number[], innerR: number, outerR: number, useLog?: boolean): (v: number) => number;
+    renderIdeogram(group: any, innerR: number, outerR: number, animate: boolean, duration: number, events?: any, seriesRef?: any, separatorColor?: string): void;
+    renderIdeogramBands(group: any, innerR: number, outerR: number, animate: boolean, duration: number): void;
+    renderChromosomeLabels(group: any, radius: number, fontSize?: number, animate?: boolean, duration?: number, delay?: number, labelColor?: string): void;
+}
+export declare function parseRadius(val: any, minDim: number): number | undefined;
+export declare function safeMinMax(values: number[]): {
+    min: number;
+    max: number;
+};
+export declare function parseColor(c: string): [number, number, number, number];

package/dist/series/bioinformatics/circos/CircosRules.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Conditional formatting engine for circos tracks.
+ * Processes rule arrays against data points, returning resolved visual styles.
+ */
+import type { CircosRule, CircosDataPoint, ResolvedStyle } from './CircosTypes';
+export declare function applyRules(point: CircosDataPoint, index: number, rules: CircosRule[] | undefined, defaults: ResolvedStyle): ResolvedStyle;

package/dist/series/bioinformatics/circos/CircosSpiralChart.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Spiral Plot — data rendered along an Archimedean spiral path.
+ * Each revolution represents one period (day, week, month, year, or custom
+ * length). Data values are shown as colored segments whose intensity follows
+ * a configurable color scale.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../../BaseSeries';
+import type { InternalSeriesConfig } from '../../../types/options';
+export declare class CircosSpiralChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+    private getSpiralData;
+    private normalizeValues;
+    /**
+     * Compute segment positions along the Archimedean spiral r = a + b*theta.
+     * Each segment spans one angular slice of 2pi/periodLength.
+     */
+    private computeSegments;
+    private renderSegments;
+    /**
+     * Build an arc-like SVG path for a single spiral segment.
+     * Track width derived from spiral b parameter: each revolution adds 2πb of
+     * radial distance, so track width = 2πb * fillFraction (default 0.95).
+     */
+    private buildSegmentPath;
+    /**
+     * Render period labels at the 12 o'clock position for each revolution.
+     * Each revolution is at a different radius, so labels naturally separate.
+     * If data has date fields, use the first date of each revolution.
+     */
+    private renderRevolutionLabels;
+}

package/dist/series/bioinformatics/circos/CircosTypes.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Shared type definitions for the entire Circos visualization system.
+ * Used by CircosSeries, all track renderers, and all variant series.
+ */
+export type CircosTrackType = 'scatter' | 'line' | 'histogram' | 'heatmap' | 'link' | 'highlight' | 'stack' | 'text' | 'tile' | 'ribbon' | 'connector' | 'area' | 'glyph' | 'lollipop';
+export type CircosColorScaleName = 'YlOrRd' | 'Blues' | 'Greens' | 'Reds' | 'Purples' | 'Oranges' | 'Greys' | 'RdBu' | 'RdYlGn' | 'RdYlBu' | 'Spectral' | 'PiYG' | 'BrBG' | 'PuOr' | 'PRGn' | 'Viridis' | 'Plasma' | 'Inferno' | 'Magma' | 'Cividis' | 'Turbo' | 'Warm' | 'Cool' | 'CubehelixDefault';
+export type GlyphSymbol = 'circle' | 'triangle-up' | 'triangle-down' | 'diamond' | 'square' | 'cross' | 'star';
+export type ConnectorType = 'straight' | 'elbow' | 'bezier';
+export type BandType = 'gneg' | 'gpos25' | 'gpos50' | 'gpos75' | 'gpos100' | 'acen' | 'gvar' | 'stalk';
+export interface CircosRule {
+    condition: (d: CircosDataPoint, index: number) => boolean;
+    style: {
+        color?: string;
+        opacity?: number;
+        size?: number;
+        show?: boolean;
+        symbol?: GlyphSymbol;
+        strokeWidth?: number;
+        strokeColor?: string;
+    };
+    flow?: 'stop' | 'continue';
+}
+export interface CircosTrackAxes {
+    show?: boolean;
+    count?: number;
+    color?: string;
+    opacity?: number;
+    strokeWidth?: number;
+    showValues?: boolean;
+    valueFormat?: string;
+}
+export interface CircosTrackBackground {
+    color?: string;
+    opacity?: number;
+    border?: {
+        color?: string;
+        width?: number;
+    };
+}
+export interface IdeogramBand {
+    chr: string;
+    start: number;
+    end: number;
+    type: BandType;
+    name?: string;
+}
+export interface ChromosomeDef {
+    id: string;
+    length: number;
+    color?: string;
+    bands?: IdeogramBand[];
+    gap?: number;
+}
+export interface ChromosomeArc {
+    id: string;
+    startAngle: number;
+    endAngle: number;
+    length: number;
+    color: string;
+}
+export interface CircosDataPoint {
+    chr: string;
+    start: number;
+    end?: number;
+    value?: number;
+    sourceChr?: string;
+    sourceStart?: number;
+    sourceEnd?: number;
+    targetChr?: string;
+    targetStart?: number;
+    targetEnd?: number;
+    color?: string;
+    opacity?: number;
+    label?: string;
+    symbol?: GlyphSymbol;
+    category?: string;
+    layer?: number;
+    data?: Record<string, any>;
+}
+export interface CircosTrack {
+    type: CircosTrackType;
+    data: CircosDataPoint[];
+    innerRadius?: number;
+    outerRadius?: number;
+    color?: string;
+    opacity?: number;
+    options?: Record<string, any>;
+    rules?: CircosRule[];
+    axes?: CircosTrackAxes;
+    background?: CircosTrackBackground;
+    colorScale?: CircosColorScaleName;
+    logScale?: boolean;
+    tooltip?: {
+        formatter?: (d: CircosDataPoint) => string;
+        enabled?: boolean;
+    };
+}
+export interface CircosLayoutConfig {
+    gap: number;
+    outerRadius: number;
+    innerRadius: number;
+    trackGap: number;
+    showLabels: boolean;
+    labelFontSize: number;
+    showBands: boolean;
+}
+export interface TrackRenderOptions {
+    animate: boolean;
+    duration: number;
+    /** Absolute delay (ms) before this track's animation begins — set by the orchestrator. */
+    baseDelay?: number;
+    cx: number;
+    cy: number;
+    canvasThreshold: number;
+    events?: any;
+    seriesRef?: any;
+    /** Separator/border color for track elements — matches the chart background. */
+    separatorColor?: string;
+}
+export interface ResolvedStyle {
+    color: string;
+    opacity: number;
+    size: number;
+    show: boolean;
+    symbol?: GlyphSymbol;
+    strokeWidth?: number;
+    strokeColor?: string;
+}
+export declare const DEFAULT_CHR_COLORS: string[];
+export declare const BAND_COLORS: Record<BandType, string>;
+export declare const DEFAULT_CANVAS_THRESHOLD = 5000;

package/dist/series/bioinformatics/circos/tracks/AreaTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Area track renderer — filled region between line trace and baseline.
+ * Like line track but with fill between the trace and innerR/outerR.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderAreaTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/ConnectorTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Connector track renderer — simple connecting lines between positions.
+ * Types: straight, elbow (radial→angular), bezier.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderConnectorTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/GlyphTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Glyph track renderer — custom d3-shape symbols at angular+radial positions.
+ * Supports: circle, triangle-up/down, diamond, square, cross, star.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderGlyphTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/HeatmapTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Heatmap track renderer — arc segments colored by value intensity.
+ * SVG for small datasets, Canvas for large.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderHeatmapTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/HighlightTrackRenderer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Highlight track renderer — semi-transparent arc regions for marking areas.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderHighlightTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/HistogramTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Histogram track renderer — radial arc bars scaled by value.
+ * SVG for small datasets, Canvas for large.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderHistogramTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/LineTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Line track renderer — continuous radial path connecting data points.
+ * Animated via stroke-dasharray reveal.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderLineTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/LinkTrackRenderer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Link track renderer — thin bezier curves between genomic positions.
+ * Batches by color for large link sets (>500).
+ */
+import 'd3-transition';
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderLinkTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/LollipopTrackRenderer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lollipop track renderer — radial stems with dots at endpoints.
+ * Standard in genomics for showing mutation/variant positions and their
+ * significance (NG-Circos LOLLIPOP module equivalent).
+ * Each point: thin radial line from baseline to value radius + circle dot.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderLollipopTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/RibbonTrackRenderer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Ribbon track renderer — variable-width filled links.
+ * Width proportional to source/target span. Supports twist detection.
+ * Path: source arc → bezier to target → target arc → bezier back.
+ */
+import 'd3-transition';
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderRibbonTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/ScatterTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Scatter track renderer — points at (angle, radius) by chr+position and value.
+ * Supports both SVG (small) and Canvas (large dataset) rendering.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderScatterTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/StackTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Stack track renderer — stacked categorical arc segments at each bin position.
+ * Groups data by position, stacks categories radially outward.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderStackTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/TextTrackRenderer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Text track renderer — rotated text labels at genomic positions.
+ * Anti-overlap via sweep-line: sort by angle, push outward if collision.
+ * Optional leader lines connecting label to original position.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderTextTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/TileTrackRenderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tile track renderer — region span annotations as small arcs with auto-layering.
+ * Greedy layer assignment to avoid overlap within each chromosome.
+ */
+import type { CircosTrack, TrackRenderOptions } from '../CircosTypes';
+import type { CircosLayoutEngine } from '../CircosLayoutEngine';
+export declare function renderTileTrack(engine: CircosLayoutEngine, group: any, track: CircosTrack, innerR: number, outerR: number, opts: TrackRenderOptions): void;

package/dist/series/bioinformatics/circos/tracks/TrackAxesRenderer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Track axes renderer — concentric grid lines within track bands.
+ * Optional value labels at 12 o'clock position.
+ */
+import type { CircosTrackAxes } from '../CircosTypes';
+export declare function renderTrackAxes(group: any, axes: CircosTrackAxes, innerR: number, outerR: number, labelColor?: string): void;

package/dist/series/bioinformatics/circos/tracks/TrackBackgroundRenderer.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Track background renderer — filled arc ring behind track data.
+ */
+import type { CircosTrackBackground } from '../CircosTypes';
+export declare function renderTrackBackground(group: any, bg: CircosTrackBackground, innerR: number, outerR: number): void;

package/dist/series/cartesian/AreaChart.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Area and AreaSpline series with features:
+ * stacking (normal/percent), negativeFillColor, zones, markers,
+ * trackByArea, connectNulls, dashStyle, data labels, and animated updates.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig, PointOptions } from '../../types/options';
+export declare class AreaChart extends BaseSeries {
+    protected isSpline: boolean;
+    private areaPath;
+    private linePath;
+    private negAreaPath;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private renderMainArea;
+    private renderWithNegativeColor;
+    private renderZones;
+    protected getCurve(): import("d3-shape").CurveFactory;
+    private getFilteredData;
+    private buildGenerators;
+    animateUpdate(duration: number): void;
+    private animateLineEntry;
+    protected renderMarkers(data: PointOptions[], color: string, animate: boolean): void;
+    /**
+     * Track hover by area fill region, not just individual points.
+     */
+    private renderAreaHoverTargets;
+    private renderHoverTargets;
+}
+export declare class AreaSplineChart extends AreaChart {
+    protected isSpline: boolean;
+}

package/dist/series/cartesian/BoxPlotChart.d.ts

@@ -0,0 +1,24 @@
+/**
+ * BoxPlot series with features: medianColor, medianWidth,
+ * medianDashStyle, stemColor, stemWidth, stemDashStyle, whiskerColor, whiskerWidth,
+ * whiskerLength, whiskerDashStyle, boxDashStyle, fillColor, colorByPoint,
+ * grouping/groupPadding/pointPadding, data labels, and animated updates.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class BoxPlotChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    animateUpdate(duration: number): void;
+    private computeBoxGeometry;
+    private getPointColor;
+    private parseWhiskerLength;
+    private attachBoxPointEvents;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/cartesian/BubbleChart.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bubble series with features: displayNegative, zThreshold,
+ * sizeBy (area/width), sizeByAbsoluteValue, zMin/zMax overrides, jitter,
+ * negativeColor, data labels, and animated updates.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class BubbleChart extends BaseSeries {
+    private sizeScale;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    animateUpdate(duration: number): void;
+    private filterByZThreshold;
+    private getZValue;
+    private buildSizeScale;
+    private parseSize;
+    private getBubbleFill;
+    private attachBubbleEvents;
+    getBubbleLegendInfo(): {
+        sizeBy: "area" | "width";
+        color: string;
+        ranges: {
+            value: number;
+            radius: number;
+        }[];
+    } | null;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/cartesian/ColumnChart.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Column and Bar series with features: grouping,
+ * stacking (normal/percent), negativeColor, maxPointWidth, minPointLength,
+ * pointWidth, crisp pixel snapping, data labels, shadow, and animated updates.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class ColumnChart extends BaseSeries {
+    protected isHorizontal: boolean;
+    constructor(config: InternalSeriesConfig);
+    private getEntryDuration;
+    render(): void;
+    private renderVerticalBars;
+    private renderHorizontalBars;
+    private renderStackedBars;
+    private getBarY;
+    private getBarHeight;
+    private crispCoord;
+    private computeStackedRectParams;
+    private computeStackedStartParams;
+    private rectParamsToPath;
+    animateUpdate(duration: number): void;
+    private updateStackedBars;
+    protected computeBarGeometry(): {
+        barWidth: number;
+        barOffset: number;
+        baseline: number;
+        groupWidth: number;
+    };
+    private getPointColor;
+    private renderColumnDataLabels;
+    private attachHoverEffects;
+}
+export declare class BarChart extends ColumnChart {
+    protected isHorizontal: boolean;
+}

package/dist/series/cartesian/LineChart.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Line series with features: negativeColor,
+ * zones, markers, dashStyle, linecap, step, connectNulls,
+ * data labels, point selection, and animated updates.
+ */
+import { Selection } from 'd3-selection';
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig, PointOptions } from '../../types/options';
+export declare class LineChart extends BaseSeries {
+    protected pathSelection: Selection<SVGPathElement, any, any, any> | null;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    private renderMainLine;
+    /**
+     * Split line into positive/negative segments using threshold and negativeColor.
+     */
+    private renderNegativeColor;
+    protected renderZones(data: PointOptions[], baseColor: string): void;
+    animateUpdate(duration: number): void;
+    protected buildLineGenerator(): import("d3-shape").Line<PointOptions>;
+    protected getFilteredData(): PointOptions[];
+    protected getCurve(): import("d3-shape").CurveFactory;
+    protected animateLineEntry(path: Selection<SVGPathElement, any, any, any>): void;
+    protected renderMarkers(data: PointOptions[], color: string, animate: boolean): void;
+    private getMarkerFill;
+    protected renderHoverTargets(data: PointOptions[], color: string): void;
+}

package/dist/series/cartesian/ScatterChart.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Scatter series with features: jitter, marker symbols,
+ * data labels, point selection, animated updates, and negativeColor.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class ScatterChart extends BaseSeries {
+    private cachedPositions;
+    constructor(config: InternalSeriesConfig);
+    private resolveMarkerSymbol;
+    getLegendSymbolShape(): string | null;
+    render(): void;
+    animateUpdate(duration: number): void;
+    private getPointFill;
+    private getEntryDuration;
+    private renderCircles;
+    private renderSymbols;
+    private attachScatterEvents;
+}

package/dist/series/cartesian/SplineChart.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Spline series: smooth catmull-rom curve variant of LineChart.
+ */
+import { LineChart } from './LineChart';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class SplineChart extends LineChart {
+    constructor(config: InternalSeriesConfig);
+    protected getCurve(): import("d3-shape").CurveCatmullRomFactory;
+}

package/dist/series/cartesian/WaterfallChart.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Waterfall series with features: upColor, negativeColor,
+ * borderRadius, lineColor/dashStyle for connectors, isSum/isIntermediateSum,
+ * data labels, grouping, and animated updates.
+ */
+import 'd3-transition';
+import { BaseSeries } from '../BaseSeries';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class WaterfallChart extends BaseSeries {
+    private processed;
+    constructor(config: InternalSeriesConfig);
+    render(): void;
+    animateUpdate(duration: number): void;
+    private processWaterfallData;
+    private getBarColor;
+    private computeBarGeometry;
+    private renderConnectors;
+    private attachBarEvents;
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}

package/dist/series/financial/AreaRangeChart.d.ts

@@ -0,0 +1,24 @@
+import { BaseSeries } from '../BaseSeries';
+import { type CurveFactory } from 'd3-shape';
+import type { InternalSeriesConfig } from '../../types/options';
+export declare class AreaRangeChart extends BaseSeries {
+    constructor(config: InternalSeriesConfig);
+    /** Curve used for the band edges. Overridden by areasplinerange for smoothing. */
+    protected getCurve(): CurveFactory;
+    render(): void;
+    /**
+     * Computes extents using low/high values for the y-axis range.
+     */
+    getDataExtents(): {
+        xMin: number;
+        xMax: number;
+        yMin: number;
+        yMax: number;
+    };
+}
+/**
+ * Area range with smoothed (Catmull-Rom) band edges.
+ */
+export declare class AreaSplineRangeChart extends AreaRangeChart {
+    protected getCurve(): CurveFactory;
+}