@christtrade/depth 0.14.0 → 0.15.0

package/types/console/Console.d.ts

@@ -0,0 +1,190 @@
+import type { ChartEvents } from '../core/TypedEventBus';
+import { type ChartSettings } from '../lib/types/chart-settings';
+import type { ArgSpec, ArgType } from './types';
+import { type TypeParser } from './values';
+/** What the console needs from a chart. `chart.console` wires this up for you */
+export interface ConsoleHost {
+    on<K extends keyof ChartEvents>(event: K, fn: (data: ChartEvents[K]) => void): () => void;
+    emit<K extends keyof ChartEvents>(event: K, data: ChartEvents[K]): void;
+    settings(): Readonly<ChartSettings>;
+    focusedCell(): number;
+    playheadNs(): bigint;
+    status(): Record<string, unknown>;
+}
+export interface ConsoleStorage {
+    read<T>(key: string, fallback: T): T;
+    write(key: string, value: unknown): void;
+}
+export type ScreenKey = {
+    type: 'down' | 'up';
+    key: string;
+    code: string;
+    ctrl: boolean;
+    alt: boolean;
+    shift: boolean;
+    meta: boolean;
+    repeat: boolean;
+};
+export interface ScreenOptions {
+    /** Cover the whole page instead of just the terminal panel */
+    maximize?: boolean;
+}
+export interface Screen {
+    readonly cols: number;
+    readonly rows: number;
+    /** Pixel size of one cell. */
+    readonly cell: {
+        width: number;
+        height: number;
+    };
+    /** Resolves once the terminal has drawn it */
+    write(data: string): Promise<void>;
+    /** Typed text as terminal sequences (arrows arrive as \x1b[A ...) */
+    onData(fn: (data: string) => void): () => void;
+    onKey(fn: (key: ScreenKey) => void): () => void;
+    onResize(fn: (cols: number, rows: number) => void): () => void;
+    /** Aborted when the screen closes */
+    readonly closed: AbortSignal;
+    close(): void;
+}
+/** What a terminal ui gives the console so commands can draw full screen */
+export interface ConsoleDisplay {
+    readonly cols: number;
+    openScreen(opts: ScreenOptions): Screen;
+}
+export interface CommandContext {
+    /** Parsed against the command's `args`. Empty when it declares none. */
+    args: Record<string, unknown>;
+    /** Raw words after the command name. */
+    argv: string[];
+    /** The text after the command name. */
+    raw: string;
+    /** Lines from the command before a `|`, or null when nothing was piped in. */
+    input: string[] | null;
+    print(text: string): void;
+    error(text: string): void;
+    signal: AbortSignal;
+    console: Console;
+    /** Take over the terminal. */
+    screen(opts?: ScreenOptions): Screen;
+}
+export interface CommandDef {
+    name: string;
+    help?: string;
+    /** Declared args are parsed, checked, and tab completed. */
+    args?: ArgSpec[];
+    /** Hidden and refused unless `developer 1`. */
+    dev?: boolean;
+    /** Runs, but never listed, completed or found */
+    hidden?: boolean;
+    /** Takes the rest of the line as-is, `;` included for commands whose input is code. */
+    rest?: boolean;
+    run(ctx: CommandContext): void | Promise<void>;
+    /** `argv` is the words before the one being completed, `current` that word so far. */
+    complete?(argIndex: number, argv: string[], current: string): string[];
+}
+export interface CvarDef {
+    name: string;
+    type: ArgType;
+    nullable?: boolean;
+    help?: string;
+    group?: string;
+    dev?: boolean;
+    default: unknown;
+    get(): unknown;
+    set(value: unknown): void;
+}
+export declare function keyName(e: {
+    key: string;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    metaKey?: boolean;
+}): string;
+/**
+ * A console over the chart. Every command in `ChartEvents`
+ * and every field of `ChartSettings` is available without registering it;
+ * plugins and hosts add their own with `register` / `registerCvar`.
+ */
+export declare class Console {
+    private readonly host;
+    private readonly storage;
+    private readonly commands;
+    private readonly cvars;
+    private readonly types;
+    private readonly outputs;
+    private readonly clears;
+    private readonly listening;
+    private readonly listenPatterns;
+    private readonly rates;
+    private abortCtl;
+    private display;
+    private screenOpen;
+    private readonly builtins;
+    private readonly state;
+    readonly history: string[];
+    constructor(host: ConsoleHost, storage?: ConsoleStorage);
+    register(def: CommandDef): () => void;
+    registerCvar(def: CvarDef): () => void;
+    registerSavedCvar(def: Omit<CvarDef, 'get' | 'set'> & {
+        onChange?: (value: unknown) => void;
+    }): () => void;
+    /** teach the console to read a named type from text, so like `Timeframe` from "5m" */
+    registerType(name: string, parser: TypeParser): () => void;
+    /** The terminal's width, default 100 */
+    get cols(): number;
+    /** Attach the terminal that full-screen commands draw on. Returns a detach. */
+    setDisplay(display: ConsoleDisplay): () => void;
+    private openScreen;
+    onOutput(fn: (text: string) => void): () => void;
+    onClear(fn: () => void): () => void;
+    print(text: string): void;
+    private readonly captures;
+    /** Run a line and hand back what it printed instead of printing it. */
+    capture(line: string, signal?: AbortSignal): Promise<string[]>;
+    /** Extra names `js` can see. Hosts add their own. */
+    readonly scope: Record<string, unknown>;
+    scriptNames(): string[];
+    script(name: string): string | undefined;
+    /** Save a `js` script, or delete it with null. */
+    setScript(name: string, source: string | null): void;
+    cfgNames(): string[];
+    cfg(name: string): string | undefined;
+    /** Save a cfg, or delete it with null. */
+    setCfg(name: string, text: string | null): void;
+    error(text: string): void;
+    get developer(): boolean;
+    submit(line: string): Promise<void>;
+    exec(line: string, depth?: number, signal?: AbortSignal): Promise<void>;
+    private isRest;
+    private captured;
+    abort(): void;
+    handleKey(key: string): boolean;
+    dispose(): void;
+    start(): Promise<void>;
+    private run;
+    private listed;
+    private resolveCommand;
+    private env;
+    private timezone;
+    private parseArgs;
+    private usage;
+    private eventCommand;
+    private showCvar;
+    private findCvar;
+    private listen;
+    private unlisten;
+    private onListened;
+    private save;
+    private settingsDiff;
+    suggest(line: string): string | null;
+    highlight(line: string): string;
+    complete(line: string): {
+        from: number;
+        items: string[];
+    };
+    private names;
+    private completeArg;
+    private completeNamedArg;
+    private registerBuiltins;
+}

