@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/rendering/static-layer-cache.d.ts

@@ -0,0 +1,34 @@
+export interface StaticLayerCacheKey {
+    readonly cssWidth: number;
+    readonly cssHeight: number;
+    readonly dpr: number;
+    readonly themeFingerprint: string;
+    readonly dataFingerprint: string;
+    /** Hosts can suffix any extra state that affects the static layer. */
+    readonly extra: string;
+}
+export declare class StaticLayerCache {
+    private cachedKey;
+    private cachedSurface;
+    /** Stats - flips a counter every hit / miss for benchmark + dev
+     *  inspection. Auditable side-effect. */
+    private hits;
+    private misses;
+    /** Returns the cached surface when `key` matches the prior call.
+     *  Returns null on miss; caller paints into the surface returned by
+     *  `acquireSurface(w, h, dpr)` next. */
+    lookup(key: StaticLayerCacheKey): HTMLCanvasElement | null;
+    /** Acquire (or recycle) the offscreen surface the caller will paint
+     *  into. Always recreated on size/DPR change (cheaper than scaling). */
+    acquireSurface(cssWidth: number, cssHeight: number, dpr: number): HTMLCanvasElement;
+    /** Commit the current surface to the cache under `key`. Caller calls
+     *  this after painting. */
+    commit(key: StaticLayerCacheKey): void;
+    /** Force a miss on the next lookup. */
+    invalidate(): void;
+    /** Inspection - useful for benches + dev audit. */
+    stats(): {
+        readonly hits: number;
+        readonly misses: number;
+    };
+}

package/dist/rendering/threshold-split.d.ts

@@ -0,0 +1,14 @@
+export interface ThresholdRun {
+    readonly side: "above" | "below";
+    /** First data-point index in this run (inclusive). */
+    readonly fromIdx: number;
+    /** Last data-point index (inclusive). */
+    readonly toIdx: number;
+    /** Time (ms) at the entry crossing. NaN when the run starts without a
+     *  crossing (window start, or first finite value after a NaN gap). */
+    readonly fromCrossingT: number;
+    /** Time (ms) at the exit crossing. NaN when the run ends without a
+     *  crossing (window end, or last finite value before a NaN gap). */
+    readonly toCrossingT: number;
+}
+export declare function computeThresholdRuns(times: Float64Array, values: Float64Array, startIdx: number, endIdx: number, thresholdY: number): ThresholdRun[];

package/dist/shared/binary-search.d.ts

@@ -0,0 +1,2 @@
+export declare function bisectNearest(arr: Float64Array, target: number): number;
+export declare function bisectLeft(arr: Float64Array, target: number): number;

package/dist/shared/typed.d.ts

@@ -0,0 +1,8 @@
+export declare const f64At: (arr: Float64Array, i: number) => number;
+export declare const f32At: (arr: Float32Array, i: number) => number;
+export declare const u32At: (arr: Uint32Array, i: number) => number;
+export declare const u16At: (arr: Uint16Array, i: number) => number;
+export declare const u8At: (arr: Uint8Array, i: number) => number;
+export declare const i32At: (arr: Int32Array, i: number) => number;
+export declare const i16At: (arr: Int16Array, i: number) => number;
+export declare const i8At: (arr: Int8Array, i: number) => number;

package/dist/solid/chart-group.d.ts

@@ -0,0 +1,16 @@
+import { JSX } from 'solid-js';
+import { ChartGroupOptions, ChartGroupState, TimeRange } from '../composition/chart-group-state';
+export type { ChartGroupOptions, ChartGroupState, TimeRange, SyncYScale, ReferencePoint, } from '../composition/chart-group-state';
+export interface ChartGroupProps extends Partial<ChartGroupOptions> {
+    children?: JSX.Element;
+    onSelectionChange?: (time: number | null) => void;
+    onBrushChange?: (range: TimeRange | null) => void;
+    onPaneResize?: (heights: readonly number[]) => void;
+}
+interface ChartGroupContextValue {
+    readonly options: () => ChartGroupOptions;
+    readonly state: ChartGroupState;
+    readonly version: () => number;
+}
+export declare function useChartGroup(): ChartGroupContextValue | null;
+export declare function ChartGroup(props: ChartGroupProps): JSX.Element;

package/dist/solid/charts-provider.d.ts

