@agg-build/sdk 4.17.4 → 4.18.0

package/dist/agg-websocket-BatL1Zrt.d.ts

@@ -0,0 +1,4320 @@
+type CandleInterval = "1m" | "5m" | "1h" | "1d";
+/** Universal OHLCV candle. Chart-library-agnostic. */
+interface Candle {
+    /** Interval-aligned open time in seconds. */
+    openTime: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    /** Accumulated trade volume. 0 if no trades in interval. */
+    v: number;
+    tradeCount: number;
+    isFinal: boolean;
+}
+/**
+ * Accumulates OHLCV candles from orderbook delta midpoints and trades.
+ * All 4 intervals computed simultaneously. onChange batched via rAF (~16ms).
+ */
+declare class CandleBuilder {
+    private forming;
+    private closedMap;
+    private listeners;
+    private _midpoint;
+    private dirty;
+    private scheduled;
+    constructor();
+    /** Feed a midpoint (from orderbook delta). Updates O/H/L/C for all intervals. */
+    addMidpoint(midpoint: number, timestampSecs: number): void;
+    /** Feed a trade. Updates volume + refines H/L/C from trade price. */
+    addTrade(price: number, size: number, timestampSecs: number): void;
+    /** Current forming candle for an interval. */
+    getForming(interval: CandleInterval): Candle | null;
+    /** Closed candles for an interval (ring buffer, max 500, newest last). */
+    getClosed(interval: CandleInterval): Candle[];
+    /** Apply a bounded Worker view without recomputing candles from presentation samples. */
+    replaceTail(tail: Record<CandleInterval, {
+        forming: Candle | null;
+        closed: Candle[];
+    }>): void;
+    /** Current midpoint (latest value fed). */
+    get midpoint(): number | null;
+    /**
+     * Subscribe to state changes. Returns unsubscribe function.
+     * BATCHED: callbacks fire at most once per rAF frame (~16ms).
+     * In non-browser environments, falls back to 16ms setTimeout.
+     */
+    onChange(listener: () => void): () => void;
+    /** Clear all state (on reconnect). */
+    reset(): void;
+    /** Clear all state AND unsubscribe all listeners. Called on store eviction. */
+    dispose(): void;
+    private updateCandle;
+    private markDirty;
+}
+
+/**
+ * WebSocket protocol types for the Agg platform.
+ * All callback timestamps are in **seconds** (converted from server ms at SDK dispatch).
+ * These are plain TS interfaces — no Zod dependency for partner-side usage.
+ */
+/** Aggregated level wire format: [price, totalSize, {venue: sizeAtPrice}] */
+type WsAttributedLevel = [number, number, Record<string, number>];
+/** Per-venue level wire format: [price, size] */
+type WsVenueLevel = [number, number];
+interface WsVenueInfo {
+    bestBid: number | null;
+    bestAsk: number | null;
+}
+interface WsVenueBook {
+    bids: WsVenueLevel[];
+    asks: WsVenueLevel[];
+}
+interface WsOrderbookSnapshot {
+    type: "orderbook_snapshot";
+    outcomeId: string;
+    channel?: "orderbook" | "trades";
+    seq: number;
+    checksum: number;
+    bids: WsAttributedLevel[];
+    asks: WsAttributedLevel[];
+    venueOrderbooks: Record<string, WsVenueBook>;
+    venues: Record<string, WsVenueInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+    /**
+     * Sticky tick of this outcome's book, inferred at runtime by the engine.
+     * `null` until inferred. Optional — older snapshot producers (REST fallback)
+     * may omit this field entirely.
+     */
+    tick?: number | null;
+    /** Provenance of the published `midpoint`. See {@link MarkSource}. */
+    markSource?: MarkSource$1;
+}
+/**
+ * Provenance tag for a published midpoint. Mirrors the Rust engine
+ * `MarkSource::as_str()` output.
+ */
+type WsMarkSource = "local" | "local_merged" | "local_one_sided" | "sibling" | "local_boundary" | "none";
+type MarkSource$1 = WsMarkSource;
+interface WsOrderbookDelta {
+    type: "orderbook_delta";
+    outcomeId: string;
+    channel?: "orderbook" | "trades";
+    seq: number;
+    checksum: number;
+    bidChanges: WsAttributedLevel[];
+    askChanges: WsAttributedLevel[];
+    venueDeltaBooks: Record<string, {
+        bidChanges: WsVenueLevel[];
+        askChanges: WsVenueLevel[];
+    }>;
+    venues: Record<string, WsVenueInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+interface WsTrade {
+    type: "trade";
+    outcomeId: string;
+    channel?: "orderbook" | "trades";
+    venue: string;
+    side: "buy" | "sell";
+    price: number;
+    size: number;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+type WsCandleInterval = "1m" | "5m" | "1h" | "1d";
+interface WsSubscribed {
+    type: "subscribed";
+    /** Confirmed ids. For `orderbook`/`trades` these are venueMarketOutcomeIds.
+     *  For `arb` this historically mirrors the marketIds — prefer `marketIds`. */
+    outcomeIds: string[];
+    /** Confirmed marketIds — only set on `arb` confirmations, whose
+     *  subscriptions are keyed by marketIds, not outcomeIds. */
+    marketIds?: string[];
+    channel: "orderbook" | "trades" | "arb" | "arb-feed";
+}
+interface WsUnsubscribed {
+    type: "unsubscribed";
+    /** See {@link WsSubscribed.outcomeIds}. */
+    outcomeIds: string[];
+    /** Confirmed marketIds — only set on `arb` confirmations. */
+    marketIds?: string[];
+    channel: "orderbook" | "trades" | "arb" | "arb-feed";
+}
+interface WsConnected {
+    type: "connected";
+    appId: string;
+    userId?: string;
+}
+interface WsAuthenticated {
+    type: "authenticated";
+    userId: string;
+}
+interface WsHeartbeat {
+    type: "heartbeat";
+    /** @unit seconds (converted from server ms) */
+    ts: number;
+}
+interface WsResolvedOutcome {
+    label: string;
+    winner?: boolean;
+    externalIdentifier?: string;
+}
+interface WsMarketResolved {
+    type: "market_resolved";
+    outcomeId: string;
+    status: "resolved" | "closed";
+    /** Winning outcome label, or null if unknown. */
+    result: string | null;
+    /** Per-outcome resolution data. */
+    outcomes: WsResolvedOutcome[];
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+interface WsError {
+    type: "error";
+    message: string;
+}
+interface WsOrderSubmitted {
+    type: "order_submitted";
+    venue: string;
+    orderId: string;
+    side: string;
+    price: number;
+    size: number;
+    outcomeId?: string;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+interface WsBalanceUpdate {
+    type: "balance_update";
+    venue: string;
+    tradingBalanceCents: number;
+    walletBalanceCents?: number;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+type WsOrderEventType = "cancelled" | "created" | "signed" | "pending_bridge" | "bridge_complete" | "submitting" | "submitted" | "expired" | "dag_started" | "dag_completed" | "dag_failed" | "dag_cancelled" | "step_started" | "step_completed" | "step_waiting" | "step_failed" | "step_retrying" | "filled" | "partial_fill" | "failed" | "bridge_ws_subscribed" | "bridge_ws_subscribe_failed" | "bridge_polling_fallback";
+interface WsOrderEvent {
+    type: "order_event";
+    event: WsOrderEventType;
+    userId: string;
+    orderId: string;
+    /** Partner trade id from `placeOrder()`, when the order carried one. */
+    externalId?: string;
+    venue: string;
+    dagRunId?: string;
+    stepId?: string;
+    stepType?: string;
+    /** 1-based step index. Pair with `totalSteps` to render "Step 3 of 7". */
+    sequence?: number;
+    totalSteps?: number;
+    templateName?: string;
+    /** Maps sequence → stepType for all steps — sent on dag_started so labels are available upfront. */
+    stepTypes?: Record<number, string>;
+    filledAmountRaw?: string;
+    remainingAmountRaw?: string;
+    /**
+     * Quote-time and actual shares + payout. All 6-decimal atomic units
+     * (so 1.234567 shares = "1234567", "$50 to win" = "50000000"). Set
+     * on `filled` / `partial_fill` so the UI can render "Quoted X / Got Y"
+     * without re-deriving from cost ÷ price (which loses precision on
+     * fractional fills and divides by zero before `executionPrice` exists).
+     */
+    quotedSharesRaw?: string;
+    actualSharesRaw?: string;
+    quotedToWinRaw?: string;
+    actualToWinRaw?: string;
+    /** Quote-time price (decimal string, e.g. "0.5"). Pair with `executionPriceRaw`
+     * to render the slippage diff inline. */
+    quotedPriceRaw?: string;
+    /** Actual avg fill price (decimal string). */
+    executionPriceRaw?: string;
+    /**
+     * Set on `partial_fill` events only. One of `"venue_capacity"`,
+     * `"price_slipped"`, `"user_cancelled"`, `"timeout"`, `"bridge_short"`,
+     * or a venue-specific tag.
+     */
+    partialFillReason?: string;
+    errorReason?: string;
+    attempt?: number;
+    correlationId?: string;
+    /** @unit milliseconds (raw from server — NOT converted like other WS types) */
+    timestamp: number;
+}
+interface WsRedeemEvent {
+    type: "redeem_event";
+    redeemId: string;
+    venueMarketOutcomeId: string;
+    status: "submitted" | "confirmed" | "failed";
+    callsId: string | null;
+    pendingUserOpId: string | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    /** @unit seconds (converted from server ms) */
+    timestamp: number;
+}
+/** Top-level withdrawal lifecycle states surfaced to partner clients. */
+type WsWithdrawalLifecycleStatus = "pending" | "bridging" | "transferring" | "completed" | "partial" | "failed";
+type WsWithdrawalLegStatus = "planned" | "submitted" | "confirmed" | "failed";
+interface WsWithdrawalLifecycleLeg {
+    sourceChainId: number;
+    destChainId: number;
+    type: "transfer" | "bridge";
+    status: WsWithdrawalLegStatus;
+    amountRaw: string;
+    txHash: string | null;
+    bridgeOperationId: string | null;
+    /** Human-readable failure reason when `status === "failed"`. Null/absent when succeeded or in-flight. */
+    errorMessage?: string | null;
+}
+/**
+ * Per-withdrawal lifecycle event. Wire shape is intentionally additive:
+ * consumers should pass through unknown enum values rather than failing.
+ */
+interface WsWithdrawalLifecycleEvent {
+    type: "withdrawal_lifecycle";
+    withdrawalId: string;
+    userId: string;
+    status: WsWithdrawalLifecycleStatus;
+    /** Requested withdrawal amount in destination-token native decimals. */
+    requestedAmountRaw?: string;
+    /** Terminal settled amount in destination-token native decimals. */
+    completedAmountRaw?: string | null;
+    /** Realized platform fee in destination-token native decimals. Only present on terminal events. */
+    feeRaw?: string | null;
+    /** True when `status` is terminal (`completed` / `partial` / `failed`). */
+    terminal: boolean;
+    /** Optional leg delta — present when this event was triggered by a leg flip. */
+    leg?: WsWithdrawalLifecycleLeg;
+    /** All legs at the moment of emission (snapshot). */
+    legs?: WsWithdrawalLifecycleLeg[];
+    /** Failure reason for terminal `failed` / `partial`. */
+    errorMessage?: string;
+    correlationId?: string;
+    /** @unit milliseconds (raw from server — NOT converted like other WS types) */
+    timestamp: number;
+}
+interface WsArbMarketUpdate {
+    type: "arb_market_update";
+    marketId: string;
+    /** Producer assertion that globally inactive venues were excluded. */
+    activeVenuesOnly: true;
+    venueEventId: string | null;
+    arbReturn: number;
+    ts: number;
+    liquidityUsd?: number;
+    liquidityTier?: "deep" | "shallow";
+}
+interface WsArbFeedEntry {
+    marketId: string;
+    venueEventId: string | null;
+    arbReturn: number;
+    ts: number;
+    liquidityUsd?: number;
+    liquidityTier?: "deep" | "shallow";
+}
+interface WsArbFeedBatch {
+    type: "arb_feed_batch";
+    feed: "arb";
+    /** Producer assertion that globally inactive venues were excluded. */
+    activeVenuesOnly: true;
+    entries: WsArbFeedEntry[];
+    flushTs: number;
+    chunk: number;
+    chunkCount: number;
+}
+type WsServerMessage = WsOrderbookSnapshot | WsOrderbookDelta | WsTrade | WsSubscribed | WsUnsubscribed | WsConnected | WsAuthenticated | WsHeartbeat | WsMarketResolved | WsError | WsOrderSubmitted | WsBalanceUpdate | WsOrderEvent | WsRedeemEvent | WsWithdrawalLifecycleEvent | WsArbMarketUpdate | WsArbFeedBatch;
+type WsClientMessage = {
+    action: "subscribe";
+    channel: "orderbook" | "trades";
+    outcomeIds: string[];
+} | {
+    action: "unsubscribe";
+    channel: "orderbook" | "trades";
+    outcomeIds: string[];
+} | {
+    action: "resnapshot";
+    channel: "orderbook";
+    outcomeIds: string[];
+} | {
+    action: "subscribe";
+    channel: "arb";
+    marketIds: string[];
+} | {
+    action: "unsubscribe";
+    channel: "arb";
+    marketIds: string[];
+} | {
+    action: "subscribe";
+    channel: "arb-feed";
+} | {
+    action: "unsubscribe";
+    channel: "arb-feed";
+} | {
+    action: "authenticate";
+    token: string;
+};
+type DiagnosticEvent = {
+    type: "seq_gap";
+    marketId: string;
+    outcomeId: string;
+    expected: number;
+    received: number;
+} | {
+    type: "checksum_mismatch";
+    marketId: string;
+    outcomeId: string;
+    expected: number;
+    computed: number;
+} | {
+    type: "reconnect";
+    attempt: number;
+    delayMs: number;
+} | {
+    type: "stale_connection";
+    lastMessageAge: number;
+};
+type DiagnosticCallback = (event: DiagnosticEvent) => void;
+
+/**
+ * Immutable orderbook utility functions for the SDK.
+ * Applies WS deltas to local book state, computes checksums for integrity verification.
+ * Every function returns a **new object** — never mutates inputs.
+ */
+
+interface OrderbookLevel {
+    price: number;
+    size: number;
+    venues: Record<string, number>;
+}
+interface VenueOrderbookLevel {
+    price: number;
+    size: number;
+}
+interface OrderbookState {
+    marketId: string;
+    /** The outcome whose price the midpoint represents (e.g. the "Yes" outcome in binary markets). */
+    outcomeId?: string | null;
+    bids: OrderbookLevel[];
+    asks: OrderbookLevel[];
+    venueOrderbooks: Record<string, {
+        bids: VenueOrderbookLevel[];
+        asks: VenueOrderbookLevel[];
+    }>;
+    venues: Record<string, WsVenueInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    seq: number;
+    checksum: number;
+    /** @unit seconds */
+    timestamp: number;
+}
+/**
+ * Compute the XOR-based checksum of an orderbook.
+ * Matches the Rust engine's checksum: XOR of crc32("B{price}:{size}") for each
+ * bid and crc32("A{price}:{size}") for each ask, independently hashed then XOR'd.
+ */
+declare function computeChecksum(book: {
+    bids: OrderbookLevel[];
+    asks: OrderbookLevel[];
+}): number;
+/**
+ * Convert a WS snapshot message into local OrderbookState.
+ * Timestamp is expected to already be in seconds (converted by AggWebSocket).
+ */
+declare function snapshotToOrderbook(snapshot: WsOrderbookSnapshot): OrderbookState;
+/**
+ * Apply a WS delta to an existing OrderbookState, returning a new state.
+ * Bids sorted descending, asks ascending (maintained invariant).
+ */
+declare function applyOrderbookDelta(state: OrderbookState, delta: WsOrderbookDelta): OrderbookState;
+
+/** Use these constants instead of hardcoding "kalshi" or "polymarket". */
+declare enum Venue {
+    kalshi = "kalshi",
+    polymarket = "polymarket",
+    limitless = "limitless",
+    opinion = "opinion",
+    predict = "predict",
+    pred = "pred",
+    tiprun = "tiprun",
+    probable = "probable",
+    myriad = "myriad",
+    hyperliquid = "hyperliquid",
+    novig = "novig",
+    prophetx = "prophetx",
+    betdex = "betdex"
+}
+/** Single source of truth for venue identifiers. */
+declare const VENUES: readonly [Venue.kalshi, Venue.polymarket, Venue.limitless, Venue.opinion, Venue.predict, Venue.pred, Venue.tiprun, Venue.probable, Venue.myriad, Venue.hyperliquid, Venue.novig, Venue.prophetx, Venue.betdex];
+/** Canonical destination chain for venues with on-chain funding or settlement. */
+declare const VENUE_CHAIN_IDS: Partial<Record<Venue, number>>;
+/**
+ * Venues that participate in new discovery, market-data, and execution flows.
+ *
+ * Keep retired venues in {@link Venue} and {@link VENUES}: historical orders,
+ * positions, settlement, and redemption still rely on those identifiers.
+ * Re-activating a venue is therefore an intentional code change here rather
+ * than a runtime configuration toggle.
+ */
+declare const ACTIVE_VENUES: readonly [Venue.kalshi, Venue.polymarket, Venue.limitless, Venue.opinion, Venue.predict, Venue.pred, Venue.tiprun, Venue.probable, Venue.myriad, Venue.hyperliquid, Venue.novig, Venue.prophetx, Venue.betdex];
+/**
+ * Venues excluded from new user-facing activity. BETDEX is active at the
+ * compile-time boundary now that discovery and execution are implemented;
+ * partner rollout remains controlled by app policy and runtime flags.
+ */
+declare const INACTIVE_VENUES: readonly [];
+/** Whether a venue may participate in new user-facing activity. */
+declare function isVenueActive(venue: string): boolean;
+/** Whether a venue is intentionally retained only for wind-down/history flows. */
+declare function isVenueInactive(venue: string): boolean;
+/**
+ * Data-plane visibility (listings/search/orderbook DISPLAY). Distinct from
+ * {@link isVenueActive} (execution/routing) — this predicate never affects
+ * whether a venue can trade. `dataVisibleOverride` un-hides specific venues
+ * for DATA surfaces only; callers pass an env-derived list.
+ */
+declare function isVenueDataVisible(venue: string, dataVisibleOverride?: readonly Venue[]): boolean;
+/**
+ * Merge app-specific disabled venues with the compile-time retired set, then
+ * remove any venue explicitly opted into data visibility via
+ * `dataVisibleVenues` (see {@link isVenueDataVisible}). Results use the
+ * canonical {@link VENUES} order and ignore unknown values.
+ */
+declare function getEffectiveDisabledVenues(disabledVenues?: readonly (Venue | string)[], dataVisibleVenues?: readonly Venue[]): Venue[];
+
+declare enum AccountType {
+    oauth = "oauth",
+    siwe = "siwe",
+    siws = "siws",
+    email = "email"
+}
+declare enum AccountProvider {
+    wallet = "wallet",
+    solana_wallet = "solana_wallet",
+    google = "google",
+    twitter = "twitter",
+    apple = "apple",
+    email = "email"
+}
+
+declare enum Chain {
+    evm = "evm",
+    svm = "svm"
+}
+
+declare enum MatchStatus {
+    pending = "pending",
+    unmatched = "unmatched",
+    review = "review",
+    matched = "matched",
+    verified = "verified",
+    rejected = "rejected"
+}
+declare enum MatchType {
+    manual = "manual",
+    llm = "llm"
+}
+/** Match statuses considered "confirmed" for user-facing data (orderbooks, listings, aggregation). */
+declare const CONFIRMED_MATCH_STATUSES: MatchStatus[];
+declare enum MarketStatus {
+    open = "open",
+    closed = "closed",
+    resolved = "resolved",
+    unopened = "unopened",
+    paused = "paused"
+}
+
+declare enum OrderStatus {
+    pending = "pending",
+    signing = "signing",
+    pending_bridge = "pending_bridge",
+    submitting = "submitting",
+    submitted = "submitted",
+    open = "open",
+    partially_filled_open = "partially_filled_open",
+    cancel_pending = "cancel_pending",
+    filled = "filled",
+    partial_fill = "partial_fill",
+    failed = "failed",
+    expired = "expired",
+    cancelled = "cancelled"
+}
+declare enum TradeSide$1 {
+    Buy = "buy",
+    Sell = "sell"
+}
+declare enum OrderType {
+    Market = "market",
+    Limit = "limit"
+}
+declare enum TimeInForce {
+    GTC = "GTC",
+    GTD = "GTD",
+    FOK = "FOK",
+    FAK = "FAK",
+    IOC = "IOC",
+    ALO = "ALO"
+}
+
+/**
+ * Standalone type definitions — no Zod dependency.
+ * These mirror the types in types/index.ts but are defined as plain interfaces.
+ * Used by the types-only barrel to avoid leaking Zod into SDK/hooks declarations.
+ */
+
+type HelloResponse = {
+    message: string;
+};
+type App = {
+    id: string;
+    name: string;
+    allowedOrigins: string[];
+    active: boolean;
+    blockedCountries: string[];
+    blockedRegions: string[];
+    orderFee: string;
+    signupBonus: string;
+    createdAt: string;
+    updatedAt: string;
+};
+type CreateApp = {
+    name: string;
+    allowedOrigins: string[];
+    blockedCountries: string[];
+    blockedRegions: string[];
+};
+type NonceResponse = {
+    nonce: string;
+};
+type AuthUser = {
+    id: string;
+};
+type UserProfile = {
+    id: string;
+    username: string | null;
+    avatarUrl: string | null;
+    externalId: string | null;
+    isLocationBlocked: boolean;
+    accounts: {
+        type: AccountType;
+        provider: AccountProvider;
+        providerAccountId: string;
+    }[];
+    wallets: {
+        chain: Chain;
+        address: string;
+    }[];
+    venueAccounts: {
+        status: string;
+        id: string;
+        venue: Venue;
+        kycStatus: string;
+    }[] | null;
+};
+type Account = {
+    type: AccountType;
+    provider: AccountProvider;
+    providerAccountId: string;
+};
+type ServerWallet = {
+    chain: Chain;
+    address: string;
+};
+type UpdateUserBody = {
+    username?: string | undefined;
+    confirmAvatar?: true | undefined;
+    removeAvatar?: true | undefined;
+};
+type VerifyBody = {
+    message: string;
+    signature: string;
+};
+type VerifyResponse = {
+    accessToken: string;
+    user: {
+        id: string;
+    };
+    refreshToken?: string | undefined;
+};
+type AuthTokenResponse = {
+    accessToken: string;
+    user: {
+        id: string;
+    };
+    refreshToken?: string | undefined;
+};
+type AuthCodeResponse = {
+    code: string;
+};
+type ProphetxExecutionMode = "clearinghouse" | "direct";
+type UpsertVenueKey = {
+    venue: Venue.prophetx;
+    credentials: {
+        accessKey: string;
+        secretKey: string;
+    };
+} | {
+    venue: Venue.kalshi;
+    credentials: {
+        keyId: string;
+        privateKey: string;
+    };
+} | {
+    venue: Venue.polymarket;
+    credentials: {
+        apiKey: string;
+        secret: string;
+        passphrase: string;
+    };
+};
+type VenueKeySummary = {
+    updatedAt: string;
+    venue: Venue;
+};
+type VenueKeyStatus = {
+    hasAccountHistory?: boolean;
+    venue: Venue;
+    connected: boolean;
+    validatedAt: string | null;
+    kycStatus: string;
+};
+type TradeSplit = {
+    venue: Venue;
+    venueMarketOutcomeId: string;
+    side: TradeSide$1;
+    price: number;
+    size: number;
+    signedOrder?: any;
+    negRisk?: boolean | undefined;
+    outcomeExternalIdentifier?: string | undefined;
+};
+type ComputeSplitsSelection = {
+    venue: Venue;
+    venueMarketOutcomeId: string;
+};
+type SetupVenueKeyStep = {
+    type: "setup_venue_key";
+    venue: Venue;
+    stepPayload: {
+        instructions: string;
+        setupUrl?: string | undefined;
+    };
+};
+type DepositStep = {
+    type: "deposit";
+    venue: Venue;
+    currency: string;
+    stepPayload?: {
+        instructions: string;
+        setupUrl?: string | undefined;
+        depositUrl?: string | undefined;
+    } | undefined;
+    requiredAmountCents?: number | undefined;
+    requiredAmountUsd?: string | undefined;
+    transactionData?: {
+        value: string;
+        chainId: number;
+        to: string;
+        data: string;
+    } | undefined;
+};
+type SetupDepositAddressStep = {
+    type: "setup_deposit_address";
+    venue: Venue.polymarket;
+    stepPayload: {
+        setupUrl: string;
+        instructions: string;
+    };
+};
+type ValidateBalanceOnClientStep = {
+    type: "validate_balance_on_client";
+    venue: Venue.polymarket;
+    stepPayload: {
+        requiredAmountUsd: string;
+        instructions?: string | undefined;
+        currency?: string | undefined;
+    };
+};
+type TradeStep = {
+    type: "setup_venue_key";
+    venue: Venue;
+    stepPayload: {
+        instructions: string;
+        setupUrl?: string | undefined;
+    };
+} | {
+    type: "deposit";
+    venue: Venue;
+    currency: string;
+    stepPayload?: {
+        instructions: string;
+        setupUrl?: string | undefined;
+        depositUrl?: string | undefined;
+    } | undefined;
+    requiredAmountCents?: number | undefined;
+    requiredAmountUsd?: string | undefined;
+    transactionData?: {
+        value: string;
+        chainId: number;
+        to: string;
+        data: string;
+    } | undefined;
+} | {
+    type: "setup_deposit_address";
+    venue: Venue.polymarket;
+    stepPayload: {
+        setupUrl: string;
+        instructions: string;
+    };
+} | {
+    type: "validate_balance_on_client";
+    venue: Venue.polymarket;
+    stepPayload: {
+        requiredAmountUsd: string;
+        instructions?: string | undefined;
+        currency?: string | undefined;
+    };
+};
+type ValidateTradeRequest = {
+    splits: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+        side: TradeSide$1;
+        price: number;
+        size: number;
+        signedOrder?: any;
+        negRisk?: boolean | undefined;
+        outcomeExternalIdentifier?: string | undefined;
+    }[];
+};
+type ValidateTradeResponse = {
+    steps: ({
+        type: "setup_venue_key";
+        venue: Venue;
+        stepPayload: {
+            instructions: string;
+            setupUrl?: string | undefined;
+        };
+    } | {
+        type: "deposit";
+        venue: Venue;
+        currency: string;
+        stepPayload?: {
+            instructions: string;
+            setupUrl?: string | undefined;
+            depositUrl?: string | undefined;
+        } | undefined;
+        requiredAmountCents?: number | undefined;
+        requiredAmountUsd?: string | undefined;
+        transactionData?: {
+            value: string;
+            chainId: number;
+            to: string;
+            data: string;
+        } | undefined;
+    } | {
+        type: "setup_deposit_address";
+        venue: Venue.polymarket;
+        stepPayload: {
+            setupUrl: string;
+            instructions: string;
+        };
+    } | {
+        type: "validate_balance_on_client";
+        venue: Venue.polymarket;
+        stepPayload: {
+            requiredAmountUsd: string;
+            instructions?: string | undefined;
+            currency?: string | undefined;
+        };
+    })[];
+    canExecute: boolean;
+};
+type ExecuteTradeRequest = {
+    splits: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+        side: TradeSide$1;
+        price: number;
+        size: number;
+        signedOrder?: any;
+        negRisk?: boolean | undefined;
+        outcomeExternalIdentifier?: string | undefined;
+    }[];
+};
+type ExecuteTradeResponse = {
+    orders: {
+        venue: Venue;
+        orders: {
+            orderId: string;
+        }[];
+    }[];
+    errors?: {
+        message: string;
+        venue: Venue;
+    }[] | undefined;
+};
+type GetBalanceQuery = {
+    venue: Venue;
+};
+type GetBalanceResponse = {
+    venue: Venue;
+    currency: string;
+    balances: {
+        tradingBalanceCents?: number | undefined;
+        walletBalanceCents?: number | undefined;
+    };
+};
+type WalletChainBalance = {
+    chainId: number;
+    tokenAddress: string;
+    balanceRaw: string;
+    heldRaw?: string | undefined;
+    availableRaw?: string | undefined;
+    decimals: number;
+    lastSyncedAt: string;
+    tokenSymbol?: string | undefined;
+};
+type WalletTokenBalance = {
+    tokenSymbol: string;
+    totalRaw: string;
+    availableRaw?: string | undefined;
+    reservedRaw?: string | undefined;
+    decimals: number;
+    chains: {
+        chainId: number;
+        tokenAddress: string;
+        tokenSymbol?: string | undefined;
+        balanceRaw: string;
+        heldRaw?: string | undefined;
+        availableRaw?: string | undefined;
+        decimals: number;
+        lastSyncedAt: string;
+    }[];
+};
+type PriceSource = "orderbook" | "cached" | "entry" | "settled";
+/**
+ * Health of the orderbook a position was marked against — passthrough of
+ * the engine's `BookQuality` verdict. `priceSource` says where a mark came
+ * from; this says whether that source was trustworthy. Anything other than
+ * `healthy` is a low-confidence mark.
+ *
+ * Read `priceSource` first — this only qualifies book-derived marks. A
+ * `settled` position is exact (1/0) and consults no book, so it reports
+ * `empty`; that is not a confidence signal.
+ */
+type BookQuality = "healthy" | "wide_spread" | "bid_only" | "ask_only" | "endpoint_stub" | "crossed" | "empty";
+type VenuePositionBalance = {
+    venue: Venue;
+    balance: number;
+    costBasis: number;
+    unrealizedPnl: number;
+    realizedPnl: number;
+    priceSource: PriceSource;
+    bookQuality: BookQuality;
+};
+type UnifiedBalanceResponse = {
+    cash: {
+        tokenSymbol: string;
+        totalRaw: string;
+        availableRaw?: string | undefined;
+        reservedRaw?: string | undefined;
+        decimals: number;
+        chains: {
+            chainId: number;
+            tokenAddress: string;
+            tokenSymbol?: string | undefined;
+            balanceRaw: string;
+            heldRaw?: string | undefined;
+            availableRaw?: string | undefined;
+            decimals: number;
+            lastSyncedAt: string;
+            /** Chain wallet address; native venue collateral uses account IDs instead. */
+            address?: string | undefined;
+            custodyKind?: "EOA" | "DEPOSIT_WALLET" | "POLYMARKET_LEGACY" | "VENUE_ACCOUNT" | undefined;
+            /** Native cash is venue-scoped, not fungible EOA inventory. */
+            venue?: Venue | undefined;
+            venueAccountId?: string | undefined;
+            externalAccountId?: string | undefined;
+            isFresh?: boolean | undefined;
+            /**
+             * A `proxy` balance is spendable on Polymarket only, yet is still part
+             * of the parent token's `totalRaw`/`availableRaw`; subtract these rows
+             * for fungible-only spending power.
+             */
+            legacyKind?: "safe" | "proxy" | undefined;
+        }[];
+    }[];
+    positions: {
+        venue: Venue;
+        balance: number;
+        costBasis: number;
+        unrealizedPnl: number;
+        realizedPnl: number;
+    }[];
+    venueCash?: {
+        transferable?: boolean;
+        executionBackend?: ProphetxExecutionMode;
+        venue: Venue;
+        balanceCents: number;
+        accountModel?: "platform-hosted";
+        asset?: "USDC";
+        decimals?: 6;
+        balanceRaw?: string;
+        availableRaw?: string;
+        unmatchedExposureRaw?: string;
+        portfolioValueCents?: number | undefined;
+        updatedAt: string;
+    }[];
+    /**
+     * Paper-account summary. Present only when the request resolved to paper
+     * mode; absent in a live response. Mirrors `UnifiedBalanceResponseSchemaTB`
+     * in `typebox/schemas/trading.ts` — keep the two in sync. All dollars.
+     */
+    paper?: {
+        startingBalance: number;
+        cashBalance: number;
+        positionsValue: number;
+        /** Banked P&L from closed trades — account-level, not summable from positions. */
+        realizedPnl: number;
+        unrealizedPnl: number;
+        /** realized + unrealized. */
+        earnings: number;
+    };
+};
+type UserHolding = {
+    venue: Venue;
+    side: "long" | "short";
+    size: number;
+    marketId: string;
+    outcomeId: string;
+    outcomeLabel?: string | undefined;
+    conditionId?: string | undefined;
+    avgPrice?: number | undefined;
+    pnl?: number | undefined;
+};
+type GetHoldingsResponse = {
+    data: {
+        venue: Venue;
+        side: "long" | "short";
+        size: number;
+        marketId: string;
+        outcomeId: string;
+        outcomeLabel?: string | undefined;
+        conditionId?: string | undefined;
+        avgPrice?: number | undefined;
+        pnl?: number | undefined;
+    }[];
+    nextCursor: string | null;
+    hasMore: boolean;
+};
+type GetHoldingsQuery = {
+    venue: Venue;
+    venueMarketId?: string | undefined;
+    venueEventId?: string | undefined;
+    cursor?: string | undefined;
+};
+type GetOrdersQuery = {
+    status?: OrderStatus | undefined;
+    orderType?: "market" | "limit" | undefined;
+    orderId?: string | undefined;
+    /** Filter to all legs of one quote (multi-venue split routes). */
+    quoteId?: string | undefined;
+    /** Filter to the order(s) carrying this partner trade id. */
+    externalId?: string | undefined;
+    /** Filter to orders on any of these venue markets. */
+    venueMarketIds?: string[] | undefined;
+    cursor?: string | undefined;
+    limit?: number | undefined;
+};
+type GetPositionsQuery = {
+    cursor?: string | undefined;
+    limit?: number | undefined;
+    status?: "active" | "closed" | undefined;
+};
+type OrderListItem = {
+    status: string;
+    id: string;
+    /**
+     * Parent quote — lets the frontend correlate legs of a multi-venue
+     * split route without a second request. Nullable for sell-side /
+     * standalone orders without a Quote row.
+     */
+    quoteId: string | null;
+    /** Partner-supplied trade id from POST /execution/orders. */
+    externalId: string | null;
+    /** Partner-supplied order id from POST /execution/limit-orders. */
+    clientOrderId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    venue: Venue;
+    side: string;
+    amountRaw: string;
+    orderType?: "market" | "limit" | undefined;
+    limitPriceRaw: string | null;
+    limitSizeRaw?: string | null | undefined;
+    timeInForce: TimeInForce | null;
+    postOnly?: boolean | undefined;
+    expiresAt: Date | string | null;
+    reservedCostRaw?: string | null | undefined;
+    filledSizeRaw?: string | null | undefined;
+    filledCostRaw?: string | null | undefined;
+    remainingSizeRaw?: string | null | undefined;
+    averageFillPriceRaw?: string | null | undefined;
+    venueOrderId?: string | null | undefined;
+    cancelRequestedAt?: Date | string | null | undefined;
+    cancelledAt?: Date | string | null | undefined;
+    slippageBps: number | null;
+    quotedPriceRaw: string | null;
+    quotedCostRaw: string | null;
+    /**
+     * Quote-time shares + payout, 6-decimal atomic. Lets the UI render
+     * "Quoted X shares / $Y to win" without re-deriving from cost ÷
+     * price (precision drift on fractional fills; divide-by-zero before
+     * `executionPrice` exists).
+     */
+    quotedSharesRaw: string | null;
+    quotedToWinRaw: string | null;
+    filledAmountRaw: string | null;
+    executionPrice: string | null;
+    /**
+     * Actual shares + payout, populated by the venue's finalize handler.
+     * Pair with the quoted-side fields above to render the diff inline.
+     */
+    actualSharesRaw: string | null;
+    actualToWinRaw: string | null;
+    /**
+     * Set only on `partial_fill`. One of `"venue_capacity"`,
+     * `"price_slipped"`, `"user_cancelled"`, `"timeout"`, `"bridge_short"`,
+     * or a venue-specific tag.
+     */
+    partialFillReason: string | null;
+    /**
+     * Fee breakdown. Optional so paper-trading orders, which have no venue
+     * fees, no bridges and no app-fee charge, stay valid without fabricating
+     * a zeroed breakdown that would read as "this trade was free".
+     *
+     * `quoted` is what the route promised at accept time; `actual` is money
+     * that moved. `actual.appFee` and `actual.bridge` are TRADE-level and
+     * shared by every order under one `actual.dagRunId` — group by it before
+     * summing. `quoted.venueFeeRaw` and `actual.venueFeeRaw` are per-leg.
+     */
+    fees?: {
+        /**
+         * How the venue charges: `"fill"`, `"fill_in_game_only"`,
+         * `"winnings"`, `"exit"`, or null when the schedule cannot be
+         * expressed as a rate. Decides what the venue-fee figures mean.
+         */
+        venueFeeBasis: string | null;
+        quoted: {
+            /** 6-dec USD atoms. Null when the router emitted no fee for this leg. */
+            venueFeeRaw: string | null;
+            /** Worst-case partner fee if the route fills 100%. */
+            appFeeRaw: string | null;
+            appFeeBips: number | null;
+        };
+        actual: {
+            /** Null until the order reaches a DAG run. */
+            dagRunId: string | null;
+            /** Venue-reported fee, 6-dec USD atoms. Null = unknown, never free. */
+            venueFeeRaw: string | null;
+            appFee: {
+                bips: number;
+                /** floor(filled × bips / 10_000). */
+                dueRaw: string;
+                /** Below `dueRaw` on `under_collected`, "0" on skips. */
+                collectedRaw: string;
+                status: string;
+            } | null;
+            bridge: {
+                relayFeeUsd: string | null;
+                originGasCostUsd: string | null;
+                operationCount: number;
+                pricedOperationCount: number;
+            } | null;
+        };
+    } | undefined;
+    txHash: string | null;
+    errorMessage: string | null;
+    dagRunId: string | null;
+    venueMarket: {
+        id: string;
+        venueEventId?: string | undefined;
+        question: string;
+        image: string | null;
+    } | null;
+    venueMarketOutcome: {
+        label: string;
+        title: string | null;
+    } | null;
+};
+type PositionGroup = {
+    venueMarket: {
+        venueEventId: string;
+        question: string;
+        image: string | null;
+        status: MarketStatus;
+        venueMarketOutcomes: {
+            unrealizedPnl: number;
+            label: string;
+            title: string | null;
+            winner: boolean | null;
+            venueBreakdown: {
+                executionBackend?: ProphetxExecutionMode;
+                venue: Venue;
+                size: number;
+                venueMarketId: string;
+                venueMarketOutcomeId: string;
+                custodyKind?: "EOA" | "DEPOSIT_WALLET" | "VENUE_OMNIBUS" | "VENUE_ACCOUNT";
+                venueAccountId?: string;
+                externalAccountId?: string;
+            }[];
+            totalSize: number;
+            /** Weighted over legs with a known entry price — see `costBasisUnknown`. */
+            avgEntryPrice: number;
+            /**
+             * At least one leg was imported from an externally-acquired self-custody
+             * balance with no acquisition price we could reconcile. `totalValue`
+             * covers every leg; `avgEntryPrice` and `unrealizedPnl` cover only the
+             * legs with a known entry, and are 0 when none of them do.
+             */
+            costBasisUnknown?: boolean;
+            currentPrice: number;
+            totalValue: number;
+            unrealizedPnlPercent: number;
+            priceSource: PriceSource;
+            bookQuality: BookQuality;
+        }[];
+    };
+    targetMarketId: string;
+    eventId?: string | undefined;
+    redeemStatus: "eligible" | "pending" | "redeemed" | "ineligible";
+    status: "active" | "closed";
+    resolutionDate: string | null;
+};
+type VenueMarket = {
+    id: string;
+    venue: Venue;
+    question: string;
+    venueMarketOutcomes: {
+        id: string;
+        /** REMOVED — no longer returned; use GET /midpoints for live prices. */
+        price?: number | undefined;
+        venueMarketId: string;
+        label: string;
+        title?: string | null | undefined;
+        externalIdentifier?: string | null | undefined;
+        winner?: boolean | null | undefined;
+        /** Per-share USDC payout of this outcome in [0, 1] once settled; source of truth over `winner` when set. */
+        payoutPerShare?: number | null | undefined;
+        /** Counterpart outcomes on matched sibling markets — only populated
+         *  on the parent (queried) market's outcomes. Each entry is a
+         *  `{ venueMarketId, venueMarketOutcomeId }` ref into the same
+         *  response's `matchedVenueMarkets[].venueMarketOutcomes[]`. */
+        matchedVenueMarketOutcomes?: {
+            venueMarketId: string;
+            venueMarketOutcomeId: string;
+        }[];
+    }[];
+    externalIdentifier: string;
+    status?: MarketStatus | undefined;
+    createdAt?: string | null | undefined;
+    negRisk?: boolean | undefined;
+    marketId?: string | null | undefined;
+    conditionId?: string | null | undefined;
+    venueEventId?: string | null | undefined;
+    image?: string | null | undefined;
+    description?: string | null | undefined;
+    rulesPrimary?: string | null | undefined;
+    rulesSecondary?: string | null | undefined;
+    volume?: number | null | undefined;
+    startDate?: string | null | undefined;
+    endDate?: string | null | undefined;
+    creationDate?: string | null | undefined;
+    resolutionDate?: string | null | undefined;
+    /** Sports market classification for type-aware sorting (moneyline, spread, total, etc.). */
+    sportsMarketType?: string | null | undefined;
+    /** Sort rank within a sports section (0=moneyline, 1=spread, 2=total, 3+=other). */
+    sectionRank?: number | null | undefined;
+    /** Period identifier for sports markets (e.g., "1H", "2H", "Q1", etc.). */
+    period?: string | null | undefined;
+    /** Normalized subject category for prop-tab grouping (e.g., game_lines, exact_score, etc.). */
+    marketCategory?: string | null | undefined;
+    /** Section/tab grouping key for sports markets (e.g. "player_props", "totals"). */
+    marketGroup?: string | null | undefined;
+    /** Fine-grained sub-classification within a marketGroup (e.g. "moneyline", "rushing_yards"). */
+    marketSubtype?: string | null | undefined;
+    /** Line value for spread/total markets (e.g., 2.5 for totals, 3 for spreads). */
+    lineValue?: number | null | undefined;
+    /** Per-market minimum order size in shares/contracts, where AGG ingests one:
+     *  Polymarket (the market's own floor) and PRED (0.001); null elsewhere.
+     *  POST /execution/limit-orders validates `sizeRaw` against it on Polymarket.
+     *  `null` means no value was ingested — NOT that the market is unconstrained;
+     *  other venues enforce floors this field does not carry. */
+    minOrderSize?: number | null | undefined;
+    /** Price increment from venue metadata — a seed, not a guarantee. Prefer the
+     *  runtime-inferred `tick` from the orderbook endpoints when aligning a limit
+     *  price: the live grid can be finer than this. */
+    tickSize?: number | null | undefined;
+    matchedVenueMarkets?: {
+        id: string;
+        venue: Venue;
+        question: string;
+        externalIdentifier: string;
+        status?: MarketStatus | undefined;
+        conditionId?: string | null | undefined;
+        description?: string | null | undefined;
+        rulesPrimary?: string | null | undefined;
+        rulesSecondary?: string | null | undefined;
+        venueMarketOutcomes?: {
+            id: string;
+            /** REMOVED — no longer returned; use GET /midpoints for live prices. */
+            price?: number | undefined;
+            venueMarketId: string;
+            label: string;
+            winner?: boolean | null | undefined;
+            /** Per-share USDC payout of this outcome in [0, 1] once settled; source of truth over `winner` when set. */
+            payoutPerShare?: number | null | undefined;
+        }[] | undefined;
+        volume?: number | null | undefined;
+        venueEvent?: {
+            id: string;
+            externalIdentifier: string;
+            slug?: string | null | undefined;
+            series?: {
+                id: string;
+                venue: string;
+                externalIdentifier: string;
+                name?: string | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+    }[] | undefined;
+};
+type VenueEvent = {
+    id: string;
+    venue: Venue;
+    image: string | null;
+    title: string;
+    externalIdentifier: string;
+    categories: {
+        id: string;
+        category: {
+            id: string;
+            name: string;
+            displayName: string | null;
+            parentId: string | null;
+            eventCount: number;
+            volume24hr: number;
+            volume: number;
+        };
+    }[];
+    status?: MarketStatus | undefined;
+    updatedAt?: string | null | undefined;
+    description?: string | null | undefined;
+    volume?: number | null | undefined;
+    startDate?: string | null | undefined;
+    endDate?: string | null | undefined;
+    creationDate?: string | null | undefined;
+    /**
+     * Scheduled kickoff/start of the underlying game (sports events only).
+     * Distinct from `endDate` (market close/expiration), which can sit well
+     * after the game. The FE prefers this over `endDate` for the game-date
+     * title suffix. Null for non-sports events.
+     */
+    gameStartTime?: string | null | undefined;
+    slug?: string | null | undefined;
+    subtitle?: string | null | undefined;
+    venues?: Venue[];
+    venueCount?: number | undefined;
+    groupMarketCount?: number | undefined;
+    /**
+     * Same-venue companion grouping: the id of this event's group base. NULL means
+     * the event IS the base, or is standalone. A venue splits one game into several
+     * events (`… - More Markets`, `… : Spread`), and same-venue events never share
+     * a matched cluster — so on a companion, `matchedVenueEvents[]` lists the other
+     * venues' EQUIVALENT companions, not the game's cluster. Use this id (or the
+     * shared `aggKey`) to reach the base.
+     */
+    groupParentId?: string | null | undefined;
+    marketCount?: number | undefined;
+    /**
+     * ISO-8601 duration denormalized from Series.recurrence. `null` means
+     * the event has no recurring schedule (one-off). Use this value with
+     * the `?recurrence=` filter on /venue-events using public recurrence
+     * enum values.
+     */
+    recurrence?: string | null | undefined;
+    /** Deterministic game-level canonical key for cross-venue sports detail loading. */
+    aggKey?: string | null | undefined;
+    /** Type-aware structure classification used to sort markets under this event. */
+    structureType?: "candidate" | "sport" | "axis" | "dates" | null | undefined;
+    /** Canonical sport slug for sports events (e.g. "basketball", "soccer"); null for non-sports. */
+    sport?: string | null | undefined;
+    /** Structured per-venue settlement key-differences for this event's cluster. */
+    settlementDiff?: SettlementDiff | null | undefined;
+};
+type Orderbook = {
+    bids: {
+        price: number;
+        size: number;
+    }[];
+    asks: {
+        price: number;
+        size: number;
+    }[];
+    negRisk?: boolean | undefined;
+};
+type AttributedOrderbookLevel = {
+    price: number;
+    size: number;
+    venues: Record<string, number>;
+};
+type AttributedOrderbook = {
+    bids: {
+        price: number;
+        size: number;
+        venues: Record<string, number>;
+    }[];
+    asks: {
+        price: number;
+        size: number;
+        venues: Record<string, number>;
+    }[];
+};
+type PricePoint = {
+    price: number;
+    timestamp: number;
+    open?: number | undefined;
+    high?: number | undefined;
+    low?: number | undefined;
+    close?: number | undefined;
+};
+type MarketPriceHistory = {
+    venue: Venue;
+    marketId: string;
+    marketTicker: string;
+    points: {
+        price: number;
+        timestamp: number;
+        open?: number | undefined;
+        high?: number | undefined;
+        low?: number | undefined;
+        close?: number | undefined;
+    }[];
+};
+type PricesHistoryResponse = {
+    data: {
+        venue: Venue;
+        marketId: string;
+        marketTicker: string;
+        points: {
+            price: number;
+            timestamp: number;
+            open?: number | undefined;
+            high?: number | undefined;
+            low?: number | undefined;
+            close?: number | undefined;
+        }[];
+    }[];
+};
+type OrderbookHistoryPoint = {
+    volume: number | null;
+    timestamp: number;
+    midpoint: number;
+    bestBid: number | null;
+    bestAsk: number | null;
+    spread: number | null;
+    open?: number | undefined;
+    high?: number | undefined;
+    low?: number | undefined;
+    close?: number | undefined;
+};
+type OrderbookHistoryResponse = {
+    venueMarketOutcomeId: string;
+    points: {
+        volume: number | null;
+        timestamp: number;
+        midpoint: number;
+        bestBid: number | null;
+        bestAsk: number | null;
+        spread: number | null;
+        open?: number | undefined;
+        high?: number | undefined;
+        low?: number | undefined;
+        close?: number | undefined;
+    }[];
+};
+/** Reference to a counterpart outcome on a matched sibling market.
+ *  Resolves into the same response's `matchedVenueMarkets[].venueMarketOutcomes[]`
+ *  by id. Sourced from `MatchedVenueMarketOutcome` so the alignment is
+ *  robust to inversely-framed binary markets and multi-outcome markets. */
+type MatchedVenueMarketOutcomeRef = {
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+};
+type VenueMarketOutcome = {
+    id: string;
+    /**
+     * REMOVED — /venue-events and /venue-markets no longer return outcome
+     * prices. Fetch live prices from GET /midpoints (or the live-price hooks),
+     * keyed by this outcome's `id`.
+     */
+    price?: number | undefined;
+    venueMarketId: string;
+    label: string;
+    title?: string | null | undefined;
+    externalIdentifier?: string | null | undefined;
+    winner?: boolean | null | undefined;
+    /** Per-share USDC payout of this outcome in [0, 1] once settled; source of truth over `winner` when set. */
+    payoutPerShare?: number | null | undefined;
+    /** Counterpart outcomes on matched sibling markets — only populated on
+     *  the parent (queried) market's outcomes. */
+    matchedVenueMarketOutcomes?: MatchedVenueMarketOutcomeRef[];
+};
+type VenueEventWithMarkets = VenueEvent & {
+    venueMarkets: VenueMarket[];
+};
+type VenueMarketListItem = Omit<VenueMarket, "matchedVenueMarkets">;
+type VenueEventListItem = VenueEvent & {
+    venueMarkets: VenueMarketListItem[];
+    marketCount: number;
+};
+/** Per-outcome midpoint inside a matched-sibling entry. Aligned via MVMO
+ *  so the `venueMarketOutcomeId` resolves the same outcome the parent's
+ *  `matchedVenueMarketOutcomes` ref points to. */
+type MatchedMidpointOutcome = {
+    venueMarketOutcomeId: string;
+    midpoint: number | null;
+    bestBid?: number | null;
+    bestAsk?: number | null;
+};
+type MatchedMidpoint = {
+    venueMarketId: string;
+    venue: string;
+    /** Sibling's market-level midpoint. Kept for backwards compat — the
+     *  authoritative cross-venue alignment lives in `outcomes`. */
+    midpoint: number | null;
+    /** Per-outcome midpoints keyed by sibling outcome id. Optional during
+     *  rollout — older engine builds may omit it. */
+    outcomes?: MatchedMidpointOutcome[];
+};
+type OutcomeMidpoint = {
+    venueMarketOutcomeId: string;
+    label: string;
+    midpoint: number | null;
+    bestBid?: number | null;
+    bestAsk?: number | null;
+};
+type MidpointItem = {
+    venueMarketId: string;
+    venue: string;
+    midpoint: number | null;
+    spread: number | null;
+    timestamp: number | null;
+    outcomes: OutcomeMidpoint[];
+    matched: MatchedMidpoint[];
+    arbReturn?: number | null | undefined;
+};
+type ComputeSplitsRequest = {
+    side: TradeSide$1;
+    selections: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+    }[];
+    maxDollarAmount: number;
+};
+type ComputeSplitsResponse = {
+    splits: {
+        venue: Venue;
+        venueMarketOutcomeId: string;
+        side: TradeSide$1;
+        price: number;
+        size: number;
+        signedOrder?: any;
+        negRisk?: boolean | undefined;
+        outcomeExternalIdentifier?: string | undefined;
+    }[];
+    totalSize: number;
+    totalCost: number;
+};
+type Category = {
+    id: string;
+    name: string;
+    displayName: string | null;
+    parentId: string | null;
+    eventCount: number;
+    volume24hr: number;
+    volume: number;
+};
+type SettlementSource = {
+    name: string;
+    url?: string | null | undefined;
+};
+type SettlementDifference = {
+    type: string;
+    title: string;
+    perVenue: Record<string, string>;
+    summary?: string | undefined;
+};
+type SettlementDiff = {
+    sharedSummary: string;
+    differences: SettlementDifference[];
+};
+type ExecuteManagedRequest = {
+    quoteId: string;
+};
+type ValidateManagedRequest = {
+    venueMarketOutcomeIds: string[];
+    side: "buy" | "sell";
+    amount: number;
+};
+type WithdrawTokenSymbol$1 = "USDC" | "USDC.e" | "USDT";
+type WithdrawalSourceTokenSymbol$1 = WithdrawTokenSymbol$1 | "pUSD" | "USD1";
+type WithdrawManagedRequest = {
+    /** Positive integer string in the token's native decimals (e.g. "100000" = 0.1 USDC). */
+    amountRaw: string;
+    tokenSymbol: WithdrawTokenSymbol$1;
+    /** EVM 0x-prefixed 20-byte recipient address. */
+    destinationAddress: string;
+    /** EVM chain ID where the recipient should receive funds. Required since v2026.04. */
+    destinationChainId: number;
+};
+type WithdrawalSourceStatus$1 = "pending" | "submitted" | "confirmed" | "failed";
+type WithdrawalSourceItem = {
+    sourceId: string;
+    chainId: number;
+    tokenSymbol: WithdrawalSourceTokenSymbol$1;
+    /** On-chain token address on `chainId`. */
+    tokenAddress: string;
+    /**
+     * On-chain decimals for `(chainId, tokenAddress)`. Critical for clients
+     * because `amountRaw` is in source-native decimals (BNB USDC is 18-dec,
+     * EVM USDC is 6-dec).
+     */
+    decimals: number;
+    amountRaw: string;
+    custodyKind?: "DEPOSIT_WALLET" | "VENUE_ACCOUNT";
+    venue?: string;
+    sourceVenueAccountId?: string;
+    sourceExternalAccountId?: string;
+    status: WithdrawalSourceStatus$1;
+    txHash: string | null;
+    bridgeOperationId: string | null;
+};
+/** @deprecated Use `WithdrawalSourceItem` from the lifecycle response. */
+type WithdrawalSource = {
+    amountRaw: string;
+    chainId: number;
+    txHash?: string | undefined;
+    bridgeOperationId?: string | undefined;
+};
+type SyncBalancesResponse = {
+    synced: true;
+};
+
+/** App-level paper/live mode. An app is one or the other, never both. */
+type AppTradingMode = "live" | "paper";
+interface AppClientConfigResponse {
+    prophetxExecutionMode?: "clearinghouse" | "direct";
+    disabledVenues: Venue[];
+    disabledCategoryPresets: string[];
+    earlyAccessEnabled: boolean;
+    authOptions: AppClientAuthOption[];
+    /**
+     * Server-owned execution mode. Prefer this over any locally-configured
+     * `trading.executionMode` — the API enforces it regardless of what the
+     * client sends, and end users cannot change it.
+     */
+    tradingMode: AppTradingMode;
+    /**
+     * One-time simulated balance granted on first paper use, in dollars.
+     * Interpolate this into paper copy rather than hardcoding a figure.
+     */
+    paperStartingBalance: number;
+}
+interface VenueGeoPolicyEntry {
+    venue: Venue;
+    /** ISO 3166-1 alpha-2, upper-case. Empty means no country restriction. */
+    blockedCountries: string[];
+    /**
+     * ISO 3166-1 alpha-2, upper-case. When present, this venue is ALLOWLIST
+     * mode: ONLY these countries are permitted (`blockedCountries` is always
+     * `[]` alongside this and must be ignored). Absent/undefined ⇒ ordinary
+     * denylist mode, use `blockedCountries` as before. Only Novig uses this
+     * today — a client that reads only `blockedCountries` sees an allowlisted
+     * venue as unrestricted, which is exactly the misread this field closes.
+     */
+    allowedCountries?: string[];
+}
+interface VenueGeoPolicyResponse {
+    venues: VenueGeoPolicyEntry[];
+}
+interface RpcTokenResponse {
+    token: string;
+    expiresAt: number;
+}
+type AggAuthProviderType = "siwe" | "siws" | "google" | "twitter" | "apple" | "email";
+interface AppClientAuthOption {
+    provider: AggAuthProviderType;
+    type: "oauth" | "email" | "wallet";
+    enabled: boolean;
+    callbackUrl?: string;
+    statement?: string;
+}
+type AggAuthDeliveryMode = "body" | "cookie-refresh";
+interface AggClientAuthOptions {
+    getEarlyAccessCode?: () => string | null;
+}
+type AggAuthStartBody = {
+    provider: Exclude<AggAuthProviderType, "email">;
+    redirectUrl?: string;
+    /** Cloudflare Turnstile token — required when a prior authStart returned `challenge_required`. */
+    turnstileToken?: string;
+    earlyAccessCode?: string;
+} | {
+    provider: "email";
+    email: string;
+    redirectUrl?: string;
+    /** Cloudflare Turnstile token — required when a prior authStart returned `challenge_required`. */
+    turnstileToken?: string;
+    earlyAccessCode?: string;
+};
+/** SIWE / SIWS sign-in. `kind` is optional so callers that predate the discriminator still compile. */
+interface AggAuthWalletVerifyBody {
+    kind?: "wallet";
+    message: string;
+    signature: string;
+    earlyAccessCode?: string;
+}
+/** Privy sign-in. Requires the app's wallet provider to be Privy; the token must come from that Privy app. */
+interface AggAuthPrivyVerifyBody {
+    kind: "privy";
+    privyToken: string;
+    earlyAccessCode?: string;
+}
+/** Body for `POST /auth/verify` — mirrors the API's union on `kind`. */
+type AggAuthVerifyBody = AggAuthWalletVerifyBody | AggAuthPrivyVerifyBody;
+type AggAuthStartResult = {
+    type: "nonce";
+    nonce: string;
+    statement?: string;
+} | {
+    type: "redirect";
+    url: string;
+} | {
+    type: "magic_link";
+    success: true;
+} | {
+    type: "challenge_required";
+    siteKey: string;
+};
+/**
+ * Body for `POST /users/me/link-account/start` — authenticated account linking.
+ *
+ * `redirectUrl` is required for OAuth/email providers: the callback / magic-link
+ * verify hands the partner a `link_confirm_token` by redirecting to `redirectUrl`,
+ * and the partner app completes the flow by calling `/confirm` from that page.
+ *
+ * Wallet providers (`siwe`/`siws`) instead return a `wallet_challenge` with a
+ * `message` the user signs VERBATIM; the signature is then confirmed with
+ * `{ kind: "wallet_signature", message, signature }`.
+ */
+type AggLinkAccountBody = {
+    provider: "google" | "twitter" | "apple";
+    redirectUrl: string;
+} | {
+    provider: "email";
+    email: string;
+    redirectUrl: string;
+} | {
+    provider: "siwe" | "siws";
+    address: string;
+};
+type AggLinkAccountResult = {
+    type: "redirect";
+    url: string;
+} | {
+    type: "magic_link";
+    success: true;
+} | {
+    type: "wallet_challenge";
+    message: string;
+};
+/**
+ * Wallet branch of `POST /users/me/link-account/confirm`. Requires `kind` so it
+ * can never be confused with the `token` branch. `message` MUST be the exact
+ * `message` returned by `/start`'s `wallet_challenge` — the server compares it
+ * byte-for-byte, so do not reconstruct or edit it client-side.
+ */
+type AggLinkAccountWalletConfirmBody = {
+    kind: "wallet_signature";
+    message: string;
+    signature: string;
+};
+/**
+ * Success result of /users/me/link-account/confirm.
+ * - `linked` — new Account row written.
+ * - `already_linked_same` — identity was already attached to the caller's Principal
+ *   (idempotent; safe to retry).
+ *
+ * Collisions with a different Principal surface as HTTP 409 and are thrown by the
+ * SDK's request layer — catch them at the call site, don't expect them here.
+ */
+type AggLinkAccountConfirmResult = {
+    status: "linked" | "already_linked_same";
+    provider: string;
+};
+type AggSessionUser = AuthUser | UserProfile;
+interface AggClientSessionInput {
+    accessToken: string;
+    refreshToken?: string;
+    user?: AggSessionUser;
+}
+/** Non-sensitive auth snapshot persisted to localStorage for UI bootstrapping.
+ *  Tokens are NEVER included — they exist only in process memory. */
+interface PersistedAuthSnapshot {
+    user: {
+        id: string;
+        username: string | null;
+        avatarUrl: string | null;
+        walletAddress?: string | null;
+    } | null;
+    authHint: {
+        wasAuthenticated: boolean;
+    };
+}
+/** Auth lifecycle status for UI state machines. */
+type AuthStatus = "unknown" | "authenticated" | "unauthenticated";
+type SignatureRequestType = "eip712" | "personal_sign"
+/** EVM transaction — bridge legs and approvals. secp256k1. */
+ | "transaction"
+/** Solana transaction — bridge legs on SVM. ed25519, NOT secp256k1. */
+ | "solana_transaction" | "hl_l1_action"
+/**
+ * EIP-7702 authorization over `{ contractAddress, chainId, nonce }`.
+ *
+ * A signature over a RAW digest — `keccak(0x05 ‖ rlp([chainId, delegate,
+ * nonce]))` — not EIP-191 and not EIP-712. Many wallets do not expose this,
+ * and that is expected: reject it and the server falls back to asking the
+ * user to broadcast a plain approve instead.
+ */
+ | "eip7702_authorization"
+/**
+ * A Gnosis Safe transaction relayed through Polymarket — a legacy Polymarket
+ * wallet funding a fill. The payload is the SafeTx as EIP-712 typed data,
+ * but the wallet must `personal_sign` the RAW 32 bytes of
+ * `hashTypedData(payload)` (`signMessage({ message: { raw: hash } })`):
+ * Polymarket's relayer only accepts that shape. `payload.safeTxHash` carries
+ * the digest for convenience; the server recomputes it from the typed data.
+ */
+ | "safe_tx";
+/** One payload the client must sign before a fill can proceed. */
+interface SignatureRequest {
+    /** Echo this back with the signature. */
+    stepId: string;
+    /** Payload shape. Discriminates how to sign — not which venue. */
+    type: SignatureRequestType;
+    venue: string;
+    /** The address that must produce this signature. Sign with this key, not another. */
+    signerAddress: string;
+    /** Absent for non-EVM payloads (e.g. Hyperliquid L1 actions). */
+    chainId?: number;
+    /** Sign verbatim. */
+    payload: unknown;
+    expiresAt: string;
+    /** Why this signature is being asked for, when the server knows (e.g. `"fee"`, `"funding_and_fee"`). Display only. */
+    purpose?: string;
+}
+/**
+ * Supplied by the partner. Receives a payload, returns a signature. The SDK
+ * never sees the key.
+ *
+ * Return a 0x-prefixed hex string for anything the wallet SIGNS:
+ *
+ * - `eip712` — `signTypedData` over `payload`.
+ * - `personal_sign` — `personal_sign` over `payload`.
+ * - `safe_tx` — `personal_sign` over the RAW 32 bytes of
+ *   `hashTypedData(payload)` (viem: `signMessage({ message: { raw: hash } })`,
+ *   MetaMask: `personal_sign` with the hex hash). The wallet shows a hash, not
+ *   a structured prompt — that is what Polymarket's own relayer requires.
+ * - `hl_l1_action` — Hyperliquid L1 action, EIP-712 in phantom-agent form.
+ * - `eip7702_authorization` — an EIP-7702 authorization over
+ *   `{ contractAddress, chainId, nonce }`. This is a signature over a RAW
+ *   digest, not EIP-191 and not EIP-712, and many wallets do not expose it.
+ *   **Throwing here does not help**: there is no reject verb, so a thrown
+ *   signer is indistinguishable from a slow user — the request simply expires
+ *   and the fill dies. If your wallet cannot produce this signature, declare
+ *   `approveMode: "user_broadcast"` on the fill instead and the approve is
+ *   requested as a `transaction` the user sends themselves. Handling this
+ *   request is what makes funding gasless.
+ *
+ * Return `{ txHash }` for anything the wallet BROADCASTS:
+ *
+ * - `transaction` — send it, then return the hash **immediately, without
+ *   awaiting the receipt**. The server watches for the mined receipt itself
+ *   and will not resume until it matches the request byte-for-byte.
+ */
+type SignerFn = (req: SignatureRequest) => Promise<string | {
+    txHash: string;
+}>;
+/**
+ * How long `fillSelfCustody` will keep waiting before giving up.
+ *
+ * Covers a first-time user: sign the wallet-setup batch, wait for it on-chain,
+ * then sign the order. Generous because the wait is a relayer transaction
+ * confirming, not a human deciding.
+ */
+declare const SELF_CUSTODY_FILL_TIMEOUT_MS: number;
+/** Gap between re-reads while an on-chain step is in flight. */
+declare const SELF_CUSTODY_POLL_INTERVAL_MS = 2000;
+/**
+ * States a run never leaves. Everything else means "still working".
+ *
+ * Typed against `ExecutionOverallState` so a typo'd or renamed literal (e.g.
+ * `cancelled` drifting to `canceled`) is a compile error instead of a state
+ * that silently stops being treated as terminal. Mirrors
+ * `ExecutionOverallStateTB` in the contract; keep the two in step.
+ */
+declare const TERMINAL_EXECUTION_STATES: ReadonlySet<ExecutionOverallState>;
+type SportsGameStatus = "scheduled" | "live" | "paused" | "finished" | "cancelled" | "postponed" | "unknown";
+interface SportsLiveParticipant {
+    position: "first" | "second";
+    name: string;
+    shortName: string | null;
+    imageUrl: string | null;
+    score: string | null;
+}
+interface SportsLiveState {
+    eventId: string;
+    sport: string;
+    status: SportsGameStatus;
+    participants: [SportsLiveParticipant, SportsLiveParticipant];
+    period: string | null;
+    clock: string | null;
+    updatedAt: string | null;
+}
+interface SportsLiveResponse {
+    data: SportsLiveState[];
+    missingEventIds: string[];
+}
+interface AggClientOptions {
+    /** Browser adapters can inject a Worker transport; other runtimes keep the native client. */
+    webSocketFactory?: (options: AggWebSocketOptions) => AggWebSocket;
+    baseUrl: string;
+    /** Public App ID — sent as x-app-id header. For client-side partner usage. */
+    appId?: string;
+    /** Secret admin key — sent as x-admin-key header. Server-side only. */
+    adminKey?: string;
+    /**
+     * Partner API key for server-side use. Sent as `x-app-api-key`. NEVER embed
+     * in browser bundles, source maps, or logs. Keys start with `agg_<appId>_`.
+     */
+    apiKey?: string;
+    /** WebSocket URL for real-time feeds. Must be set explicitly to use createWebSocket(). */
+    wsUrl?: string;
+    /** Opt in after immutable history publication/CDN rollout. Defaults false. */
+    preferImmutableHistory?: boolean;
+    /**
+     * @deprecated Kalshi live discovery and trading are retired. This ignored
+     * compatibility option remains to avoid breaking existing SDK consumers.
+     */
+    kalshiDemo?: boolean;
+    /** Optional auth request hooks used to enrich auth payloads. */
+    auth?: AggClientAuthOptions;
+    /** Move refresh delivery to an HttpOnly cookie on auth endpoints. Defaults to "body". */
+    authDelivery?: AggAuthDeliveryMode;
+    /** Persist a non-sensitive auth hint to localStorage for UI bootstrapping.
+     *  Tokens are NEVER persisted — they exist only in process memory.
+     *  When authDelivery is "body", refresh tokens are lost on page reload.
+     *  When authDelivery is "cookie-refresh", refresh tokens survive via HttpOnly cookies
+     *  and the SDK attempts a silent refresh on cold start. Defaults to true. */
+    persistSession?: boolean;
+    /**
+     * Supplies signatures for self-custodial fills. Required whenever
+     * `fillSelfCustody()` is called with `signingAddress` — the SDK never
+     * holds a key itself, so without this option a fill that needs a
+     * client-side signature cannot proceed. The signature requests never
+     * come back on `POST /execution/fill` itself: `fillSelfCustody()` polls
+     * `GET /execution/status` for them (`pendingSignatures`), signs each one
+     * with this function, and posts the result to
+     * `POST /execution/fill/:quoteId/signatures`.
+     */
+    signer?: SignerFn;
+}
+interface SiweMessageParams {
+    domain: string;
+    address: string;
+    uri: string;
+    nonce: string;
+    chainId?: number;
+    statement?: string;
+    issuedAt?: string;
+}
+interface SiwsMessageParams {
+    domain: string;
+    /** Base58-encoded Solana public key. */
+    address: string;
+    uri: string;
+    nonce: string;
+    /** Solana chain ID: "mainnet", "devnet", "testnet", or "localnet". Defaults to "mainnet". */
+    chainId?: string;
+    statement?: string;
+    issuedAt?: string;
+}
+/** OHLCV bar point for chart rendering. */
+interface ChartCandle {
+    /** Venue average; distinct from OHLC close. */
+    mean?: number;
+    /** Open time in Unix milliseconds. */
+    t: number;
+    /** Open price (0-1). */
+    o: number;
+    /** High price (0-1). */
+    h: number;
+    /** Low price (0-1). */
+    l: number;
+    /** Close price (0-1). */
+    c: number;
+    /** Volume (null if unavailable). */
+    v: number | null;
+}
+/** @deprecated Historical chart bars are canonical per outcome. Use ChartBarsResponse instead. */
+interface ChartVenueCandles {
+    venue: string;
+    candles: ChartCandle[];
+}
+type ChartResolution = "1m" | "5m" | "1h" | "1d";
+/**
+ * Freshness signal embedded in every chart response. Compare
+ * `staleSeconds` against the resolution to decide whether to show a
+ * "delayed" badge on the chart.
+ */
+interface ChartBarsMeta {
+    state?: "ready" | "warming" | "unsupported" | "failed" | "empty";
+    complete?: boolean;
+    retryAfterMs?: number;
+    /** Agg fetch/publication time. Does not measure upstream delivery latency. */
+    fetchedAtMs?: number;
+    /** Server-side wall clock when the response was assembled, in milliseconds. */
+    serverTime: number;
+    /** `open_time` of the most-recent bar in `data`, in milliseconds. Null if `data` is empty. */
+    lastBarOpenTime: number | null;
+    /** `serverTime - lastBarOpenTime` in seconds. Null if `data` is empty. */
+    staleSeconds: number | null;
+}
+/** Response from GET /charts/bars. */
+interface ChartBarsResponse {
+    /** VenueMarketOutcome.id requested by the caller. */
+    venueMarketOutcomeId: string;
+    /** Venue of the canonical historical series. */
+    venue: string;
+    /** Resolution returned by the backend. */
+    resolution: ChartResolution;
+    /** Bars sorted in ascending open time. */
+    data: ChartCandle[];
+    /** Freshness signal — see {@link ChartBarsMeta}. */
+    meta: ChartBarsMeta;
+}
+interface ChartHistoryManifest {
+    version: 1;
+    revision: string | null;
+    venueMarketOutcomeId: string;
+    venue: string;
+    resolution: ChartResolution;
+    semantics: "venue-ohlcv-v1" | "polymarket-price-samples-v1" | "kalshi-ohlcv-quote-fallback-v2";
+    from: number;
+    to: number;
+    finalizedThrough: number;
+    chunks: Array<{
+        key: string;
+        url: string;
+        sha256: string;
+        from: number;
+        to: number;
+        points: number;
+    }>;
+    meta: ChartBarsMeta;
+}
+/** Matched market reference returned by batch/aggregate endpoints. */
+interface VenueMarketRef {
+    venue: string;
+    venueMarketId: string;
+}
+type OrderbookBatchItemStatus = "ok" | "market_not_found" | "market_resolved" | "market_closed" | "market_paused" | "market_unopened" | "book_not_loaded";
+type OrderbookBatchItemErrorCode = "market_not_found" | "market_resolved" | "market_closed" | "market_paused" | "market_unopened" | "book_not_loaded";
+interface OrderbookBatchItemError {
+    code: OrderbookBatchItemErrorCode;
+    message: string;
+    retryable: boolean;
+}
+interface OrderbooksOnlyError {
+    code: "use_orderbooks_endpoint";
+    message: string;
+    retryable: boolean;
+}
+interface OrderbookServiceUnavailableError {
+    code: "orderbook_service_unavailable";
+    message: string;
+    retryable: boolean;
+}
+interface RequestedOrderbookMarket {
+    venueMarketId: string;
+    venue: string;
+    marketStatus: "open" | "closed" | "resolved" | "unopened" | "paused";
+    tickSize: number | null;
+    endDate: string | null;
+    resolutionDate: string | null;
+}
+interface MatchedOrderbookMarket extends VenueMarketRef {
+    marketStatus: "open" | "closed" | "resolved" | "unopened" | "paused";
+    tickSize: number | null;
+    hasOrderbook: boolean;
+    /**
+     * Hyperliquid HIP-4 deployer namespace this member belongs to (e.g. "ap").
+     * `null` for every other venue and for Hyperliquid members without one.
+     * Names which deployer this cluster member is — distinct from whether its
+     * book was published (see `hasOrderbook`).
+     */
+    deployerVenue?: string | null;
+}
+/**
+ * Provenance of a published `midpoint`. Mirrors the engine's `MarkSource`.
+ *
+ *  - `local`            — true two-sided midpoint from the venue's own book
+ *  - `local_merged`     — midpoint from the cross-venue merged book
+ *  - `local_one_sided`  — only one side present; mark is the live side, NOT a midpoint
+ *  - `sibling`          — derived from the complementary outcome (e.g. NO from YES)
+ *  - `local_boundary`   — clamped to the [tick, 1-tick] boundary
+ *  - `none`             — no mark available
+ */
+type MarkSource = "local" | "local_merged" | "local_one_sided" | "sibling" | "local_boundary" | "none";
+declare const RECURRENCE_CADENCES: readonly ["PT5M", "PT10M", "PT15M", "PT30M", "PT1H", "PT4H", "P1D", "P1W", "P1M", "P1Y"];
+type RecurrenceCadence = (typeof RECURRENCE_CADENCES)[number];
+type RecurrenceFilter = RecurrenceCadence | "null";
+type RecurringCryptoDuration = "PT5M" | "PT15M" | "PT30M" | "PT1H" | "PT4H" | "P1D";
+type RecurringCryptoDurationInput = RecurringCryptoDuration | "5m" | "15m" | "30m" | "1h" | "4h" | "1d";
+type RecurringCryptoSourceConfidence = "verified" | "inferred" | "missing";
+interface ListRecurringCryptoMarketsOptions {
+    assets?: string[];
+    durations?: RecurringCryptoDurationInput[];
+    interval?: RecurringCryptoDurationInput;
+    window?: "current";
+    venues?: Venue[];
+    status?: MarketStatus[];
+    windowStartFrom?: string;
+    windowStartTo?: string;
+    cursor?: string;
+    limit?: number;
+    includeOrderbookPrices?: boolean;
+    includeReferencePrices?: boolean;
+    includeDirectVenueMarkets?: boolean;
+    includeOrderbookDepth?: boolean;
+    orderbookDepth?: number;
+    orderbookDepthAmountUsd?: number;
+}
+interface RecurringCryptoOrderbookDepthLevel {
+    price: number;
+    size: number;
+    notionalUsd: number;
+    cumulativeSize: number;
+    cumulativeNotionalUsd: number;
+    fillSize: number | null;
+    fillNotionalUsd: number | null;
+}
+interface RecurringCryptoOrderbookDepthSide {
+    levels: RecurringCryptoOrderbookDepthLevel[];
+    totalSize: number;
+    totalNotionalUsd: number;
+    requestedNotionalUsd: number | null;
+    filledSize: number | null;
+    filledNotionalUsd: number | null;
+    unfilledNotionalUsd: number | null;
+    avgPrice: number | null;
+    worstPrice: number | null;
+    fillsComplete: boolean | null;
+}
+interface RecurringCryptoOutcomeOrderbookDepth {
+    currency: "USD";
+    amountUsd: number | null;
+    buy: RecurringCryptoOrderbookDepthSide;
+    sell: RecurringCryptoOrderbookDepthSide;
+}
+interface RecurringCryptoOutcome {
+    /**
+     * Canonical Agg outcome id. Null for direct live venue rows because those
+     * rows are discovery data and cannot be passed to smart order routing.
+     */
+    venueMarketOutcomeId: string | null;
+    /** Venue-native outcome id or synthetic external id for direct live rows. */
+    externalOutcomeId: string | null;
+    /** False for this endpoint; live crypto markets are not smart-route inputs. */
+    routeable: boolean;
+    /** False for this endpoint; split-order routing is not supported here. */
+    splitOrdersAllowed: boolean;
+    label: string;
+    title: string | null;
+    midpoint: number | null;
+    bestBid: number | null;
+    bestAsk: number | null;
+    markSource: MarkSource | string | null;
+    lastKnownPrice: number | null;
+    orderbookDepth: RecurringCryptoOutcomeOrderbookDepth | null;
+}
+interface RecurringCryptoMarketMetrics {
+    volume: number | null;
+    volume24h: number | null;
+    openInterest: number | null;
+    liquidity: number | null;
+    spread: number | null;
+}
+interface RecurringCryptoResolution {
+    sourceName: string | null;
+    sourceUrl: string | null;
+    sourceDomain: string | null;
+    rawCriteria: unknown;
+    confidence: RecurringCryptoSourceConfidence;
+}
+interface RecurringCryptoReferencePrice {
+    asset: string;
+    quoteAsset: "USD";
+    raw: string | null;
+    decimals: number | null;
+    normalized: number | null;
+    timestamp: string | null;
+    provider: string | null;
+    providerMarketId: string | null;
+    confidence: RecurringCryptoSourceConfidence;
+    fetchedAt?: string | null;
+    ageMs?: number | null;
+    refreshing?: boolean;
+    stale?: boolean;
+}
+type CryptoReferencePriceTarget = {
+    type: "venueMarket";
+    venueMarketId: string;
+} | {
+    type: "venueEvent";
+    venueEventId: string;
+} | {
+    type: "externalVenueMarket";
+    venue: Venue;
+    externalMarketId: string;
+} | {
+    type: "market";
+    venue: Venue;
+    venueEventId?: string;
+    venueMarketId: string;
+    externalEventId?: string | null;
+    externalMarketId?: string;
+    asset: string;
+    quoteAsset?: "USD";
+    resolution: RecurringCryptoResolution;
+};
+interface CryptoReferencePriceExternalMarketInput {
+    venue: Venue;
+    externalMarketId: string;
+}
+interface CryptoReferencePriceMarketInput extends RecurringCryptoVenueMarket {
+    asset: string;
+    quoteAsset?: "USD";
+}
+interface GetCryptoReferencePricesOptions {
+    targets?: CryptoReferencePriceTarget[];
+    venueMarketIds?: string[];
+    venueEventIds?: string[];
+    externalMarkets?: CryptoReferencePriceExternalMarketInput[];
+    markets?: CryptoReferencePriceMarketInput[];
+    windowMarkets?: RecurringCryptoWindowMarket[];
+    signal?: AbortSignal;
+}
+interface CryptoReferencePriceError {
+    code: "not_found" | "not_recurring_crypto" | "reference_feed_missing" | "price_unavailable" | "stale_price";
+    message: string;
+}
+interface CryptoReferencePriceSource {
+    provider: string | null;
+    providerMarketId: string | null;
+    confidence: RecurringCryptoSourceConfidence;
+}
+interface CryptoReferencePriceResult {
+    target: CryptoReferencePriceTarget;
+    venue: Venue | null;
+    venueEventId: string | null;
+    venueMarketId: string | null;
+    externalEventId: string | null;
+    externalMarketId: string | null;
+    asset: string | null;
+    quoteAsset: "USD" | null;
+    raw: string | null;
+    decimals: number | null;
+    normalized: number | null;
+    providerTimestamp: string | null;
+    fetchedAt: string | null;
+    ageMs: number | null;
+    refreshing: boolean;
+    stale: boolean;
+    source: CryptoReferencePriceSource;
+    error: CryptoReferencePriceError | null;
+}
+interface CryptoReferencePricesResponse {
+    data: CryptoReferencePriceResult[];
+    softRefreshMs: number;
+    hardMaxAgeMs: number;
+}
+type RecurringCryptoComparisonPriceSource = "referencePrice" | "midpoint" | "lastKnownPrice";
+interface RecurringCryptoComparisonPoint {
+    venue: Venue;
+    venueMarketId: string;
+    value: number;
+    label: string | null;
+    source: RecurringCryptoComparisonPriceSource;
+    provider: string | null;
+    providerMarketId: string | null;
+    timestamp: string | null;
+    confidence: RecurringCryptoSourceConfidence | null;
+}
+interface RecurringCryptoPriceComparison {
+    count: number;
+    min: RecurringCryptoComparisonPoint | null;
+    max: RecurringCryptoComparisonPoint | null;
+    spread: number | null;
+    spreadBps: number | null;
+    byVenue: RecurringCryptoComparisonPoint[];
+}
+interface RecurringCryptoWindowComparisons {
+    referencePrice: RecurringCryptoPriceComparison;
+    outcomePrices: {
+        up: RecurringCryptoPriceComparison;
+        down: RecurringCryptoPriceComparison;
+    };
+}
+interface RecurringCryptoVenueMarket {
+    venue: Venue;
+    venueEventId: string;
+    venueMarketId: string;
+    externalEventId: string | null;
+    externalMarketId: string;
+    question: string;
+    status: MarketStatus;
+    priceSource: "snag" | "direct";
+    /** False for this endpoint; live crypto markets are not smart-route inputs. */
+    routeable: boolean;
+    /** False for this endpoint; split-order routing is not supported here. */
+    splitOrdersAllowed: boolean;
+    outcomes: RecurringCryptoOutcome[];
+    metrics: RecurringCryptoMarketMetrics;
+    resolution: RecurringCryptoResolution;
+    referencePrice: RecurringCryptoReferencePrice;
+}
+interface RecurringCryptoWindowMarket {
+    id: string;
+    asset: string;
+    quoteAsset: "USD";
+    duration: RecurringCryptoDuration;
+    windowStart: string;
+    windowEnd: string;
+    status: MarketStatus;
+    markets: RecurringCryptoVenueMarket[];
+    comparisons: RecurringCryptoWindowComparisons;
+}
+interface RecurringCryptoMarketsResponse {
+    data: RecurringCryptoWindowMarket[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+/** Per-venue orderbook entry with native tick spacing. */
+interface VenueOrderbookEntry {
+    venueMarketId: string;
+    tickSize: number | null;
+    orderbook: Orderbook;
+    /**
+     * Sticky tick of this venue's book inferred at runtime by the engine. May
+     * differ from the seed `tickSize` when the live grid is finer than the DB
+     * metadata. Optional — only populated when the engine has emitted runtime
+     * metadata for this entry.
+     */
+    tick?: number | null;
+    /** Provenance of this venue book's published midpoint. See {@link MarkSource}. */
+    markSource?: MarkSource;
+    /**
+     * Hyperliquid HIP-4 deployer namespace whose book this entry publishes
+     * (e.g. "ap"). `null` for every other venue. When a cluster has more than
+     * one Hyperliquid deployer member, only one member's book is published per
+     * request — this names which one, so a caller never pairs this entry's depth
+     * with a different member's `venueMarketId`.
+     */
+    deployerVenue?: string | null;
+}
+/** Response from GET /orderbooks (batch). */
+interface BatchOrderbooksResponse {
+    data: Array<{
+        venueMarketId: string;
+        status: OrderbookBatchItemStatus;
+        error: OrderbookBatchItemError | null;
+        requestedMarket: RequestedOrderbookMarket | null;
+        venueOrderbooks: Record<string, VenueOrderbookEntry>;
+        matchedMarkets: MatchedOrderbookMarket[];
+    }>;
+    meta: {
+        requestedCount: number;
+        okCount: number;
+        errorCount: number;
+    };
+}
+/** A single market midpoint row returned by GET /midpoints. */
+interface MidpointRow {
+    venueMarketId: string;
+    venue: string;
+    midpoint: number | null;
+    spread: number | null;
+    timestamp: number | null;
+    arbReturn?: number | null;
+    /** Provenance of `midpoint`. */
+    markSource?: MarkSource;
+    /**
+     * When `markSource === "sibling"`, the matched venueMarketId whose book
+     * supplied the headline mark. Allows the FE to label "sourced from venue X"
+     * without re-running the matching logic.
+     */
+    siblingVenueMarketId?: string;
+    /** Top-of-book buy-side price. Only present when `bestPrice=true`. */
+    bestBid?: number | null;
+    /** Top-of-book sell-side price. Only present when `bestPrice=true`. */
+    bestAsk?: number | null;
+}
+/** Per-outcome midpoint from a live orderbook. */
+interface OutcomeMidpointRow {
+    venueMarketOutcomeId: string;
+    label: string;
+    midpoint: number | null;
+    /** Provenance of `midpoint`. */
+    markSource?: MarkSource;
+    /** Top-of-book buy-side price. Only present when `bestPrice=true`. */
+    bestBid?: number | null;
+    /** Top-of-book sell-side price. Only present when `bestPrice=true`. */
+    bestAsk?: number | null;
+}
+/** Response from GET /midpoints (batch). */
+interface BatchMidpointsResponse {
+    data: Array<MidpointRow & {
+        outcomes: OutcomeMidpointRow[];
+        matched: MidpointRow[];
+        /**
+         * Live, quality-gated cross-venue arbitrage return for this market's
+         * cluster as a decimal fraction (`0.0085` = 0.85%), computed fresh by
+         * the engine on this request. Prefer it over the `arbReturn` embedded
+         * in venue-event listings, which a background sync can leave stale.
+         * Only present when the request set `bestPrice=true`.
+         */
+        arbReturn?: number | null;
+        /**
+         * DB status of the requested market. Present whenever the id resolves
+         * to a known market. Resolved markets never serve a price (see `error`).
+         */
+        marketStatus?: MarketStatus;
+        /**
+         * Structured refusal, mirroring GET /orderbooks per-item errors:
+         * `market_resolved` for settled markets (prices are nulled instead of
+         * serving a stale mark), `market_not_found` for unknown ids.
+         */
+        error?: {
+            code: "market_resolved" | "market_not_found";
+            message: string;
+            retryable: boolean;
+        };
+    }>;
+}
+/** Response from GET /orderbook/outcome/:id (single outcome). */
+interface OutcomeOrderbookResponse {
+    /** CRC of returned depth-limited levels; full engine checksum remains unchanged. */
+    snapshotChecksum?: number;
+    venueMarketOutcomeId: string;
+    venueMarketId: string;
+    venue: string;
+    orderbook: {
+        bids: Array<{
+            price: number;
+            size: number;
+        }>;
+        asks: Array<{
+            price: number;
+            size: number;
+        }>;
+    };
+    midpoint: number | null;
+    spread: number | null;
+    seq: number;
+    checksum: number;
+    timestamp: number;
+    /** Sticky tick of this outcome's book, inferred at runtime. `null` until inferred. */
+    tick: number | null;
+    /** Provenance of `midpoint`. See {@link MarkSource}. */
+    markSource: MarkSource;
+}
+/** Standard paginated list response from the API. */
+interface PaginatedResponse<T> {
+    data: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface OrderListQuery {
+    userId?: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+}
+interface TradeExecutorOrder {
+    id: string;
+    userId: string;
+    venue: string;
+    status: string;
+    marketId: string;
+    tokenId: string;
+    side: string;
+    amountRaw: string;
+    quoteId: string | null;
+    externalId: string | null;
+    clientOrderId: string | null;
+    dagRunId: string | null;
+    filledAmountRaw: string | null;
+    executionPrice: string | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface TradeExecutorOrderListResponse {
+    orders: TradeExecutorOrder[];
+    total: number;
+}
+/** A single level in the aggregated orderbook with per-venue attribution. */
+interface AggregatedOrderbookLevel {
+    price: number;
+    size: number;
+    venues: Record<string, number>;
+}
+/** A simple orderbook level without venue attribution. */
+interface SimpleOrderbookLevel {
+    price: number;
+    size: number;
+}
+/** Per-venue best-bid/ask info. */
+interface VenuePriceInfo {
+    bestBid: number | null;
+    bestAsk: number | null;
+}
+/** Response from GET /orderbook/:venueMarketId — canonical aggregated orderbook. */
+interface AggregatedOrderbookResponse {
+    venueMarketId: string;
+    orderbook: {
+        bids: AggregatedOrderbookLevel[];
+        asks: AggregatedOrderbookLevel[];
+    };
+    venueOrderbooks: Record<string, {
+        bids: SimpleOrderbookLevel[];
+        asks: SimpleOrderbookLevel[];
+    }>;
+    venues: Record<string, VenuePriceInfo>;
+    midpoint: number | null;
+    spread: number | null;
+    timestamp: number;
+    /** Sequence number (present in live responses). */
+    seq?: number;
+    /** CRC32 checksum (present in live responses). */
+    checksum?: number | null;
+    /** Markets matched across venues for this canonical market. */
+    matchedMarkets?: Array<{
+        venue: string;
+        venueMarketId: string;
+    }>;
+}
+interface ExecuteManagedParams {
+    quoteId: string;
+    /** Trading mode. Defaults to live. */
+    mode?: ExecutionMode;
+    /**
+     * Optional intent fallback. When the supplied `quoteId` has expired in the
+     * cache (e.g. user clicked Buy after a tab was inactive), the server
+     * resolves the latest quote for this intent and refreshes/executes against
+     * that instead of returning 400 `quote_not_found`. Same intent = same buttons
+     * the user pressed in the UI; a different `maxSpend`, mode, or venue scope is
+     * a different intent and won't match.
+     */
+    fallbackToLatest?: {
+        outcomeId: string;
+        side: "buy" | "sell";
+        maxSpend?: number;
+        sellShares?: number;
+        allowedVenues?: Venue[];
+    };
+    /**
+     * Self-custody: the wallet that will sign this fill. Must be a wallet
+     * already linked to this account. Omit for managed custody (the default).
+     */
+    signingAddress?: string;
+    /**
+     * Self-custody only: which approve shape a cross-chain fill uses when the
+     * bridge needs an ERC20 approve. Omit (the default) for "sponsored" — the
+     * approve costs the wallet no gas, but the wallet must sign a one-time
+     * EIP-7702 authorization over a RAW DIGEST, which many wallets cannot
+     * produce. Send "user_broadcast" when yours cannot: the user sends the
+     * approve from their own wallet and pays its gas. Only your client can know
+     * which applies — it is a property of the wallet software, not of the
+     * address or the chain.
+     *
+     * Worth surfacing in your UI: "user_broadcast" never establishes the
+     * delegation, so an approve is needed on EVERY bridge. "sponsored" costs one
+     * signature once per chain.
+     *
+     * Neither mode makes bridging free — the approve is only one of the costs.
+     * Relay's fee comes out of the amount delivered on every bridge, and one-time
+     * costs apply per route. Quote with `deepEstimate` and read
+     * `feeBreakdown.bridgeFees` and `feeBreakdown.setupCosts` rather than
+     * inferring cost from the approve mode.
+     */
+    approveMode?: "sponsored" | "user_broadcast";
+}
+interface ExecuteManagedResponse {
+    alreadyAccepted?: boolean;
+    quoteId: string;
+    orderIds: string[];
+    status: "pending";
+    redeemId?: string;
+    message?: string;
+    /**
+     * What this fill is waiting to be signed, if anything. On the immediate
+     * `POST /execution/fill` response this is always absent or empty — even
+     * for a self-custody fill, the DAG parks asynchronously, after this
+     * response has already been sent. Real entries only ever come back from
+     * polling `GET /execution/status` or from the next
+     * `POST /execution/fill/:quoteId/signatures` response (this same shape,
+     * reused). Drive the whole round trip through `fillSelfCustody()` rather
+     * than reading this field on the fill response by hand.
+     */
+    pendingSignatures?: SignatureRequest[];
+}
+type LimitOrderTimeInForce = "GTC" | "GTD" | "FOK" | "FAK" | "IOC" | "ALO";
+type CancelOrderSignature = {
+    signature: string;
+    timestamp: number;
+} | {
+    venue: "hyperliquid";
+    action: {
+        type: "cancel";
+        cancels: Array<{
+            a: number;
+            o: number;
+        }>;
+    };
+    nonce: number;
+    signature: {
+        r: string;
+        s: string;
+        v: 27 | 28;
+    };
+};
+interface PlaceLimitOrderParams {
+    /** BETDEX uses hosted cash: GTC/IOC only, no signer, post-only or expiry.
+     * Native odds are rounded conservatively and stake is rounded down. GTC
+     * unmatched liquidity is cancelled at the in-play transition. SELL closes
+     * the same For outcome and requires collateral as well as owned inventory.
+     */
+    venue: Venue;
+    venueMarketOutcomeId: string;
+    side: "buy" | "sell";
+    limitPriceRaw: string;
+    sizeRaw: string;
+    timeInForce: LimitOrderTimeInForce;
+    postOnly?: boolean;
+    expiresAt?: string;
+    clientOrderId?: string;
+    /** Linked account EOA. Polymarket supports GTC/GTD buys; Hyperliquid supports GTC/ALO buys and sells. Agent keys stay on the client. Omit for managed custody. */
+    signingAddress?: string;
+    /** Same bridge approval mode as market fills; defaults to sponsored. */
+    approveMode?: ExecuteManagedParams["approveMode"];
+    /** Self-custody buys only: other wallets linked to this account whose balances may bridge in to fund the order. Requires signingAddress. */
+    fundingAddresses?: string[];
+}
+interface PlaceLimitOrderResponse {
+    orderId: string;
+    /** Poll getExecutionStatus and answer submitFillSignatures using this ID. */
+    quoteId?: string;
+    status: "pending" | "submitting" | "submitted" | "cancel_pending" | "partial_fill" | "open" | "partially_filled_open" | "filled" | "cancelled" | "expired" | "failed";
+    venue: Venue;
+    venueOrderId?: string | null;
+    reservedCostRaw?: string | null;
+    limitPriceRaw: string;
+    limitSizeRaw: string;
+    filledSizeRaw: string;
+    remainingSizeRaw: string;
+}
+interface PlaceOrderParams {
+    venue: Venue;
+    venueMarketOutcomeId: string;
+    side: "buy" | "sell";
+    /** Buy only. Maximum all-in USD spend, inclusive of app fee. */
+    maxSpend?: number;
+    /** Sell only. Number of contracts to sell. */
+    sellShares?: number;
+    /**
+     * Your trade id. Required, unique within your app — two different users of
+     * the same app cannot share one. A repeat returns 409 instead of trading twice.
+     */
+    externalId: string;
+    /** Slippage cap in bps. Defaults to 500 (5%). Set explicitly on sells. */
+    slipCapBps?: number;
+    /** Restrict funding to these chain IDs. Omit to allow every funded chain. */
+    allowedSourceChainIds?: number[];
+    /** USD budgets capped by refreshed wallet balances; omitted chains cannot fund. */
+    chainBalances?: Record<string, number>;
+    /** Referral: EVM address that receives the referral fee. Needs an app API key. */
+    referrer?: string;
+    /** Referral fee in bips of routed notional (1..10000). Snag-free. */
+    referrerFeeBips?: number;
+    /** Who funds the referral: "user" (default) reserves it from maxSpend; "app" pays from `referralPayerAddress` after the fill. */
+    referralPayer?: "user" | "app";
+    /** Required with `referralPayer: "app"`: the wallet that signs the parked payout transaction. */
+    referralPayerAddress?: string;
+    /**
+     * Skip the smart-route solver and send one order straight to `venue` (predict,
+     * hyperliquid, novig and prophetx only; others return 400). Requires a `read_write` `x-app-api-key`. No
+     * bridging: funds must already sit on the venue's own chain, and `allowedSourceChainIds` /
+     * `chainBalances` are ignored alongside it. You own price and minimum
+     * checks — an order the venue refuses fails after acceptance and uses up its `externalId`.
+     */
+    skipQuote?: boolean;
+    /**
+     * With `skipQuote`, skip the balance check and fund hold on a buy: nothing checks the
+     * balance and an underfunded order fails at the venue. Sells still check the position.
+     */
+    skipBalance?: boolean;
+    /**
+     * With `skipQuote`, the price to trade at (e.g. `0.52`). Optional: if omitted, the best
+     * available price at submission is used (best ask to buy, bid to sell). Ignored on
+     * prophetx, which prices the order itself within `slipCapBps`.
+     */
+    price?: number;
+}
+interface PlaceOrderResponse {
+    orderId: string;
+    externalId: string;
+    venue: Venue;
+    status: "pending";
+    quoteId: string;
+    /** `null` if the order row doesn't carry a quoted price. Not zero. */
+    quotedPriceRaw: string | null;
+    /** `null` under the same conditions as `quotedPriceRaw`. Not zero. */
+    quotedCostRaw: string | null;
+    /** `null` under the same conditions as `quotedPriceRaw`. Not zero. */
+    quotedSharesRaw: string | null;
+}
+interface ValidateManagedParams {
+    venueMarketOutcomeIds: string[];
+    side: "buy" | "sell";
+    amount: number;
+}
+interface ValidateManagedResponse {
+    canExecute: boolean;
+    availableBalanceRaw: string;
+    requiredBalanceRaw: string;
+    bridgeSourceChainId?: number;
+    bridgeAmountRaw?: string;
+}
+type BalanceRefillPolicyStatus = "enabled" | "paused";
+type BalanceRefillAttemptStatus = "reserved" | "executing" | "completed" | "failed";
+interface BalanceRefillAttempt {
+    id: string;
+    policyId: string;
+    status: BalanceRefillAttemptStatus;
+    /** Target-chain balance when the threshold was crossed, in 6-decimal USD units. */
+    triggerBalanceRaw: string;
+    /** Minimum amount the refill must deliver, in 6-decimal USD units. */
+    requestedDeliveryRaw: string;
+    /** Reserved source amount, in 6-decimal USD units. */
+    sourceAmountRaw: string;
+    completedAmountRaw: string | null;
+    sourceChainId: number;
+    targetChainId: number;
+    feeRaw: string | null;
+    errorMessage: string | null;
+    startedAt: string | null;
+    completedAt: string | null;
+    createdAt: string;
+}
+interface BalanceRefillPolicy {
+    id: string;
+    targetChainId: number;
+    targetTokenAddress: string;
+    targetTokenSymbol: "USDC";
+    /** Balance floor, in 6-decimal USD units. */
+    minimumRaw: string;
+    /** Minimum delivered amount per refill, in 6-decimal USD units. */
+    refillAmountRaw: string;
+    dailyCapRaw: string;
+    maxFeeRaw: string;
+    status: BalanceRefillPolicyStatus;
+    cooldownSeconds: number;
+    lastObservedRaw: string | null;
+    lastEvaluatedAt: string | null;
+    nextEligibleAt: string | null;
+    consentedAt: string;
+    createdAt: string;
+    updatedAt: string;
+    latestAttempt: BalanceRefillAttempt | null;
+}
+interface CreateBalanceRefillPolicyParams {
+    targetChainId: number;
+    targetTokenSymbol?: "USDC";
+    minimumRaw: string;
+    refillAmountRaw: string;
+    /** Optional daily refill limit. Defaults to $1,002 in 6-decimal USD units. */
+    dailyCapRaw?: string;
+    /** Optional per-refill fee limit. Defaults to $2 in 6-decimal USD units. */
+    maxFeeRaw?: string;
+}
+interface UpdateBalanceRefillPolicyParams {
+    minimumRaw?: string;
+    refillAmountRaw?: string;
+    dailyCapRaw?: string;
+    maxFeeRaw?: string;
+    status?: BalanceRefillPolicyStatus;
+}
+type WithdrawTokenSymbol = "USDC" | "USDC.e" | "USDT";
+type WithdrawalSourceTokenSymbol = WithdrawTokenSymbol | "pUSD" | "USD1";
+interface WithdrawManagedParams {
+    /** Positive integer string in the token's native decimals (e.g. "100000" = 0.1 USDC). */
+    amountRaw: string;
+    tokenSymbol: WithdrawTokenSymbol;
+    /** Recipient address. EVM destinations use 0x-prefixed 20-byte hex; Solana uses base58. */
+    destinationAddress: string;
+    /** Chain ID where the recipient should receive funds. Required as of v2026.04. */
+    destinationChainId: number;
+    /**
+     * When `true`, the server caps the withdrawal to the maximum deliverable amount
+     * instead of rejecting an over-balance request. Use only when the user explicitly
+     * clicked Max — manual over-typed amounts must still surface the unviable state.
+     */
+    max?: boolean;
+}
+type WithdrawalLifecycleStatus = "pending" | "bridging" | "transferring" | "completed" | "partial" | "failed";
+type WithdrawalSourceStatus = "pending" | "submitted" | "confirmed" | "failed";
+type WithdrawalLegType = "transfer" | "bridge";
+type WithdrawalLegStatus = "planned" | "submitted" | "confirmed" | "failed";
+interface WithdrawalLeg {
+    type: WithdrawalLegType;
+    status: WithdrawalLegStatus;
+    sourceChainId: number;
+    destChainId: number;
+    amountRaw: string;
+    txHash: string | null;
+    bridgeOperationId: string | null;
+    /** Human-readable failure reason when `status === "failed"`. Null when succeeded or in-flight. */
+    errorMessage?: string | null;
+}
+interface WithdrawManagedSourceItem {
+    sourceId: string;
+    chainId: number;
+    tokenSymbol: WithdrawalSourceTokenSymbol;
+    /** On-chain token address on `chainId`. */
+    tokenAddress: string;
+    /**
+     * On-chain decimals for `(chainId, tokenAddress)`. Required to interpret
+     * `amountRaw`: BNB USDC is 18-dec, EVM USDC is 6-dec.
+     */
+    decimals: number;
+    amountRaw: string;
+    /** Smart-wallet or native-account custody; absent for ordinary EOA sources. */
+    custodyKind?: "DEPOSIT_WALLET" | "VENUE_ACCOUNT";
+    /** Venue that owns the source (for example, `pred` or `tiprun`). */
+    venue?: string;
+    sourceVenueAccountId?: string;
+    /** Lossless native account ID, not an EVM address. */
+    sourceExternalAccountId?: string;
+    status: WithdrawalSourceStatus;
+    txHash: string | null;
+    bridgeOperationId: string | null;
+}
+/**
+ * `pricingStatus === "quoted"` means the response includes a fresh preflight
+ * quote; other states may carry null `expected.*` fields. Do NOT treat null
+ * fields as missing.
+ */
+interface WithdrawalExpected {
+    outputRaw: string | null;
+    feeRaw: string | null;
+    etaSeconds: number | null;
+}
+/** Body for POST /execution/withdraw/preview — identical to a withdraw request. */
+type WithdrawPreviewParams = WithdrawManagedParams;
+interface WithdrawalQuoteParams {
+    tokenSymbol: WithdrawTokenSymbol;
+    destinationChainId: number;
+}
+interface WithdrawalQuoteResponse {
+    tokenSymbol: WithdrawTokenSymbol;
+    destinationChainId: number;
+    maxDeliverableRaw: string;
+    rawBalanceRaw: string;
+    decimals: number;
+}
+/** Response from POST /execution/withdraw/preview. All amounts are raw strings in destination-token native decimals. */
+interface WithdrawPreviewResponse {
+    receiveAmountRaw: string | null;
+    feeRaw: string | null;
+    relayFeeRaw: string | null;
+    networkFeeRaw: string | null;
+    pricingStatus: "quoted" | "unviable";
+    quoteExpiresAt: string | null;
+    unviableReason: string | null;
+    maxDeliverableRaw: string | null;
+}
+interface WithdrawManagedResponse {
+    withdrawalId: string;
+    status: WithdrawalLifecycleStatus;
+    requested: {
+        tokenSymbol: WithdrawTokenSymbol;
+        amountRaw: string;
+    };
+    /**
+     * Terminal settled amount in destination-token native decimals.
+     * Null until at least one source confirms.
+     */
+    completedAmountRaw: string | null;
+    destination: {
+        chainId: number;
+        address: string;
+        tokenSymbol: WithdrawTokenSymbol;
+    };
+    legs: WithdrawalLeg[];
+    expected: WithdrawalExpected;
+    pricingStatus: "unquoted" | "quoting" | "quoted" | "unviable";
+    /**
+     * Persisted terminal-state error reason. Always `null` until the
+     * withdrawal reaches `failed` / `partial`. The submit response always
+     * returns `null`; populated values arrive via the GET status endpoint or
+     * via a terminal `withdrawal_lifecycle` WS event.
+     */
+    errorMessage: string | null;
+    sources: WithdrawManagedSourceItem[];
+}
+interface DepositAddressesToken {
+    symbol: string;
+    address: string;
+    decimals: number;
+}
+interface DepositAddressesSupportedChain {
+    chainId: number;
+    name: string;
+    tokens: DepositAddressesToken[];
+}
+interface DepositAddressesReadyResponse {
+    ready: true;
+    evmAddress: string;
+    svmAddress: string;
+    supportedChains: DepositAddressesSupportedChain[];
+}
+interface DepositAddressesPendingResponse {
+    ready: false;
+}
+type DepositAddressesResponse = DepositAddressesReadyResponse | DepositAddressesPendingResponse;
+interface GetPositionsParams {
+    cursor?: string;
+    limit?: number;
+    status?: "active" | "closed";
+    mode?: ExecutionMode;
+}
+interface GetOrdersParams {
+    status?: string;
+    cursor?: string;
+    limit?: number;
+}
+interface OrderbookQuoteParams {
+    marketId: string;
+    side: "buy" | "sell";
+    size: number;
+}
+interface OrderbookQuoteFill {
+    venue: string;
+    size: number;
+    avgPrice: number;
+    cost: number;
+}
+interface OrderbookQuoteResponse {
+    marketId: string;
+    side: "buy" | "sell";
+    requestedSize: number;
+    filledSize: number;
+    avgPrice: number | null;
+    totalCost: number;
+    slippage: number | null;
+    fills: OrderbookQuoteFill[];
+}
+type ExecutionOrdersQuery = GetOrdersQuery & {
+    mode?: ExecutionMode;
+};
+type ExecutionOrderItem = OrderListItem;
+type ExecutionStatusQuery = {
+    quoteId: string;
+    mode?: ExecutionMode;
+};
+type ExecutionOverallState = "created" | "routing" | "quoting" | "placing" | "confirming" | "filled" | "partially_filled" | "failed" | "cancelled" | "expired";
+interface ExecutionDagProgress {
+    dagRunId: string;
+    totalSteps: number;
+    currentSequence: number;
+    currentStepType: string | null;
+    completedSequences: number[];
+    stepTypes: Record<number, string>;
+    status: "running" | "completed" | "failed";
+    errorReason: string | null;
+}
+type ExecutionDisplayStepKind = "submit" | "setup" | "bridge" | "fill" | "internal";
+type ExecutionDisplayGroupStatus = "pending" | "in_progress" | "completed" | "failed" | "skipped";
+interface ExecutionStatusStep {
+    sequence: number;
+    stepType: string;
+    status: "pending" | "in_progress" | "completed" | "failed" | "skipped";
+    attempt: number;
+    startedAt: string | null;
+    completedAt: string | null;
+    errorReason: string | null;
+    /** Venue legs this step funds or executes; join to `orders[].orderId`. */
+    orderIds: string[];
+    /** Display class. `internal` steps are not meant to be rendered. */
+    kind: ExecutionDisplayStepKind;
+    /** Steps sharing a groupId render as ONE row. */
+    groupId: string;
+    /** Rolled-up status for the group; identical on every member. */
+    groupStatus: ExecutionDisplayGroupStatus;
+    /** Row copy, phrased for the current `groupStatus`. */
+    label: string;
+    /** Set on `kind: "bridge"` only. */
+    bridge?: {
+        amount: string;
+        tokenSymbol: string;
+        fromChain: string;
+        toChain: string;
+    };
+}
+interface ExecutionStatusOrder {
+    orderId: string;
+    venue: string;
+    status: string;
+    event: "filled" | "partial_fill" | "failed" | null;
+    filledAmountRaw?: string;
+    remainingAmountRaw?: string;
+    quotedSharesRaw?: string;
+    actualSharesRaw?: string;
+    quotedToWinRaw?: string;
+    actualToWinRaw?: string;
+    quotedPriceRaw?: string;
+    executionPriceRaw?: string;
+    partialFillReason?: string;
+    errorReason?: string;
+    venueOrderId?: string;
+    txHash?: string;
+    updatedAt: string;
+}
+interface ExecutionStatusResponse {
+    executionId: string | null;
+    quoteId: string;
+    orderIds: string[];
+    overallState: ExecutionOverallState;
+    terminal: boolean;
+    errorReason: string | null;
+    pollAfterMs: number | null;
+    dagProgress: ExecutionDagProgress | null;
+    steps: ExecutionStatusStep[];
+    orders: ExecutionStatusOrder[];
+    /**
+     * What this run is waiting to be signed, mirroring the fill response's
+     * field of the same name. This is the polling route `fillSelfCustody` reads
+     * while an on-chain step is in flight — a caller polling this route for
+     * progress learns about newly-parked steps here too, not just from the
+     * signatures endpoint.
+     */
+    pendingSignatures?: SignatureRequest[];
+}
+type ExecutionPositionsQuery = GetPositionsQuery & {
+    mode?: ExecutionMode;
+};
+type ExecutionPositionGroup = PositionGroup;
+/** Whose cash to return: the managed server wallet (default) or the account's linked wallets. */
+type BalanceCustody = "managed" | "self";
+type ManagedBalancesParams = {
+    mode?: ExecutionMode;
+    custody?: BalanceCustody;
+};
+interface PaperTradingAppOptions {
+    /** App ID for the paper account namespace. Defaults to AggClient appId. */
+    appId?: string;
+}
+interface PaperTradingListParams {
+    limit?: number;
+    cursor?: string;
+}
+interface PaperTradingAccountListParams extends PaperTradingListParams {
+    externalId?: string;
+}
+interface CreatePaperTradingAccountParams {
+    name?: string;
+    externalId?: string;
+    initialBalanceRaw?: string;
+    initialBalance?: number;
+}
+interface SetPaperTradingBalanceParams {
+    balanceRaw?: string;
+    balance?: number;
+    reason?: string;
+}
+interface ResetPaperTradingAccountParams {
+    balanceRaw?: string;
+    balance?: number;
+    reason?: string;
+}
+interface PlacePaperTradingOrderParams {
+    venueMarketOutcomeId: string;
+    side: "buy" | "sell";
+    spendRaw?: string;
+    spend?: number;
+    shares?: number;
+    slippageBps?: number;
+    clientOrderId?: string;
+}
+type PaperTradingMarkSource = "orderbook_midpoint" | "orderbook_best_bid" | "catalog_price";
+type PaperTradingLiquidityStatus = "full" | "partial" | "none";
+interface PaperTradingAccount {
+    id: string;
+    appId: string;
+    name: string | null;
+    externalId: string | null;
+    currency: string;
+    startingBalanceRaw: string;
+    startingBalance: number;
+    cashBalanceRaw: string;
+    cashBalance: number;
+    realizedPnlRaw: string;
+    realizedPnl: number;
+    kycStatus: "verified";
+    kycVerified: true;
+    status: "active" | "archived";
+    createdAt: string;
+    updatedAt: string;
+}
+interface PaperTradingPosition {
+    id: string;
+    accountId: string;
+    venue: string;
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+    marketQuestion: string;
+    outcomeLabel: string;
+    size: number;
+    avgEntryPrice: number;
+    markPrice: number;
+    markSource: PaperTradingMarkSource;
+    markTimestamp: number | null;
+    bestBidPrice: number | null;
+    bestAskPrice: number | null;
+    midpoint: number | null;
+    spread: number | null;
+    marketValueRaw: string;
+    marketValue: number;
+    unrealizedPnlRaw: string;
+    unrealizedPnl: number;
+    liquidationPrice: number | null;
+    liquidationValueRaw: string;
+    liquidationValue: number;
+    liquidationPnlRaw: string;
+    liquidationPnl: number;
+    liquidityShares: number;
+    liquidityStatus: PaperTradingLiquidityStatus;
+    realizedPnlRaw: string;
+    realizedPnl: number;
+    createdAt: string;
+    updatedAt: string;
+}
+interface PaperTradingOrder {
+    id: string;
+    accountId: string;
+    venue: string;
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+    marketQuestion: string;
+    outcomeLabel: string;
+    side: "buy" | "sell";
+    status: "filled" | "rejected";
+    clientOrderId: string | null;
+    requestedSpendRaw: string | null;
+    requestedSpend: number | null;
+    requestedShares: number | null;
+    filledShares: number;
+    avgPrice: number | null;
+    slippageBps: number | null;
+    notionalRaw: string;
+    notional: number;
+    cashDeltaRaw: string;
+    cashDelta: number;
+    realizedPnlRaw: string;
+    realizedPnl: number;
+    rejectionReason: string | null;
+    createdAt: string;
+}
+interface PaperTradingBalanceAdjustment {
+    id: string;
+    accountId: string;
+    type: "set_balance" | "reset";
+    amountRaw: string;
+    amount: number;
+    previousCashBalanceRaw: string;
+    previousCashBalance: number;
+    newCashBalanceRaw: string;
+    newCashBalance: number;
+    reason: string | null;
+    createdAt: string;
+}
+interface PaperTradingPortfolio {
+    account: PaperTradingAccount;
+    cashBalanceRaw: string;
+    cashBalance: number;
+    marketValueRaw: string;
+    marketValue: number;
+    equityRaw: string;
+    equity: number;
+    realizedPnlRaw: string;
+    realizedPnl: number;
+    unrealizedPnlRaw: string;
+    unrealizedPnl: number;
+    liquidationValueRaw: string;
+    liquidationValue: number;
+    liquidationEquityRaw: string;
+    liquidationEquity: number;
+    liquidationPnlRaw: string;
+    liquidationPnl: number;
+    positions: PaperTradingPosition[];
+}
+interface PaperTradingAccountsPage {
+    data: PaperTradingAccount[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface PaperTradingPositionsPage {
+    data: PaperTradingPosition[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface PaperTradingOrdersPage {
+    data: PaperTradingOrder[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface PaperTradingBalanceResponse {
+    account: PaperTradingAccount;
+    adjustment: PaperTradingBalanceAdjustment;
+}
+type UserActivityType = "trade" | "withdrawal" | "bridge" | "deposit" | "user_op" | "redeem";
+interface UserActivityBase {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    status: string;
+}
+interface UserActivityVenueMarket {
+    id: string;
+    venueEventId: string;
+    question: string | null;
+    image: string | null;
+}
+interface UserActivityVenueMarketOutcome {
+    id: string;
+    label: string;
+    title: string | null;
+    price: number;
+}
+interface UserActivityTrade extends UserActivityBase {
+    type: "trade";
+    venue: string;
+    side: string;
+    amountRaw: string;
+    filledAmountRaw: string | null;
+    executionPrice: string | null;
+    venueMarket: UserActivityVenueMarket | null;
+    venueMarketOutcome: UserActivityVenueMarketOutcome | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    /** @deprecated Use venueMarket.question. */
+    marketQuestion?: string | null;
+    /** @deprecated Use venueMarketOutcome.label/title. */
+    outcomeLabel?: string | null;
+}
+interface UserActivityWithdrawal extends UserActivityBase {
+    type: "withdrawal";
+    tokenSymbol: string;
+    amountRaw: string;
+    destinationAddress: string;
+    destinationChainId: string;
+    completedAmountRaw: string | null;
+    chainId?: string | null;
+    txHash?: string | null;
+    errorMessage: string | null;
+}
+interface UserActivityBridge extends UserActivityBase {
+    type: "bridge";
+    tokenSymbol: string;
+    amountRaw: string;
+    sourceChainId: string;
+    destChainId: string;
+    sourceTxHash: string | null;
+    destTxHash: string | null;
+}
+interface UserActivityDeposit extends UserActivityBase {
+    type: "deposit";
+    tokenSymbol: string;
+    amountRaw: string;
+    chainId: string;
+    fromAddress: string;
+    txHash: string;
+    source: "connected_wallet" | "external_wallet";
+}
+interface UserActivityUserOp extends UserActivityBase {
+    type: "user_op";
+    callsId: string;
+    chainId: string;
+    walletAddress: string;
+    txHash: string | null;
+    confirmedAt: string | null;
+}
+interface UserActivityRedeemLeg {
+    id: string;
+    venueMarketOutcomeId: string;
+    venue: string;
+    status: string;
+    chainId: string;
+    payoutTokenSymbol: string;
+    payoutAmountRaw: string | null;
+    txHash: string | null;
+    errorMessage: string | null;
+    venueMarket: UserActivityVenueMarket | null;
+    venueMarketOutcome: Omit<UserActivityVenueMarketOutcome, "price"> | null;
+}
+interface UserActivityRedeem extends UserActivityBase {
+    type: "redeem";
+    totalPayoutRaw: string | null;
+    legs: UserActivityRedeemLeg[];
+}
+type UserActivityItem = UserActivityTrade | UserActivityWithdrawal | UserActivityBridge | UserActivityDeposit | UserActivityUserOp | UserActivityRedeem;
+interface UserActivityQuery {
+    type?: UserActivityType;
+    cursor?: string;
+    limit?: number;
+}
+interface RampQuoteRequest {
+    sourceAmount: string;
+    sourceCurrencyCode: string;
+    destinationCurrencyCode: string;
+    paymentMethodType?: string;
+}
+interface RampQuote {
+    serviceProvider: string;
+    transactionType: string;
+    sourceAmount: number;
+    sourceCurrencyCode: string;
+    destinationAmount: number;
+    destinationCurrencyCode: string;
+    exchangeRate: number;
+    totalFee: number;
+    networkFee: number;
+    transactionFee: number;
+    partnerFee: number;
+    fiatAmountWithoutFees: number;
+    paymentMethodType: string;
+    countryCode: string;
+    rampScore: number;
+    lowKyc: boolean;
+}
+interface RampSessionRequest {
+    sourceAmount: string;
+    sourceCurrencyCode: string;
+    destinationCurrencyCode: string;
+    serviceProvider: string;
+    walletAddress: string;
+    redirectUrl?: string;
+}
+interface RampWidgetSession {
+    id: string;
+    token: string;
+    widgetUrl: string;
+    serviceProviderWidgetUrl: string;
+}
+type SmartRouteStatus = "ok" | "infeasible" | "checker_rejected" | "solver_error" | "invalid_input" | "no_orderbooks" | "min_order_size_violated" | "insufficient_input_amount" | "engine_unavailable" | "insufficient_position" | "insufficient_depth" | "no_bids_above_min_price" | "insufficient_balance";
+/** A single fill at a price level within a venue. */
+interface SmartRouteFill {
+    price: number;
+    size: number;
+    fill: number;
+}
+/** Per-venue routing result with fills and chain info. */
+interface SmartRouteVenueFill {
+    /** CH executable price and normalized input, in micro-USDC. */
+    limitPriceMicroUsdc?: string;
+    inAmount?: string;
+    outAmount?: string;
+    venue: string;
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+    chain: string;
+    avgPrice: number;
+    yesPrice: number;
+    noPrice: number;
+    fills: SmartRouteFill[];
+    executionBackend?: "clearinghouse" | "direct";
+    venueAccountId?: string;
+    venueQty: number;
+    /**
+     * Builder fee for this fill in USD — the slice paid to a builder code
+     * rather than to the venue. Excluded from `venueFee`. Optional so an
+     * older engine build that does not emit it still validates.
+     */
+    builderFee?: number;
+    /**
+     * What the venue takes from this leg's payout if the outcome wins (USD):
+     * Hyperliquid HIP-4's close fee on the $1 settlement, 0 elsewhere. Not a
+     * cost at fill; already netted out of `estimatedPayout`.
+     */
+    settlementFee?: number;
+    /** Inclusive fee/reserve funding budget. For fee display, use the route's
+     * feeBreakdown.venueFees and executionReserve instead. */
+    venueFee?: number;
+}
+interface SmartRouteAllocation {
+    sourceChainId: string;
+    venue: string;
+    amount: number;
+    sourceTokenAddress?: string;
+    custodyKind?: "EOA" | "DEPOSIT_WALLET" | "POLYMARKET_LEGACY" | "VENUE_ACCOUNT";
+    custodyAddress?: string;
+    /** Native venue cash identifies an account, not an EVM custody address. */
+    sourceVenueAccountId?: string;
+    /** Lossless decimal native account ID; never convert this to a JS number. */
+    sourceExternalAccountId?: string;
+    /** On-chain funding wallet, when present; absent for native venue cash. */
+    sourceAddress?: string;
+    exactToken?: boolean;
+}
+interface SmartRouteBridgeStep {
+    sourceChainId: string;
+    destChainId: string;
+    /** Source-side amount sent into the bridge, in USD: the allocations this lane funds plus `cost`. */
+    amount: number;
+    /**
+     * Delivery margin, in USD, sent on top of the allocations so the destination
+     * still receives them in full after the bridge takes its fee. A planning
+     * reserve, not the expected fee: excluded from `feeBreakdown.bridgeFees` and
+     * `totalCost`, and whatever the bridge does not charge arrives at the
+     * destination as the user's balance. Read `feeBreakdown.bridgeFees` for the
+     * expected bridge fee.
+     */
+    cost: number;
+    sourceTokenAddress?: string;
+    destTokenAddress?: string;
+}
+interface VenueSoloQuote {
+    quoteFailure?: {
+        venue: string;
+        code: string;
+        retryAt?: string;
+    };
+    /**
+     * Minted by the API per successful + executable solo; send this to
+     * /execution/fill to execute single-venue. `null` when the solo is not
+     * executable (status !== "ok", filledQty === 0, or venue not in
+     * SUPPORTED_FILL_VENUES). FE filters on truthiness.
+     */
+    quoteId: string | null;
+    /** Why this venue cannot execute when quoteId is null (or execution is geo-gated). */
+    unavailableReason?: string;
+    venue: string;
+    /**
+     * The outcome this solo is bound to. `venue` alone is NOT unique — one venue
+     * can list the same matched outcome more than once (e.g. two Hyperliquid
+     * deployers listing the same game), producing two solo cards with the same
+     * `venue`. Key on this alongside `venue` when identifying a card.
+     */
+    venueMarketOutcomeId?: string;
+    avgPrice: number | null;
+    filledQty: number;
+    rawExecCost: number;
+    estimatedPayout: number;
+    estimatedProfit: number;
+    returnPct: number;
+    /**
+     * `feeBreakdown.totalCost` plus this solo's own user-paid app fee and
+     * referral — same composition as the primary route's `totalCostIncFees`.
+     * `estimatedProfit`/`returnPct` stay router values, unaffected. Absent
+     * when the router sent no `feeBreakdown` for this solo.
+     */
+    totalCostIncFees?: number;
+    status: string;
+    /** Per-price-level fills, identical shape to primary fills. Empty for non-ok statuses. */
+    fills: SmartRouteVenueFill[];
+    allocations?: SmartRouteAllocation[];
+    bridgeSteps?: SmartRouteBridgeStep[];
+    /**
+     * One-time setup costs for this solo's chosen venue + market. Populated
+     * only when the originating quote opted in via `deepEstimate=true`; absent
+     * on cheap quotes and on non-executable / failed solos. Same shape as the
+     * multi-route `feeBreakdown.setupCosts`. The solo's `estimatedProfit` and
+     * `returnPct` are recomputed against `cost basis + setupCostsTotal` so
+     * per-venue comparisons are setup-inclusive.
+     */
+    setupCosts?: SmartRouteSetupCostLine[];
+    /** Sum of this solo's `setupCosts` entries where `alreadyPaid=false`. */
+    setupCostsTotal?: number;
+    /**
+     * Cost breakdown for executing THIS venue alone. Present when
+     * `status === "ok"`; absent otherwise.
+     *
+     * Read this — not the top-level `feeBreakdown` — when rendering fees for a
+     * single venue. A solo's bridge lanes and venue fee are its own, so a venue
+     * needing no bridge reports `bridgeFees: 0` here even when the multi-route
+     * plan bridged.
+     */
+    feeBreakdown?: SmartRouteFeeBreakdown;
+}
+/** @deprecated Smart-route side overrides are kept only for source compatibility. */
+type SmartRouteSide = "yes" | "no";
+/** Trade direction for order routing. "buy" (default) reads asks, "sell" reads bids. */
+type TradeSide = "buy" | "sell";
+/** Trading mode for normal execution endpoints. Defaults to live. */
+type ExecutionMode = "live" | "paper";
+/** Request params for GET /orderbook/:venueMarketOutcomeId/route. */
+interface SmartRouteParams {
+    venueMarketOutcomeId?: string;
+    /** @deprecated Use venueMarketOutcomeId. */
+    venueMarketId?: string;
+    /** @deprecated Use venueMarketOutcomeId. */
+    outcomeId?: string;
+    /** @deprecated Side is ignored for routing and echoed back only for legacy consumers. */
+    side?: SmartRouteSide;
+    /** Trade direction: "buy" (default) or "sell". */
+    tradeSide?: TradeSide;
+    /** Trading mode. Defaults to live. */
+    mode?: ExecutionMode;
+    maxSpend?: number;
+    /** Sell only: target number of contracts to sell. Required for sell unless maxSpend is given. */
+    sellShares?: number;
+    chainBalances?: Record<string, number>;
+    slipCapBps?: number;
+    compareVenues?: boolean;
+    /** Restrict this quote to one or more executable venues. */
+    allowedVenues?: Venue[];
+    /**
+     * Opt in to the deep cost-estimate surface. When `true`, the response
+     * `feeBreakdown` includes `setupCosts` (one-time chain approvals + Kalshi
+     * SPL token-account rents) with per-item `alreadyPaid` flags from the
+     * user's prior trade history. Buy-only; ignored for sells.
+     *
+     * Deep quotes also pre-deduct the unpaid setup total from `maxSpend`
+     * before routing, so `totalCostIncFees` (and the recomputed
+     * `estimatedProfit` / `returnPct`) stay within the partner's stated
+     * budget.
+     */
+    deepEstimate?: boolean;
+    /** Referral: EVM address that receives the referral fee. Needs an app API key. */
+    referrer?: string;
+    /** Referral fee in bips of routed notional (1..10000). Snag-free. */
+    referrerFeeBips?: number;
+    /** Who funds the referral: "user" (default) reserves it from maxSpend; "app" pays from `referralPayerAddress` after the fill. */
+    referralPayer?: "user" | "app";
+    /** Required with `referralPayer: "app"`: the wallet that signs the parked payout transaction. */
+    referralPayerAddress?: string;
+}
+/** One-time setup line item — populated only on deep-estimate quotes. */
+interface SmartRouteSetupCostLine {
+    /** "chainApproval" = ERC-20 + venue-contract approvals on the venue's
+     *  chain (Polymarket / Polygon, Limitless / Base, predict.fun / BNB).
+     *  "venueMarketAta" = Kalshi-on-Solana per-market token-account rent.
+     *  "hyperliquidActivation" = Hyperliquid's one-time 1 USDC fee to activate
+     *  the user's address on its first deposit; `alreadyPaid` once the address
+     *  exists on Hyperliquid. Deducted from the bridged amount, not a step. */
+    kind: "chainApproval" | "venueMarketAta" | "hyperliquidActivation";
+    venue: string;
+    /** Set when `kind === "chainApproval"`. */
+    chainId?: number;
+    /** Set when `kind === "venueMarketAta"`. */
+    venueMarketId?: string;
+    /** Per-item cost in USD. Sourced from documented chain-paymaster floors
+     *  (Polygon/Base/Arbitrum ≈ $0.05, BNB $0.20, Solana ATA ≈ $0.30). */
+    costUsd: number;
+    /** True if the user has already paid this on a prior fill — render as a
+     *  strike-through "first-time fee" chip rather than charging again. */
+    alreadyPaid: boolean;
+}
+/** Cost breakdown for a route quote. */
+interface SmartRouteFeeBreakdown {
+    rawExecCost: number;
+    venueFees: number;
+    /**
+     * Builder fee in USD — the slice paid to a builder code rather than to the
+     * venue. Partners with their own builder code see their own rate here;
+     * everyone else sees the platform default. Excluded from `venueFees`,
+     * included in `totalCost`.
+     */
+    builderFee?: number;
+    /** Additional CH funding reserve for slippage or possible venue charges.
+     * Excluded from venueFees and totalCost; included in funding allocations.
+     * Only the unused portion is released after execution. */
+    executionReserve?: number;
+    bridgeFees: number;
+    executionGas: number;
+    totalCost: number;
+    /** Populated only when the request specified `deepEstimate=true`. */
+    setupCosts?: SmartRouteSetupCostLine[];
+    /** Sum of `setupCosts` entries where `alreadyPaid === false`. */
+    setupCostsTotal?: number;
+    /**
+     * Partner-level execution fee in USD. The worst-case fee the user will
+     * pay against the routed buy notional at quote time. Buy-side only —
+     * sell quotes don't carry this field.
+     *
+     * Actual collection happens after the trade fills, against realized
+     * notional (which may be less on partial fills). Partner UIs should
+     * render this as "you'll pay up to $X in app fees".
+     *
+     * Both `appFee` and `appFeeBips` are present iff `appFee > 0`.
+     */
+    appFee?: number;
+    /** Partner's configured bips for this market — the rate that produced `appFee`. */
+    appFeeBips?: number;
+    /** Category key the bips resolved against (e.g. "sports", or "all" for the fallback). */
+    appFeeCategory?: string;
+    /** The `executionGas` line when it is actually collected with the app fee. Present iff > 0; already inside `totalCost`. */
+    gasReimbursement?: number;
+    /** Referral fee the USER pays, in USD. Present iff > 0 and `referralPayer` is "user"; already inside `totalCostIncFees`. An app-paid referral never appears here. */
+    referralFee?: number;
+}
+/** Response from GET /orderbook/:venueMarketOutcomeId/route. */
+interface SmartRouteSettlementLeg {
+    action: "redeem";
+    venue: string;
+    venueMarketId: string;
+    venueMarketOutcomeId: string;
+    positionId: string;
+    size: string;
+    redeemPath: "evm" | "svm";
+}
+interface SmartRouteSettlementPlan {
+    redeemId: string;
+    status: "redeem_only" | "partial_redeem";
+    message: string;
+    totalRedeemableShares: number;
+    totalRedeemShares: number;
+    totalSellShares: number;
+    redeemLegs: SmartRouteSettlementLeg[];
+}
+/** Slippage metrics for the route. Mirrors `SmartRouteResponseTB.slippage`. */
+interface SmartRouteSlippage {
+    /** Volume-weighted average price. */
+    vwap: number;
+    /** Reference midpoint used by the optimizer. */
+    refMidpoint: number;
+    /** Route slippage = max(0, VWAP - refMidpoint). */
+    slippage: number;
+    /** Slippage in basis points relative to ref midpoint. */
+    slippageBps: number;
+}
+interface SmartRouteResponse {
+    quoteRefreshNotBefore?: string;
+    quoteFailure?: {
+        venue: string;
+        code: string;
+        retryAt?: string;
+    };
+    quoteId: string;
+    venueMarketOutcomeId: string;
+    venueMarketId: string;
+    estimatedCostRaw: string;
+    expiresAt: string;
+    /**
+     * Timestamp at which the quote begins to drift — frontends should refetch
+     * a fresh `getSmartRoute` at this point even though the cached quoteId
+     * remains executable until `expiresAt`. Always earlier than `expiresAt`.
+     */
+    refreshAt: string;
+    status: SmartRouteStatus;
+    fills: SmartRouteVenueFill[];
+    totalFilled: number;
+    rawExecCost: number;
+    solveTimeMs: number;
+    verifyTimeMs: number;
+    matchedMarkets: Array<{
+        venue: string;
+        venueMarketId: string;
+    }>;
+    error?: string;
+    message?: string;
+    settlementPlan?: SmartRouteSettlementPlan;
+    warnings?: Array<{
+        venue: string;
+        venueMarketOutcomeId: string;
+        reason: string;
+    }>;
+    venueSoloQuotes?: VenueSoloQuote[];
+    allocations?: SmartRouteAllocation[];
+    bridgeSteps?: SmartRouteBridgeStep[];
+    /**
+     * Route slippage metrics. Present on the wire (`SmartRouteResponseTB`) but
+     * missing from this mirror until now — `@agg-build/hooks` already reads
+     * `slippage.slippageBps` to flag thin liquidity.
+     */
+    slippage?: SmartRouteSlippage;
+    /** Estimated payout if the outcome wins (= totalFilled shares × $1, less
+     *  settlement fees — see `fills[].settlementFee`). */
+    estimatedPayout?: number;
+    /** Total cost including all fees (rawExecCost + venueFees + bridgeFees +
+     *  executionGas). For deep-estimate quotes, `setupCostsTotal` is folded
+     *  into this number and `estimatedProfit` / `returnPct` are recomputed
+     *  against it. */
+    totalCostIncFees?: number;
+    /** Estimated profit if the outcome wins (= estimatedPayout − totalCostIncFees). */
+    estimatedProfit?: number;
+    /** Return on investment percentage (= estimatedProfit / totalCostIncFees × 100). */
+    returnPct?: number;
+    /** Per-route fee breakdown. Always present when the engine produced a
+     *  feasible plan; omitted on solo / failed quotes. The `setupCosts` and
+     *  `setupCostsTotal` fields are populated only when the request set
+     *  `deepEstimate=true`. */
+    feeBreakdown?: SmartRouteFeeBreakdown;
+    /**
+     * Quote-time snapshot of the partner fee configuration that produced
+     * `feeBreakdown.appFee`, frozen so config drift between quote and execute
+     * cannot change what the user is charged.
+     *
+     * This is NOT the display number — that is `feeBreakdown.appFee`, in USD.
+     * This is the audit record: `quotedAppFeeRaw` is the worst-case charge in
+     * 6-decimal USD atoms, and is what a partner reconciles against their
+     * `AppFeeCharge` rows. `null` when the app has no fee configured.
+     */
+    appFee?: {
+        bips: number;
+        categoryKey: string;
+        quotedAppFeeRaw: string;
+    } | null;
+    /** Referral snapshot; null/absent when no referrer was accepted. */
+    referral?: {
+        referrer: string;
+        feeBips: number;
+        payer: "user" | "app";
+        payerAddress?: string;
+        quotedFeeUsd: number;
+    } | null;
+    /** Populated only when status === "insufficient_position". */
+    positionAvailability?: {
+        totalSellableShares: number;
+        venueMarketOutcomes: Array<{
+            id: string;
+            venue: string;
+            venueMarketId: string;
+            availableShares: number;
+        }>;
+    };
+    /** @deprecated Echoed only when the deprecated request-side override is provided. */
+    side?: SmartRouteSide;
+}
+interface CancelManagedExecutionResponse {
+    quoteId: string | null;
+    orderIds: string[];
+    status: "cancelled" | "cancel_pending";
+}
+type PositionRedeemStatus = "eligible" | "pending" | "redeemed" | "ineligible";
+type RedeemLegStatus = "submitted" | "confirmed" | "ineligible" | "rejected";
+interface RedeemLegResult {
+    venueMarketOutcomeId: string;
+    status: RedeemLegStatus;
+    callsId: string | null;
+    pendingUserOpId: string | null;
+    txHash: string | null;
+    reason: string | null;
+}
+interface RedeemRequest {
+    venueMarketOutcomeIds: string[];
+    /**
+     * Trading mode. Defaults to live, matching the other execution methods.
+     * Honoured on a live app; ignored on a paper app, which has no real-money
+     * path and always settles on paper.
+     */
+    mode?: ExecutionMode;
+}
+interface RedeemResponse {
+    redeemId: string;
+    results: RedeemLegResult[];
+}
+type SearchType = "events" | "markets";
+interface SearchParams {
+    mode?: "instant" | "full";
+    q: string;
+    type: SearchType;
+    categoryIds?: string[];
+    /**
+     * Filter results by status (e.g. `["open"]` for tradeable-only). Without
+     * it the server returns all statuses; recurring series ("BTC Up or Down -
+     * 5 Min") can then fill a page with resolved history, which a UI that
+     * hides non-open rows renders as an empty result.
+     */
+    status?: MarketStatus[];
+    limit?: number;
+    cursor?: string;
+    /**
+     * Opt in to the server-side reranker for higher-quality top results.
+     *
+     * Send `deep: true` for the final search-results page (submit / Enter) and
+     * leave it off for debounced typeahead. Adds ~100–150 ms on a cold rerank
+     * cache and ~3 ms on a warm one — typeahead can't afford the cold cost,
+     * and the result orderings differ enough that the server gives the two
+     * modes separate cache slots.
+     *
+     * Defaults to `false`.
+     */
+    deep?: boolean;
+}
+type SearchResponse<T> = {
+    meta?: {
+        complete?: boolean;
+        degradedSignals?: string[];
+    };
+    type: SearchType;
+    data: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+};
+interface NewsFeedPageOptions {
+    cursor?: string;
+    since?: string;
+    before?: string;
+    limit?: number;
+}
+interface NewsFeedMarketNewsParams {
+    venueMarketIds?: string[];
+    venueEventIds?: string[];
+    customQuery?: string;
+    tbs?: string;
+    limit?: number;
+}
+interface NewsFeedArticleWithSummary {
+    title: string;
+    url: string;
+    snippet: string;
+    source: string;
+    imageUrl: string | null;
+    publishedAt: string | null;
+    summary: string;
+    relevanceScore: number;
+}
+interface NewsFeedMarketNewsResult {
+    venueMarketId: string;
+    venueEventId: string;
+    question: string;
+    eventTitle: string;
+    category: string;
+    searchQuery: string;
+    timeRange: string;
+    timeRangeLabel: string;
+    articles: NewsFeedArticleWithSummary[];
+}
+interface NewsFeedMarketNewsResponse {
+    results: NewsFeedMarketNewsResult[];
+}
+interface NewsFeedLinkedMarket {
+    venueMarketId: string;
+    question: string;
+    venue: string;
+    yesPrice: number;
+    eventTitle: string;
+    eventId: string;
+    summary: string;
+    relevanceScore: number;
+}
+interface NewsFeedArticleFeedItem {
+    article: {
+        id: string;
+        title: string;
+        url: string;
+        snippet: string;
+        source: string;
+        imageUrl: string | null;
+        publishedAt: string | null;
+    };
+    markets: NewsFeedLinkedMarket[];
+    category: string;
+    id: string;
+    seq: number;
+    timestamp: string;
+}
+interface NewsFeedMarketFeedArticle {
+    title: string;
+    url: string;
+    source: string;
+    imageUrl: string | null;
+    publishedAt: string | null;
+    summary: string;
+    relevanceScore: number;
+    seq: number;
+    addedAt: string;
+}
+interface NewsFeedMarketFeedItem {
+    venueMarketId: string;
+    question: string;
+    venue: string;
+    yesPrice: number;
+    eventTitle: string;
+    eventId: string;
+    category: string;
+    articleCount: number;
+    articles: NewsFeedMarketFeedArticle[];
+}
+interface NewsFeedArticleFeedResponse {
+    data: NewsFeedArticleFeedItem[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface NewsFeedMarketFeedResponse {
+    data: NewsFeedMarketFeedItem[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface NewsFeedListResponse {
+    feeds: Array<{
+        id: string;
+        name: string;
+        itemCount: number;
+    }>;
+}
+interface NewsFeedStatusResponse {
+    articles: {
+        total: number;
+        today: number;
+    };
+    feedItems: {
+        total: number;
+        today: number;
+    };
+    perCategory: Array<{
+        category: string;
+        todayCount: number;
+        dailyLimit: number;
+    }>;
+    config: {
+        cronEnabled: boolean;
+        itemsPerDay: number;
+        batchSize: number;
+        categories: string[];
+    };
+}
+type CorrelatedMarketSide = "yes" | "no";
+type CorrelatedMarketSignalDirection = "more_likely" | "less_likely";
+interface CorrelatedMarketSignal {
+    id: string;
+    text: string;
+    side: CorrelatedMarketSide;
+    direction: CorrelatedMarketSignalDirection;
+    domain: string;
+}
+interface CorrelatedMarketSignalBatch {
+    id: string;
+    venueMarketId: string;
+    sourceModel: string;
+    promptVersion: number;
+    createdAt: string;
+    signals: CorrelatedMarketSignal[];
+}
+interface CorrelatedMarketsStatus {
+    markets: {
+        total: number;
+        processed: number;
+        coverage: number;
+    };
+    signals: {
+        total: number;
+        withEmbeddings: number;
+        missingEmbeddings: number;
+    };
+    eventTitleEmbeddings: {
+        total: number;
+        events: number;
+        coverage: number;
+    };
+    config: {
+        batchSize: number;
+        jobsEnabled: boolean;
+        backfillInterval: string;
+        reembedInterval: string;
+        eventEmbeddingInterval: string;
+    };
+}
+interface CorrelatedMarketQueryResult {
+    venueMarketId: string;
+    marketQuestion: string;
+    marketStatus: MarketStatus;
+    marketStartDate: string;
+    marketEndDate: string | null;
+    eventTitle: string;
+    eventStatus: MarketStatus;
+    eventStartDate: string;
+    eventEndDate: string | null;
+    score: number;
+    matchedSignal: CorrelatedMarketSignal;
+    matchSource: "signal" | "title_fallback";
+    venue: string;
+}
+interface CorrelatedMarketCascadeItem {
+    venueEventId: string;
+    eventTitle: string;
+    eventStatus: MarketStatus;
+    eventStartDate: string;
+    eventEndDate: string | null;
+    score: number;
+    action: string;
+    reason: string;
+    reasonDomain: string;
+}
+interface CorrelatedMarketCascadeResponse {
+    data: CorrelatedMarketCascadeItem[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+interface ResolveCorrelatedMarketsParams {
+    venue?: string;
+    externalId?: string;
+    slug?: string;
+    conditionId?: string;
+    q?: string;
+    side?: CorrelatedMarketSide;
+    mode?: "expand" | "hedge";
+    limit?: number;
+    cursor?: string;
+    includeResolved?: boolean;
+}
+type ResolveCorrelatedMarketsResponse = ({
+    market: {
+        id: string;
+        question: string;
+    };
+} & CorrelatedMarketCascadeResponse) | {
+    market: {
+        id: string;
+        question: string;
+    };
+    status: "processing";
+    message: string;
+};
+interface ResolvedCorrelatedMarketsResponse extends CorrelatedMarketCascadeResponse {
+    market: {
+        id: string;
+        question: string;
+    };
+}
+/** Display-first event navigation payload; market pages remain cursor paginated. */
+interface EventBootstrapResponse {
+    detailsDeferred: true;
+    event: VenueEvent;
+    markets: PaginatedResponse<VenueMarket>;
+    selectedOutcomeIds: string[];
+    references: {
+        historyManifestPath: "/charts/history/manifest";
+        liveChannel: "orderbook";
+    };
+    freshness: {
+        assembledAt: number;
+        marketStatus: "open" | null;
+    };
+}
+
+type MarketSubscription = {
+    id: string;
+    channel: "orderbook" | "trades" | "arb" | "arb-feed";
+};
+type CandleTail = Record<CandleInterval, {
+    forming: Candle | null;
+    closed: Candle[];
+}>;
+interface MarketView {
+    revision: number;
+    integrity: "ok" | "resyncing";
+    outcomeId: string;
+    book: OrderbookState | null;
+    snapshot: boolean;
+    candles: CandleTail;
+    trades: WsTrade[];
+    receivedAtMs: number;
+}
+interface MarketViewBatch {
+    generation: number;
+    views: MarketView[];
+    publishedAtMs: number;
+}
+type EngineEvent = {
+    name: keyof AggWebSocketCallbacks;
+    args: unknown[];
+    revision: number;
+};
+interface HistoryRangeRequest {
+    key: string;
+    generation: number;
+    url: string;
+    headers?: Record<string, string>;
+}
+/** Framework-independent processing. The native worker and replay tests run this exact engine. */
+declare class MarketDataEngine {
+    private socket;
+    private generation;
+    private receivedAtMs;
+    private revision;
+    private deliveredClosed;
+    private subscriptions;
+    private builders;
+    private dirty;
+    private observer?;
+    private timer?;
+    private inFlight;
+    private deliveryToken;
+    private cancelDelivery?;
+    private disposed;
+    private history;
+    private measurements;
+    start(options: Omit<AggWebSocketOptions, "callbacks">, event: (event: EngineEvent) => void): void;
+    observeViews(observer: (batch: MarketViewBatch) => Promise<void> | void): void;
+    setSubscriptions(subscriptions: MarketSubscription[], generation: number): void;
+    authenticate(token: string): void;
+    resnapshot(ids: string[]): void;
+    connect(): void;
+    disconnect(): void;
+    resume(): void;
+    getMeasurements(): {
+        activeSubscriptions: number;
+        activeOutcomes: number;
+        cachedBooks: number;
+        builders: number;
+        historyTasks: number;
+        pendingOutcomes: number;
+        inFlightDeliveries: number;
+        retainedCandleOutcomes: number;
+        socket: AggWebSocketDiagnostics | null;
+        received: number;
+        published: number;
+        coalesced: number;
+        maxPendingOutcomes: number;
+        maxInFlight: number;
+    };
+    decodeHistory(payload: string): ChartBarsResponse;
+    /** Fetch/decode on the processing side; newer range generations abort obsolete fetches. */
+    loadHistoryRange(request: HistoryRangeRequest): Promise<ChartBarsResponse | null>;
+    loadImmutableRange(key: string, generation: number, manifest: ChartHistoryManifest): Promise<ChartCandle[]>;
+    cancelHistoryRange(key: string, generation?: number): void;
+    dispose(): void;
+    private builder;
+    private mark;
+    private schedule;
+    private publish;
+}
+
+interface AggWebSocketCallbacks {
+    /** Local receipt clock, distinct from venue/source timestamps. */
+    onFrameReceived?: (receivedAtMs: number) => void;
+    /** Pre-accumulated live views from the optional processing engine. */
+    onMarketView?: (view: MarketView) => void;
+    /** Invoked with the venueMarketOutcomeId the snapshot belongs to. */
+    onSnapshot?: (outcomeId: string, book: OrderbookState) => void;
+    /** Invoked with the venueMarketOutcomeId the delta belongs to. */
+    onDelta?: (outcomeId: string, book: OrderbookState) => void;
+    onTrade?: (trade: WsTrade) => void;
+    /** Every validated update, before optional view batching. Timestamps are seconds. */
+    onBookTick?: (outcomeId: string, tick: {
+        midpoint: number | null;
+        timestamp: number;
+        source: "snapshot" | "delta";
+    }) => void;
+    onHeartbeat?: (hb: WsHeartbeat) => void;
+    onSubscribed?: (msg: WsSubscribed) => void;
+    onUnsubscribed?: (msg: WsUnsubscribed) => void;
+    onConnected?: (msg: WsConnected) => void;
+    onAuthenticated?: (msg: WsAuthenticated) => void;
+    onMarketResolved?: (msg: WsMarketResolved) => void;
+    onError?: (msg: WsError) => void;
+    onOrderSubmitted?: (msg: WsOrderSubmitted) => void;
+    onBalanceUpdate?: (msg: WsBalanceUpdate) => void;
+    onOrderEvent?: (msg: WsOrderEvent) => void;
+    onRedeemEvent?: (msg: WsRedeemEvent) => void;
+    onWithdrawalLifecycle?: (msg: WsWithdrawalLifecycleEvent) => void;
+    onArbMarket?: (msg: WsArbMarketUpdate) => void;
+    onArbFeed?: (batch: WsArbFeedBatch) => void;
+    onDiagnostics?: DiagnosticCallback;
+    onConnectionStateChange?: (connected: boolean) => void;
+}
+interface AggWebSocketDiagnostics {
+    connected: boolean;
+    transport: "direct" | "worker" | "disposed";
+    orderbookOutcomeIds: string[];
+    tradeOutcomeIds: string[];
+    arbMarketIds: string[];
+    arbFeedSubscribers: number;
+    cachedBooks: number;
+    cachedArb: number;
+    resyncingBooks: number;
+    pendingResnapshots: number;
+    pendingHistoryRequests: number;
+    workerAttached?: boolean;
+    bridgeListeners?: number;
+    host?: Record<string, unknown>;
+}
+interface AggWebSocketOptions {
+    /** Full WebSocket URL including query params (appId). Token should NOT be in the URL. */
+    url: string;
+    callbacks?: AggWebSocketCallbacks;
+    /** JWT to send via the authenticate message after connecting (avoids token in URL/logs). */
+    initialToken?: string;
+    /** Enable websocket debug logs. Default: false. */
+    enableLogs?: boolean;
+    /** Engine-only: read immutable books through getBook at presentation cadence. */
+    deferBookViews?: boolean;
+}
+/**
+ * Agg WebSocket client. Single WS connection with refcounted market subscriptions.
+ */
+declare class AggWebSocket {
+    private ws;
+    private readonly url;
+    private callbacks;
+    private readonly subs;
+    private readonly pendingSubs;
+    private readonly pendingTradeSubs;
+    private readonly pendingResnapshots;
+    private readonly pendingFlushSubs;
+    private readonly pendingFlushUnsubs;
+    private readonly pendingFlushTradeSubs;
+    private readonly pendingFlushTradeUnsubs;
+    private readonly pendingFlushArbSubs;
+    private readonly pendingFlushArbUnsubs;
+    private flushScheduled;
+    private readonly arbSubs;
+    private readonly arbFeedCbs;
+    /** Latest arb market update per marketId (last-value-wins, loss-tolerant). */
+    private readonly latestArb;
+    private readonly books;
+    private readonly deferBookViews;
+    /** Markets currently resyncing (awaiting snapshot after seq gap / checksum mismatch). */
+    private readonly resyncing;
+    private connecting;
+    private _connected;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private staleTimer;
+    private lastMessageTime;
+    private destroyed;
+    private historyControllers;
+    private hostDiagnostics?;
+    private initialToken?;
+    private readonly enableLogs;
+    constructor(options: AggWebSocketOptions);
+    get connected(): boolean;
+    /** Decode dynamic authenticated REST bytes in the same processing environment as live data. */
+    decodeHistory(payload: string): Promise<ChartBarsResponse>;
+    /** Immutable history decoder. Browser adapters execute this inside their Worker. */
+    loadHistory(manifest: ChartHistoryManifest, options?: {
+        signal?: AbortSignal;
+    }): Promise<ChartCandle[]>;
+    /** Optional framework-independent host diagnostics, cleared on disposal. */
+    setHostDiagnostics(provider?: () => Record<string, unknown>): void;
+    /** On-demand ownership diagnostics; contains no credentials or user/account data. */
+    getDiagnostics(): AggWebSocketDiagnostics;
+    /** Get the current orderbook state for an outcome (or null if no snapshot received yet). */
+    getBook(outcomeId: string): OrderbookState | null;
+    /** Whether an outcome is currently resyncing (waiting for fresh snapshot). */
+    isResyncing(outcomeId: string): boolean;
+    /** Get the latest arb update for a market (or null if none received yet). */
+    getArb(marketId: string): WsArbMarketUpdate | null;
+    /**
+     * Subscribe to per-market arb updates for a given marketId.
+     * Ref-counted: multiple callers for the same marketId share one server subscription.
+     * Returns an unsubscribe function.
+     */
+    subscribeArb(marketId: string, cb: (m: WsArbMarketUpdate) => void): () => void;
+    /**
+     * Subscribe to the global arb-feed batches.
+     * Only one server subscription is maintained regardless of how many callers.
+     * Returns an unsubscribe function.
+     */
+    subscribeArbFeed(cb: (b: WsArbFeedBatch) => void): () => void;
+    /**
+     * Subscribe to a feed by outcome ID.
+     * @param outcomeId  The venueMarketOutcomeId to subscribe to.
+     * @param channel    "orderbook" (default) or "trades".
+     * Returns an unsubscribe function (ref-counted).
+     */
+    subscribe(outcomeId: string, channel?: "orderbook" | "trades"): () => void;
+    /**
+     * Subscribe to an outcome's trade feed.
+     * @deprecated Use `subscribe(outcomeId, "trades")` instead.
+     * Returns an unsubscribe function.
+     */
+    subscribeTrades(outcomeId: string): () => void;
+    private _subscribeTrades;
+    /** Send a JWT to authenticate (or re-authenticate) the connection. */
+    authenticate(token: string): void;
+    /** Request a fresh snapshot for one or more subscribed outcomes. */
+    resnapshot(outcomeIdOrIds: string | string[]): void;
+    /** Connect (idempotent). Called automatically on first subscribe. */
+    connect(): void;
+    /** Disconnect and clean up. Reusable — call connect() to reconnect. */
+    disconnect(): void;
+    /** Permanently destroy. Cannot reconnect after this. */
+    destroy(): void;
+    /** Update callbacks (e.g., after React re-render). */
+    setCallbacks(callbacks: AggWebSocketCallbacks): void;
+    private ensureConnected;
+    private doConnect;
+    private scheduleReconnect;
+    private cancelReconnect;
+    private resetStaleTimer;
+    private cancelStaleTimer;
+    private handleMessage;
+    /**
+     * Server confirmed the connection — gateway has validated our appId and is
+     * ready to accept subscriptions. Now flush all pending subs.
+     */
+    private handleConnected;
+    private handleSnapshot;
+    private handleDelta;
+    private handleTrade;
+    private handleHeartbeat;
+    private handleMarketResolved;
+    private handleOrderSubmitted;
+    private handleBalanceUpdate;
+    private handleRedeemEvent;
+    private requestResnapshot;
+    /**
+     * Schedule a microtask that flushes queued subscribe/unsubscribe frames.
+     * Coalesces multiple same-tick sub/unsub calls into at most one frame per
+     * channel+action pair.
+     */
+    private scheduleFlush;
+    private flushPending;
+    private sendSubscribe;
+    private send;
+    private activeOrderbookMarkets;
+    private activeTradeMarkets;
+    private activeArbMarkets;
+    private emitDiagnostic;
+    private summarizeTopLevels;
+    private debugOrderbook;
+    private isOrderbookDebugEnabled;
+}
+
+export { type SetPaperTradingBalanceParams as $, AggWebSocket as A, type ExecutionStatusQuery as B, type ChartBarsResponse as C, type ExecutionStatusResponse as D, type ExecutionOrdersQuery as E, type UserActivityQuery as F, type UserActivityItem as G, type ExecutionPositionsQuery as H, type ExecutionPositionGroup as I, type ManagedBalancesParams as J, type UnifiedBalanceResponse as K, type UpsertVenueKey as L, MarketDataEngine as M, type VenueKeySummary as N, type OrderbookState as O, type PaginatedResponse as P, type VenueKeyStatus as Q, type CreatePaperTradingAccountParams as R, type SiweMessageParams as S, type TradeSplit as T, type UserProfile as U, Venue as V, type WsArbMarketUpdate as W, type PaperTradingAppOptions as X, type PaperTradingAccount as Y, type PaperTradingAccountListParams as Z, type PaperTradingAccountsPage as _, type AggWebSocketOptions as a, type SyncBalancesResponse as a$, type PaperTradingBalanceResponse as a0, type ResetPaperTradingAccountParams as a1, type PlacePaperTradingOrderParams as a2, type PaperTradingOrder as a3, type PaperTradingListParams as a4, type PaperTradingPositionsPage as a5, type PaperTradingOrdersPage as a6, type PaperTradingPortfolio as a7, type CancelOrderSignature as a8, type CancelManagedExecutionResponse as a9, type CorrelatedMarketCascadeResponse as aA, type ResolveCorrelatedMarketsParams as aB, type ResolveCorrelatedMarketsResponse as aC, type ChartResolution as aD, type BatchOrderbooksResponse as aE, type BatchMidpointsResponse as aF, type OutcomeOrderbookResponse as aG, type SmartRouteParams as aH, type SmartRouteResponse as aI, type ExecuteManagedParams as aJ, type ExecuteManagedResponse as aK, type PlaceLimitOrderParams as aL, type PlaceLimitOrderResponse as aM, type PlaceOrderParams as aN, type PlaceOrderResponse as aO, type RedeemRequest as aP, type RedeemResponse as aQ, type BalanceRefillPolicy as aR, type CreateBalanceRefillPolicyParams as aS, type UpdateBalanceRefillPolicyParams as aT, type BalanceRefillAttempt as aU, type WithdrawManagedParams as aV, type WithdrawManagedResponse as aW, type WithdrawPreviewParams as aX, type WithdrawPreviewResponse as aY, type WithdrawalQuoteParams as aZ, type WithdrawalQuoteResponse as a_, MatchStatus as aa, MarketStatus as ab, type RecurrenceFilter as ac, type VenueEvent as ad, type EventBootstrapResponse as ae, type SportsLiveResponse as af, type ListRecurringCryptoMarketsOptions as ag, type RecurringCryptoMarketsResponse as ah, type GetCryptoReferencePricesOptions as ai, type CryptoReferencePricesResponse as aj, type Category as ak, type AppClientConfigResponse as al, type VenueGeoPolicyResponse as am, type RpcTokenResponse as an, type NewsFeedListResponse as ao, type NewsFeedPageOptions as ap, type NewsFeedArticleFeedResponse as aq, type NewsFeedMarketFeedResponse as ar, type NewsFeedStatusResponse as as, type NewsFeedMarketNewsParams as at, type NewsFeedMarketNewsResponse as au, type SearchParams as av, type SearchResponse as aw, type CorrelatedMarketsStatus as ax, type CorrelatedMarketSignalBatch as ay, type CorrelatedMarketQueryResult as az, type ChartHistoryManifest as b, type ExecutionDisplayGroupStatus as b$, type DepositAddressesResponse as b0, type GetPositionsParams as b1, type PositionGroup as b2, type RampQuoteRequest as b3, type RampQuote as b4, type RampSessionRequest as b5, type RampWidgetSession as b6, type Candle as b7, ACTIVE_VENUES as b8, type Account as b9, type ChartBarsMeta as bA, type ChartVenueCandles as bB, type ComputeSplitsRequest as bC, type ComputeSplitsResponse as bD, type ComputeSplitsSelection as bE, type CorrelatedMarketCascadeItem as bF, type CorrelatedMarketSide as bG, type CorrelatedMarketSignal as bH, type CorrelatedMarketSignalDirection as bI, type CreateApp as bJ, type CryptoReferencePriceError as bK, type CryptoReferencePriceExternalMarketInput as bL, type CryptoReferencePriceMarketInput as bM, type CryptoReferencePriceResult as bN, type CryptoReferencePriceSource as bO, type CryptoReferencePriceTarget as bP, type DepositAddressesPendingResponse as bQ, type DepositAddressesReadyResponse as bR, type DepositAddressesSupportedChain as bS, type DepositAddressesToken as bT, type DepositStep as bU, type DiagnosticCallback as bV, type DiagnosticEvent as bW, type ExecuteManagedRequest as bX, type ExecuteTradeRequest as bY, type ExecuteTradeResponse as bZ, type ExecutionDagProgress as b_, AccountProvider as ba, AccountType as bb, type AggAuthDeliveryMode as bc, type AggAuthPrivyVerifyBody as bd, type AggAuthProviderType as be, type AggAuthWalletVerifyBody as bf, type AggClientAuthOptions as bg, type AggSessionUser as bh, type AggregatedOrderbookLevel as bi, type AggregatedOrderbookResponse as bj, type App as bk, type AppTradingMode as bl, type AttributedOrderbook as bm, type AttributedOrderbookLevel as bn, type AuthCodeResponse as bo, type AuthTokenResponse as bp, type AuthUser as bq, type BalanceCustody as br, type BalanceRefillAttemptStatus as bs, type BalanceRefillPolicyStatus as bt, type BookQuality as bu, CONFIRMED_MATCH_STATUSES as bv, CandleBuilder as bw, type CandleInterval as bx, type CandleTail as by, Chain as bz, type ChartCandle as c, type RecurringCryptoComparisonPriceSource as c$, type ExecutionDisplayStepKind as c0, type ExecutionMode as c1, type ExecutionOverallState as c2, type ExecutionStatusOrder as c3, type ExecutionStatusStep as c4, type GetBalanceQuery as c5, type GetBalanceResponse as c6, type GetHoldingsQuery as c7, type GetHoldingsResponse as c8, type GetOrdersParams as c9, OrderType as cA, type OrderbookBatchItemError as cB, type OrderbookBatchItemErrorCode as cC, type OrderbookBatchItemStatus as cD, type OrderbookHistoryPoint as cE, type OrderbookHistoryResponse as cF, type OrderbookLevel as cG, type OrderbookQuoteFill as cH, type OrderbookQuoteParams as cI, type OrderbookQuoteResponse as cJ, type OrderbookServiceUnavailableError as cK, type OrderbooksOnlyError as cL, type OutcomeMidpoint as cM, type OutcomeMidpointRow as cN, type PaperTradingBalanceAdjustment as cO, type PaperTradingLiquidityStatus as cP, type PaperTradingMarkSource as cQ, type PaperTradingPosition as cR, type PersistedAuthSnapshot as cS, type PositionRedeemStatus as cT, type PricePoint as cU, type PriceSource as cV, type PricesHistoryResponse as cW, type ProphetxExecutionMode as cX, RECURRENCE_CADENCES as cY, type RecurrenceCadence as cZ, type RecurringCryptoComparisonPoint as c_, type GetOrdersQuery as ca, type GetPositionsQuery as cb, type HelloResponse as cc, type HistoryRangeRequest as cd, INACTIVE_VENUES as ce, type LimitOrderTimeInForce as cf, type MarkSource as cg, type MarketPriceHistory as ch, type MarketView as ci, type MarketViewBatch as cj, MatchType as ck, type MatchedMidpoint as cl, type MatchedMidpointOutcome as cm, type MatchedOrderbookMarket as cn, type MatchedVenueMarketOutcomeRef as co, type MidpointItem as cp, type MidpointRow as cq, type NewsFeedArticleFeedItem as cr, type NewsFeedArticleWithSummary as cs, type NewsFeedLinkedMarket as ct, type NewsFeedMarketFeedArticle as cu, type NewsFeedMarketFeedItem as cv, type NewsFeedMarketNewsResult as cw, type NonceResponse as cx, type OrderListItem as cy, OrderStatus as cz, type AggWebSocketDiagnostics as d, type ValidateTradeResponse as d$, type RecurringCryptoDuration as d0, type RecurringCryptoDurationInput as d1, type RecurringCryptoMarketMetrics as d2, type RecurringCryptoOrderbookDepthLevel as d3, type RecurringCryptoOrderbookDepthSide as d4, type RecurringCryptoOutcome as d5, type RecurringCryptoOutcomeOrderbookDepth as d6, type RecurringCryptoPriceComparison as d7, type RecurringCryptoReferencePrice as d8, type RecurringCryptoResolution as d9, type SmartRouteSettlementPlan as dA, type SmartRouteSetupCostLine as dB, type SmartRouteSide as dC, type SmartRouteStatus as dD, type SmartRouteVenueFill as dE, type SportsGameStatus as dF, type SportsLiveParticipant as dG, type SportsLiveState as dH, TERMINAL_EXECUTION_STATES as dI, TimeInForce as dJ, type TradeExecutorOrder as dK, type TradeStep as dL, type UserActivityBridge as dM, type UserActivityDeposit as dN, type UserActivityRedeem as dO, type UserActivityRedeemLeg as dP, type UserActivityTrade as dQ, type UserActivityType as dR, type UserActivityUserOp as dS, type UserActivityWithdrawal as dT, VENUES as dU, VENUE_CHAIN_IDS as dV, type ValidateBalanceOnClientStep as dW, type ValidateManagedParams as dX, type ValidateManagedRequest as dY, type ValidateManagedResponse as dZ, type ValidateTradeRequest as d_, type RecurringCryptoSourceConfidence as da, type RecurringCryptoVenueMarket as db, type RecurringCryptoWindowComparisons as dc, type RecurringCryptoWindowMarket as dd, type RedeemLegResult as de, type RedeemLegStatus as df, type RequestedOrderbookMarket as dg, type ResolvedCorrelatedMarketsResponse as dh, SELF_CUSTODY_FILL_TIMEOUT_MS as di, SELF_CUSTODY_POLL_INTERVAL_MS as dj, type ServerWallet as dk, type SettlementDiff as dl, type SettlementDifference as dm, type SettlementSource as dn, type SetupDepositAddressStep as dp, type SetupVenueKeyStep as dq, type SignatureRequest as dr, type SignatureRequestType as ds, type SignerFn as dt, type SimpleOrderbookLevel as du, type SmartRouteAllocation as dv, type SmartRouteBridgeStep as dw, type SmartRouteFeeBreakdown as dx, type SmartRouteFill as dy, type SmartRouteSettlementLeg as dz, type WsArbFeedBatch as e, type VenueEventListItem as e0, type VenueEventWithMarkets as e1, type VenueGeoPolicyEntry as e2, type VenueMarketListItem as e3, type VenueMarketRef as e4, type VenueOrderbookEntry as e5, type VenueOrderbookLevel as e6, type VenuePositionBalance as e7, type VenuePriceInfo as e8, type VenueSoloQuote as e9, type WsMarketResolved as eA, type WsOrderEvent as eB, type WsOrderEventType as eC, type WsOrderSubmitted as eD, type WsOrderbookDelta as eE, type WsOrderbookSnapshot as eF, type WsRedeemEvent as eG, type WsServerMessage as eH, type WsSubscribed as eI, type WsTrade as eJ, type WsUnsubscribed as eK, type WsVenueBook as eL, type WsVenueInfo as eM, type WsVenueLevel as eN, type WsWithdrawalLegStatus as eO, type WsWithdrawalLifecycleEvent as eP, type WsWithdrawalLifecycleLeg as eQ, type WsWithdrawalLifecycleStatus as eR, applyOrderbookDelta as eS, computeChecksum as eT, getEffectiveDisabledVenues as eU, isVenueActive as eV, isVenueDataVisible as eW, isVenueInactive as eX, snapshotToOrderbook as eY, type VerifyBody as ea, type VerifyResponse as eb, type WalletChainBalance as ec, type WalletTokenBalance as ed, type WithdrawManagedRequest as ee, type WithdrawManagedSourceItem as ef, type WithdrawTokenSymbol as eg, type WithdrawalExpected as eh, type WithdrawalLeg as ei, type WithdrawalLegStatus as ej, type WithdrawalLegType as ek, type WithdrawalLifecycleStatus as el, type WithdrawalSource as em, type WithdrawalSourceItem as en, type WithdrawalSourceStatus as eo, type WithdrawalSourceTokenSymbol as ep, type WsArbFeedEntry as eq, type WsAttributedLevel as er, type WsAuthenticated as es, type WsBalanceUpdate as et, type WsCandleInterval as eu, type WsClientMessage as ev, type WsConnected as ew, type WsError as ex, type WsHeartbeat as ey, type WsMarkSource as ez, type AggWebSocketCallbacks as f, type VenueMarket as g, type VenueMarketOutcome as h, type Orderbook as i, TradeSide$1 as j, type AggClientOptions as k, type AggClientSessionInput as l, type AuthStatus as m, type SiwsMessageParams as n, type AggAuthVerifyBody as o, type AggAuthStartBody as p, type AggAuthStartResult as q, type AggLinkAccountBody as r, type AggLinkAccountResult as s, type AggLinkAccountWalletConfirmBody as t, type AggLinkAccountConfirmResult as u, type UpdateUserBody as v, type UserHolding as w, type OrderListQuery as x, type TradeExecutorOrderListResponse as y, type ExecutionOrderItem as z };