@christtrade/depth 0.12.21

package/types/lib/compact-buffer.d.ts

@@ -0,0 +1,66 @@
+/**
+ * A flat typed-array store for MBO events, in place of an MboEvent[]. Rather
+ * than a heap object per event at 150-200 bytes each, every event packs into 20
+ * bytes:
+ *
+ *   [0..7]   ts_ns        BigInt64, absolute nanoseconds
+ *   [8..11]  pricex100    Int32, null becomes the INT32_MIN sentinel
+ *   [12..15] size         Uint32
+ *   [16..18] order_id     Uint24, little-endian
+ *   [19]     packed       bits 7-4 action, bits 3-2 side, bits 1-0 spare
+ *
+ * At 30M events that's about 600MB instead of ~5GB.
+ *   findFloorIndex()       - binary search by nanosecond timestamp
+ */
+import type { MboEvent } from './types';
+export interface CompactBuffer {
+    /** Raw backing storage. Do not read directly - use the accessor functions. */
+    _buf: ArrayBuffer;
+    /** DataView over _buf. */
+    _view: DataView;
+    /** Number of events currently stored. */
+    length: number;
+    /** Capacity in events (buf.byteLength / BYTES_PER_EVENT). */
+    capacity: number;
+    /** Absolute ns timestamp of the first stored event (or 0n if empty). */
+    firstTs: bigint;
+    /** Absolute ns timestamp of the last stored event (or 0n if empty). */
+    lastTs: bigint;
+}
+export declare function createCompactBuffer(initialCapacity?: number): CompactBuffer;
+/**
+ * Append an array of MboEvents to the buffer.
+ * Events must already be sorted ascending by ts_event (they come from fetchChunk
+ * in order, so this is always true).
+ *
+ * `isoToNs` is passed in to avoid a circular import - use the one from sampler.ts.
+ */
+export declare function appendEvents(cb: CompactBuffer, events: MboEvent[], isoToNs: (iso: string) => bigint): void;
+/**
+ * Decode event at index `idx` into a scratch object.
+ * The returned reference is reused on the next call - copy fields if you need
+ * to store the result.
+ */
+export declare function getEvent(cb: CompactBuffer, idx: number): Readonly<MboEvent>;
+/**
+ * Read just the nanosecond timestamp of event at index `idx`.
+ * Faster than getEvent() when you only need the time (e.g., binary search).
+ */
+export declare function getTsNs(cb: CompactBuffer, idx: number): bigint;
+/**
+ * Returns the index of the last event with ts <= `targetNs`, or -1 if none.
+ * Equivalent to the existing binary-search pattern in chart.tsx.
+ */
+export declare function findFloorIndex(cb: CompactBuffer, targetNs: bigint): number;
+/**
+ * Remove the first `count` events from the buffer.
+ * This does a single memmove - O(N) but infrequent (only called on hour boundary).
+ */
+export declare function trimFront(cb: CompactBuffer, count: number): void;
+/**
+ * Decode a range [start, end) of the buffer back to MboEvent[].
+ * Used when workers need the full event objects (heatmap worker init,
+ * footprint rebuild on TF change, etc).
+ * Keep calls infrequent - this allocates one object per event.
+ */
+export declare function sliceToMboEvents(cb: CompactBuffer, start: number, end: number): MboEvent[];

package/types/lib/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const MIN_TRADE_SIZE = 1;
+export declare const MAX_DOT_RADIUS = 8;
+export declare const MIN_DOT_RADIUS = 1.5;
+export declare const MIN_TIME_SPAN = 10000000n;
+export declare const MAX_TIME_SPAN = 86400000000000n;

package/types/lib/createSimulatedAdapter.d.ts

