@christtrade/depth 0.12.21

package/types/hooks/useTradingState.d.ts

@@ -0,0 +1,135 @@
+import type { TradeLine } from '../lib/types';
+import { type Order, type Fill, type Position, type BracketAmendment, type PriceTick, type TradingEvent } from '../lib/types/trading-types';
+export interface UseTradingStateOptions {
+    /**
+     * Subscribe to all trading lifecycle events.
+     * Stable reference - wrap in useCallback if defined inline.
+     */
+    onEvent?: (event: TradingEvent) => void;
+    /**
+     * Override the PnL label shown in position line pills.
+     * Default: "+$420.00 - +2.10%"
+     */
+    formatPnlLabel?: (pnl: number, pct: number) => string;
+    /**
+     * Minimum tick size - used to snap bracket order line prices on drag.
+     */
+    tickSize?: number;
+    /**
+     * Dollar value per 1 price-unit move per contract.
+     * Sourced from SymbolInfo.contract.multiplier when available.
+     * Falls back to per-symbol string matching when omitted.
+     */
+    tickValue?: number;
+    /**
+     * Which price to use for unrealized PnL mark.
+     *
+     * 'conservative' (default) - bid for long positions, ask for short.
+     *   This is the exchange-standard mark-to-market convention: it reflects
+     *   the price you would actually receive if you exited right now.
+     *   A long exits by selling -> filled at bid.
+     *   A short exits by buying -> filled at ask.
+     *
+     * 'mid'  - midpoint of bid/ask. Overstates PnL by half the spread on
+     *   both sides. Useful for display purposes only.
+     *
+     * 'last' - last trade price. Natural for replay/backtest scenarios.
+     *   Falls back to mid if no last price is available.
+     *
+     * 'bid'  - always bid regardless of side.
+     * 'ask'  - always ask regardless of side.
+     */
+    markMode?: 'conservative' | 'bid' | 'ask' | 'mid' | 'last';
+    /**
+     * If true, bracket TP/SL lines are only shown when the parent position
+     * line is hovered. Default: false (always visible).
+     */
+    bracketLinesOnHoverOnly?: boolean;
+    onUpdatePosition?: (position: Position) => void;
+    onUpdateOrder?: (order: Order) => void;
+    /**
+     * Called when the user drags a working order line to a new price.
+     * You should send the amend request to your broker here.
+     */
+    onAmendOrder?: (orderId: string, newPrice: number) => void;
+    /**
+     * Called when the user drags a TP or SL bracket line to a new price.
+     * Receives a full BracketAmendment so your broker adapter has everything
+     * it needs: position id, which side, the array index, the level id (if
+     * you assigned one), the new price and the qty of that level.
+     */
+    onAmendBracket?: (amendment: BracketAmendment) => void;
+    /**
+     * Called when the user clicks the x button on an order line.
+     */
+    onCancelOrder?: (orderId: string) => void;
+    /**
+     * Called when the user clicks the x button on a position line.
+     */
+    onClosePosition?: (positionId: string) => void;
+    /**
+     * Called when the user clicks the ↕ (reverse) button on a position line.
+     */
+    onReversePosition?: (positionId: string) => void;
+    /**
+     * Called when user right-clicks any trade line.
+     */
+    onContextMenu?: (kind: 'order' | 'position', id: string, price: number, y: number) => void;
+}
+export interface TradingState {
+    orders: Map<string, Order>;
+    positions: Map<string, Position>;
+    fills: Fill[];
+    tradeLines: TradeLine[];
+}
+export interface UseTradingStateReturn extends TradingState {
+    upsertOrder: (order: Order) => void;
+    removeOrder: (orderId: string) => void;
+    applyFill: (fill: Fill) => void;
+    upsertPosition: (position: Position) => void;
+    toast: (title: string, options?: {
+        description?: string;
+        tone?: 'profit' | 'loss' | 'neutral';
+    }) => void;
+    removePosition: (positionId: string) => void;
+    tick: (priceTick: PriceTick) => void;
+    syncOrders: (orders: Order[]) => void;
+    syncPositions: (positions: Position[]) => void;
+    reset: () => void;
+    /**
+     * The canonical lines map. Pass as `linesRef` to useTradeLines so drag
+     * price updates bypass React state during the drag and go straight to the
+     * canvas via redraw().
+     */
+    linesRef: React.MutableRefObject<Map<string, TradeLine>>;
+    /**
+     * Id of the bracket line currently being dragged. Pass to useTradeLines so
+     * it can flag the active drag; while set, line rebuilds (e.g. from playback
+     * ticks) preserve that line's live price instead of reverting it.
+     */
+    draggingLineIdRef: React.MutableRefObject<string | null>;
+    /**
+     * Register the chart's redraw callback. Call this once after the chart
+     * mounts, e.g. in a useEffect. Enables handle.setLabel / handle.setPrice
+     * to repaint the canvas without a React re-render.
+     *
+     *   useEffect(() => {
+     *     trading.registerRedraw(redraw);
+     *   }, [redraw]);
+     */
+    registerRedraw: (fn: () => void) => void;
+    /**
+     * Pass this directly to useTradeLines as the `onGhostMove` prop.
+     *
+     * When the user drags a ghost TP/SL pill:
+     *   - If a real level already exists at that slot index, its price is updated.
+     *   - If the slot is new (index === existing levels length), a new level is
+     *     appended with qty defaulting to the full remaining position qty minus
+     *     the qty already committed to other levels of the same kind.
+     *   - onAmendBracket is called with the full BracketAmendment.
+     *
+     * lineId format expected: "position:<positionId>"
+     */
+    handleGhostMove: (lineId: string, kind: 'tp' | 'sl', index: number, price: number) => void;
+}
+export declare function useTradingState(options?: UseTradingStateOptions): UseTradingStateReturn;