@@ -0,0 +1,38 @@
+import { JSX, ParentComponent } from 'solid-js';
+import { Theme, ThemeInput, VisualStyle } from '../personalization';
+export interface ChartsProviderValue {
+    theme: ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: VisualStyle;
+    outlineFillColor: "auto" | string;
+    outlineFillOpacity: number;
+    cornerRadius: number;
+    borderWidth: number;
+    accents: boolean;
+    osTheme: Theme;
+    appTheme: Theme;
+}
+export interface ChartsProviderProps {
+    theme?: ThemeInput;
+    palette?: string;
+    locale?: string;
+    timeZone?: string;
+    visualStyle?: VisualStyle;
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    cornerRadius?: number;
+    borderWidth?: number;
+    accents?: boolean;
+    osTheme?: Theme;
+    appTheme?: Theme;
+    /** Host-supplied custom palettes. */
+    palettes?: readonly import('../personalization/palette/types').Palette[];
+    children?: JSX.Element;
+}
+export declare const ChartsProvider: ParentComponent<ChartsProviderProps>;
+/** Returns an accessor - call as `ctx()` to read the current provider value.
+ *  Mirrors React's `useChartsContext()` shape semantically; in Solid the
+ *  return is a getter so reactivity propagates through the chart components. */
+export declare function useChartsContext(): () => ChartsProviderValue;

package/dist/solid/components/area-chart.d.ts

@@ -0,0 +1,21 @@
+import { JSX } from 'solid-js';
+import { LineChartProps } from './line-chart';
+import { AreaBaseline } from '../../personalization/axes/area-baseline';
+import { StackingMode } from '../../personalization/axes/stacking';
+export type { AreaBaseline } from '../../personalization/axes/area-baseline';
+export type { StackingMode } from '../../personalization/axes/stacking';
+export type AreaFillType = "flat" | "gradient";
+export interface ThresholdFillConfig {
+    value?: number;
+    aboveColor?: string;
+    belowColor?: string;
+}
+export type ThresholdFill = false | true | ThresholdFillConfig;
+export interface AreaChartProps extends Omit<LineChartProps, "areaFill"> {
+    baseline?: AreaBaseline;
+    fillType?: AreaFillType;
+    fillOpacity?: number;
+    thresholdFill?: ThresholdFill;
+    stacked?: StackingMode;
+}
+export declare function AreaChart(props: AreaChartProps): JSX.Element;

package/dist/solid/components/bar-chart.d.ts

