@christtrade/depth 0.12.21

package/types/lib/types/drawing-types.d.ts

@@ -0,0 +1,393 @@
+export type DrawingTool = 'cursor' | 'hline' | 'vline' | 'extended-line' | 'line' | 'cross-line' | 'info-line' | 'trend-angle' | 'ray' | 'hray' | 'parallel-channel' | 'rect' | 'triangle' | 'fib' | 'text' | 'fvp' | 'long' | 'short' | 'flat-channel' | 'disjoint-channel' | 'regression-trend' | 'pitchfork' | 'schiff-pitchfork' | 'modified-schiff-pitchfork' | 'inside-pitchfork' | 'fib-extension' | 'fib-trend-extension' | 'fib-channel' | 'fib-time-zone' | 'fib-speed-fan' | 'fib-circles' | 'fib-spiral' | 'fib-wedge' | 'gann-box' | 'gann-square' | 'gann-fan' | 'xabcd' | 'cypher' | 'abcd' | 'three-drives' | 'head-shoulders' | 'triangle-pattern' | 'elliott-impulse' | 'elliott-correction' | 'elliott-triangle' | 'elliott-double-combo' | 'elliott-triple-combo' | 'rotated-rect' | 'ellipse' | 'circle' | 'polygon' | 'arc' | 'curve' | 'double-curve' | 'polyline' | 'path' | 'anchored-text' | 'note' | 'callout' | 'comment' | 'price-label' | 'signpost' | 'flag' | 'pin' | 'table' | 'arrow' | 'arrow-marker' | 'arrow-up' | 'arrow-down' | 'brush' | 'highlighter' | 'forecast' | 'projection' | 'bars-pattern' | 'ghost-feed' | 'price-range' | 'date-range' | 'date-price-range' | 'anchored-volume-profile' | 'fixed-range-volume' | 'anchored-vwap' | 'ruler';
+type AllKeys<T> = T extends any ? keyof T : never;
+type ValueOfKey<T, K extends PropertyKey> = T extends any ? K extends keyof T ? T[K] : never : never;
+/** A drawing of unknown tool: read any field, get `undefined` if absent. */
+export type AnyDrawing = {
+    [K in AllKeys<Drawing>]?: ValueOfKey<Drawing, K>;
+};
+/**
+ * What the chart is currently armed with, or what is currently selected.
+ *
+ * - `name`  - the tool, `'cursor'` when nothing is armed.
+ * - `id`    - identity of the drawing: the selected one, or the id the next
+ *             committed drawing will carry.
+ * - `state` - its fields. For an armed tool that is the style it will be
+ *             created with; for a selection it is the live drawing.
+ */
+export type ActiveDrawingTool = {
+    name: DrawingTool;
+    id: string;
+    state: AnyDrawing;
+};
+/** The idle tool. Shared so every "back to cursor" site agrees on the shape. */
+export declare const CURSOR_TOOL: ActiveDrawingTool;
+export type Anchor = {
+    ts: bigint;
+    price: number;
+};
+export type TextAlign = 'left' | 'center' | 'right';
+export type VerticalAlign = 'top' | 'middle' | 'bottom';
+export type LabelStyle = {
+    label?: string;
+    labelColor?: string;
+    labelFontSize?: number;
+    labelBold?: boolean;
+    labelItalic?: boolean;
+    labelHorizontalAlign?: TextAlign;
+    labelVerticalAlign?: VerticalAlign;
+    labelTextOrientation?: 'horizontal' | 'vertical';
+};
+export type DrawingAnchorId = 'a' | 'b' | 'c' | 'anchor' | 'body' | 'tl' | 'tr' | 'bl' | 'br' | 'mt' | 'mb' | 'ml' | 'mr' | 'all' | `a${number}`;
+export type HitResult = {
+    drawingId: string;
+    anchor: DrawingAnchorId;
+} | null;
+export type HLineDrawing = {
+    id: string;
+    tool: 'hline';
+    price: number;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type VLineDrawing = {
+    id: string;
+    tool: 'vline';
+    ts: bigint;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type ExtLineDrawing = {
+    id: string;
+    tool: 'extended-line';
+    a: Anchor;
+    b: Anchor;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    extendLeft: boolean;
+    extendRight: boolean;
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type LineDrawing = {
+    id: string;
+    tool: 'line';
+    a: Anchor;
+    b: Anchor;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    extendLeft: boolean;
+    extendRight: boolean;
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type CrossLineDrawing = {
+    id: string;
+    tool: 'cross-line';
+    price: number;
+    ts: bigint;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type InfoLineDrawing = {
+    id: string;
+    tool: 'info-line';
+    a: Anchor;
+    b: Anchor;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    extendLeft?: boolean;
+    extendRight?: boolean;
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type TrendAngleDrawing = {
+    id: string;
+    tool: 'trend-angle';
+    a: Anchor;
+    b: Anchor;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    extendLeft?: boolean;
+    extendRight?: boolean;
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type RayDrawing = {
+    id: string;
+    tool: 'ray';
+    a: Anchor;
+    b: Anchor;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type HorzRayDrawing = {
+    id: string;
+    tool: 'hray';
+    price: number;
+    ts: bigint;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export interface ChannelLevel {
+    id: string;
+    value: number | string;
+    color: string;
+    lineWidth: number;
+    dash: number[];
+    enabled: boolean;
+}
+export type ParallelChannelDrawing = {
+    id: string;
+    tool: 'parallel-channel';
+    a: Anchor;
+    b: Anchor;
+    height: number;
+    enableBackground: boolean;
+    backgroundColor: string;
+    dash: number[];
+    levels?: ChannelLevel[];
+    extendLeft?: boolean;
+    extendRight?: boolean;
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type RectDrawing = {
+    id: string;
+    tool: 'rect';
+    a: Anchor;
+    b: Anchor;
+    color: string;
+    borderColor?: string;
+    borderLineWidth?: number;
+    borderDash?: number[];
+    fillColor?: string;
+    fillOpacity: number;
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export type TriangleDrawing = {
+    id: string;
+    tool: 'triangle';
+    a: Anchor;
+    b: Anchor;
+    c: Anchor;
+    color: string;
+    borderColor?: string;
+    borderLineWidth?: number;
+    borderDash?: number[];
+    fillColor?: string;
+    fillOpacity: number;
+    locked?: boolean;
+    visible?: boolean;
+} & LabelStyle;
+export interface FibLevel {
+    id: string;
+    value: string;
+    color: string;
+    enabled: boolean;
+}
+export type FibDrawing = {
+    id: string;
+    tool: 'fib';
+    a: Anchor;
+    b: Anchor;
+    color: string;
+    levels: FibLevel[];
+    locked?: boolean;
+    visible?: boolean;
+    extendLeft: boolean;
+    extendRight: boolean;
+    dash: number[];
+    lineWidth: number;
+    showPrices: boolean;
+    showLevels: boolean;
+    backgroundColor: string;
+    enableBackground: boolean;
+    labelAlign: string;
+} & LabelStyle;
+export type TextDrawing = {
+    id: string;
+    tool: 'text';
+    anchor: Anchor;
+    text: string;
+    color: string;
+    fontSize: number;
+    bold?: boolean;
+    italic?: boolean;
+    textAlign?: TextAlign;
+    locked?: boolean;
+    visible?: boolean;
+    screenAnchored?: boolean;
+    screenX?: number;
+    screenY?: number;
+};
+export type PositionDrawing = {
+    id: string;
+    a: Anchor;
+    b: Anchor;
+    /** Zone above the entry: target for a long, stop for a short. */
+    upColor: string;
+    /** Zone below the entry: stop for a long, target for a short. */
+    downColor: string;
+    /** Entry line + box border. */
+    entryColor: string;
+    upAmount: number;
+    downAmount: number;
+    /** Contracts/shares - sizes the order the settings bar can place. */
+    qty: number;
+    drawInfo: boolean;
+    fontSize: number;
+    textColor: string;
+    locked?: boolean;
+    visible?: boolean;
+    extendLeft: boolean;
+    extendRight: boolean;
+};
+export type LongDrawing = PositionDrawing & {
+    tool: 'long';
+};
+export type ShortDrawing = PositionDrawing & {
+    tool: 'short';
+};
+export type PluginDrawing = {
+    id: string;
+    tool: string;
+    anchors: Anchor[];
+    data?: unknown;
+    locked?: boolean;
+    visible?: boolean;
+};
+export type PluginDraftDrawing = {
+    tool?: undefined;
+    pluginToolId: string;
+    anchors: Anchor[];
+    data?: unknown;
+};
+export type VpDataCache = {
+    prices: Float64Array;
+    buyVol: Float64Array;
+    sellVol: Float64Array;
+    totalVol: Float64Array;
+    poc: number;
+};
+export type FvpProfileMode = 'stacked' | 'split' | 'delta' | 'total';
+export type FixedVolumeProfileDrawing = {
+    id: string;
+    tool: 'fvp';
+    a: Anchor;
+    b: Anchor;
+    profileMode: FvpProfileMode;
+    barsWidth: number;
+    barOpacity: number;
+    enableBuyColor: boolean;
+    buyColor: string;
+    enableSellColor: boolean;
+    sellColor: string;
+    totalColor: string;
+    deltaNegColor: string;
+    showVolNumbers: boolean;
+    volNumbersFontSize: number;
+    showPoc: boolean;
+    pocColor: string;
+    showPocLabel: boolean;
+    pocExtendLeft: boolean;
+    pocExtendRight: boolean;
+    showValueArea: boolean;
+    valueAreaPct: number;
+    valueAreaFillColor: string;
+    showVaHLines: boolean;
+    vaLineColor: string;
+    vaLineExtendLeft: boolean;
+    vaLineExtendRight: boolean;
+    showDevPoc: boolean;
+    devPocColor: string;
+    showDevVa: boolean;
+    devVaColor: string;
+    enableBg: boolean;
+    bgColor: string;
+    enableBorder: boolean;
+    borderColor: string;
+    borderDash: number[];
+    highlightPocBar: boolean;
+    pocBarLineWidth: number;
+    vaBarDimming: boolean;
+    vaOutsideDimFrac: number;
+    labelPills: boolean;
+    splitCenterLine: boolean;
+    barGap: boolean;
+    /** Runtime-only - never serialized. */
+    vpData?: VpDataCache;
+} & LabelStyle;
+export type Drawing = HLineDrawing | VLineDrawing | ExtLineDrawing | LineDrawing | CrossLineDrawing | InfoLineDrawing | TrendAngleDrawing | RayDrawing | HorzRayDrawing | ParallelChannelDrawing | RectDrawing | TriangleDrawing | FibDrawing | TextDrawing | FixedVolumeProfileDrawing | LongDrawing | ShortDrawing | PluginDrawing;
+export declare const DEFAULT_FIB_LEVELS: FibLevel[];
+export declare const DEFAULT_CHANNEL_LEVELS: ChannelLevel[];
+export declare function defaultStyleForTool(tool: DrawingTool): Partial<Drawing>;
+/**
+ * Arm a tool for creation. The id is minted here so the tool, the draft and the
+ * committed drawing all share one identity - `getActiveTool().id` names the
+ * drawing that is about to exist.
+ */
+export declare function armTool(tool: DrawingTool, style?: Partial<Drawing>): ActiveDrawingTool;
+/** Describe an existing drawing in the same shape an armed tool uses. */
+export declare function toolFromDrawing(d: Drawing): ActiveDrawingTool;
+export declare const HIT_TOLERANCE_PX = 7;
+export type DraftDrawing = {
+    tool: 'hline';
+    price: number;
+} | {
+    tool: 'vline';
+    ts: bigint;
+} | {
+    tool: 'hray' | 'cross-line';
+    price: number;
+    ts: bigint;
+} | {
+    tool: 'line' | 'ray' | 'extended-line' | 'info-line' | 'trend-angle' | 'parallel-channel';
+    a: Anchor;
+    b: Anchor | null;
+} | {
+    tool: 'rect' | 'fib';
+    a: Anchor;
+    b: Anchor | null;
+} | {
+    tool: 'triangle';
+    a: Anchor;
+    b: Anchor | null;
+} | {
+    tool: 'text';
+    anchor: Anchor;
+} | {
+    tool: 'fvp';
+    a: Anchor;
+    b: Anchor | null;
+} | PluginDraftDrawing;
+export type DrawingStyleTemplate = {
+    id: string;
+    name: string;
+    tool: DrawingTool;
+    style: Partial<Drawing>;
+    createdAt: number;
+};
+export declare function loadTemplates(): DrawingStyleTemplate[];
+export declare function saveTemplate(tpl: DrawingStyleTemplate): void;
+export declare function deleteTemplate(id: string): void;
+export {};

package/types/lib/types/footprint.d.ts

@@ -0,0 +1,119 @@
+import type { MboEvent } from '.';
+/** Volume at a single price level inside one bar. */
+export type FootprintLevel = {
+    price: number;
+    bidVol: number;
+    askVol: number;
+    delta: number;
+    totalVol: number;
+    /** Bid volume significantly exceeds ask at this level (sell imbalance). */
+    bidImbalance: boolean;
+    /** Ask volume significantly exceeds bid at this level (buy imbalance). */
+    askImbalance: boolean;
+    /**
+     * DIAGONAL IMBALANCE
+     * Sierra Chart / Bookmap definition: compares the ASK at this level
+     * against the BID one tick BELOW, and the BID at this level against the
+     * ASK one tick ABOVE.  This surfaces diagonal pressure in the tape.
+     *
+     * diagAskImbalance: ask[n] >= threshold x bid[n-1]   -> upward diagonal pressure
+     * diagBidImbalance: bid[n] >= threshold x ask[n+1]   -> downward diagonal pressure
+     */
+    diagAskImbalance: boolean;
+    diagBidImbalance: boolean;
+    /**
+     * ABSORPTION
+     * Large volume that didn't move price - the market "absorbed" the flow.
+     * Detected when totalVol >= absorptionThreshold AND the level is inside
+     * the bar body (between open and close), AND the delta is small relative
+     * to the volume (i.e. both sides traded heavily).
+     */
+    absorption: boolean;
+};
+/** All price levels for a single candle bar. */
+export type FootprintBar = {
+    /** Bar open timestamp (nanoseconds, floored to barNs boundary). */
+    ts: bigint;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    totalVol: number;
+    totalDelta: number;
+    maxLevelVol: number;
+    maxAbsDelta: number;
+    /** Sorted high->low. */
+    levels: FootprintLevel[];
+    isBullish: boolean;
+    poc: number;
+    /**
+     * STACKED IMBALANCE (buy side)
+     * Price range [stackedBuyLow, stackedBuyHigh] where >= stackMinCount
+     * consecutive levels all have askImbalance === true.
+     * Can be multiple non-overlapping stacks per bar.
+     */
+    stackedBuyZones: PriceRange[];
+    /**
+     * STACKED IMBALANCE (sell side)
+     * Price range where >= stackMinCount consecutive levels all have bidImbalance.
+     */
+    stackedSellZones: PriceRange[];
+    /**
+     * UNFINISHED AUCTION (high)
+     * The bar high has zero (or near-zero) ask volume - buyers ran out of
+     * sellers at the top, price "unfinished" - likely to revisit.
+     */
+    unfinishedTop: boolean;
+    /**
+     * UNFINISHED AUCTION (low)
+     * The bar low has zero (or near-zero) bid volume - sellers ran out of
+     * buyers at the bottom.
+     */
+    unfinishedBottom: boolean;
+    /** Number of levels with absorption signal in this bar. */
+    absorptionCount: number;
+    /** Dominant diagonal imbalance direction for the bar ('buy'|'sell'|'none'). */
+    diagDominant: 'buy' | 'sell' | 'none';
+};
+export type PriceRange = {
+    low: number;
+    high: number;
+};
+/**
+ * Display mode for footprint cells.
+ *
+ * 'bid-ask'  - two columns per level: sell vol (left) | buy vol (right)
+ * 'profile'  - single bar, width = total vol, green/red by dominant side
+ * 'delta'    - bar width = |delta|, coloured by direction
+ * 'total'    - bar width = total vol, neutral grey
+ */
+export type FootprintMode = 'bid-ask' | 'profile' | 'delta' | 'total';
+export type FootprintOptions = {
+    tickSize?: number;
+    /** Ratio threshold for a level to be considered imbalanced (default 3.0 = 300%). */
+    imbalanceRatio?: number;
+    /**
+     * Minimum consecutive imbalanced levels to form a stacked imbalance zone
+     * (default 3).
+     */
+    stackMinCount?: number;
+    /**
+     * Volume threshold multiplier for absorption detection.
+     * A level is "absorbed" when totalVol >= absorptionMult x bar average level vol
+     * AND |delta / totalVol| <= absorptionDeltaFrac (default 0.25).
+     */
+    absorptionMult?: number;
+    absorptionDeltaFrac?: number;
+    /**
+     * How many ticks from the bar extreme to look for unfinished auction.
+     * Default 1 = only the exact high/low tick.
+     */
+    unfinishedTicks?: number;
+    /**
+     * Diagonal imbalance ratio threshold.
+     * ask[n] / bid[n-1] >= diagRatio  -> diagAskImbalance
+     * Default: same as imbalanceRatio.
+     */
+    diagRatio?: number;
+};
+export declare function buildFootprint(events: MboEvent[], barNs: bigint, options?: FootprintOptions): FootprintBar[];

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

@@ -0,0 +1,30 @@
+import type { MboEvent } from '.';
+import type { ViewBounds } from '.';
+export type SerializedBounds = {
+    tMin: string;
+    tMax: string;
+    pMin: number;
+    pMax: number;
+};
+export type WorkerInitMessage = {
+    type: 'init';
+    events: MboEvent[];
+};
+export type HeatmapRequest = {
+    type: 'render';
+    requestId: number;
+    bounds: SerializedBounds;
+    chartW: number;
+    chartH: number;
+    /** Optional playback horizon (nanoseconds as string). When set, the worker
+     *  stops adding new snapshot columns at this timestamp but forward-fills the
+     *  last column to the right edge of the canvas - showing the last known book
+     *  state held flat into the future, matching trades/bid-ask line behaviour. */
+    horizonNs?: string;
+};
+export type HeatmapResponse = {
+    requestId: number;
+    bitmap: ImageBitmap;
+    bounds: SerializedBounds;
+};
+export declare function serializeBounds(b: ViewBounds): SerializedBounds;

package/types/lib/types/index.d.ts

@@ -0,0 +1,147 @@
+export type MboEvent = {
+    ts_event: string;
+    action: 'A' | 'C' | 'M' | 'T' | 'F' | 'R';
+    side: 'B' | 'A' | 'N';
+    price: number | null;
+    size: number;
+    order_id: string;
+    sequence: number;
+    flags: number;
+};
+export type Order = {
+    price: number;
+    size: number;
+};
+export type BookState = {
+    bids: Map<string, Order>;
+    asks: Map<string, Order>;
+    /** Cached best bid price - maintained incrementally by applyEvent(). O(1) read. */
+    bestBid: number | null;
+    /** Cached best ask price - maintained incrementally by applyEvent(). O(1) read. */
+    bestAsk: number | null;
+};
+export type TradePoint = {
+    ts: bigint;
+    price: number;
+    size: number;
+    side: 'B' | 'A';
+};
+export type PriceHistory = {
+    ts: bigint;
+    bestAsk: number;
+    bestBid: number;
+};
+export type BookSnapshot = {
+    ts: bigint;
+    bids: Map<number, number>;
+    asks: Map<number, number>;
+};
+export type ChartType = 'line' | 'area' | 'step' | 'candles' | 'hollow' | 'heikin-ashi' | 'bars' | 'baseline' | 'renko' | 'kagi' | 'line-break' | 'footprint' | (string & {});
+export type DataResponse = {
+    requestId: string;
+    events: any;
+};
+export type DataRequest = {
+    requestId: string;
+    event: string;
+};
+export type TradeLineKind = 'entry' | 'sl' | 'tp' | 'be' | 'limit' | 'stop' | 'stop_limit' | 'alert' | 'custom';
+export type TradeLineSide = 'long' | 'short' | 'neutral';
+export type TradeLine = {
+    id?: string;
+    kind: TradeLineKind;
+    side?: TradeLineSide;
+    price: number;
+    /** If set the line snaps to the nearest tick multiple on drag */
+    tickSize?: number;
+    label?: string;
+    qty?: number;
+    pnl?: number;
+    pnlPct?: number;
+    pnlLabel?: string;
+    entryPrice?: number;
+    color?: string;
+    lineWidth?: number;
+    lineDash?: number[];
+    opacity?: number;
+    /** Show a subtle filled band between this line and `bandToPrice` */
+    bandToPrice?: number;
+    bandOpacity?: number;
+    /**
+     * When true on an `entry` line: renders two small draggable mini-pills
+     * (TP and SL) to the left of the main pill.
+     * Drag them vertically to set a take-profit or stop-loss price.
+     * The band from entry->TP/SL is drawn while dragging.
+     * Multiple TP/SL pairs are supported - use `onGhostMove` in useTradeLines
+     * to persist prices. Ghost state is managed by useTradeLines.
+     * `numGhosts` controls how many TP/SL pairs to show (default 1).
+     */
+    ghosts?: boolean;
+    /** Number of TP/SL ghost pill pairs to render (default 1). */
+    numGhosts?: number;
+    align?: 'left' | 'right';
+    /** Margin from the aligned edge in px or % */
+    margin?: number;
+    marginType?: 'px' | 'percent';
+    showPricePill?: boolean;
+    showLinePill?: boolean;
+    showPnlPill?: boolean;
+    /** Extra badges shown in the inline pill, e.g. ["2 NQ", "+$420", "1.3R"] */
+    badges?: string[];
+    /**
+     * An order that hasn't been placed - drawn where it would land.
+     *
+     * Styling only, and deliberately separate from `locked`: a proposal is
+     * still something you grab and move. It draws dotted and darkened so it
+     * reads as intent rather than as a position you actually hold.
+     */
+    preview?: boolean;
+    movable?: boolean;
+    locked?: boolean;
+    /** Called when user finishes dragging (mouseup). New price passed in. */
+    onMove?: (newPrice: number) => void;
+    afterMove?: (newPrice: number) => void;
+    /** Called when user clicks the x button */
+    onClose?: () => void;
+    /** Called when user clicks the reverse/flip button */
+    onReverse?: () => void;
+    /** Called when user right-clicks the line */
+    onContextMenu?: (price: number, y: number) => void;
+    /** Called when user double-clicks the line */
+    onDoubleClick?: (price: number) => void;
+    onClick?: (price: number) => void;
+    visible?: boolean;
+    /** Hide below this chart height in px */
+    minChartHeightToShow?: number;
+};
+export type CreateOrderEvent = {
+    side: TradeLineSide;
+    price: number;
+    type: 'market' | 'limit' | 'stop' | 'stop_limit';
+    qty: number;
+    stop?: number;
+};
+export type ViewBounds = {
+    tMin: bigint;
+    tMax: bigint;
+    pMin: number;
+    pMax: number;
+    pRef?: number;
+};
+export type SerialTrade = {
+    ts: bigint;
+    price: number;
+    size: number;
+    side: 'B' | 'A';
+};
+export type OhlcvBarMs = {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+};
+export interface DomPanelHandle {
+    update(state: BookState): void;
+}