package/types/console/builtins/cfgedit.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef, Console } from '../Console';
+export declare function cfgEditCommand(con: Console): CommandDef;

package/types/console/builtins/editor.d.ts

@@ -0,0 +1,9 @@
+import type { CommandContext } from '../Console';
+export declare function editText(ctx: CommandContext, opts: {
+    title: string;
+    name: string;
+    text: string | undefined;
+    highlight: (line: string) => string;
+    save: (text: string) => void;
+    fresh: string;
+}): Promise<void>;

package/types/console/builtins/js.d.ts

@@ -0,0 +1,9 @@
+import type { CommandDef, Console } from '../Console';
+export declare function jsScope(con: Console, print: (t: string) => void, extra?: Record<string, unknown>): Record<string, unknown>;
+export declare function evaluate(con: Console, raw: string, print: (t: string) => void, extra?: Record<string, unknown>): Promise<{
+    value: unknown;
+    shown: boolean;
+}>;
+export declare const describeError: (err: unknown) => string;
+export declare function completePath(con: Console, current: string): string[];
+export declare function jsCommand(con: Console): CommandDef;

package/types/console/builtins/pipes.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef, Console } from '../Console';
+export declare function pipeCommands(con: Console): CommandDef[];

package/types/console/builtins/plot.d.ts

@@ -0,0 +1,9 @@
+import type { CommandDef, Console } from '../Console';
+type Series = {
+    name: string;
+    values: number[];
+};
+export declare function toSeries(v: unknown): Series[];
+export declare function plotLines(series: Series[], cols: number, rows: number): string[];
+export declare function plotCommand(con: Console): CommandDef;
+export {};

package/types/console/builtins/scripts.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef, Console } from '../Console';
+export declare function scriptCommands(con: Console): CommandDef[];