package/types/interfaces/IAccountAdapter.d.ts

@@ -0,0 +1,38 @@
+import type { Fill, Order, Position, PositionClose } from '../lib/types/trading-types';
+export interface AccountSnapshot {
+    balance: number;
+    equity: number;
+    realizedPnl: number;
+    unrealizedPnl: number;
+    openPositionCount: number;
+    currency: string;
+}
+export interface IAccountAdapter {
+    readonly id: string;
+    /**
+     * AccountManager calls this once on attach so the adapter can register
+     * its push callbacks.
+     */
+    attach(callbacks: AccountAdapterCallbacks): void;
+    /**
+     * Called when AccountManager is destroyed or the adapter is swapped out.
+     */
+    detach(): void;
+    destroy(): void;
+}
+export interface AccountAdapterCallbacks {
+    onFill: (fill: Fill & {
+        ts: bigint;
+    }) => void;
+    onPositionUpdate: (position: Position & {
+        ts: bigint;
+    }) => void;
+    onPositionClose: (close: PositionClose & {
+        ts: bigint;
+    }) => void;
+    onBalanceUpdate: (balance: number, ts: bigint) => void;
+    /** Optional - adapters that surface individual orders can push them here. */
+    onOrderUpdate?: (order: Order & {
+        ts: bigint;
+    }) => void;
+}

package/types/interfaces/ICoordinateTransformer.d.ts

