@christtrade/depth 0.12.21

package/types/lib/slice-worker-client.d.ts

@@ -0,0 +1,138 @@
+/**
+ * KEY DESIGN PRINCIPLE - NO MAIN-THREAD DESERIALIZATION:
+ *
+ * The onmessage handler does ZERO object allocation. It reattaches ArrayBuffers
+ * and resolves with raw Float64Array-backed data only. Callers that need JS
+ * objects (TradePoint[], PriceHistory[], Map) call the exported lazy helpers.
+ *
+ * Public API:
+ *   sliceToMboEventsAsync   - off-thread slice, returns MboEvent[]
+ *   prependMergeAsync       - off-thread prepend (raw buffer result)
+ *   loadIngestAsync         - off-thread load post-processing (raw buffer result)
+ *   appendIngestAsync       - off-thread append (raw buffer result)
+ *
+ * Raw-buffer result helpers (call ONLY when you actually need JS objects,
+ * never in the hot onmessage path):
+ *   deserializeTradesFromBuf
+ *   deserializePriceHistoryFromBuf
+ *   deserializeOhlcvCacheFromBuf
+ *   serializeTrades / serializePriceHistory / serializeOhlcvCache
+ *
+ *   destroySliceWorker()
+ */
+import type { CompactBuffer } from '../lib/compact-buffer';
+import type { MboEvent, PriceHistory } from '../lib/types';
+type TradePoint = {
+    ts: bigint;
+    price: number;
+    size: number;
+    side: string;
+};
+type OhlcvEntry = {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    delta: number;
+};
+export interface PrependMergeOptions {
+    cb: CompactBuffer;
+    incomingBuf: ArrayBuffer;
+    existingTrades: TradePoint[];
+    newTrades: TradePoint[];
+    existingPriceHistory: PriceHistory[];
+    newPriceHistory: PriceHistory[];
+    existingOhlcvCache: Map<bigint, OhlcvEntry> | null;
+    barNs: bigint;
+    existingTradesBufRaw?: ArrayBuffer;
+    existingPhBufRaw?: ArrayBuffer;
+    existingOhlcvBufRaw?: ArrayBuffer;
+}
+export interface LoadIngestOptions {
+    tradesBuf: ArrayBuffer;
+    phBuf: ArrayBuffer;
+    barNs: bigint;
+}
+export interface AppendIngestOptions {
+    cb: CompactBuffer;
+    incomingBuf: ArrayBuffer;
+    existingTradesBuf: ArrayBuffer;
+    newTrades: TradePoint[];
+    existingPhBuf: ArrayBuffer;
+    newPriceHistory: PriceHistory[];
+    existingOhlcvBuf: ArrayBuffer;
+    trimBeforeNs: bigint;
+    barNs: bigint;
+    dataEndNs: bigint;
+}
+/**
+ * Raw-buffer results - no JS objects allocated on the main thread.
+ * Call deserialize* helpers only when you actually need to iterate.
+ */
+export interface RawIngestResult {
+    /** Raw Float64Array (TRADE_STRIDE f64s per trade). */
+    tradesBuf: ArrayBuffer;
+    /** Raw Float64Array (PH_STRIDE f64s per point). */
+    phBuf: ArrayBuffer;
+    /** Raw Float64Array - bucketed price history. */
+    bucketedPhBuf: ArrayBuffer;
+    /** Raw Float64Array (OHLCV_STRIDE f64s per entry). */
+    ohlcvBuf: ArrayBuffer;
+}
+export interface PrependMergeRawResult extends RawIngestResult {
+    cb: CompactBuffer;
+    prependedCount: number;
+}
+export interface LoadIngestRawResult {
+    ohlcvBuf: ArrayBuffer;
+    bucketedPhBuf: ArrayBuffer;
+    tradesBuf: ArrayBuffer;
+    phBuf: ArrayBuffer;
+}
+export interface AppendIngestRawResult {
+    cb: CompactBuffer;
+    mergedTradesBuf: ArrayBuffer;
+    mergedPhBuf: ArrayBuffer;
+    mergedOhlcvBuf: ArrayBuffer;
+    appendedCount: number;
+    compactCutCount: number;
+    tradeCutCount: number;
+    phCutCount: number;
+}
+export declare function serializeTrades(trades: TradePoint[]): ArrayBuffer;
+export declare function serializePriceHistory(ph: PriceHistory[]): ArrayBuffer;
+export declare function serializeOhlcvCache(map: Map<bigint, OhlcvEntry> | null): ArrayBuffer;
+export declare function deserializeTradesFromBuf(buf: ArrayBuffer): TradePoint[];
+export declare function deserializePriceHistoryFromBuf(buf: ArrayBuffer): PriceHistory[];
+export declare function deserializeOhlcvCacheFromBuf(buf: ArrayBuffer, horizon: bigint): Map<bigint, OhlcvEntry>;
+/**
+ * Fast typed-array lookup for the candle cache - avoids deserializing the whole cache
+ * into a Map just to do a single key lookup during mousemove / status line.
+ * Returns null if not found.
+ */
+export declare function lookupOhlcvFromBuf(buf: ArrayBuffer, targetKey: bigint): OhlcvEntry | null;
+export declare function sliceToMboEventsAsync(cb: CompactBuffer, start: number, end: number, messageType: 'init' | 'append' | 'prepend'): Promise<{
+    events: MboEvent[];
+    cb: CompactBuffer;
+    messageType: typeof messageType;
+}>;
+/**
+ * Off-thread prepend merge. Returns RAW buffers - caller deserializes lazily.
+ * Pass existingTradesBufRaw / existingPhBufRaw / existingOhlcvBufRaw when
+ * available (from previous ingest result) to avoid serialising full dataset.
+ */
+export declare function prependMergeAsync(opts: PrependMergeOptions): Promise<PrependMergeRawResult>;
+/**
+ * Off-thread load-ingest. Returns RAW buffers - caller deserializes lazily.
+ * tradesBuf and phBuf are TRANSFERRED.
+ */
+export declare function loadIngestAsync(opts: LoadIngestOptions): Promise<LoadIngestRawResult>;
+/**
+ * Off-thread append-ingest. Returns RAW buffers - caller deserializes lazily.
+ * Only serialise the SMALL incremental newTrades / newPriceHistory on the
+ * main thread. All existingXxxBuf are transferred (zero-copy).
+ */
+export declare function appendIngestAsync(opts: AppendIngestOptions): Promise<AppendIngestRawResult>;
+export declare function destroySliceWorker(): void;
+export {};

