@wick-charts/react 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -1,78 +1,40 @@
-import { andromeda } from '@wick-charts/core';
-import { AxisBound } from '@wick-charts/core';
-import { AxisConfig } from '@wick-charts/core';
-import { ayuMirage } from '@wick-charts/core';
-import { BarSeriesOptions } from '@wick-charts/core';
-import { BarStacking } from '@wick-charts/core';
-import { buildTheme } from '@wick-charts/core';
-import { CandlestickSeriesOptions } from '@wick-charts/core';
-import { catppuccin } from '@wick-charts/core';
-import { ChartInstance } from '@wick-charts/core';
-import { ChartLayout } from '@wick-charts/core';
-import { ChartOptions } from '@wick-charts/core';
-import { ChartTheme } from '@wick-charts/core';
-import { createTheme } from '@wick-charts/core';
-import { CrosshairPosition } from '@wick-charts/core';
 import { CSSProperties } from 'react';
-import { darkTheme } from '@wick-charts/core';
-import { detectInterval } from '@wick-charts/core';
-import { dracula } from '@wick-charts/core';
-import { formatDate } from '@wick-charts/core';
-import { formatTime } from '@wick-charts/core';
-import { githubLight } from '@wick-charts/core';
-import { gruvbox } from '@wick-charts/core';
-import { handwritten } from '@wick-charts/core';
-import { highContrast } from '@wick-charts/core';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
-import { lavenderMist } from '@wick-charts/core';
-import { lightPink } from '@wick-charts/core';
-import { lightTheme } from '@wick-charts/core';
-import { LineData } from '@wick-charts/core';
-import { LineSeriesOptions } from '@wick-charts/core';
-import { materialPalenight } from '@wick-charts/core';
-import { minimalLight } from '@wick-charts/core';
-import { mintBreeze } from '@wick-charts/core';
-import { monokaiPro } from '@wick-charts/core';
-import { nightOwl } from '@wick-charts/core';
-import { normalizeTime } from '@wick-charts/core';
-import { OHLCData } from '@wick-charts/core';
-import { OHLCInput } from '@wick-charts/core';
-import { oneDarkPro } from '@wick-charts/core';
-import { panda } from '@wick-charts/core';
-import { peachCream } from '@wick-charts/core';
-import { PieSeriesOptions } from '@wick-charts/core';
-import { PieSliceData } from '@wick-charts/core';
 import { Provider } from 'react';
-import { quietLight } from '@wick-charts/core';
 import { ReactNode } from 'react';
-import { rosePineDawn } from '@wick-charts/core';
-import { sandDune } from '@wick-charts/core';
-import { SeriesType } from '@wick-charts/core';
-import { solarizedLight } from '@wick-charts/core';
-import { StackingMode } from '@wick-charts/core';
-import { ThemeConfig } from '@wick-charts/core';
-import { ThemePreset } from '@wick-charts/core';
-import { themes } from '@wick-charts/core';
-import { TimePoint } from '@wick-charts/core';
-import { TimePointInput } from '@wick-charts/core';
-import { TimeValue } from '@wick-charts/core';
-import { Typography } from '@wick-charts/core';
-import { VisibleRange } from '@wick-charts/core';
-import { XAxisConfig } from '@wick-charts/core';
-import { YAxisConfig } from '@wick-charts/core';
-import { YRange } from '@wick-charts/core';
-
-export { andromeda }
-
-export { AxisBound }
-
-export { AxisConfig }
-
-export { ayuMirage }
+
+export declare const andromeda: ThemePreset;
+
+/**
+ * Defines a bound for the Y axis.
+ *
+ * - `"auto"` — fully automatic (default)
+ * - `number` — static value, e.g. `0` or `100`
+ * - `string` — percentage offset from the auto value, e.g. `"+10%"`, `"-5%"`
+ * - `(values: number[]) => number` — custom function receiving all visible values
+ */
+export declare type AxisBound = 'auto' | number | string | ((values: number[]) => number);
+
+/** Grouped axis configuration for both axes. */
+export declare interface AxisConfig {
+    y?: YAxisConfig;
+    x?: XAxisConfig;
+}
+
+export declare const ayuMirage: ThemePreset;
 
 export declare function BarSeries({ data, options, label, id: idProp, onSeriesId }: BarSeriesProps): null;
 