@@ -0,0 +1,42 @@
+import type { IDataAdapter, FetchRequest, BarResponse, SymbolInfo } from '../interfaces/IDataAdapter';
+export interface SimulatedAdapterConfig {
+    /** Reproducible seed. Omit for random. */
+    seed?: number;
+    /** Starting mid-price. Default 21000. */
+    startPrice?: number;
+    /** Bar duration in nanoseconds. Default 60_000_000_000n (1 min). */
+    barDurationNs?: bigint;
+    /** Number of intra-bar ticks used to construct H/L. Default 20. */
+    intrabbarTicks?: number;
+    /** Tick size for price rounding. Default 0.25. */
+    tickSize?: number;
+    /** Override regime parameters if you want to tune the sim. */
+    regimes?: Partial<Record<Regime, Partial<RegimeParams>>>;
+}
+type Regime = 'TRENDING' | 'MEAN_REVERTING' | 'VOLATILE';
+interface RegimeParams {
+    /** Annualised drift (log-return). Positive = uptrend. */
+    drift: number;
+    /** Baseline annualised volatility (used as GARCH long-run vol). */
+    baseVol: number;
+    /** OU mean-reversion speed (0 = pure GBM, higher = stronger pull). */
+    ouSpeed: number;
+    /** GARCH alpha (shock persistence weight). */
+    garchAlpha: number;
+    /** GARCH beta (variance persistence weight). alpha+beta < 1 for stationarity. */
+    garchBeta: number;
+    /** Student-t degrees of freedom for innovations (Infinity = Gaussian). */
+    tDof: number;
+    /** Average bars before regime transitions (geometric dist). */
+    avgDuration: number;
+}
+export declare class SimulatedMarketAdapter implements IDataAdapter {
+    private readonly cfg;
+    constructor(cfg?: SimulatedAdapterConfig);
+    searchSymbols(): Promise<SymbolInfo[]>;
+    resolveSymbol(): SymbolInfo;
+    fetchBars(request: FetchRequest): Promise<BarResponse>;
+}
+/** Convenience factory matching the naming convention used in ChartPageClient. */
+export declare function createSimulatedAdapter(cfg?: SimulatedAdapterConfig): SimulatedMarketAdapter;
+export {};

package/types/lib/dpr.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Device pixel ratio for canvas rendering.
+ *
+ * All canvas sizing (handleResize) and context transforms (setTransform) must
+ * use this value so the physical-pixel count and the draw-coordinate scale stay
+ * in sync. Anywhere that derives cssW/cssH from canvas.width must also divide
+ * by this value, not window.devicePixelRatio directly.
+ *
+ * Sharpness on any DPR comes from coordinate snapping (Math.floor(x)+0.5),
+ * not from overriding the DPR here.
+ */
+export declare function getEffectiveDpr(): number;
+/**
+ * Round a css-px coordinate onto a whole device pixel.
+ *
+ * The canvas is drawn through a `setTransform(dpr, …)`, so a css coordinate of
+ * 493.6 at dpr 1.25 lands on device pixel 617.0 - a *fraction* of a pixel off.
+ * Fills absorb that as a soft edge; text does not. An 11px label whose baseline
+ * sits half a device pixel low is antialiased across two rows of pixels and
+ * reads as blurry, which is why axis labels are the first thing to look wrong.
+ *
+ * Use for text origins and for the edges of axis background bands. Do NOT use it
+ * for data-driven geometry (candles, lines) - those need the sub-pixel precision
+ * to stay where the data says they are; they use the `Math.floor(x) + 0.5`
+ * stroke convention instead.
+ */
+export declare function snapToDevicePx(v: number, dpr?: number): number;

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

@@ -0,0 +1 @@
+export {};

package/types/lib/indicator-stdlib.d.ts