package/types/lib/slice.worker.d.ts

@@ -0,0 +1,139 @@
+/**
+ * slice.worker.ts
+ *
+ * Message types:
+ *
+ *  1. 'slice'          - decode a range of a CompactBuffer to MboEvent[]
+ *
+ *  2. 'prepend-merge'  - full prepend hot path off-thread:
+ *       merge compact chunk, trades, priceHistory + bucket, OHLCV cache
+ *
+ *  3. 'load-ingest'    - NEW: everything ingestLoadedData used to do on the
+ *       main thread after receiving data:
+ *         - rebuild the candleCache cache from trades
+ *         - bucket priceHistory
+ *       Returns typed-array buffers the main thread just assigns to refs.
+ *
+ *  4. 'append-ingest'  - NEW: everything ingestAppendedData used to do on the
+ *       main thread:
+ *         - compact buffer grow + memcopy
+ *         - allTrades / allPriceHistory concat + trim
+ *         - candleCache cache update + trim
+ *       Returns typed-array buffers the main thread just assigns to refs.
+ *
+ * All ArrayBuffers are transferred (zero-copy) in both directions.
+ */
+import { sliceToMboEvents } from '../lib/compact-buffer';
+export interface SliceRequest {
+    kind: 'slice';
+    id: string;
+    buf: ArrayBuffer;
+    length: number;
+    capacity: number;
+    start: number;
+    end: number;
+    messageType: 'init' | 'append' | 'prepend';
+}
+export interface PrependMergeRequest {
+    kind: 'prepend-merge';
+    id: string;
+    existingBuf: ArrayBuffer;
+    existingLength: number;
+    existingCapacity: number;
+    incomingBuf: ArrayBuffer;
+    existingTradesBuf: ArrayBuffer;
+    newTradesBuf: ArrayBuffer;
+    existingPhBuf: ArrayBuffer;
+    newPhBuf: ArrayBuffer;
+    existingOhlcvBuf: ArrayBuffer;
+    barNsHi: number;
+    barNsLo: number;
+}
+/**
+ * 'load-ingest' - off-thread heavy work from ingestLoadedData.
+ * The data worker already built the compact buffer; we just need to
+ * rebuild candleCache and bucket priceHistory.
+ */
+export interface LoadIngestRequest {
+    kind: 'load-ingest';
+    id: string;
+    /** Serialised trades (TRADE_STRIDE Float64s per trade) */
+    tradesBuf: ArrayBuffer;
+    /** Serialised priceHistory (PH_STRIDE Float64s per point) */
+    phBuf: ArrayBuffer;
+    barNsHi: number;
+    barNsLo: number;
+}
+export interface LoadIngestResponse {
+    kind: 'load-ingest';
+    id: string;
+    ohlcvBuf: ArrayBuffer;
+    bucketedPhBuf: ArrayBuffer;
+    /** Returned so main thread can reattach without re-serialising */
+    tradesBuf: ArrayBuffer;
+    phBuf: ArrayBuffer;
+}
+/**
+ * 'append-ingest' - off-thread heavy work from ingestAppendedData.
+ */
+export interface AppendIngestRequest {
+    kind: 'append-ingest';
+    id: string;
+    existingBuf: ArrayBuffer;
+    existingLength: number;
+    existingCapacity: number;
+    incomingBuf: ArrayBuffer;
+    existingTradesBuf: ArrayBuffer;
+    newTradesBuf: ArrayBuffer;
+    existingPhBuf: ArrayBuffer;
+    newPhBuf: ArrayBuffer;
+    existingOhlcvBuf: ArrayBuffer;
+    /** Trim everything older than this ns. 0 = no trim. */
+    trimBeforeNsHi: number;
+    trimBeforeNsLo: number;
+    barNsHi: number;
+    barNsLo: number;
+    dataEndNsHi: number;
+    dataEndNsLo: number;
+}
+export interface AppendIngestResponse {
+    kind: 'append-ingest';
+    id: string;
+    mergedBuf: ArrayBuffer;
+    mergedLength: number;
+    mergedCapacity: number;
+    mergedTradesBuf: ArrayBuffer;
+    mergedPhBuf: ArrayBuffer;
+    mergedOhlcvBuf: ArrayBuffer;
+    appendedCount: number;
+    /** Events trimmed from the compact buffer front (caller adjusts playheadIdx). */
+    compactCutCount: number;
+    /** Trades trimmed from front. */
+    tradeCutCount: number;
+    /** PriceHistory points trimmed from front. */
+    phCutCount: number;
+    newFirstTsHi: number;
+    newFirstTsLo: number;
+    newLastTsHi: number;
+    newLastTsLo: number;
+}
+export type SliceWorkerRequest = SliceRequest | PrependMergeRequest | LoadIngestRequest | AppendIngestRequest;
+export interface SliceResponse {
+    kind: 'slice';
+    id: string;
+    messageType: 'init' | 'append' | 'prepend';
+    events: ReturnType<typeof sliceToMboEvents>;
+    buf: ArrayBuffer;
+}
+export interface PrependMergeResponse {
+    kind: 'prepend-merge';
+    id: string;
+    mergedBuf: ArrayBuffer;
+    mergedLength: number;
+    mergedCapacity: number;
+    mergedTradesBuf: ArrayBuffer;
+    mergedPhBuf: ArrayBuffer;
+    bucketedPhBuf: ArrayBuffer;
+    mergedOhlcvBuf: ArrayBuffer;
+    prependedCount: number;
+}

