@tony01/astroneum 0.4.1-beta.2

package/dist/index.d.ts

@@ -0,0 +1,1434 @@
+import { I as IndicatorTemplate, O as OverlayTemplate, X as XAxisTemplate, Y as YAxisTemplate, A as AstroneumOptions, a as AstroneumHandle, C as CandleData, b as IndicatorPlugin, P as Price, T as Timestamp, V as Volume, c as Chart, S as SerializedChartState, d as Period, e as SymbolInfo, D as Datafeed } from './Indicator-BBI3L_lx.js';
+export { f as ChartEventMap, g as ChartPlugin, h as ChartPluginContext, i as DatafeedSubscribeCallback, j as Viewport } from './Indicator-BBI3L_lx.js';
+export { DefaultDatafeed, WebSocketDatafeed, WebSocketDatafeedOptions } from './entries/datafeeds/polygon.js';
+export { BinanceAdapter, BitgetAdapter, CryptoSymbolInfo, DATAFEED_ERROR_EVENT, DatafeedErrorDetail, DatafeedErrorType, ExchangeAdapter, OkxAdapter, STANDARD_CRYPTO_SYMBOLS, StandardCryptoDatafeed, StandardCryptoDatafeedOptions, createStandardCryptoDatafeed } from './entries/datafeeds/crypto.js';
+import * as react from 'react';
+export { MultiChartCount, MultiChartLayout, MultiChartLayoutOptions, MultiChartSlot } from './entries/multichart.js';
+export { BarReplay, BarReplayOptions, BarReplayState } from './entries/replay.js';
+export { Alert, AlertCheckInput, AlertCondition, AlertCreate, AlertFrequency, AlertManager, AlertStatus, AlertTriggeredCallback, NotificationSchedule, SoundDuration, SoundTitle } from './entries/alerts.js';
+export { CompiledIndicator, InputOptions, PlotOptions, ScriptEngine, StudyOptions } from './entries/script.js';
+export { WatchSymbol, Watchlist, WatchlistManager } from './entries/watchlist.js';
+import { Position } from './entries/portfolio.js';
+export { PnLResult, PortfolioTracker, PositionSide } from './entries/portfolio.js';
+
+declare function registerIndicator<D = unknown, C = unknown, E = unknown>(indicator: IndicatorTemplate<D, C, E>): void;
+declare function getSupportedIndicators(): string[];
+
+declare function registerOverlay<E = unknown>(template: OverlayTemplate<E>): void;
+declare function getSupportedOverlays(): string[];
+
+declare function registerXAxis(axis: XAxisTemplate): void;
+
+declare function registerYAxis(axis: YAxisTemplate): void;
+
+declare const AstroneumChart: react.ForwardRefExoticComponent<AstroneumOptions & react.RefAttributes<AstroneumHandle>>;
+
+/**
+ * Drawing Style Templates & Presets
+ *
+ * Provides named overlay style presets that users can apply to drawing tools,
+ * plus save/load of custom templates to localStorage.
+ */
+interface OverlayStylePreset {
+    /** Unique identifier for this preset. */
+    id: string;
+    /** Human-readable display name. */
+    name: string;
+    /** Partial overlay style object compatible with the engine's overlay styles. */
+    styles: DrawingStyleTemplate;
+}
+interface DrawingStyleTemplate {
+    line?: {
+        color?: string;
+        size?: number;
+        style?: 'solid' | 'dashed' | 'dotted';
+    };
+    polygon?: {
+        color?: string;
+    };
+    text?: {
+        color?: string;
+        size?: number;
+        family?: string;
+        weight?: string;
+    };
+    rectText?: {
+        color?: string;
+        size?: number;
+        family?: string;
+        weight?: string;
+        paddingLeft?: number;
+        paddingRight?: number;
+        paddingTop?: number;
+        paddingBottom?: number;
+        borderRadius?: number;
+        borderSize?: number;
+        borderColor?: string;
+        backgroundColor?: string;
+    };
+    point?: {
+        color?: string;
+        radius?: number;
+        borderColor?: string;
+        borderSize?: number;
+    };
+}
+/**
+ * Manager for drawing style presets.
+ * Provides access to built-in presets and allows saving/loading custom ones.
+ *
+ * @example
+ * ```ts
+ * const templates = DrawingTemplates.getInstance()
+ * const preset = templates.getPreset('bullish')
+ * // Apply preset.styles to an overlay via chart.overrideOverlay(...)
+ * ```
+ */
+declare class DrawingTemplates {
+    private static _instance;
+    private _custom;
+    private constructor();
+    static getInstance(): DrawingTemplates;
+    private _loadCustom;
+    private _saveCustom;
+    /** Return all presets (built-in first, then custom). */
+    getAll(): OverlayStylePreset[];
+    /** Return built-in presets only. */
+    getBuiltIn(): OverlayStylePreset[];
+    /** Return user-saved custom presets. */
+    getCustom(): OverlayStylePreset[];
+    /** Find a preset by id (searches built-ins then custom). */
+    getPreset(id: string): OverlayStylePreset | undefined;
+    /**
+     * Save a new custom preset (or overwrite an existing custom one with the same id).
+     * Note: built-in preset ids cannot be overwritten.
+     */
+    saveCustomPreset(preset: OverlayStylePreset): void;
+    /** Delete a custom preset by id. Built-in presets cannot be deleted. */
+    deleteCustomPreset(id: string): boolean;
+    /**
+     * Apply a preset to an engine overlay via overrideOverlay.
+     * Returns the styles object ready to pass to `chart.overrideOverlay({ groupId, styles })`.
+     */
+    toOverlayStyles(presetId: string): DrawingStyleTemplate | undefined;
+    /**
+     * Preview a preset on an overlay without saving it. The styles are applied
+     * temporarily via overrideOverlay. Combine with the revert function to
+     * restore the original styles after preview ends.
+     *
+     * @returns A revert function that restores the original styles.
+     */
+    preview(presetId: string, overlayId: string, chart: {
+        overrideOverlay: (o: {
+            id?: string;
+            styles?: unknown;
+        }) => void;
+        getOverlays: () => Array<{
+            id: string;
+            styles: unknown;
+        }>;
+    }): (() => void) | null;
+    /**
+     * Apply a specific color to an individual drawing overlay by ID.
+     * Changes are persisted with the overlay (stored in overlay styles).
+     */
+    static applyColor(chart: {
+        overrideOverlay: (o: {
+            id?: string;
+            styles?: unknown;
+        }) => void;
+    }, overlayId: string, color: string): void;
+}
+
+/**
+ * PerformanceMode — data decimation and virtualization utilities.
+ *
+ * Use these when dealing with very large datasets to keep renders fast:
+ *   - `decimate(data, maxBars)` — LTTB downsampling
+ *   - `virtualizeWindow(data, start, end, buffer)` — windowed slice
+ *   - `shouldDecimate(length, threshold?)` — quick heuristic
+ */
+
+/**
+ * Transform standard OHLCV bars into Heikin-Ashi candles.
+ *
+ * Heikin-Ashi candles use averaged values to filter out market noise:
+ *   ha_close = (open + high + low + close) / 4
+ *   ha_open  = (prev_ha_open + prev_ha_close) / 2
+ *   ha_high  = max(high, ha_open, ha_close)
+ *   ha_low   = min(low, ha_open, ha_close)
+ *
+ * @param data  Source candlestick data
+ * @returns     New array of Heikin-Ashi candles (same timestamps, volume, turnover)
+ */
+declare function heikinAshi(data: CandleData[]): CandleData[];
+interface Bar {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+    [key: string]: unknown;
+}
+/**
+ * Downsample `data` to `targetCount` points using the LTTB algorithm.
+ * Always preserves the first and last bar. Returns a new array.
+ */
+declare function decimate<T extends Bar>(data: T[], targetCount: number): T[];
+/**
+ * Return only the bars within [visibleStart, visibleEnd] timestamps,
+ * extended by `buffer` bars on each side to support look-back indicators.
+ */
+declare function virtualizeWindow<T extends Bar>(data: T[], visibleStart: number, visibleEnd: number, buffer?: number): T[];
+/**
+ * Returns true when the dataset is large enough that decimation makes sense.
+ * @param dataLength - Total number of bars in the dataset
+ * @param threshold  - Bar count threshold, default 5000
+ */
+declare function shouldDecimate(dataLength: number, threshold?: number): boolean;
+declare class PerformanceMode {
+    static decimate: typeof decimate;
+    static virtualizeWindow: typeof virtualizeWindow;
+    static shouldDecimate: typeof shouldDecimate;
+    static heikinAshi: typeof heikinAshi;
+}
+
+var indicator = "Indicator";
+var main_indicator = "Main Indicator";
+var sub_indicator = "Sub Indicator";
+var setting = "Setting";
+var timezone = "Timezone";
+var screenshot = "Screenshot";
+var full_screen = "Full Screen";
+var exit_full_screen = "Exit";
+var save = "Save";
+var confirm = "Confirm";
+var color = "Color";
+var show = "Show";
+var cancel = "Cancel";
+var ma = "MA(Moving Average)";
+var ema = "EMA(Exponential Moving Average)";
+var sma = "SMA";
+var boll = "BOLL(Bolinger Bands)";
+var bbi = "BBI(Bull And Bearlndex)";
+var sar = "SAR(Stop and Reverse)";
+var vol = "VOL(Volume)";
+var macd = "MACD(Moving Average Convergence / Divergence)";
+var kdj = "KDJ(KDJ Index)";
+var rsi = "RSI(Relative Strength Index)";
+var bias = "BIAS(Bias Ratio)";
+var brar = "BRAR(Bull and Bear Sentiment)";
+var cci = "CCI(Commodity Channel Index)";
+var dmi = "DMI(Directional Movement Index)";
+var cr = "CR(Energy Index)";
+var psy = "PSY(Psychological Line)";
+var dma = "DMA(Different of Moving Average)";
+var trix = "TRIX(Triple Exponentially Smoothed Moving Average)";
+var obv = "OBV(On Balance Volume)";
+var vr = "VR(Volatility Volume Ratio)";
+var wr = "WR(Williams %R)";
+var mtm = "MTM(Momentum Index)";
+var emv = "EMV(Ease of Movement Value)";
+var roc = "ROC(Price Rate of Change)";
+var pvt = "PVT(Price and Volume Trend)";
+var ao = "AO(Awesome Oscillator)";
+var utc = "UTC";
+var honolulu = "(UTC-10) Honolulu";
+var juneau = "(UTC-8) Juneau";
+var los_angeles = "(UTC-7) Los Angeles";
+var chicago = "(UTC-5) Chicago";
+var toronto = "(UTC-4) Toronto";
+var sao_paulo = "(UTC-3) Sao Paulo";
+var london = "(UTC+1) London";
+var berlin = "(UTC+2) Berlin";
+var bahrain = "(UTC+3) Bahrain";
+var dubai = "(UTC+4) Dubai";
+var ashkhabad = "(UTC+5) Ashkhabad";
+var almaty = "(UTC+6) Almaty";
+var bangkok = "(UTC+7) Bangkok";
+var shanghai = "(UTC+8) Shanghai";
+var tokyo = "(UTC+9) Tokyo";
+var sydney = "(UTC+10) Sydney";
+var norfolk = "(UTC+12) Norfolk";
+var horizontal_straight_line = "Horizontal Line";
+var horizontal_ray_line = "Horizontal Ray";
+var horizontal_segment = "Horizontal Segment";
+var vertical_straight_line = "Vertical Line";
+var vertical_ray_line = "Vertical Ray";
+var vertical_segment = "Vertical Segment";
+var straight_line = "Trend Line";
+var ray_line = "Ray";
+var segment = "Segment";
+var arrow = "Arrow";
+var price_line = "Price Line";
+var price_channel_line = "Price Channel Line";
+var parallel_straight_line = "Parallel Line";
+var fibonacci_line = "Fibonacci Line";
+var fibonacci_segment = "Fibonacci Segment";
+var fibonacci_circle = "Fibonacci Circle";
+var fibonacci_spiral = "Fibonacci Spiral";
+var fibonacci_speed_resistance_fan = "Fibonacci Sector";
+var fibonacci_extension = "Fibonacci Extension";
+var gann_box = "Gann Box";
+var gann_fan = "Gann Fan";
+var pitchfork = "Andrews Pitchfork";
+var rect = "Rect";
+var parallelogram = "Parallelogram";
+var circle = "Circle";
+var triangle = "Triangle";
+var three_waves = "Three Waves";
+var five_waves = "Five Waves";
+var eight_waves = "Eight Waves";
+var any_waves = "Any Waves";
+var abcd = "ABCD Pattern";
+var xabcd = "XABCD Pattern";
+var weak_magnet = "Weak Magnet";
+var strong_magnet = "Strong Magnet";
+var symbol_search = "Symbol Search";
+var symbol_code = "Symbol Code";
+var params_1 = "Parameter 1";
+var params_2 = "Parameter 2";
+var params_3 = "Parameter 3";
+var params_4 = "Parameter 4";
+var params_5 = "Parameter 5";
+var line_1 = "Line 1";
+var line_2 = "Line 2";
+var line_3 = "Line 3";
+var line_4 = "Line 4";
+var line_5 = "Line 5";
+var period = "Period";
+var standard_deviation = "Standard Deviation";
+var candle_type = "Candle Type";
+var candle_solid = "Candle Solid";
+var candle_stroke = "Candle Stroke";
+var candle_up_stroke = "Candle Up Stroke";
+var candle_down_stroke = "Candle Down Stroke";
+var ohlc = "OHLC";
+var area = "Area";
+var last_price_show = "Show Last Price";
+var high_price_show = "Show Highest Price";
+var low_price_show = "Show Lowest Price";
+var indicator_last_value_show = "Show indicator's last value";
+var price_axis_type = "Price Axis Type";
+var normal = "Normal";
+var percentage = "Percentage";
+var log = "Log";
+var reverse_coordinate = "Reverse Coordinate";
+var grid_show = "Show Grids";
+var restore_default = "Restore Defaults";
+var alerts = "Alerts";
+var alert_create = "Create";
+var alert_history = "History";
+var alert_condition = "Condition";
+var alert_price = "Price";
+var alert_note = "Note";
+var alert_note_placeholder = "Optional label…";
+var alert_add = "Add Alert";
+var alert_active = "Active";
+var alert_no_history = "No triggered alerts yet";
+var alert_reactivate = "Re-activate";
+var alert_above = "Above";
+var alert_below = "Below";
+var alert_crosses_above = "Crosses ↑";
+var alert_crosses_below = "Crosses ↓";
+var alert_trigger = "Trigger";
+var alert_trigger_once = "Once only";
+var alert_trigger_every_bar = "Every bar";
+var alert_trigger_bar_close = "Once per bar close";
+var alert_expiration = "Expiration";
+var alert_expiration_open = "Open-ended";
+var alert_expiration_1d = "In 1 day";
+var alert_expiration_1w = "In 1 week";
+var alert_expiration_1m = "In 1 month";
+var alert_expiration_2m = "In 2 months";
+var alert_message = "Message";
+var alert_message_hint = "Sent as the webhook body when a webhook URL is set.";
+var alert_webhook_body = "Webhook body";
+var alert_notifications = "Notifications";
+var alert_back = "Back";
+var alert_apply = "Apply";
+var alert_notif_app = "Notify in app";
+var alert_notif_app_desc = "Provides a push notification in the mobile app.";
+var alert_notif_toast = "Show toast notification";
+var alert_notif_toast_desc = "Displays an onsite notification in the page corner.";
+var alert_notif_email = "Send email";
+var alert_notif_email_desc = "Sends an email to the address in your account settings.";
+var alert_notif_webhook = "Webhook URL";
+var alert_notif_webhook_desc = "Sends a POST request to your URL when the alert triggers.";
+var alert_notif_sound = "Play sound";
+var alert_notif_sound_desc = "Plays an audio cue when your alert triggers.";
+var alert_notif_plaintext = "Send plain text";
+var alert_notif_plaintext_desc = "Sends plain text to an alternative email.";
+var alert_notif_none = "None";
+var alert_webhook_valid = "Valid target URL";
+var alert_webhook_invalid = "Invalid URL — use http(s)://, no private or localhost hosts";
+var alert_sound_once = "Once";
+var alert_sound_repeating = "Repeating";
+var alert_schedule = "Notification schedule";
+var alert_schedule_desc = "Notifications are muted outside this schedule.";
+var alert_schedule_weekdays = "Weekdays";
+var alert_schedule_working_hours = "Working hours (Mon–Fri 09:00–18:00)";
+var alert_schedule_custom = "Custom";
+var alert_webhook_delivered = "Delivered";
+var alert_webhook_failed = "Failed";
+var alert_webhook_sending = "Sending";
+var alert_log = "Log";
+var alert_clear_log = "Clear log";
+var alert_actions = "Actions";
+var alert_no_log = "No alerts triggered yet";
+var alert_webhook_success = "Webhook successfully delivered";
+var alert_webhook_failed_prefix = "Webhook delivery failed";
+var alert_webhook_timeout = "request took too long and timed out";
+var alert_webhook_learn_more = "Learn more";
+var snap_levels = "Snap to price levels";
+var no_magnet = "No snap";
+var script_editor = "Script Editor";
+var script_editor_hint = "Write JavaScript — uses Pine Script–inspired API with ta.* helpers";
+var script_compile = "Compile";
+var script_apply = "Add to Chart";
+var script_compiled = "Compiled";
+var script_api_ref = "API Reference";
+var watchlist = "Watchlist";
+var watchlist_new = "New Watchlist";
+var watchlist_add_list = "Add watchlist";
+var watchlist_delete_list = "Delete watchlist";
+var watchlist_add_symbol = "Add";
+var watchlist_remove_symbol = "Remove symbol";
+var watchlist_enter_symbol = "Enter ticker…";
+var enUS = {
+	indicator: indicator,
+	main_indicator: main_indicator,
+	sub_indicator: sub_indicator,
+	setting: setting,
+	timezone: timezone,
+	screenshot: screenshot,
+	full_screen: full_screen,
+	exit_full_screen: exit_full_screen,
+	save: save,
+	confirm: confirm,
+	color: color,
+	show: show,
+	cancel: cancel,
+	ma: ma,
+	ema: ema,
+	sma: sma,
+	boll: boll,
+	bbi: bbi,
+	sar: sar,
+	vol: vol,
+	macd: macd,
+	kdj: kdj,
+	rsi: rsi,
+	bias: bias,
+	brar: brar,
+	cci: cci,
+	dmi: dmi,
+	cr: cr,
+	psy: psy,
+	dma: dma,
+	trix: trix,
+	obv: obv,
+	vr: vr,
+	wr: wr,
+	mtm: mtm,
+	emv: emv,
+	roc: roc,
+	pvt: pvt,
+	ao: ao,
+	utc: utc,
+	honolulu: honolulu,
+	juneau: juneau,
+	los_angeles: los_angeles,
+	chicago: chicago,
+	toronto: toronto,
+	sao_paulo: sao_paulo,
+	london: london,
+	berlin: berlin,
+	bahrain: bahrain,
+	dubai: dubai,
+	ashkhabad: ashkhabad,
+	almaty: almaty,
+	bangkok: bangkok,
+	shanghai: shanghai,
+	tokyo: tokyo,
+	sydney: sydney,
+	norfolk: norfolk,
+	horizontal_straight_line: horizontal_straight_line,
+	horizontal_ray_line: horizontal_ray_line,
+	horizontal_segment: horizontal_segment,
+	vertical_straight_line: vertical_straight_line,
+	vertical_ray_line: vertical_ray_line,
+	vertical_segment: vertical_segment,
+	straight_line: straight_line,
+	ray_line: ray_line,
+	segment: segment,
+	arrow: arrow,
+	price_line: price_line,
+	price_channel_line: price_channel_line,
+	parallel_straight_line: parallel_straight_line,
+	fibonacci_line: fibonacci_line,
+	fibonacci_segment: fibonacci_segment,
+	fibonacci_circle: fibonacci_circle,
+	fibonacci_spiral: fibonacci_spiral,
+	fibonacci_speed_resistance_fan: fibonacci_speed_resistance_fan,
+	fibonacci_extension: fibonacci_extension,
+	gann_box: gann_box,
+	gann_fan: gann_fan,
+	pitchfork: pitchfork,
+	rect: rect,
+	parallelogram: parallelogram,
+	circle: circle,
+	triangle: triangle,
+	three_waves: three_waves,
+	five_waves: five_waves,
+	eight_waves: eight_waves,
+	any_waves: any_waves,
+	abcd: abcd,
+	xabcd: xabcd,
+	weak_magnet: weak_magnet,
+	strong_magnet: strong_magnet,
+	symbol_search: symbol_search,
+	symbol_code: symbol_code,
+	params_1: params_1,
+	params_2: params_2,
+	params_3: params_3,
+	params_4: params_4,
+	params_5: params_5,
+	line_1: line_1,
+	line_2: line_2,
+	line_3: line_3,
+	line_4: line_4,
+	line_5: line_5,
+	period: period,
+	standard_deviation: standard_deviation,
+	candle_type: candle_type,
+	candle_solid: candle_solid,
+	candle_stroke: candle_stroke,
+	candle_up_stroke: candle_up_stroke,
+	candle_down_stroke: candle_down_stroke,
+	ohlc: ohlc,
+	area: area,
+	last_price_show: last_price_show,
+	high_price_show: high_price_show,
+	low_price_show: low_price_show,
+	indicator_last_value_show: indicator_last_value_show,
+	price_axis_type: price_axis_type,
+	normal: normal,
+	percentage: percentage,
+	log: log,
+	reverse_coordinate: reverse_coordinate,
+	grid_show: grid_show,
+	restore_default: restore_default,
+	alerts: alerts,
+	alert_create: alert_create,
+	alert_history: alert_history,
+	alert_condition: alert_condition,
+	alert_price: alert_price,
+	alert_note: alert_note,
+	alert_note_placeholder: alert_note_placeholder,
+	alert_add: alert_add,
+	alert_active: alert_active,
+	alert_no_history: alert_no_history,
+	alert_reactivate: alert_reactivate,
+	alert_above: alert_above,
+	alert_below: alert_below,
+	alert_crosses_above: alert_crosses_above,
+	alert_crosses_below: alert_crosses_below,
+	alert_trigger: alert_trigger,
+	alert_trigger_once: alert_trigger_once,
+	alert_trigger_every_bar: alert_trigger_every_bar,
+	alert_trigger_bar_close: alert_trigger_bar_close,
+	alert_expiration: alert_expiration,
+	alert_expiration_open: alert_expiration_open,
+	alert_expiration_1d: alert_expiration_1d,
+	alert_expiration_1w: alert_expiration_1w,
+	alert_expiration_1m: alert_expiration_1m,
+	alert_expiration_2m: alert_expiration_2m,
+	alert_message: alert_message,
+	alert_message_hint: alert_message_hint,
+	alert_webhook_body: alert_webhook_body,
+	alert_notifications: alert_notifications,
+	alert_back: alert_back,
+	alert_apply: alert_apply,
+	alert_notif_app: alert_notif_app,
+	alert_notif_app_desc: alert_notif_app_desc,
+	alert_notif_toast: alert_notif_toast,
+	alert_notif_toast_desc: alert_notif_toast_desc,
+	alert_notif_email: alert_notif_email,
+	alert_notif_email_desc: alert_notif_email_desc,
+	alert_notif_webhook: alert_notif_webhook,
+	alert_notif_webhook_desc: alert_notif_webhook_desc,
+	alert_notif_sound: alert_notif_sound,
+	alert_notif_sound_desc: alert_notif_sound_desc,
+	alert_notif_plaintext: alert_notif_plaintext,
+	alert_notif_plaintext_desc: alert_notif_plaintext_desc,
+	alert_notif_none: alert_notif_none,
+	alert_webhook_valid: alert_webhook_valid,
+	alert_webhook_invalid: alert_webhook_invalid,
+	alert_sound_once: alert_sound_once,
+	alert_sound_repeating: alert_sound_repeating,
+	alert_schedule: alert_schedule,
+	alert_schedule_desc: alert_schedule_desc,
+	"alert_schedule_24/7": "24/7",
+	alert_schedule_weekdays: alert_schedule_weekdays,
+	alert_schedule_working_hours: alert_schedule_working_hours,
+	alert_schedule_custom: alert_schedule_custom,
+	alert_webhook_delivered: alert_webhook_delivered,
+	alert_webhook_failed: alert_webhook_failed,
+	alert_webhook_sending: alert_webhook_sending,
+	alert_log: alert_log,
+	alert_clear_log: alert_clear_log,
+	alert_actions: alert_actions,
+	alert_no_log: alert_no_log,
+	alert_webhook_success: alert_webhook_success,
+	alert_webhook_failed_prefix: alert_webhook_failed_prefix,
+	alert_webhook_timeout: alert_webhook_timeout,
+	alert_webhook_learn_more: alert_webhook_learn_more,
+	snap_levels: snap_levels,
+	no_magnet: no_magnet,
+	script_editor: script_editor,
+	script_editor_hint: script_editor_hint,
+	script_compile: script_compile,
+	script_apply: script_apply,
+	script_compiled: script_compiled,
+	script_api_ref: script_api_ref,
+	watchlist: watchlist,
+	watchlist_new: watchlist_new,
+	watchlist_add_list: watchlist_add_list,
+	watchlist_delete_list: watchlist_delete_list,
+	watchlist_add_symbol: watchlist_add_symbol,
+	watchlist_remove_symbol: watchlist_remove_symbol,
+	watchlist_enter_symbol: watchlist_enter_symbol
+};
+
+type LocaleKey = keyof typeof enUS;
+type LocaleMap = Partial<Record<LocaleKey, string>>;
+/**
+ * Register a locale dictionary explicitly. Use this to ship your own
+ * translations or to override a built-in locale at runtime.
+ */
+declare function load(key: string, ls: LocaleMap): void;
+/**
+ * Asynchronously load one of the built-in locales. Resolves with the
+ * dictionary, or `null` when the locale is not a built-in (already
+ * loaded locales return the cached map). Subsequent lookups for that
+ * locale will return its translations.
+ *
+ * ```ts
+ * await loadLocale('ja-JP')
+ * chartRef.current?.setLocale('ja-JP')
+ * ```
+ */
+declare function loadLocale(key: string): Promise<LocaleMap | null>;
+/** Names of all built-in locales that can be passed to `loadLocale`. */
+declare const BUILTIN_LOCALES: ReadonlyArray<string>;
+
+/**
+ * Locale-aware number and date formatting utilities.
+ * Uses the native Intl API — no extra dependencies.
+ */
+interface FormatPriceOptions {
+    /** Number of decimal places. Defaults to 2. */
+    precision?: number;
+    /** Whether to show compact notation (1.2K, 3.4M). Defaults to false. */
+    compact?: boolean;
+    /** Currency code, e.g. "USD". When provided, formats as currency. */
+    currency?: string;
+}
+/**
+ * Format a price / numeric value for display.
+ *
+ * @example
+ * formatPrice(1234567.891, 'en-US', { precision: 2 }) // "1,234,567.89"
+ * formatPrice(1234567.891, 'de-DE', { precision: 2 }) // "1.234.567,89"
+ * formatPrice(1234567, 'en-US', { compact: true })     // "1.2M"
+ * formatPrice(1234.5, 'en-US', { currency: 'USD' })    // "$1,234.50"
+ */
+declare function formatPrice(value: number, locale: string, options?: FormatPriceOptions): string;
+/**
+ * Format a volume number compactly.
+ *
+ * @example
+ * formatVolume(1234567, 'en-US') // "1.2M"
+ * formatVolume(54321,   'zh-CN') // "5.4万"
+ */
+declare function formatVolume(value: number, locale: string): string;
+/**
+ * Format a percentage value.
+ *
+ * @example
+ * formatPercent(0.0523, 'en-US') // "5.23%"
+ * formatPercent(-0.012, 'fr-FR') // "-1,20 %"
+ */
+declare function formatPercent(value: number, locale: string, precision?: number): string;
+type DateFormatStyle = 'short' | 'medium' | 'long' | 'full';
+type TimeFormatStyle = 'short' | 'medium';
+/**
+ * Format a UNIX timestamp (ms or s) as a locale-aware date string.
+ *
+ * @param timestamp  UNIX timestamp in milliseconds (or seconds — auto-detected)
+ * @param locale     BCP-47 locale string, e.g. "en-US"
+ * @param style      Intl DateTimeFormat date style
+ */
+declare function formatDate(timestamp: number, locale: string, style?: DateFormatStyle): string;
+/**
+ * Format a UNIX timestamp as a locale-aware time string.
+ */
+declare function formatTime(timestamp: number, locale: string, style?: TimeFormatStyle): string;
+/**
+ * Format a UNIX timestamp as a combined date+time string.
+ */
+declare function formatDateTime(timestamp: number, locale: string, dateStyle?: DateFormatStyle, timeStyle?: TimeFormatStyle): string;
+/**
+ * Format a duration in milliseconds as a human-readable string.
+ * Uses RelativeTimeFormat for relative phrases when |ms| < threshold.
+ *
+ * @example
+ * formatDuration(60_000,    'en-US') // "1 minute"
+ * formatDuration(3_600_000, 'de-DE') // "1 Stunde"
+ */
+declare function formatDuration(ms: number, locale: string): string;
+/**
+ * Format a Period as a short locale-aware timeframe label.
+ *
+ * @example
+ * formatPeriod({ multiplier: 1, timespan: 'minute' }, 'en-US')  // "1m"
+ * formatPeriod({ multiplier: 4, timespan: 'hour' },   'zh-CN')  // "4时"
+ * formatPeriod({ multiplier: 1, timespan: 'day' },    'en-US')  // "1D"
+ */
+declare function formatPeriod(period: {
+    multiplier: number;
+    timespan: string;
+}, locale: string): string;
+/**
+ * Detect an appropriate number of decimal places for a given price.
+ * Useful when `pricePrecision` is not specified on a SymbolInfo.
+ *
+ * @example
+ * detectPricePrecision(0.00001234) // 8
+ * detectPricePrecision(1234.56)    // 2
+ * detectPricePrecision(50000)      // 0
+ */
+declare function detectPricePrecision(price: number): number;
+
+type NormalizedIndicatorRow = Record<string, number | null>;
+declare function createIndicatorTemplateFromPlugin<TOutput>(plugin: IndicatorPlugin<TOutput>): IndicatorTemplate<NormalizedIndicatorRow, number>;
+declare function registerIndicatorPlugin<TOutput>(plugin: IndicatorPlugin<TOutput>): void;
+declare function registerIndicatorPlugins(plugins: ReadonlyArray<IndicatorPlugin<unknown>>): void;
+
+/** Cast a raw number to the Price brand. Use only when the number is known to be a price. */
+declare function asPrice(n: number): Price;
+/** Cast a raw number to the Volume brand. Use only when the number is known to be a volume. */
+declare function asVolume(n: number): Volume;
+/** Cast a raw number to the Timestamp brand (milliseconds). Use only at data ingress. */
+declare function asTimestamp(n: number): Timestamp;
+/**
+ * Returns a dispatcher that schedules `fn` on the next animation frame,
+ * coalescing rapid calls so only the last value is delivered.
+ *
+ * @example
+ * const dispatch = rafCoalesce((tick: CandleData) => chart.update(tick))
+ * ws.onmessage = e => dispatch(parse(e.data))  // safe to call 100×/s
+ */
+declare function rafCoalesce<T>(fn: (value: T) => void): (value: T) => void;
+/**
+ * OHLCV-aware frame-coalescing scheduler for financial tick streams.
+ *
+ * Unlike `rafCoalesce` (which drops intermediate values), `rafMergeTick`
+ * merges multiple ticks that arrive within a single animation frame into
+ * one financially accurate OHLCV bar:
+ *
+ *   open   = first tick's open  (bar opening price)
+ *   high   = max across all ticks (price extreme)
+ *   low    = min across all ticks (price extreme)
+ *   close  = last tick's close  (current price)
+ *   volume = sum of all volumes (accurate volume)
+ *
+ * This is the correct coalescer for financial charting:
+ * - Never loses high/low extremes (important for candle accuracy)
+ * - Never loses volume (critical for volume indicators)
+ * - Delivers one merged tick per rAF frame — O(1) render cost
+ *
+ * @example
+ * const dispatch = rafMergeTick((merged) => chart.updateData(merged))
+ * ws.onmessage = e => dispatch(parseTick(e.data))  // safe to call 500×/s
+ */
+declare function rafMergeTick(fn: (tick: CandleData) => void): (tick: CandleData) => void;
+declare function deepSet(obj: object, path: string, value: unknown): void;
+declare function deepClone<T>(obj: T): T;
+
+/**
+ * EventBus — type-safe, zero-dependency synchronous event bus.
+ *
+ * Usage:
+ *   const bus = new EventBus<ChartEventMap>()
+ *   const off = bus.on('tick', candle => chart.update(candle))
+ *   bus.emit('tick', newCandle)
+ *   off()  // unsubscribe
+ *
+ * Performance characteristics:
+ *   - O(n_listeners) per emit — keep listener count low in hot paths
+ *   - All events are synchronous and ordered (FIFO within an event key)
+ *   - No allocations on emit when there are no listeners for the key
+ */
+type ListenerOf<TMap, K extends keyof TMap> = (payload: TMap[K]) => void;
+declare class EventBus<TMap extends Record<string, unknown>> {
+    private readonly _listeners;
+    /**
+     * Subscribe to an event. Returns an unsubscribe function.
+     * The returned function is idempotent — safe to call multiple times.
+     */
+    on<K extends keyof TMap>(event: K, listener: ListenerOf<TMap, K>): () => void;
+    /** Unsubscribe a specific listener. No-op if not currently subscribed. */
+    off<K extends keyof TMap>(event: K, listener: ListenerOf<TMap, K>): void;
+    /** Emit an event, invoking all registered listeners synchronously. */
+    emit<K extends keyof TMap>(event: K, payload: TMap[K]): void;
+    /**
+     * Clear all listeners for a specific event, or all listeners when called
+     * with no argument (useful for component teardown).
+     */
+    clear(event?: keyof TMap): void;
+}
+
+/**
+ * TickAnimator — smoothly interpolates the last candlestick bar as live ticks arrive.
+ *
+ * Problem it solves:
+ *   Raw WebSocket ticks arrive at irregular bursts (10–500 ms apart). Without
+ *   animation, the last bar jumps discretely on every tick — jarring at high
+ *   update rates. TickAnimator interpolates close/high/low between the previous
+ *   and next confirmed values over a configurable `duration` (default 120 ms),
+ *   targeting 60–120 fps via requestAnimationFrame.
+ *
+ * Design rules (per SKILL.md):
+ *   - Zero allocations inside the rAF loop — all state is pre-allocated
+ *   - Uses `performance.now()` for sub-millisecond frame timing
+ *   - Single rAF handle — never stacks multiple loops
+ *   - Price fields use the branded Price type (compatible with engine CandleData)
+ *
+ * Usage:
+ *   const animator = new TickAnimator((interpolated) => chart.updateData(interpolated))
+ *   ws.onmessage = e => animator.feed(parsedTick)
+ *   // On symbol change / cleanup:
+ *   animator.cancel()
+ */
+
+interface TickAnimatorOptions {
+    /**
+     * Duration of the interpolation animation in milliseconds.
+     * Lower = more responsive but less smooth.
+     * Higher = smoother but introduces lag.
+     * Default: 120ms (≈7 frames at 60fps, ≈12 frames at 100fps).
+     */
+    duration?: number;
+    /**
+     * Interpolation easing profile.
+     * - 'easeOut' (default): snappy response that settles smoothly.
+     * - 'linear': constant-speed interpolation, better for video-like motion.
+     */
+    easing?: 'easeOut' | 'linear';
+}
+declare class TickAnimator {
+    private readonly _onFrame;
+    private readonly _duration;
+    private readonly _easing;
+    /** Snapshot of the bar at the moment the last tick arrived (animation start). */
+    private _fromClose;
+    private _fromHigh;
+    private _fromLow;
+    /** Target values (the actual received tick). */
+    private _toClose;
+    private _toHigh;
+    private _toLow;
+    /** Stable fields that don't animate. */
+    private _timestamp;
+    private _open;
+    private _volume;
+    private _turnover;
+    /** Reused output object — written in-place every rAF frame. No allocation.
+     * @warning Consumers MUST NOT retain or mutate this object. It is reused
+     * across frames — storing a reference will see stale/corrupted data. */
+    private readonly _frame;
+    private _startTime;
+    private _rafId;
+    private _running;
+    constructor(onFrame: (tick: CandleData) => void, options?: TickAnimatorOptions);
+    /**
+     * Feed a new confirmed tick.
+     * Starts (or restarts) the interpolation from the last rendered state to `next`.
+     * Safe to call at any rate — will coalesce intermediate ticks automatically
+     * by updating the target (`_to*`) without resetting the start time.
+     */
+    feed(next: CandleData): void;
+    /**
+     * Cancel the running animation (e.g., on symbol change, unmount).
+     * Safe to call at any time, including when not animating.
+     */
+    cancel(): void;
+    private _elapsed;
+    private _tick;
+}
+
+/**
+ * RingBuffer<T> — fixed-capacity circular buffer with O(1) append, prepend, and index access.
+ *
+ * Purpose: streaming time-series data (candles, ticks) that grows at the tail
+ * and drops the oldest bar at the head when capacity is exceeded.
+ * Avoids the O(n) cost of Array.splice() during live streaming.
+ *
+ * Capacity design: set to your desired visible bar count × 2–4× for history.
+ * At 1 tick/second and 4h of data: 14_400 bars → use capacity = 32_768.
+ *
+ * @example
+ * const bars = new RingBuffer<CandleData>(8192)
+ * bars.push(tick)                // O(1) — auto-drops oldest when full
+ * const last = bars.last()       // O(1)
+ * const bar  = bars.at(-1)       // O(1) — negative index from tail
+ * bars.updateLast(merged)        // O(1) — in-place last bar update
+ */
+declare class RingBuffer<T> {
+    private readonly _buf;
+    private readonly _capacity;
+    /** Index of the oldest item (logical position 0). */
+    private _head;
+    /** Total items ever written — from this we derive the current fill and tail. */
+    private _size;
+    constructor(capacity: number);
+    get length(): number;
+    get capacity(): number;
+    get isFull(): boolean;
+    /**
+     * Append an item to the tail.
+     * When full, silently overwrites (and advances) the oldest item.
+     */
+    push(item: T): void;
+    /**
+     * Replace the last item in-place.
+     * Used to update the current live bar with a new tick merge result.
+     * O(1) — no allocation.
+     */
+    updateLast(item: T): void;
+    /**
+     * Access item at logical index.
+     * Positive: 0 = oldest, `length - 1` = newest.
+     * Negative: -1 = newest, -length = oldest.
+     * Returns `undefined` when out of bounds.
+     */
+    at(index: number): T | undefined;
+    /** Most recently pushed item. O(1). */
+    last(): T | undefined;
+    /** Oldest item still in the buffer. O(1). */
+    first(): T | undefined;
+    /**
+     * Iterate from oldest to newest without allocating a copy.
+     * Uses a standard iterator protocol so it works with `for…of`.
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Return a dense snapshot copy as a plain array, oldest → newest.
+     * O(n). Use sparingly — this allocates. Prefer `at()` / iteration.
+     */
+    toArray(): T[];
+    clear(): void;
+}
+
+/**
+ * UndoManager — tracks chart overlay mutations for Ctrl+Z / Ctrl+Y support.
+ *
+ * Every createOverlay / removeOverlay / overrideOverlay is recorded as a
+ * snapshot of the full overlay list. Undo pops the stack and restores.
+ *
+ * Usage:
+ *   const undo = new UndoManager(chart)
+ *   chart.createOverlay(...)
+ *   undo.record()           // call after every mutation
+ *   undo.undo()             // Ctrl+Z
+ *   undo.redo()             // Ctrl+Y
+ */
+declare class UndoManager {
+    private readonly _chart;
+    private _stack;
+    private _redoStack;
+    private _maxDepth;
+    private _lastSnapshot;
+    constructor(chart: AstroneumHandle, maxDepth?: number);
+    /** Record current overlay state. Call after every overlay mutation. */
+    record(): void;
+    /** Undo last mutation. Returns true if an undo was performed. */
+    undo(): boolean;
+    /** Redo last undone mutation. Returns true if a redo was performed. */
+    redo(): boolean;
+    /** Clear all undo/redo history. */
+    clear(): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+}
+
+/**
+ * SessionVisualizer — renders session breaks, extended-hours shading, and
+ * session extremes (high/low/open/close) as persistent chart overlays.
+ *
+ * Usage:
+ *   const sv = new SessionVisualizer(chart, { timezone: 'America/New_York' })
+ *   sv.enable()
+ *   // session breaks and extremes auto-update when the chart scrolls/zooms
+ *   sv.disable()
+ */
+
+interface SessionConfig {
+    /** IANA timezone, e.g. 'America/New_York'. Default: 'America/New_York' */
+    timezone?: string;
+    /** Regular market open hour (0-23) in the configured timezone. Default: 9 (9:30 AM ET) */
+    openHour?: number;
+    /** Regular market open minute. Default: 30 */
+    openMinute?: number;
+    /** Regular market close hour. Default: 16 (4:00 PM ET) */
+    closeHour?: number;
+    /** Regular market close minute. Default: 0 */
+    closeMinute?: number;
+    /** Whether to show extended-hours shading. Default: true */
+    showExtendedHours?: boolean;
+    /** Whether to show session high/low/open/close lines. Default: true */
+    showSessionLevels?: boolean;
+}
+declare class SessionVisualizer {
+    private _chart;
+    private _config;
+    private _enabled;
+    private _animFrame;
+    constructor(chart: Chart, config?: SessionConfig);
+    get enabled(): boolean;
+    enable(): void;
+    disable(): void;
+    toggle(): void;
+    /** Call when the chart scrolls/zooms. Debounced via rAF. */
+    refresh(): void;
+    private _refresh;
+    private _removeGuides;
+}
+
+/**
+ * Volume Profile indicator — horizontal histogram of volume at each price level.
+ *
+ * Usage:
+ *   import { volumeProfilePlugin } from '@tony01/astroneum'
+ *   registerIndicatorPlugin(volumeProfilePlugin)
+ *   chart.createIndicator({ name: 'volume_profile' })
+ *
+ * Or set it as a sub-indicator:
+ *   <AstroneumChart subIndicators={['VOL', 'volume_profile']} />
+ */
+interface VolumeProfileRow {
+    price: number;
+    volume: number;
+    /** Cumulative volume from top → this level */
+    cumulative: number;
+}
+declare const volumeProfilePlugin: IndicatorPlugin<VolumeProfileRow>;
+
+interface ChartTemplate {
+    id: string;
+    name: string;
+    state: SerializedChartState;
+    createdAt: string;
+}
+/**
+ * ChartTemplateManager — save/load named chart configurations.
+ *
+ * Templates persist to localStorage and include theme, locale, timezone,
+ * styles, indicators, and overlay state. Symbols and periods are intentionally
+ * NOT included — templates apply chart settings to any symbol.
+ *
+ * Usage:
+ *   const templates = ChartTemplateManager.getInstance()
+ *   templates.save('My Setup', chart.serializeState())
+ *   templates.load('My Setup', chart) // applies to current chart
+ */
+declare class ChartTemplateManager {
+    private static _instance;
+    private _templates;
+    private constructor();
+    static getInstance(): ChartTemplateManager;
+    /** Save current chart state as a named template. Overwrites if name exists. */
+    save(name: string, state: SerializedChartState): ChartTemplate;
+    /** Load a template onto a chart. Returns false if template not found. */
+    load(name: string, chart: AstroneumHandle): boolean;
+    /** Delete a template by name. Returns false if not found. */
+    delete(name: string): boolean;
+    /** List all saved template names. */
+    list(): string[];
+    /** Get a template by name. */
+    get(name: string): ChartTemplate | undefined;
+    /** Get all templates. */
+    getAll(): ChartTemplate[];
+    private _persist;
+    private _load;
+}
+
+/**
+ * Build a higher-timeframe bar array from lower-TF data using OHLCV resampling.
+ *
+ * This is a client-side resampler — it aggregates lower-TF bars into higher-TF
+ * bars without requiring a second datafeed subscription. The output can be fed
+ * to any indicator calc function that expects CandleData[].
+ *
+ * @example
+ * ```ts
+ * // Resample 15m bars to 4H bars
+ * const h4Bars = resampleBars(bars15m, { multiplier: 4, timespan: 'hour', text: '4H' })
+ * const ema4h = sma(h4Bars.map(b => b.close), 21)
+ *
+ * // Forward-fill to align with lower-TF bars
+ * const aligned = forwardFill(h4Bars, bars15m)
+ * ```
+ *
+ * @param data   Source lower-timeframe bars (must be sorted ascending by timestamp)
+ * @param period Target higher timeframe
+ * @returns      Resampled bars
+ */
+declare function resampleBars(data: CandleData[], period: Period): CandleData[];
+/**
+ * Forward-fill higher-TF indicator values to align with lower-TF bar array.
+ * Each lower-TF bar gets the indicator value from the most recent higher-TF bar.
+ *
+ * @param htValues   Higher-TF indicator values (one per higher-TF bar)
+ * @param htBars     Higher-TF bars (same length as htValues)
+ * @param ltBars     Lower-TF bars to align to
+ * @returns          Array of length ltBars.length, with forward-filled values
+ */
+declare function forwardFill(htValues: number[], htBars: Pick<CandleData, 'timestamp'>[], ltBars: Pick<CandleData, 'timestamp'>[]): number[];
+/**
+ * Convenience: create a higher-TF indicator factory.
+ * Call `calc` on the full lower-TF dataset, then `getValue(i)` for each bar.
+ *
+ * @example
+ * ```ts
+ * const h4Sma = mtfIndicator(bars15m, { multiplier: 4, timespan: 'hour', text: '4H' }, (data) => sma(data, 21))
+ * const h4SmaValues = bars15m.map((_, i) => h4Sma.getValue(i))
+ * ```
+ */
+declare function mtfIndicator<T>(data: CandleData[], higherPeriod: Period, indicatorFn: (data: CandleData[]) => T[]): {
+    getValue: (index: number) => T | null;
+    result: T[];
+};
+
+/**
+ * PositionVisualizer — renders entry, stop-loss, and take-profit levels
+ * directly on the chart as colored horizontal lines with labels.
+ *
+ * Usage:
+ *   const pv = new PositionVisualizer(chart)
+ *   pv.show(position)
+ *   // When position updates:
+ *   pv.update(position)
+ *   pv.hide()
+ */
+
+interface PositionVisual {
+    position: Position;
+    stopPrice?: number;
+    targetPrice?: number;
+}
+declare class PositionVisualizer {
+    private _chart;
+    private _active;
+    constructor(chart: Chart);
+    /** Show position lines on the chart. */
+    show(visual: PositionVisual): void;
+    /** Hide all position lines. */
+    hide(): void;
+    /** Update position lines (calls show internally). */
+    update(visual: PositionVisual): void;
+    get active(): boolean;
+    private _createLine;
+    private _createLabel;
+}
+
+/**
+ * ZigZag indicator — detects swing highs and lows using price deviation.
+ *
+ * A swing high occurs when price is the highest within a `deviation`-bar
+ * window on both sides. The resulting array contains the pivot prices at
+ * swing points, with NaN for non-pivot bars.
+ *
+ * @param data       Source candle data
+ * @param deviation  Number of bars to confirm a swing (default 5)
+ * @returns          Array of pivot values (NaN = no pivot at that bar)
+ */
+declare function zigzag(data: CandleData[], deviation?: number): number[];
+/**
+ * Detect support and resistance zones from clustered pivot points.
+ * Returns price levels where swings cluster within `tolerance` percentage.
+ */
+declare function detectSupportResistance(data: CandleData[], zigzagDeviation?: number, clusterTolerance?: number): Array<{
+    price: number;
+    count: number;
+    type: 'support' | 'resistance';
+}>;
+/**
+ * ZigZag IndicatorPlugin — can be registered as a chart indicator and will
+ * render swing lines between pivot points on the chart.
+ */
+declare const zigzagPlugin: IndicatorPlugin<number>;
+
+/**
+ * Candlestick pattern recognition plugin.
+ *
+ * Scans OHLC data for common candlestick patterns and marks them on the chart.
+ * Patterns are grouped: single-bar, two-bar, three-bar.
+ *
+ * Usage:
+ *   import { patternRecognitionPlugin, registerIndicatorPlugin } from '@tony01/astroneum'
+ *   registerIndicatorPlugin(patternRecognitionPlugin)
+ *   chart.createIndicator({ name: 'patterns', calcParams: [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1] })
+ */
+interface PatternMatch {
+    index: number;
+    pattern: string;
+    type: 'bullish' | 'bearish' | 'neutral';
+    timestamp: number;
+    high: number;
+    low: number;
+}
+interface PatternDef {
+    id: string;
+    name: string;
+    category: 'single' | 'two' | 'three';
+    type: 'bullish' | 'bearish' | 'neutral';
+    fn: (data: CandleData[], i: number) => PatternMatch | null;
+}
+declare const PATTERN_CATALOGUE: PatternDef[];
+declare const patternRecognitionPlugin: IndicatorPlugin<PatternMatch>;
+
+/**
+ * MultiPeriodLayout — renders multiple charts of the same symbol at
+ * different timeframes stacked vertically. Crosshair syncs across all
+ * panes at the same timestamp.
+ *
+ * Usage:
+ *   const layout = new MultiPeriodLayout({
+ *     container: 'chart-root',
+ *     symbol: { ticker: 'BTCUSDT', ... },
+ *     periods: [
+ *       { multiplier: 4, timespan: 'hour', text: '4H' },
+ *       { multiplier: 1, timespan: 'hour', text: '1H' },
+ *       { multiplier: 15, timespan: 'minute', text: '15m' },
+ *     ],
+ *     datafeed: myDatafeed,
+ *   })
+ */
+
+interface MultiPeriodLayoutOptions extends Omit<AstroneumOptions, 'symbol' | 'period'> {
+    container: string | HTMLElement;
+    symbol: SymbolInfo;
+    /** Periods for each pane (top to bottom). Default: [4H, 1H, 15m] */
+    periods?: Period[];
+    /** localStorage key for persistence. Pass null to disable. */
+    storageKey?: string | null;
+}
+declare class MultiPeriodLayout {
+    private _container;
+    private _periods;
+    private _charts;
+    private _options;
+    private _storageKey;
+    private _wrapperEl;
+    constructor(options: MultiPeriodLayoutOptions);
+    private _render;
+    private _destroy;
+    setTheme(theme: string): void;
+    setLocale(locale: string): void;
+    getCharts(): AstroneumHandle[];
+    destroy(): void;
+}
+
+/**
+ * CompareOverlay — overlays a second symbol's price as a colored line on the
+ * main chart pane. Uses registerIndicatorPlugin infrastructure for rendering.
+ *
+ * Unlike TradingView's compare feature (which supports dual Y-axis), this
+ * implementation normalizes both symbols to percentage change from the first
+ * visible bar, making them visually comparable on a single Y-axis.
+ *
+ * Usage:
+ *   const compare = createCompareIndicator('AAPL', myDatafeed)
+ *   registerIndicatorPlugin(compare)
+ *   chart.createIndicator({ name: 'compare_AAPL' })
+ */
+interface CompareIndicatorOptions {
+    /** Display name shown in legend */
+    name: string;
+    /** Color of the compare line */
+    color?: string;
+}
+/**
+ * Create an indicator plugin that overlays a comparison symbol's price data
+ * normalized to percentage change.
+ */
+declare function createCompareIndicator(compareSymbol: SymbolInfo, datafeed: Datafeed, period: Period, color?: string): IndicatorPlugin<number>;
+
+/**
+ * Depth of Market (DOM) / Order Book indicator plugin.
+ *
+ * Renders a ladder-style order book on the right side of the chart showing
+ * cumulative bid/ask volume at each price level.
+ *
+ * This is a client-side approximation — a real DOM requires Level 2 market
+ * data from the exchange. This implementation uses the visible candle data
+ * to visualize historical volume distribution at price levels, which is
+ * useful for identifying support/resistance and liquidity zones.
+ *
+ * Usage:
+ *   import { domPlugin } from '@tony01/astroneum'
+ *   registerIndicatorPlugin(domPlugin)
+ *   chart.createIndicator({ name: 'dom', calcParams: [20] }) // 20 price levels
+ */
+interface DOMLevel {
+    price: number;
+    bidVolume: number;
+    askVolume: number;
+    totalVolume: number;
+}
+declare const domPlugin: IndicatorPlugin<DOMLevel>;
+
+/**
+ * PriceScaleTransform — log, percentage, and indexed-to-100 price axis
+ * scaling implemented as data-level transformations.
+ *
+ * These transforms work by converting candle OHLC data before it reaches
+ * the chart engine, and converting axis tick values back for display.
+ * This avoids modifying the engine core Y-axis renderer.
+ */
+
+type PriceScaleMode = 'linear' | 'log' | 'percent' | 'indexed';
+/**
+ * Transform OHLC data from linear to the target scale mode.
+ * Returns a new array — does not mutate input.
+ */
+declare function transformCandles(data: CandleData[], mode: PriceScaleMode, basePrice?: number): CandleData[];
+/**
+ * Convert a display price from the transformed scale back to linear.
+ */
+declare function untransformPrice(value: number, mode: PriceScaleMode, basePrice: number): number;
+/**
+ * Format a tick label for the given scale mode.
+ */
+declare function formatScaleTick(value: number, mode: PriceScaleMode, basePrice: number, precision?: number): string;
+
+/**
+ * Non-time-based bar generators: Renko, Kagi, Line Break, Tick, Range, Volume.
+ *
+ * Each function takes standard time-based OHLC data and produces a new array
+ * of synthetic bars where timestamps are artificially spaced for equal-width
+ * rendering on a time-based X-axis. This workaround avoids modifying the
+ * engine core BarSpace/VisibleRange.
+ *
+ * Usage:
+ *   const renko = generateRenko(bars, 10) // $10 brick size
+ *   chart.setData(renko)                  // feed to chart as candles
+ */
+
+/**
+ * Generate Renko bricks from OHLC data.
+ * Each brick has a fixed price size. A new brick forms when price moves
+ * beyond the brick size in either direction.
+ *
+ * @param data      Source OHLC bars (sorted ascending)
+ * @param brickSize Price size of each Renko brick
+ * @returns         Array of synthetic bricks with artificial timestamps
+ */
+declare function generateRenko(data: CandleData[], brickSize: number): CandleData[];
+/**
+ * Generate Kagi line segments from OHLC data.
+ * Kagi draws vertical lines (yang = rising, yin = falling) that reverse
+ * when price moves beyond a threshold.
+ *
+ * @param data         Source OHLC bars (sorted ascending)
+ * @param reversalPct  Reversal threshold as percentage (e.g., 3 = 3%)
+ * @returns            Array of synthetic bars representing line segments
+ */
+declare function generateKagi(data: CandleData[], reversalPct?: number): CandleData[];
+/**
+ * Generate tick bars from raw OHLC data by simulating tick aggregation.
+ * Groups bars into buckets of N "ticks" (where each source bar = 1 tick).
+ *
+ * @param data       Source OHLC bars
+ * @param ticksPerBar Number of ticks per synthetic bar
+ * @returns           Aggregated tick bars
+ */
+declare function generateTickBars(data: CandleData[], ticksPerBar: number): CandleData[];
+/**
+ * Generate range bars from OHLC data.
+ * Each bar covers a fixed price range. New bar forms when price moves beyond
+ * the range boundary.
+ *
+ * @param data       Source OHLC bars
+ * @param rangeSize  Price range per bar
+ * @returns           Range bars with artificial timestamps
+ */
+declare function generateRangeBars(data: CandleData[], rangeSize: number): CandleData[];
+
+/**
+ * Point & Figure chart generator.
+ *
+ * P&F charts use X and O columns on a grid instead of time-based candles.
+ * X = rising price column, O = falling price column.
+ * Box size = minimum price move to add a mark. Reversal = number of boxes
+ * required to reverse the current column direction.
+ *
+ * Since the engine requires CandleData[] (time-based), we convert P&F
+ * bricks into synthetic candles with artificial 1-minute timestamps
+ * and uniform spacing. Each brick = one candle bar rendered as a solid
+ * block (open=low, close=high for X, open=high, close=low for O).
+ *
+ * Usage:
+ *   import { generatePointAndFigure } from '@tony01/astroneum'
+ *   const pfBars = generatePointAndFigure(bars, 10, 3) // $10 box, 3-box reversal
+ *   // Feed to chart as regular candles
+ *
+ * Also exports a standalone renderer for true P&F grid visualization
+ * via canvas (used with IndicatorPlugin infrastructure).
+ */
+
+interface PFConfig {
+    /** Box size in price units. Default: derived from data (1% of average price) */
+    boxSize?: number;
+    /** Number of boxes to reverse direction. Default: 3 */
+    reversal?: number;
+    /** Chart type: 'pf' = X/O columns, 'hilo' = high/low based */
+    method?: 'close' | 'hilo';
+}
+interface PFColumn {
+    /** X (rising) or O (falling) */
+    type: 'X' | 'O';
+    /** Price at the top of this column */
+    top: number;
+    /** Price at the bottom of this column */
+    bottom: number;
+    /** Number of boxes in this column */
+    boxes: number;
+    /** Column index (0-based from left) */
+    columnIndex: number;
+}
+/**
+ * Generate Point & Figure columns from price data.
+ * Returns the raw columns for custom rendering.
+ */
+declare function computePFColumns(data: CandleData[], config?: PFConfig): PFColumn[];
+/**
+ * Convert P&F columns to CandleData for rendering in the standard chart engine.
+ * Each X box = green candle (open < close), each O box = red candle (open > close).
+ */
+declare function pfColumnsToBars(columns: PFColumn[]): CandleData[];
+/**
+ * One-shot: generate P&F bars from OHLC data.
+ */
+declare function generatePointAndFigure(data: CandleData[], boxSize?: number, reversal?: number): CandleData[];
+/**
+ * Point & Figure IndicatorPlugin — renders true X/O grid on the chart
+ * via Canvas2D custom render path.
+ */
+declare const pointAndFigurePlugin: IndicatorPlugin<number>;
+
+export { AstroneumChart, AstroneumHandle, AstroneumOptions, BUILTIN_LOCALES, CandleData, type ChartTemplate, ChartTemplateManager, type CompareIndicatorOptions, type DOMLevel, Datafeed, type DateFormatStyle, type DrawingStyleTemplate, DrawingTemplates, EventBus, type FormatPriceOptions, IndicatorPlugin, MultiPeriodLayout, type MultiPeriodLayoutOptions, type OverlayStylePreset, PATTERN_CATALOGUE, type PFColumn, type PFConfig, type PatternDef, type PatternMatch, type Bar as PerformanceBar, PerformanceMode, Period, Position, type PositionVisual, PositionVisualizer, Price, type PriceScaleMode, RingBuffer, SerializedChartState, type SessionConfig, SessionVisualizer, SymbolInfo, TickAnimator, type TickAnimatorOptions, type TimeFormatStyle, Timestamp, UndoManager, Volume, type VolumeProfileRow, asPrice, asTimestamp, asVolume, computePFColumns, createCompareIndicator, createIndicatorTemplateFromPlugin, deepClone, deepSet, detectPricePrecision, detectSupportResistance, domPlugin, formatDate, formatDateTime, formatDuration, formatPercent, formatPeriod, formatPrice, formatScaleTick, formatTime, formatVolume, forwardFill, generateKagi, generatePointAndFigure, generateRangeBars, generateRenko, generateTickBars, getSupportedIndicators, getSupportedOverlays, heikinAshi, loadLocale, load as loadLocales, mtfIndicator, patternRecognitionPlugin, pfColumnsToBars, pointAndFigurePlugin, rafCoalesce, rafMergeTick, registerIndicator, registerIndicatorPlugin, registerIndicatorPlugins, registerOverlay, registerXAxis, registerYAxis, resampleBars, transformCandles, untransformPrice, volumeProfilePlugin, zigzag, zigzagPlugin };