@@ -0,0 +1,84 @@
+import { JSX } from 'solid-js';
+import { LineSeriesInput } from '../../domain';
+import { ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, ChartFormatter, Theme, Palette, LegendVisibility, LegendPosition } from '../../personalization';
+import { YAxisPosition, XAxisPosition } from '../../rendering/draw/axis';
+import { GridStyle } from '../../rendering/draw/grid';
+import { CrosshairMarker } from '../../rendering/draw/crosshair';
+import { Orientation } from '../../viewport/orientation';
+import { ValueLabels } from '../../personalization/axes/value-labels';
+export type BarChartSeriesInput = LineSeriesInput;
+export interface BarSeriesConfig {
+    readonly id: string;
+    readonly data: BarChartSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+}
+export type BarGrouping = "clustered" | "stacked" | "normalized" | "overlapping";
+export interface BarTooltipSeriesValue {
+    readonly id: string;
+    readonly label: string;
+    readonly color: string;
+    readonly value: number;
+}
+export interface BarChartTooltipProps {
+    readonly t: number;
+    readonly idx: number;
+    readonly seriesValues: readonly BarTooltipSeriesValue[];
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: Theme;
+    readonly palette: Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+export type BarChartTooltipProp = undefined | false | ((props: BarChartTooltipProps) => JSX.Element);
+export interface BarChartProps {
+    data?: BarChartSeriesInput;
+    series?: readonly BarSeriesConfig[];
+    grouping?: BarGrouping;
+    groupPadding?: number;
+    orientation?: Orientation;
+    valueLabels?: ValueLabels;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    tooltip?: BarChartTooltipProp;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    barWidthRatio?: number;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+export declare function BarChart(props: BarChartProps): JSX.Element;

package/dist/solid/components/candle-chart.d.ts

@@ -0,0 +1,142 @@
+import { JSX } from 'solid-js';
+import { CandleSeriesInput, LiveState, SignalMarker, OrderMarker, PositionMarker, EventMarker, Drawing as DrawingT, SignalMarker as DomSignalMarker, OrderMarker as DomOrderMarker, PositionMarker as DomPositionMarker, EventMarker as DomEventMarker } from '../../domain';
+import { ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LiveBarIndicator, ConnectionIndicator, StaleVisualization, LegendPosition, Theme, Palette, BarEntryAnimation, BarUpdateAnimation, ChartFormatter } from '../../personalization';
+import { YAxisPosition, XAxisPosition } from '../../rendering/draw/axis';
+import { GridStyle } from '../../rendering/draw/grid';
+import { CrosshairMarker } from '../../rendering/draw/crosshair';
+import { LastPriceLineStyle } from '../../rendering/draw/last-price';
+import { IndicatorPaneSpec, IndicatorLineStyle } from '../../personalization/axes/indicator-pane-spec';
+import { CandleChartTooltipProps, CandleDirection } from '../tooltips/default-candle-tooltip';
+import { ExtremeTooltipProp, ExtremeTooltipProps, HighLowMarkers } from '../tooltips/default-extreme-tooltip';
+import { VolumeBarTooltipProps } from '../tooltips/default-volume-bar-tooltip';
+export interface SignalTooltipProps {
+    marker: DomSignalMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export interface OrderTooltipProps {
+    marker: DomOrderMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export interface PositionTooltipProps {
+    marker: DomPositionMarker;
+    lastClose: number;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export interface EventTooltipProps {
+    marker: DomEventMarker;
+    pointerX: number;
+    pointerY: number;
+    formatter: ChartFormatter;
+}
+export type CandleType = "solid" | "heikin-ashi" | "ohlc-bars";
+export type WickColor = "body" | "neutral" | string;
+export type VolumePlacement = "subpane" | "overlay";
+export type VolumeColoring = "by-direction" | "single" | "by-magnitude";
+export type VolumeScale = "linear" | "log";
+export type CandleChartTooltipProp = undefined | false | ((props: CandleChartTooltipProps) => JSX.Element);
+export type { CandleChartTooltipProps, CandleDirection };
+export type { ExtremeTooltipProp, ExtremeTooltipProps, HighLowMarkers };
+export type { VolumeBarTooltipProps };
+export type { IndicatorPaneSpec, IndicatorLineStyle };
+/** Imperative handle exposed via `ref` on `<CandleChart>`. Binary
+ *  data ingestion - primitive args. */
+export interface CandleChartHandle {
+    /** Push a live tick. Updates high/low/close of the most recent bar
+     *  in-place; the host owns bar progression (call `update({ data })`
+     *  with a fresh last bar to start a new bucket). */
+    onTick(time: number, price: number, size?: number): void;
+}
+export interface CandleChartProps {
+    /** Solid ref callback - receives the imperative handle after mount. */
+    ref?: (handle: CandleChartHandle) => void;
+    data: CandleSeriesInput;
+    historyData?: CandleSeriesInput;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    cornerRadius?: number;
+    borderWidth?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    candleType?: CandleType;
+    bodyWidthRatio?: number;
+    wickWidth?: number;
+    wickColor?: WickColor;
+    dojiMinBodyHeight?: number;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    crosshairPaneSync?: boolean;
+    tooltip?: CandleChartTooltipProp;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+    lastPriceLine?: LastPriceLineStyle;
+    lastPriceLabel?: boolean;
+    highLowMarkers?: HighLowMarkers;
+    extremeTooltip?: ExtremeTooltipProp;
+    volumeVisible?: boolean;
+    volumePlacement?: VolumePlacement;
+    volumeColoring?: VolumeColoring;
+    volumeSingleColor?: "auto" | string;
+    volumeScale?: VolumeScale;
+    volumeHeightRatio?: number;
+    volumeBarTooltip?: boolean | ((props: VolumeBarTooltipProps) => JSX.Element);
+    indicators?: readonly IndicatorPaneSpec[];
+    indicatorLineWidth?: number;
+    indicatorLineStyle?: IndicatorLineStyle;
+    indicatorOpacity?: number;
+    liveBarIndicator?: LiveBarIndicator;
+    connectionIndicator?: ConnectionIndicator;
+    liveSince?: number;
+    connectionState?: LiveState;
+    staleThreshold?: number;
+    staleVisualization?: StaleVisualization;
+    staleBanner?: boolean | ((p: {
+        state: LiveState;
+        liveSince: number | undefined;
+        theme: Theme;
+        palette: Palette;
+    }) => JSX.Element);
+    legendPosition?: LegendPosition;
+    reducedMotion?: boolean;
+    barEntryAnimation?: BarEntryAnimation;
+    barUpdateAnimation?: BarUpdateAnimation;
+    drawings?: readonly DrawingT[];
+    signals?: readonly SignalMarker[];
+    orders?: readonly OrderMarker[];
+    position?: PositionMarker;
+    events?: readonly EventMarker[];
+    signalTooltip?: false | ((p: SignalTooltipProps) => JSX.Element);
+    orderTooltip?: false | ((p: OrderTooltipProps) => JSX.Element);
+    positionTooltip?: false | ((p: PositionTooltipProps) => JSX.Element);
+    eventTooltip?: false | ((p: EventTooltipProps) => JSX.Element);
+}
+export declare function CandleChart(props: CandleChartProps): JSX.Element;

package/dist/solid/components/chart-group-brush.d.ts

@@ -0,0 +1,13 @@
+import { JSX } from 'solid-js';
+export interface ChartGroupBrushProps {
+    readonly domain: {
+        start: number;
+        end: number;
+    };
+    readonly width?: number;
+    readonly height?: number;
+    readonly trackColor?: string;
+    readonly selectionColor?: string;
+    readonly handleColor?: string;
+}
+export declare function ChartGroupBrush(props: ChartGroupBrushProps): JSX.Element;

package/dist/solid/components/chart-group-navigator.d.ts

@@ -0,0 +1,12 @@
+import { JSX } from 'solid-js';
+import { LineSeriesInput } from '../../domain';
+export interface ChartGroupNavigatorProps {
+    readonly data: LineSeriesInput;
+    readonly domain?: {
+        start: number;
+        end: number;
+    };
+    readonly width?: number;
+    readonly height?: number;
+}
+export declare function ChartGroupNavigator(props: ChartGroupNavigatorProps): JSX.Element;

package/dist/solid/components/depth-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { DepthChartBaseProps, DepthChartTooltipProps } from '../../charts/depth-chart-helpers';
+export type { DepthChartTooltipProps, HoverState, DepthLevel, DepthSeriesInput, } from '../../charts/depth-chart-helpers';
+export type DepthChartTooltipProp = undefined | false | ((props: DepthChartTooltipProps) => JSX.Element);
+export interface DepthChartProps extends DepthChartBaseProps {
+    tooltip?: DepthChartTooltipProp;
+}
+export declare function DepthChart(props: DepthChartProps): JSX.Element;

package/dist/solid/components/heatmap-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { HeatmapChartBaseProps, HeatmapChartTooltipProps } from '../../charts/heatmap-chart-helpers';
+export type { HeatmapChartTooltipProps, HoverState, } from '../../charts/heatmap-chart-helpers';
+export type HeatmapChartTooltipProp = undefined | false | ((props: HeatmapChartTooltipProps) => JSX.Element);
+export interface HeatmapChartProps extends HeatmapChartBaseProps {
+    tooltip?: HeatmapChartTooltipProp;
+}
+export declare function HeatmapChart(props: HeatmapChartProps): JSX.Element;

package/dist/solid/components/histogram-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { HistogramChartBaseProps, HistogramChartTooltipProps } from '../../charts/histogram-chart-helpers';
+export type { HistogramChartTooltipProps, HoverState, } from '../../charts/histogram-chart-helpers';
+export type HistogramChartTooltipProp = undefined | false | ((props: HistogramChartTooltipProps) => JSX.Element);
+export interface HistogramChartProps extends HistogramChartBaseProps {
+    tooltip?: HistogramChartTooltipProp;
+}
+export declare function HistogramChart(props: HistogramChartProps): JSX.Element;

package/dist/solid/components/kagi-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { KagiChartBaseProps, KagiChartTooltipProps } from '../../charts/kagi-chart-controller';
+export type KagiChartTooltipProp = undefined | false | ((props: KagiChartTooltipProps) => JSX.Element);
+export interface KagiChartProps extends KagiChartBaseProps {
+    tooltip?: KagiChartTooltipProp;
+}
+export type { KagiChartTooltipProps, HoverState, } from '../../charts/kagi-chart-controller';
+export declare function KagiChart(props: KagiChartProps): JSX.Element;

package/dist/solid/components/line-chart.d.ts

@@ -0,0 +1,110 @@
+import { JSX } from 'solid-js';
+import { LineSeriesInput, LiveState } from '../../domain';
+import { ThemeInput, LiveBarIndicator, ConnectionIndicator, LegendPosition, LegendVisibility, StaleVisualization, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, Theme, Palette } from '../../personalization';
+import { GridStyle } from '../../rendering/draw/grid';
+import { CrosshairMarker } from '../../rendering/draw/crosshair';
+import { YAxisPosition, XAxisPosition } from '../../rendering/draw/axis';
+import { LastPriceLineStyle } from '../../rendering/draw/last-price';
+import { CurveType } from '../../personalization/axes/curve-type';
+import { LineDash } from '../../personalization/axes/line-dash';
+import { PointMarkers } from '../../personalization/axes/point-markers';
+import { LineChartTooltipProps, TooltipSeriesValue } from '../tooltips/default-tooltip';
+import { ExtremeTooltipProp, ExtremeTooltipProps, HighLowMarkers } from '../tooltips/default-extreme-tooltip';
+import { AreaFillThreshold, AreaFillConfig, SeriesConfig, LineChartIndicatorSpec } from '../../charts/line-chart-helpers';
+export type { AreaFillThreshold, AreaFillConfig, SeriesConfig, LineChartIndicatorSpec, };
+export type { HighLowMarkers, ExtremeTooltipProp, ExtremeTooltipProps };
+export type { LineChartTooltipProps, TooltipSeriesValue };
+export type CrosshairSnap = "free" | "x-axis" | "data";
+export type CrosshairMode = "follow" | "sticky";
+export type LineChartTooltipProp = boolean | ((props: LineChartTooltipProps) => JSX.Element);
+export interface ConnectionIndicatorRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    position: LegendPosition;
+    theme: Theme;
+    palette: Palette;
+}
+export type ConnectionIndicatorProp = ConnectionIndicator | ((props: ConnectionIndicatorRenderProps) => JSX.Element);
+export interface StaleBannerRenderProps {
+    state: LiveState;
+    liveSince: number | undefined;
+    theme: Theme;
+    palette: Palette;
+}
+export type StaleBannerProp = boolean | ((props: StaleBannerRenderProps) => JSX.Element);
+/** Imperative handle exposed via `ref` on `<LineChart>`. Lets the host
+ *  push live-tick updates without re-rendering the Solid component.
+ *  Binary data ingestion: primitive args. */
+export interface LineChartHandle {
+    /** Append a live tick (time ms, price). `size` is accepted for API
+     *  parity with CandleChart but is unused for line charts. */
+    onTick(time: number, price: number, size?: number): void;
+}
+export interface LineChartProps {
+    /** Solid ref callback - receives the imperative handle after mount. */
+    ref?: (handle: LineChartHandle) => void;
+    data?: LineSeriesInput;
+    historyData?: LineSeriesInput;
+    series?: readonly SeriesConfig[];
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    crosshairVisible?: boolean;
+    crosshairSnap?: CrosshairSnap;
+    crosshairMode?: CrosshairMode;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    tooltip?: LineChartTooltipProp;
+    indicators?: readonly LineChartIndicatorSpec[];
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+    lastPriceLine?: LastPriceLineStyle;
+    lastPriceLabel?: boolean;
+    chartBgColor?: string;
+    highLowMarkers?: HighLowMarkers;
+    extremeTooltip?: ExtremeTooltipProp;
+    liveBarIndicator?: LiveBarIndicator;
+    connectionIndicator?: ConnectionIndicatorProp;
+    legendPosition?: LegendPosition;
+    legend?: LegendVisibility;
+    staleVisualization?: StaleVisualization;
+    staleBanner?: StaleBannerProp;
+    liveSince?: number;
+    connectionState?: LiveState;
+    staleThreshold?: number;
+    reducedMotion?: boolean;
+    curveType?: CurveType;
+    stepEdgeRadius?: number;
+    lineWidth?: number;
+    lineDash?: LineDash;
+    lineDashSpacing?: number;
+    pointMarkers?: PointMarkers;
+    areaFill?: AreaFillConfig;
+    glow?: import('../../personalization/axes/glow').GlowInput;
+    glowColor?: import('../../personalization/axes/glow').GlowColorInput;
+}
+export declare function LineChart(props: LineChartProps): JSX.Element;

package/dist/solid/components/pie-chart.d.ts

@@ -0,0 +1,20 @@
+import { JSX } from 'solid-js';
+import { PieChartBaseProps, PieChartTooltipProps } from '../../charts/pie-chart-helpers';
+import { ChartFormatter, Theme, Palette } from '../../personalization';
+export type { PieChartTooltipProps, HoverState, PieSeriesInput, PieSlice, } from '../../charts/pie-chart-helpers';
+export type PieChartTooltipProp = undefined | false | ((props: PieChartTooltipProps) => JSX.Element);
+export interface PieChartProps extends PieChartBaseProps {
+    tooltip?: PieChartTooltipProp;
+}
+export interface DonutCenterLabelData {
+    readonly totalValue: number;
+    readonly formatter: ChartFormatter;
+    readonly theme: Theme;
+    readonly palette: Palette;
+}
+export type CenterLabelProp = false | true | string | ((data: DonutCenterLabelData) => JSX.Element);
+export interface DonutChartProps extends PieChartProps {
+    centerLabel?: CenterLabelProp;
+}
+export declare function PieChart(props: PieChartProps): JSX.Element;
+export declare function DonutChart(props: DonutChartProps): JSX.Element;

package/dist/solid/components/point-figure-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { PnFChartBaseProps, PnFChartTooltipProps } from '../../charts/pnf-chart-controller';
+export type PointFigureChartTooltipProp = undefined | false | ((props: PnFChartTooltipProps) => JSX.Element);
+export interface PointFigureChartProps extends PnFChartBaseProps {
+    tooltip?: PointFigureChartTooltipProp;
+}
+export type { PnFChartTooltipProps, HoverState, } from '../../charts/pnf-chart-controller';
+export declare function PointFigureChart(props: PointFigureChartProps): JSX.Element;

package/dist/solid/components/renko-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { RenkoChartBaseProps, RenkoChartTooltipProps } from '../../charts/renko-chart-controller';
+export type RenkoChartTooltipProp = undefined | false | ((props: RenkoChartTooltipProps) => JSX.Element);
+export interface RenkoChartProps extends RenkoChartBaseProps {
+    tooltip?: RenkoChartTooltipProp;
+}
+export type { RenkoChartTooltipProps, HoverState, } from '../../charts/renko-chart-controller';
+export declare function RenkoChart(props: RenkoChartProps): JSX.Element;

package/dist/solid/components/sankey-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { SankeyChartBaseProps, SankeyChartTooltipProps } from '../../charts/sankey-chart-controller';
+export type SankeyChartTooltipProp = undefined | false | ((props: SankeyChartTooltipProps) => JSX.Element);
+export interface SankeyChartProps extends SankeyChartBaseProps {
+    tooltip?: SankeyChartTooltipProp;
+}
+export type { SankeyChartTooltipProps, HoverState, SankeyInput, SankeyNodeInput, SankeyLinkInput, } from '../../charts/sankey-chart-controller';
+export declare function SankeyChart(props: SankeyChartProps): JSX.Element;

package/dist/solid/components/scatter-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { ScatterChartBaseProps, ScatterChartTooltipProps } from '../../charts/scatter-chart-helpers';
+export type { ScatterChartTooltipProps, HoverState, } from '../../charts/scatter-chart-helpers';
+export type ScatterChartTooltipProp = undefined | false | ((props: ScatterChartTooltipProps) => JSX.Element);
+export interface ScatterChartProps extends ScatterChartBaseProps {
+    tooltip?: ScatterChartTooltipProp;
+}
+export declare function ScatterChart(props: ScatterChartProps): JSX.Element;

package/dist/solid/components/sunburst-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { SunburstChartBaseProps, SunburstChartTooltipProps } from '../../charts/sunburst-chart-helpers';
+export type { SunburstChartTooltipProps, HoverState, } from '../../charts/sunburst-chart-helpers';
+export type SunburstChartTooltipProp = undefined | false | ((props: SunburstChartTooltipProps) => JSX.Element);
+export interface SunburstChartProps extends SunburstChartBaseProps {
+    tooltip?: SunburstChartTooltipProp;
+}
+export declare function SunburstChart(props: SunburstChartProps): JSX.Element;

package/dist/solid/components/treemap-chart.d.ts

@@ -0,0 +1,8 @@
+import { JSX } from 'solid-js';
+import { TreemapChartBaseProps, TreemapChartTooltipProps } from '../../charts/treemap-chart-helpers';
+export type { TreemapChartTooltipProps, HoverState, } from '../../charts/treemap-chart-helpers';
+export type TreemapChartTooltipProp = undefined | false | ((props: TreemapChartTooltipProps) => JSX.Element);
+export interface TreemapChartProps extends TreemapChartBaseProps {
+    tooltip?: TreemapChartTooltipProp;
+}
+export declare function TreemapChart(props: TreemapChartProps): JSX.Element;

package/dist/solid/hooks/use-chart-theme.d.ts

@@ -0,0 +1,2 @@
+import { Theme, ThemeInput } from '../../personalization';
+export declare function useChartTheme(perChartTheme?: ThemeInput): () => Theme;