package/types/lib/storage.d.ts

@@ -0,0 +1,108 @@
+export declare const STORAGE_NAMESPACE = "christtrade:chart:";
+/**
+ * Every chart-owned storage key. Add new keys here rather than inlining string
+ * literals at the call site - `clearChartStorage` and the migration both key off
+ * this namespace.
+ */
+export declare const StorageKey: {
+    readonly chartSettings: "christtrade:chart:settings";
+    readonly customTimeframes: "christtrade:chart:custom-timeframes";
+    readonly favoriteTimeframes: "christtrade:chart:favorite-timeframes";
+    readonly drawingTemplates: "christtrade:chart:drawing-templates";
+    readonly drawingFavorites: "christtrade:chart:drawing-favorites";
+    readonly colorSwatches: "christtrade:chart:color-swatches";
+    readonly pluginStartup: "christtrade:chart:plugin-startup";
+    readonly pluginPanels: "christtrade:chart:plugin-panels";
+};
+/**  sdklaföfkdslfk:Settings blob a plugin owns via `ctx.getSettings()` / `ctx.saveSettings()`. */
+export declare function pluginSettingsKey(pluginId: string): string;
+/** Individual entry in a plugin's namespaced KV store (`ctx.storage`). */
+export declare function pluginStorageKey(pluginId: string, key: string): string;
+/** Prefix covering every key belonging to one plugin's KV store. */
+export declare function pluginStoragePrefix(pluginId: string): string;
+/**
+ * Bookkeeping about this device rather than user data - one-shot migration
+ * markers and the like. Excluded from clearChartStorage() and from the
+ * preferences block of a save document, since it means nothing on another device.
+ */
+export declare const META_PREFIX = "christtrade:chart:meta:";
+/**
+ * Where the chart keeps its settings. localStorage-shaped and synchronous, so a
+ * host can point it at something else - an account-level store that syncs to a
+ * server, for instance - and everything the chart persists follows.
+ */
+export interface ChartStorageBackend {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    /** Every key held, so the chart can enumerate what it has stored. */
+    keys(): string[];
+}
+/**
+ * Replace localStorage as the chart's backing store, or pass `null` to go back
+ * to it.
+ *
+ * Anything already stored on this device that the backend doesn't have is copied
+ * across, so switching over carries the user's settings with it instead of
+ * resetting them. Install it before constructing a chart - the constructor reads
+ * settings on the way up.
+ */
+export declare function setChartStorageBackend(next: ChartStorageBackend | null): void;
+export declare function onChartStorageChange(fn: () => void): () => void;
+/** Whether the chart may read/write localStorage. Defaults to on. */
+export declare function isPersistenceEnabled(): boolean;
+export declare function setPersistenceEnabled(enabled: boolean): void;
+/** Subscribe to persistence toggles. Returns an unsubscribe function. */
+export declare function onPersistenceChange(fn: (enabled: boolean) => void): () => void;
+/** Raw read. Falls back to the session store; null when nothing is set. */
+export declare function readStored(key: string): string | null;
+/** JSON read with a fallback for missing or malformed values. */
+export declare function readJSON<T>(key: string, fallback: T): T;
+/** Raw write. Stays in memory for the session when persistence is off. */
+export declare function writeStored(key: string, value: string): void;
+/** JSON write. Stays in memory for the session when persistence is off. */
+export declare function writeJSON(key: string, value: unknown): void;
+/**
+ * Delete a key. Runs even when persistence is off, so "forget this" always
+ * means forget it.
+ */
+export declare function removeStored(key: string): void;
+/** Delete every key under `prefix`. Runs regardless of the persistence flag. */
+export declare function removeStoredByPrefix(prefix: string): void;
+/**
+ * Every chart-owned key currently holding a value, across both backing stores.
+ * Excludes the persistence preference itself.
+ */
+export declare function chartStorageKeys(): string[];
+/**
+ * Wipe all chart-owned data, including plugin storage and any un-migrated
+ * legacy keys. The persistence preference itself survives.
+ */
+export declare function clearChartStorage(): void;
+/** Rough byte count of everything the chart currently has stored. */
+export declare function chartStorageSize(): number;
+/**
+ * Device-level chart preferences - custom and favorite timeframes, favorite
+ * drawings, drawing style templates, saved color swatches, and every plugin's
+ * settings and KV store.
+ *
+ * Keyed by full storage key so anything added to StorageKey later, or written by
+ * a third-party plugin, rides along without extra plumbing. Values are the parsed
+ * JSON rather than raw strings so a save document stays readable; every writer
+ * goes through writeJSON, so that round-trips losslessly.
+ *
+ * Per-pane chart settings are NOT here - those already travel in
+ * `ChartSaveState.charts[i].settings`.
+ */
+export type ChartPreferences = Record<string, unknown>;
+export declare function serializeChartPreferences(): ChartPreferences;
+/**
+ * Apply a saved preferences block. Writes go through the persistence gate, so
+ * restoring with persistence off applies for the session without touching disk.
+ *
+ * Merges by default: keys absent from `prefs` keep their current value. Pass
+ * `{ replace: true }` for an exact "make this device look like the save" restore.
+ */
+export declare function restoreChartPreferences(prefs: ChartPreferences | undefined, opts?: {
+    replace?: boolean;
+}): void;

