@christtrade/depth 0.12.21

package/types/core/ExecutionEngine.d.ts

@@ -0,0 +1,95 @@
+import { IExecutionAdapter } from '../interfaces/IExecutionAdapter';
+import type { PlaceOrderRequest, FillSearchOptions, FillAmbiguity } from '../lib/matchingEngine';
+import { L3MatchingEngine } from '../lib/matchingEngine';
+import type { TypedEventBus } from './TypedEventBus';
+import type { BracketAmendment, Order, Position } from '../lib/types/trading-types';
+import type { MboEvent, PriceHistory } from '../lib/types';
+import type { OhlcvBar } from '../interfaces/IDataAdapter';
+import type { SerialTrade } from '../lib/types';
+/**
+ * Vetoes an order before it reaches a book. Return a reason to refuse it, or
+ * null to let it through. Pre-trade risk lives here rather than in the caller,
+ * since every order route lands on placeOrder and there are several.
+ */
+export type OrderGuard = (req: PlaceOrderRequest) => string | null;
+export declare class ExecutionEngine {
+    private builtIns;
+    private activeSymbol;
+    private custom;
+    private destroyed;
+    private guard;
+    private eventBus;
+    private fillSearch;
+    attachBuiltIn(engine: L3MatchingEngine, symbol: string): void;
+    setFillSearch(patch: Partial<FillSearchOptions>): void;
+    getFillSearch(): FillSearchOptions;
+    hasPendingTriggers(symbol?: string): boolean;
+    settleGapBars(bars: Array<{
+        tsNs: bigint;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+    }>, ambiguity?: FillAmbiguity, symbol?: string): void;
+    detachBuiltIn(symbol: string): void;
+    /**
+     * Switch the active symbol - the default target for calls that don't name
+     * one. In a layout this follows the focused pane, so a plugin calling
+     * `placeOrder` with no symbol lands on the chart the user is looking at.
+     */
+    setActiveSymbol(symbol: string): void;
+    /** The instrument symbol-less calls currently resolve to. */
+    getActiveSymbol(): string;
+    /**
+     * Last traded price for a symbol. NaN when the book has no price yet - no
+     * such instrument, or its data hasn't landed. Callers that act on the number
+     * must check `Number.isFinite` first.
+     */
+    getCurrentPrice(symbol: string): number;
+    /** Whether a book can price an order right now. */
+    hasPrice(symbol?: string): boolean;
+    setCustomAdapter(adapter: IExecutionAdapter | null): void;
+    private builtInFor;
+    private targetFor;
+    private eachBuiltIn;
+    ingestCompactBuf(buf: ArrayBuffer, symbol?: string): void;
+    ingestOhlcvBars(bars: OhlcvBar[], barNs?: bigint, symbol?: string): void;
+    appendOhlcvBars(bars: OhlcvBar[], barNs?: bigint, symbol?: string): void;
+    ingestSupplementalBars(bars: Array<{
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>, symbol?: string): void;
+    appendSupplementalBars(bars: Array<{
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }>, symbol?: string): void;
+    ingestTicks(trades: SerialTrade[], symbol?: string): void;
+    ingestPriceHistory(history: PriceHistory[], symbol?: string): void;
+    appendTicks(trades: SerialTrade[], symbol?: string): void;
+    appendPriceHistory(history: PriceHistory[], symbol?: string): void;
+    appendCompactBuf(buf: ArrayBuffer, symbol?: string): void;
+    seekTo(tNs: bigint, symbol?: string): void;
+    onMboEvent(event: MboEvent, tsNs: bigint, symbol?: string): void;
+    /** Refused orders emit `trading:order-blocked` and never reach a book. */
+    setOrderGuard(guard: OrderGuard | null): void;
+    setEventBus(eventBus: TypedEventBus | null): void;
+    placeOrder(req: PlaceOrderRequest): string | Promise<string> | undefined;
+    cancelOrder(orderId: string): void;
+    amendOrder(orderId: string, newPrice: number): void;
+    amendBracket(amendment: BracketAmendment): void;
+    closePosition(positionId: string): void;
+    reversePosition(positionId: string): void;
+    syncPosition(position: Position): void;
+    syncOrder(order: Order): void;
+    totalFeesPaid(): number;
+    totalRealizedPnl(): number;
+    destroy(): void;
+}

package/types/core/GlobalChartBus.d.ts

@@ -0,0 +1,32 @@
+import type { DepthChart } from './DepthChart';
+export type GlobalEventMap = {
+    'global:chart-registered': {
+        id: string;
+        chart: DepthChart;
+    };
+    'global:chart-unregistered': {
+        id: string;
+    };
+    'global:focus-changed': {
+        chartId: string | null;
+    };
+    [key: string]: unknown;
+};
+export type GlobalHandler<T = unknown> = (data: T) => void;
+export declare class GlobalChartBus {
+    private readonly handlers;
+    private readonly charts;
+    private focusedChartId;
+    registerChart(chart: DepthChart): void;
+    unregisterChart(id: string): void;
+    setFocus(chartId: string): void;
+    getChart(id: string): DepthChart | null;
+    getCharts(): ReadonlyMap<string, DepthChart>;
+    getFocusedChartId(): string | null;
+    on<K extends keyof GlobalEventMap>(event: K, handler: GlobalHandler<GlobalEventMap[K]>): () => void;
+    emit<K extends keyof GlobalEventMap>(event: K, data: GlobalEventMap[K]): void;
+    once<K extends keyof GlobalEventMap>(event: K, handler: GlobalHandler<GlobalEventMap[K]>): () => void;
+    broadcastTo<K extends keyof import('./TypedEventBus').ChartEvents>(chartId: string, event: K, data: import('./TypedEventBus').ChartEvents[K]): void;
+    broadcastAll<K extends keyof import('./TypedEventBus').ChartEvents>(event: K, data: import('./TypedEventBus').ChartEvents[K]): void;
+}
+export declare const globalChartBus: GlobalChartBus;

package/types/core/Playback.d.ts

@@ -0,0 +1,48 @@
+import { PlaybackMode } from '../hooks/usePlaybackEngine';
+import { TypedEventBus } from './TypedEventBus';
+export declare function toNs(t: bigint | number | Date | string): bigint;
+export declare class PlaybackController {
+    private eventBus;
+    private isPlaying;
+    private currentStepSize;
+    private currentSpeed;
+    private currentMode;
+    private currentStepSnap;
+    private currentTime;
+    private forwardOnly;
+    private floorNs;
+    private subscriptions;
+    constructor(eventBus: TypedEventBus, initialTimeNs?: bigint);
+    play(): void;
+    pause(): void;
+    playing(): boolean;
+    stepSize(): string;
+    setStepSize(step: string): void;
+    mode(): PlaybackMode;
+    setMode(mode: PlaybackMode): void;
+    stepSnap(): boolean;
+    setStepSnap(snap: boolean): void;
+    speed(): number;
+    setSpeed(speed: number): void;
+    /**
+     * Refuse any move that would put the playhead behind where it has already
+     * been. The floor starts wherever it is when the lock goes on.
+     */
+    lockForward(on: boolean): void;
+    /** The earliest time the playhead may move to, or null when unlocked. */
+    floor(): bigint | null;
+    allows(tNs: bigint): boolean;
+    private refuse;
+    stepBack(): void;
+    stepForward(): void;
+    /** Where the playhead currently is, in epoch ns. */
+    time(): bigint;
+    /**
+     * Jump the playhead anywhere, pausing first. The target may sit outside the
+     * loaded window, in which case the engine streams or re-centers to reach it,
+     * and it clamps to the last available bar if the data runs out.
+     */
+    goTo(t: bigint | number | Date | string): void;
+    subscribeToEvents(): void;
+    destroy(): void;
+}

package/types/core/PlaybackStateRegistry.d.ts

@@ -0,0 +1,25 @@
+import type { TypedEventBus } from './TypedEventBus';
+export interface PluginStateSnapshot {
+    serialize(): unknown;
+    restore(state: unknown): void;
+}
+export declare class PlaybackStateRegistry {
+    private readonly eventBus;
+    private readonly plugins;
+    private readonly checkpoints;
+    private lastCheckpointNs;
+    private currentHorizonNs;
+    private readonly intervalNs;
+    private readonly unsubs;
+    constructor(eventBus: TypedEventBus, opts?: {
+        intervalNs?: bigint;
+    });
+    register(pluginId: string, snapshot: PluginStateSnapshot): () => void;
+    onHorizonAdvance(horizonNs: bigint): void;
+    private _snapshot;
+    restoreToNearest(targetNs: bigint): bigint | null;
+    private _resetAll;
+    private _wire;
+    getCheckpointCount(): number;
+    destroy(): void;
+}

package/types/core/PluginRegistry.d.ts

@@ -0,0 +1,67 @@
+import { RenderEngine } from './RenderEngine';
+import { TypedEventBus } from './TypedEventBus';
+export interface PluginIcon {
+    viewBox: string;
+    paths: string[];
+}
+export type { PluginType, Permission, ToolbarItem, BottomBarItem, BottomBarHandle, FloatingPanelOpts, ContextMenuItem, ThemeDef, SettingSchema, SettingSchemaType, PluginStorage, ServiceApi, ServiceObserver, PluginServices, PluginSchedule, NotifyLevel, NotifyOptions, PluginStateSnapshot, PluginExecutionSurface, PluginLifecycle, PaneOptions, PluginDataSnapshot, PluginContext, ChartPlugin, PluginManifest, } from '../interfaces/plugins/IChartPlugin';
+export type { DrawingPlugin } from '../interfaces/plugins/IDrawingPlugin';
+export type { ChartTypePlugin, ChartTypeRenderContext, ChartTypeActiveContext, ChartTypePointerEvent, ChartTypeKeyEvent, } from '../interfaces/plugins/IChartTypePlugin';
+export type { DataSourcePlugin } from '../interfaces/plugins/IDataSourcePlugin';
+export type { IndicatorPlugin } from '../interfaces/plugins/IIndicatorPlugin';
+import type { ChartPlugin, PluginContext, PluginLifecycle, PluginServices } from '../interfaces/plugins/IChartPlugin';
+/**
+ * A pooled plugin as persisted in a save document. The id is kept so a restore
+ * re-installs under the same one, and a host that also installs the plugin
+ * manually dedups against the restored copy rather than accumulating duplicates.
+ */
+export interface InstalledPlugin {
+    id: string;
+    code: string;
+}
+export declare class PluginRegistry {
+    private installed;
+    private readonly serviceRegistry;
+    private readonly serviceListeners;
+    private pendingInstalls;
+    private renderEngineReady;
+    private eventBus;
+    options: {
+        enabled: boolean;
+        indicator: boolean;
+        drawing: boolean;
+        'chart-type': boolean;
+        extension: boolean;
+    };
+    setOptions(options: {
+        enabled: boolean;
+        indicators: boolean;
+        drawings: boolean;
+        charts: boolean;
+        extensions: boolean;
+    }): void;
+    setEventBus(bus: TypedEventBus): void;
+    /**
+     * Is this id installed, or queued for install? Install is async - a plugin
+     * registered before the RenderEngine attaches sits in pendingInstalls, and
+     * callers have to treat that as installed or they double-install it.
+     */
+    has(id: string): boolean;
+    /** Ids of every installed / pending plugin. */
+    getInstalledIds(): string[];
+    /** Name and type of every installed / pending plugin, for a manager UI. */
+    getInstalledPlugins(): Array<{
+        id: string;
+        name: string;
+        type: ChartPlugin['type'];
+    }>;
+    register(plugin: ChartPlugin, ctx: PluginContext): Promise<void>;
+    notifyRenderEngineReady(engine: RenderEngine): void;
+    buildLifecycle(eventBus: TypedEventBus): PluginLifecycle;
+    private _doInstall;
+    buildServices(pluginId: string): PluginServices;
+    private buildRestrictedContext;
+    serialize(): InstalledPlugin[];
+    unregister(id: string): void;
+    destroy(): void;
+}

package/types/core/PluginSchedule.d.ts

@@ -0,0 +1,15 @@
+export interface PluginSchedule {
+    interval(ms: number, fn: () => void): () => void;
+    timeout(ms: number, fn: () => void): () => void;
+    raf(fn: () => void): () => void;
+}
+export declare class PluginScheduleImpl implements PluginSchedule {
+    private readonly intervals;
+    private readonly timeouts;
+    private readonly rafIds;
+    private destroyed;
+    interval(ms: number, fn: () => void): () => void;
+    timeout(ms: number, fn: () => void): () => void;
+    raf(fn: () => void): () => void;
+    destroy(): void;
+}

package/types/core/RenderEngine.d.ts

@@ -0,0 +1,143 @@
+import { TypedEventBus } from './TypedEventBus';
+import type { ChartPane, Rect } from '../lib/types/indicator-types';
+import type { Indicator } from '../lib/types/indicator-types';
+import type { TradePoint, PriceHistory, ViewBounds } from '../lib/types';
+import type { FootprintBar } from '../lib/types/footprint';
+import type { ChartSettings } from '../lib/types/chart-settings';
+import type { Crosshair } from '../lib/renderers/renderer';
+import type { Drawing, DraftDrawing, DrawingAnchorId, ActiveDrawingTool } from '../lib/types/drawing-types';
+import type { TradeLine } from '../lib/types';
+import { LiveTransformer } from '../interfaces/ICoordinateTransformer';
+import { ChartTypePlugin } from './PluginRegistry';
+import { SessionMapper } from './SessionMapper';
+import { AccountSnapshot, DataLevel, SymbolInfo } from '.';
+import type { CrosshairSync } from '../lib/types/layout-sync';
+export type DrawHook = (ctx: CanvasRenderingContext2D, view: ViewBounds, transformer: LiveTransformer) => void;
+export interface DrawParams {
+    panes: ChartPane[];
+    layouts: Record<string, Rect>;
+    indicators: Indicator[];
+    trades: TradePoint[];
+    priceHistory: PriceHistory[];
+    footprintBars: FootprintBar[];
+    heatmapBitmap: ImageBitmap | null;
+    bitmapOffsets: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+    barNs: bigint;
+    chartSettings: ChartSettings;
+    horizon: bigint;
+    candleCache: Map<bigint, any> | null;
+    openBar: FootprintBar | null;
+    /** Bars to render as candles - OHLCV adapter data or loading-preview bars. */
+    ohlcvBars: {
+        time: number;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume: number;
+    }[];
+    crosshair: Crosshair | null;
+    drawings: Drawing[];
+    draft: DraftDrawing | null;
+    tradeLines: TradeLine[];
+    hoveredDividerIdx: number;
+    hoveringLegend: boolean;
+    showTooltip: boolean;
+    selectedTrade: TradePoint | null;
+    activeTool: ActiveDrawingTool;
+    draggingAnchor: any;
+    isHoldingCtrl: boolean;
+    isHoldingShift: boolean;
+    showShiftInfo: boolean;
+    shiftInfoAnchor: {
+        ts: bigint;
+        price: number;
+        x: number;
+        y: number;
+    };
+    shiftInfoAnchor2: {
+        ts: bigint;
+        price: number;
+        x: number;
+        y: number;
+    } | null;
+    tradeLineInteraction: any;
+    selectedDrawingId: string;
+    hoveredDrawingId: string;
+    hotAnchor: DrawingAnchorId;
+    editingTextId: string;
+    transformer: LiveTransformer;
+    sessionMapper: SessionMapper;
+    isPluginChartType: boolean;
+    chartPlugin?: ChartTypePlugin;
+    pluginComputed?: unknown;
+    dataLevel: DataLevel;
+    accountSnapshot: AccountSnapshot;
+    symbolInfo: SymbolInfo;
+    /**
+     * Width (css px) of the right price axis. Derived from the symbol's price
+     * precision and the visible range, not a user setting.
+     */
+    priceScaleWidth: number;
+    hidePriceScale: boolean;
+    hideTimeScale: boolean;
+    /**
+     * Crosshair mirrored from another cell of the layout, in data space.
+     * Projected onto this chart's own axes at paint time, so pan and zoom keep it
+     * on the right bar with no extra traffic. Null when this chart owns the
+     * pointer, or nothing is being mirrored.
+     */
+    syncCrosshair: CrosshairSync | null;
+}
+export declare class RenderEngine {
+    private readonly baseCanvas;
+    private readonly drawingsCanvas;
+    private readonly uiCanvas;
+    private readonly eventBus;
+    private readonly chartId;
+    private rafId;
+    private dirty;
+    private beforeBaseDraw;
+    private afterBaseDraw;
+    private afterUIDraw;
+    private drawParams;
+    private view;
+    private readonly priceTransition;
+    private resizeObserver;
+    private destroyed;
+    constructor(baseCanvas: HTMLCanvasElement, drawingsCanvas: HTMLCanvasElement, uiCanvas: HTMLCanvasElement, eventBus: TypedEventBus, chartId?: number);
+    private startLoop;
+    markDirty(layer: 'base' | 'drawings' | 'ui'): void;
+    markAllDirty(): void;
+    setDrawParams(params: DrawParams): void;
+    setView(v: ViewBounds): void;
+    getView(): ViewBounds | null;
+    private doBaseRedraw;
+    /**
+     * Draws the ChristTrade banner into the base layer, in the same pass that
+     * paints the price data, so the attribution shares the chart's coordinate
+     * space and DPR transform.
+     *
+     * Apache-2.0 does not require you to keep this. See the Attribution section
+     * of the README for the ask, and NOTICE for what the trademark does cover.
+     */
+    private drawAttribution;
+    private doDrawingsRedraw;
+    private doUIRedraw;
+    addDrawHook(phase: 'before-base' | 'after-base' | 'after-ui', hook: DrawHook): () => void;
+    private handleResize;
+    private flushSync;
+    toDataURL(type?: string): string;
+    /**
+     * All three layers flattened onto a fresh canvas, in paint order. Use this
+     * rather than `toDataURL` when the snapshot should include the drawings and
+     * the crosshair/UI layer.
+     */
+    captureComposite(): HTMLCanvasElement;
+    destroy(): void;
+}

package/types/core/ScriptedPlugin.d.ts

@@ -0,0 +1,153 @@
+import type { ChartPlugin } from './PluginRegistry';
+import type { StyleField } from '../components/drawings/drawing-settings-dialog';
+export type ParamDef = {
+    label: string;
+    type: 'number';
+    default: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+} | {
+    label: string;
+    type: 'stepperInt';
+    default: number;
+    min?: number;
+    max?: number;
+    step?: number;
+} | {
+    label: string;
+    type: 'slider';
+    default: number;
+    min: number;
+    max: number;
+    step?: number;
+    suffix?: string;
+} | {
+    label: string;
+    type: 'rangeWithSteps';
+    default: number;
+    min: number;
+    max: number;
+    steps: {
+        value: number;
+        label: string;
+    }[];
+} | {
+    label: string;
+    type: 'opacity';
+    default: number;
+} | {
+    label: string;
+    type: 'fontSize';
+    default: number;
+} | {
+    label: string;
+    type: 'color';
+    default: string;
+} | {
+    label: string;
+    type: 'text';
+    default: string;
+    placeholder?: string;
+    maxLength?: number;
+} | {
+    label: string;
+    type: 'select';
+    default: string;
+    options: string[] | {
+        value: string;
+        label: string;
+    }[];
+} | {
+    label: string;
+    type: 'buttonGroup';
+    default: string;
+    options: {
+        value: string;
+        label: string;
+    }[];
+} | {
+    label: string;
+    type: 'boolean';
+    default: boolean;
+} | {
+    label: string;
+    type: 'checkbox';
+    default: boolean;
+    description?: string;
+} | {
+    label: string;
+    type: 'dualColor';
+    labelA: string;
+    defaultA: string;
+    labelB: string;
+    defaultB: string;
+} | {
+    label: string;
+    type: 'dualOpacity';
+    labelA: string;
+    defaultA: number;
+    labelB: string;
+    defaultB: number;
+} | {
+    label: string;
+    type: 'colorGradient';
+    defaultStart: string;
+    defaultEnd: string;
+} | {
+    label: string;
+    type: 'colorWithOpacity';
+    defaultColor: string;
+    defaultOpacity: number;
+} | {
+    label: string;
+    type: 'toggledColor';
+    defaultToggle: boolean;
+    defaultColor: string;
+} | {
+    label: string;
+    type: 'toggledInput';
+    toggleLabel: string;
+    inputLabel: string;
+    defaultToggle: boolean;
+    defaultInput: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+} | {
+    label: string;
+    type: 'inlineFields';
+    fields: Array<{
+        type: 'stepperInt';
+        key: string;
+        label: string;
+        default: number;
+        min?: number;
+        max?: number;
+        step?: number;
+    } | {
+        type: 'buttonGroup';
+        key: string;
+        label: string;
+        default: string;
+        options: {
+            value: string;
+            label: string;
+        }[];
+    } | {
+        type: 'checkbox';
+        key: string;
+        label: string;
+        default: boolean;
+    }>;
+};
+export declare function hasFunctionDecl(script: string, name: string): boolean;
+export declare function buildStyleSchema(paramDefs: Record<string, ParamDef>): StyleField[];
+export declare function buildParamDefaults(paramDefs: Record<string, ParamDef>): Record<string, unknown>;
+/**
+ * @param category Fallback picker category, used when the script doesn't declare
+ *                 one itself. The built-ins pass theirs here.
+ */
+export declare function createScriptedPlugin(script: string, id?: string, category?: string): ChartPlugin;

package/types/core/SessionMapper.d.ts

@@ -0,0 +1,54 @@
+import type { TradingSession } from '../interfaces/IDataAdapter';
+export interface SessionSegment {
+    /** Real UTC ns start of this open window */
+    realStart: bigint;
+    /** Real UTC ns end (exclusive) */
+    realEnd: bigint;
+    /** Market-ns offset at realStart */
+    marketStart: bigint;
+    /** Duration of this open window in market-ns (= realEnd - realStart) */
+    duration: bigint;
+}
+export declare class SessionMapper {
+    segments: SessionSegment[];
+    private totalMarketNs;
+    /** Real ns range this mapper covers */
+    rangeFrom: bigint;
+    rangeTo: bigint;
+    /** Bumped on every mutation, so LiveTransformer can spot a stale cache. */
+    version: number;
+    private _buildSegments;
+    /** Build the mapper over a real-time range. Resolved to the minute. */
+    build(session: TradingSession | null, from: bigint, to: bigint): void;
+    /**
+     * Extend the mapper backward to cover `newFrom` up to the current start.
+     * Only walks the new range, and shifts every existing segment's marketStart
+     * to account for the history prepended in front of it.
+     */
+    extendBackward(session: TradingSession | null, newFrom: bigint): void;
+    get hasSession(): boolean;
+    /**
+     * The open window containing `ts`, or null when it lands in a closed one or
+     * outside the built range.
+     *
+     * Exposed because bar buckets are anchored to the session open: which bar a
+     * timestamp falls in is answered from the segment's start rather than an
+     * epoch multiple, and several places need to answer it the same way.
+     */
+    segmentAt(ts: bigint): SessionSegment | null;
+    /** Real UTC ns to market ns, snapping a closed window to the nearest edge. */
+    tsToMarket(ts: bigint): bigint;
+    /** Market ns back to real UTC ns. */
+    marketToTs(market: bigint): bigint;
+    getBreaks(): {
+        ts: bigint;
+        type: string;
+    }[];
+    /** The market span a real [from, to] range covers. */
+    realSpanToMarketSpan(from: bigint, to: bigint): bigint;
+    /** A real ts to a pixel x in [0, chartW]. tMin/tMax are real ns view bounds. */
+    tsToX(ts: bigint, tMin: bigint, tMax: bigint, chartW: number): number;
+    /** And back: a pixel x in [0, chartW] to real UTC ns. */
+    xToTs(x: number, tMin: bigint, tMax: bigint, chartW: number): bigint;
+}
+export declare function createSessionMapper(): SessionMapper;

package/types/core/SessionUtils.d.ts

@@ -0,0 +1,53 @@
+import type { TradingSession } from '../interfaces/IDataAdapter';
+/**
+ * The wall-clock date/time a UTC ns timestamp lands on in an IANA timezone.
+ * Month is 1-based, dayOfWeek is 0=Sun.
+ */
+export declare function wallClock(ns: bigint, tz: string): {
+    year: number;
+    month: number;
+    day: number;
+    dayOfWeek: number;
+    minuteOfDay: number;
+    isoDate: string;
+};
+export declare function isMarketOpenFromWC(session: TradingSession, minuteOfDay: number, dayOfWeek: number, isoDate: string): boolean;
+export type SessionStatus = {
+    kind: 'always';
+} | {
+    kind: 'open';
+} | {
+    kind: 'sub';
+    label: string;
+} | {
+    kind: 'closed';
+};
+/**
+ * Market status at a UTC ns timestamp. Checks the main session first, then any
+ * named subsessions (pre/post market and so on).
+ */
+export declare function getSessionStatus(session: TradingSession | null, atNs: bigint): SessionStatus;
+export interface SessionWindow {
+    from: bigint;
+    to: bigint;
+}
+/** Is the market open at this UTC ns timestamp? */
+export declare function isMarketOpen(session: TradingSession, atNs: bigint): boolean;
+/**
+ * Clip a UTC ns range into the open market windows inside it, ascending.
+ * Closed windows are dropped, and a 24/7 session returns the range as one
+ * window. Resolved to the minute.
+ */
+export declare function clipToSession(session: TradingSession, from: bigint, to: bigint): SessionWindow[];
+/** Next market open at or after `fromNs`, or `fromNs` if it's already open. */
+export declare function nextOpenNs(session: TradingSession, fromNs: bigint): bigint;
+/** Most recent close before `fromNs`, or `fromNs` if the market is open. */
+export declare function prevCloseNs(session: TradingSession, fromNs: bigint): bigint;
+/**
+ * Walk backward from `fromNs` by `targetDuration` of market-open time, skipping
+ * closed windows, so the real span returned covers exactly that much trading.
+ *
+ * On a Sun 6pm - Fri 5pm ET session, walking back one market hour from Sunday
+ * 10pm ET lands on Friday 4pm ET.
+ */
+export declare function walkBackMarketNs(session: TradingSession | null, fromNs: bigint, targetMarketNs: bigint): bigint;