@agg-build/sdk 4.17.4 → 4.19.0

package/dist/agg-websocket-CE7v1_-O.d.mts

@@ -0,0 +1,4358 @@
+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 CancelVenueOrderParams {
+    venue: "polymarket" | "hyperliquid";
+    venueOrderId: string;
+    signerAddress: string;
+    cancelSignature: CancelOrderSignature;
+}
+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;
+}
+/** Column a leaderboard is ranked by. */
+type LeaderboardMetric = "realizedPnl" | "volume";
+interface LeaderboardQuery {
+    /** Inclusive UTC calendar day, `YYYY-MM-DD`. Omit both for all time. */
+    from?: string;
+    /** Inclusive UTC calendar day, `YYYY-MM-DD`. */
+    to?: string;
+    /** Default `realizedPnl`. */
+    metric?: LeaderboardMetric;
+    /** 1..100, default 50. */
+    limit?: number;
+    cursor?: string;
+}
+interface LeaderboardRow {
+    /** Exact within the top 100, `null` beyond. */
+    rank: number | null;
+    userId: string;
+    /** Null unless the app's `leaderboardIdentity` is `profile`. */
+    username: string | null;
+    /** Null unless the app's `leaderboardIdentity` is `profile`. */
+    avatarUrl: string | null;
+    /** Null under `anonymous`; primary wallet under `wallet` or `profile`. */
+    walletAddress: string | null;
+    /** Filled orders in the range. */
+    orders: number;
+    /** USD notional of every filled order in the range, buys and sells. */
+    volume: number;
+    /** USD notional of filled buy orders only — what the trader put in. */
+    spent: number;
+    /** Gross realized P&L in USD (sells + settlements, before fees). */
+    realizedPnl: 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 PaperTradingAccountListParams 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 LeaderboardRow as H, type ExecutionPositionsQuery as I, type ExecutionPositionGroup as J, type ManagedBalancesParams as K, type LeaderboardQuery as L, MarketDataEngine as M, type UnifiedBalanceResponse as N, type OrderbookState as O, type PaginatedResponse as P, type UpsertVenueKey as Q, type VenueKeySummary as R, type SiweMessageParams as S, type TradeSplit as T, type UserProfile as U, Venue as V, type WsArbMarketUpdate as W, type VenueKeyStatus as X, type CreatePaperTradingAccountParams as Y, type PaperTradingAppOptions as Z, type PaperTradingAccount as _, type AggWebSocketOptions as a, type WithdrawPreviewResponse as a$, type PaperTradingAccountsPage as a0, type SetPaperTradingBalanceParams as a1, type PaperTradingBalanceResponse as a2, type ResetPaperTradingAccountParams as a3, type PlacePaperTradingOrderParams as a4, type PaperTradingOrder as a5, type PaperTradingListParams as a6, type PaperTradingPositionsPage as a7, type PaperTradingOrdersPage as a8, type PaperTradingPortfolio as a9, type CorrelatedMarketsStatus as aA, type CorrelatedMarketSignalBatch as aB, type CorrelatedMarketQueryResult as aC, type CorrelatedMarketCascadeResponse as aD, type ResolveCorrelatedMarketsParams as aE, type ResolveCorrelatedMarketsResponse as aF, type ChartResolution as aG, type BatchOrderbooksResponse as aH, type BatchMidpointsResponse as aI, type OutcomeOrderbookResponse as aJ, type SmartRouteParams as aK, type SmartRouteResponse as aL, type ExecuteManagedParams as aM, type ExecuteManagedResponse as aN, type PlaceLimitOrderParams as aO, type PlaceLimitOrderResponse as aP, type PlaceOrderParams as aQ, type PlaceOrderResponse as aR, type RedeemRequest as aS, type RedeemResponse as aT, type BalanceRefillPolicy as aU, type CreateBalanceRefillPolicyParams as aV, type UpdateBalanceRefillPolicyParams as aW, type BalanceRefillAttempt as aX, type WithdrawManagedParams as aY, type WithdrawManagedResponse as aZ, type WithdrawPreviewParams as a_, type CancelOrderSignature as aa, type CancelManagedExecutionResponse as ab, type CancelVenueOrderParams as ac, MatchStatus as ad, MarketStatus as ae, type RecurrenceFilter as af, type VenueEvent as ag, type EventBootstrapResponse as ah, type SportsLiveResponse as ai, type ListRecurringCryptoMarketsOptions as aj, type RecurringCryptoMarketsResponse as ak, type GetCryptoReferencePricesOptions as al, type CryptoReferencePricesResponse as am, type Category as an, type AppClientConfigResponse as ao, type VenueGeoPolicyResponse as ap, type RpcTokenResponse as aq, type NewsFeedListResponse as ar, type NewsFeedPageOptions as as, type NewsFeedArticleFeedResponse as at, type NewsFeedMarketFeedResponse as au, type NewsFeedStatusResponse as av, type NewsFeedMarketNewsParams as aw, type NewsFeedMarketNewsResponse as ax, type SearchParams as ay, type SearchResponse as az, type ChartHistoryManifest as b, type ExecuteTradeRequest as b$, type WithdrawalQuoteParams as b0, type WithdrawalQuoteResponse as b1, type SyncBalancesResponse as b2, type DepositAddressesResponse as b3, type GetPositionsParams as b4, type PositionGroup as b5, type RampQuoteRequest as b6, type RampQuote as b7, type RampSessionRequest as b8, type RampWidgetSession as b9, type CandleInterval as bA, type CandleTail as bB, Chain as bC, type ChartBarsMeta as bD, type ChartVenueCandles as bE, type ComputeSplitsRequest as bF, type ComputeSplitsResponse as bG, type ComputeSplitsSelection as bH, type CorrelatedMarketCascadeItem as bI, type CorrelatedMarketSide as bJ, type CorrelatedMarketSignal as bK, type CorrelatedMarketSignalDirection as bL, type CreateApp as bM, type CryptoReferencePriceError as bN, type CryptoReferencePriceExternalMarketInput as bO, type CryptoReferencePriceMarketInput as bP, type CryptoReferencePriceResult as bQ, type CryptoReferencePriceSource as bR, type CryptoReferencePriceTarget as bS, type DepositAddressesPendingResponse as bT, type DepositAddressesReadyResponse as bU, type DepositAddressesSupportedChain as bV, type DepositAddressesToken as bW, type DepositStep as bX, type DiagnosticCallback as bY, type DiagnosticEvent as bZ, type ExecuteManagedRequest as b_, type Candle as ba, ACTIVE_VENUES as bb, type Account as bc, AccountProvider as bd, AccountType as be, type AggAuthDeliveryMode as bf, type AggAuthPrivyVerifyBody as bg, type AggAuthProviderType as bh, type AggAuthWalletVerifyBody as bi, type AggClientAuthOptions as bj, type AggSessionUser as bk, type AggregatedOrderbookLevel as bl, type AggregatedOrderbookResponse as bm, type App as bn, type AppTradingMode as bo, type AttributedOrderbook as bp, type AttributedOrderbookLevel as bq, type AuthCodeResponse as br, type AuthTokenResponse as bs, type AuthUser as bt, type BalanceCustody as bu, type BalanceRefillAttemptStatus as bv, type BalanceRefillPolicyStatus as bw, type BookQuality as bx, CONFIRMED_MATCH_STATUSES as by, CandleBuilder as bz, type ChartCandle as c, type ProphetxExecutionMode as c$, type ExecuteTradeResponse as c0, type ExecutionDagProgress as c1, type ExecutionDisplayGroupStatus as c2, type ExecutionDisplayStepKind as c3, type ExecutionMode as c4, type ExecutionOverallState as c5, type ExecutionStatusOrder as c6, type ExecutionStatusStep as c7, type GetBalanceQuery as c8, type GetBalanceResponse as c9, type NewsFeedMarketNewsResult as cA, type NonceResponse as cB, type OrderListItem as cC, OrderStatus as cD, OrderType as cE, type OrderbookBatchItemError as cF, type OrderbookBatchItemErrorCode as cG, type OrderbookBatchItemStatus as cH, type OrderbookHistoryPoint as cI, type OrderbookHistoryResponse as cJ, type OrderbookLevel as cK, type OrderbookQuoteFill as cL, type OrderbookQuoteParams as cM, type OrderbookQuoteResponse as cN, type OrderbookServiceUnavailableError as cO, type OrderbooksOnlyError as cP, type OutcomeMidpoint as cQ, type OutcomeMidpointRow as cR, type PaperTradingBalanceAdjustment as cS, type PaperTradingLiquidityStatus as cT, type PaperTradingMarkSource as cU, type PaperTradingPosition as cV, type PersistedAuthSnapshot as cW, type PositionRedeemStatus as cX, type PricePoint as cY, type PriceSource as cZ, type PricesHistoryResponse as c_, type GetHoldingsQuery as ca, type GetHoldingsResponse as cb, type GetOrdersParams as cc, type GetOrdersQuery as cd, type GetPositionsQuery as ce, type HelloResponse as cf, type HistoryRangeRequest as cg, INACTIVE_VENUES as ch, type LeaderboardMetric as ci, type LimitOrderTimeInForce as cj, type MarkSource as ck, type MarketPriceHistory as cl, type MarketView as cm, type MarketViewBatch as cn, MatchType as co, type MatchedMidpoint as cp, type MatchedMidpointOutcome as cq, type MatchedOrderbookMarket as cr, type MatchedVenueMarketOutcomeRef as cs, type MidpointItem as ct, type MidpointRow as cu, type NewsFeedArticleFeedItem as cv, type NewsFeedArticleWithSummary as cw, type NewsFeedLinkedMarket as cx, type NewsFeedMarketFeedArticle as cy, type NewsFeedMarketFeedItem as cz, type AggWebSocketDiagnostics as d, type ValidateManagedParams as d$, RECURRENCE_CADENCES as d0, type RecurrenceCadence as d1, type RecurringCryptoComparisonPoint as d2, type RecurringCryptoComparisonPriceSource as d3, type RecurringCryptoDuration as d4, type RecurringCryptoDurationInput as d5, type RecurringCryptoMarketMetrics as d6, type RecurringCryptoOrderbookDepthLevel as d7, type RecurringCryptoOrderbookDepthSide as d8, type RecurringCryptoOutcome as d9, type SmartRouteBridgeStep as dA, type SmartRouteFeeBreakdown as dB, type SmartRouteFill as dC, type SmartRouteSettlementLeg as dD, type SmartRouteSettlementPlan as dE, type SmartRouteSetupCostLine as dF, type SmartRouteSide as dG, type SmartRouteStatus as dH, type SmartRouteVenueFill as dI, type SportsGameStatus as dJ, type SportsLiveParticipant as dK, type SportsLiveState as dL, TERMINAL_EXECUTION_STATES as dM, TimeInForce as dN, type TradeExecutorOrder as dO, type TradeStep as dP, type UserActivityBridge as dQ, type UserActivityDeposit as dR, type UserActivityRedeem as dS, type UserActivityRedeemLeg as dT, type UserActivityTrade as dU, type UserActivityType as dV, type UserActivityUserOp as dW, type UserActivityWithdrawal as dX, VENUES as dY, VENUE_CHAIN_IDS as dZ, type ValidateBalanceOnClientStep as d_, type RecurringCryptoOutcomeOrderbookDepth as da, type RecurringCryptoPriceComparison as db, type RecurringCryptoReferencePrice as dc, type RecurringCryptoResolution as dd, type RecurringCryptoSourceConfidence as de, type RecurringCryptoVenueMarket as df, type RecurringCryptoWindowComparisons as dg, type RecurringCryptoWindowMarket as dh, type RedeemLegResult as di, type RedeemLegStatus as dj, type RequestedOrderbookMarket as dk, type ResolvedCorrelatedMarketsResponse as dl, SELF_CUSTODY_FILL_TIMEOUT_MS as dm, SELF_CUSTODY_POLL_INTERVAL_MS as dn, type ServerWallet as dp, type SettlementDiff as dq, type SettlementDifference as dr, type SettlementSource as ds, type SetupDepositAddressStep as dt, type SetupVenueKeyStep as du, type SignatureRequest as dv, type SignatureRequestType as dw, type SignerFn as dx, type SimpleOrderbookLevel as dy, type SmartRouteAllocation as dz, type WsArbFeedBatch as e, isVenueInactive as e$, type ValidateManagedRequest as e0, type ValidateManagedResponse as e1, type ValidateTradeRequest as e2, type ValidateTradeResponse as e3, type VenueEventListItem as e4, type VenueEventWithMarkets as e5, type VenueGeoPolicyEntry as e6, type VenueMarketListItem as e7, type VenueMarketRef as e8, type VenueOrderbookEntry as e9, type WsConnected as eA, type WsError as eB, type WsHeartbeat as eC, type WsMarkSource as eD, type WsMarketResolved as eE, type WsOrderEvent as eF, type WsOrderEventType as eG, type WsOrderSubmitted as eH, type WsOrderbookDelta as eI, type WsOrderbookSnapshot as eJ, type WsRedeemEvent as eK, type WsServerMessage as eL, type WsSubscribed as eM, type WsTrade as eN, type WsUnsubscribed as eO, type WsVenueBook as eP, type WsVenueInfo as eQ, type WsVenueLevel as eR, type WsWithdrawalLegStatus as eS, type WsWithdrawalLifecycleEvent as eT, type WsWithdrawalLifecycleLeg as eU, type WsWithdrawalLifecycleStatus as eV, applyOrderbookDelta as eW, computeChecksum as eX, getEffectiveDisabledVenues as eY, isVenueActive as eZ, isVenueDataVisible as e_, type VenueOrderbookLevel as ea, type VenuePositionBalance as eb, type VenuePriceInfo as ec, type VenueSoloQuote as ed, type VerifyBody as ee, type VerifyResponse as ef, type WalletChainBalance as eg, type WalletTokenBalance as eh, type WithdrawManagedRequest as ei, type WithdrawManagedSourceItem as ej, type WithdrawTokenSymbol as ek, type WithdrawalExpected as el, type WithdrawalLeg as em, type WithdrawalLegStatus as en, type WithdrawalLegType as eo, type WithdrawalLifecycleStatus as ep, type WithdrawalSource as eq, type WithdrawalSourceItem as er, type WithdrawalSourceStatus as es, type WithdrawalSourceTokenSymbol as et, type WsArbFeedEntry as eu, type WsAttributedLevel as ev, type WsAuthenticated as ew, type WsBalanceUpdate as ex, type WsCandleInterval as ey, type WsClientMessage as ez, type AggWebSocketCallbacks as f, snapshotToOrderbook as f0, 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 };