package/types/lib/symbol-info.d.ts

@@ -0,0 +1,12 @@
+import type { SymbolInfo } from '../interfaces/IDataAdapter';
+/**
+ * A structured-clone-safe copy of a SymbolInfo, with `icon` stripped.
+ *
+ * `SymbolIcon` may carry a `render` callback, and functions cannot cross a
+ * `postMessage` boundary - the clone throws before the worker ever sees it.
+ * Icons are a presentation concern, so nothing off the main thread needs them.
+ *
+ * Call this on any SymbolInfo bound for a worker, `structuredClone`, or
+ * persisted layout.
+ */
+export declare function toTransferableSymbolInfo(info: SymbolInfo): SymbolInfo;

package/types/lib/symbol-search.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The built-in symbol matcher. Used by DataEngine whenever the adapter declares
+ * `symbolSearch: 'none'` (the default) - the adapter hands over its universe
+ * once and every keystroke is matched here instead of over the network.
+ *
+ * Adapters that search server-side can still import this to match and rank their
+ * own results the same way the built-in picker does.
+ *
+ * Matching is word-anchored, never substring-anywhere. That distinction is the
+ * whole design: a universe of "Spot X / TetherUS" pairs has "eth" sitting inside
+ * "t-eth-er" on every single row, so a loose substring rule returns the entire
+ * list for the first three characters of "ethusdt". Queries match the start of a
+ * word, the start of the ticker, or as a fuzzy subsequence of the ticker - and
+ * nothing else.
+ */
+import type { SymbolInfo, SymbolSearchRequest, SymbolSearchResponse } from '../interfaces/IDataAdapter';
+/**
+ * Match, rank and page `symbols` against `request`. Non-matching symbols are
+ * dropped, not merely sorted down.
+ *
+ * A parent survives if it or any of its subsymbols matches, so a group stays
+ * reachable while searching for one of its contracts. Subsymbols are never
+ * hoisted into the result - the picker renders them nested under their parent.
+ */
+export declare function searchSymbolsLocally(symbols: SymbolInfo[], request: SymbolSearchRequest): SymbolSearchResponse;
+/** Adapters may return a bare array for convenience. Normalize to a response. */
+export declare function normalizeSymbolSearchResponse(result: SymbolSearchResponse | SymbolInfo[]): SymbolSearchResponse;
+/** Cache key for a search. Ignores `signal`, which never affects the result. */
+export declare function symbolSearchCacheKey(request: SymbolSearchRequest): string;

