@tony01/astroneum 0.4.1-beta.2

package/dist/Indicator-BBI3L_lx.d.ts

@@ -0,0 +1,1181 @@
+import react__default from 'react';
+
+type Nullable<T> = T | null;
+
+interface NeighborData<D> {
+    prev: D;
+    current: D;
+    next: D;
+}
+type Timestamp$1 = number;
+interface CandleData {
+    timestamp: Timestamp$1;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+    turnover?: number;
+    [key: string]: unknown;
+}
+
+interface Margin {
+    marginLeft: number;
+    marginTop: number;
+    marginRight: number;
+    marginBottom: number;
+}
+interface Padding {
+    paddingLeft: number;
+    paddingTop: number;
+    paddingRight: number;
+    paddingBottom: number;
+}
+interface Offset {
+    offsetLeft: number;
+    offsetTop: number;
+    offsetRight: number;
+    offsetBottom: number;
+}
+/**
+ * line type
+ */
+type LineType = 'dashed' | 'solid';
+interface LineStyle {
+    style: LineType;
+    size: number;
+    color: string;
+    dashedValue: number[];
+}
+interface SmoothLineStyle extends LineStyle {
+    smooth: boolean | number;
+    show?: boolean;
+}
+interface StateLineStyle extends LineStyle {
+    show: boolean;
+}
+type PathType = 'stroke' | 'fill';
+interface PathStyle {
+    style: PathType;
+    color: string;
+    lineWidth: number;
+}
+type PolygonType = PathType | 'stroke_fill';
+interface PolygonStyle {
+    style: PolygonType;
+    color: string | CanvasGradient;
+    borderColor: string;
+    borderSize: number;
+    borderStyle: LineType;
+    borderDashedValue: number[];
+}
+interface RectStyle extends PolygonStyle {
+    borderRadius: number | number[];
+}
+interface TextStyle extends Padding {
+    style: PolygonType;
+    color: string;
+    size: number;
+    family: string;
+    weight: number | string;
+    borderStyle: LineType;
+    borderDashedValue: number[];
+    borderSize: number;
+    borderColor: string;
+    borderRadius: number | number[];
+    backgroundColor: string | CanvasGradient;
+}
+interface StateTextStyle extends TextStyle {
+    show: boolean;
+}
+type LastValueMarkTextStyle = Omit<StateTextStyle, 'backgroundColor'>;
+type TooltipShowRule = 'always' | 'follow_cross' | 'none';
+type TooltipShowType = 'standard' | 'rect';
+interface ChangeColor {
+    upColor: string;
+    downColor: string;
+    noChangeColor: string;
+}
+interface GradientColor {
+    offset: number;
+    color: string;
+}
+type FeatureType = 'path' | 'icon_font';
+interface FeaturePathStyle extends Omit<PathStyle, 'color'> {
+    path: string;
+}
+interface FeatureIconFontStyle {
+    family: string;
+    code: string;
+}
+interface FeatureStyle extends Padding, Margin {
+    id: string;
+    backgroundColor: string;
+    activeBackgroundColor: string;
+    size: number;
+    color: string;
+    activeColor: string;
+    borderRadius: number | number[];
+    type: FeatureType;
+    content: FeaturePathStyle | FeatureIconFontStyle;
+}
+interface GridStyle {
+    show: boolean;
+    horizontal: StateLineStyle;
+    vertical: StateLineStyle;
+}
+type TooltipTextStyle = Pick<TextStyle, 'color' | 'size' | 'family' | 'weight'> & Margin;
+type TooltipTitleStyle = TooltipTextStyle & {
+    show: boolean;
+};
+type TooltipLegendStyle = TooltipTextStyle & {
+    defaultValue: string;
+};
+interface TooltipLegendChild {
+    text: string;
+    color: string;
+}
+interface TooltipLegend {
+    title: string | TooltipLegendChild;
+    value: string | TooltipLegendChild;
+}
+type TooltipFeaturePosition = 'left' | 'middle' | 'right';
+interface TooltipFeatureStyle extends FeatureStyle {
+    position: TooltipFeaturePosition;
+}
+interface TooltipStyle extends Offset {
+    showRule: TooltipShowRule;
+    showType: TooltipShowType;
+    features: TooltipFeatureStyle[];
+}
+interface CandleAreaPointStyle {
+    show: boolean;
+    color: string;
+    radius: number;
+    rippleColor: string;
+    rippleRadius: number;
+    animation: boolean;
+    animationDuration: number;
+}
+interface CandleAreaStyle {
+    lineSize: number;
+    lineColor: string;
+    value: string;
+    smooth: boolean;
+    backgroundColor: string | GradientColor[];
+    point: CandleAreaPointStyle;
+}
+interface CandleHighLowPriceMarkStyle {
+    show: boolean;
+    color: string;
+    textOffset: number;
+    textSize: number;
+    textFamily: string;
+    textWeight: string;
+}
+type CandleLastPriceMarkLineStyle = Omit<StateLineStyle, 'color'>;
+type CandleLastPriceMarkExtendTextPosition = 'above_price' | 'below_price';
+type CandleLastPriceMarkExtendTextStyle = LastValueMarkTextStyle & {
+    position: CandleLastPriceMarkExtendTextPosition;
+    updateInterval: number;
+};
+interface CandleLastPriceMarkStyle extends ChangeColor {
+    show: boolean;
+    compareRule: CandleColorCompareRule;
+    line: CandleLastPriceMarkLineStyle;
+    text: LastValueMarkTextStyle;
+    extendTexts: CandleLastPriceMarkExtendTextStyle[];
+}
+interface CandlePriceMarkStyle {
+    show: boolean;
+    high: CandleHighLowPriceMarkStyle;
+    low: CandleHighLowPriceMarkStyle;
+    last: CandleLastPriceMarkStyle;
+}
+type CandleTooltipRectPosition = 'fixed' | 'pointer';
+interface CandleTooltipRectStyle extends Omit<RectStyle, 'style' | 'borderDashedValue' | 'borderStyle'>, Padding, Offset {
+    position: CandleTooltipRectPosition;
+}
+type CandleTooltipLegendsCustomCallback = (data: NeighborData<Nullable<CandleData>>, styles: CandleStyle) => TooltipLegend[];
+interface CandleTooltipStyle extends TooltipStyle {
+    title: TooltipTitleStyle & {
+        template: string;
+    };
+    legend: TooltipLegendStyle & {
+        template: CandleTooltipLegendsCustomCallback | TooltipLegend[];
+    };
+    rect: CandleTooltipRectStyle;
+}
+type CandleType = 'candle_solid' | 'candle_stroke' | 'candle_up_stroke' | 'candle_down_stroke' | 'ohlc' | 'area';
+type CandleColorCompareRule = 'current_open' | 'previous_close';
+interface CandleBarColor extends ChangeColor {
+    compareRule: CandleColorCompareRule;
+    upBorderColor: string;
+    downBorderColor: string;
+    noChangeBorderColor: string;
+    upWickColor: string;
+    downWickColor: string;
+    noChangeWickColor: string;
+}
+interface CandleStyle {
+    type: CandleType;
+    bar: CandleBarColor;
+    area: CandleAreaStyle;
+    priceMark: CandlePriceMarkStyle;
+    tooltip: CandleTooltipStyle;
+}
+type IndicatorPolygonStyle = Omit<PolygonStyle, 'color' | 'borderColor'> & ChangeColor;
+interface IndicatorLastValueMarkStyle {
+    show: boolean;
+    text: LastValueMarkTextStyle;
+}
+interface IndicatorTooltipStyle extends TooltipStyle {
+    title: TooltipTitleStyle & {
+        showName: boolean;
+        showParams: boolean;
+    };
+    legend: TooltipLegendStyle;
+}
+interface IndicatorStyle {
+    ohlc: Pick<CandleBarColor, 'compareRule' | 'upColor' | 'downColor' | 'noChangeColor'>;
+    bars: IndicatorPolygonStyle[];
+    lines: SmoothLineStyle[];
+    circles: IndicatorPolygonStyle[];
+    lastValueMark: IndicatorLastValueMarkStyle;
+    tooltip: IndicatorTooltipStyle;
+    [key: string]: unknown;
+}
+type AxisLineStyle = Omit<StateLineStyle, 'style' | 'dashedValue'>;
+interface AxisTickLineStyle extends AxisLineStyle {
+    length: number;
+}
+interface AxisTickTextStyle extends Pick<StateTextStyle, 'show' | 'color' | 'weight' | 'family' | 'size'> {
+    marginStart: number;
+    marginEnd: number;
+}
+interface AxisStyle {
+    show: boolean;
+    size: number | 'auto';
+    axisLine: AxisLineStyle;
+    tickLine: AxisTickLineStyle;
+    tickText: AxisTickTextStyle;
+}
+interface CrosshairDirectionStyle {
+    show: boolean;
+    line: StateLineStyle;
+    text: StateTextStyle;
+}
+interface CrosshairStyle {
+    show: boolean;
+    horizontal: CrosshairDirectionStyle & {
+        features: TooltipFeatureStyle[];
+    };
+    vertical: CrosshairDirectionStyle;
+}
+interface OverlayPointStyle {
+    color: string;
+    borderColor: string;
+    borderSize: number;
+    radius: number;
+    activeColor: string;
+    activeBorderColor: string;
+    activeBorderSize: number;
+    activeRadius: number;
+}
+interface OverlayStyle {
+    point: OverlayPointStyle;
+    line: SmoothLineStyle;
+    rect: RectStyle;
+    polygon: PolygonStyle;
+    circle: PolygonStyle;
+    arc: LineStyle;
+    text: TextStyle;
+    [key: string]: unknown;
+}
+interface SeparatorStyle {
+    size: number;
+    color: string;
+    fill: boolean;
+    activeBackgroundColor: string;
+}
+interface Styles {
+    grid: GridStyle;
+    candle: CandleStyle;
+    indicator: IndicatorStyle;
+    xAxis: AxisStyle;
+    yAxis: AxisStyle;
+    separator: SeparatorStyle;
+    crosshair: CrosshairStyle;
+    overlay: OverlayStyle;
+}
+
+type Price = number & {
+    readonly _brand: 'Price';
+};
+type Volume = number & {
+    readonly _brand: 'Volume';
+};
+type Timestamp = number & {
+    readonly _brand: 'Timestamp';
+};
+interface IndicatorDef {
+    name: string;
+    calcParams?: number[];
+}
+/** Canonical timespan identifiers — aligned with engine PeriodType */
+type Timespan = 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+interface SymbolInfo {
+    ticker: string;
+    name?: string;
+    shortName?: string;
+    exchange?: string;
+    market?: string;
+    pricePrecision?: number;
+    volumePrecision?: number;
+    priceCurrency?: string;
+    type?: string;
+    logo?: string;
+    [key: string]: unknown;
+}
+interface Period {
+    multiplier: number;
+    /** Canonical timespan — maps directly to engine PeriodType */
+    timespan: Timespan;
+    text: string;
+}
+type DatafeedSubscribeCallback = (data: CandleData) => void;
+interface Datafeed {
+    searchSymbols(search?: string): Promise<SymbolInfo[]>;
+    getHistoryData(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<CandleData[]>;
+    subscribe(symbol: SymbolInfo, period: Period, callback: DatafeedSubscribeCallback): void;
+    unsubscribe(symbol: SymbolInfo, period: Period): void;
+}
+interface AstroneumOptions {
+    styles?: DeepPartial<Styles>;
+    watermark?: string | Node;
+    theme?: string;
+    locale?: string;
+    drawingBarVisible?: boolean;
+    symbol: SymbolInfo;
+    period: Period;
+    periods?: Period[];
+    timezone?: string;
+    mainIndicators?: IndicatorDef[];
+    subIndicators?: string[];
+    plugins?: ChartPlugin[];
+    datafeed: Datafeed;
+    /** Inline styles applied to the root `.astroneum` container element. */
+    style?: react__default.CSSProperties;
+    /** Additional class names applied to the root `.astroneum` container element. */
+    className?: string;
+    /**
+     * Make the chart canvas focusable + emit an `aria-live` summary of the
+     * crosshair OHLCV. Off by default to avoid surprising existing apps.
+     * When `true`, the chart container gets `tabindex=0`, `role="img"`,
+     * and an `aria-label` describing the current symbol. Cursor moves
+     * announce OHLCV through a visually-hidden polite live region.
+     */
+    accessible?: boolean;
+    /**
+     * Optional ARIA label override for the chart canvas. Only used when
+     * `accessible` is true. Defaults to a string built from the symbol
+     * ticker and current period.
+     */
+    ariaLabel?: string;
+    /**
+     * Bar rendering style. Defaults to 'candle' (standard candlesticks).
+     * 'heikin_ashi' transforms OHLC data with the Heikin-Ashi formula
+     * before rendering — no datafeed changes required.
+     */
+    barStyle?: 'candle' | 'heikin_ashi';
+    /**
+     * Price axis scale mode. Defaults to 'linear' (absolute price).
+     * 'log' uses logarithmic scale (useful for long-term charts).
+     * 'percent' shows percentage change from the first visible bar.
+     */
+    priceScale?: 'linear' | 'log' | 'percent';
+    initialHistory?: 'all' | 'none';
+}
+/**
+ * Serialised chart state — drawings, indicators, and the user-facing
+ * surface settings (theme, locale, timezone, symbol, period, styles).
+ *
+ * The shape is intentionally simple JSON so it can be persisted to
+ * `localStorage`, a URL, or a backend. The `version` field lets the
+ * library evolve the format without breaking older payloads.
+ */
+interface SerializedChartState {
+    version: 1;
+    theme: string;
+    locale: string;
+    timezone: string;
+    symbol: SymbolInfo;
+    period: Period;
+    styles: DeepPartial<Styles>;
+    mainIndicators: IndicatorDef[];
+    subIndicators: string[];
+    overlays: Array<{
+        name: string;
+        points?: ReadonlyArray<{
+            timestamp?: number;
+            value?: number;
+            dataIndex?: number;
+        }>;
+        styles?: unknown;
+        lock?: boolean;
+        visible?: boolean;
+    }>;
+}
+interface AstroneumHandle {
+    setTheme(theme: string): void;
+    getTheme(): string;
+    setStyles(styles: DeepPartial<Styles>): void;
+    getStyles(): Styles;
+    setLocale(locale: string): void;
+    getLocale(): string;
+    setTimezone(timezone: string): void;
+    getTimezone(): string;
+    setSymbol(symbol: SymbolInfo): void;
+    getSymbol(): SymbolInfo;
+    setPeriod(period: Period): void;
+    getPeriod(): Period;
+    getDataListLength(): number;
+    getLastDataTimestamp(): number | null;
+    /**
+     * Capture the chart's current user-visible state as a JSON-safe object.
+     * Includes theme, locale, timezone, symbol, period, styles, indicators,
+     * and drawing overlays. Pair with `loadState()` to restore.
+     */
+    serializeState(): SerializedChartState;
+    /**
+     * Restore a previously-captured state. Best-effort: missing or unknown
+     * indicator / overlay names are silently skipped, matching the engine's
+     * behaviour for unregistered names.
+     */
+    loadState(state: SerializedChartState): void;
+    /**
+     * Subscribe to crosshair moves. Returns an unsubscribe function.
+     * Callback receives the crosshair data (or null when it leaves the chart).
+     * Returns a Coordinate-like object with the timestamp + price at cursor.
+     */
+    onCrosshairMove(callback: (data: unknown) => void): () => void;
+    /**
+     * Programmatically set the crosshair position on this chart.
+     * Used internally by MultiChartLayout for crosshair sync.
+     */
+    setCrosshair(data: unknown): void;
+    /** Lock or unlock ALL drawing overlays at once. */
+    lockAllDrawings(locked: boolean): void;
+    createIndicator(value: string | IndicatorCreate, isStack?: boolean, paneOptions?: PaneOptions): Nullable<string>;
+    removeIndicator(filter?: IndicatorFilter): boolean;
+    createOverlay(value: string | OverlayCreate | Array<string | OverlayCreate>): Nullable<string> | Array<Nullable<string>>;
+    removeOverlay(filter?: OverlayFilter): boolean;
+    getDataList(): CandleData[];
+    resetData(): void;
+    resize(): void;
+}
+interface Viewport {
+    /** Minimum (bottom) visible price in canvas coordinates. */
+    priceMin: Price;
+    /** Maximum (top) visible price in canvas coordinates. */
+    priceMax: Price;
+    /** Earliest visible candle timestamp (ms). */
+    timeMin: Timestamp;
+    /** Latest visible candle timestamp (ms). */
+    timeMax: Timestamp;
+    /** Physical canvas resolution [width, height] in device pixels. */
+    resolution: readonly [width: number, height: number];
+}
+interface IndicatorPlugin<TOutput> {
+    /** Unique registry name — used as the indicator identifier in the engine. */
+    name: string;
+    /** Short display name shown in the chart legend. */
+    shortName?: string;
+    /** Default calculation parameters (can be overridden by the user). */
+    calcParams?: number[];
+    /**
+     * Pure calculation function. Must NOT mutate `data`.
+     * Called on every data update; keep it fast (O(n) or better).
+     */
+    calc(data: CandleData[], params: number[]): TOutput[];
+    /** Canvas 2D renderer — for lightweight overlays and small datasets. */
+    render2D?(ctx: CanvasRenderingContext2D, output: TOutput[], viewport: Viewport): void;
+    /**
+     * WebGL2 renderer — for high-density or GPU-accelerated rendering.
+     * Astroneum reuses a stable per-indicator vbo and falls back to render2D when WebGL2 is unavailable.
+     */
+    renderGL?(gl: WebGL2RenderingContext, output: TOutput[], viewport: Viewport, vbo: WebGLBuffer): void;
+}
+interface ChartPluginContext {
+    /** The chart instance mounted by Astroneum. */
+    chart: Chart;
+    /** Register a typed indicator plugin at runtime. */
+    registerIndicatorPlugin: (plugin: IndicatorPlugin<unknown>) => void;
+    /** Batch register typed indicator plugins at runtime. */
+    registerIndicatorPlugins: (plugins: ReadonlyArray<IndicatorPlugin<unknown>>) => void;
+}
+interface ChartPlugin {
+    /** Optional plugin label for diagnostics and debugging. */
+    name?: string;
+    /** Indicator plugins to register before this chart starts creating indicators. */
+    indicators?: ReadonlyArray<IndicatorPlugin<unknown>>;
+    /** Optional lifecycle hook called once after the chart is initialized. */
+    onInit?: (context: ChartPluginContext) => void | (() => void);
+}
+interface ChartEventMap {
+    /** Fired when the active symbol changes. */
+    'symbol-change': SymbolInfo;
+    /** Fired when the active period / timeframe changes. */
+    'period-change': Period;
+    /** Fired on every crosshair move; null when the crosshair leaves the chart. */
+    'crosshair-move': Coordinate | null;
+    /** Fired when the user zooms the chart. */
+    'zoom': {
+        scale: number;
+        anchor: ZoomAnchor;
+    };
+    /** Fired when a historical data batch is loaded. */
+    'data-load': {
+        type: 'init' | 'forward' | 'backward';
+        count: number;
+    };
+    /** Fired when a real-time tick arrives from the datafeed subscription. */
+    'tick': CandleData;
+    /** Fired when the user starts drawing an overlay (value = overlay type name). */
+    'drawing-start': string;
+    /** Fired when the user finishes drawing (value = overlay id). */
+    'drawing-end': string;
+    /** Fired when the active theme changes (value = theme name). */
+    'theme-change': string;
+}
+
+type DataLoadType = 'init' | 'forward' | 'backward' | 'update';
+type DataLoadMore = boolean | {
+    backward?: boolean;
+    forward?: boolean;
+};
+interface DataLoaderGetBarsParams {
+    type: DataLoadType;
+    timestamp: Nullable<number>;
+    symbol: SymbolInfo;
+    period: Period;
+    callback: (data: CandleData[], more?: DataLoadMore) => void;
+}
+interface DataLoaderSubscribeBarParams {
+    symbol: SymbolInfo;
+    period: Period;
+    callback: (data: CandleData) => void;
+}
+type DataLoaderUnsubscribeBarParams = Omit<DataLoaderSubscribeBarParams, 'callback'>;
+interface DataLoader {
+    getBars: (params: DataLoaderGetBarsParams) => void | Promise<void>;
+    subscribeBar?: (params: DataLoaderSubscribeBarParams) => void;
+    unsubscribeBar?: (params: DataLoaderUnsubscribeBarParams) => void;
+}
+
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer X> ? ReadonlyArray<DeepPartial<X>> : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+interface Coordinate {
+    x: number;
+    y: number;
+}
+
+interface Bounding {
+    width: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+
+type ActionCallback = (data?: unknown) => void;
+type ActionType = 'onZoom' | 'onScroll' | 'onVisibleRangeChange' | 'onCandleTooltipFeatureClick' | 'onIndicatorTooltipFeatureClick' | 'onCrosshairFeatureClick' | 'onCrosshairChange' | 'onCandleBarClick' | 'onPaneDrag';
+
+type PickRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+
+type ExcludePickPartial<T, K extends keyof T> = PickRequired<Partial<T>, K>;
+
+interface BarSpace {
+    bar: number;
+    halfBar: number;
+    gapBar: number;
+    halfGapBar: number;
+}
+
+interface Crosshair extends Partial<Coordinate> {
+    paneId?: string;
+    realX?: number;
+    timestamp?: number;
+    candleData?: CandleData;
+    dataIndex?: number;
+    realDataIndex?: number;
+}
+
+interface VisibleRange {
+    readonly from: number;
+    readonly to: number;
+    readonly realFrom: number;
+    readonly realTo: number;
+}
+
+/**
+ * This file uses most of the logic of lightweight-charts/mouse-event-handler.ts(https://github.com/tradingview/lightweight-charts) for reference.
+ * Makes some modifications to add some events.
+ * The use of the source code of this file is also subject to the terms
+ * and consitions of the license of "lightweight-charts" (Apache License V2, see
+ * </licenses/LICENSE-lightweight-charts>).
+ */
+
+interface MouseTouchEvent extends Coordinate {
+    pageX: number;
+    pageY: number;
+    isTouch?: boolean;
+    preventDefault?: () => void;
+}
+
+type PickPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+interface Point {
+    dataIndex: number;
+    timestamp: number;
+    value: number;
+}
+
+type PaneState = 'normal' | 'maximize' | 'minimize';
+interface PaneOptions {
+    id?: string;
+    height?: number;
+    minHeight?: number;
+    dragEnabled?: boolean;
+    order?: number;
+    state?: PaneState;
+    axis?: Partial<AxisCreate>;
+}
+
+type FormatDateType = 'tooltip' | 'crosshair' | 'xAxis';
+interface FormatDateParams {
+    dateTimeFormat: Intl.DateTimeFormat;
+    timestamp: number;
+    template: string;
+    type: FormatDateType;
+}
+type FormatDate = (params: FormatDateParams) => string;
+type FormatBigNumber = (value: string | number) => string;
+type ExtendTextType = 'last_price';
+interface FormatExtendTextParams {
+    type: ExtendTextType;
+    data: CandleData;
+    index: number;
+}
+type FormatExtendText = (params: FormatExtendTextParams) => string;
+interface Formatter {
+    formatDate: FormatDate;
+    formatBigNumber: FormatBigNumber;
+    formatExtendText: FormatExtendText;
+}
+interface DecimalFold {
+    threshold: number;
+    format: (value: string | number) => string;
+}
+interface ThousandsSeparator {
+    sign: string;
+    format: (value: string | number) => string;
+}
+type ZoomAnchorType = 'cursor' | 'last_bar';
+interface ZoomAnchor {
+    main: ZoomAnchorType;
+    xAxis: ZoomAnchorType;
+}
+
+interface YAxisTemplate extends AxisTemplate {
+    /**
+     * Y-axis scale smoothing time in seconds.
+     * Larger value = longer/softer scaling, smaller value = shorter/tighter scaling.
+     */
+    scaleSmoothTime?: number;
+    /**
+     * MT4-style scale stabilization deadband in pixels.
+     * Tiny auto-range shifts under this threshold are ignored.
+     */
+    scaleDeadbandPx?: number;
+    /**
+     * Portion of under-deadband movement that still passes through.
+     * 0 = fully hold (step-like), 1 = no hold.
+     */
+    scaleDeadbandLeak?: number;
+}
+interface YAxis extends Axis, Required<YAxisTemplate> {
+    isFromZero: () => boolean;
+    isInCandle: () => boolean;
+    convertToNicePixel: (value: number) => number;
+    getDisplayRange: () => {
+        realFrom: number;
+        realTo: number;
+    };
+}
+
+type OverlayMode = 'normal' | 'weak_magnet' | 'strong_magnet';
+interface OverlayPerformEventParams {
+    currentStep: number;
+    mode: OverlayMode;
+    points: Array<Partial<Point>>;
+    performPointIndex: number;
+    performPoint: Partial<Point>;
+}
+interface OverlayEventCollection<E> {
+    onDrawStart: Nullable<OverlayEventCallback<E>>;
+    onDrawing: Nullable<OverlayEventCallback<E>>;
+    onDrawEnd: Nullable<OverlayEventCallback<E>>;
+    onRemoved: Nullable<OverlayEventCallback<E>>;
+    onClick: Nullable<OverlayEventCallback<E>>;
+    onDoubleClick: Nullable<OverlayEventCallback<E>>;
+    onRightClick: Nullable<OverlayEventCallback<E>>;
+    onPressedMoveStart: Nullable<OverlayEventCallback<E>>;
+    onPressedMoving: Nullable<OverlayEventCallback<E>>;
+    onPressedMoveEnd: Nullable<OverlayEventCallback<E>>;
+    onMouseMove: Nullable<OverlayEventCallback<E>>;
+    onMouseEnter: Nullable<OverlayEventCallback<E>>;
+    onMouseLeave: Nullable<OverlayEventCallback<E>>;
+    onSelected: Nullable<OverlayEventCallback<E>>;
+    onDeselected: Nullable<OverlayEventCallback<E>>;
+}
+interface OverlayFigure {
+    key?: string;
+    type: string;
+    attrs: unknown;
+    styles?: unknown;
+    ignoreEvent?: boolean | Array<keyof Omit<OverlayEventCollection<unknown>, 'onDrawStart' | 'onDrawing' | 'onDrawEnd' | 'onRemoved'>>;
+}
+interface OverlayCreateFiguresCallbackParams<E> {
+    chart: Chart;
+    overlay: Overlay<E>;
+    coordinates: Coordinate[];
+    bounding: Bounding;
+    xAxis: Nullable<XAxis>;
+    yAxis: Nullable<YAxis>;
+}
+interface OverlayEvent<E> extends Partial<MouseTouchEvent> {
+    figure?: OverlayFigure;
+    overlay: Overlay<E>;
+    chart: Chart;
+}
+type OverlayEventCallback<E> = (event: OverlayEvent<E>) => void;
+type OverlayCreateFiguresCallback<E> = (params: OverlayCreateFiguresCallbackParams<E>) => OverlayFigure | OverlayFigure[];
+interface Overlay<E = unknown> extends OverlayEventCollection<E> {
+    /**
+     * Unique identification
+     */
+    id: string;
+    /**
+     * Group id
+     */
+    groupId: string;
+    /**
+     * Pane id
+     */
+    paneId: string;
+    /**
+     * Name
+     */
+    name: string;
+    /**
+     * Total number of steps required to complete mouse operation
+     */
+    totalStep: number;
+    /**
+     * Current step
+     */
+    currentStep: number;
+    /**
+     * Whether it is locked. When it is true, it will not respond to events
+     */
+    lock: boolean;
+    /**
+     * Whether the overlay is visible
+     */
+    visible: boolean;
+    /**
+     * Draw level
+     */
+    zLevel: number;
+    /**
+     * Whether the default figure corresponding to the point is required
+     */
+    needDefaultPointFigure: boolean;
+    /**
+     * Whether the default figure on the Y axis is required
+     */
+    needDefaultXAxisFigure: boolean;
+    /**
+     * Whether the default figure on the X axis is required
+     */
+    needDefaultYAxisFigure: boolean;
+    /**
+     * Mode
+     */
+    mode: OverlayMode;
+    /**
+     * When mode is weak_magnet is the response distance
+     */
+    modeSensitivity: number;
+    /**
+     * Time and value information
+     */
+    points: Array<Partial<Point>>;
+    /**
+     * Extended Data
+     */
+    extendData: E;
+    /**
+     * The style information and format are consistent with the overlay in the unified configuration
+     */
+    styles: Nullable<DeepPartial<OverlayStyle>>;
+    /**
+     * Create figures corresponding to points
+     */
+    createPointFigures: Nullable<OverlayCreateFiguresCallback<E>>;
+    /**
+     * Create figures on the Y axis
+     */
+    createXAxisFigures: Nullable<OverlayCreateFiguresCallback<E>>;
+    /**
+     * Create figures on the X axis
+     */
+    createYAxisFigures: Nullable<OverlayCreateFiguresCallback<E>>;
+    /**
+     * Special handling callbacks when pressing events
+     */
+    performEventPressedMove: Nullable<(params: OverlayPerformEventParams) => void>;
+    /**
+     * In drawing, special handling callback when moving events
+     */
+    performEventMoveForDrawing: Nullable<(params: OverlayPerformEventParams) => void>;
+}
+type OverlayTemplate<E = unknown> = ExcludePickPartial<Omit<Overlay<E>, 'id' | 'groupId' | 'paneId' | 'points' | 'currentStep'>, 'name'>;
+type OverlayCreate<E = unknown> = ExcludePickPartial<Omit<Overlay<E>, 'currentStep' | 'totalStep' | 'createPointFigures' | 'createXAxisFigures' | 'createYAxisFigures' | 'performEventPressedMove' | 'performEventMoveForDrawing'>, 'name'>;
+type OverlayFilter<E = unknown> = Partial<Pick<Overlay<E>, 'id' | 'groupId' | 'name' | 'paneId'>>;
+
+interface Store {
+    setStyles: (value: string | DeepPartial<Styles>) => void;
+    getStyles: () => Styles;
+    setFormatter: (formatter: Partial<Formatter>) => void;
+    getFormatter: () => Formatter;
+    setLocale: (locale: string) => void;
+    getLocale: () => string;
+    setTimezone: (timezone: string) => void;
+    getTimezone: () => string;
+    setThousandsSeparator: (thousandsSeparator: Partial<ThousandsSeparator>) => void;
+    getThousandsSeparator: () => ThousandsSeparator;
+    setDecimalFold: (decimalFold: Partial<DecimalFold>) => void;
+    getDecimalFold: () => DecimalFold;
+    setSymbol: (symbol: PickPartial<SymbolInfo, 'pricePrecision' | 'volumePrecision'>) => void;
+    getSymbol: () => Nullable<SymbolInfo>;
+    setPeriod: (period: Period) => void;
+    getPeriod: () => Nullable<Period>;
+    getDataList: () => CandleData[];
+    setOffsetRightDistance: (distance: number) => void;
+    getOffsetRightDistance: () => number;
+    setMaxOffsetLeftDistance: (distance: number) => void;
+    setMaxOffsetRightDistance: (distance: number) => void;
+    setLeftMinVisibleBarCount: (barCount: number) => void;
+    setRightMinVisibleBarCount: (barCount: number) => void;
+    setBarSpace: (space: number) => void;
+    getBarSpace: () => BarSpace;
+    getVisibleRange: () => VisibleRange;
+    setDataLoader: (dataLoader: DataLoader) => void;
+    overrideIndicator: (override: IndicatorCreate) => boolean;
+    removeIndicator: (filter?: IndicatorFilter) => boolean;
+    overrideOverlay: (override: Partial<OverlayCreate>) => boolean;
+    removeOverlay: (filter?: OverlayFilter) => boolean;
+    setZoomEnabled: (enabled: boolean) => void;
+    isZoomEnabled: () => boolean;
+    setZoomAnchor: (behavior: ZoomAnchor) => void;
+    getZoomAnchor: () => ZoomAnchor;
+    setScrollEnabled: (enabled: boolean) => void;
+    isScrollEnabled: () => boolean;
+    resetData: () => void;
+}
+
+type DomPosition = 'root' | 'main' | 'yAxis';
+interface ConvertFilter {
+    paneId?: string;
+    absolute?: boolean;
+}
+interface Chart extends Store {
+    id: string;
+    getDom: (paneId?: string, position?: DomPosition) => Nullable<HTMLElement>;
+    getSize: (paneId?: string, position?: DomPosition) => Nullable<Bounding>;
+    createIndicator: (value: string | IndicatorCreate, isStack?: boolean, paneOptions?: PaneOptions) => Nullable<string>;
+    getIndicators: (filter?: IndicatorFilter) => Indicator[];
+    createOverlay: (value: string | OverlayCreate | Array<string | OverlayCreate>) => Nullable<string> | Array<Nullable<string>>;
+    getOverlays: (filter?: OverlayFilter) => Overlay[];
+    setPaneOptions: (options: PaneOptions) => void;
+    getPaneOptions: (id?: string) => Nullable<PaneOptions> | PaneOptions[];
+    scrollByDistance: (distance: number, animationDuration?: number) => void;
+    scrollToRealTime: (animationDuration?: number) => void;
+    scrollToDataIndex: (dataIndex: number, animationDuration?: number) => void;
+    scrollToTimestamp: (timestamp: number, animationDuration?: number) => void;
+    zoomAtCoordinate: (scale: number, coordinate?: Coordinate, animationDuration?: number) => void;
+    zoomAtDataIndex: (scale: number, dataIndex: number, animationDuration?: number) => void;
+    zoomAtTimestamp: (scale: number, timestamp: number, animationDuration?: number) => void;
+    convertToPixel: (points: Partial<Point> | Array<Partial<Point>>, filter?: ConvertFilter) => Partial<Coordinate> | Array<Partial<Coordinate>>;
+    convertFromPixel: (coordinates: Array<Partial<Coordinate>>, filter?: ConvertFilter) => Partial<Point> | Array<Partial<Point>>;
+    executeAction: (type: ActionType, data: Crosshair) => void;
+    subscribeAction: (type: ActionType, callback: ActionCallback) => void;
+    unsubscribeAction: (type: ActionType, callback?: ActionCallback) => void;
+    getConvertPictureUrl: (includeOverlay?: boolean, type?: 'png' | 'jpeg' | 'bmp', backgroundColor?: string) => string;
+    resize: () => void;
+}
+
+interface AxisTick {
+    coord: number;
+    value: number | string;
+    text: string;
+}
+interface AxisRange extends VisibleRange {
+    readonly range: number;
+    readonly realRange: number;
+    readonly displayFrom: number;
+    readonly displayTo: number;
+    readonly displayRange: number;
+}
+interface AxisGap {
+    top?: number;
+    bottom?: number;
+}
+type AxisPosition = 'left' | 'right';
+interface AxisValueToValueParams {
+    range: AxisRange;
+}
+type AxisValueToValueCallback = (value: number, params: AxisValueToValueParams) => number;
+interface AxisCreateRangeParams {
+    chart: Chart;
+    paneId: string;
+    defaultRange: AxisRange;
+}
+type AxisCreateRangeCallback = (params: AxisCreateRangeParams) => AxisRange;
+interface AxisCreateTicksParams {
+    range: AxisRange;
+    bounding: Bounding;
+    defaultTicks: AxisTick[];
+}
+type AxisCreateTicksCallback = (params: AxisCreateTicksParams) => AxisTick[];
+type AxisMinSpanCallback = (value: number) => number;
+interface AxisTemplate {
+    name: string;
+    reverse?: boolean;
+    inside?: boolean;
+    position?: AxisPosition;
+    scrollZoomEnabled?: boolean;
+    gap?: AxisGap;
+    valueToRealValue?: AxisValueToValueCallback;
+    realValueToDisplayValue?: AxisValueToValueCallback;
+    displayValueToRealValue?: AxisValueToValueCallback;
+    realValueToValue?: AxisValueToValueCallback;
+    displayValueToText?: (value: number, precision: number) => string;
+    minSpan?: AxisMinSpanCallback;
+    createRange?: AxisCreateRangeCallback;
+    createTicks?: AxisCreateTicksCallback;
+}
+interface Axis {
+    override: (axis: AxisTemplate) => void;
+    getTicks: () => AxisTick[];
+    getRange: () => AxisRange;
+    getAutoSize: () => number;
+    convertToPixel: (value: number) => number;
+    convertFromPixel: (px: number) => number;
+}
+type AxisCreate = Omit<AxisTemplate, 'displayValueToText' | 'valueToRealValue' | 'realValueToDisplayValue' | 'displayValueToRealValue' | 'realValueToValue'>;
+
+type XAxisTemplate = Pick<AxisTemplate, 'name' | 'scrollZoomEnabled' | 'createTicks'>;
+interface XAxis extends Axis, Required<XAxisTemplate> {
+    convertTimestampFromPixel: (pixel: number) => Nullable<number>;
+    convertTimestampToPixel: (timestamp: number) => number;
+}
+
+interface CircleAttrs {
+    x: number;
+    y: number;
+    r: number;
+}
+
+interface ArcAttrs extends CircleAttrs {
+    startAngle: number;
+    endAngle: number;
+}
+
+interface RectAttrs {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+interface TextAttrs {
+    x: number;
+    y: number;
+    text: string;
+    width?: number;
+    height?: number;
+    align?: CanvasTextAlign;
+    baseline?: CanvasTextBaseline;
+}
+
+type IndicatorSeries = 'normal' | 'price' | 'volume';
+type IndicatorFigureStyle = Partial<Omit<SmoothLineStyle, 'style'>> & Partial<Omit<RectStyle, 'style'>> & Partial<TextStyle> & Partial<{
+    style: LineType[keyof LineType];
+}> & Record<string, unknown>;
+type IndicatorFigureAttrs = Partial<ArcAttrs> & Partial<LineStyle> & Partial<RectAttrs> & Partial<TextAttrs> & Record<string, unknown>;
+interface IndicatorFigureAttrsCallbackParams<D> {
+    data: NeighborData<Nullable<D>>;
+    coordinate: NeighborData<Record<keyof D, number> & {
+        x: number;
+    }>;
+    bounding: Bounding;
+    barSpace: BarSpace;
+    xAxis: XAxis;
+    yAxis: YAxis;
+}
+interface IndicatorFigureStylesCallbackParams<D> {
+    data: NeighborData<Nullable<D>>;
+    indicator: Indicator<D>;
+    defaultStyles?: IndicatorStyle;
+}
+type IndicatorFigureAttrsCallback<D> = (params: IndicatorFigureAttrsCallbackParams<D>) => IndicatorFigureAttrs;
+type IndicatorFigureStylesCallback<D> = (params: IndicatorFigureStylesCallbackParams<D>) => IndicatorFigureStyle;
+interface IndicatorFigure<D = unknown> {
+    key: string;
+    title?: string;
+    type?: string;
+    baseValue?: number;
+    attrs?: IndicatorFigureAttrsCallback<D>;
+    styles?: IndicatorFigureStylesCallback<D>;
+}
+type IndicatorRegenerateFiguresCallback<D, C> = (calcParams: C[]) => Array<IndicatorFigure<D>>;
+interface IndicatorTooltipData {
+    name: string;
+    calcParamsText: string;
+    features: TooltipFeatureStyle[];
+    legends: TooltipLegend[];
+}
+interface IndicatorCreateTooltipDataSourceParams<D> {
+    chart: Chart;
+    indicator: Indicator<D>;
+    bounding: Bounding;
+    crosshair: Crosshair;
+    xAxis: XAxis;
+    yAxis: YAxis;
+}
+type IndicatorCreateTooltipDataSourceCallback<D> = (params: IndicatorCreateTooltipDataSourceParams<D>) => Partial<IndicatorTooltipData>;
+interface IndicatorDrawParams<D, C, E> {
+    ctx: CanvasRenderingContext2D;
+    chart: Chart;
+    indicator: Indicator<D, C, E>;
+    bounding: Bounding;
+    xAxis: XAxis;
+    yAxis: YAxis;
+}
+type IndicatorDrawCallback<D, C, E> = (params: IndicatorDrawParams<D, C, E>) => boolean;
+type IndicatorCalcCallback<D, C, E> = (dataList: CandleData[], indicator: Indicator<D, C, E>) => Promise<D[]> | D[];
+type IndicatorShouldUpdateCallback<D, C, E> = (prev: Indicator<D, C, E>, current: Indicator<D, C, E>) => (boolean | {
+    calc: boolean;
+    draw: boolean;
+});
+interface Indicator<D = unknown, C = unknown, E = unknown> {
+    /**
+     * Unique id
+     */
+    id: string;
+    /**
+     * Pane id
+     */
+    paneId: string;
+    /**
+     * Indicator name
+     */
+    name: string;
+    /**
+     * Short name, for display
+     */
+    shortName: string;
+    /**
+     * Precision
+     */
+    precision: number;
+    /**
+     * Calculation parameters
+     */
+    calcParams: C[];
+    /**
+     * Whether ohlc column is required
+     */
+    shouldOhlc: boolean;
+    /**
+     * Whether large data values need to be formatted, starting from 1000, for example, whether 100000 needs to be formatted with 100K
+     */
+    shouldFormatBigNumber: boolean;
+    /**
+     * Whether the indicator is visible
+     */
+    visible: boolean;
+    /**
+     * Z index
+     */
+    zLevel: number;
+    /**
+     * Extend data
+     */
+    extendData: E;
+    /**
+     * Indicator series
+     */
+    series: IndicatorSeries;
+    /**
+     * Figure configuration information
+     */
+    figures: Array<IndicatorFigure<D>>;
+    /**
+     * Specified minimum value
+     */
+    minValue: Nullable<number>;
+    /**
+     * Specified maximum value
+     */
+    maxValue: Nullable<number>;
+    /**
+     * Style configuration
+     */
+    styles: Nullable<DeepPartial<IndicatorStyle>>;
+    /**
+     *  Should update, should calc or draw
+     */
+    shouldUpdate: Nullable<IndicatorShouldUpdateCallback<D, C, E>>;
+    /**
+     * Indicator calculation
+     */
+    calc: IndicatorCalcCallback<D, C, E>;
+    /**
+     * Regenerate figure configuration
+     */
+    regenerateFigures: Nullable<IndicatorRegenerateFiguresCallback<D, C>>;
+    /**
+     * Create custom tooltip text
+     */
+    createTooltipDataSource: Nullable<IndicatorCreateTooltipDataSourceCallback<D>>;
+    /**
+     * Custom draw
+     */
+    draw: Nullable<IndicatorDrawCallback<D, C, E>>;
+    /**
+     * Calculation result
+     */
+    result: D[];
+}
+type IndicatorTemplate<D = unknown, C = unknown, E = unknown> = ExcludePickPartial<Omit<Indicator<D, C, E>, 'result' | 'paneId'>, 'name' | 'calc'>;
+type IndicatorCreate<D = unknown, C = unknown, E = unknown> = ExcludePickPartial<Omit<Indicator<D, C, E>, 'result'>, 'name'>;
+type IndicatorFilter = Partial<Pick<Indicator, 'id' | 'paneId' | 'name'>>;
+
+export type { AstroneumOptions as A, CandleData as C, Datafeed as D, IndicatorTemplate as I, Nullable as N, OverlayTemplate as O, Price as P, SerializedChartState as S, Timestamp as T, Volume as V, XAxisTemplate as X, YAxisTemplate as Y, AstroneumHandle as a, IndicatorPlugin as b, Chart as c, Period as d, SymbolInfo as e, ChartEventMap as f, ChartPlugin as g, ChartPluginContext as h, DatafeedSubscribeCallback as i, Viewport as j };