package/types/console/builtins/watch.d.ts

@@ -0,0 +1,2 @@
+import type { CommandDef, Console } from '../Console';
+export declare function watchCommand(con: Console): CommandDef;

package/types/console/chart-host.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../core/DepthChart';
+import { Console } from './Console';
+export declare function createChartConsole(chart: DepthChart): Console;

package/types/console/lex.d.ts

@@ -0,0 +1,16 @@
+export type Token = {
+    text: string;
+    start: number;
+    end: number;
+    quoted: boolean;
+};
+export declare function splitStatements(line: string): {
+    text: string;
+    start: number;
+}[];
+export declare function splitPipes(stmt: string): {
+    text: string;
+    start: number;
+}[];
+export declare function tokenize(stmt: string): Token[];
+export declare function quote(s: string): string;

package/types/console/manifest.gen.d.ts

@@ -0,0 +1,3 @@
+import type { CvarSpec, EventSpec } from './types';
+export declare const EVENTS: EventSpec[];
+export declare const CVARS: CvarSpec[];

package/types/console/plugin-console.d.ts

@@ -0,0 +1,24 @@
+import type { ArgSpec } from './types';
+import type { CvarDef } from './Console';
+export type ScriptCommandMeta = {
+    name: string;
+    help?: string;
+    args: Record<string, unknown>;
+};
+export declare function slugOf(name: string): string;
+export declare function scriptArgSpecs(args: Record<string, unknown>): ArgSpec[];
+type ParamDefLike = {
+    type: string;
+    label?: string;
+    options?: unknown[];
+} & Record<string, unknown>;
+export declare function paramCvars(opts: {
+    slug: string;
+    paramDefs: Record<string, ParamDefLike>;
+    defaults: Record<string, unknown>;
+    keysOf: (key: string, def: ParamDefLike) => string[];
+    get: (key: string) => unknown;
+    set: (key: string, value: unknown) => void;
+    group: string;
+}): CvarDef[];
+export {};

package/types/console/tools/book.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef } from '../Console';
+export declare function bookCommand(chart: DepthChart): CommandDef;

package/types/console/tools/free.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef } from '../Console';
+export declare function freeCommand(chart: DepthChart): CommandDef;

package/types/console/tools/look.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef } from '../Console';
+export declare function lookCommand(chart: DepthChart): CommandDef;

package/types/console/tools/market.d.ts

@@ -0,0 +1,6 @@
+import type { SymbolInfo } from '../../interfaces/IDataAdapter';
+export declare function upperBound(rows: readonly {
+    ts: bigint;
+}[], ts: bigint): number;
+export declare function tickOf(info: SymbolInfo | null, prices: number[]): number;
+export declare function decimalsOf(tick: number): number;

package/types/console/tools/net.d.ts

@@ -0,0 +1,14 @@
+import type { CommandDef } from '../Console';
+type Req = PerformanceResourceTiming & {
+    responseStatus?: number;
+    deliveryType?: string;
+};
+export declare function netRecorder(): {
+    requests: Req[];
+    clear(): void;
+};
+export declare function netCommand(rec: {
+    requests: Req[];
+    clear(): void;
+}): CommandDef;
+export {};

package/types/console/tools/netgraph.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { Console } from '../Console';
+export declare function registerNetGraph(chart: DepthChart, con: Console): void;

package/types/console/tools/profile.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef } from '../Console';
+export declare function profileCommand(chart: DepthChart): CommandDef;

package/types/console/tools/tape.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef } from '../Console';
+export declare function tapeCommand(chart: DepthChart): CommandDef;

package/types/console/tools/top.d.ts

@@ -0,0 +1,10 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef } from '../Console';
+type Heap = {
+    usedJSHeapSize: number;
+    totalJSHeapSize: number;
+    jsHeapSizeLimit: number;
+};
+export declare const heapInfo: () => Heap | null;
+export declare function topCommand(chart: DepthChart): CommandDef;
+export {};

package/types/console/tools/trace.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef, Console } from '../Console';
+export declare function traceTools(chart: DepthChart, con: Console): CommandDef[];

package/types/console/tools/triggers.d.ts