@@ -0,0 +1,105 @@
+import { SessionMapper } from '../core/SessionMapper';
+import { type SessionStatus } from '../core/SessionUtils';
+import type { TradingSession } from './IDataAdapter';
+import type { ViewBounds } from '../lib/types';
+export type PriceScaleMode = 'linear' | 'log' | 'percent';
+export interface ICoordinateTransformer {
+    tsToX(ts: bigint, view: ViewBounds, chartW: number): number;
+    priceToY(price: number, view: ViewBounds, chartH: number): number;
+    xToTs(x: number, view: ViewBounds, chartW: number): bigint;
+    yToPrice(y: number, view: ViewBounds, chartH: number): number;
+}
+export declare class LiveTransformer {
+    private view;
+    private mode;
+    private _sessionMapper;
+    private _barNs;
+    private _barAlignedStarts;
+    private _sessionMapperVersion;
+    private _ordinal;
+    setOrdinal(columnTs: BigInt64Array | null): void;
+    getOrdinal(): BigInt64Array | null;
+    private _ordinalActive;
+    setSessionMapper(mapper: SessionMapper | null): void;
+    getSessionMapper(): SessionMapper | null;
+    /** Fractional column index for a timestamp (monotonic; extrapolates past the ends). */
+    tsToFracIndex(ts: bigint): number;
+    /** Inverse of tsToFracIndex (lerps between columns; extrapolates past the ends). */
+    indexToTs(idx: number): bigint;
+    private _idxMin;
+    private _idxMax;
+    /** Pixel x for a (fractional) column index under the current view. */
+    indexToX(i: number, chartW: number): number;
+    /** Fractional column index at a pixel x under the current view. */
+    xToIndex(x: number, chartW: number): number;
+    /** Fast (index) => x closure for the current frame (renderer hot path). */
+    makeIndexToXFn(chartW: number): (i: number) => number;
+    private _session;
+    setSession(session: TradingSession | null): void;
+    /** Returns the market status (open/closed/pre-post/always) for any UTC ns timestamp. */
+    getSessionStatus(ts: bigint): SessionStatus;
+    /**
+     * Must be called whenever the active timeframe changes. Triggers a recompute
+     * of the per-session bar-alignment offsets on next access.
+     */
+    setBarNs(barNs: bigint): void;
+    private _ensureBarAlignedStarts;
+    /**
+     * Map a real UTC timestamp to bar-aligned market time.
+     *
+     * - Inside segment i: barAlignedStarts[i] + (ts - seg.realStart)
+     * - In a gap between sessions: linearly interpolated into the padding zone
+     *   of the previous segment (preserves continuity during pan/zoom)
+     * - Before first segment / after last segment: linear extrapolation
+     */
+    private _tsToBarAligned;
+    /**
+     * Inverse of _tsToBarAligned.
+     * - In segment i's real zone: exact real timestamp
+     * - In segment i's padding zone: linearly mapped back to real gap timestamp
+     * - Before/after covered range: linear extrapolation
+     */
+    private _barAlignedToTs;
+    /** Called by ChartInner on every view change (pan, zoom, data load). */
+    update(view: ViewBounds): void;
+    /**
+     * Called by ChartInner when ChartSettings.priceScaleMode changes.
+     * All subsequent priceToY / yToPrice calls use the new math automatically.
+     */
+    setScaleMode(mode: PriceScaleMode): void;
+    getScaleMode(): PriceScaleMode;
+    getView(): ViewBounds;
+    tsToX(ts: bigint, chartW: number): number;
+    /**
+     * Returns a fast (ts: bigint) => x closure for the current view + chartW.
+     * Computes mMin and scale once at call time (2 binary searches total instead
+     * of 2N), then uses a per-closure segment hint so sequential point access
+     * (the common case for lines and fills) is O(1) per point.
+     * Call once per draw command; pass the closure to each point in the series.
+     */
+    makeTsToXFn(chartW: number): (ts: bigint) => number;
+    /**
+     * Returns a fast (price: number) => y closure for the current frame.
+     * Linear path is fully pre-baked; log/percent fall back to the method.
+     */
+    makePriceToYFn(chartH: number): (price: number) => number;
+    priceToY(price: number, chartH: number): number;
+    xToTs(x: number, chartW: number): bigint;
+    yToPrice(y: number, chartH: number): number;
+    /**
+     * Pixel width of one bar at the current view and canvas size.
+     * Use in renderer instead of computing barPx from tRange manually.
+     */
+    getBarPx(chartW: number): number;
+    tsToXAt(ts: bigint, view: ViewBounds, chartW: number): number;
+    priceToYAt(price: number, view: ViewBounds, chartH: number): number;
+    xToTsAt(x: number, view: ViewBounds, chartW: number): bigint;
+    yToPriceAt(y: number, view: ViewBounds, chartH: number): number;
+    private _linearPriceToY;
+    private _linearYToPrice;
+    private _logPriceToY;
+    private _logYToPrice;
+    private _pctPriceToY;
+    private _pctYToPrice;
+}
+export type TransformedDrawHook = (ctx: CanvasRenderingContext2D, transformer: LiveTransformer) => void;

package/types/interfaces/IDataAdapter.d.ts

