@0xmonaco/types 1.1.8 → 1.1.10

package/dist/wire/schema.d.ts

@@ -768,7 +768,10 @@ export interface paths {
          * List application balances
          * @description List application balances.
          *
-         *      Returns a paginated list of the balances of the application's users.
+         *      Returns a paginated list of the wallet balances of the application's users.
+         *      Funds held in a margin account are not included, so a user funded through
+         *      margin can show zero here. Read those users from
+         *      `GET /api/v1/applications/margin-accounts`.
          *      Public: the application is selected by `client_id`.
          */
         get: operations["list_application_balances"];
@@ -803,6 +806,38 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/applications/margin-accounts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List application margin accounts
+         * @description List application margin accounts.
+         *
+         *      Returns a paginated list of the application's margin accounts, one row per
+         *      margin account with sub-accounts listed beside their parent. An
+         *      application that funds its users through margin reads their collateral
+         *      here: margin collateral is not a wallet balance, so `ListAppBalances` does
+         *      not show it.
+         *
+         *      Figures are a persisted baseline repriced at the latest risk marks. They
+         *      can briefly lag the matching engine, which this read never calls.
+         *      Copy-trading accounts are not listed, so the rows need not add up to all
+         *      of a wallet's margin collateral.
+         *      Public: the application is selected by `client_id`.
+         */
+        get: operations["list_application_margin_accounts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/applications/movements": {
         parameters: {
             query?: never;
@@ -2229,12 +2264,18 @@ export interface paths {
         get?: never;
         put?: never;
         /**
-         * @description Move collateral between the spot wallet, the caller's margin accounts and
-         *      their risk buckets. `from` and `to` each name the wallet or a margin
-         *      account (optionally one of its risk buckets). Supported moves: wallet to
-         *      the default margin account and back, margin account to margin account,
-         *      and margin account to one of its own risk buckets. The older transfer
-         *      routes keep working unchanged.
+         * @description Move collateral between any two of the caller's places: the spot wallet, a
+         *      margin account, a risk bucket. `from` and `to` each name the wallet or a
+         *      margin account (optionally one of its risk buckets). A route that crosses
+         *      accounts or the wallet runs up to three moves in one step: out of the risk
+         *      bucket, across to the other account, into the destination. The wallet is
+         *      reached through the default margin account. A refused request moves nothing.
+         *      A route to or from the wallet or a risk bucket refuses a copy-trading
+         *      sub-account. If the service fails partway, the request answers
+         *      COLLATERAL_TRANSFER_STOPPED_PARTWAY (HTTP 409 / gRPC ALREADY_EXISTS) naming
+         *      the margin account that holds the amount: move it from there rather than
+         *      retrying, and re-read the wallet balance. The older transfer routes keep
+         *      working unchanged.
          */
         post: operations["transfer_collateral"];
         delete?: never;
@@ -3060,6 +3101,14 @@ export interface paths {
          *      consume, nor an original that fails to cancel, and the same original
          *      listed twice is judged per occurrence — so confirm against open orders
          *      rather than relying on the code alone.
+         *
+         *      A replacement the pair's size rules refuse (below the minimum, above the
+         *      maximum, off the quantity step, or a total that does not exceed what
+         *      already filled) is also refused before the cancel, so its original keeps
+         *      its price and queue spot. It is not a guarantee either: the kept order's
+         *      funds are not freed for the other items, one of which may then fail after
+         *      its own cancel, and another item's replacement may cross and sweep it
+         *      under self-trade prevention.
          */
         post: operations["batch_replace_orders"];
         delete?: never;
@@ -3533,7 +3582,15 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /**
+         * List your RFQs
+         * @description List your RFQs.
+         *
+         *      The caller's own RFQs as the taker, newest first, in every state, those
+         *      that filled nothing included. Each carries what GetRfq gives the taker
+         *      except the live view: read GetRfq for that.
+         */
+        get: operations["list_rfqs"];
         put?: never;
         /**
          * Request quotes
@@ -4343,7 +4400,7 @@ export interface components {
              * @description Distinct taker seller user IDs in executed trade records in this window, including system IDs on liquidation and ADL fills; all counts are null when this window is suppressed
              */
             takerSellerCount?: number | null;
-            /** @description True when any user count in this window is below five; all counts in the window are then null */
+            /** @description True when any user count in this window is below five, or while the activity history does not yet reach back to the window's start (briefly, after the activity aggregate is first built); all counts in the window are then null */
             suppressed?: boolean | null;
         };
         AddFollowPositionMarginRequest: {
@@ -4474,13 +4531,22 @@ export interface components {
              * @description Balance UUID
              */
             id?: string | null;
-            /** @description Last sync timestamp (ISO 8601) */
+            /**
+             * @deprecated
+             * @description Deprecated: this timestamp is not kept up to date and must not be used. It is not a sync or health signal.
+             */
             lastSyncAt?: string | null;
-            /** @description Last sync block number */
+            /**
+             * @deprecated
+             * @description Deprecated: this block number is not kept up to date and must not be used. It is not a sync or health signal.
+             */
             lastSyncBlock?: string | null;
             /** @description Locked balance */
             lockedBalance?: string | null;
-            /** @description On-chain balance */
+            /**
+             * @deprecated
+             * @description Deprecated: this value is not kept up to date and must not be used. It is not a sync or health signal.
+             */
             onChainBalance?: string | null;
             /** @description Token symbol */
             symbol?: string | null;
@@ -4496,6 +4562,66 @@ export interface components {
              */
             userId?: string | null;
         };
+        /**
+         * @description One margin account of an application.
+         *
+         *      A public row, so it is deliberately smaller than `MarginAccountSummary`: it
+         *      carries no free-text label, no risk bucket or position data, and no margin
+         *      requirement. Risk buckets are not rows: their allocated collateral and held
+         *      realized PnL are already inside the account's figures.
+         *
+         *      Every figure is a persisted baseline repriced at the latest risk marks, so
+         *      it can briefly lag the matching engine.
+         */
+        ApplicationMarginAccount: {
+            /**
+             * Format: uuid
+             * @description Margin account UUID
+             */
+            marginAccountId?: string | null;
+            /**
+             * Format: uuid
+             * @description UUID of the user who owns this margin account
+             */
+            userId?: string | null;
+            /** @description Wallet address of the owning user */
+            address?: string | null;
+            /**
+             * @description Sub-account key; default is the parent margin account
+             * @example default
+             */
+            subaccountKey?: string | null;
+            /**
+             * @description Margin account state: ACTIVE or CLOSED (a closed sub-account)
+             * @example ACTIVE
+             */
+            marginAccountState?: string | null;
+            /**
+             * @description Deposited collateral in USD, before any PnL. A persisted baseline: it can briefly lag the matching engine.
+             * @example 1000
+             */
+            collateral?: string | null;
+            /**
+             * @description Account equity in USD: settled collateral, unrealized PnL at the latest risk marks, and realized PnL held by open risk buckets. A persisted baseline repriced at the latest risk marks: it can briefly lag the matching engine.
+             * @example 1012.5
+             */
+            equity?: string | null;
+            /**
+             * @description Collateral available for new margin, in USD. Not the withdrawal bound. A persisted baseline: it can briefly lag the matching engine.
+             * @example 800
+             */
+            freeCollateral?: string | null;
+            /**
+             * @description Collateral a transfer out of this margin account can take, in USD. A persisted baseline: the matching engine enforces the transfer and can accept less.
+             * @example 750
+             */
+            withdrawableCollateral?: string | null;
+            /**
+             * Format: date-time
+             * @description When this margin account was last persisted (RFC 3339). Repricing at newer marks does not move it.
+             */
+            updatedAt?: string | null;
+        };
         ApplicationMovement: {
             /** @description Transaction amount */
             amount?: string | null;
@@ -4998,7 +5124,7 @@ export interface components {
              */
             postOnly?: boolean | null;
             /**
-             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and events are not persisted for redelivery, so one can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replace item carries no order type or time-in-force and its original must still be RESTING, so the IOC/FOK and MARKET post-acceptance rejection shapes are unreachable here. Failures split by WHEN they occur, and the difference decides whether your original survives. Before sequencing: every validation failure — a malformed value included — fails ITS ITEM alone with a structured error.code (INVALID_CLIENT_ORDER_ID for a malformed handle, the same code batch-create uses) and no mutation and no event, batch-create parity; the whole request 400s only for an empty or oversize batch. (Earlier releases rejected the whole batch for a malformed value here.) A pre-cancel gate then drops two more classes before anything is cancelled — a handle conflict, and a post-only replacement that would cross the book as it will stand once this batch's originals are cancelled — so in the ordinary POST_ONLY_WOULD_CROSS case the item fails with its original still RESTING and untouched. After that the endpoint is CANCEL-FIRST: the original is cancelled in pass 1, so a residual placement failure then — a self-trade rejection, or a crossing that only became apparent in pass 2 — leaves the original CANCELLED and emits its cancellation events (terminal reason 'replaced') while the item reports the placement error and no replacement is placed. Never assume a failed item left your original resting; read results[] and the stream. Single ReplaceOrder differs: it is atomic, and a rejected replacement leaves the original untouched. Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
+             * @description Client-assigned correlation handle, echoed back on order reads (detail and list) and on order WebSocket events. At most 64 characters from [A-Za-z0-9._:-]; surrounding whitespace is trimmed before storage, and a blank or whitespace-only value is treated as absent. Uniqueness is enforced only among your orders that are RESTING on the book: an item reusing a value another of your resting orders still holds fails that item alone — the batch itself returns 2xx / OK and the offending item's result slot carries error.code CLIENT_ORDER_ID_CONFLICT; no transport-level 409 / ALREADY_EXISTS is raised. An order that never rests — MARKET, IOC/FOK, or a LIMIT that fills completely on arrival — does not take the handle, and the value is released the moment any order reaches a terminal state. It is therefore NOT an idempotency key, though on this replace path a retry cannot double-execute: the request names the original order id, and the sequencer revalidates that original in memory and on the book at sequence time, so once the first replacement succeeds the original is gone and a retry is rejected with ORDER_NOT_FOUND rather than placing a second order. That code is itself ambiguous — the original may instead have filled or been cancelled — so the risk here is acting on a stale view, not duplicate execution. Reconcile a lost response against the order WebSocket stream, which carries this value on the submit acknowledgement and on fills, including for orders that never rest; order history is replica-backed and can omit an order that did land. The stream is not replayable and has no sequence number to backfill from, and events are not persisted for redelivery, so one can be missed while your connection still looks healthy. A matching event is therefore positive proof the order was accepted, but silence is NEVER evidence it was not, and no client-observable condition makes it so. Absent positive evidence the outcome is unresolved: hold and escalate rather than resubmitting. A replace item carries no order type or time-in-force and its original must still be RESTING, so the IOC/FOK and MARKET post-acceptance rejection shapes are unreachable here. Failures split by WHEN they occur, and the difference decides whether your original survives. Before sequencing: every validation failure — a malformed value included — fails ITS ITEM alone with a structured error.code (INVALID_CLIENT_ORDER_ID for a malformed handle, the same code batch-create uses) and no mutation and no event, batch-create parity; the whole request 400s only for an empty or oversize batch. (Earlier releases rejected the whole batch for a malformed value here.) A pre-cancel gate then drops three more classes before anything is cancelled — a replacement the pair's size rules refuse, a handle conflict, and a post-only replacement that would cross the book as it will stand once this batch's originals are cancelled — so in the ordinary POST_ONLY_WOULD_CROSS case the item fails with its original still RESTING and untouched. After that the endpoint is CANCEL-FIRST: the original is cancelled in pass 1, so a residual placement failure then — a self-trade rejection, or a crossing that only became apparent in pass 2 — leaves the original CANCELLED and emits its cancellation events (terminal reason 'replaced') while the item reports the placement error and no replacement is placed. Never assume a failed item left your original resting; read results[] and the stream. Single ReplaceOrder differs: it is atomic, and a rejected replacement leaves the original untouched. Where no surface is conclusive, do not resubmit. A replacement is a new order with a new id, so it carries its own value and inherits nothing from the original — restate it to keep the handle.
              * @example quote-btc-1130-a
              */
             clientOrderId?: string | null;
@@ -6653,8 +6779,8 @@ export interface components {
             settledAt?: string | null;
             /**
              * @description True when the window held fewer than the minimum accepted samples and
-             *      settled at the carried last settled rate (zero if no rate was ever
-             *      settled) instead of a freshly computed average.
+             *      settled at zero instead of a freshly computed average. (Windows settled
+             *      before this rule carried the last settled rate instead.)
              */
             carried?: boolean | null;
         };
@@ -7065,7 +7191,7 @@ export interface components {
              */
             currentFundingRate?: string | null;
             /**
-             * @description Implied rate for the in-progress window. An estimate refreshed on each accepted premium sample (roughly every sample interval plus persistence lag), not a real-time stream; absent when the window has no samples. A window that ends with too few accepted samples settles at the previous settled rate instead (0 for a market that has never settled one), so the settled rate can differ from this estimate
+             * @description Implied rate for the in-progress window. An estimate refreshed on each accepted premium sample (roughly every sample interval plus persistence lag), not a real-time stream; absent when the window has no samples. A window that ends with too few accepted samples settles at zero instead, so the settled rate can differ from this estimate
              * @example 0.00012
              */
             estimatedNextFundingRate?: string | null;
@@ -7357,6 +7483,7 @@ export interface components {
              * @example 117845632.18
              */
             quoteVolume24h?: string | null;
+            totalVolumeLtdBySource?: components["schemas"]["LtdVolumeBySource"];
             volume24hBySource?: components["schemas"]["Volume24hBySource"];
         };
         /** @description Exchange-wide life-to-date cumulative market statistics across all trading pairs. */
@@ -7372,6 +7499,7 @@ export interface components {
              * @example 19284736
              */
             totalTradeCountLtd?: number | null;
+            totalVolumeLtdBySource?: components["schemas"]["LtdVolumeBySource"];
         };
         GetMovementsResponse: {
             movements?: components["schemas"]["LedgerMovement"][] | null;
@@ -7982,6 +8110,8 @@ export interface components {
             returnPct?: string | null;
             maxDrawdown?: components["schemas"]["PortfolioPerformanceDrawdown"];
             points?: components["schemas"]["PortfolioPerformancePoint"][] | null;
+            /** @description Modified Dietz return over the window: pnl divided by the starting equity plus each deposit minus each withdrawal, each weighted by the share of the window it was in the account (a flow is taken at the middle of its sample interval). Never below -100%, since an account cannot lose more than it received. Unlike return_pct it stays defined after equity touches zero. Null when the window has no positive-equity sample, or when withdrawals leave that time-weighted capital below 5% of what it would have been without them (the starting equity plus the time-weighted deposits), so the gain on a sliver of capital is not reported. Not bounded above: a capital just over that limit can still give a gain of up to about 20 times the return on the full base. max_drawdown and calculation_method describe the time-weighted return_pct series only and can cover less of the window than this figure. */
+            modifiedDietzReturnPct?: string | null;
         };
         GetPortfolioRealizedPnlResponse: {
             window?: components["schemas"]["PortfolioSeriesWindow"];
@@ -8595,7 +8725,7 @@ export interface components {
              */
             code?: string | null;
         };
-        /** @description Current public long/short account positioning and active trader aggregates. Accounts are classified by net position across OPEN risk buckets. Account identifiers are never returned; position metrics are null when either side has fewer than five accounts. Responses may be reused from a per-pair cache for up to 30 seconds. */
+        /** @description Current public long/short account positioning and active trader aggregates. Accounts are classified by net position across OPEN risk buckets. Account identifiers are never returned; position metrics are null when either side has fewer than five accounts, and an active-trader window's counts are null while it is suppressed. Responses may be reused from a per-pair cache for up to 30 seconds. */
         GetTraderMetricsResponse: {
             /**
              * Format: uuid
@@ -9321,6 +9451,38 @@ export interface components {
              */
             totalCapped?: boolean | null;
         };
+        ListAppMarginAccountsResponse: {
+            marginAccounts?: components["schemas"]["ApplicationMarginAccount"][] | null;
+            /**
+             * Format: uint32
+             * @description Number of margin accounts matching the filter, bounded by the server ceiling — a lower bound when totalCapped is true.
+             * @example 50
+             */
+            total?: number | null;
+            /**
+             * Format: uint32
+             * @description Items per page
+             * @example 20
+             */
+            pageSize?: number | null;
+            /**
+             * Format: uint32
+             * @description Number of pages at this pageSize, bounded by the server ceiling — a lower bound when totalCapped is true.
+             * @example 3
+             */
+            totalPages?: number | null;
+            /**
+             * @description Cursor for the next page, minted from the last row of an over-fetched
+             *      page: this listing is one ordered read, so a page shorter than
+             *      `pageSize` proves the walk is exhausted and this is empty.
+             */
+            nextPageToken?: string | null;
+            /**
+             * @description True when more than the server ceiling of margin accounts matched, so the count stopped at the ceiling and total/totalPages are a lower bound.
+             * @example false
+             */
+            totalCapped?: boolean | null;
+        };
         ListAppMovementsResponse: {
             movements?: components["schemas"]["ApplicationMovement"][] | null;
             /**
@@ -9738,6 +9900,12 @@ export interface components {
              */
             totalCapped?: boolean | null;
         };
+        ListRfqsResponse: {
+            /** @description Newest first. Each is the taker's status as GetRfq gives it, without the live view */
+            rfqs?: components["schemas"]["RfqStatus"][] | null;
+            /** @description Pass as pageToken for the next page; empty once there are no more */
+            nextPageToken?: string | null;
+        };
         ListSubAccountsResponse: {
             subAccounts?: components["schemas"]["SubAccount"][] | null;
             /**
@@ -9889,6 +10057,45 @@ export interface components {
             /** @description Opaque cursor for the next page; empty when the page is the end of the ordered result */
             nextPageToken?: string | null;
         };
+        /**
+         * @description Life-to-date totals split by how they executed (RFQ-17): the order-book part
+         *      and the RFQ part, which add up exactly to the totals beside them. Base volume
+         *      is present only where the totals carry it (a single market).
+         */
+        LtdVolumeBySource: {
+            /**
+             * @description Life-to-date base-token volume filled on the order book
+             * @example 123000.00000000
+             */
+            orderBookBaseVolume?: string | null;
+            /**
+             * @description Life-to-date base-token volume filled by RFQ block trades
+             * @example 456.78900000
+             */
+            rfqBaseVolume?: string | null;
+            /**
+             * @description Life-to-date quote-token volume filled on the order book
+             * @example 9100000000.00
+             */
+            orderBookQuoteVolume?: string | null;
+            /**
+             * @description Life-to-date quote-token volume filled by RFQ block trades
+             * @example 23456789.50
+             */
+            rfqQuoteVolume?: string | null;
+            /**
+             * Format: int64
+             * @description Life-to-date number of order-book trades
+             * @example 482900
+             */
+            orderBookTradeCount?: number | null;
+            /**
+             * Format: int64
+             * @description Life-to-date number of RFQ fills (one per maker child)
+             * @example 31
+             */
+            rfqTradeCount?: number | null;
+        };
         ManagedMarketAssignment: {
             launchId?: string | null;
             /** Format: uuid */
@@ -10397,6 +10604,8 @@ export interface components {
             returnPct?: string | null;
             /** @enum {string|null} */
             calculationMethod?: "sampled_twr" | null;
+            /** @description Modified Dietz return over the window, defined after spot equity touches zero; see GetPortfolioPerformanceResponse.modified_dietz_return_pct */
+            modifiedDietzReturnPct?: string | null;
         };
         PortfolioBestDay: {
             /**
@@ -12026,10 +12235,29 @@ export interface components {
              */
             openInterestNotionalAvg7d?: string | null;
             /**
-             * @description Estimated rate for the in-progress funding window, the same value as getFundingState / getPerpMarketSummary estimatedNextFundingRate (a decimal fraction per funding window). An estimate refreshed on each accepted premium sample, not a real-time stream. A window that ends with too few accepted samples settles at the previous settled rate instead (0 for a market that has never settled one), so the settled rate can differ from this estimate. Null for spot pairs and margin pairs whose current window has no samples yet
+             * @description Estimated rate for the in-progress funding window, the same value as getFundingState / getPerpMarketSummary estimatedNextFundingRate (a decimal fraction per funding window). An estimate refreshed on each accepted premium sample, not a real-time stream. A window that ends with too few accepted samples settles at zero instead, so the settled rate can differ from this estimate. Null for spot pairs and margin pairs whose current window has no samples yet
              * @example 0.00012
              */
             estimatedNextFundingRate?: string | null;
+            quoteVolume24hBySource?: components["schemas"]["ScreenerQuoteVolumeBySource"];
+            totalVolumeLtdBySource?: components["schemas"]["LtdVolumeBySource"];
+        };
+        /**
+         * @description A screener row's 24h quote volume split by execution source (RFQ-17). The
+         *      order-book part is the displayed total minus the displayed RFQ part, so the
+         *      two always add up to quoteVolume24h.
+         */
+        ScreenerQuoteVolumeBySource: {
+            /**
+             * @description Quote-token volume filled on the order book in the last 24 hours
+             * @example 115265632.18
+             */
+            orderBookQuoteVolume?: string | null;
+            /**
+             * @description Quote-token volume filled by RFQ block trades in the last 24 hours
+             * @example 2580000.00
+             */
+            rfqQuoteVolume?: string | null;
         };
         /** @description One UTC-day bucket in a pair's 7-day snapshot. */
         ScreenerSnapshotPoint: {
@@ -13113,6 +13341,13 @@ export interface components {
             toMarginAccountId?: string | null;
             /** @description The destination risk bucket, when the destination is one. */
             toRiskBucketId?: string | null;
+            /** @description The source risk bucket, when the source is one. */
+            fromRiskBucketId?: string | null;
+            /**
+             * @description Whether funding the destination risk bucket credited its sole open
+             *      position's margin. Absent when the destination is not a risk bucket.
+             */
+            positionMarginCredited?: boolean | null;
         };
         TransferCollateralToMarginAccountRequest: {
             /** @description Parent margin account UUID that receives collateral. */
@@ -16272,6 +16507,74 @@ export interface operations {
             };
         };
     };
+    list_application_margin_accounts: {
+        parameters: {
+            query: {
+                /** @description Application client ID */
+                clientId: string;
+                /** @description Filter by wallet address. A wallet with no margin account in the application returns an empty page. */
+                address?: string;
+                /** @description Items per page (max 1000) */
+                pageSize?: number;
+                /**
+                 * @description Pagination cursor with two states:
+                 *       - Omitted or empty string (""): start a cursor walk with no prior
+                 *         position.
+                 *       - Non-empty: an opaque cursor from a previous response's
+                 *         `nextPageToken`; results resume immediately after that position.
+                 *
+                 *      Ordered by margin account id ascending.
+                 *
+                 *      Filters must match the request that produced the token, or the request
+                 *      is rejected 400.
+                 */
+                pageToken?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListAppMarginAccountsResponse"];
+                };
+            };
+            /** @description Bad request (missing client_id, invalid address, page size or page token) */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description No active, displayed application has this client_id (unknown, inactive and hidden builders read alike) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Public read rate limit exceeded for this client IP; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     list_application_movements: {
         parameters: {
             query: {
@@ -16424,6 +16727,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description The read did not finish within its 3 s budget; narrow the filters or retry later */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     get_application_stats: {
@@ -16476,6 +16786,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description The read did not finish within its 3 s budget; narrow the filters or retry later */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     list_application_users: {
@@ -22150,6 +22467,58 @@ export interface operations {
             };
         };
     };
+    list_rfqs: {
+        parameters: {
+            query?: {
+                /** @description RFQs per page, 1 to 100 (default 50) */
+                pageSize?: number;
+                pageToken?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListRfqsResponse"];
+                };
+            };
+            /** @description Invalid page size or malformed page token */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description RFQ is not enabled for this account (RFQ_DISABLED) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description RFQ service unavailable; retry */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     create_rfq: {
         parameters: {
             query?: never;
@@ -23437,6 +23806,8 @@ export interface operations {
                  *      pair is rejected rather than seeking into another pair's history.
                  */
                 pageToken?: string;
+                /** @description The execution source to keep: RFQ (RFQ block fills) or CLOB (order-book fills), the values of each trade's executionSource. Omit for every fill. RFQ covers recent fills (the hot trade store); older RFQ fills stay on the unfiltered pages */
+                executionSource?: "RFQ" | "CLOB";
             };
             header?: never;
             path: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@0xmonaco/types",
-	"version": "1.1.8",
+	"version": "1.1.10",
 	"type": "module",
 	"homepage": "https://docs.0xmonaco.com/sdk/typescript",
 	"main": "./dist/index.js",
@@ -16,7 +16,7 @@
 		"lint": "biome lint ."
 	},
 	"dependencies": {
-		"@0xmonaco/contracts": "1.1.8",
+		"@0xmonaco/contracts": "1.1.10",
 		"zod": "^4.6.7"
 	},
 	"peerDependencies": {