@totalis/hip4-client 0.0.0-stage → 0.73.0

package/dist/generated/realtime.d.ts

@@ -0,0 +1,1486 @@
+export type paths = Record<string, never>;
+export type webhooks = Record<string, never>;
+export type components = {
+    schemas: {
+        readonly AccountReadInvalidation: components["schemas"]["Invalidation"];
+        readonly Cursor: {
+            /**
+             * Format: uuid
+             * @description Identifier of the delivery stream journal this cursor belongs to.
+             */
+            readonly stream_id: string;
+            /**
+             * Format: uuid
+             * @description Journal generation; a restore or reset starts a new generation, and sequences from different generations are never compared.
+             */
+            readonly generation_id: string;
+            /** @description Decimal position within the generation. It strictly increases but can skip numbers in a filtered view. */
+            readonly sequence: string;
+        };
+        readonly OperationUpdatedPayload: {
+            /** @description Operation identifier (32-byte hex). Read GET /v1/me/operations/{operation_id} for the full resource. */
+            readonly operation_id: components["schemas"]["Bytes32"];
+            /** @description Operation type, as the operation's kind: ACCEPT, SELL_BACK, CASHOUT_TRANSFER, WITHDRAW_USER and the others GET /v1/me/operations/{operation_id} names. Treat unlisted values as opaque. */
+            readonly kind: string;
+            /** @description Operation status after this change. QUEUED, IN_FLIGHT, RETRYABLE and UNKNOWN are nonterminal; COMMITTED (on chain), REVERTED and EXPIRED_UNEXECUTED are terminal. */
+            readonly status: components["schemas"]["OperationState"];
+            /** @description Chain transaction hash of the latest submission; null until a transaction has been submitted. */
+            readonly transaction_hash: components["schemas"]["Bytes32"] | null;
+            /** @description Why the operation ended EXPIRED_UNEXECUTED, as the operation's `failure_reason`. Present only then. */
+            readonly failure_reason?: components["schemas"]["OperationFailureReason"];
+            /** @description When the operation last changed state, RFC3339 UTC. */
+            readonly updated_at: components["schemas"]["Timestamp"];
+        };
+        readonly VaultBalanceChangedPayload: {
+            /** @description Linked wallet address whose vault balance changed. */
+            readonly address: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Claimable vault balance of the address after the change, in atomic USDC (6 decimals); not the size of the change. */
+            readonly amount: components["schemas"]["Amount"];
+            /** @description Chain transaction that produced the balance change. */
+            readonly transaction_hash: components["schemas"]["Bytes32"];
+            /**
+             * @description Always COMMITTED: the change was observed in a committed chain transaction.
+             * @constant
+             */
+            readonly status: "COMMITTED";
+        };
+        /** @description A quote left an RFQ's book. An entry quote also stops being acceptable at its `accept_before`, which sends no event. */
+        readonly QuoteRemovedPayload: {
+            /** @description RFQ whose book lost the quote. */
+            readonly rfq_id: components["schemas"]["Uuid"];
+            /** @description Quote that left the book. */
+            readonly quote_id: components["schemas"]["Bytes32"];
+            /**
+             * @description Why it left. CANCELLED: the maker cancelled or declined it, its acceptance timed out, or the maker's quote lease lapsed. REPLACED: the maker created a newer quote on the RFQ. ACCEPTED: the maker's confirm accepted it.
+             * @enum {unknown}
+             */
+            readonly status: "CANCELLED" | "REPLACED" | "ACCEPTED";
+        };
+        readonly WalletFundingPayload: {
+            /** @description The acceptance whose wallet funding changed; its accept Idempotency-Key. */
+            readonly acceptance_id: components["schemas"]["Uuid"];
+            /**
+             * @description Wallet funding status after the change: DEPOSIT_QUEUED, AWAITING_VAULT_CREDIT, ACCEPT_QUEUED, UNKNOWN, ACCEPTED, EXPIRED_REQUOTE or FAILED.
+             * @enum {unknown}
+             */
+            readonly status: "DEPOSIT_QUEUED" | "AWAITING_VAULT_CREDIT" | "ACCEPT_QUEUED" | "UNKNOWN" | "ACCEPTED" | "EXPIRED_REQUOTE" | "FAILED";
+            /** @description When the wallet funding last changed, RFC3339 UTC. */
+            readonly updated_at: components["schemas"]["Timestamp"];
+            /** @description The acceptance's `fund_by`, from `ACCEPT_QUEUED` on: send any HyperCore to wallet transfer that funds it before this time. */
+            readonly fund_by?: components["schemas"]["Timestamp"];
+        };
+        readonly RfqPayload: ({
+            /**
+             * Format: uuid
+             * @description RFQ this event reports.
+             */
+            readonly rfq_id: string;
+            /**
+             * @description RFQ status after this event. ACCEPTED: a quote was accepted and confirmed. CANCELLED: the owner cancelled it or a newer intent generation replaced it. FAILED: the accepted trade failed on chain. DECLINED: every maker that could answer declined to quote it.
+             * @enum {unknown}
+             */
+            readonly status: "ACCEPTED" | "CANCELLED" | "FAILED" | "DECLINED";
+            /** @description Why a FAILED RFQ ended: the accept transaction reverted or expired unexecuted. Null for every other status. */
+            readonly terminal_reason: components["schemas"]["RfqTerminalReason"] | null;
+            /** @description When the RFQ was durably created, RFC3339 UTC. */
+            readonly created_at: components["schemas"]["Timestamp"];
+            /** @description End of quote collection, RFC3339 UTC. Makers stop quoting at this instant; natural expiry emits no event. */
+            readonly expires_at: components["schemas"]["Timestamp"];
+            /** @description Automatic-RFQ intent this RFQ belongs to. Present together with intent_generation only for RFQs created with an intent. */
+            readonly intent_id?: components["schemas"]["Uuid"];
+            /** @description Generation of the intent; a newer generation supersedes older RFQs of the same intent. Present only with intent_id. */
+            readonly intent_generation?: components["schemas"]["PositiveInt64String"];
+        } & components["schemas"]["IntentIdentityPair"]) & ({
+            /**
+             * @description RFQ status; FAILED requires a terminal_reason, every other status has none.
+             * @enum {unknown}
+             */
+            readonly status?: "ACCEPTED" | "CANCELLED" | "DECLINED";
+            /** @description Null unless status is FAILED, then the reason the accepted trade failed. */
+            readonly terminal_reason?: null;
+        } | {
+            /**
+             * @description RFQ status; FAILED requires a terminal_reason, every other status has none.
+             * @constant
+             */
+            readonly status?: "FAILED";
+            /** @description Null unless status is FAILED, then the reason the accepted trade failed. */
+            readonly terminal_reason?: components["schemas"]["RfqTerminalReason"];
+        });
+        /** @description The whole entry RFQ as GET /v1/rfqs/{rfq_id} returns it while open, without status: the event says it is OPEN. */
+        readonly EntryRfqPayload: {
+            /** @description Entry RFQ that opened. */
+            readonly rfq_id: components["schemas"]["rfq_id"];
+            /** @description Always ENTRY for this payload. */
+            readonly kind: components["schemas"]["kind"];
+            /** @description Wallet that signs the accept and will own the position; a quote's taker. */
+            readonly taker: components["schemas"]["taker"];
+            /** @description Stake in atomic USDC (6 decimals), before taker fees; a quote's stake. */
+            readonly stake: components["schemas"]["Amount"];
+            /** @description What the vault backs if a quote is accepted: stake less the taker fee every quote must carry. Absent while the taker fee is unknown. */
+            readonly net_stake?: components["schemas"]["Amount"];
+            /** @description When the RFQ was durably created, RFC3339 UTC. */
+            readonly created_at: components["schemas"]["Timestamp"];
+            /** @description End of quote collection, RFC3339 UTC. Makers stop quoting at this instant; natural expiry emits no event. */
+            readonly expires_at: components["schemas"]["Timestamp"];
+            /** @description Requested legs in strictly increasing outcome_id order; a quote's legs. */
+            readonly legs: components["schemas"]["legs"];
+            /** @description Automatic-RFQ intent this RFQ belongs to. Present together with intent_generation only for RFQs created with an intent. */
+            readonly intent_id?: components["schemas"]["Uuid"];
+            /** @description Generation of the intent; a newer generation supersedes older RFQs of the same intent. Present only with intent_id. */
+            readonly intent_generation?: components["schemas"]["PositiveInt64String"];
+        } & components["schemas"]["IntentIdentityPair"];
+        readonly CashoutRfqPayload: {
+            /**
+             * Format: uuid
+             * @description Cash-out RFQ that opened.
+             */
+            readonly rfq_id: string;
+            /** @description When the RFQ was durably created, RFC3339 UTC. */
+            readonly created_at: components["schemas"]["Timestamp"];
+            /** @description End of cash-out quote collection, RFC3339 UTC. */
+            readonly expires_at: components["schemas"]["Timestamp"];
+            /**
+             * @description Always CASHOUT for this payload.
+             * @constant
+             */
+            readonly kind: "CASHOUT";
+            /** @description Position the owner wants to cash out. */
+            readonly position_id: components["schemas"]["Bytes32"];
+            /** @description Current owner of the position, who would sell it. */
+            readonly owner: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description legStateOf(legs, decision_read_gas) value read at decision_block; a quote must sign this exact value. */
+            readonly leg_state: components["schemas"]["Bytes32"];
+            /** @description The position's on-chain legs hash; the hash of legs must match it. */
+            readonly legs_hash: components["schemas"]["Bytes32"];
+            /** @description Pinned HyperEVM block number (decimal) for every pricing read: the position, owner, maker capacity, buyer balance and legStateOf. */
+            readonly decision_block: components["schemas"]["UInt64String"];
+            /**
+             * @description Exact gas limit, always 500000, to pass to the legStateOf read at decision_block.
+             * @constant
+             */
+            readonly decision_read_gas: "500000";
+            /** @description Maker that wrote the position originally. */
+            readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+            /** @description The position's stake after the taker fee, tickets(position_id).stake, in atomic USDC (6 decimals); fixed when the position opened. */
+            readonly net_stake: components["schemas"]["Amount"];
+            /** @description What the position pays if every leg wins, tickets(position_id).payout, in atomic USDC (6 decimals); fixed when the position opened. */
+            readonly payout: components["schemas"]["Amount"];
+            /** @description The position's canonical legs in leg order. */
+            readonly legs: readonly components["schemas"]["Leg"][];
+            /** @description Automatic-RFQ intent this RFQ belongs to. Present together with intent_generation only for RFQs created with an intent. */
+            readonly intent_id?: components["schemas"]["Uuid"];
+            /** @description Generation of the intent; present only with intent_id. */
+            readonly intent_generation?: components["schemas"]["PositiveInt64String"];
+        } & components["schemas"]["IntentIdentityPair"];
+        /** @description A position changed on chain. */
+        readonly PositionEventPayload: {
+            /** @description Position that changed; the contract's ticketId. Read GET /v1/me/positions/{position_id}, or the maker's position, for its status and amounts. */
+            readonly position_id: components["schemas"]["Bytes32"];
+            /** @description HyperEVM block number (decimal) of the change. */
+            readonly block_number: components["schemas"]["UInt64String"];
+            /** @description Log index of the change within its block. */
+            readonly log_index: number;
+        };
+        /** @description A maker's vault capital changed on chain. */
+        readonly MakerCapitalPayload: {
+            /** @description Maker whose vault capital changed. Read GET /v1/makers/{maker_id}/capital for the figures. */
+            readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+            /** @description HyperEVM block number (decimal) of the change. */
+            readonly block_number: components["schemas"]["UInt64String"];
+            /** @description Log index of the change within its block. */
+            readonly log_index: number;
+        };
+        readonly EventBase: {
+            /** @description Cursor of this event. Persist it after applying the event and resume after it. */
+            readonly cursor: components["schemas"]["Cursor"];
+            /**
+             * Format: uuid
+             * @description Unique event identifier for deduplicating at-least-once delivery; order comes from cursor.sequence.
+             */
+            readonly event_id: string;
+            /**
+             * @description What changed. The value selects the payload shape.
+             * @enum {unknown}
+             */
+            readonly event_type: "QUOTE_CREATED" | "QUOTE_REMOVED" | "QUOTE_ACCEPTED" | "RFQ_CREATED" | "RFQ_ACCEPTED" | "RFQ_CANCELLED" | "RFQ_FAILED" | "RFQ_DECLINED" | "OPERATION_UPDATED" | "VAULT_BALANCE_CHANGED" | "WALLET_FUNDING_UPDATED" | "WITHDRAWAL_UPDATED" | "CORE_EXIT_UPDATED" | "WALLET_BALANCE_CHANGED" | "COLLATERAL_REDUCTION_UPDATED" | "POSITION_OPENED" | "POSITION_TRANSFERRED" | "POSITION_SETTLED" | "POSITION_CLOSED" | "POSITION_UPDATED" | "MAKER_CAPITAL_UPDATED";
+            /**
+             * Format: date-time
+             * @description When the authoritative state transition happened, RFC3339 UTC. Measure receipt time locally.
+             */
+            readonly occurred_at: string;
+            /** @description Event-specific body that identifies the resource and its new state. Reread the named HTTP resource for the complete representation. */
+            readonly payload: unknown;
+        };
+        readonly Event: (components["schemas"]["EventBase"] & {
+            /**
+             * @description QUOTE_CREATED: a maker created a quote on an RFQ you own. Account stream only.
+             * @constant
+             */
+            readonly event_type: "QUOTE_CREATED";
+            /** @description The whole quote, identical to its item in the RFQ's quote list; accept it with its quote_id. */
+            readonly payload: components["schemas"]["Quote"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description QUOTE_REMOVED: a quote left the book of an RFQ you own. Account stream only.
+             * @constant
+             */
+            readonly event_type: "QUOTE_REMOVED";
+            /** @description The quote and why it left. */
+            readonly payload: components["schemas"]["QuoteRemovedPayload"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description QUOTE_ACCEPTED: a taker accepted this maker's quote and awaits its confirm. Maker stream only.
+             * @constant
+             */
+            readonly event_type: "QUOTE_ACCEPTED";
+            /** @description The same item the maker snapshot's acceptances carry; confirm or decline it at /v1/quotes/{quote_id}/confirm before deadline. */
+            readonly payload: components["schemas"]["MakerAcceptance"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description RFQ_CREATED: an entry or cash-out RFQ opened.
+             * @constant
+             */
+            readonly event_type: "RFQ_CREATED";
+            /** @description The whole open RFQ, discriminated by kind: an entry RFQ as makers quote it, or complete public cash-out decision evidence for pricing a cash-out quote. */
+            readonly payload: components["schemas"]["EntryRfqPayload"] | components["schemas"]["CashoutRfqPayload"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description An RFQ had a quote accepted, was cancelled, failed, or was declined by every maker that could answer it.
+             * @enum {unknown}
+             */
+            readonly event_type: "RFQ_ACCEPTED" | "RFQ_CANCELLED" | "RFQ_FAILED" | "RFQ_DECLINED";
+            /** @description The RFQ and its new status. */
+            readonly payload: components["schemas"]["RfqPayload"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description OPERATION_UPDATED: an operation, such as an accept, sell-back, transfer or withdrawal payout, changed status.
+             * @constant
+             */
+            readonly event_type: "OPERATION_UPDATED";
+            /** @description Current status of the operation and its kind. */
+            readonly payload: components["schemas"]["OperationUpdatedPayload"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description VAULT_BALANCE_CHANGED: a committed transaction changed a linked wallet's vault balance.
+             * @constant
+             */
+            readonly event_type: "VAULT_BALANCE_CHANGED";
+            /** @description The wallet, its new vault balance and the transaction. */
+            readonly payload: components["schemas"]["VaultBalanceChangedPayload"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description WALLET_FUNDING_UPDATED: the wallet funding of an acceptance changed status.
+             * @constant
+             */
+            readonly event_type: "WALLET_FUNDING_UPDATED";
+            /** @description The acceptance and its wallet funding's new status. */
+            readonly payload: components["schemas"]["WalletFundingPayload"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description WITHDRAWAL_UPDATED: a withdrawal was admitted or changed state.
+             * @constant
+             */
+            readonly event_type: "WITHDRAWAL_UPDATED";
+            /** @description The whole withdrawal as GET /v1/me/withdrawals/{withdrawal_id} returns it; follow a withdrawal from these events alone. */
+            readonly payload: components["schemas"]["Withdrawal"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description CORE_EXIT_UPDATED: a HyperCore exit changed status.
+             * @constant
+             */
+            readonly event_type: "CORE_EXIT_UPDATED";
+            /** @description The exit and its new stored status. */
+            readonly payload: {
+                /** @description HyperCore exit that changed. */
+                readonly exit_id: components["schemas"]["Uuid"];
+                /**
+                 * @description Stored exit status. Refresh GET /v1/core-exits/{exit_id} for the full resource.
+                 * @enum {unknown}
+                 */
+                readonly status: "PENDING" | "SENT" | "CREDITED" | "RECOVERED" | "FAILED" | "ABANDONED";
+                /** @description When the exit last changed, RFC3339 UTC. */
+                readonly updated_at: components["schemas"]["Timestamp"];
+            };
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description WALLET_BALANCE_CHANGED: an observed USDC transfer touched a linked wallet.
+             * @constant
+             */
+            readonly event_type: "WALLET_BALANCE_CHANGED";
+            /** @description An observed USDC transfer touched this linked wallet. Refresh GET /v1/me/balances for the wallet balance. */
+            readonly payload: {
+                /** @description Linked wallet the transfer touched, as sender or recipient. */
+                readonly address: components["schemas"]["LowercaseNonZeroAddress"];
+                /** @description Chain transaction of the observed USDC transfer. */
+                readonly transaction_hash: components["schemas"]["Bytes32"];
+                /** @description HyperEVM block number (decimal) of the transfer. */
+                readonly block_number: string;
+            };
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description COLLATERAL_REDUCTION_UPDATED: a maker collateral-reduction job changed status.
+             * @constant
+             */
+            readonly event_type: "COLLATERAL_REDUCTION_UPDATED";
+            /** @description The job, its new status and its operation once durable. */
+            readonly payload: {
+                /** @description Collateral-reduction job that changed. */
+                readonly job_id: components["schemas"]["Uuid"];
+                /**
+                 * @description Stored job status. Refresh GET /v1/makers/{maker_id}/collateral-reductions/{job_id} for the full resource; its operation reports OPERATION_UPDATED.
+                 * @enum {unknown}
+                 */
+                readonly status: "QUEUED" | "SOLVING" | "NO_IMPROVEMENT" | "DURABLE" | "FAILED";
+                /** @description Chain operation executing the reduction; null until the job is durable. */
+                readonly operation_id: components["schemas"]["Bytes32"] | null;
+                /** @description When the job last changed, RFC3339 UTC. */
+                readonly updated_at: components["schemas"]["Timestamp"];
+            };
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description A position opened (the fill of an entry), changed owner (a transfer), settled, closed (a sell-back or claim), or otherwise changed. The owner and the underwriting maker receive it; a transfer also reaches the previous owner.
+             * @enum {unknown}
+             */
+            readonly event_type: "POSITION_OPENED" | "POSITION_TRANSFERRED" | "POSITION_SETTLED" | "POSITION_CLOSED" | "POSITION_UPDATED";
+            /** @description The position and where the change happened on chain; reread the position for its status. */
+            readonly payload: components["schemas"]["PositionEventPayload"];
+        }) | (components["schemas"]["EventBase"] & {
+            /**
+             * @description MAKER_CAPITAL_UPDATED: a maker's vault capital changed. Maker stream only.
+             * @constant
+             */
+            readonly event_type: "MAKER_CAPITAL_UPDATED";
+            /** @description The maker and where the change happened on chain; reread its capital. */
+            readonly payload: components["schemas"]["MakerCapitalPayload"];
+        });
+        readonly PublicationCheckpoint: {
+            /** @description Every authorized event up to this cursor was published and delivered on this socket before this frame. */
+            readonly cursor: components["schemas"]["Cursor"];
+            /** @description Database commit cut the checkpoint covers, RFC3339 UTC. It is not renewed by reading, so its age is the publication lag. */
+            readonly source_cut_at: components["schemas"]["Timestamp"];
+            /** @description Database clock when the checkpoint was read, RFC3339 UTC. */
+            readonly server_time: components["schemas"]["Timestamp"];
+        };
+        readonly PublicationFrame: {
+            /**
+             * @description Frame discriminator, always publication.
+             * @constant
+             */
+            readonly channel: "publication";
+            /** @description Publication coverage, sent each heartbeat to subscriptions that set publication_freshness. Null when no checkpoint is available; treat freshness as unproven. */
+            readonly data: components["schemas"]["PublicationCheckpoint"] | null;
+        };
+        readonly Snapshot: {
+            /** @description Stream cursor the snapshot is consistent with. Events after it follow on the stream; reconnect with it to replay them. */
+            readonly cursor: components["schemas"]["Cursor"];
+            /** @description Current live state keyed by class, each class holding at most 100 items with the same item shape as its truncated route. Maker snapshots carry open_rfqs, acceptances and operations. Account snapshots carry rfqs, quotes, acceptances and operations, plus open_rfqs when the subscription set open_rfqs. quotes holds the live quotes on the account's open RFQs, the same items as QUOTE_CREATED; its route is each open RFQ's quote list. acceptances holds, for an account, its acceptances still PENDING_CONFIRM, each read again at GET /v1/quotes/{quote_id}/acceptance, and for a maker the acceptances awaiting its confirm, earliest deadline first, paged at /v1/makers/{maker_id}/acceptances. */
+            readonly resources: unknown;
+            /** @description Classes the snapshot truncated, each with the HTTP route that pages the rest. Absent when nothing was truncated. */
+            readonly truncated?: readonly {
+                /** @description Truncated resource class, such as quotes or operations. */
+                readonly resource: string;
+                /** @description HTTP route that pages the complete class. */
+                readonly href: string;
+            }[];
+        };
+        readonly AccountSubscription: {
+            /**
+             * @description The credential's own account: its RFQs, quotes, acceptances, operations and balances.
+             * @constant
+             */
+            readonly type: "account";
+            /** @description Last durably applied cursor to resume after. Omit it to start from a snapshot. Scoped keys need replay:read to send one. */
+            readonly cursor?: components["schemas"]["Cursor"];
+            /** @description Opt in to every open RFQ, not only your own, in the snapshot's open_rfqs and as RFQ events. Needs rfq:read; without it the server closes with SUBSCRIPTION_DENIED. */
+            readonly open_rfqs?: boolean;
+            /** @description Opt in to readInvalidated frames for the account this credential reads. The server derives the scope and returns it in the subscriptionResponse. Without it, a session or unscoped key still gets readInvalidated frames for its own ACTIVITY and POSITIONS; scoped keys get none. */
+            readonly account_reads?: boolean;
+            /** @description Opt in to publication checkpoints and a 1000 ms authenticated heartbeat. */
+            readonly publication_freshness?: boolean;
+        };
+        readonly MakerSubscription: {
+            /**
+             * @description A maker the credential acts for: open RFQs, acceptances of its quotes, and its operations and capital.
+             * @constant
+             */
+            readonly type: "maker";
+            /** @description The maker to stream. A maker key names its own maker; a dashboard session names a maker it is a member of. */
+            readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+            /** @description Last durably applied cursor to resume after. Omit it to start from a snapshot. Scoped keys need replay:read to send one. */
+            readonly cursor?: components["schemas"]["Cursor"];
+            /** @description Opt in to readInvalidated frames for the maker's account reads. The server derives the scope and returns it in the subscriptionResponse. */
+            readonly account_reads?: boolean;
+            /** @description Opt in to publication checkpoints and a 1000 ms authenticated heartbeat. */
+            readonly publication_freshness?: boolean;
+        };
+        readonly Subscribe: {
+            /**
+             * @description Always subscribe. The client sends this one frame first, and only once: close the socket to end the subscription.
+             * @constant
+             */
+            readonly method: "subscribe";
+            /** @description Exactly one subscription, discriminated by type. The credential must act for it. */
+            readonly subscription: components["schemas"]["AccountSubscription"] | components["schemas"]["MakerSubscription"];
+        };
+        readonly SubscriptionResponse: {
+            /**
+             * @description Frame discriminator, always subscriptionResponse. The server sends it once, right after accepting the subscribe.
+             * @constant
+             */
+            readonly channel: "subscriptionResponse";
+            /** @description The accepted subscription and where its events start. */
+            readonly data: {
+                /**
+                 * @description The method this frame answers, always subscribe.
+                 * @constant
+                 */
+                readonly method: "subscribe";
+                /** @description The accepted subscription, echoed without its cursor. */
+                readonly subscription: {
+                    /**
+                     * @description The credential's own account: its RFQs, quotes, acceptances, operations and balances.
+                     * @constant
+                     */
+                    readonly type: "account";
+                    /** @description Opt in to every open RFQ, not only your own, in the snapshot's open_rfqs and as RFQ events. Needs rfq:read; without it the server closes with SUBSCRIPTION_DENIED. */
+                    readonly open_rfqs?: boolean;
+                    /** @description Opt in to readInvalidated frames for the account this credential reads. The server derives the scope and returns it in the subscriptionResponse. Without it, a session or unscoped key still gets readInvalidated frames for its own ACTIVITY and POSITIONS; scoped keys get none. */
+                    readonly account_reads?: boolean;
+                    /** @description Opt in to publication checkpoints and a 1000 ms authenticated heartbeat. */
+                    readonly publication_freshness?: boolean;
+                } | {
+                    /**
+                     * @description A maker the credential acts for: open RFQs, acceptances of its quotes, and its operations and capital.
+                     * @constant
+                     */
+                    readonly type: "maker";
+                    /** @description The maker to stream. A maker key names its own maker; a dashboard session names a maker it is a member of. */
+                    readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+                    /** @description Opt in to readInvalidated frames for the maker's account reads. The server derives the scope and returns it in the subscriptionResponse. */
+                    readonly account_reads?: boolean;
+                    /** @description Opt in to publication checkpoints and a 1000 ms authenticated heartbeat. */
+                    readonly publication_freshness?: boolean;
+                };
+                /**
+                 * Format: uuid
+                 * @description Server-assigned identifier of this connection.
+                 */
+                readonly connection_id: string;
+                /**
+                 * Format: date-time
+                 * @description Server clock when the session opened, RFC3339 UTC.
+                 */
+                readonly server_time: string;
+                /**
+                 * @description Idle heartbeat interval in milliseconds: 1000 when the subscription set publication_freshness, otherwise 15000.
+                 * @enum {unknown}
+                 */
+                readonly heartbeat_interval_ms: 1000 | 15000;
+                /**
+                 * @description How the stream starts. REPLAY: the subscription cursor is valid and events after it follow. SNAPSHOT: no cursor was sent and a snapshot follows. RESET: the cursor is stale, ahead or from another generation; replace local state with the snapshot that follows.
+                 * @enum {unknown}
+                 */
+                readonly resume: "REPLAY" | "SNAPSHOT" | "RESET";
+                /** @description Events are delivered strictly after this cursor: the subscription cursor on REPLAY, otherwise the snapshot's cursor. */
+                readonly cursor: components["schemas"]["Cursor"];
+                /** @description Read-invalidation subscription the server derived from the credential. Present only when the subscription set account_reads. */
+                readonly account_reads?: components["schemas"]["ReadSubscription"];
+            };
+        };
+        readonly SnapshotFrame: {
+            /**
+             * @description Frame discriminator, always snapshot.
+             * @constant
+             */
+            readonly channel: "snapshot";
+            /** @description Principal-scoped live state and the cursor it is consistent with. */
+            readonly data: components["schemas"]["Snapshot"];
+        };
+        readonly EventFrame: {
+            /**
+             * @description Frame discriminator, always event.
+             * @constant
+             */
+            readonly channel: "event";
+            /** @description The committed journal event. */
+            readonly data: components["schemas"]["Event"];
+        };
+        readonly ReadInvalidatedFrame: {
+            /**
+             * @description Frame discriminator, always readInvalidated. Sent to subscriptions that set account_reads, and for its own ACTIVITY and POSITIONS to every account subscription on a session or unscoped key.
+             * @constant
+             */
+            readonly channel: "readInvalidated";
+            /** @description The account reads to refetch. */
+            readonly data: components["schemas"]["Invalidation"];
+        };
+        readonly ResetFrame: {
+            /**
+             * @description Frame discriminator, always reset. The server closes right after; discard local state, reload over HTTP and reconnect.
+             * @constant
+             */
+            readonly channel: "reset";
+        };
+        readonly DrainFrame: {
+            /**
+             * @description Frame discriminator, always drain.
+             * @constant
+             */
+            readonly channel: "drain";
+            /** @description When the server closes this connection and when to reconnect. */
+            readonly data: {
+                /** @description When the server closes this connection with CONNECTION_DRAIN, RFC3339 UTC. Open a replacement and resume from the last applied cursor before then. */
+                readonly deadline: components["schemas"]["Timestamp"];
+                /** @description Suggested delay in milliseconds before opening the replacement connection; currently 1000. */
+                readonly retry_after_ms: number;
+            };
+        };
+        readonly MarketRefresh: {
+            /**
+             * @description Frame discriminator, always marketRefresh.
+             * @constant
+             */
+            readonly channel: "marketRefresh";
+            /** @description The market catalog changed; refetch it. */
+            readonly data: {
+                /** @description Current market catalog generation. Refetch the catalog when it differs from the one you hold. */
+                readonly catalog_generation: string;
+                /**
+                 * @description HTTP route to refetch, always /v1/markets.
+                 * @constant
+                 */
+                readonly resource: "/v1/markets";
+            };
+        };
+        readonly MarketSubscription: {
+            /**
+             * @description Always market.
+             * @constant
+             */
+            readonly type: "market";
+            /** @description 1 to 256 unique outcome IDs (decimal strings) to follow. The snapshot and deltas cover only these outcomes. */
+            readonly outcome_ids: readonly components["schemas"]["UInt32String"][];
+            /** @description Opt in to a publication frame every 5000 ms while the socket is current. */
+            readonly publication_freshness?: boolean;
+            /** @description Opt in to scoreboards frames: the live game scoreboard of every game with a selected outcome, complete after each snapshot, then on every change. Without it the socket gets no scoreboards frame. */
+            readonly scoreboards?: boolean;
+        };
+        readonly MarketScoreboardsFrame: {
+            /**
+             * @description Frame discriminator, always scoreboards.
+             * @constant
+             */
+            readonly channel: "scoreboards";
+            /** @description Live game scoreboards of the selection. */
+            readonly data: {
+                /** @description True right after each snapshot: games lists every game of the selection that has a scoreboard; replace all local scoreboards with it, and a game not listed has none. False afterwards: games lists only games whose scoreboard changed, appeared or went; apply them over the local ones. */
+                readonly complete: boolean;
+                /** @description One entry per game, by id. */
+                readonly games: readonly components["schemas"]["MarketScoreboardGame"][];
+            };
+        };
+        readonly MarketScoreboardGame: {
+            /** @description The game's contract 4 browse card: game:, question: or market: followed by its key. */
+            readonly id: string;
+            /** @description The selected outcomes of this game, ascending. */
+            readonly outcome_ids: readonly components["schemas"]["UInt32String"][];
+            /** @description The game as the live game feed last read it, exactly as the detail's scoreboard, competitors in the matchup's order. Null when it no longer has one: the feed lost it, its unfinished reading went stale (75 seconds without a fresh read), or it left the catalog. A refresh that shows the same score, status, period, clock, outs and last play sends no frame, so refreshed_at is the read that produced this content and only moves with a change; never age the board from it, the server nulls a stale one. */
+            readonly scoreboard: components["schemas"]["Scoreboard"] | null;
+        };
+        readonly MarketPublicationFrame: {
+            /**
+             * @description Frame discriminator, always publication.
+             * @constant
+             */
+            readonly channel: "publication";
+            /** @description How far the socket is proven current. */
+            readonly data: {
+                /** @description Every available reference of the selection was sent on this socket, before this frame, in a state market-data observed at this time (its received_at clock) or later; merged intermediate values are not claimed. RFC3339 UTC. Rises from frame to frame. */
+                readonly through: components["schemas"]["Timestamp"];
+                /** @description Server clock when the frame was sent, RFC3339 UTC. */
+                readonly server_time: components["schemas"]["Timestamp"];
+            };
+        };
+        readonly MarketSubscribe: {
+            /**
+             * @description Always subscribe. The client sends this one frame first.
+             * @constant
+             */
+            readonly method: "subscribe";
+            /** @description The outcomes to follow. */
+            readonly subscription: components["schemas"]["MarketSubscription"];
+        };
+        readonly MarketSubscriptionResponse: {
+            /**
+             * @description Frame discriminator, always subscriptionResponse.
+             * @constant
+             */
+            readonly channel: "subscriptionResponse";
+            /** @description The accepted subscription. */
+            readonly data: {
+                /**
+                 * @description The method this frame answers, always subscribe.
+                 * @constant
+                 */
+                readonly method: "subscribe";
+                /** @description The accepted subscription, echoed. */
+                readonly subscription: components["schemas"]["MarketSubscription"];
+                /**
+                 * Format: date-time
+                 * @description Server clock when the session opened, RFC3339 UTC.
+                 */
+                readonly server_time: string;
+                /**
+                 * @description Idle heartbeat interval in milliseconds, always 15000.
+                 * @constant
+                 */
+                readonly heartbeat_interval_ms: 15000;
+                /**
+                 * @description Largest frame the server sends, in bytes (1 MiB).
+                 * @constant
+                 */
+                readonly max_frame_bytes: 1048576;
+            };
+        };
+        readonly MarketSnapshotFrame: {
+            /**
+             * @description Frame discriminator, always snapshot.
+             * @constant
+             */
+            readonly channel: "snapshot";
+            /** @description Complete state of the selected outcomes. Replace all local market-stream state with it. */
+            readonly data: components["schemas"]["MarketPublicationSnapshot"];
+        };
+        readonly MarketDeltaFrame: {
+            /**
+             * @description Frame discriminator, always delta.
+             * @constant
+             */
+            readonly channel: "delta";
+            /** @description Changes to the selected outcomes since this socket's last snapshot or delta. */
+            readonly data: components["schemas"]["MarketPublicationDelta"];
+        };
+        readonly MarketPublicationSnapshot: {
+            /**
+             * @description Publication schema version, always "1".
+             * @constant
+             */
+            readonly schema_version: "1";
+            /** @description Market-data producer that built this state. A different producer requires a new snapshot. */
+            readonly producer_id: components["schemas"]["Uuid"];
+            /** @description Catalog generation the markets belong to. */
+            readonly catalog_generation: components["schemas"]["PositiveInt64"];
+            /** @description Reference-price feed generation; the producer starts a new, higher generation when it restarts the feed. */
+            readonly feed_generation: components["schemas"]["PositiveInt64"];
+            /**
+             * @description Complete for the selected outcome hot set.
+             * @constant
+             */
+            readonly complete: true;
+            /** @description Publication version of this state. The first delta's previous_version equals it. */
+            readonly version: components["schemas"]["PositiveInt64"];
+            /** @description Catalog entry of each selected outcome. */
+            readonly catalog: readonly components["schemas"]["PublicationCatalogMarket"][];
+            /** @description Reference price for each side of each selected outcome. */
+            readonly references: readonly components["schemas"]["PublicationReference"][];
+        };
+        /** @description Selected public market state changes. Timestamp-only reference observations are applied privately but may be omitted from this stream. Price, best bid/ask, availability, reason, source, quality, scale, freshness and feed-generation changes remain material. Reference timestamps identify the last delivered observation, not a client-side freshness lease. Use published freshness/eligibility and stream recovery. Versions can be sparse; every delta is anchored to the receiving socket's cursor. Catalog or producer replacement requires a new snapshot/reset. */
+        readonly MarketPublicationDelta: {
+            /**
+             * @description Publication schema version, always "1".
+             * @constant
+             */
+            readonly schema_version: "1";
+            /** @description Market-data producer; always equal to the snapshot's producer. */
+            readonly producer_id: components["schemas"]["Uuid"];
+            /** @description Catalog generation; always equal to the snapshot's, since a catalog change resets the stream. */
+            readonly catalog_generation: components["schemas"]["PositiveInt64"];
+            /** @description Reference-price feed generation of the upserted references. */
+            readonly feed_generation: components["schemas"]["PositiveInt64"];
+            /** @description Must exactly equal this socket's last accepted snapshot or delta version. Different sockets can receive different anchors for the same update after joining during suppressed observations. On a mismatch, resnapshot; never infer missing state. */
+            readonly previous_version: components["schemas"]["PositiveInt64"];
+            /** @description Strictly greater than previous_version, but need not equal previous_version + 1. Timestamp-only suppression and coalescing can skip intermediate versions. Accept the sparse advance only when previous_version matches this socket's cursor, then store this version. */
+            readonly version: components["schemas"]["PositiveInt64"];
+            /** @description Selected catalog entries that were added or changed; replace them whole. */
+            readonly catalog_upserts: readonly components["schemas"]["PublicationCatalogMarket"][];
+            /** @description Selected outcomes removed from the catalog. */
+            readonly catalog_removals: readonly components["schemas"]["PublicationCatalogRemoval"][];
+            /** @description Selected reference prices that changed materially; replace them whole. */
+            readonly reference_upserts: readonly components["schemas"]["PublicationReference"][];
+            /** @description Selected reference prices that were removed. */
+            readonly reference_removals: readonly components["schemas"]["PublicationReferenceRemoval"][];
+        };
+        readonly LowercaseNonZeroAddress: string;
+        /** Format: uint64-decimal */
+        readonly UInt64String: string;
+        readonly NonZeroUInt64String: components["schemas"]["UInt64String"] & unknown;
+        readonly Scope: {
+            /** @description EVM chain ID of the deployment, as a decimal string. */
+            readonly chain_id: string;
+            /** @description Lowercase vault contract address of the deployment. */
+            readonly vault: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Account or maker whose data the read returns. */
+            readonly subject: {
+                /**
+                 * @description ACCOUNT for a personal account read.
+                 * @constant
+                 */
+                readonly kind: "ACCOUNT";
+                /** @description Participant ID of the authenticated account. */
+                readonly account_id: string;
+                /** @description Lowercase linked wallet address whose personal history and positions are read. */
+                readonly wallet: components["schemas"]["LowercaseNonZeroAddress"];
+            } | {
+                /**
+                 * @description MAKER for a maker read.
+                 * @constant
+                 */
+                readonly kind: "MAKER";
+                /** @description On-chain maker ID whose data is read, as a decimal string; equals maker_id in the path. */
+                readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+            };
+        };
+        /** @description Account reads that changed: refetch the named resources for the scope. */
+        readonly Invalidation: {
+            /**
+             * @description Account-read contract version of the invalidation; always "1".
+             * @constant
+             */
+            readonly contract_version: "1";
+            /** @description Account or maker scope whose reads changed; the same scope the subscriptionResponse's account_reads names when the subscription set account_reads. */
+            readonly scope: components["schemas"]["Scope"];
+            /** @description Revision of the changed reads, as a decimal string; a higher revision supersedes a lower one. */
+            readonly revision: string;
+            /** @description Account reads to refetch. */
+            readonly resources: readonly ("BALANCES" | "CAPITAL" | "ACTIVITY" | "POSITIONS" | "PERFORMANCE" | "TELEMETRY" | "QUOTES" | "ACCESS")[];
+            /** @description Stream cursor of the change; persist it like an event cursor. */
+            readonly cursor: components["schemas"]["Cursor"];
+        };
+        readonly Bytes32: string;
+        /** @enum {unknown} */
+        readonly OperationState: "QUEUED" | "IN_FLIGHT" | "RETRYABLE" | "UNKNOWN" | "COMMITTED" | "REVERTED" | "EXPIRED_UNEXECUTED";
+        /**
+         * @description Why an operation ended EXPIRED_UNEXECUTED; nothing it would have done happened. INSUFFICIENT_CASH: an ACCEPT whose taker's money (free vault Cash, or the wallet USDC its funding draws) did not cover the stake when it was to execute, for a funded accept by two seconds after its `fund_by`; the RFQ fails with the same `terminal_reason`. DEADLINE_BEFORE_CLAIM: the venue reached it too late, with too little of its signed deadline left to sign and send it. AUTHORIZATION_TOO_CLOSE: when the venue took it, the chain's clock left too little of its signed deadline to send it. SIGNER_QUOTE_LIFE: its signed deadline could not cover the wait for its place in the sender's queue. SIMULATION_REVERTED: simulated before sending, the vault would have rejected it, for a reason other than INSUFFICIENT_CASH. QUARANTINE_EXPIRED: it was held for review after the signer refused it or its retries ran out, and its signed deadline passed meanwhile. ATTESTATION_EXPIRED: a maker's self-funded attestation expired before its signed transaction arrived. For an ACCEPT every reason but INSUFFICIENT_CASH fails the RFQ as EXPIRED_UNEXECUTED.
+         * @enum {string}
+         */
+        readonly OperationFailureReason: "INSUFFICIENT_CASH" | "DEADLINE_BEFORE_CLAIM" | "AUTHORIZATION_TOO_CLOSE" | "SIGNER_QUOTE_LIFE" | "SIMULATION_REVERTED" | "QUARANTINE_EXPIRED" | "ATTESTATION_EXPIRED";
+        /** Format: date-time */
+        readonly Timestamp: string;
+        /** Format: uint128-decimal */
+        readonly Amount: string;
+        /** Format: uuid */
+        readonly Uuid: string;
+        /** @description Positive signed 64-bit decimal integer, at most 9223372036854775807. */
+        readonly PositiveInt64String: string;
+        readonly IntentIdentityPair: {
+            /** @description Automatic-RFQ intent (UUIDv7) the RFQ belongs to. */
+            readonly intent_id: components["schemas"]["Uuid"];
+            /** @description Generation of that intent, as a decimal string; a higher generation supersedes the intent's earlier RFQs. */
+            readonly intent_generation: components["schemas"]["PositiveInt64String"];
+        } | {
+            readonly intent_id?: never;
+            readonly intent_generation?: never;
+        };
+        /** @enum {string} */
+        readonly RfqTerminalReason: "REVERTED" | "EXPIRED_UNEXECUTED" | "INSUFFICIENT_CASH";
+        /**
+         * Format: uuid
+         * @description Identifier of this RFQ (UUID).
+         */
+        readonly rfq_id: string;
+        /**
+         * @description RFQ kind; ENTRY asks makers to quote a new position.
+         * @constant
+         */
+        readonly kind: "ENTRY";
+        /** @description Wallet that signs the accept and will own the position. */
+        readonly taker: string;
+        readonly UInt32String: string;
+        /** @enum {string} */
+        readonly Side: "YES" | "NO";
+        /** @description One (outcome, side) pair, as markets and positions name it. */
+        readonly Leg: {
+            /** @description HIP-4 outcome ID the leg is on, as a decimal string. The signed Leg encodes it as uint32. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /** @description Outcome side the leg backs. The signed Leg encodes YES as 0 and NO as 1. */
+            readonly side: components["schemas"]["Side"];
+        };
+        /** @description Requested legs in strictly increasing outcome_id order. */
+        readonly legs: readonly components["schemas"]["Leg"][];
+        readonly Uint256: string;
+        /** @description Entry terms a maker quotes; they mirror the signed Quote and TakerAccept structs field for field. */
+        readonly QuoteTerms: {
+            /** @description On-chain maker ID of the quoting maker. */
+            readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+            /** @description Legs the quote covers; must equal the RFQ legs in order. The signed Leg encodes outcome_id as uint32 and side as uint8, 0 for YES and 1 for NO. */
+            readonly legs: readonly components["schemas"]["Leg"][];
+            /** @description Taker stake in atomic USDC (6 decimals), before taker fees. */
+            readonly stake: components["schemas"]["Amount"];
+            /** @description Gross amount the position pays if every leg wins, in atomic USDC (6 decimals), before the profit fee. */
+            readonly payout: components["schemas"]["Amount"];
+            /** @description Profit fee in basis points, charged at claim on the winning profit (payout minus net stake). */
+            readonly fee_bps: number;
+            /** @description Entry fee in basis points taken from the stake at accept: net stake is stake minus floor(stake * taker_fee_bps / 10000). */
+            readonly taker_fee_bps: number;
+            /** @description Wallet that must sign the accept and will own the position. */
+            readonly taker: string;
+            /** @description Unix seconds after which the quote can no longer be accepted. */
+            readonly expiry: components["schemas"]["UInt64String"];
+            /** @description Random uint256, as a decimal string, that makes each signed quote unique. */
+            readonly salt: components["schemas"]["Uint256"];
+        };
+        /** @description A maker's offer to open a position on an entry RFQ. */
+        readonly EntryQuote: {
+            /** @description Quote ID: the EIP-712 digest of `entry` as the `Quote` struct. Accept it with `POST /v1/quotes/{quote_id}/accept`. */
+            readonly quote_id: components["schemas"]["Bytes32"];
+            /** @description RFQ this quote answers. */
+            readonly rfq_id: components["schemas"]["Uuid"];
+            /**
+             * @description Always `ENTRY`: the quote opens a new position.
+             * @constant
+             */
+            readonly kind: "ENTRY";
+            /** @description Venue-wide publication sequence number; a higher value was created later. */
+            readonly sequence: number;
+            /** @description Accept the quote before this time, as an RFC3339 UTC timestamp: 14 seconds before `entry.expiry`, which leaves time for the maker to confirm and the trade to land. Fixed when the quote is created; an accept at or after it is refused as expired. */
+            readonly accept_before: components["schemas"]["Timestamp"];
+            /** @description Entry terms. To accept, the taker signs them as the EIP-712 `TakerAccept` struct. */
+            readonly entry: components["schemas"]["QuoteTerms"];
+        };
+        readonly Hash32: string;
+        /** @description Sell-back terms: the underwriting maker buys the position back and it closes. They mirror the signed SellBack struct. */
+        readonly SellBackTerms: {
+            /** @description Position the quote is for; the signed SellBack names it ticketId. */
+            readonly position_id: components["schemas"]["Hash32"];
+            /** @description Buyback price the original maker pays the owner to close the ticket, in atomic USDC (6 decimals). */
+            readonly price: components["schemas"]["Amount"];
+            /** @description Current position owner, who sells the ticket back. */
+            readonly owner: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Unix seconds after which the quote can no longer be executed. */
+            readonly expiry: components["schemas"]["UInt64String"];
+            /** @description Random uint256, as a decimal string, that makes each signed quote unique. */
+            readonly salt: components["schemas"]["Uint256"];
+            /** @description Position leg state the quote was priced against; must equal the RFQ's leg_state. */
+            readonly leg_state: components["schemas"]["Hash32"];
+        };
+        /** @description A cash-out offer from the maker that backs the position: its vault buys the position back for `price`. */
+        readonly SellBackQuote: {
+            /** @description Quote ID: the EIP-712 digest of `sell_back` as the `SellBack` struct, which the owner signs to accept. */
+            readonly quote_id: components["schemas"]["Bytes32"];
+            /** @description RFQ this quote answers. */
+            readonly rfq_id: components["schemas"]["Uuid"];
+            /**
+             * @description Always `SELL_BACK`: the backing maker buys the position back.
+             * @constant
+             */
+            readonly kind: "SELL_BACK";
+            /** @description Venue-wide publication sequence number; a higher value was created later. */
+            readonly sequence: number;
+            /** @description Sell-back terms the owner accepts by signing `quote_id` as `SellBack`. */
+            readonly sell_back: components["schemas"]["SellBackTerms"];
+        };
+        /** @description Transfer terms: another maker buys the position and becomes its owner. They mirror the signed CashoutTransfer struct. */
+        readonly TransferTerms: {
+            /** @description Position the quote is for; the signed CashoutTransfer names it ticketId. */
+            readonly position_id: components["schemas"]["Hash32"];
+            /** @description Price the buyer pays the seller for the whole position, in atomic USDC (6 decimals). */
+            readonly price: components["schemas"]["Amount"];
+            /** @description Current position owner, who sells the ticket. */
+            readonly seller: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description The bidding maker's current quote signer, which becomes the owner and pays from its own vault balance. */
+            readonly buyer: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Unix seconds after which the quote can no longer be executed. */
+            readonly expiry: components["schemas"]["UInt64String"];
+            /** @description Random uint256, as a decimal string, that makes each signed quote unique. */
+            readonly salt: components["schemas"]["Uint256"];
+            /** @description Position leg state the quote was priced against; must equal the RFQ's leg_state. */
+            readonly leg_state: components["schemas"]["Hash32"];
+        };
+        /** @description A cash-out offer from another maker: it pays the owner `price` and takes over the position. */
+        readonly TransferQuote: {
+            /** @description Quote ID: the EIP-712 digest of `transfer` as the `CashoutTransfer` struct, which the owner signs to accept. */
+            readonly quote_id: components["schemas"]["Bytes32"];
+            /** @description RFQ this quote answers. */
+            readonly rfq_id: components["schemas"]["Uuid"];
+            /**
+             * @description Always `TRANSFER`: another maker takes over the position.
+             * @constant
+             */
+            readonly kind: "TRANSFER";
+            /** @description Venue-wide publication sequence number; a higher value was created later. */
+            readonly sequence: number;
+            /** @description Transfer terms the owner accepts by signing `quote_id` as `CashoutTransfer`. */
+            readonly transfer: components["schemas"]["TransferTerms"];
+        };
+        /** @description One live, unsigned quote on an RFQ, told apart by `kind`. List quotes, the account snapshot's quotes and `QUOTE_CREATED` carry the same item. */
+        readonly Quote: components["schemas"]["EntryQuote"] | components["schemas"]["SellBackQuote"] | components["schemas"]["TransferQuote"];
+        /** @description A taker's accept of your entry quote. */
+        readonly EntryMakerAcceptance: {
+            /** @description The accepted quote. Confirm with `POST /v1/quotes/{quote_id}/confirm`. */
+            readonly quote_id: components["schemas"]["Bytes32"];
+            /** @description RFQ this quote answers. */
+            readonly rfq_id: components["schemas"]["Uuid"];
+            /**
+             * @description Always `ENTRY`: the accepted quote opens a new position.
+             * @constant
+             */
+            readonly kind: "ENTRY";
+            /** @description Confirm before this instant, an RFC3339 UTC timestamp. A later answer cannot reopen the acceptance. */
+            readonly deadline: components["schemas"]["Timestamp"];
+            /** @description Accepted entry terms; sign them as `Quote`. */
+            readonly entry: components["schemas"]["QuoteTerms"];
+        };
+        /** @description An owner's accept of your sell-back quote. */
+        readonly SellBackMakerAcceptance: {
+            /** @description The accepted quote. Confirm with `POST /v1/quotes/{quote_id}/confirm`. */
+            readonly quote_id: components["schemas"]["Bytes32"];
+            /** @description RFQ this quote answers. */
+            readonly rfq_id: components["schemas"]["Uuid"];
+            /**
+             * @description Always `SELL_BACK`: your vault buys the position back.
+             * @constant
+             */
+            readonly kind: "SELL_BACK";
+            /** @description Confirm before this instant, an RFC3339 UTC timestamp. A later answer cannot reopen the acceptance. */
+            readonly deadline: components["schemas"]["Timestamp"];
+            /** @description Accepted sell-back terms; sign them as `SellBack`. */
+            readonly sell_back: components["schemas"]["SellBackTerms"];
+        };
+        /** @description An owner's accept of your transfer quote. */
+        readonly TransferMakerAcceptance: {
+            /** @description The accepted quote. Confirm with `POST /v1/quotes/{quote_id}/confirm`. */
+            readonly quote_id: components["schemas"]["Bytes32"];
+            /** @description RFQ this quote answers. */
+            readonly rfq_id: components["schemas"]["Uuid"];
+            /**
+             * @description Always `TRANSFER`: you take over the position.
+             * @constant
+             */
+            readonly kind: "TRANSFER";
+            /** @description Confirm before this instant, an RFC3339 UTC timestamp. A later answer cannot reopen the acceptance. */
+            readonly deadline: components["schemas"]["Timestamp"];
+            /** @description Accepted transfer terms; sign them as `CashoutTransfer`. */
+            readonly transfer: components["schemas"]["TransferTerms"];
+        };
+        /** @description A taker's accept of your quote, waiting for your confirm until `deadline`, told apart by `kind`. `QUOTE_ACCEPTED`, the maker snapshot's `acceptances` and List pending acceptances carry the same item. It never includes the taker's signature or `acceptance_id`. */
+        readonly MakerAcceptance: components["schemas"]["EntryMakerAcceptance"] | components["schemas"]["SellBackMakerAcceptance"] | components["schemas"]["TransferMakerAcceptance"];
+        readonly Withdrawal: {
+            /** @description Server-assigned ID of this withdrawal. */
+            readonly withdrawal_id: components["schemas"]["Uuid"];
+            /** @description Embedded wallet that pays out. */
+            readonly account: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description External address that receives the USDC. */
+            readonly destination: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Total amount sent to destination, in atomic USDC (6 decimals). */
+            readonly amount: components["schemas"]["Amount"];
+            /** @description Part of amount first withdrawn from the vault to the wallet, in atomic USDC; "0" when the wallet already covered it. */
+            readonly shortfall_amount: components["schemas"]["Amount"];
+            /**
+             * @description VAULT_WITHDRAWAL_QUEUED: the vault top-up is queued and the payout waits for it; PAYOUT_SUBMITTED: the payout is queued or relayed; PAYOUT_COMMITTED: destination received amount (terminal); FAILED: the withdrawal stopped and nothing left the Totalis balance: a vault top-up that committed stays in the wallet (terminal).
+             * @enum {unknown}
+             */
+            readonly status: "VAULT_WITHDRAWAL_QUEUED" | "PAYOUT_SUBMITTED" | "PAYOUT_COMMITTED" | "FAILED";
+            /** @description Operation of the vault top-up; null when there is no shortfall. */
+            readonly vault_operation_id: components["schemas"]["Bytes32"] | null;
+            /** @description Operation of the relayed payout; null until the vault top-up commits. */
+            readonly payout_operation_id: components["schemas"]["Bytes32"] | null;
+            /** @description HyperEVM transaction of the payout; null until it is broadcast. */
+            readonly payout_transaction_hash: components["schemas"]["Bytes32"] | null;
+            /** @description When the withdrawal last changed, RFC3339 UTC. */
+            readonly updated_at: components["schemas"]["Timestamp"];
+        };
+        readonly ReadSubscription: {
+            /**
+             * @description Account-read contract version of the subscription; always "1".
+             * @constant
+             */
+            readonly contract_version: "1";
+            /** @description Account or maker scope the server derived from the credential for this stream. */
+            readonly scope: components["schemas"]["Scope"];
+            /** @description Stream cursor the client asked to resume after; null when it started without one. */
+            readonly cursor: components["schemas"]["Cursor"] | null;
+        };
+        readonly ScoreboardCompetitor: {
+            /** @description The participant's name as our catalog spells it, cut to 96 characters ending in an ellipsis when longer. */
+            readonly name: string;
+            /** @description Current score; null before the game starts and when the feed has none. */
+            readonly score: number | null;
+            /** @description Soccer penalty shootout goals, separate from score; null when there was no shootout. */
+            readonly shootout_score: number | null;
+        };
+        /** @description A matchup's game as the live game feed last read it, for display only: never a result, settlement or trading input. A reading of an unfinished game is served only while under 75 seconds old; a FINAL, POSTPONED or CANCELLED one stays. A field the feed lacks is null, never a guess. */
+        readonly Scoreboard: {
+            /**
+             * @description The game's phase. BREAK is a pause in play: half time, between periods or innings.
+             * @enum {string}
+             */
+            readonly status: "SCHEDULED" | "LIVE" | "BREAK" | "FINAL" | "POSTPONED" | "DELAYED" | "SUSPENDED" | "CANCELLED";
+            /** @description Display label of the period in play, or just ended during a BREAK: Q1-Q4, OT, 2OT (basketball, American football); P1-P3, OT, SO (hockey); Top 7th, Bottom 7th, Mid 7th, End 7th (baseball); HT at half time; ET or PEN in soccer extra time or penalties. On a FINAL only how it went beyond regulation (OT, 2OT, SO, AET, PEN, an extra inning such as 10th), else null. */
+            readonly period: string | null;
+            /** @description Game clock while LIVE: remaining time such as 4:58, or soccer minutes such as 67' and 90+6'. Null otherwise and in baseball. */
+            readonly clock: string | null;
+            /** @description Outs in the current half-inning while a baseball game is LIVE, when the feed has them. */
+            readonly outs: number | null;
+            /** @description Both sides in the order the matchup names them: a game's participants, else a question's or market's 'A v B' title order. Never the feed's home and away order. */
+            readonly competitors: readonly components["schemas"]["ScoreboardCompetitor"][];
+            /** @description The feed's text of the latest play while the game is in play, in English, cut to 200 characters ending in an ellipsis when longer. */
+            readonly last_play: string | null;
+            /** @description When the backend last read this from the feed. */
+            readonly refreshed_at: components["schemas"]["Timestamp"];
+        };
+        /**
+         * Format: positive-int64-decimal
+         * @description Positive generation or version bounded by signed int64 storage.
+         */
+        readonly PositiveInt64: string;
+        /** @enum {string} */
+        readonly MarketState: "ACTIVE" | "CLOSED" | "UNSUPPORTED";
+        readonly ResultUnresolved: {
+            /**
+             * @description AVAILABLE: the native result was read successfully.
+             * @constant
+             */
+            readonly availability: "AVAILABLE";
+            /**
+             * @description UNRESOLVED: the native market has not recorded a result.
+             * @constant
+             */
+            readonly result_state: "UNRESOLVED";
+        };
+        /** @description Native result numerator in the inclusive range zero through Q = 100000000. */
+        readonly FactorNumerator: string;
+        readonly NonZeroBytes32: components["schemas"]["Bytes32"] & unknown;
+        readonly ResultNumeric: {
+            /**
+             * @description AVAILABLE: the native result was read successfully.
+             * @constant
+             */
+            readonly availability: "AVAILABLE";
+            /**
+             * @description NUMERIC_RECORDED: the native market recorded a numeric payout for the YES side.
+             * @constant
+             */
+            readonly result_state: "NUMERIC_RECORDED";
+            /** @description YES payout as a fraction of factor_scale; 100000000 pays YES in full, 0 pays NO in full. */
+            readonly yes_factor_numerator: components["schemas"]["FactorNumerator"];
+            /**
+             * @description Denominator for yes_factor_numerator; always 100000000.
+             * @constant
+             */
+            readonly factor_scale: "100000000";
+            /** @description HyperEVM block number of the native read that observed this result. */
+            readonly recorded_at_block: components["schemas"]["PositiveInt64"];
+            /** @description SHA-256 over the chain, contracts, block number and hash, outcome and result of the native read that observed this result. */
+            readonly evidence_digest: components["schemas"]["NonZeroBytes32"];
+        };
+        readonly ResultNonnumeric: {
+            /**
+             * @description AVAILABLE: the native result was read successfully.
+             * @constant
+             */
+            readonly availability: "AVAILABLE";
+            /**
+             * @description RECOGNIZED_NONNUMERIC_OBSERVED: the native market recorded a recognized result that carries no numeric payout factor.
+             * @constant
+             */
+            readonly result_state: "RECOGNIZED_NONNUMERIC_OBSERVED";
+            /** @description HyperEVM block number of the native read that observed this result. */
+            readonly recorded_at_block: components["schemas"]["PositiveInt64"];
+            /** @description SHA-256 over the chain, contracts, block number and hash, outcome and result of the native read that observed this result. */
+            readonly evidence_digest: components["schemas"]["NonZeroBytes32"];
+        };
+        readonly ResultUnavailable: {
+            /**
+             * @description UNAVAILABLE: the native result could not be read; reason says why.
+             * @constant
+             */
+            readonly availability: "UNAVAILABLE";
+            /**
+             * @description NOT_QUERIED: not read yet; NATIVE_READ_FAILED: the on-chain read failed; RPC_UNAVAILABLE: no RPC provider answered; MALFORMED_RETURN: the contract returned an unexpected shape; PROVIDER_DISAGREEMENT: providers returned different results; UNSUPPORTED_PROTOCOL_VERSION: the outcome uses an unsupported protocol version.
+             * @enum {string}
+             */
+            readonly reason: "NOT_QUERIED" | "NATIVE_READ_FAILED" | "RPC_UNAVAILABLE" | "MALFORMED_RETURN" | "PROVIDER_DISAGREEMENT" | "UNSUPPORTED_PROTOCOL_VERSION";
+        };
+        readonly Result: components["schemas"]["ResultUnresolved"] | components["schemas"]["ResultNumeric"] | components["schemas"]["ResultNonnumeric"] | components["schemas"]["ResultUnavailable"];
+        readonly EligibilityEnabled: {
+            /**
+             * @description ENABLED: Totalis currently accepts new positions on this market.
+             * @constant
+             */
+            readonly state: "ENABLED";
+        };
+        readonly EligibilityDisabled: {
+            /**
+             * @description DISABLED: Totalis does not currently accept new positions on this market; reason says why.
+             * @constant
+             */
+            readonly state: "DISABLED";
+            /**
+             * @description Why new positions are refused. UNSUPPORTED_PROTOCOL_VERSION, UNSUPPORTED_QUOTE_ASSET and IDENTITY_CONFLICT are permanent support failures; MARKET_NOT_ACTIVE means the native market is no longer live; NATIVE_STATE_UNAVAILABLE, NATIVE_STATE_STALE, REFERENCE_UNAVAILABLE, REFERENCE_STALE and SOURCE_GENERATION_MISMATCH are temporary data outages; FINANCIAL_PROFILE_DISABLED means trading is switched off in this environment; SOURCE_UNQUALIFIED marks cached catalog copies that carry no live eligibility.
+             * @enum {string}
+             */
+            readonly reason: "UNSUPPORTED_PROTOCOL_VERSION" | "UNSUPPORTED_QUOTE_ASSET" | "IDENTITY_CONFLICT" | "DEADLINE_UNAVAILABLE" | "SOURCE_UNQUALIFIED" | "FINANCIAL_PROFILE_DISABLED" | "MARKET_NOT_ACTIVE" | "NATIVE_STATE_UNAVAILABLE" | "NATIVE_STATE_STALE" | "DEADLINE_BUFFER_ENTERED" | "REFERENCE_UNAVAILABLE" | "REFERENCE_STALE" | "SOURCE_GENERATION_MISMATCH";
+        };
+        readonly Eligibility: components["schemas"]["EligibilityEnabled"] | components["schemas"]["EligibilityDisabled"];
+        /** @description Reviewed UTC source windows and retained legacy admission metadata. These fields do not control trading availability. Null times require external evidence or are not defined. Settlement boundaries never promise settlement or mutate native lifecycle. */
+        readonly Timing: null | {
+            /** @description Scheduled time of the underlying event in Unix seconds, taken from the market definition; null when the template has no scheduled event. */
+            readonly scheduled_event_at: components["schemas"]["PositiveInt64"] | null;
+            /** @description End of the source observation window in Unix seconds, such as a price fixing time or touch deadline; null when the template defines none. */
+            readonly observation_ends_at: components["schemas"]["PositiveInt64"] | null;
+            /** @description Source backstop date in Unix seconds by which the market resolves even if the event has not happened; null when the template defines none. */
+            readonly resolution_backstop_at: components["schemas"]["PositiveInt64"] | null;
+            /** @description End of the evidence window in Unix seconds, the source evidence date plus evidence_delay_seconds; null when the template has no evidence date. */
+            readonly evidence_ends_at: components["schemas"]["PositiveInt64"] | null;
+            /** @description Earliest source-defined settlement instant in Unix seconds, qualified by settlement_boundary; null when unknown. It is not a promise that settlement happens then. */
+            readonly settlement_not_before: components["schemas"]["PositiveInt64"] | null;
+            /**
+             * @deprecated
+             * @description Legacy metadata only. Does not control market visibility or Combo entry. Use native lifecycle and eligibility.
+             */
+            readonly admission_cutoff_at: components["schemas"]["PositiveInt64"] | null;
+            /**
+             * @description Timing format version; currently always 1.
+             * @constant
+             */
+            readonly version: "1";
+            /**
+             * @description Hyperliquid network whose reviewed template definition produced these windows.
+             * @enum {unknown}
+             */
+            readonly network: "mainnet" | "testnet";
+            /** @description Hyperliquid outcome template the windows were read from, for example priceTouch or binaryPrice. */
+            readonly template_id: string;
+            /**
+             * @description How observation_ends_at bounds the window: INCLUSIVE includes that instant, EXCLUSIVE stops just before it, INSTANT means a single fixing at that instant, UNKNOWN means the template defines no observation boundary.
+             * @enum {unknown}
+             */
+            readonly observation_boundary: "INCLUSIVE" | "EXCLUSIVE" | "INSTANT" | "UNKNOWN";
+            /**
+             * @description INCLUSIVE allows settlement at settlement_not_before, EXCLUSIVE only after it; UNKNOWN exactly when settlement_not_before is null.
+             * @enum {unknown}
+             */
+            readonly settlement_boundary: "INCLUSIVE" | "EXCLUSIVE" | "UNKNOWN";
+            /** @description Reviewed code for how the template resolves, for example PRICE_OBSERVATION, TOUCH_OR_WINDOW_END or WINNER_OR_ELIMINATION_OR_BACKSTOP. */
+            readonly settlement_rule: string;
+            /**
+             * @deprecated
+             * @description Legacy classification retained for existing clients; no separate Totalis admission calendar is enforced.
+             * @enum {unknown}
+             */
+            readonly admission_policy: "BEFORE_SCHEDULED_EVENT" | "SOURCE_UPPER_BOUND" | "UNAVAILABLE";
+            /** @description Reviewed allowance in seconds between the event and the official result fixing; 0 when none applies. */
+            readonly fixing_delay_seconds: number;
+            /** @description Seconds added to the source evidence date to form evidence_ends_at; 0 when the template has no evidence window. */
+            readonly evidence_delay_seconds: number;
+            /** @description Code for the off-chain or venue event that can resolve the market, for example OFFICIAL_DECISION or TOUCH_OR_DELISTING; empty when none is defined. */
+            readonly external_event: string;
+            /** @description True when the market can resolve before its source window ends, for example on a price touch or an early official result. */
+            readonly early_resolution: boolean;
+        };
+        readonly DeadlineAvailable: {
+            /** @description Reviewed source windows for the market; null for markets without a reviewed template, such as recurring rounds. */
+            readonly timing: components["schemas"]["Timing"];
+            /**
+             * @description AVAILABLE: a source date was derived for this market.
+             * @constant
+             */
+            readonly availability: "AVAILABLE";
+            /**
+             * @deprecated
+             * @description Legacy buffered source-date metadata retained for compatibility. Neither this value nor its buffer controls trading, visibility or settlement.
+             */
+            readonly resolution_deadline: components["schemas"]["PositiveInt64"];
+            /**
+             * @deprecated
+             * @description Legacy source-date encoding only; not an execution buffer.
+             */
+            readonly safety_buffer_seconds: string;
+            /**
+             * @description How the source date was derived: STRUCTURED_METADATA from a reviewed template field, OPERATOR_OVERRIDE from a reviewed per-question override, PINNED_GRAMMAR from the retired description grammar.
+             * @enum {string}
+             */
+            readonly derivation_kind: "STRUCTURED_METADATA" | "PINNED_GRAMMAR" | "OPERATOR_OVERRIDE";
+            /** @description Reviewed market class the date rule applies to, for example PRICE_BINARY, PRICE_TOUCH or SPORTS_TOURNAMENT. */
+            readonly market_class: string;
+            /** @description Version of the date rule set that classified the market. */
+            readonly market_class_version: components["schemas"]["PositiveInt64"];
+            /** @description Version of the parser that read the source date from the market definition. */
+            readonly parser_version: components["schemas"]["PositiveInt64"];
+            /** @description Version of the legacy safety-buffer policy used for resolution_deadline. */
+            readonly buffer_version: components["schemas"]["PositiveInt64"];
+            /** @description SHA-256 of the native question or outcome definition the date was derived from. */
+            readonly source_digest: components["schemas"]["NonZeroBytes32"];
+            /** @description SHA-256 identifying the date rule set and template registry used for the derivation. */
+            readonly grammar_digest: components["schemas"]["NonZeroBytes32"];
+            /** @description SHA-256 of the raw source catalog snapshot the date was derived from. */
+            readonly fixture_digest: components["schemas"]["NonZeroBytes32"];
+        };
+        readonly DeadlineUnavailable: {
+            /** @description Reviewed source windows when the template supplies them even though no source date was derived; otherwise null. */
+            readonly timing: components["schemas"]["Timing"];
+            /**
+             * @description UNAVAILABLE: no source date could be derived; reason says why.
+             * @constant
+             */
+            readonly availability: "UNAVAILABLE";
+            /**
+             * @description UNQUALIFIED_MARKET_CLASS: no reviewed rule covers this market; MISSING_STRUCTURED_SOURCE: the template has no usable date field; AMBIGUOUS_DESCRIPTION: the definition could not be parsed to one date; UNSUPPORTED_PROTOCOL_VERSION: the outcome uses an unsupported protocol version.
+             * @enum {string}
+             */
+            readonly reason: "UNQUALIFIED_MARKET_CLASS" | "MISSING_STRUCTURED_SOURCE" | "AMBIGUOUS_DESCRIPTION" | "UNSUPPORTED_PROTOCOL_VERSION";
+        };
+        readonly Deadline: components["schemas"]["DeadlineAvailable"] | components["schemas"]["DeadlineUnavailable"];
+        readonly "$defs-DeadlineAvailable": {
+            /**
+             * @description AVAILABLE: a source date was derived for this market.
+             * @constant
+             */
+            readonly availability: "AVAILABLE";
+            /** @description Legacy buffered source date in Unix seconds: the source date plus safety_buffer_seconds. It does not control trading, visibility or settlement. */
+            readonly resolution_deadline: components["schemas"]["PositiveInt64"];
+            /** @description Legacy buffer in seconds added to the source date to form resolution_deadline; not an execution buffer. */
+            readonly safety_buffer_seconds: string;
+            /**
+             * @description How the source date was derived: STRUCTURED_METADATA from a reviewed template field, OPERATOR_OVERRIDE from a reviewed per-question override, PINNED_GRAMMAR from the retired description grammar.
+             * @enum {string}
+             */
+            readonly derivation_kind: "STRUCTURED_METADATA" | "PINNED_GRAMMAR" | "OPERATOR_OVERRIDE";
+            /** @description Reviewed market class the date rule applies to, for example PRICE_BINARY. */
+            readonly market_class: string;
+            /** @description Version of the date rule set that classified the market. */
+            readonly market_class_version: components["schemas"]["PositiveInt64"];
+            /** @description Version of the parser that read the source date from the market definition. */
+            readonly parser_version: components["schemas"]["PositiveInt64"];
+            /** @description Version of the legacy safety-buffer policy used for resolution_deadline. */
+            readonly buffer_version: components["schemas"]["PositiveInt64"];
+            /** @description SHA-256 of the native question or outcome definition the date was derived from. */
+            readonly source_digest: components["schemas"]["NonZeroBytes32"];
+            /** @description SHA-256 identifying the date rule set and template registry used for the derivation. */
+            readonly grammar_digest: components["schemas"]["NonZeroBytes32"];
+            /** @description SHA-256 of the raw source catalog snapshot the date was derived from. */
+            readonly fixture_digest: components["schemas"]["NonZeroBytes32"];
+        };
+        readonly "$defs-DeadlineUnavailable": {
+            /**
+             * @description UNAVAILABLE: no source date could be derived; reason says why.
+             * @constant
+             */
+            readonly availability: "UNAVAILABLE";
+            /**
+             * @description UNQUALIFIED_MARKET_CLASS: no reviewed rule covers this market; MISSING_STRUCTURED_SOURCE: the template has no usable date field; AMBIGUOUS_DESCRIPTION: the definition could not be parsed to one date; UNSUPPORTED_PROTOCOL_VERSION: the outcome uses an unsupported protocol version.
+             * @enum {string}
+             */
+            readonly reason: "UNQUALIFIED_MARKET_CLASS" | "MISSING_STRUCTURED_SOURCE" | "AMBIGUOUS_DESCRIPTION" | "UNSUPPORTED_PROTOCOL_VERSION";
+        };
+        readonly "$defs-Deadline": components["schemas"]["$defs-DeadlineAvailable"] | components["schemas"]["$defs-DeadlineUnavailable"];
+        /** Format: uint256-decimal */
+        readonly Uint: string;
+        readonly PublicationCatalogSide: {
+            /** @description Market side, YES or NO. */
+            readonly side: components["schemas"]["Side"];
+            /** @description Hyperliquid coin name of this side, # followed by outcome_id times 10 plus the side index. */
+            readonly coin: string;
+            /** @description Hyperliquid asset ID used to trade this side. */
+            readonly asset_id: components["schemas"]["Uint"];
+        };
+        readonly PublicationCatalogMarket: {
+            /** @description Hyperliquid outcome ID of the market. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /** @description Hyperliquid question ID, or 4294967295 for a standalone market. */
+            readonly native_question_id: components["schemas"]["UInt32String"];
+            /**
+             * @description STANDALONE for a market with no question, NAMED for a named outcome of a question, FALLBACK for a question's fallback outcome; absent from older producers.
+             * @enum {string}
+             */
+            readonly relationship_kind?: "FALLBACK" | "NAMED" | "STANDALONE";
+            /**
+             * @description SUPPORTED, or why Totalis cannot support the market: UNSUPPORTED_PROTOCOL_VERSION, UNSUPPORTED_QUOTE_ASSET or IDENTITY_CONFLICT; absent from older producers.
+             * @enum {string}
+             */
+            readonly support_state?: "SUPPORTED" | "UNSUPPORTED_PROTOCOL_VERSION" | "UNSUPPORTED_QUOTE_ASSET" | "IDENTITY_CONFLICT";
+            /** @description Display title derived from the market definition. */
+            readonly title: string;
+            /** @description Native lifecycle: ACTIVE, CLOSED or UNSUPPORTED. */
+            readonly state: components["schemas"]["MarketState"];
+            /** @description Native result as last read from HyperEVM. */
+            readonly result: components["schemas"]["Result"];
+            /** @description Revision of this market's catalog metadata; it increases when the metadata changes. */
+            readonly metadata_revision: components["schemas"]["PositiveInt64"];
+            /** @description Whether Totalis currently accepts new positions on this market. */
+            readonly eligibility: components["schemas"]["Eligibility"];
+            /** @description Hyperliquid deployer venue of the market, empty for Hyperliquid's own markets. Current producers always send it; when absent (older producers) consumers treat the deployer as unlisted and refuse the market as a Combo leg. */
+            readonly venue?: string;
+            /** @description Consumers-first rollout accepts the previous producer deadline without timing; current producers emit the full temporal deadline. Unknown fields remain rejected. */
+            readonly deadline: components["schemas"]["Deadline"] | components["schemas"]["$defs-Deadline"];
+            /** @description The YES and NO sides, in that order. */
+            readonly sides: readonly components["schemas"]["PublicationCatalogSide"][];
+            /** @description Publication version at which this item last changed; at most the packet's terminal version. */
+            readonly version: components["schemas"]["PositiveInt64"];
+        };
+        readonly SourceQualityPair: {
+            /**
+             * @description Hyperliquid price feed; HYPERLIQUID_FAST_ASSET_CTXS in this branch.
+             * @constant
+             */
+            readonly source: "HYPERLIQUID_FAST_ASSET_CTXS";
+            /**
+             * @description Asset context values carry BOOK_MID or MARK_PRICE quality.
+             * @enum {unknown}
+             */
+            readonly quality: "BOOK_MID" | "MARK_PRICE";
+        } | {
+            /**
+             * @description Hyperliquid price feed; HYPERLIQUID_ALL_MIDS in this branch.
+             * @constant
+             */
+            readonly source: "HYPERLIQUID_ALL_MIDS";
+            /**
+             * @description All-mids values always carry ALL_MIDS_FALLBACK quality.
+             * @constant
+             */
+            readonly quality: "ALL_MIDS_FALLBACK";
+        } | {
+            /**
+             * @description Hyperliquid price feed; HYPERLIQUID_L2_BOOK in this branch.
+             * @constant
+             */
+            readonly source: "HYPERLIQUID_L2_BOOK";
+            /**
+             * @description Order book values always carry BOOK_MID quality.
+             * @constant
+             */
+            readonly quality: "BOOK_MID";
+        } | {
+            /**
+             * @description Hyperliquid price feed; HYPERLIQUID_BBO in this branch.
+             * @constant
+             */
+            readonly source: "HYPERLIQUID_BBO";
+            /**
+             * @description Best bid and offer values always carry BOOK_MID quality.
+             * @constant
+             */
+            readonly quality: "BOOK_MID";
+        } | {
+            /**
+             * @description Hyperliquid price feed; HYPERLIQUID_TRADES in this branch.
+             * @constant
+             */
+            readonly source: "HYPERLIQUID_TRADES";
+            /**
+             * @description Trade values always carry TRADE quality.
+             * @constant
+             */
+            readonly quality: "TRADE";
+        };
+        /** @enum {string} */
+        readonly Source: "HYPERLIQUID_FAST_ASSET_CTXS" | "HYPERLIQUID_ALL_MIDS" | "HYPERLIQUID_L2_BOOK" | "HYPERLIQUID_BBO" | "HYPERLIQUID_TRADES";
+        /** @enum {string} */
+        readonly Quality: "BOOK_MID" | "MARK_PRICE" | "ALL_MIDS_FALLBACK" | "TRADE";
+        /**
+         * Format: uint256-decimal
+         * @description Nonnegative integer value paired with an explicit positive scale.
+         */
+        readonly IntegerValue: string;
+        /**
+         * Format: uint256-decimal
+         * @description Positive base-10 scale for an integer value.
+         */
+        readonly Scale: string;
+        readonly FeedReferenceAvailable: {
+            /**
+             * @description AVAILABLE: a qualified reference price has been observed for this side.
+             * @constant
+             */
+            readonly availability: "AVAILABLE";
+            /** @description Hyperliquid feed the reference price came from. */
+            readonly source: components["schemas"]["Source"];
+            /** @description How the reference price was derived; see the source and quality pairing. */
+            readonly quality: components["schemas"]["Quality"];
+            /** @description Reference price of this side as an integer: the book midpoint, or mark when the book is one-sided or empty, which is published only while mark is known. Divide by scale for the probability price between 0 and 1. */
+            readonly value: components["schemas"]["IntegerValue"];
+            /** @description Best bid at scale; set only for HYPERLIQUID_L2_BOOK and HYPERLIQUID_BBO sources when the book has bids, otherwise null. */
+            readonly best_bid?: components["schemas"]["IntegerValue"] | null;
+            /** @description Best ask at scale; set only for HYPERLIQUID_L2_BOOK and HYPERLIQUID_BBO sources when the book has asks, otherwise null. */
+            readonly best_ask?: components["schemas"]["IntegerValue"] | null;
+            /** @description Price of the latest book execution on this side at scale, kept across restarts; a fill prints on both sides at prices summing to scale. Null when no trade is known. */
+            readonly last_trade?: components["schemas"]["IntegerValue"] | null;
+            /** @description Hyperliquid time of last_trade, RFC 3339 UTC; null exactly when last_trade is null. */
+            readonly last_trade_at?: components["schemas"]["Timestamp"] | null;
+            /** @description Crowd probability at scale: the newest evidence (an execution, or the book midpoint while best_ask - best_bid is at most 10% of scale) kept within [best_bid, best_ask]. On a book wider than 50% of scale, one-sided or empty, it is null once that evidence is more than 20 minutes old. Null before any evidence. The midpoint rounds half to even, so YES and NO chances sum to scale. chance_basis says which applied. */
+            readonly chance?: components["schemas"]["IntegerValue"] | null;
+            /** @description Where chance comes from: MID, the current book midpoint; LAST_TRADE, last_trade inside the current book; HELD, earlier evidence kept within the current book (a midpoint the book no longer supports, or evidence clamped to best_bid or best_ask). Null exactly when chance is null. */
+            readonly chance_basis?: ("MID" | "LAST_TRADE" | "HELD") | null;
+            /** @description Value of one held share at scale: chance when known, else best_bid, else 0 when only asks exist; null when no book is known. Not a price a trade receives. */
+            readonly mark?: components["schemas"]["IntegerValue"] | null;
+            /** @description Divisor for value, best_bid, best_ask, last_trade, chance and mark; currently 1000000000000000000 (18 decimals). */
+            readonly scale: components["schemas"]["Scale"];
+            /**
+             * @description FRESH when received within the last 15 seconds, otherwise STALE.
+             * @enum {string}
+             */
+            readonly freshness: "FRESH" | "STALE";
+            /** @description Reference-price feed generation that produced this value; a higher generation starts whenever the feed is re-snapshotted, for example after a restart or catalog change. */
+            readonly feed_generation: components["schemas"]["PositiveInt64"];
+            /** @description Hyperliquid timestamp of the observation as RFC 3339 UTC; null when the source provides none. */
+            readonly source_time: components["schemas"]["Timestamp"] | null;
+            /** @description When Totalis received the observation, RFC 3339 UTC. */
+            readonly received_at: components["schemas"]["Timestamp"];
+        } & components["schemas"]["SourceQualityPair"];
+        readonly FeedReferenceUnavailable: {
+            /**
+             * @description UNAVAILABLE: no qualified reference price exists for this side; reason says why.
+             * @constant
+             */
+            readonly availability: "UNAVAILABLE";
+            /** @description Hyperliquid feed that was expected to supply the price. */
+            readonly source: components["schemas"]["Source"];
+            /**
+             * @description NOT_OBSERVED: no price seen yet; AMBIGUOUS_SOURCE: the source gave conflicting values; STALE_GENERATION: the last price belongs to an older feed generation; UNSUPPORTED_MARKET: the market is not supported; SOURCE_UNQUALIFIED: the copy carries no live price, as in cached catalog pages and finished markets that left the catalog.
+             * @enum {string}
+             */
+            readonly reason: "NOT_OBSERVED" | "AMBIGUOUS_SOURCE" | "STALE_GENERATION" | "UNSUPPORTED_MARKET" | "SOURCE_UNQUALIFIED";
+            /**
+             * @description Always UNKNOWN while no price is available.
+             * @constant
+             */
+            readonly freshness: "UNKNOWN";
+            /** @description Last update time of the market record this state was derived from, RFC 3339 UTC; 1970-01-01T00:00:00Z in cached catalog copies. */
+            readonly received_at: components["schemas"]["Timestamp"];
+        };
+        readonly FeedReference: components["schemas"]["FeedReferenceAvailable"] | components["schemas"]["FeedReferenceUnavailable"];
+        readonly PublicationReference: {
+            /** @description Hyperliquid outcome ID of the market. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /** @description Market side the reference belongs to, YES or NO. */
+            readonly side: components["schemas"]["Side"];
+            /** @description Current reference price of this side, or why none is available. */
+            readonly reference: components["schemas"]["FeedReference"];
+            /** @description Publication version at which this reference last changed. */
+            readonly version: components["schemas"]["PositiveInt64"];
+        };
+        readonly PublicationCatalogRemoval: {
+            /** @description Hyperliquid outcome ID removed from the catalog. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /** @description Publication version of the removal. */
+            readonly version: components["schemas"]["PositiveInt64"];
+        };
+        readonly PublicationReferenceRemoval: {
+            /** @description Hyperliquid outcome ID whose reference was removed. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /** @description Market side whose reference was removed, YES or NO. */
+            readonly side: components["schemas"]["Side"];
+            /** @description Publication version of the removal. */
+            readonly version: components["schemas"]["PositiveInt64"];
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+};
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;