@@ -0,0 +1,402 @@
+/**
+ * The single source of truth for how data enters DepthChart.
+ */
+export type { MboEvent } from '../lib/types';
+import { ReactNode } from 'react';
+import type { Timeframe } from '../lib/timeframes';
+export type DataLevel = 'l3' | 'l2' | 'ohlcv' | 'tick';
+export type DayOfWeek = 'Mon' | 'Tue' | 'Wed' | 'Thu' | 'Fri' | 'Sat' | 'Sun';
+export interface SessionCorrection {
+    /** ISO date: '2024-11-29' */
+    date: string;
+    /** Time range in HHMM-HHMM format: '0930-1300' */
+    hours: string;
+}
+export interface TradingSubsession {
+    id: string;
+    label: string;
+    /** HHMM-HHMM, e.g. '0400-0930'. Overnight: '1800-0000' */
+    hours: string;
+    days?: DayOfWeek[];
+}
+export interface TradingSession {
+    /**
+     * Trading hours in HHMM-HHMM format.
+     * '24/7' or 'always' -> never closed.
+     * Overnight sessions work naturally: '1800-1700' means open 6pm, close 5pm next day.
+     */
+    hours: '24/7' | 'always' | string;
+    /** IANA timezone, e.g. 'America/New_York'. Required unless hours is '24/7'/'always'. */
+    timezone: string;
+    /** Trading days. Defaults to Mon-Fri when omitted. */
+    days?: DayOfWeek[];
+    /** Named subsessions (pre/post market, etc.) - purely for display. */
+    subsessions?: TradingSubsession[];
+    /** Non-trading holidays. ISO dates: ['2024-11-28', '2024-12-25'] */
+    holidays?: string[];
+    /** Partial-session corrections, e.g. early close days. */
+    corrections?: SessionCorrection[];
+}
+export interface FractionalFormat {
+    /** Denominator of the fraction. E.g. 32 for 1/32nds (T-Bonds). */
+    denominator: number;
+    /** Sub-denominator for 1/4 of 1/32 etc. (ZF, ZB). */
+    subDenominator?: number;
+}
+export interface PriceFormat {
+    /** Decimal places for display, e.g. 2 for 19234.25 */
+    precision: number;
+    /** Minimum price increment, e.g. 0.25 for NQ */
+    minTick: number;
+    /** Set for fractional instruments (T-Bonds, Corn futures). */
+    fractional?: FractionalFormat;
+}
+export type SymbolType = 'future' | 'stock' | 'forex' | 'crypto' | 'index' | 'option' | 'spread' | 'bond' | 'etf' | 'custom';
+/**
+ * How an instrument trades. Reached through `SymbolInfo.contract`, which is the
+ * only thing that owns it - the account holds a balance, not a tick size, so
+ * nothing about sizing or pricing should be read off it. Resolve one with
+ * `specForSymbol(info)`.
+ */
+export interface ContractSpec {
+    /** Point value / multiplier. E.g. 20 for NQ ($20/pt). */
+    multiplier?: number;
+    /** Minimum price increment (alias for priceFormat.minTick). */
+    tickSize?: number;
+    /** Cash value of one tick. */
+    tickValue?: number;
+    /** Settlement currency. */
+    currency?: string;
+    /**
+     * Smallest tradable increment of quantity.
+     *
+     * 1 for a listed future, where a third of a contract does not exist. Spot
+     * and perpetual venues are the other case entirely - Binance will sell you
+     * 0.001 BTC - so this is what separates "size" from "contract count", and
+     * order sizing floors to it rather than to whole numbers.
+     *
+     * Defaults to 1, which is the safe reading for anything that forgot to say.
+     */
+    qtyStep?: number;
+    /** Smallest order the venue will accept. Defaults to `qtyStep`. */
+    minQty?: number;
+    /** ISO date of expiry. */
+    expiresAt?: string;
+    /** True for continuous/front-month contracts (/NQ1 etc.) */
+    continuous?: boolean;
+}
+export type SymbolIcon = 
+/** Shorthand for { src }. */
+string
+/** Image URL, data: URI, or imported SVG path. */
+ | {
+    src: string;
+    alt?: string;
+}
+/** Monogram fallback - depth draws the chip. */
+ | {
+    text: string;
+    color?: string;
+}
+/** Escape hatch: any component, sized by the renderer. */
+ | {
+    render: (props: {
+        size: number;
+    }) => ReactNode;
+};
+export interface SymbolInfo {
+    symbol: string;
+    description?: string;
+    /** Full name shown in the symbol picker. Falls back to description. */
+    longName?: string;
+    exchange?: string;
+    /** Listed (primary) exchange, if different from routing exchange. */
+    listedExchange?: string;
+    /** Instrument type. */
+    type: SymbolType;
+    /** Data level this adapter produces. */
+    dataLevel: DataLevel;
+    /** Icon for this symbol. */
+    icon?: SymbolIcon;
+    legendIcon?: SymbolIcon;
+    /**
+     * Price formatting. When omitted, tickSize is used as a fallback for
+     * minTick and precision is inferred from it.
+     */
+    priceFormat: PriceFormat;
+    /** @deprecated Minimum price increment. Fallback for `priceFormat.minTick`. */
+    tickSize?: number;
+    /**
+     * Symbol timezone. Used as the default for session.timezone when not
+     * specified there. Falls back to 'UTC'.
+     */
+    timezone?: string;
+    /** Trading session. When absent, the symbol is treated as 24/7. */
+    session?: TradingSession;
+    /**
+     * How the instrument trades: what a tick is worth, what a point is worth,
+     * and the smallest size the venue accepts. The single source for all of it.
+     *
+     * Every instrument type, not only futures and options - spot crypto has a
+     * tick size and a (fractional) size step just as much as a listed contract
+     * does, and anything that sizes an order needs both.
+     */
+    contract?: ContractSpec;
+    /** Locale for number formatting. E.g. 'en-US'. */
+    locale?: string;
+    /** Volume decimal places. 0 = always integer. Default 0. */
+    volumePrecision?: number;
+    /** Subsymbols shown in the symbol picker (e.g. individual contracts under /NQ1). */
+    subsymbols?: SymbolInfo[];
+    /**
+     * Extra search terms. The built-in matcher searches these alongside symbol,
+     * name and exchange, so `keywords: ['gold', 'bullion']` makes XAUUSD
+     * reachable by typing "gold". Adapters that search server-side
+     * (`symbolSearch: 'server'`) own their own matching and can ignore this.
+     */
+    keywords?: string[];
+    /**
+     * Ascending-sorted list of barNs values this adapter can natively serve.
+     *
+     * DataEngine picks the coarsest supported resolution <= the active timeframe
+     * for all fetches. When the active timeframe drops below a loaded segment's
+     * resolution, DataEngine re-fetches that segment at the finer resolution
+     * and emits `data:refine` so ChartInner can replace the stale bars.
+     *
+     * Example: `[60_000_000_000n, 300_000_000_000n, 3_600_000_000_000n]`
+     * declares native support for 1m, 5m, and 1h bars.
+     *
+     * If omitted or empty, the adapter is assumed to handle any barNs (legacy behavior).
+     */
+    supportedResolutions?: bigint[];
+    /** Arbitrary extra metadata. Not processed by the engine. */
+    meta?: Record<string, unknown>;
+}
+export interface OhlcvBar {
+    /** Unix timestamp in milliseconds (ms since epoch). */
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+    /** Best bid at bar close. When absent the engine falls back to close minus half a tick. */
+    bid?: number;
+    /** Best ask at bar close. When absent the engine falls back to close plus half a tick. */
+    ask?: number;
+}
+export interface TickEvent {
+    /** Unix timestamp in milliseconds (ms since epoch). */
+    time: number;
+    price: number;
+    size: number;
+    side: 'B' | 'A' | 'N';
+}
+export interface L2Snapshot {
+    /** Unix timestamp in milliseconds (ms since epoch). */
+    time: number;
+    bids: Array<{
+        price: number;
+        size: number;
+    }>;
+    asks: Array<{
+        price: number;
+        size: number;
+    }>;
+}
+/**
+ * A half-open time range `[from, to)` since the Unix epoch, with `from` always
+ * <= `to` (see {@link FetchRequest.direction} for which edge a fetch extends).
+ *
+ * The same instant is offered in three units so adapters can use whichever maps
+ * cleanest onto their backend: nanoseconds are canonical (full precision); the
+ * `Ms` / `Iso` forms are derived conveniences. The ISO strings carry
+ * nanosecond precision, e.g. `'2024-05-29T00:00:00.000000000Z'`.
+ *
+ * Build one with {@link makeTimeRange} so the derived forms stay consistent.
+ */
+export interface TimeRange {
+    /** Start, ns since epoch (inclusive). Canonical. */
+    fromNs: bigint;
+    /** End, ns since epoch (exclusive). Canonical. */
+    toNs: bigint;
+    /** Start, ms since epoch (inclusive). Truncated from `fromNs`. */
+    fromMs: number;
+    /** End, ms since epoch (exclusive). Truncated from `toNs`. */
+    toMs: number;
+    /** Start as a nanosecond-precision ISO 8601 string. */
+    fromIso: string;
+    /** End as a nanosecond-precision ISO 8601 string. */
+    toIso: string;
+}
+/**
+ * Nanosecond-precision ISO 8601 string for a ns-since-epoch instant, e.g.
+ * `'2024-05-29T00:00:00.000000000Z'`. Use {@link Date} on the `Ms` forms if you
+ * only need millisecond precision.
+ */
+export declare function nsToIso(ns: bigint): string;
+/** Build a {@link TimeRange} from ns bounds, filling in the ms/ISO conveniences. */
+export declare function makeTimeRange(fromNs: bigint, toNs: bigint): TimeRange;
+export interface FetchRequest {
+    /**
+     * The instrument being requested, with its price format, session, data
+     * level and any other metadata. Multi-symbol adapters key off
+     * `symbolInfo.symbol`; single-symbol adapters can ignore it.
+     */
+    symbolInfo: SymbolInfo;
+    /**
+     * Chronological span to cover. `range.fromNs` is always <= `range.toNs`
+     * regardless of `direction` - the bounds are never reversed.
+     */
+    range: TimeRange;
+    /**
+     * Target bar resolution, with its human label and default bar count.
+     * Read `timeframe.barNs` for the bar duration in nanoseconds.
+     */
+    timeframe: Timeframe;
+    /**
+     * Which edge of the loaded data this fetch is extending:
+     *  - `initial`  - the first load for a window.
+     *  - `forward`  - newer bars, appended to the right.
+     *  - `backward` - older bars, prepended to the left.
+     */
+    direction: 'initial' | 'forward' | 'backward';
+    /**
+     * When set, also return bars at this finer resolution (ns) as
+     * `supplementalBars`, for smoother playback. The engine sets this
+     * automatically from the adapter's getCapabilities().
+     */
+    supplementalBarNs?: bigint;
+}
+export interface SupplementalBarSet {
+    /** barNs of the finer-resolution data */
+    resolution: bigint;
+    bars: OhlcvBar[];
+}
+export interface BarResponse {
+    /** Raw MBO events (L3). Leave empty for other data levels or _preProcessed. */
+    events: import('../lib/types').MboEvent[];
+    /** OHLCV bars - populate for dataLevel === 'ohlcv' */
+    ohlcvBars?: OhlcvBar[];
+    /**
+     * Optional finer-resolution bars for the same time range.
+     * The engine uses these to produce smoother playback via real prices instead
+     * of the synthetic interpolation fallback.
+     */
+    supplementalBars?: SupplementalBarSet[];
+    /** Tick events - populate for dataLevel === 'tick' */
+    ticks?: TickEvent[];
+    /** L2 depth snapshots - populate for dataLevel === 'l2' */
+    l2Snapshots?: L2Snapshot[];
+    hasMore: boolean;
+    coveredFrom?: bigint;
+    coveredTo?: bigint;
+    _preProcessed?: PreProcessedPayload;
+}
+export interface AdapterCapabilities {
+    /**
+     * Finer-resolution bar granularities this adapter can supply as
+     * supplementalBars alongside OHLCV responses (sorted finest-first).
+     * E.g. [1_000_000_000n] means S1 data is available.
+     */
+    supplementalResolutions?: bigint[];
+    /**
+     * Who filters symbol searches. See {@link SymbolSearchMode}.
+     * Defaults to 'none'.
+     */
+    symbolSearch?: SymbolSearchMode;
+    /**
+     * How long the picker waits after a keystroke before searching, in ms.
+     *
+     * Defaults to 200 for `symbolSearch: 'server'` - enough to stop a request
+     * per character going out over the network - and 0 for 'none', which matches
+     * in memory. Override it when the default misreads your adapter: set 0 if you
+     * declare 'server' but search a list you already hold in memory, or raise it
+     * if each search is expensive or rate-limited.
+     */
+    symbolSearchDebounceMs?: number;
+}
+export interface BarPreviewResponse {
+    symbol: string;
+    bars: {
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+        time: number;
+    }[];
+}
+export interface PreProcessedPayload {
+    compactBuf: ArrayBuffer;
+    trades: import('../lib/types').SerialTrade[];
+    priceHistory: import('../lib/types').PriceHistory[];
+    footprintBars: import('../lib/types/footprint').FootprintBar[];
+    dataStart: number;
+    dataEnd: number;
+}
+/**
+ * Who filters a {@link SymbolSearchRequest}.
+ *
+ * 'none' (default) - the adapter ignores `query` and the facets and returns its
+ * whole universe. The engine calls `searchSymbols` once, caches the result, and
+ * matches + ranks locally on every keystroke. Right for any universe small
+ * enough to ship to the client.
+ *
+ * 'server' - the adapter honors `query`, the facets, `limit` and `cursor`. The
+ * engine forwards every (debounced) keystroke and does no matching of its own.
+ * Right for a broker or exchange with tens of thousands of instruments.
+ */
+export type SymbolSearchMode = 'server' | 'none';
+export interface SymbolSearchRequest {
+    /** Free text. `''` means browse: the picker just opened, nothing typed. */
+    query: string;
+    /** Facet filters. Undefined means "any". */
+    type?: SymbolType;
+    exchange?: string;
+    dataLevel?: DataLevel;
+    /** How many results the caller wants. Adapters may return fewer. */
+    limit?: number;
+    /** Opaque cursor from a previous response. Set when paging in more results. */
+    cursor?: string;
+    /**
+     * Aborted when this search is superseded (the user typed again) or
+     * abandoned (the picker closed). Honor it if your transport can - the
+     * engine drops late responses either way.
+     */
+    signal?: AbortSignal;
+}
+export interface SymbolSearchResponse {
+    symbols: SymbolInfo[];
+    /** True when more results exist past this page. */
+    hasMore?: boolean;
+    /** Pass back as `request.cursor` to fetch the next page. */
+    cursor?: string;
+}
+export interface IDataAdapter {
+    resolveSymbol(symbol: string): SymbolInfo | Promise<SymbolInfo>;
+    /**
+     * Supply symbols for the picker. Return a bare array to hand over the whole
+     * universe and let the engine match locally; return a
+     * {@link SymbolSearchResponse} to page results yourself. Which of the two
+     * the engine expects is decided by `getCapabilities().symbolSearch`.
+     */
+    searchSymbols(request: SymbolSearchRequest): Promise<SymbolSearchResponse | SymbolInfo[]>;
+    fetchBars(request: FetchRequest): Promise<BarResponse>;
+    fetchPreview?(request: FetchRequest): Promise<BarPreviewResponse>;
+    subscribeRealtime?(onBar: (bar: BarResponse) => void): () => void;
+    connect?(): Promise<void>;
+    destroy?(): void;
+    /**
+     * Declare what supplemental resolutions this adapter can provide.
+     * Called once after resolveSymbol(). The engine attaches the finest
+     * declared resolution as supplementalResolution in every FetchRequest.
+     */
+    getCapabilities?(): AdapterCapabilities;
+}
+export type DataAdapterErrorCode = 'unauthenticated' | 'forbidden' | 'not_found' | 'no_data' | 'rate_limited' | 'server_error' | 'network_error' | 'decode_error' | 'unknown';
+export declare class DataAdapterError extends Error {
+    readonly code: DataAdapterErrorCode;
+    readonly httpStatus?: number;
+    constructor(code: DataAdapterErrorCode, message: string, httpStatus?: number);
+}