@@ -0,0 +1,3 @@
+import type { DepthChart } from '../../core/DepthChart';
+import type { CommandDef, Console } from '../Console';
+export declare function triggerTools(chart: DepthChart, con: Console): CommandDef[];

package/types/console/tools/tui.d.ts

@@ -0,0 +1,13 @@
+import type { Screen } from '../Console';
+export declare const visible: (s: string) => number;
+export declare function padEnd(s: string, w: number): string;
+export declare function padStart(s: string, w: number): string;
+export declare function clip(s: string, w: number): string;
+export declare function bar(frac: number, width: number, color?: (s: string) => string): string;
+export declare function barLeft(frac: number, width: number, color: (s: string) => string): string;
+export declare function bytes(n: number): string;
+export declare const ms: (n: number) => string;
+export declare const count: (n: number) => string;
+export declare function heat(value: number, warn: number, bad: number): (s: string) => string;
+export declare const sleep: (ms: number, signal: AbortSignal) => Promise<void>;
+export declare function liveScreen(screen: Screen, interval: number, render: () => string[], onRedraw?: (redraw: () => void) => void): Promise<void>;

package/types/console/types.d.ts

@@ -0,0 +1,62 @@
+import type { ChartEvents } from '../core/TypedEventBus';
+import type { ChartSettings } from '../lib/types/chart-settings';
+export type ArgType = {
+    kind: 'string';
+} | {
+    kind: 'number';
+} | {
+    kind: 'boolean';
+} | {
+    kind: 'bigint';
+}
+/** A moment as epoch ns ("now"/"-1h"/"2024-01-05T09:30"/epoch s/ms/ns) */
+ | {
+    kind: 'time';
+}
+/** A length in ns ("1h30m"/"250ms") */
+ | {
+    kind: 'duration';
+} | {
+    kind: 'color';
+}
+/** `open` when the union also takes any string (ex plugin chart type ids) */
+ | {
+    kind: 'enum';
+    values: string[];
+    open?: boolean;
+} | {
+    kind: 'list';
+    of: ArgType;
+}
+/** a named type the console needs a parser for so like `Timeframe` from "5m" */
+ | {
+    kind: 'named';
+    name: string;
+} | {
+    kind: 'json';
+};
+export type ArgSpec = {
+    name: string;
+    type: ArgType;
+    optional?: boolean;
+    nullable?: boolean;
+    doc?: string;
+};
+export type EventSpec = {
+    event: keyof ChartEvents;
+    /** command can be run, event can only be listened to */
+    kind: 'command' | 'event';
+    /** Plumbing, hidden unless dev mode is on */
+    dev?: boolean;
+    /** obj payloads spread into named args, anything else is just a single `value` arg */
+    spread?: boolean;
+    args: ArgSpec[];
+    doc?: string;
+};
+export type CvarSpec = {
+    name: keyof ChartSettings;
+    type: ArgType;
+    nullable?: boolean;
+    group?: string;
+    doc?: string;
+};

package/types/console/values.d.ts

@@ -0,0 +1,46 @@
+import type { ArgType } from './types';
+export declare const ansi: {
+    red: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    blue: (s: string) => string;
+    magenta: (s: string) => string;
+    cyan: (s: string) => string;
+    dim: (s: string) => string;
+    bold: (s: string) => string;
+};
+export declare function stripAnsi(s: string): string;
+export declare function link(text: string, uri: string): string;
+export declare const gotoLink: (text: string, ns: bigint) => string;
+export declare const helpLink: (text: string, name: string) => string;
+export declare const fillLink: (text: string, line: string) => string;
+/** Turns console txt into a value for a named type, ex "5m" into `Timeframe` */
+export interface TypeParser {
+    parse(text: string): unknown;
+    /** candidates for tab completion */
+    complete?(): string[];
+}
+export type ParseEnv = {
+    timezone: string;
+    playheadNs: () => bigint;
+    types: ReadonlyMap<string, TypeParser>;
+};
+export declare function parseDuration(text: string): bigint | null;
+export declare function parseTime(text: string, env: ParseEnv): bigint;
+export declare const isDurationArg: (name: string) => boolean;
+export declare const isTimeArg: (name: string) => boolean;
+export declare function parseValue(raw: string, type: ArgType, opts: {
+    nullable?: boolean;
+    name?: string;
+}, env: ParseEnv): unknown;
+export declare function completeValue(type: ArgType, env: ParseEnv): string[];
+export declare function typeLabel(type: ArgType): string;
+export type FormatEnv = {
+    timezone: string;
+};
+export declare function formatTime(ns: bigint, timezone: string): string;
+export declare function formatDuration(ns: bigint): string;
+export declare function highlightJs(code: string): string;
+export declare function sparkline(values: readonly number[], width?: number): string;
+export declare function inspect(v: unknown, env: FormatEnv, depth?: number): string;
+export declare function formatValue(v: unknown, env: FormatEnv, key?: string, depth?: number): string;

