@totalis/hip4-client 0.0.0-stage → 0.73.0

package/dist/generated/account-read.d.ts

@@ -0,0 +1,2015 @@
+export type paths = {
+    readonly "/v1/makers/{maker_id}/quotes": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Up to 50 current entry quotes for this maker, newest first, for its dashboard. Display fields only; never includes signatures. Partial list, not lifetime quote statistics. */
+        readonly get: operations["getMakerQuotes"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/me/maker": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Resolve the authenticated account canonical wallet and single admitted maker. Owner dashboard authority derives from verified wallet linkage and current indexed controller evidence, without an expiring dashboard grant. GET performs no provisioning or financial action. */
+        readonly get: operations["getOwnMaker"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/me/controlled-makers": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Discover maker vaults controlled by the authenticated participant linked wallets. Does not grant dashboard or transport access. Requires current indexed ownership. */
+        readonly get: operations["listControlledMakers"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/me/pnl": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Cumulative trading P&L of the account Portfolio shows, as a series for one range, computed on read. Core positions count realized cash plus held shares at their per-share value at each point; open Combos count nothing until their economic close. The credential selects the account and deployment. */
+        readonly get: operations["getAccountPnl"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/me/activity": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Durable scoped activity of the credential's account (a maker key reads its maker's) from qualified chain evidence and operations. The credential selects the account and deployment; requires current authorization. Returns 503 while the activity producer is disabled or source coverage is unavailable. */
+        readonly get: operations["listAccountActivity"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/me/activity/{activity_id}": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Durable scoped activity from qualified chain evidence and operations. The credential selects the deployment; requires current authorization. Returns 503 while the activity producer is disabled or source coverage is unavailable. */
+        readonly get: operations["getAccountActivity"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/capital": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description This maker's vault capital, reservations and action availability, reconciled against committed vault state. The credential selects the deployment. Access is checked against the credential's current permissions on every request. */
+        readonly get: operations["getMakerCapital"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/activity": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Durable scoped activity from qualified chain evidence and operations. The credential selects the deployment; requires current authorization. Returns 503 while the activity producer is disabled or source coverage is unavailable. */
+        readonly get: operations["listMakerActivity"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/activity/{activity_id}": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Durable scoped activity from qualified chain evidence and operations. The credential selects the deployment; requires current authorization. Returns 503 while the activity producer is disabled or source coverage is unavailable. */
+        readonly get: operations["getMakerActivity"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/positions": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Positions this maker wrote, reconciled against committed vault state. The credential selects the deployment. Access is checked against the credential's current permissions on every request. */
+        readonly get: operations["listMakerPositions"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/me/positions": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Positions of the credential's account, reconciled against committed vault state: the positions a personal credential holds, or the positions a maker key's maker wrote. The credential selects the account and deployment. Access is checked against the credential's current permissions on every request. */
+        readonly get: operations["listAccountPositions"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/me/positions/{position_id}": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description One position of the credential's account (held, or written by a maker key's maker) by position ID, reconciled against committed vault state. The credential selects the account and deployment. Access is checked against the credential's current permissions on every request. */
+        readonly get: operations["getAccountPosition"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/positions/{position_id}": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description One position this maker wrote, by position ID, reconciled against committed vault state. The credential selects the deployment. Access is checked against the credential's current permissions on every request. */
+        readonly get: operations["getMakerPosition"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/performance": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Performance of this maker per period. Complete periods aggregate the positions that closed economically in them; incomplete periods return unavailable metrics. Gas stays unavailable until the payer of every transaction receipt is attributed. The credential selects the deployment, and access is checked against its current permissions on every request. The maker is always the one named in the path, never inferred from the caller's account. */
+        readonly get: operations["getMakerPerformance"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/quote-history": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Every quote this maker published in a period, not only live ones, newest first, with each quote's status now and the period's fill rate. Display fields only; never signatures. Statuses map the venue's own states: an acceptance, the maker's answer and the trade's chain outcome decide first, then the quote's book state, then its RFQ. A decline carries no reason, since the maker's answer records none. */
+        readonly get: operations["listMakerQuoteHistory"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/exposure": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description This maker's open book by outcome at the vault projection checkpoint: per outcome its YES and NO exposure, gross and net, worst case and what offsetting saves, and what awaits settlement; book totals count each ticket once. Legs resolve as a position's do. Dashboard sessions only, like positions. */
+        readonly get: operations["getMakerExposure"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+    readonly "/v1/makers/{maker_id}/telemetry": {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: never;
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        /** @description Optional maker-reported capacity. Missing integration is unavailable; expired or revoked publisher observations are stale. Never financial authority. */
+        readonly get: operations["getMakerTelemetry"];
+        readonly put?: never;
+        readonly post?: never;
+        readonly delete?: never;
+        readonly options?: never;
+        readonly head?: never;
+        readonly patch?: never;
+        readonly trace?: never;
+    };
+};
+export type webhooks = Record<string, never>;
+export type components = {
+    schemas: {
+        readonly Amount: string;
+        readonly SignedAmount: string;
+        /** Format: date-time */
+        readonly Timestamp: string;
+        readonly Address: string;
+        readonly Digest: string;
+        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 Freshness of the read. Pages of one list share the snapshot bound into their cursor. */
+        readonly ReadContext: {
+            /** @description RFC3339 observation time of the oldest source this read used. */
+            readonly as_of: components["schemas"]["Timestamp"];
+            /**
+             * @description Freshness of the whole read. CURRENT: every source is fresh and reconciled. STALE: a source lags or has not reconciled, such as a catching-up projection, a pending reorg rescan or a period not fully covered; amounts may be displayed with their age but never authorize an action. UNAVAILABLE: a required source could not be read, so the amounts it backs are null.
+             * @enum {string}
+             */
+            readonly status: "CURRENT" | "STALE" | "UNAVAILABLE";
+        };
+        /** @description Signed amount in atomic USDC (6 decimals, "1000000" = 1 USDC); null when it could not be established, never zero in its place. */
+        readonly Metric: components["schemas"]["SignedAmount"] | null;
+        readonly Effect: {
+            /** @description Asset the delta is denominated in. */
+            readonly asset: components["schemas"]["Asset"];
+            /**
+             * @description Balance lane the delta applies to: WALLET, CORE_SPOT, CORE_MARGIN, VAULT_USER (the account's vault balance), MAKER_VAULT, STAKE_ESCROW, PAYABLE, REQUIREMENT, RESERVATION, IN_TRANSIT, REALIZED_PNL or FEE.
+             * @enum {string}
+             */
+            readonly bucket: "WALLET" | "CORE_SPOT" | "CORE_MARGIN" | "VAULT_USER" | "MAKER_VAULT" | "STAKE_ESCROW" | "PAYABLE" | "REQUIREMENT" | "RESERVATION" | "IN_TRANSIT" | "REALIZED_PNL" | "FEE";
+            /** @description Signed change to the bucket in atomic units of asset, e.g. "1000000" = 1 USDC on HyperEVM (6 decimals) and "100000000" = 1 USDC on HyperCore (8 decimals). Lane deltas are not summable income. */
+            readonly delta: components["schemas"]["SignedAmount"];
+            /**
+             * @description Economic meaning: EXTERNAL_CAPITAL (deposit or withdrawal across the subject boundary), INTERNAL_TRANSFER (move between the subject's own lanes), TRADE, FEE, HOLD (reservation) or CORRECTION (reorg reversal).
+             * @enum {string}
+             */
+            readonly classification: "EXTERNAL_CAPITAL" | "INTERNAL_TRANSFER" | "TRADE" | "FEE" | "HOLD" | "CORRECTION";
+        };
+        /** @enum {string} */
+        readonly ActivityKind: "DEPOSIT" | "WITHDRAWAL" | "INTERNAL_TRANSFER" | "ACCEPT" | "CASHOUT" | "POSITION_TRANSFER" | "SETTLEMENT" | "CLAIM" | "FILL" | "ORDER" | "CREDIT" | "CONVERSION" | "FUNDING" | "FEE" | "CORRECTION" | "REFUND";
+        readonly Activity: {
+            /** @description Stable activity identifier (64 lowercase hex characters), unchanged across revisions and replays. */
+            readonly activity_id: string;
+            /** @description Revision of this activity view, as a decimal string; increases when the activity is revised. */
+            readonly revision: string;
+            /** @description Commit-visible publication sequence of the activity's vault, as a decimal string. Lists order each vault's activity by sequence, then activity_id, descending; an account that has activity in more than one vault (after a vault redeploy) gets them merged, most recently recorded first. */
+            readonly sequence: string;
+            /** @description Business type of the activity, e.g. DEPOSIT, ACCEPT, SETTLEMENT, CLAIM, or CORRECTION for a reorg reversal. */
+            readonly kind: components["schemas"]["ActivityKind"];
+            /**
+             * @description PENDING: in progress; UNKNOWN: outcome not yet known; COMMITTED: final at its source; FAILED or REVERTED: took no effect and moves no committed cash; CORRECTED: a correction entry reversing superseded activity.
+             * @enum {string}
+             */
+            readonly status: "PENDING" | "UNKNOWN" | "COMMITTED" | "FAILED" | "REVERTED" | "CORRECTED";
+            /** @description RFC3339 evidence time; for workflow entries, the operation's creation time, which later revisions keep. Null when the occurrence time is uncertain, such as an order with no retained placement time. */
+            readonly occurred_at: string | null;
+            /**
+             * Format: date-time
+             * @description RFC3339 time the activity was recorded (ingest order).
+             */
+            readonly recorded_at: string;
+            /** @description Totalis operation IDs linked to the activity; empty when none. */
+            readonly operation_ids: readonly string[];
+            /** @description Position IDs (bytes32 hex) the activity concerns; empty when none. */
+            readonly position_ids: readonly string[];
+            /** @description Activity IDs this correction reverses; empty unless kind is CORRECTION. */
+            readonly supersedes: readonly string[];
+            /** @description HyperEVM transactions that back the activity, in evidence order; empty for HyperCore and venue-only records. */
+            readonly transaction_hashes: readonly components["schemas"]["Digest"][];
+            /** @description Balance effects for the scoped subject, each in its own asset; empty only for ORDER and POSITION_TRANSFER, which move no cash. */
+            readonly effects: readonly components["schemas"]["Effect"][];
+            /** @description Trade details for FILL, CONVERSION and CREDIT; null for every other kind and for entries recorded before trade details were retained. A CREDIT is an outcome settlement: it sells all size shares of side at price, what one share of that side paid at settlement, so the gross payout is size times price before the fee effect. */
+            readonly fill: components["schemas"]["Fill"] | null;
+            /** @description Address of the other party when known, such as a deposit's payer; null otherwise. */
+            readonly counterparty: string | null;
+            /** @description Machine-readable display code, e.g. DEPOSIT, WALLET_VAULT_TRANSFER, MAKER_WITHDRAW_REQUESTED or REORG_REVERSAL; defaults to the kind. */
+            readonly description_code: string;
+        } & (unknown & unknown & unknown & unknown & unknown);
+        readonly ActivityList: {
+            /** @description Freshness of this read: the oldest source observation and one status for every amount in the response. */
+            readonly context: components["schemas"]["ReadContext"];
+            /** @description Activities on this page, ordered by sequence, then activity_id, descending, within each vault; several vaults' activities are merged, most recently recorded first. */
+            readonly items: readonly components["schemas"]["Activity"][];
+            /** @description Opaque cursor for the next page, bound to this response's snapshot; null on the last page. Send it back unchanged as cursor. */
+            readonly next_cursor: components["schemas"]["NextCursor"];
+            /** @description True when another page exists; true exactly when next_cursor is non-null. */
+            readonly has_more: boolean;
+        };
+        readonly ActivityDetail: {
+            /** @description Freshness of this read: the oldest source observation and one status for every amount in the response. */
+            readonly context: components["schemas"]["ReadContext"];
+            /** @description The requested activity. */
+            readonly activity: components["schemas"]["Activity"];
+        };
+        /** @enum {string} */
+        readonly Permission: "READ_CAPITAL" | "READ_POSITIONS" | "READ_ACTIVITY" | "READ_PERFORMANCE" | "READ_TELEMETRY";
+        readonly MakerAccess: {
+            /** @description On-chain maker ID this access applies to, as a decimal string. */
+            readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+            /** @description Maker controller (owner) address the access was verified against. */
+            readonly owner: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Maker controller epoch at verification, as a decimal string; a controller change invalidates access derived from an earlier epoch. */
+            readonly owner_version: string;
+            /** @description Revision of the owner's wallet link, as a decimal string. It changes when the wallet is unlinked and relinked, which expires cursors bound to the old revision. */
+            readonly access_revision: string;
+            /** @description Read permissions held. They never authorize signing or spending. */
+            readonly permissions: readonly components["schemas"]["Permission"][];
+        };
+        /** @description A venue admission reservation on the maker vault. */
+        readonly Reservation: {
+            /** @description Stable reservation identifier. */
+            readonly reservation_id: string;
+            /** @description Operations holding this reservation. */
+            readonly operation_ids: readonly string[];
+            /** @description Reserved amount in atomic USDC (6 decimals, "1000000" = 1 USDC). */
+            readonly value: components["schemas"]["Amount"];
+            /**
+             * @description ACTIVE: held and not yet reflected on-chain; UNKNOWN: outcome unknown, still counted as held.
+             * @enum {string}
+             */
+            readonly status: "ACTIVE" | "UNKNOWN";
+        };
+        readonly ActionAvailability: {
+            /**
+             * @description Action this decision covers: MAKER_WITHDRAW or MAKER_QUOTE.
+             * @enum {string}
+             */
+            readonly action: "MAKER_WITHDRAW" | "MAKER_QUOTE";
+            /** @description Funding route the decision covers, e.g. MAKER_VAULT. */
+            readonly route: string;
+            /** @description Amount available for this action and route in atomic USDC (6 decimals, "1000000" = 1 USDC); null with blockers when unavailable. */
+            readonly available: components["schemas"]["UnsignedMetric"];
+            /** @description Machine-readable codes blocking the action, e.g. MAKER_WITHDRAW_PENDING or RECONCILIATION_MISMATCH; at least one when available is null. */
+            readonly blockers: readonly string[];
+        };
+        /** @description Maker capital lanes and derived collateral, in atomic USDC (6 decimals, "1000000" = 1 USDC). Amounts are null when unavailable; context.status is their freshness. */
+        readonly MakerCapital: {
+            /** @description Freshness of this read: the oldest source observation and one status for every amount in the response. */
+            readonly context: components["schemas"]["ReadContext"];
+            /** @description Maker owner (its controller) from the same indexed vault row as the lanes. */
+            readonly owner: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Maker signer (its quote signer) from the same indexed vault row as the lanes. The zero address means the maker was opened without one and cannot quote. */
+            readonly signer: string;
+            /** @description Maker vault lane V from the vault contract, including escrow and payables. */
+            readonly vault_gross: components["schemas"]["UnsignedMetric"];
+            /** @description Bettor net stakes escrowed in this maker's open tickets (E). */
+            readonly stake_escrow: components["schemas"]["UnsignedMetric"];
+            /** @description Settled winnings owed to ticket holders and not yet claimed (P). */
+            readonly payable_owed: components["schemas"]["UnsignedMetric"];
+            /** @description Original open maker exposure G: payout minus net stake summed over open tickets. */
+            readonly gross_open: components["schemas"]["UnsignedMetric"];
+            /** @description Maker discount lane D from the vault contract, which offsets gross_open in the requirement. */
+            readonly discount: components["schemas"]["UnsignedMetric"];
+            /** @description Collateral requirement R = max(G - min(D, G), ceil(G * floor_bps / 10000)) under the pinned release; null when floor_bps is null or an input is null. */
+            readonly requirement: components["schemas"]["UnsignedMetric"];
+            /** @description Collateral headroom F = max(V - E - P - R, 0). Not a guarantee of quote acceptance. */
+            readonly free_collateral: components["schemas"]["UnsignedMetric"];
+            /** @description Signed C = V - E - P. Excludes open-ticket valuation; not equity or NAV. */
+            readonly capital_net_of_senior_liabilities: components["schemas"]["Metric"];
+            /** @description Admission reservations H the venue holds for this maker that are not yet reflected on-chain; the sum of reservations. */
+            readonly pending_commitments: components["schemas"]["UnsignedMetric"];
+            /** @description max(F - H, 0): free collateral after unreflected commitments. Not private bot capacity. */
+            readonly free_after_pending: components["schemas"]["UnsignedMetric"];
+            /** @description Requirement floor K in basis points from the pinned release; null when the on-chain comparison mismatches, which makes requirement UNAVAILABLE. */
+            readonly floor_bps: number | null;
+            /** @description SHA-256 of the exact pinned artifact that names this deployment's chain and vault: the release artifact on chain 999, the environment's deployment manifest on 998. A client compares it with its own pinned artifact to bind the read to its deployment. */
+            readonly deployment_digest: string;
+            /** @description Decisions for MAKER_WITHDRAW and MAKER_QUOTE on the MAKER_VAULT route. MAKER_WITHDRAW is the amount a new withdrawal request may ask for: free_after_pending, so it never takes collateral from fills already admitted. The vault re-checks free collateral when the request executes after its delay; it is null with MAKER_WITHDRAW_PENDING while a request is live, or with a reconciliation blocker. MAKER_QUOTE is always null with one blocker, because quoting capacity depends on state only the maker's bot holds, such as its other live quotes. PRIVATE_QUOTE_CAPACITY_UNAVAILABLE means only that Totalis cannot compute that amount; it does not mean quoting is off, and the maker can keep quoting. A reconciliation blocker replaces it while the vault read and venue records disagree. */
+            readonly actions: readonly components["schemas"]["ActionAvailability"][];
+            /** @description Venue reservations on MAKER_VAULT that make up pending_commitments. */
+            readonly reservations: readonly components["schemas"]["Reservation"][];
+        } & unknown;
+        readonly Leg: {
+            /** @description HIP-4 outcome ID of the leg, as a decimal string. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /**
+             * @description Outcome side the position holds, YES or NO.
+             * @enum {string}
+             */
+            readonly side: "YES" | "NO";
+            /**
+             * @description RESOLVED: the outcome has a final result.
+             * @constant
+             */
+            readonly status: "RESOLVED";
+            /** @description Selected-side result factor over result_denominator: 100000000 is a full win, 0 a loss, values between are fractional. */
+            readonly result_numerator: string;
+            /**
+             * @description Always 100000000, the pinned grading scale.
+             * @constant
+             */
+            readonly result_denominator: "100000000";
+        } | {
+            /** @description HIP-4 outcome ID of the leg, as a decimal string. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /**
+             * @description Outcome side the position holds, YES or NO.
+             * @enum {string}
+             */
+            readonly side: "YES" | "NO";
+            /**
+             * @description UNRESOLVED: result still pending; UNAVAILABLE: historical result evidence is missing.
+             * @enum {unknown}
+             */
+            readonly status: "UNRESOLVED" | "UNAVAILABLE";
+            /** @description Null until the leg has a known result. */
+            readonly result_numerator: null;
+            /** @description Null until the leg has a known result. */
+            readonly result_denominator: null;
+        };
+        readonly Position: {
+            /** @description Position ID: the contract's ticketId (bytes32 hex). A ticketId is the EIP-712 digest of its quote under its vault's domain, so it names one position across every vault. */
+            readonly position_id: string;
+            /** @description Lowercase vault contract address the position is on. An account's positions span every vault the deployment has served: the active one, one running off and closed ones. */
+            readonly vault_address: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Whether the position's vault takes a cash-out. Only the active vault does; a position on a vault running off cannot be cashed out (`STATE_CONFLICT`) and pays out automatically when it settles. Whether this position can be cashed out now also depends on its status. */
+            readonly cashout_available: boolean;
+            /** @description Maker that wrote the position, as a decimal string. */
+            readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+            /** @description Current position owner wallet (lowercase). */
+            readonly owner: components["schemas"]["LowercaseNonZeroAddress"];
+            /**
+             * @description OPEN: not yet known eligible for settlement; AWAITING_SETTLEMENT: every leg resolved, or the payout with every unresolved leg counted as a win already rounds down to zero, but no settlement observed; SETTLED_UNCLAIMED: settled with profit still unclaimed; CLOSED: closed by zero-profit settlement, final claim or sell-back.
+             * @enum {string}
+             */
+            readonly status: "OPEN" | "AWAITING_SETTLEMENT" | "SETTLED_UNCLAIMED" | "CLOSED";
+            /** @description Profit fee in basis points, fixed when the position opened. The holder claims unclaimed_profit minus unclaimed_profit * fee_bps / 10000. */
+            readonly fee_bps: number;
+            /**
+             * @description How a CLOSED position closed: CLAIM (final claim of winnings) or SELL_BACK (bought back by the maker). Null otherwise, including direct zero-profit settlement closes and closes without retained evidence.
+             * @enum {string|null}
+             */
+            readonly close_reason: "CLAIM" | "SELL_BACK" | null;
+            /** @description Stake after the taker entry fee. */
+            readonly net_stake: components["schemas"]["UnsignedMetric"];
+            /** @description What the current owner paid for the whole position: the price of the latest transfer to them, or the gross stake with the entry fee if they have held it since opening. Settlement, claims and sell-back don't change it. Null when retained chain history has a gap that could hide a transfer. P&L compares it with what the owner gets back, settlement_payout or cashout_price, less the profit fee of fee_bps on the amount above net_stake, whatever the owner paid. */
+            readonly acquisition_cost: components["schemas"]["UnsignedMetric"];
+            /** @description Payout if every leg wins, as the maker signed it in the quote; the maker's initial exposure is payout minus net_stake. */
+            readonly payout: components["schemas"]["UnsignedMetric"];
+            /** @description Settlement payout observed on-chain; null before settlement and for sold-back positions. */
+            readonly settlement_payout: components["schemas"]["UnsignedMetric"];
+            /** @description Gross profit still claimable; "0" unless SETTLED_UNCLAIMED. The holder receives unclaimed_profit minus unclaimed_profit * fee_bps / 10000. */
+            readonly unclaimed_profit: components["schemas"]["UnsignedMetric"];
+            /** @description Cash-out price paid when the position was sold back; null unless close_reason is SELL_BACK. */
+            readonly cashout_price: components["schemas"]["UnsignedMetric"];
+            /** @description Position legs in ascending outcome_id order, with each leg's resolution. */
+            readonly legs: readonly components["schemas"]["Leg"][];
+            /**
+             * Format: date-time
+             * @description RFC3339 time of the position's opening event; lists order by it, newest first.
+             */
+            readonly created_at: string;
+            /**
+             * Format: date-time
+             * @description RFC3339 time of the position's latest lifecycle event.
+             */
+            readonly updated_at: string;
+            /**
+             * @description Settlement result: LOSS (zero payout), PARTIAL (payout below net stake), WIN (payout at or above net stake) or EARLY_LOST (lost before every leg resolved). Null before settlement, for sell-backs, or when historical evidence is missing.
+             * @enum {string|null}
+             */
+            readonly settlement_kind: "LOSS" | "PARTIAL" | "WIN" | "EARLY_LOST" | null;
+            /** @description The maker's signed P&L on this position once it closed economically: net_stake minus settlement_payout, or minus cashout_price for a sell-back; positive when the maker won. The same amount performance recognizes, so fees the owner paid never enter it. Null while OPEN or AWAITING_SETTLEMENT and when the close amount is unavailable. */
+            readonly maker_pnl: components["schemas"]["Metric"];
+            /**
+             * @description Sign of maker_pnl: WON (positive), LOST (negative) or EVEN (zero); null exactly when maker_pnl is null.
+             * @enum {string|null}
+             */
+            readonly maker_result: "WON" | "LOST" | "EVEN" | null;
+            /** @description Fees the vault took on this position so far, all paid by its owners and none by the maker: the taker entry fee at opening plus the profit fee withheld from each claim and from a sell-back. Null when retained history has a gap that could hide one. */
+            readonly protocol_fees: components["schemas"]["UnsignedMetric"];
+        } & (unknown & unknown & unknown & unknown & unknown & unknown & unknown & unknown);
+        readonly PositionList: {
+            /** @description Freshness of this read: the oldest source observation and one status for every amount in the response. */
+            readonly context: components["schemas"]["ReadContext"];
+            /** @description Positions on this page, newest created_at first, then position_id descending. */
+            readonly items: readonly components["schemas"]["Position"][];
+            /** @description Opaque cursor for the next page, bound to this response's snapshot; null on the last page. Send it back unchanged as cursor. */
+            readonly next_cursor: components["schemas"]["NextCursor"];
+            /** @description True when another page exists; true exactly when next_cursor is non-null. */
+            readonly has_more: boolean;
+            /** @description Exact number of positions in the whole filtered snapshot (not just this page), as a decimal string. */
+            readonly total_count: string;
+        };
+        readonly PositionDetail: {
+            /** @description Freshness of this read: the oldest source observation and one status for every amount in the response. */
+            readonly context: components["schemas"]["ReadContext"];
+            /** @description The requested position. */
+            readonly position: components["schemas"]["Position"];
+        };
+        /** @description Maker realized performance for a period. Every period aggregate is null unless the whole period is covered by reconciled history. */
+        readonly Performance: {
+            /** @description Freshness of this read: the oldest source observation and one status for every amount in the response. */
+            readonly context: components["schemas"]["ReadContext"];
+            /**
+             * Format: date-time
+             * @description Inclusive RFC3339 start of the requested period, echoed from the query.
+             */
+            readonly from: string;
+            /**
+             * Format: date-time
+             * @description Exclusive RFC3339 end of the requested period, echoed from the query.
+             */
+            readonly through: string;
+            /**
+             * @description P&L recognition rule: realized at economic close (settlement or sell-back), version 1. Claims do not recognize P&L again.
+             * @constant
+             */
+            readonly recognition: "REALIZED_AT_ECONOMIC_CLOSE_V1";
+            /**
+             * Format: date-time
+             * @description Earliest from this maker's periods can start at and still be complete: the later of where retained vault history and venue workflows begin, or the maker's opening block if later still. Request from=history_from for an all-time period. Null while vault history is unavailable.
+             */
+            readonly history_from: string | null;
+            /** @description Tickets economically closed in the period, as a decimal string; null when settled_net_stake is null. */
+            readonly closed_ticket_count: string | null;
+            /** @description Closes in the period the maker won (positive maker P&L), as a decimal string; null exactly when closed_ticket_count is null. */
+            readonly won_ticket_count: string | null;
+            /** @description Closes in the period the maker lost (negative maker P&L), as a decimal string; null exactly when closed_ticket_count is null. */
+            readonly lost_ticket_count: string | null;
+            /** @description Closes in the period with zero maker P&L, as a decimal string; null exactly when closed_ticket_count is null. Won, lost and even add up to closed_ticket_count. */
+            readonly even_ticket_count: string | null;
+            /** @description Net stake released by economic closes in the period. */
+            readonly settled_net_stake: components["schemas"]["UnsignedMetric"];
+            /** @description Signed maker trading P&L from closes in the period (net stake minus effective payout). */
+            readonly gross_trading_pnl: components["schemas"]["Metric"];
+            /** @description Sum of the maker P&L of the period's closes the maker won (each positive), so never negative. gross_winning_pnl + gross_losing_pnl = gross_trading_pnl; profit factor is gross_winning_pnl / -gross_losing_pnl. */
+            readonly gross_winning_pnl: components["schemas"]["Metric"];
+            /** @description Sum of the maker P&L of the period's closes the maker lost (each negative), so never positive. */
+            readonly gross_losing_pnl: components["schemas"]["Metric"];
+            /** @description Fees the maker paid in the period. Taker fees are not maker expenses. */
+            readonly attributed_fees: components["schemas"]["UnsignedMetric"];
+            /** @description Signed gross_trading_pnl minus attributed_fees. */
+            readonly net_trading_pnl: components["schemas"]["Metric"];
+            /** @description Deposits into the maker vault in the period; never P&L. */
+            readonly external_inflows: components["schemas"]["UnsignedMetric"];
+            /** @description Executed maker withdrawals in the period; never P&L. */
+            readonly external_outflows: components["schemas"]["UnsignedMetric"];
+            /** @description Cumulative net realized P&L at UTC day boundaries within the requested interval, from the same revision as totals, in atomic USDC (6 decimals, "1000000" = 1 USDC): the opening zero point at from, one point per UTC day with closes or maker-paid fees, then through if no day ends there. Each point carries the closes since the previous one, so a day with closes is told apart from the synthetic endpoints. Empty when net_trading_pnl is null. */
+            readonly series?: readonly {
+                /**
+                 * Format: date-time
+                 * @description Point time: from for the opening zero point, then the end of each UTC day with closes (capped at through), then through.
+                 */
+                readonly at: string;
+                /** @description Cumulative signed net trading P&L from from up to at, in atomic USDC (6 decimals, "1000000" = 1 USDC). */
+                readonly net_trading_pnl: string;
+                /** @description Closes since the previous point, as a decimal string: the day's closes for a day point ("0" only on a day whose maker-paid fees moved P&L); "0" for the opening point and for a through point added after the last such day. */
+                readonly closed_ticket_count: string;
+                /** @description Net trading P&L of those closes: net_trading_pnl minus the previous point's. A day point with closes is a real close day even when this is "0". */
+                readonly net_trading_pnl_change: string;
+            }[];
+        } & (unknown & unknown & unknown);
+        readonly TelemetryData: {
+            readonly publisher_id: string;
+            readonly sequence: string;
+            /** Format: date-time */
+            readonly observed_at: string;
+            /** Format: date-time */
+            readonly expires_at: string;
+            /** @constant */
+            readonly product: "OUTCOME_TICKET";
+            readonly risk_scope: string;
+            readonly risk_revision: string;
+            /** @description Quoting capacity the maker reported, in atomic USDC (6 decimals, "1000000" = 1 USDC); null when it reported none. */
+            readonly quoting_capacity: components["schemas"]["UnsignedMetric"];
+            /** @enum {string} */
+            readonly bot_status: "QUOTING" | "PAUSED" | "DEGRADED" | "STOPPED";
+            readonly reason: string | null;
+        };
+        readonly Telemetry: {
+            /** @description Freshness of this read: the oldest source observation and one status for every amount in the response. */
+            readonly context: components["schemas"]["ReadContext"];
+            readonly telemetry: ({
+                /** @enum {string} */
+                readonly status: "CURRENT" | "STALE";
+                readonly data: components["schemas"]["TelemetryData"];
+                readonly reason: string | null;
+            } & unknown) | {
+                /** @constant */
+                readonly status: "UNAVAILABLE";
+                readonly data: null;
+                readonly reason: string;
+            };
+        };
+        /** @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 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;
+        };
+        /** @description Non-negative amount in atomic USDC (6 decimals, "1000000" = 1 USDC); null when it could not be established, never zero in its place. */
+        readonly UnsignedMetric: components["schemas"]["Amount"] | null;
+        /** Format: uint64-decimal */
+        readonly UInt64String: string;
+        readonly NonZeroUInt64String: components["schemas"]["UInt64String"] & unknown;
+        readonly DashboardQuotes: {
+            /** Format: date-time */
+            readonly generated_at: string;
+            readonly quotes: readonly {
+                /** Format: uuid */
+                readonly rfq_id: string;
+                /** @description Bettor stake in atomic USDC (6 decimals), before taker fees. */
+                readonly stake: string;
+                /** @description Stake less the quote's taker fee, floor(stake * taker_fee_bps / 10000), in atomic USDC (6 decimals): what the vault escrows if the quote fills. Payout minus net_stake is the maker's risk. */
+                readonly net_stake: string;
+                /** @description Signed potential bettor payout in atomic USDC (6 decimals). */
+                readonly payout: string;
+                /** @description Quote expiry as Unix epoch seconds. */
+                readonly expiry: string;
+                readonly legs: number;
+            }[];
+        };
+        /**
+         * @description Stable HTTP error code. Each code has one HTTP status and one retry value.
+         * @enum {string}
+         */
+        readonly ErrorCode: "INVALID_REQUEST" | "INVALID_QUERY" | "INVALID_CURSOR" | "INVALID_IDEMPOTENCY_KEY" | "ORIGIN_REQUIRED" | "SUBPROTOCOL_REQUIRED" | "UNSUPPORTED_BROWSE_CONTRACT" | "UNAUTHENTICATED" | "FORBIDDEN" | "ORIGIN_NOT_ALLOWED" | "ACCESS_REQUIRED" | "SIGN_IN_REQUIRED" | "NOT_FOUND" | "IDENTITY_NOT_FOUND" | "QUOTE_NOT_FOUND" | "INVITE_CODE_NOT_FOUND" | "IDEMPOTENCY_KEY_REUSED" | "STATE_CONFLICT" | "INVITE_CODE_EXHAUSTED" | "STALE_CURSOR" | "CURSOR_EXPIRED" | "CURSOR_RESET" | "RECURRING_DEFINITION_CONFLICT" | "EMBEDDED_WALLET_CONFLICT" | "SECRET_UNAVAILABLE" | "ROTATION_IN_PROGRESS" | "TELEMETRY_CONFLICT" | "RFQ_NOT_CANCELLABLE" | "RFQ_NOT_OPEN" | "RFQ_GENERATION_STALE" | "RFQ_GENERATION_IN_FLIGHT" | "QUOTE_EXPIRED" | "QUOTE_CANCELLED" | "QUOTE_REPLACED" | "QUOTE_SIGNER_CHANGED" | "QUOTE_CAPACITY_EXCEEDED" | "CORE_ACCOUNT_NOT_READY" | "CORE_ACCOUNT_ACTIVATION_REQUIRED" | "CORE_EXIT_ABANDONED" | "CORE_MOVE_IN_FLIGHT" | "ACCEPTANCE_IN_FLIGHT" | "USERNAME_TAKEN" | "USERNAME_ALREADY_SET" | "USERNAME_REQUIRED" | "INVALID_SIGNATURE" | "WALLET_CONTRACT_UNSUPPORTED" | "WRONG_AUTHORITY" | "KEY_LIMIT_REACHED" | "USERNAME_NOT_ALLOWED" | "FOLLOW_SELF" | "FOLLOW_LIMIT_REACHED" | "RATE_LIMITED" | "CONNECTION_LIMIT" | "RFQ_INTENT_LIMIT" | "QUOTE_EXPOSURE_LIMIT" | "DEPENDENCY_STALE" | "AUTHORIZATION_UNAVAILABLE" | "SOURCE_UNAVAILABLE" | "CONTRACT_UNAVAILABLE" | "MARKET_DATA_UNAVAILABLE" | "BROWSE_UNAVAILABLE" | "FINANCIAL_ACTIONS_DISABLED" | "CORE_EXIT_UNAVAILABLE" | "COLLATERAL_REDUCTION_UNAVAILABLE" | "SPONSORSHIP_UNAVAILABLE" | "CONTRACT_SIGNATURE_OVERLOADED" | "QUOTE_EXPOSURE_STALE" | "COMBO_AUTOMATIC_DISABLED" | "GAS_PRICE_ABOVE_CEILING" | "EMBEDDED_WALLET_UNAVAILABLE" | "CONNECTION_DRAIN";
+        readonly FieldViolation: {
+            /**
+             * @description REQUIRED: the input is missing. INVALID: it is present but malformed or out of range. UNEXPECTED: the input is not accepted here.
+             * @enum {string}
+             */
+            readonly code: "REQUIRED" | "INVALID" | "UNEXPECTED";
+            /** @description JSON pointer into the body, or into the query parameters as one flat object for requests without a body, for example /legs/0/stake or /limit. */
+            readonly field: string;
+        };
+        /**
+         * @description NEVER: stop. BACKOFF: resend the same request with the same Idempotency-Key after Retry-After. REFRESH: re-read state, then send a new request with a new Idempotency-Key.
+         * @enum {string}
+         */
+        readonly Retry: "NEVER" | "BACKOFF" | "REFRESH";
+        readonly ErrorDetail: {
+            /** @description Stable registered code; branch on this, not on message or status. */
+            readonly code: components["schemas"]["ErrorCode"];
+            /** @description Each invalid input by JSON pointer; empty when the error is not about a specific input. */
+            readonly field_violations: readonly components["schemas"]["FieldViolation"][];
+            /** @description Human-readable; may change without notice. */
+            readonly message: string;
+            /**
+             * Format: uuid
+             * @description UUIDv7 of this request, also returned in the X-Request-ID header. Quote it when reporting a problem.
+             */
+            readonly request_id: string;
+            /** @description What the caller should do next; fixed by the registry for each code. */
+            readonly retry: components["schemas"]["Retry"];
+        };
+        readonly Error: {
+            /** @description The one error this request failed with. */
+            readonly error: components["schemas"]["ErrorDetail"];
+        };
+        readonly LowercaseNonZeroAddress: string;
+        readonly OwnMaker: {
+            /**
+             * @description Account-read contract version; always "1" for this response shape.
+             * @constant
+             */
+            readonly contract_version: "1";
+            /** @description EVM chain ID of the deployment the credential is bound to, as a decimal string (999 on HyperEVM Mainnet). */
+            readonly chain_id: string;
+            /** @description Lowercase address of the vault contract of the credential's deployment. */
+            readonly vault: components["schemas"]["LowercaseNonZeroAddress"];
+            /**
+             * Format: date-time
+             * @description RFC3339 UTC time the server built this response.
+             */
+            readonly generated_at: string;
+            /** @description Maker ownership state of the caller's account, derived from its linked wallet and indexed on-chain controller evidence. */
+            readonly ownership: {
+                /**
+                 * @description NOT_CREATED: the account's wallet controls no maker; WALLET_REQUIRED: the account has no single qualifying linked wallet; OWNERSHIP_CONFLICT: several candidate wallets, or the maker's current controller no longer matches; READY: the maker is admitted and current; PENDING: the maker profile awaits admission; RESTRICTED: the maker profile is restricted or closed; SETUP_REQUIRED: a maker controlled by the wallet exists on-chain but has no admitted profile yet.
+                 * @enum {string}
+                 */
+                readonly state: "NOT_CREATED" | "WALLET_REQUIRED" | "OWNERSHIP_CONFLICT" | "READY" | "PENDING" | "RESTRICTED" | "SETUP_REQUIRED";
+                /** @description Linked wallet that controls (owns) the maker; absent when the account has no single qualifying linked wallet. */
+                readonly owner?: components["schemas"]["LowercaseNonZeroAddress"];
+                /** @description The admitted maker and the caller's owner access to it; null unless state is READY, PENDING or RESTRICTED. */
+                readonly maker: components["schemas"]["MakerAccess"] | null;
+            };
+        };
+        /**
+         * @description Maximum items in one page. A page may hold fewer, even none, while has_more is true.
+         * @default 50
+         */
+        readonly PageLimit: number;
+        /** @description Opaque list cursor. Send a previous response's next_cursor back unchanged; never build or parse one. */
+        readonly PageCursor: string;
+        /** Format: eip55-address */
+        readonly "$defs-Address": string;
+        /** @description Opaque cursor for the next page, or null when has_more is false. */
+        readonly NextCursor: string | null;
+        readonly ControlledMakerList: {
+            /**
+             * @description Account-read contract version; always "1" for this response shape.
+             * @constant
+             */
+            readonly contract_version: "1";
+            /** @description EVM chain ID of the deployment the credential is bound to, as a decimal string (999 on HyperEVM Mainnet). */
+            readonly chain_id: string;
+            /** @description Lowercase address of the vault contract of the credential's deployment. */
+            readonly vault: components["schemas"]["LowercaseNonZeroAddress"];
+            /** @description Makers in this vault whose on-chain controller is one of the caller's linked wallets, in ascending maker_id order. Discovery only; grants no access. */
+            readonly items: readonly {
+                /** @description On-chain maker ID in the vault, as a decimal string. */
+                readonly maker_id: components["schemas"]["NonZeroUInt64String"];
+                /** @description Maker controller (owner) address; one of the caller's linked wallets. */
+                readonly owner: components["schemas"]["LowercaseNonZeroAddress"];
+                /** @description Address currently authorized to sign the maker's quotes. */
+                readonly signer: components["schemas"]["$defs-Address"];
+            }[];
+            /** @description Opaque cursor for the next page; null on the last page. Send it back unchanged as cursor. */
+            readonly next_cursor: components["schemas"]["NextCursor"];
+            /** @description True when another page exists; true exactly when next_cursor is non-null. */
+            readonly has_more: boolean;
+            /**
+             * Format: date-time
+             * @description RFC3339 UTC time the server built this response.
+             */
+            readonly generated_at: string;
+        };
+        /** @description Cumulative trading P&L of the account Portfolio shows, computed on read: Core trading plus Combos closed in the deployment's vault. Points are cumulative since tracked_since, not rebased: a window's change is its last point minus its first. Deposits, withdrawals and moves between Core and the vault never move it. */
+        readonly PnL: {
+            /**
+             * @description The requested range, echoed.
+             * @enum {string}
+             */
+            readonly range: "1D" | "1W" | "1M" | "ALL";
+            /** @description Where P&L starts: the later of the start of the account's recorded Core history and 2026-10-09T00:00:00Z, the first whole day of stored values; P&L is cumulative from here. It does not prove that history is complete: a fill gap, an unbridged cash gap or holdings the history cannot reproduce make the read UNAVAILABLE with tracked_since still set. Null while the wallet is not yet observed, with no points and a STALE context. */
+            readonly tracked_since: components["schemas"]["Timestamp"] | null;
+            /** @description Ascending instants: the window start (never before tracked_since), every round UTC step boundary inside it (1D every 15 minutes, 1W every hour, 1M every 6 hours, ALL an adaptive step of at most 200 points), then the read time valued at live marks. */
+            readonly points: readonly {
+                /** @description Point time. */
+                readonly at: components["schemas"]["Timestamp"];
+                /** @description Cumulative P&L from tracked_since up to at, in atomic USDC (6 decimals, "1000000" = 1 USDC), rounded once, half away from zero. Null when a share held at at has no known value, when at precedes the first known value of shares held at tracked_since (every earlier point is null), or when the read is UNAVAILABLE; null is never zero. */
+                readonly pnl: components["schemas"]["SignedAmount"] | null;
+            }[];
+            /** @description Freshness of this read. as_of is the valuation instant, the last point's at: it values the history at that instant's marks, and STALE says a source lags. UNAVAILABLE nulls every point. */
+            readonly context: components["schemas"]["ReadContext"];
+        };
+        /** @description Asset an effect moves. Deltas of different assets are different units and are never summed or compared. */
+        readonly Asset: {
+            /** @description Stable asset identifier. HyperEVM tokens use CAIP-19 `eip155:<chain_id>/erc20:<lowercase address>`; HyperCore spot tokens use `hypercore:<mainnet|testnet>/token:<spotMeta tokenId>`. */
+            readonly asset_id: string;
+            /** @description Display symbol, e.g. USDC or HYPE. Not an identity (HyperEVM USDC and HyperCore USDC share it), but USDC is one dollar per whole unit on either chain. */
+            readonly symbol: string;
+            /** @description Scale of the asset's atomic unit: 6 for HyperEVM USDC, 8 for HyperCore USDC and HYPE. */
+            readonly decimals: number;
+        };
+        readonly UInt32String: string;
+        /** @enum {string} */
+        readonly Side: "YES" | "NO";
+        /** @description The traded leg of a HyperCore fill, conversion or settlement credit. Cash and fees stay in effects. */
+        readonly Fill: {
+            /** @description HIP-4 outcome ID traded, as a decimal string. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /** @description Outcome side traded, YES or NO. */
+            readonly side: components["schemas"]["Side"];
+            /**
+             * @description BUY or SELL of side, as Hyperliquid reported it; always SELL for a settlement credit.
+             * @enum {string}
+             */
+            readonly direction: "BUY" | "SELL";
+            /** @description Shares filled, as an exact decimal string with no trailing zeros. */
+            readonly size: string;
+            /** @description Price per share in USDC, as an exact decimal string with no trailing zeros; 0 is possible for a conversion leg or a losing settlement. */
+            readonly price: string;
+            /** @description Hyperliquid order ID, as a decimal string. */
+            readonly oid: components["schemas"]["UInt64String"];
+            /** @description Hyperliquid trade ID, as a decimal string. */
+            readonly tid: components["schemas"]["NonZeroUInt64String"];
+        };
+        /**
+         * @description Where the quote stands now. OPEN: live and acceptable. AWAITING_CONFIRMATION: the taker accepted it and the maker has not answered within its two-second deadline yet. ACCEPTED: the maker confirmed and the trade is queued or on its way to chain. FILLED: the trade committed on chain. FAILED: the trade reverted or expired unexecuted. DECLINED: the maker declined the acceptance. TIMED_OUT: the maker did not answer the acceptance in time. CANCELLED: the maker withdrew the quote. REPLACED: the maker's newer quote on the same RFQ replaced it. EXPIRED: it or its RFQ lapsed unaccepted. NOT_SELECTED: the RFQ's taker accepted another quote first. RFQ_CANCELLED: the taker cancelled or replaced the RFQ.
+         * @enum {string}
+         */
+        readonly QuoteHistoryStatus: "OPEN" | "AWAITING_CONFIRMATION" | "ACCEPTED" | "FILLED" | "FAILED" | "DECLINED" | "TIMED_OUT" | "CANCELLED" | "REPLACED" | "EXPIRED" | "NOT_SELECTED" | "RFQ_CANCELLED";
+        /** @description Fill rate of the period's quotes; status filters do not apply to it. */
+        readonly QuoteFillRate: {
+            /** @description Quotes the maker published in the period (of the requested kind), every replacement counted, whatever their status. */
+            readonly submitted_count: string;
+            /** @description Of those, quotes whose trade committed on chain (status FILLED). */
+            readonly filled_count: string;
+            /** @description floor(filled_count * 10000 / submitted_count) in basis points; null when submitted_count is 0. */
+            readonly fill_rate_bps: string | null;
+        };
+        /** @description One quote the maker published, display fields only; never a signature. A decline carries no reason: the maker's answer records none. */
+        readonly QuoteHistoryItem: {
+            /** @description Quote ID: the digest the maker signs on confirmation (bytes32 hex). */
+            readonly quote_id: string;
+            /**
+             * Format: uuid
+             * @description RFQ the quote answered.
+             */
+            readonly rfq_id: string;
+            /**
+             * @description ENTRY opens a position; CASHOUT buys one back (SELL_BACK) or buys it (TRANSFER).
+             * @enum {string}
+             */
+            readonly kind: "ENTRY" | "CASHOUT";
+            /**
+             * @description For a CASHOUT quote, SELL_BACK when the position's own maker buys it back, TRANSFER when another maker buys it; null for ENTRY.
+             * @enum {string|null}
+             */
+            readonly cashout_kind: "SELL_BACK" | "TRANSFER" | null;
+            /** @description Where the quote stands now. OPEN, AWAITING_CONFIRMATION and ACCEPTED can still change; every other status is final. FILLED is the only status in which the quote traded. */
+            readonly status: components["schemas"]["QuoteHistoryStatus"];
+            /**
+             * Format: date-time
+             * @description When the venue admitted the quote; lists order by it, newest first.
+             */
+            readonly submitted_at: string;
+            /**
+             * Format: date-time
+             * @description The quote's own expiry.
+             */
+            readonly expires_at: string;
+            /**
+             * Format: date-time
+             * @description When the taker accepted the quote; null if no taker did.
+             */
+            readonly accepted_at: string | null;
+            /**
+             * Format: date-time
+             * @description When the quote reached its status: the trade's chain receipt for FILLED and FAILED, the confirmation deadline for TIMED_OUT, the winning selection for NOT_SELECTED, the earlier of the quote's and the RFQ's expiry for EXPIRED. Null while OPEN, AWAITING_CONFIRMATION or ACCEPTED, and for DECLINED, CANCELLED, REPLACED and RFQ_CANCELLED, whose time the venue does not record.
+             */
+            readonly resolved_at: string | null;
+            /** @description The trade's operation once the maker confirmed; null otherwise. */
+            readonly operation_id: string | null;
+            /** @description For ENTRY, the position the quote opened once FILLED (its quote_id); for CASHOUT, the position being cashed out; null otherwise. */
+            readonly position_id: string | null;
+            /** @description An ENTRY quote's legs in the RFQ's order; null for CASHOUT. */
+            readonly legs: readonly {
+                /** @description HIP-4 outcome ID of the leg. */
+                readonly outcome_id: components["schemas"]["UInt32String"];
+                /**
+                 * @description Side the taker would hold.
+                 * @enum {string}
+                 */
+                readonly side: "YES" | "NO";
+            }[] | null;
+            /** @description ENTRY: the taker's gross stake, before the entry fee. Null for CASHOUT. The quoted odds are payout / stake. */
+            readonly stake: components["schemas"]["UnsignedMetric"];
+            /** @description ENTRY: stake less the taker entry fee floor(stake * taker_fee_bps / 10000), what the vault escrows. Null for CASHOUT, or when the quote's fee was never admitted. */
+            readonly net_stake: components["schemas"]["UnsignedMetric"];
+            /** @description ENTRY: what the taker receives if every leg wins. Null for CASHOUT. */
+            readonly payout: components["schemas"]["UnsignedMetric"];
+            /** @description ENTRY: what the maker stands to pay, payout minus net_stake. Null when net_stake is. */
+            readonly maker_risk: components["schemas"]["UnsignedMetric"];
+            /** @description CASHOUT: the price offered for the whole position. Null for ENTRY. */
+            readonly price: components["schemas"]["UnsignedMetric"];
+        } & (unknown & unknown & unknown & unknown);
+        /** @description Every quote the maker published in a period, not only live ones, with the period's fill rate. */
+        readonly QuoteHistory: {
+            /** @description Freshness of this read. Quotes are venue rows read now; FILLED and FAILED follow the vault projection, so as_of is its checkpoint and status is STALE while it lags. */
+            readonly context: components["schemas"]["ReadContext"];
+            /**
+             * Format: date-time
+             * @description Inclusive RFC3339 start of the period on submitted_at, echoed from the query.
+             */
+            readonly from: string;
+            /**
+             * Format: date-time
+             * @description Exclusive RFC3339 end of the period, echoed from the query.
+             */
+            readonly through: string;
+            /** @description The period's fill rate, on a list's first page (no cursor); null on later pages. */
+            readonly fill_rate: components["schemas"]["QuoteFillRate"] | null;
+            /** @description Quotes on this page, newest submitted_at first. Each status is read when the page is. */
+            readonly items: readonly components["schemas"]["QuoteHistoryItem"][];
+            /** @description Opaque cursor for the next page; null on the last page. Send it back unchanged as cursor with the same filters. */
+            readonly next_cursor: components["schemas"]["NextCursor"];
+            /** @description True exactly when next_cursor is non-null. A status-filtered page reads at most 1,000 quotes, so it may hold fewer items than limit, even none, while has_more is true. */
+            readonly has_more: boolean;
+        };
+        /** @description The maker's exposure on one outcome. A multi-leg ticket counts under every outcome it touches, so outcome amounts do not add up to the book's. */
+        readonly OutcomeExposure: {
+            /** @description HIP-4 outcome ID. */
+            readonly outcome_id: components["schemas"]["UInt32String"];
+            /** @description Open tickets with an unresolved leg on this outcome. */
+            readonly open_ticket_count: string;
+            /** @description Sum of the worst-case maker cost of open tickets whose unresolved leg on this outcome is YES. */
+            readonly yes_exposure: components["schemas"]["Amount"];
+            /** @description The same for tickets whose leg on this outcome is NO. */
+            readonly no_exposure: components["schemas"]["Amount"];
+            /** @description yes_exposure + no_exposure: the outcome's exposure with no offsetting. */
+            readonly gross_exposure: components["schemas"]["Amount"];
+            /** @description yes_exposure - no_exposure: positive when the maker is exposed to YES. */
+            readonly net_exposure: components["schemas"]["SignedAmount"];
+            /** @description max(yes_exposure, no_exposure): the most the outcome's tickets can cost the maker, whatever its result, since a result of v pays at most v x YES + (1 - v) x NO. */
+            readonly worst_case: components["schemas"]["Amount"];
+            /** @description min(yes_exposure, no_exposure) = gross_exposure - worst_case: what offsetting sides save on this outcome. */
+            readonly netting_savings: components["schemas"]["Amount"];
+            /** @description Tickets on this outcome eligible for settlement but not yet settled. */
+            readonly awaiting_ticket_count: string;
+            /** @description Their exact maker cost, max(floor(payout x factors) - net stake, 0) each. */
+            readonly awaiting_settlement: components["schemas"]["Amount"];
+        };
+        /** @description The maker's open book by outcome at the vault projection checkpoint. Amounts are exact atomic USDC. */
+        readonly Exposure: {
+            /** @description Freshness of this read: the projection checkpoint and the live outcome read. STALE while either lags, while a live outcome read failed (its legs count as unresolved), or when the open book does not add up to the maker's gross lane. */
+            readonly context: components["schemas"]["ReadContext"];
+            /** @description Open tickets not yet eligible for settlement. */
+            readonly open_ticket_count: string;
+            /** @description Sum of each such ticket's worst-case maker cost, W = ceil(max(payout x resolved factors - net stake, 0)), each ticket once, with no offsetting. Netting across outcomes and Combos is the vault discount on the capital read. */
+            readonly gross_exposure: components["schemas"]["Amount"];
+            /** @description Open tickets whose every leg has resolved, or whose payout already floors to zero, but which have not settled. */
+            readonly awaiting_ticket_count: string;
+            /** @description What those tickets will cost the maker when they settle, each once. */
+            readonly awaiting_settlement: components["schemas"]["Amount"];
+            /** @description Every outcome with an unresolved leg of an open ticket or a leg of a ticket awaiting settlement, ascending outcome_id. */
+            readonly outcomes: readonly components["schemas"]["OutcomeExposure"][];
+        };
+        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;
+        };
+    };
+    responses: {
+        /** @description Error; `code` is one of the operation's x-totalis-errors in openapi.json */
+        readonly Error: {
+            headers: {
+                readonly [name: string]: unknown;
+            };
+            content: {
+                readonly "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description Quota exhausted; resend after Retry-After */
+        readonly RateLimited: {
+            headers: {
+                readonly "Retry-After": components["headers"]["RetryAfter"];
+                readonly [name: string]: unknown;
+            };
+            content: {
+                readonly "application/json": components["schemas"]["Error"];
+            };
+        };
+        /** @description Source or authority unavailable; resend after Retry-After */
+        readonly Unavailable: {
+            headers: {
+                readonly "Retry-After": components["headers"]["RetryAfter"];
+                readonly [name: string]: unknown;
+            };
+            content: {
+                readonly "application/json": components["schemas"]["Error"];
+            };
+        };
+    };
+    parameters: {
+        /**
+         * @description Maximum items per page, 1 to 200; defaults to 50. A page may hold fewer, even none, while has_more is true.
+         * @example 50
+         */
+        readonly Limit: components["schemas"]["PageLimit"];
+        /**
+         * @description Omit for the first page; then send the previous response's next_cursor unchanged.
+         * @example eyJzIjoiMDE5OTg0YzItN2UwMC03MDAwLThhMDAtMDAwMDAwMDAwMDAxIiwicSI6MTg0MiwiaSI6IjlkNGMyYjFhIn0
+         */
+        readonly Cursor: components["schemas"]["PageCursor"];
+        /**
+         * @description Return only activities of this kind.
+         * @example DEPOSIT
+         */
+        readonly ActivityKindQueryOptional: components["schemas"]["ActivityKind"];
+        /**
+         * @description Return only activities with this status. A status-filtered page is a display view, never a balance or P&L basis.
+         * @example COMMITTED
+         */
+        readonly ActivityStatusQueryOptional: "PENDING" | "UNKNOWN" | "COMMITTED" | "FAILED" | "REVERTED" | "CORRECTED";
+        /**
+         * @description Inclusive RFC3339 lower bound on occurred_at (recorded_at for workflow entries without one). Chain activity whose occurrence time is unknown is always included.
+         * @example 2026-09-01T00:00:00Z
+         */
+        readonly FromQueryOptional: string;
+        /**
+         * @description Exclusive RFC3339 upper bound on occurred_at (recorded_at for workflow entries without one). Chain activity whose occurrence time is unknown is always included.
+         * @example 2026-09-26T00:00:00Z
+         */
+        readonly ThroughQueryOptional: string;
+        /**
+         * @description Return only activities that reference this position ID (lowercase bytes32 hex).
+         * @example 0x5e0f6a2b8c4d1e3f7a9b0c2d4e6f8a1b3c5d7e9f0a2b4c6d8e0f1a3b5c7d9e1f
+         */
+        readonly PositionIdQueryOptional: string;
+        /**
+         * @description Activity ID from a list item's activity_id (64 lowercase hex characters).
+         * @example 9d4c2b1a0f8e7d6c5b4a39281706f5e4d3c2b1a0f9e8d7c6b5a4938271605f4e
+         */
+        readonly ActivityIdPathRequired: string;
+        /**
+         * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+         * @example 7
+         */
+        readonly MakerIdPathRequired: components["schemas"]["NonZeroUInt64String"];
+        /**
+         * @description Inclusive RFC3339 start of the period on submitted_at.
+         * @example 2026-09-17T00:00:00Z
+         */
+        readonly QuoteHistoryFromQueryRequired: string;
+        /**
+         * @description Exclusive RFC3339 end of the period; must be after from.
+         * @example 2026-09-18T00:00:00Z
+         */
+        readonly QuoteHistoryThroughQueryRequired: string;
+        /**
+         * @description Return only quotes with this status. The fill rate ignores it.
+         * @example FILLED
+         */
+        readonly QuoteHistoryStatusQueryOptional: components["schemas"]["QuoteHistoryStatus"];
+        /**
+         * @description Return, and compute the fill rate over, only quotes of this kind.
+         * @example ENTRY
+         */
+        readonly QuoteKindQueryOptional: "ENTRY" | "CASHOUT";
+        /**
+         * @description Return only positions the maker closed with this result: WON, LOST or EVEN (see maker_result).
+         * @example LOST
+         */
+        readonly PositionMakerResultQueryOptional: "WON" | "LOST" | "EVEN";
+        /**
+         * @description Return only positions with this lifecycle status.
+         * @example OPEN
+         */
+        readonly PositionStatusQueryOptional: "OPEN" | "AWAITING_SETTLEMENT" | "SETTLED_UNCLAIMED" | "CLOSED";
+        /**
+         * @description Position ID: the contract's ticketId (lowercase bytes32 hex).
+         * @example 0x5e0f6a2b8c4d1e3f7a9b0c2d4e6f8a1b3c5d7e9f0a2b4c6d8e0f1a3b5c7d9e1f
+         */
+        readonly PositionIdPathRequired: string;
+        /**
+         * @description Inclusive RFC3339 start of the performance period.
+         * @example 2026-09-01T00:00:00Z
+         */
+        readonly FromQueryRequired: string;
+        /**
+         * @description Exclusive RFC3339 end of the performance period; must be after from.
+         * @example 2026-09-26T00:00:00Z
+         */
+        readonly ThroughQueryRequired: string;
+        /**
+         * @description Window of the series: 1D, 1W, 1M (default) or ALL since tracking began.
+         * @example 1D
+         */
+        readonly PnlRangeQueryOptional: "1D" | "1W" | "1M" | "ALL";
+        /**
+         * @description Return only activities with evidence from this source: HYPEREVM (EVM logs), HYPERCORE (Hyperliquid ledger) or VENUE (Totalis workflows).
+         * @example HYPEREVM
+         */
+        readonly ActivityVenueQueryOptional: "HYPEREVM" | "HYPERCORE" | "VENUE";
+    };
+    requestBodies: never;
+    headers: {
+        /** @description Seconds to wait before resending the same request */
+        readonly RetryAfter: number;
+        /** @description Always `no-store`; account data must not be cached. */
+        readonly CacheControl: "no-store";
+        /** @description The response varies by the Authorization header, so shared caches must not reuse it across credentials. */
+        readonly Vary: string;
+    };
+    pathItems: never;
+};
+export type $defs = Record<string, never>;
+export interface operations {
+    readonly getMakerQuotes: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["DashboardQuotes"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getOwnMaker: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                readonly Origin?: string;
+            };
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["OwnMaker"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly listControlledMakers: {
+        readonly parameters: {
+            readonly query?: {
+                /**
+                 * @description Maximum items per page, 1 to 200; defaults to 50. A page may hold fewer, even none, while has_more is true.
+                 * @example 50
+                 */
+                readonly limit?: components["parameters"]["Limit"];
+                /**
+                 * @description Omit for the first page; then send the previous response's next_cursor unchanged.
+                 * @example eyJzIjoiMDE5OTg0YzItN2UwMC03MDAwLThhMDAtMDAwMDAwMDAwMDAxIiwicSI6MTg0MiwiaSI6IjlkNGMyYjFhIn0
+                 */
+                readonly cursor?: components["parameters"]["Cursor"];
+            };
+            readonly header?: {
+                readonly Origin?: string;
+            };
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["ControlledMakerList"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getAccountPnl: {
+        readonly parameters: {
+            readonly query?: {
+                /**
+                 * @description Window of the series: 1D, 1W, 1M (default) or ALL since tracking began.
+                 * @example 1D
+                 */
+                readonly range?: components["parameters"]["PnlRangeQueryOptional"];
+            };
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; points are cumulative atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["PnL"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly listAccountActivity: {
+        readonly parameters: {
+            readonly query?: {
+                /**
+                 * @description Maximum items per page, 1 to 200; defaults to 50. A page may hold fewer, even none, while has_more is true.
+                 * @example 50
+                 */
+                readonly limit?: components["parameters"]["Limit"];
+                /**
+                 * @description Omit for the first page; then send the previous response's next_cursor unchanged.
+                 * @example eyJzIjoiMDE5OTg0YzItN2UwMC03MDAwLThhMDAtMDAwMDAwMDAwMDAxIiwicSI6MTg0MiwiaSI6IjlkNGMyYjFhIn0
+                 */
+                readonly cursor?: components["parameters"]["Cursor"];
+                /**
+                 * @description Return only activities of this kind.
+                 * @example DEPOSIT
+                 */
+                readonly kind?: components["parameters"]["ActivityKindQueryOptional"];
+                /**
+                 * @description Return only activities with this status. A status-filtered page is a display view, never a balance or P&L basis.
+                 * @example COMMITTED
+                 */
+                readonly status?: components["parameters"]["ActivityStatusQueryOptional"];
+                /**
+                 * @description Inclusive RFC3339 lower bound on occurred_at (recorded_at for workflow entries without one). Chain activity whose occurrence time is unknown is always included.
+                 * @example 2026-09-01T00:00:00Z
+                 */
+                readonly from?: components["parameters"]["FromQueryOptional"];
+                /**
+                 * @description Exclusive RFC3339 upper bound on occurred_at (recorded_at for workflow entries without one). Chain activity whose occurrence time is unknown is always included.
+                 * @example 2026-09-26T00:00:00Z
+                 */
+                readonly through?: components["parameters"]["ThroughQueryOptional"];
+                /**
+                 * @description Return only activities that reference this position ID (lowercase bytes32 hex).
+                 * @example 0x5e0f6a2b8c4d1e3f7a9b0c2d4e6f8a1b3c5d7e9f0a2b4c6d8e0f1a3b5c7d9e1f
+                 */
+                readonly position_id?: components["parameters"]["PositionIdQueryOptional"];
+                /**
+                 * @description Return only activities with evidence from this source: HYPEREVM (EVM logs), HYPERCORE (Hyperliquid ledger) or VENUE (Totalis workflows).
+                 * @example HYPEREVM
+                 */
+                readonly venue?: components["parameters"]["ActivityVenueQueryOptional"];
+            };
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; effect deltas are atomic units of each effect's asset; other amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["ActivityList"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getAccountActivity: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description Activity ID from a list item's activity_id (64 lowercase hex characters).
+                 * @example 9d4c2b1a0f8e7d6c5b4a39281706f5e4d3c2b1a0f9e8d7c6b5a4938271605f4e
+                 */
+                readonly activity_id: components["parameters"]["ActivityIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; effect deltas are atomic units of each effect's asset; other amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["ActivityDetail"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getMakerCapital: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["MakerCapital"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly listMakerActivity: {
+        readonly parameters: {
+            readonly query?: {
+                /**
+                 * @description Maximum items per page, 1 to 200; defaults to 50. A page may hold fewer, even none, while has_more is true.
+                 * @example 50
+                 */
+                readonly limit?: components["parameters"]["Limit"];
+                /**
+                 * @description Omit for the first page; then send the previous response's next_cursor unchanged.
+                 * @example eyJzIjoiMDE5OTg0YzItN2UwMC03MDAwLThhMDAtMDAwMDAwMDAwMDAxIiwicSI6MTg0MiwiaSI6IjlkNGMyYjFhIn0
+                 */
+                readonly cursor?: components["parameters"]["Cursor"];
+                /**
+                 * @description Return only activities of this kind.
+                 * @example DEPOSIT
+                 */
+                readonly kind?: components["parameters"]["ActivityKindQueryOptional"];
+                /**
+                 * @description Return only activities with this status. A status-filtered page is a display view, never a balance or P&L basis.
+                 * @example COMMITTED
+                 */
+                readonly status?: components["parameters"]["ActivityStatusQueryOptional"];
+                /**
+                 * @description Inclusive RFC3339 lower bound on occurred_at (recorded_at for workflow entries without one). Chain activity whose occurrence time is unknown is always included.
+                 * @example 2026-09-01T00:00:00Z
+                 */
+                readonly from?: components["parameters"]["FromQueryOptional"];
+                /**
+                 * @description Exclusive RFC3339 upper bound on occurred_at (recorded_at for workflow entries without one). Chain activity whose occurrence time is unknown is always included.
+                 * @example 2026-09-26T00:00:00Z
+                 */
+                readonly through?: components["parameters"]["ThroughQueryOptional"];
+                /**
+                 * @description Return only activities that reference this position ID (lowercase bytes32 hex).
+                 * @example 0x5e0f6a2b8c4d1e3f7a9b0c2d4e6f8a1b3c5d7e9f0a2b4c6d8e0f1a3b5c7d9e1f
+                 */
+                readonly position_id?: components["parameters"]["PositionIdQueryOptional"];
+                /**
+                 * @description Return only activities with evidence from this source: HYPEREVM (EVM logs), HYPERCORE (Hyperliquid ledger) or VENUE (Totalis workflows).
+                 * @example HYPEREVM
+                 */
+                readonly venue?: components["parameters"]["ActivityVenueQueryOptional"];
+            };
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; effect deltas are atomic units of each effect's asset; other amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["ActivityList"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getMakerActivity: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+                /**
+                 * @description Activity ID from a list item's activity_id (64 lowercase hex characters).
+                 * @example 9d4c2b1a0f8e7d6c5b4a39281706f5e4d3c2b1a0f9e8d7c6b5a4938271605f4e
+                 */
+                readonly activity_id: components["parameters"]["ActivityIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; effect deltas are atomic units of each effect's asset; other amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["ActivityDetail"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly listMakerPositions: {
+        readonly parameters: {
+            readonly query?: {
+                /**
+                 * @description Maximum items per page, 1 to 200; defaults to 50. A page may hold fewer, even none, while has_more is true.
+                 * @example 50
+                 */
+                readonly limit?: components["parameters"]["Limit"];
+                /**
+                 * @description Omit for the first page; then send the previous response's next_cursor unchanged.
+                 * @example eyJzIjoiMDE5OTg0YzItN2UwMC03MDAwLThhMDAtMDAwMDAwMDAwMDAxIiwicSI6MTg0MiwiaSI6IjlkNGMyYjFhIn0
+                 */
+                readonly cursor?: components["parameters"]["Cursor"];
+                /**
+                 * @description Return only positions with this lifecycle status.
+                 * @example OPEN
+                 */
+                readonly status?: components["parameters"]["PositionStatusQueryOptional"];
+                /**
+                 * @description Return only positions the maker closed with this result: WON, LOST or EVEN (see maker_result).
+                 * @example LOST
+                 */
+                readonly maker_result?: components["parameters"]["PositionMakerResultQueryOptional"];
+            };
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["PositionList"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly listAccountPositions: {
+        readonly parameters: {
+            readonly query?: {
+                /**
+                 * @description Maximum items per page, 1 to 200; defaults to 50. A page may hold fewer, even none, while has_more is true.
+                 * @example 50
+                 */
+                readonly limit?: components["parameters"]["Limit"];
+                /**
+                 * @description Omit for the first page; then send the previous response's next_cursor unchanged.
+                 * @example eyJzIjoiMDE5OTg0YzItN2UwMC03MDAwLThhMDAtMDAwMDAwMDAwMDAxIiwicSI6MTg0MiwiaSI6IjlkNGMyYjFhIn0
+                 */
+                readonly cursor?: components["parameters"]["Cursor"];
+                /**
+                 * @description Return only positions with this lifecycle status.
+                 * @example OPEN
+                 */
+                readonly status?: components["parameters"]["PositionStatusQueryOptional"];
+                /**
+                 * @description Return only positions the maker closed with this result: WON, LOST or EVEN (see maker_result).
+                 * @example LOST
+                 */
+                readonly maker_result?: components["parameters"]["PositionMakerResultQueryOptional"];
+            };
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path?: never;
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["PositionList"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getAccountPosition: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description Position ID: the contract's ticketId (lowercase bytes32 hex).
+                 * @example 0x5e0f6a2b8c4d1e3f7a9b0c2d4e6f8a1b3c5d7e9f0a2b4c6d8e0f1a3b5c7d9e1f
+                 */
+                readonly position_id: components["parameters"]["PositionIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["PositionDetail"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getMakerPosition: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+                /**
+                 * @description Position ID: the contract's ticketId (lowercase bytes32 hex).
+                 * @example 0x5e0f6a2b8c4d1e3f7a9b0c2d4e6f8a1b3c5d7e9f0a2b4c6d8e0f1a3b5c7d9e1f
+                 */
+                readonly position_id: components["parameters"]["PositionIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["PositionDetail"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getMakerPerformance: {
+        readonly parameters: {
+            readonly query: {
+                /**
+                 * @description Inclusive RFC3339 start of the performance period.
+                 * @example 2026-09-01T00:00:00Z
+                 */
+                readonly from: components["parameters"]["FromQueryRequired"];
+                /**
+                 * @description Exclusive RFC3339 end of the performance period; must be after from.
+                 * @example 2026-09-26T00:00:00Z
+                 */
+                readonly through: components["parameters"]["ThroughQueryRequired"];
+            };
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["Performance"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly listMakerQuoteHistory: {
+        readonly parameters: {
+            readonly query: {
+                /**
+                 * @description Inclusive RFC3339 start of the period on submitted_at.
+                 * @example 2026-09-17T00:00:00Z
+                 */
+                readonly from: components["parameters"]["QuoteHistoryFromQueryRequired"];
+                /**
+                 * @description Exclusive RFC3339 end of the period; must be after from.
+                 * @example 2026-09-18T00:00:00Z
+                 */
+                readonly through: components["parameters"]["QuoteHistoryThroughQueryRequired"];
+                /**
+                 * @description Return only quotes with this status. The fill rate ignores it.
+                 * @example FILLED
+                 */
+                readonly status?: components["parameters"]["QuoteHistoryStatusQueryOptional"];
+                /**
+                 * @description Return, and compute the fill rate over, only quotes of this kind.
+                 * @example ENTRY
+                 */
+                readonly kind?: components["parameters"]["QuoteKindQueryOptional"];
+                /**
+                 * @description Maximum items per page, 1 to 200; defaults to 50. A page may hold fewer, even none, while has_more is true.
+                 * @example 50
+                 */
+                readonly limit?: components["parameters"]["Limit"];
+                /**
+                 * @description Omit for the first page; then send the previous response's next_cursor unchanged.
+                 * @example eyJzIjoiMDE5OTg0YzItN2UwMC03MDAwLThhMDAtMDAwMDAwMDAwMDAxIiwicSI6MTg0MiwiaSI6IjlkNGMyYjFhIn0
+                 */
+                readonly cursor?: components["parameters"]["Cursor"];
+            };
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["QuoteHistory"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getMakerExposure: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; API keys do not require an Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["Exposure"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+    readonly getMakerTelemetry: {
+        readonly parameters: {
+            readonly query?: never;
+            readonly header?: {
+                /** @description Required for browser sessions; scoped maker API keys do not require Origin. */
+                readonly Origin?: string;
+            };
+            readonly path: {
+                /**
+                 * @description On-chain maker ID, as a decimal string. An API key may only name the maker it is bound to; other makers return 404.
+                 * @example 7
+                 */
+                readonly maker_id: components["parameters"]["MakerIdPathRequired"];
+            };
+            readonly cookie?: never;
+        };
+        readonly requestBody?: never;
+        readonly responses: {
+            /** @description Scoped read with one freshness status; amounts are atomic USDC strings or null. No shared caching. */
+            readonly 200: {
+                headers: {
+                    readonly "Cache-Control": components["headers"]["CacheControl"];
+                    readonly Vary: components["headers"]["Vary"];
+                    readonly [name: string]: unknown;
+                };
+                content: {
+                    readonly "application/json": components["schemas"]["Telemetry"];
+                };
+            };
+            readonly 400: components["responses"]["Error"];
+            readonly 401: components["responses"]["Error"];
+            readonly 403: components["responses"]["Error"];
+            readonly 404: components["responses"]["Error"];
+            readonly 409: components["responses"]["Error"];
+            readonly 429: components["responses"]["RateLimited"];
+            readonly 503: components["responses"]["Unavailable"];
+        };
+    };
+}