@@ -0,0 +1,426 @@
+import type { RenderContext } from './types/indicator-types';
+export interface OhlcvBar {
+    ts: bigint;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+type Series = number[] | OhlcvBar[];
+export declare function sma(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function ema(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function wma(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function hma(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function rma(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function linreg(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function rsi(bars: OhlcvBar[], period?: number): number[];
+export declare function stoch(bars: OhlcvBar[], kPeriod?: number, dPeriod?: number, smooth?: number): {
+    k: number[];
+    d: number[];
+};
+export declare function macd(bars: OhlcvBar[], fast?: number, slow?: number, signal?: number): {
+    macd: number[];
+    signal: number[];
+    histogram: number[];
+};
+export declare function atr(bars: OhlcvBar[], period?: number): number[];
+export declare function tr(bars: OhlcvBar[]): number[];
+export declare function crossover(a: number[], b: number[] | number): boolean[];
+export declare function crossunder(a: number[], b: number[] | number): boolean[];
+export declare function cross(a: number[], b: number[] | number): boolean[];
+export declare function rising(series: number[], lookback?: number): boolean[];
+export declare function falling(series: number[], lookback?: number): boolean[];
+export declare function change(series: number[], length?: number): number[];
+export declare function barssince(condition: boolean[]): number[];
+export declare function valuewhen(condition: boolean[], series: number[], occurrence?: number): number[];
+export declare function highest(series: number[], length: number): number[];
+export declare function lowest(series: number[], length: number): number[];
+export declare function pivotHigh(bars: OhlcvBar[], left?: number, right?: number): number[];
+export declare function pivotLow(bars: OhlcvBar[], left?: number, right?: number): number[];
+export declare function bb(bars: OhlcvBar[], period?: number, mult?: number, getValue?: (b: OhlcvBar) => number): {
+    upper: number[];
+    mid: number[];
+    lower: number[];
+};
+export declare function bbw(bars: OhlcvBar[], period?: number, mult?: number): number[];
+export declare function donchian(bars: OhlcvBar[], period?: number): {
+    upper: number[];
+    mid: number[];
+    lower: number[];
+};
+export declare function keltner(bars: OhlcvBar[], emaPeriod?: number, atrPeriod?: number, mult?: number): {
+    upper: number[];
+    mid: number[];
+    lower: number[];
+};
+export declare function vwap(bars: OhlcvBar[], sessionStartHour?: number): number[];
+export declare function alligator(bars: OhlcvBar[]): {
+    jaw: number[];
+    teeth: number[];
+    lips: number[];
+};
+export declare function stdev(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function variance(series: Series, period: number, getValue?: (b: OhlcvBar) => number): number[];
+export declare function dev(series: number[], period: number): number[];
+export declare function correlation(a: number[], b: number[], period: number): number[];
+export declare const max: typeof highest;
+export declare const min: typeof lowest;
+export declare function median(series: number[], period: number): number[];
+/**
+ * toPoints(bars, values)
+ *
+ * Zips a bar array with a computed number[] into plot-ready { t, price } points.
+ * Automatically filters NaN/Infinity. This is what draw() iterates over.
+ *
+ *   const pts = toPoints(data.ohlcv, sma(data.ohlcv, 20))
+ */
+export declare function toPoints(timestamps: bigint[], values: number[]): Array<{
+    t: bigint;
+    price: number;
+}>;
+export declare function last<T>(arr: T[]): T | undefined;
+/** nz(value, replacement) - replace NaN/undefined/null with replacement (default 0). */
+export declare function nz(value: number | undefined | null, replacement?: number): number;
+export type DrawCommand = {
+    type: 'line';
+    pts: Array<{
+        t: bigint;
+        price: number;
+    }>;
+    /** Uniform color string, or one color per point (segment i uses color[i]). */
+    color: string | string[];
+    width: number;
+    dash?: number[];
+    connect?: boolean;
+} | {
+    type: 'hline';
+    price: number;
+    color: string;
+    width: number;
+    dash?: number[];
+} | {
+    type: 'histogram';
+    pts: Array<{
+        t: bigint;
+        price: number;
+    }>;
+    /** Uniform color string, or one color per bar. */
+    color: string | string[];
+    base?: number;
+    gap?: number;
+} | {
+    type: 'label';
+    text: string;
+    /** bigint timestamp when anchored to price space, number when anchored to screen */
+    x: bigint | number;
+    y: number;
+    color: string;
+    fontSize?: number;
+    bold?: boolean;
+    horzAlign?: 'left' | 'right' | 'center';
+    vertAlign?: 'bottom' | 'middle' | 'top';
+    /** true = x/y are raw screen pixels, false = x is ts, y is price */
+    anchored?: boolean;
+    maxWidth?: number;
+} | {
+    type: 'fill';
+    pts1: Array<{
+        t: bigint;
+        price: number;
+    }> | number;
+    pts2: Array<{
+        t: bigint;
+        price: number;
+    }> | number;
+    opts: FillBetweenOpts;
+} | {
+    /** Axis-aligned price-space rectangle anchored to two timestamps + two prices */
+    type: 'rect';
+    t1: bigint;
+    t2: bigint;
+    price1: number;
+    price2: number;
+    fillColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    dash?: number[];
+    radius?: number;
+} | {
+    /** Circle drawn at a price/time point */
+    type: 'circle';
+    t: bigint;
+    price: number;
+    radius: number;
+    fillColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+} | {
+    /** Vertical line at a fixed timestamp spanning the full pane height */
+    type: 'vline';
+    t: bigint;
+    color: string;
+    width: number;
+    dash?: number[];
+} | {
+    /** Arrow / marker pointing up or down at a price/time point */
+    type: 'arrow';
+    t: bigint;
+    price: number;
+    direction: 'up' | 'down';
+    color: string;
+    size?: number;
+    label?: string;
+    labelColor?: string;
+} | {
+    /** Trend line between two price/time anchors - infinite extension optional */
+    type: 'trendline';
+    t1: bigint;
+    price1: number;
+    t2: bigint;
+    price2: number;
+    color: string;
+    width?: number;
+    dash?: number[];
+    extend?: 'none' | 'right' | 'both';
+} | {
+    /** Horizontal band between two prices - like fillBetween but dead simple */
+    type: 'band';
+    priceHigh: number;
+    priceLow: number;
+    fillColor: string;
+    borderColor?: string;
+    borderWidth?: number;
+} | {
+    /** Multi-point polygon in price/time space, filled and/or stroked */
+    type: 'polygon';
+    pts: Array<{
+        t: bigint;
+        price: number;
+    }>;
+    fillColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    dash?: number[];
+} | {
+    /** Dotted/painted series - individual dots at each point */
+    type: 'dots';
+    pts: Array<{
+        t: bigint;
+        price: number;
+    }>;
+    /** Uniform color string, or one color per dot. */
+    color: string | string[];
+    radius?: number;
+} | {
+    /** Text box with background pill - like a label but with a background */
+    type: 'badge';
+    t: bigint;
+    price: number;
+    text: string;
+    textColor: string;
+    bgColor: string;
+    fontSize?: number;
+    padding?: number;
+    radius?: number;
+    anchored?: boolean;
+};
+/**
+ * drawLine(pts, color, width, dash?, connect?)
+ *
+ * Draws a line connecting { t: bigint, price: number } points.
+ * Gaps in the line are inserted automatically at bar boundaries unless connect=true.
+ */
+export declare function drawLine(pts: Array<{
+    t: bigint;
+    price: number;
+}>, color: string | string[], width: number, dash?: number[], connect?: boolean): DrawCommand;
+/**
+ * drawHLine(price, color, width, dash?)
+ *
+ * Draws a horizontal line at a fixed price level spanning the full pane width.
+ */
+export declare function drawHLine(price: number, color: string, width: number, dash?: number[]): DrawCommand;
+/**
+ * drawHistogram(pts, color, base?, gap?)
+ *
+ * Draws a bar histogram. Each point { t, price } is one bar.
+ * base = the zero line price (default 0).
+ * gap = fraction of bar width left as spacing (default 0.2).
+ */
+export declare function drawHistogram(pts: Array<{
+    t: bigint;
+    price: number;
+}>, color: string | string[], base?: number, gap?: number): DrawCommand;
+/**
+ * drawLabel(text, x, y, color, fontSize?, bold?, horzAlign?, vertAlign?, anchored?, maxWidth?)
+ *
+ * anchored=false (default): x is a bigint timestamp, y is a price value.
+ * anchored=true:            x and y are raw screen pixel coordinates.
+ */
+export declare function drawLabel(text: string, x: bigint | number, y: number, color: string, fontSize?: number, bold?: boolean, horzAlign?: 'left' | 'right' | 'center', vertAlign?: 'bottom' | 'middle' | 'top', anchored?: boolean, maxWidth?: number): DrawCommand;
+export type FillBetweenOpts = {
+    mode: 'solid';
+    color: string;
+} | {
+    mode: 'screen';
+    stops: Array<{
+        offset: number;
+        color: string;
+    }>;
+} | {
+    mode: 'vertical';
+    stops: Array<{
+        price: number;
+        color: string;
+    }>;
+} | {
+    mode: 'data';
+    stops: Array<{
+        offset: number;
+        color: string;
+    }>;
+};
+/**
+ * fillBetween(pts1, pts2, opts)
+ *
+ * Fills the region between two price series (or between a series and a flat price).
+ * pts1 / pts2 can each be Array<{t,price}> or a plain number (flat level).
+ * opts.mode: 'solid' | 'screen' | 'vertical' | 'data'  (same API as before)
+ */
+export declare function fillBetween(pts1: Array<{
+    t: bigint;
+    price: number;
+}> | number, pts2: Array<{
+    t: bigint;
+    price: number;
+}> | number, opts: FillBetweenOpts): DrawCommand;
+/**
+ * drawRect(t1, price1, t2, price2, opts?)
+ *
+ * Draws a rectangle anchored to two timestamps and two price levels.
+ * Useful for highlighting ranges, supply/demand zones, etc.
+ */
+export declare function drawRect(t1: bigint, price1: number, t2: bigint, price2: number, opts?: {
+    fillColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    dash?: number[];
+    radius?: number;
+}): DrawCommand;
+/**
+ * drawCircle(t, price, radius, opts?)
+ *
+ * Draws a circle at a price/time point. radius is in pixels.
+ */
+export declare function drawCircle(t: bigint, price: number, radius: number, opts?: {
+    fillColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+}): DrawCommand;
+/**
+ * drawVLine(t, color, width, dash?)
+ *
+ * Draws a vertical line at a fixed timestamp spanning the full pane height.
+ * Great for marking events, session opens, etc.
+ */
+export declare function drawVLine(t: bigint, color: string, width?: number, dash?: number[]): DrawCommand;
+/**
+ * drawArrow(t, price, direction, color, size?, label?, labelColor?)
+ *
+ * Draws an up or down arrow marker at a price/time point.
+ * Optionally attach a text label above/below the arrow.
+ */
+export declare function drawArrow(t: bigint, price: number, direction: 'up' | 'down', color: string, size?: number, label?: string, labelColor?: string): DrawCommand;
+/**
+ * drawTrendLine(t1, price1, t2, price2, color, width?, dash?, extend?)
+ *
+ * Draws a line between two anchors. extend='right' continues to the right edge,
+ * extend='both' extends in both directions.
+ */
+export declare function drawTrendLine(t1: bigint, price1: number, t2: bigint, price2: number, color: string, width?: number, dash?: number[], extend?: 'none' | 'right' | 'both'): DrawCommand;
+/**
+ * drawBand(priceHigh, priceLow, fillColor, borderColor?, borderWidth?)
+ *
+ * Draws a horizontal price band across the full pane width.
+ * Simpler than fillBetween - just two price levels.
+ */
+export declare function drawBand(priceHigh: number, priceLow: number, fillColor: string, borderColor?: string, borderWidth?: number): DrawCommand;
+/**
+ * drawPolygon(pts, opts?)
+ *
+ * Draws a closed polygon through a series of price/time points.
+ */
+export declare function drawPolygon(pts: Array<{
+    t: bigint;
+    price: number;
+}>, opts?: {
+    fillColor?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    dash?: number[];
+}): DrawCommand;
+/**
+ * drawDots(pts, color, radius?)
+ *
+ * Draws a filled circle at each point in the series.
+ * Good for scatter plots, signal markers, etc.
+ */
+export declare function drawDots(pts: Array<{
+    t: bigint;
+    price: number;
+}>, color: string | string[], radius?: number): DrawCommand;
+/**
+ * drawBadge(t, price, text, textColor, bgColor, opts?)
+ *
+ * Draws a pill-shaped text badge anchored to a price/time point.
+ * Great for labeling signals, patterns, indicator values etc.
+ */
+export declare function drawBadge(t: bigint, price: number, text: string, textColor: string, bgColor: string, opts?: {
+    fontSize?: number;
+    padding?: number;
+    radius?: number;
+    anchored?: boolean;
+}): DrawCommand;
+export declare function executeDrawCommands(commands: DrawCommand[], renderCtx: RenderContext): void;
+export declare function obv(bars: OhlcvBar[]): number[];
+export declare function mfi(bars: OhlcvBar[], period?: number): number[];
+export declare function cci(bars: OhlcvBar[], period?: number): number[];
+export declare function williamsR(bars: OhlcvBar[], period?: number): number[];
+export declare function supertrend(bars: OhlcvBar[], period?: number, multiplier?: number): {
+    trend: number[];
+    upper: number[];
+    lower: number[];
+};
+export interface SessionDef {
+    label: string;
+    startHour: number;
+    startMinute: number;
+    endHour: number;
+    endMinute: number;
+    color: string;
+    /**
+     * IANA timezone for this session's hours (e.g. 'America/New_York',
+     * 'Europe/London'). When set, startHour/endHour are interpreted in this
+     * zone and Luxon handles DST automatically - no manual offset tweaking.
+     * Falls back to options.tz, then 'UTC' (preserving pre-existing behaviour).
+     */
+    tz?: string;
+}
+export interface SessionBoundariesOptions {
+    /**
+     * Default IANA timezone for all sessions that don't carry their own `tz`.
+     * Defaults to 'UTC'.
+     */
+    tz?: string;
+}
+export declare function sessionBoundaries(bars: OhlcvBar[], sessions: SessionDef[], options?: SessionBoundariesOptions): Array<{
+    startTs: bigint;
+    endTs: bigint;
+    high: number;
+    low: number;
+    label: string;
+    color: string;
+}>;
+export declare const STDLIB: Record<string, Function>;
+export {};

package/types/lib/indicator-worker.d.ts

@@ -0,0 +1,65 @@
+import { SerialTrade } from './types';
+export type { SerialTrade };
+/**
+ * Full recompute. Sent on load / backward seek / timeframe change.
+ * workerInit is called with ALL trades up to horizon.
+ * The return value of workerInit is both stored as state AND returned as
+ * the hydrate() payload so ChartInner can replace all existing output data.
+ */
+export interface ComputeRequest {
+    type: 'compute';
+    requestId: string;
+    trades: SerialTrade[];
+    barNs: bigint;
+    horizon: bigint;
+    ohlcv?: any[];
+    ticks?: any[];
+    snapshots?: any[];
+    indicators: Array<{
+        id: string;
+        workerInit: string;
+        params?: unknown;
+    }>;
+}
+/**
+ * Register workerUpdate functions. Sent once after each 'compute'.
+ * Separating this from 'compute' means we never re-parse source strings on
+ * the hot path (horizon:advance sends only indicatorIds, no source).
+ */
+export interface RegisterUpdateFnsRequest {
+    type: 'register-update-fns';
+    indicators: Array<{
+        id: string;
+        /** Serialized pure fn: ({ newTrades, state, barNs, horizon, params }) => { points, state } */
+        workerUpdate: string;
+    }>;
+}
+/**
+ * Incremental update. Hot path - called every horizon tick.
+ * workerUpdate receives only new trades since the last call.
+ * Returns new output points for appendHydrate().
+ */
+export interface HorizonAdvanceRequest {
+    type: 'horizon:advance';
+    requestId: string;
+    newTrades: SerialTrade[];
+    horizon: bigint;
+    barNs: bigint;
+    indicatorIds: Array<{
+        id: string;
+        params?: unknown;
+        workerInit?: string;
+    }>;
+}
+export interface ComputeResponse {
+    type: 'compute';
+    requestId: string;
+    results: Record<string, unknown>;
+    errors: Record<string, string>;
+}
+export interface HorizonAdvanceResponse {
+    type: 'horizon:advance';
+    requestId: string;
+    points: Record<string, unknown>;
+    errors: Record<string, string>;
+}