package/types/core/DepthChart.d.ts

@@ -1,3 +1,4 @@
+import { type ChartDataSnapshot } from './DataEngine';
 import type { IDataAdapter, OhlcvBar, SymbolInfo } from '../interfaces/IDataAdapter';
 import type { IExecutionAdapter } from '../interfaces/IExecutionAdapter';
 import type { IAccountAdapter } from '../interfaces/IAccountAdapter';
@@ -20,6 +21,7 @@ import { AccountManager, LedgerAdjustment, LedgerFill, LedgerOrder, LedgerPositi
 import { PlaybackMode, type PrefetchOptions } from '../hooks/usePlaybackEngine';
 import { type ChartPreferences } from '../lib/storage';
 import { type PluginCatalogEntry, type PluginStartupEntry, type PluginStartupRecord } from './plugin-startup';
+import type { Console } from '../console/Console';
 export interface FeaturesOptions {
     contextMenu?: boolean;
     plugins?: boolean | {
@@ -221,6 +223,10 @@ export declare class DepthChart {
      * the candle the chart is actually drawing on the right edge.
      */
     openBar(): OhlcvBar | null;
+    /** What the chart holds for the active symbol - the same snapshot a plugin's `ctx.getData()` returns. */
+    getData(): ChartDataSnapshot;
+    /** The paint loop, once a pane has mounted one. */
+    get renderEngine(): RenderEngine | null;
     getMaxLookbackBars(): number;
     horizon(): number;
     fitToData(): this;
@@ -332,6 +338,12 @@ export declare class DepthChart {
     getProps(): DepthProps;
     on<K extends keyof ChartEvents>(event: K, handler: (data: ChartEvents[K]) => void): () => void;
     off<K extends keyof ChartEvents>(event: K, handler: (data: ChartEvents[K]) => void): void;
+    private _console;
+    /**
+     * The chart's command console. Every bus command and chart setting is
+     * already in it. `register` / `registerCvar` add your own
+     */
+    get console(): Console;
     use(plugin: ChartPlugin): this;
     /**
      * Apply an installed plugin to the panes. Safe to call before the plugin's

package/types/core/ExecutionEngine.d.ts

@@ -1,6 +1,6 @@
 import { IExecutionAdapter } from '../interfaces/IExecutionAdapter';
 import type { PlaceOrderRequest, FillSearchOptions, FillAmbiguity } from '../lib/matchingEngine';
-import { L3MatchingEngine } from '../lib/matchingEngine';
+import { L3MatchingEngine, type BookDepth } 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';
@@ -49,6 +49,11 @@ export declare class ExecutionEngine {
     /** Whether a book can price an order right now. */
     hasPrice(symbol?: string): boolean;
     setCustomAdapter(adapter: IExecutionAdapter | null): void;
+    /**
+     * The resting book at the horizon, best `levels` prices each side. Null when
+     * a custom adapter executes
+     */
+    getDepth(levels?: number, symbol?: string): BookDepth | null;
     private builtInFor;
     private targetFor;
     private eachBuiltIn;

package/types/core/RenderEngine.d.ts

@@ -101,6 +101,19 @@ export declare class RenderEngine {
     private readonly eventBus;
     private readonly chartId;
     private rafId;
+    /** The element the canvases sit in, for overlays that want to draw over the chart without touching it */
+    get container(): HTMLElement | null;
+    get plotSize(): {
+        width: number;
+        height: number;
+    };
+    /** Frames that painted something n what they cost. Read by the consoles `top` */
+    readonly paintStats: {
+        frames: number;
+        totalMs: number;
+        lastMs: number;
+        maxMs: number;
+    };
     private dirty;
     private beforeBaseDraw;
     private afterBaseDraw;

package/types/core/ScriptedPlugin.d.ts

@@ -1,4 +1,14 @@
 import type { ChartPlugin } from './PluginRegistry';
+export type ScriptStats = {
+    name: string;
+    type: string;
+    computes: number;
+    totalMs: number;
+    lastMs: number;
+    maxMs: number;
+};
+/** Worker compute time per scripted plugin entry, keyed `${pluginId}:${index}` */
+export declare const scriptStats: Map<string, ScriptStats>;
 import type { StyleField } from '../components/drawings/drawing-settings-dialog';
 export type ParamDef = {
     label: string;

package/types/core/TypedEventBus.d.ts

@@ -490,6 +490,7 @@ export interface ChartEvents {
     'plugin:panel-removed': {
         id: string;
     };
+    /** @console command */
     'plugin:panel-toggle-visibility': {
         id: string;
         visible: boolean;
@@ -593,6 +594,7 @@ export interface ChartEvents {
         id: string;
         params: Record<string, unknown>;
     };
+    /** @console command */
     'plugin:strategy-range': {
         id: string;
         range: {
@@ -617,6 +619,7 @@ export interface ChartEvents {
         /** As on 'plugin:strategy-range' - go get the span, don't clip. */
         fetch?: boolean;
     };
+    /** @console command */
     'plugin:strategy-mode': {
         id: string;
         manual: boolean;
@@ -637,6 +640,7 @@ export interface ChartEvents {
         total: number;
         error?: string;
     };
+    /** @console command */
     'plugin:strategy-sweep': {
         id: string;
         grid: Array<Record<string, unknown>>;
@@ -681,6 +685,7 @@ export interface ChartEvents {
         iterations: number;
         reason: string;
     };
+    /** @console command */
     'plugin:strategy-walkforward': {
         id: string;
         grid: Array<Record<string, unknown>>;
@@ -883,6 +888,10 @@ export declare class TypedEventBus {
     hasListeners<K extends keyof ChartEvents>(event: K): boolean;
     off<K extends keyof ChartEvents>(event: K, handler: Function): void;
     intercept<K extends InterceptableEvent>(event: K, interceptor: Interceptor<K>): () => void;
+    /** How many times each event has been emitted. Read by the consoles `top` */
+    readonly emitCounts: Map<string, number>;
+    private readonly taps;
+    tap(fn: (event: keyof ChartEvents, data: unknown) => void): () => void;
     emit<K extends keyof ChartEvents>(event: K, data: ChartEvents[K]): void;
     clear(): void;
 }

package/types/core/index.d.ts

@@ -1,4 +1,8 @@
 export { DepthChart } from './DepthChart';
+export { Console, keyName } from '../console/Console';
+export type { ConsoleHost, ConsoleStorage, ConsoleDisplay, CommandDef, CommandContext, CvarDef, Screen, ScreenKey, ScreenOptions, } from '../console/Console';
+export type { ArgSpec, ArgType } from '../console/types';
+export type { TypeParser } from '../console/values';
 export type { ChartOptions } from './DepthChart';
 export { useDepthChart } from '../react/useDepthChart';
 export { default as Depth } from '../ChartOuter';
@@ -51,7 +55,7 @@ export type { DrawingTool } from '../lib/types/drawing-types';
 export type { FootprintBar, FootprintOptions } from '../lib/types/footprint';
 export type { ChartSettings } from '../lib/types/chart-settings';
 export { DEFAULT_CHART_SETTINGS } from '../lib/types/chart-settings';
-export type { PlaceOrderRequest, L3EngineOptions, FeeSchedule } from '../lib/matchingEngine';
+export type { PlaceOrderRequest, L3EngineOptions, FeeSchedule, BookDepth, BookLevel } from '../lib/matchingEngine';
 export { createL3MatchingEngine, feeScheduleFor, MICRO_FEE_SCHEDULE, NQ_FEE_SCHEDULE, ZERO_FEE_SCHEDULE, } from '../lib/matchingEngine';
 export { SimulatedMarketAdapter, createSimulatedAdapter } from '../lib/createSimulatedAdapter';
 export { AccountManager } from './AccountManager';