package/types/lib/timeframes.d.ts

@@ -0,0 +1,46 @@
+export type TimeframeUnit = 'none' | 'ms' | 's' | 'm' | 'h' | 'd' | 'w';
+export type Timeframe = {
+    /** Human-readable label, e.g. "1m", "5m", "1h", "213m" */
+    label: string;
+    /** Duration of ONE candle/bar in nanoseconds (also used as the view snap span multiplier) */
+    barNs: bigint;
+    /** Default number of bars to show in the viewport when this TF is selected */
+    defaultBars: number;
+    /** Whether this is a built-in preset (false = user-created custom) */
+    isPreset: boolean;
+};
+export declare const DEFAULT_BARS: Record<string, number>;
+export declare const PRESET_TIMEFRAMES: Timeframe[];
+/**
+ * Resolve a timeframe LABEL (e.g. "5m", "213m") back into a Timeframe - a preset
+ * when one matches, else a parsed custom one. Lenient: falls back to 1m on an
+ * unrecognized label rather than throwing, so a restore never hard-fails.
+ */
+export declare function resolveTimeframe(label: string): Timeframe;
+/**
+ * Resolve a raw bar duration (ns) into a full Timeframe. Reuses a built-in
+ * preset when one matches exactly; otherwise synthesizes the label and a
+ * sensible defaultBars. Used to give data adapters the rich timeframe object
+ * for whatever resolution the engine actually decided to fetch at.
+ */
+export declare function timeframeFromBarNs(barNs: bigint): Timeframe;
+/**
+ * Given a timeframe and optional bar count, return the total nanosecond span
+ * that should be visible in the viewport.
+ */
+export declare function tfViewSpan(tf: Timeframe, bars?: number): bigint;
+/**
+ * Parse a user-entered string like "213m", "2h", "45s", "3d" into a Timeframe.
+ * Returns null if the input is invalid.
+ */
+export declare function parseCustomTimeframe(input: string): Timeframe | null;
+/**
+ * Snap tMin to the nearest bar boundary aligned to Unix epoch.
+ * This keeps grid lines consistent regardless of where you're panning.
+ */
+export declare function snapToBars(ts: bigint, barNs: bigint): bigint;
+export declare function loadCustomTimeframes(): Timeframe[];
+export declare function saveCustomTimeframes(tfs: Timeframe[]): void;
+export declare const DEFAULT_FAVORITE_LABELS: string[];
+export declare function loadFavoriteTimeframes(): string[];
+export declare function saveFavoriteTimeframes(labels: string[]): void;