-export { BarSeriesOptions }
+/** Visual options for a bar series. */
+export declare interface BarSeriesOptions {
+    /** Display label shown in the tooltip (e.g. "Volume"). */
+    label?: string;
+    /** One color per layer. */
+    colors: string[];
+    barWidthRatio: number;
+    /** Stacking mode. Default: 'off'. */
+    stacking: StackingMode;
+}
 
 declare interface BarSeriesProps {
     /** Array of datasets — one per layer. A single-layer bar chart uses `[data]`. */
@@ -86,16 +48,30 @@ declare interface BarSeriesProps {
     onSeriesId?: (id: string) => void;
 }
 
-export { BarStacking }
+/** @deprecated Use {@link StackingMode} instead. */
+export declare type BarStacking = StackingMode;
 
-export { buildTheme }
+/** Lookup a theme by name (defaults to "One Dark Pro") */
+export declare function buildTheme(themeName: string): ChartTheme;
 
 export declare function CandlestickSeries({ data, options, id: idProp, onSeriesId }: CandlestickSeriesProps): null;
 
-export { CandlestickSeriesOptions }
+/** Visual options for a candlestick series. */
+export declare interface CandlestickSeriesOptions {
+    /** Display label shown in the tooltip. */
+    label?: string;
+    upColor: string;
+    downColor: string;
+    wickUpColor: string;
+    wickDownColor: string;
+    /** Width of candle body as a fraction of the available bar slot (0-1). */
+    bodyWidthRatio: number;
+    /** Apply a subtle vertical gradient to candle bodies. Default: true. */
+    candleGradient?: boolean;
+}
 
 declare interface CandlestickSeriesProps {
-    data: OHLCData[];
+    data: OHLCInput[];
     options?: Partial<CandlestickSeriesOptions>;
     /** Stable series ID. Prefer this over `onSeriesId` — same value across remounts. */
     id?: string;
@@ -103,7 +79,7 @@ declare interface CandlestickSeriesProps {
     onSeriesId?: (id: string) => void;
 }
 
-export { catppuccin }
+export declare const catppuccin: ThemePreset;
 
 /**
  * Top-level React wrapper that creates a {@link ChartInstance} and provides it to children via context.
@@ -145,39 +121,302 @@ declare interface ChartContainerProps {
     className?: string;
 }
 
-export { ChartInstance }
+/** Events emitted by {@link ChartInstance}. */
+declare interface ChartEvents {
+    crosshairMove: (pos: CrosshairPosition | null) => void;
+    viewportChange: () => void;
+    dataUpdate: () => void;
+    seriesChange: () => void;
+}
 
-export { ChartLayout }
+/**
+ * Core chart controller. Manages series, viewport, scales, and rendering.
+ * Create one per chart container and call {@link destroy} on unmount.
+ */
+export declare class ChartInstance extends EventEmitter<ChartEvents> {
+    #private;
+    /** Maps time values to horizontal pixel coordinates. */
+    readonly timeScale: TimeScale;
+    /** Maps price/value to vertical pixel coordinates. */
+    readonly yScale: YScale;
+    get yAxisWidth(): number;
+    get xAxisHeight(): number;
+    constructor(container: HTMLElement, options?: ChartOptions);
+    /** Add a candlestick (OHLC) series and return its unique ID. */
+    addCandlestickSeries(options?: Partial<CandlestickSeriesOptions & {
+        id?: string;
+    }>): string;
+    /** Add a line series and return its unique ID. */
+    addLineSeries(options?: Partial<LineSeriesOptions & {
+        layers?: number;
+        id?: string;
+    }>): string;
+    /** @deprecated Pass options as first argument: `addLineSeries({ layers: N, ...options })` */
+    addLineSeries(layerCount: number, options?: Partial<LineSeriesOptions>): string;
+    /** Set data for a specific layer within a line series. */
+    setLineLayerData(id: string, layerIndex: number, data: TimePoint[]): void;
+    /** Add a bar series and return its unique ID. */
+    addBarSeries(options?: Partial<BarSeriesOptions & {
+        layers?: number;
+        id?: string;
+    }>): string;
+    /** @deprecated Pass options as first argument: `addBarSeries({ layers: N, ...options })` */
+    addBarSeries(layerCount: number, options?: Partial<BarSeriesOptions>): string;
+    /** Set data for a specific layer within a bar series. */
+    setBarLayerData(id: string, layerIndex: number, data: TimePoint[]): void;
+    /** Add a pie/donut series. Set `innerRadiusRatio > 0` for donut. */
+    addPieSeries(options?: Partial<PieSeriesOptions & {
+        id?: string;
+    }>): string;
+    /** Set data for a pie/donut series. */
+    setPieData(id: string, data: PieSliceData[]): void;
+    /** Remove a series by ID and clean up its resources. */
+    removeSeries(id: string): void;
+    /** Replace all data for a series (batch load). Accepts `Date` objects for time fields. */
+    setSeriesData(id: string, data: OHLCInput[] | TimePointInput[]): void;
+    /** Append a new data point to the end of a series (real-time tick). */
+    appendData(id: string, point: OHLCInput | TimePointInput): void;
+    /** Update the last data point of a series in place (e.g. live candle update). */
+    updateData(id: string, point: OHLCInput | TimePointInput): void;
+    /** Update visual options (color, width, etc.) for an existing series. */
+    updateSeriesOptions(id: string, options: Partial<CandlestickSeriesOptions> | Partial<LineSeriesOptions> | Partial<BarSeriesOptions> | Partial<PieSeriesOptions>): void;
+    /**
+     * Batch multiple updates: suppress recomputes until `fn` returns.
+     * Equivalent to `beginUpdate()` / `endUpdate()` but safer (always calls endUpdate even on throw).
+     */
+    batch(fn: () => void): void;
+    /** @deprecated Use {@link batch} instead. */
+    beginUpdate(): void;
+    /** @deprecated Use {@link batch} instead. */
+    endUpdate(): void;
+    /** Show or hide a series. Hidden series are not rendered and excluded from Y-range. */
+    setSeriesVisible(seriesId: string, visible: boolean): void;
+    isSeriesVisible(seriesId: string): boolean;
+    /** Show or hide a specific layer within a multi-layer series. */
+    setLayerVisible(seriesId: string, layerIndex: number, visible: boolean): void;
+    isLayerVisible(seriesId: string, layerIndex: number): boolean;
+    /** Auto-fit the viewport to show all data across every series. */
+    fitContent(): void;
+    getVisibleRange(): VisibleRange;
+    getYRange(): YRange;
+    getCrosshairPosition(): CrosshairPosition | null;
+    /** Get the last visible value and whether the absolute last point is on screen. */
+    getLastValue(seriesId: string): {
+        value: number;
+        isLive: boolean;
+    } | null;
+    /** Get the second-to-last value, useful for computing change. */
+    getPreviousClose(seriesId: string): number | null;
+    getLastData(seriesId: string): OHLCData | TimePoint | null;
+    /** Find the data point closest to the given timestamp within one data interval. */
+    getDataAtTime(seriesId: string, time: number): OHLCData | TimePoint | null;
+    /** Get all layers' data at a given time for multi-layer series (Bar/Line with stacking). */
+    getLayerSnapshots(seriesId: string, time: number): {
+        value: number;
+        color: string;
+    }[] | null;
+    getSeriesIds(): string[];
+    /** Get the primary display color for a series. */
+    getSeriesColor(seriesId: string): string | null;
+    getSeriesLabel(seriesId: string): string | undefined;
+    /** Get per-layer colors for a series. Returns null for non-bar/line series (e.g. candlestick, pie). */
+    getSeriesLayers(seriesId: string): {
+        color: string;
+    }[] | null;
+    /** Get all pie slices with computed colors and percentages. Returns null for non-pie series. */
+    getPieSlices(seriesId: string): {
+        label: string;
+        value: number;
+        percent: number;
+        color: string;
+    }[] | null;
+    /** Get the hovered pie slice info (label, value, percentage, color). Returns null if no hover. */
+    getPieHoverInfo(seriesId: string): {
+        label: string;
+        value: number;
+        percent: number;
+        color: string;
+    } | null;
+    /** Apply a new theme and update candlestick series colors. Line series keep their individual colors. */
+    setTheme(theme: ChartTheme): void;
+    getTheme(): ChartTheme;
+    /** Update axis configuration and re-render. */
+    setAxis(config: AxisConfig): void;
+    getMediaSize(): Size;
+    /** Returns layout metrics for the chart area, Y axis, and time axis. */
+    getLayout(): ChartLayout;
+    getDataInterval(): number;
+    /** Update viewport padding at runtime. Refits the visible range to current data bounds. */
+    setPadding(padding: ChartOptions['padding']): void;
+    /** Show or hide the background grid. Takes effect on the next render frame. */
+    setGrid(grid: boolean): void;
+    /** Notify chart that a YLabel is present (affects right padding). */
+    setYLabel(has: boolean): void;
+    private updatePieHover;
+    private updateViewportPadding;
+    /** Tear down the chart: cancel animations, remove listeners, and detach the canvas. */
+    destroy(): void;
+    /** Compute the earliest and latest timestamps across all series. */
+    private getDataBounds;
+    private onDataChanged;
+    /** Check whether the last data point of any series falls within the visible time range. */
+    private isLastPointVisible;
+    private updateDataInterval;
+    private updateYRange;
+    /** Resolve an {@link AxisBound} to a concrete numeric value. */
+    private resolveBound;
+    /**
+     * Lightweight scale sync: updates timeScale/yScale from current viewport state
+     * without advancing the Y smoothing animation. Called from the viewport 'change'
+     * handler so DOM axis components always read fresh coordinates on re-render.
+     */
+    private syncScales;
+    private updateScales;
+    /** Expensive: background, grid, all series. Only on data/viewport/resize change. */
+    private renderMain;
+    /** Cheap overlay: crosshair, nearest-point dots, pulse animation. */
+    private renderOverlay;
+}
 
-export { ChartOptions }
+/** Layout metrics describing the chart area, Y axis, and time axis sizes. */
+export declare interface ChartLayout {
+    chartArea: Rect;
+    yAxisWidth: number;
+    xAxisHeight: number;
+}
 
-export { ChartTheme }
+/** Options passed when creating a new {@link ChartInstance}. */
+export declare interface ChartOptions {
+    theme?: ChartTheme;
+    axis?: AxisConfig;
+    /**
+     * Viewport padding. `top`/`bottom` are in pixels. `left`/`right` accept either pixels (`50`)
+     * or data intervals (`{ intervals: 3 }`). Defaults: `{ top: 20, bottom: 20, right: { intervals: 3 }, left: { intervals: 0 } }`.
+     */
+    padding?: {
+        top?: number;
+        bottom?: number;
+        right?: number | {
+            intervals: number;
+        };
+        left?: number | {
+            intervals: number;
+        };
+    };
+    /** Enable zoom, pan, and crosshair interactions. Defaults to true. */
+    interactive?: boolean;
+    /** Show the background grid. Defaults to true. */
+    grid?: boolean;
+}
+
+/**
+ * Complete visual theme for a chart instance.
+ * Controls colors for every visual element: background, series, axes, crosshair, tooltip, etc.
+ */
+export declare interface ChartTheme {
+    /** Page/container background */
+    background: string;
+    /** Chart area gradient [top, bottom] — subtle vignette for depth */
+    chartGradient: [string, string];
+    typography: Typography;
+    /** Grid line appearance in the chart area. */
+    grid: {
+        color: string;
+        style: 'solid' | 'dashed' | 'dotted';
+    };
+    /** OHLC candlestick body and wick colors. */
+    candlestick: {
+        upColor: string;
+        downColor: string;
+        wickUpColor: string;
+        wickDownColor: string;
+    };
+    /** Default line series appearance including area gradient fill. */
+    line: {
+        color: string;
+        width: number;
+        areaTopColor: string;
+        areaBottomColor: string;
+    };
+    /** Color palette for multi-series charts (stacked bars, overlays). */
+    seriesColors: string[];
+    /** Bollinger band / envelope fill colors. */
+    bands: {
+        upper: string;
+        lower: string;
+    };
+    /** Crosshair line and axis label styling. */
+    crosshair: {
+        color: string;
+        labelBackground: string;
+        labelTextColor: string;
+    };
+    /** Axis tick label styling. */
+    axis: {
+        textColor: string;
+    };
+    /** Floating label shown at the current value level on the Y axis. */
+    yLabel: {
+        upBackground: string;
+        downBackground: string;
+        neutralBackground: string;
+        textColor: string;
+    };
+    /** Hover tooltip styling. */
+    tooltip: {
+        background: string;
+        textColor: string;
+        borderColor: string;
+    };
+}
 
-export { createTheme }
+/**
+ * Build a complete {@link ThemePreset} from a partial config.
+ * Only `background` is required — everything else is derived from it.
+ */
+export declare function createTheme(config: ThemeConfig): ThemePreset;
 
 export declare function Crosshair(): JSX_2.Element | null;
 
-export { CrosshairPosition }
+/** Crosshair position in both pixel and data space. */
+export declare interface CrosshairPosition {
+    /** X position in CSS pixels relative to the chart container. */
+    mediaX: number;
+    /** Y position in CSS pixels relative to the chart container. */
+    mediaY: number;
+    /** Snapped time value (timestamp in milliseconds) under the crosshair. */
+    time: number;
+    /** Y (value) under the crosshair. */
+    y: number;
+}
+
+export declare const darkTheme: ChartTheme;
 
-export { darkTheme }
+export declare function detectInterval(times: number[]): number;
 
-export { detectInterval }
+export declare const dracula: ThemePreset;
 
-export { dracula }
+declare class EventEmitter<Events = Record<string, Listener>> {
+    private listeners;
+    on<K extends string & keyof Events>(event: K, listener: Events[K] & Listener): void;
+    off<K extends string & keyof Events>(event: K, listener: Events[K] & Listener): void;
+    protected emit<K extends string & keyof Events>(event: K, ...args: Events[K] extends (...a: infer A) => any ? A : never): void;
+    removeAllListeners(): void;
+}
 
-export { formatDate }
+export declare function formatDate(timestamp: number): string;
 
-export { formatTime }
+export declare function formatTime(timestamp: number, interval: number): string;
 
-export { githubLight }
+export declare const githubLight: ThemePreset;
 
-export { gruvbox }
+export declare const gruvbox: ThemePreset;
 
-export { handwritten }
+export declare const handwritten: ThemePreset;
 
-export { highContrast }
+export declare const highContrast: ThemePreset;
 
-export { lavenderMist }
+export declare const lavenderMist: ThemePreset;
 
 export declare function Legend({ items, position, mode }: LegendProps): JSX_2.Element | null;
 
@@ -199,15 +438,29 @@ export declare interface LegendProps {
     mode?: 'toggle' | 'solo';
 }
 
-export { lightPink }
+export declare const lightPink: ThemePreset;
 
-export { lightTheme }
+export declare const lightTheme: ChartTheme;
 
-export { LineData }
+/** @deprecated Use {@link TimePoint} instead. */
+export declare type LineData = TimePoint;
 
 export declare function LineSeries({ data, options, label, id: idProp, onSeriesId }: LineSeriesProps): null;
 
-export { LineSeriesOptions }
+/** Visual options for a line series. */
+export declare interface LineSeriesOptions {
+    /** Display label shown in the tooltip (e.g. "BTC", "Revenue"). */
+    label?: string;
+    /** One color per layer. */
+    colors: string[];
+    lineWidth: number;
+    /** Whether to render a gradient area fill below the line (or between stacked layers). */
+    areaFill: boolean;
+    /** Whether to show an animated pulsing dot at the last data point. */
+    pulse: boolean;
+    /** Stacking mode. Default: 'off'. */
+    stacking: StackingMode;
+}
 
 declare interface LineSeriesProps {
     /** Array of datasets — one per layer. A single line uses `[data]`. */
@@ -220,17 +473,20 @@ declare interface LineSeriesProps {
     onSeriesId?: (id: string) => void;
 }
 
-export { materialPalenight }
+declare type Listener = (...args: any[]) => void;
+
+export declare const materialPalenight: ThemePreset;
 
-export { minimalLight }
+export declare const minimalLight: ThemePreset;
 
-export { mintBreeze }
+export declare const mintBreeze: ThemePreset;
 
-export { monokaiPro }
+export declare const monokaiPro: ThemePreset;
 
-export { nightOwl }
+export declare const nightOwl: ThemePreset;
 
-export { normalizeTime }
+/** Convert a {@link TimeValue} (number ms or Date) to a millisecond timestamp. */
+export declare function normalizeTime(t: TimeValue): number;
 
 export declare function NumberFlow({ value, format, locale, spinDuration, className, style }: NumberFlowProps): JSX_2.Element;
 
@@ -243,15 +499,26 @@ declare interface NumberFlowProps {
     style?: CSSProperties;
 }
 
-export { OHLCData }
+/** A single OHLC(V) candlestick data point. Time is a timestamp in milliseconds. */
+export declare interface OHLCData {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
 
-export { OHLCInput }
+/** {@link OHLCData} that also accepts `Date` for the time field. */
+export declare type OHLCInput = Omit<OHLCData, 'time'> & {
+    time: TimeValue;
+};
 
-export { oneDarkPro }
+export declare const oneDarkPro: ThemePreset;
 
-export { panda }
+export declare const panda: ThemePreset;
 
-export { peachCream }
+export declare const peachCream: ThemePreset;
 
 export declare function PieLegend({ seriesId, format }: PieLegendProps): JSX_2.Element | null;
 
@@ -266,7 +533,21 @@ export declare interface PieLegendProps {
 /** Pie chart series. Set `options.innerRadiusRatio` > 0 for donut. */
 export declare function PieSeries({ data, options, id: idProp, onSeriesId }: PieSeriesProps): null;
 
-export { PieSeriesOptions }
+/** Visual options for a pie/donut series. `innerRadiusRatio > 0` makes it a donut. */
+export declare interface PieSeriesOptions {
+    /** Palette fallback (defaults to theme.seriesColors). */
+    colors?: string[];
+    /** 0 = pie, 0.6 = donut. Fraction of outer radius used as inner hole. */
+    innerRadiusRatio: number;
+    /** Gap between slices in radians (default 0.02). */
+    padAngle: number;
+    /** Slice border color (default transparent). */
+    strokeColor: string;
+    /** Slice border width (default 0). */
+    strokeWidth: number;
+    /** Display label shown in tooltip. */
+    label?: string;
+}
 
 declare interface PieSeriesProps {
     data: PieSliceData[];
@@ -277,7 +558,14 @@ declare interface PieSeriesProps {
     onSeriesId?: (id: string) => void;
 }
 
-export { PieSliceData }
+/** Optional min/max constraints for the Y axis. Omit a side for automatic scaling. */
+/** A single slice in a pie/donut chart. */
+export declare interface PieSliceData {
+    label: string;
+    value: number;
+    /** Override color for this slice. Falls back to seriesColors palette. */
+    color?: string;
+}
 
 /** Tooltip for pie/donut charts. Shows hovered slice label, value, and percentage. */
 export declare function PieTooltip({ seriesId }: PieTooltipProps): JSX_2.Element | null;
@@ -286,15 +574,30 @@ declare interface PieTooltipProps {
     seriesId: string;
 }
 
-export { quietLight }
+export declare const quietLight: ThemePreset;
 
-export { rosePineDawn }
+/** Axis-aligned rectangle in media (CSS) coordinates. */
+declare interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare const rosePineDawn: ThemePreset;
 
-export { sandDune }
+export declare const sandDune: ThemePreset;
 
-export { SeriesType }
+/** Supported primary series types. */
+export declare type SeriesType = 'candlestick' | 'line' | 'bar' | 'pie';
 
-export { solarizedLight }
+/** Width and height pair. */
+declare interface Size {
+    width: number;
+    height: number;
+}
+
+export declare const solarizedLight: ThemePreset;
 
 export declare function Sparkline({ data, theme, variant, valuePosition, formatValue, label, sublabel, color, negativeColor, areaFill, width, height, lineWidth, gradient, style, }: SparklineProps): JSX_2.Element;
 
@@ -333,25 +636,88 @@ export declare type SparklineValuePosition = 'left' | 'right' | 'none';
 
 export declare type SparklineVariant = 'line' | 'bar';
 
-export { StackingMode }
+/** Stacking mode for bar/line series: off (overlap), normal (stacked), percent (100% stacked). */
+export declare type StackingMode = 'off' | 'normal' | 'percent';
 
-export { ThemeConfig }
+/**
+ * Input config for {@link createTheme}. Mirrors the structure of {@link ChartTheme}
+ * but everything is optional except `background`. Missing values are derived automatically.
+ */
+export declare interface ThemeConfig {
+    name?: string;
+    description?: string;
+    background: string;
+    chartGradient?: [string, string];
+    typography?: Partial<ChartTheme['typography']>;
+    grid?: Partial<ChartTheme['grid']>;
+    candlestick?: Partial<ChartTheme['candlestick']>;
+    line?: Partial<ChartTheme['line']>;
+    seriesColors?: string[];
+    bands?: Partial<ChartTheme['bands']>;
+    crosshair?: Partial<ChartTheme['crosshair']>;
+    axis?: Partial<ChartTheme['axis']>;
+    yLabel?: Partial<ChartTheme['yLabel']>;
+    tooltip?: Partial<ChartTheme['tooltip']>;
+    /** URL to load the font (e.g. Google Fonts). */
+    fontUrl?: string | null;
+}
 
-export { ThemePreset }
+export declare interface ThemePreset {
+    name: string;
+    description?: string;
+    fontUrl: string | null;
+    theme: ChartTheme;
+    dark: boolean;
+    /** Optional CSS background-image for the page */
+    backgroundImage?: string;
+    backgroundSize?: string;
+}
 
 export declare const ThemeProvider: Provider<ChartTheme | null>;
 
-export { themes }
+/** All built-in themes keyed by display name */
+export declare const themes: Record<string, ThemePreset>;
 
 declare function TimeAxis(): JSX_2.Element;
 export { TimeAxis }
 export { TimeAxis as XAxis }
 
-export { TimePoint }
+/** A single time-value data point for line and bar series. Time is a timestamp in milliseconds. */
+export declare interface TimePoint {
+    time: number;
+    value: number;
+}
 
-export { TimePointInput }
+/** {@link TimePoint} that also accepts `Date` for the time field. */
+export declare type TimePointInput = Omit<TimePoint, 'time'> & {
+    time: TimeValue;
+};
+
+declare class TimeScale {
+    private from;
+    private to;
+    private width;
+    private pixelRatio;
+    update(range: VisibleRange, mediaWidth: number, pixelRatio: number): void;
+    timeToX(time: number): number;
+    timeToBitmapX(time: number): number;
+    xToTime(x: number): number;
+    pixelDeltaToTimeDelta(pixelDelta: number): number;
+    barWidthMedia(dataInterval: number): number;
+    barWidthBitmap(dataInterval: number): number;
+    niceTickValues(dataInterval: number): {
+        ticks: number[];
+        tickInterval: number;
+    };
+    getRange(): VisibleRange;
+    getMediaWidth(): number;
+}
 
-export { TimeValue }
+/**
+ * Accepted time input: a timestamp in **milliseconds** (like `Date.now()`) or a `Date` object.
+ * `Date` values are converted to milliseconds internally via `Date.getTime()`.
+ */
+export declare type TimeValue = number | Date;
 
 /**
  * Two-part tooltip:
@@ -378,7 +744,14 @@ declare interface TooltipProps {
 /** Sort order for multi-series tooltip values. */
 export declare type TooltipSort = 'none' | 'asc' | 'desc';
 
-export { Typography }
+/** Font family and size tokens used across the chart. */
+export declare interface Typography {
+    fontFamily: string;
+    fontSize: number;
+    axisFontSize: number;
+    yFontSize: number;
+    tooltipFontSize: number;
+}
 
 export declare function useChartInstance(): ChartInstance;
 
@@ -398,13 +771,33 @@ export declare function useVisibleRange(chart: ChartInstance): VisibleRange;
 
 export declare function useYRange(chart: ChartInstance): YRange;
 
-export { VisibleRange }
+/** Time range (timestamps in milliseconds) of the currently visible portion of the chart. */
+export declare interface VisibleRange {
+    from: number;
+    to: number;
+}
 
-export { XAxisConfig }
+/** Configuration for the X (time) axis. */
+export declare interface XAxisConfig {
+    /** Height in pixels. Default: 30. */
+    height?: number;
+    /** Whether the axis is visible. Default: true. When false, height is treated as 0. */
+    visible?: boolean;
+}
 
 export declare function YAxis(): JSX_2.Element;
 
-export { YAxisConfig }
+/** Configuration for the Y axis. */
+export declare interface YAxisConfig {
+    /** Width in pixels. Default: 55. */
+    width?: number;
+    /** Minimum bound. Default: 'auto'. */
+    min?: AxisBound;
+    /** Maximum bound. Default: 'auto'. */
+    max?: AxisBound;
+    /** Whether the axis is visible. Default: true. When false, width is treated as 0. */
+    visible?: boolean;
+}
 
 export declare function YLabel({ seriesId, color }: YLabelProps): JSX_2.Element | null;
 
@@ -414,6 +807,35 @@ declare interface YLabelProps {
     color?: string;
 }
 
-export { YRange }
+/** Min/max value range for the Y axis. */
+export declare interface YRange {
+    min: number;
+    max: number;
+}
+
+/**
+ * Maps values to vertical pixel positions (and vice versa).
+ * Also provides tick generation and value formatting for the Y axis.
+ */
+declare class YScale {
+    private min;
+    private max;
+    private height;
+    private pixelRatio;
+    /** Recalculate the scale with a new Y range, chart height, and device pixel ratio. */
+    update(range: YRange, mediaHeight: number, pixelRatio: number): void;
+    /** Convert a value to a Y position in CSS (media) pixels. */
+    valueToY(value: number): number;
+    /** Convert a value to a Y position in physical (bitmap) pixels. */
+    valueToBitmapY(value: number): number;
+    /** Convert a Y position in CSS pixels back to a value. */
+    yToValue(y: number): number;
+    /** Generate evenly spaced "nice" tick values that fit the current range and chart height. */
+    niceTickValues(): number[];
+    getRange(): YRange;
+    getMediaHeight(): number;
+    /** Format a value for display, adapting decimal places to the visible range magnitude. */
+    formatY(value: number): string;
+}
 
 export { }