package/types/lib/tradingview-import.d.ts

@@ -0,0 +1,32 @@
+import type { ChartSettings } from './types/chart-settings';
+/**
+ * Map `tradingview.chartproperties` (plus the separately-stored
+ * `mainSeriesProperties`, which the library keeps more current) onto our settings.
+ * Returns null when there's nothing to import.
+ */
+export declare function readTradingViewChartSettings(): Partial<ChartSettings> | null;
+/**
+ * Map `tradingview.chart.favoriteDrawings` onto our drawing tool ids, dropping
+ * tools we don't implement. Returns null when there's nothing to import.
+ */
+export declare function readTradingViewFavoriteDrawings(): string[] | null;
+/** True when this browser has TradingView preferences worth importing. */
+export declare function hasTradingViewSettings(): boolean;
+export interface TradingViewImportResult {
+    /** Chart settings (colors, grid, margins, chart type, …) were written. */
+    settings: boolean;
+    /** Favorite drawing tools were written. */
+    favorites: boolean;
+}
+/**
+ * Seed empty ChristTrade preferences from TradingView's.
+ *
+ * Each target is imported independently and only when currently unset, so a user
+ * who has customized colors but never starred a drawing still gets their
+ * favorites across. Runs at most once per device unless `force` is passed.
+ */
+export declare function importTradingViewSettings(opts?: {
+    force?: boolean;
+}): TradingViewImportResult;
+/** Forget that the import ran, so the next chart construction retries it. */
+export declare function resetTradingViewImport(): void;

package/types/lib/types/chart-settings.d.ts

@@ -0,0 +1,90 @@
+import type { FootprintMode } from './footprint';
+import type { ChartType } from './index';
+export type ChartSettings = {
+    chartType: ChartType;
+    upBodyColor: string;
+    downBodyColor: string;
+    upWickColor: string;
+    downWickColor: string;
+    upBorderColor: string;
+    downBorderColor: string;
+    wickColorMatchesBody: boolean;
+    borderColorMatchesBody: boolean;
+    wickWidth: number;
+    borderWidth: number;
+    drawEmptyCandles: boolean;
+    baselineValue: number | null;
+    renkoBrickSize: number | null;
+    kagiReversal: number | null;
+    lineBreakCount: number;
+    footprintMode: FootprintMode;
+    footprintVolume: 'none' | 'split' | 'total';
+    footprintImbalanceRatio: number;
+    footprintStackMinCount: number;
+    footprintShowStackedImbalance: boolean;
+    footprintShowAbsorption: boolean;
+    footprintShowUnfinishedAuction: boolean;
+    footprintShowDiagonalImbalance: boolean;
+    footprintDiagRatio: number;
+    footprintAbsorptionMult: number;
+    footprintAbsorptionDeltaFrac: number;
+    priceScaleMode: 'normal' | 'log' | 'percent';
+    autoScale: boolean;
+    priceAxisResizeSensitivity: number;
+    invertScale: boolean;
+    allowLabelOverlap: boolean;
+    /** Smoothly ease the live price line + axis pills toward each new value instead of snapping. */
+    animatePriceUpdates: boolean;
+    scaleMarginTop: number;
+    scaleMarginBottom: number;
+    showGrid: boolean;
+    gridHorizontalColor: string;
+    gridVerticalColor: string;
+    crosshairMode: 'normal' | 'magnet' | 'hidden';
+    crosshairColor: string;
+    crosshairWidth: number;
+    crosshairDash: number[];
+    showBreaks: boolean;
+    breaksColor: string;
+    breaksWidth: number;
+    breaksDash: number[];
+    showStatusLine: boolean;
+    statusLineOHLC: boolean;
+    statusLineVolume: boolean;
+    statusLineDelta: boolean;
+    statusLineChange: boolean;
+    statusLineFontSize: number;
+    backgroundColor: string;
+    axisBackgroundColor: string;
+    showBidLine: boolean;
+    showAskLine: boolean;
+    showMidLine: boolean;
+    showLastTradeLine: boolean;
+    showFills: boolean;
+    showTradeDots: boolean;
+    tradeDotsSizeMult: number;
+    showHeatmap: boolean;
+    heatmapContrast: number;
+    heatmapColorBid: string;
+    heatmapColorAsk: string;
+    resamplingDebounce: number;
+    priceLineVisible: boolean;
+    priceLineColor: string;
+    sessionHighlightEnabled: boolean;
+    sessionHighlightColor: string;
+    horizonScrollEasing: 'none' | 'linear' | 'easeOut' | 'easeInOut';
+    horizonScrollDuration: number;
+    timezone: string;
+    use24HourClock: boolean;
+    showTimezoneLabel: boolean;
+    /**
+     * Settings belonging to plugin chart types, keyed by chart type id. Each
+     * plugin owns its own bag - see `ChartTypePlugin.settingsSchema`.
+     */
+    pluginSettings: Record<string, Record<string, unknown>>;
+};
+export declare const DEFAULT_CHART_SETTINGS: ChartSettings;
+/** Keys whose value differs from DEFAULT_CHART_SETTINGS (deep value compare). */
+export declare function diffChartSettings(settings: ChartSettings): Partial<ChartSettings>;
+/** Re-expand a settings diff back onto the current defaults. */
+export declare function mergeChartSettings(diff?: Partial<ChartSettings>): ChartSettings;