@0xmonaco/types 1.0.42 → 1.0.44

package/dist/wire/schema.d.ts

@@ -1573,6 +1573,85 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/orders/twap": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List TWAP orders
+         * @description List TWAP orders.
+         *
+         *      List TWAP parent orders for the authenticated user with pagination and
+         *      optional filtering by state and trading pair.
+         */
+        get: operations["list_twap_orders"];
+        put?: never;
+        /**
+         * Create TWAP order
+         * @description Create TWAP order.
+         *
+         *      Create a server-side TWAP (time-weighted average price) parent order. The
+         *      matching engine executes it as a schedule of MARKET child orders with
+         *      seeded size/timing randomization across the requested window, then stops
+         *      hard at the end time — any unfilled remainder is reported as shortfall,
+         *      never traded past the window. Delegated-agent sessions are rejected.
+         */
+        post: operations["create_twap_order"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/orders/twap/{twapOrderId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get TWAP order by ID
+         * @description Get TWAP order by ID.
+         *
+         *      Get a single TWAP parent order by its ID. Users can only access their own
+         *      TWAP orders.
+         */
+        get: operations["get_twap_order"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/orders/twap/{twapOrderId}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancel TWAP order
+         * @description Cancel TWAP order.
+         *
+         *      Cancel a TWAP parent order. Child orders are IOC and never rest, so the
+         *      cancel is atomic and immediate; already-executed quantity stands.
+         */
+        post: operations["cancel_twap_order"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/orders/{orderId}": {
         parameters: {
             query?: never;
@@ -2191,6 +2270,11 @@ export interface components {
              * @example 1050750000
              */
             totalBalanceRaw?: string | null;
+            /**
+             * @description True when this asset is the chain's wrapped-native token (e.g. WSEI): vault deposits can be made in native coin via depositNative (the vault wraps on entry) and withdrawals pay out native
+             * @example true
+             */
+            wrappedNative?: boolean | null;
         };
         AppUser: {
             /**
@@ -2739,7 +2823,7 @@ export interface components {
              */
             price?: string | null;
             /**
-             * @description New quantity (if changing)
+             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder.
              * @example 0.7
              */
             quantity?: string | null;
@@ -2821,6 +2905,11 @@ export interface components {
              * @example 123e4567-e89b-12d3-a456-426614174000
              */
             orderId: string;
+            /**
+             * @description Partial cancel: reduce the resting order in place to this remaining quantity, keeping its queue position. A target ("leave this much resting"), not an amount to remove, so a retried request converges. Must be a positive multiple of the market's quantity step, strictly below the order's current remaining quantity; the delta is released exactly as a cancel releases it (spot unlock / margin reserve). Omit for a full cancel.
+             * @example 0.5
+             */
+            remainingQuantityTarget?: string | null;
         };
         CancelOrderResponse: {
             /**
@@ -2840,6 +2929,24 @@ export interface components {
              */
             message?: string | null;
         };
+        CancelTwapOrderResponse: {
+            /**
+             * Format: uuid
+             * @description Cancelled TWAP parent order UUID
+             * @example 123e4567-e89b-12d3-a456-426614174000
+             */
+            twapOrderId?: string | null;
+            /**
+             * @description Result status: SUCCESS or FAILED
+             * @example SUCCESS
+             */
+            status?: string | null;
+            /**
+             * @description Human-readable status message
+             * @example TWAP order cancelled successfully
+             */
+            message?: string | null;
+        };
         Candle: {
             /**
              * @description Unix timestamp for the start of the candle period in milliseconds
@@ -3209,6 +3316,153 @@ export interface components {
              */
             delegationId?: string | null;
         };
+        CreateTwapOrderRequest: {
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             * @example afae0e16-2d05-4ee9-9ee8-afae0e162d05
+             */
+            tradingPairId: string;
+            /**
+             * @description Order side: BUY or SELL
+             * @example BUY
+             */
+            side: string;
+            /**
+             * @description Total quantity to execute across the window as decimal string. Must be at least 2x the pair's minimum order size so it can be sliced, and small enough that the window's slice budget can carry it with every child at or below the pair's maximum order size.
+             * @example 10
+             */
+            quantity: string;
+            /**
+             * Format: int64
+             * @description Execution window length in seconds from launch. Exactly one of durationSeconds or endTime must be set. Bounds (env-tunable defaults): 60 to 2592000 (1 minute to 30 days).
+             * @example 3600
+             */
+            durationSeconds?: number | null;
+            /**
+             * @description Window start (RFC 3339, UTC only — use a Z suffix; non-UTC offsets are rejected). Only valid together with endTime; defaults to now.
+             * @example 2026-08-01T10:00:00Z
+             */
+            startTime?: string | null;
+            /**
+             * @description Window end (RFC 3339, UTC only — use a Z suffix; non-UTC offsets are rejected). Exactly one of durationSeconds or endTime must be set. The effective window must satisfy the same duration bounds. Execution stops hard at this time; any unfilled remainder is reported as shortfall.
+             * @example 2026-08-01T11:00:00Z
+             */
+            endTime?: string | null;
+            /**
+             * @description Optional parent-level limit price as decimal string. BUY child orders never execute above it, SELL children never below it. Omitted: slippage band protection only.
+             * @example 35000.00
+             */
+            limitPrice?: string | null;
+            /**
+             * Format: int32
+             * @description Per-slice protective price band in basis points around the reference price (default 100 = 1%, maximum 500 = 5% — deliberately tighter than the standalone market-order cap; TWAP slices never sweep deep)
+             * @example 100
+             */
+            slippageToleranceBps?: number | null;
+            /**
+             * @description Apply seeded randomization to slice sizes and timing (default true). The seed is recorded for audit, so the schedule is reproducible to compliance but unpredictable to the market.
+             * @example true
+             */
+            randomize?: boolean | null;
+            /**
+             * @description Whether the TWAP parent is reduce-only (margin only). Child orders inherit it and clamp to the live position.
+             * @example false
+             */
+            reduceOnly?: boolean | null;
+            /**
+             * @description Trading mode: SPOT or MARGIN (default: SPOT)
+             * @example SPOT
+             */
+            tradingMode?: string | null;
+            /**
+             * Format: uuid
+             * @description Margin account UUID for margin TWAP orders. Resolved once at creation and reused by every child order.
+             * @example 123e4567-e89b-12d3-a456-426614174000
+             */
+            marginAccountId?: string | null;
+            /**
+             * Format: uuid
+             * @description Existing isolated risk bucket UUID for risk-bucket-scoped margin TWAP orders. Snapshot at creation.
+             * @example 123e4567-e89b-12d3-a456-426614174001
+             */
+            riskBucketId?: string | null;
+            /**
+             * @description Risk bucket mode for margin TWAP orders. Defaults to ISOLATED. Values: ISOLATED, CROSS.
+             * @example CROSS
+             * @enum {string|null}
+             */
+            marginMode?: "ISOLATED" | "CROSS" | null;
+            /**
+             * @description Leverage multiplier as a decimal string. Required for normal margin TWAP orders; optional and ignored for reduce-only.
+             * @example 5
+             */
+            leverage?: string | null;
+            /**
+             * @description Strategy key used to group risk buckets for margin orders
+             * @example my-strategy
+             */
+            strategyKey?: string | null;
+            /**
+             * @description Use master account balance for sub-account orders
+             * @example false
+             */
+            useMasterBalance?: boolean | null;
+            /**
+             * @description Client-assigned idempotency key (max 36 chars), unique per user and application. A duplicate is rejected with 409.
+             * @example oms-3f6a1c
+             */
+            clientTwapId?: string | null;
+        };
+        CreateTwapOrderResponse: {
+            /**
+             * Format: uuid
+             * @description Created TWAP parent order UUID
+             * @example 123e4567-e89b-12d3-a456-426614174000
+             */
+            twapOrderId?: string | null;
+            /**
+             * @description Result status: SUCCESS or FAILED. SUCCESS means the parent is durably recorded; execution itself is best-effort within the window.
+             * @example SUCCESS
+             */
+            status?: string | null;
+            /**
+             * @description Human-readable status message
+             * @example TWAP order created successfully
+             */
+            message?: string | null;
+            /**
+             * @description Initial parent state: always PENDING at create; the parent activates on its first attempted slice
+             * @example PENDING
+             */
+            state?: string | null;
+            /**
+             * Format: uuid
+             * @description Resolved margin account UUID for margin TWAP orders
+             */
+            marginAccountId?: string | null;
+            /**
+             * Format: uuid
+             * @description Resolved isolated risk bucket UUID for risk-bucket-scoped margin TWAP orders
+             */
+            riskBucketId?: string | null;
+            /**
+             * Format: int32
+             * @description Number of slices in the planned schedule
+             * @example 120
+             */
+            plannedSlices?: number | null;
+            /**
+             * @description Planned time of the first slice (ISO 8601)
+             * @example 2026-08-01T10:00:27Z
+             */
+            firstSliceAt?: string | null;
+            /**
+             * @description Resolved window end (ISO 8601). Execution never continues past it.
+             * @example 2026-08-01T11:00:00Z
+             */
+            endTime?: string | null;
+        };
         DelegatedAgent: {
             /**
              * Format: uuid
@@ -3506,11 +3760,14 @@ export interface components {
              *      value, so the two surfaces cannot disagree. Absent when the user has no
              *      margin account yet.
              *
-             *      This is NOT trading headroom. It is bounded by allocation (principal not
-             *      earmarked by risk buckets) as well as by margin requirements, and an
-             *      unrealized gain does not raise it: a mark-to-market gain is initial margin
-             *      for new positions but may not fund an exit. Size new positions from
-             *      `MarginAccountSummary.free_collateral`, which credits that gain in full.
+             *      This is NOT trading headroom for existing cross exposure. It is bounded
+             *      by allocation (principal not earmarked by risk buckets) as well as by
+             *      margin requirements, and an unrealized gain does not raise it: a
+             *      mark-to-market gain is initial margin against existing cross exposure but
+             *      may not fund an exit. `MarginAccountSummary.free_collateral` credits that
+             *      gain in full and remains the trading-margin headroom for existing cross
+             *      exposure — but a NEW isolated or first-use position allocates principal
+             *      through the same gate this field measures, so size those from this field.
              *
              *      Note the two `margin_*` fields answer opposite questions:
              *      `margin_transferable` is wallet-to-margin capacity, this is the amount that
@@ -3571,6 +3828,11 @@ export interface components {
              * @example 1050750000
              */
             totalBalanceRaw?: string | null;
+            /**
+             * @description True when this asset is the chain's wrapped-native token (e.g. WSEI): vault deposits can be made in native coin via depositNative (the vault wraps on entry) and withdrawals pay out native
+             * @example true
+             */
+            wrappedNative?: boolean | null;
         };
         GetBalancesResponse: {
             balances?: components["schemas"]["AccountBalance"][] | null;
@@ -4528,6 +4790,15 @@ export interface components {
              *      as unavailable, never as zero.
              */
             liquidationPrice?: string | null;
+            /**
+             * @description Account distress ratio: maintenance margin required divided by equity
+             *      (higher is closer to liquidation). Equity that is zero or negative has no
+             *      meaningful quotient, so an account that still owes a maintenance requirement
+             *      reports the maximum-decimal sentinel (79228162514264337593543950335,
+             *      maximal distress) rather than zero or a negative value, and an account with
+             *      no open maintenance requirement reports zero. Clamp the sentinel before
+             *      display.
+             */
             marginRatio?: string | null;
             /**
              * @description Maintenance margin required by this position at mark_price using the
@@ -5210,6 +5481,27 @@ export interface components {
              */
             totalPages?: number | null;
         };
+        ListTwapOrdersResponse: {
+            orders?: components["schemas"]["TwapOrder"][] | null;
+            /**
+             * Format: uint32
+             * @description Total number of TWAP orders matching the filter
+             * @example 3
+             */
+            total?: number | null;
+            /**
+             * Format: uint32
+             * @description Current page number
+             * @example 1
+             */
+            page?: number | null;
+            /**
+             * Format: uint32
+             * @description Items per page
+             * @example 20
+             */
+            pageSize?: number | null;
+        };
         MarginAccountMovement: {
             id?: string | null;
             movementType?: string | null;
@@ -5502,6 +5794,14 @@ export interface components {
             priceAsOf?: string | null;
             /** @enum {string|null} */
             pricingStatus?: "priced" | "unpriced" | null;
+            /** @description Weighted-average cost per unit of the holding, quote-denominated, from the spot cost-basis engine. Deposits are marked at the last-traded price at deposit time. Present only when a cost-basis checkpoint exists for the asset. */
+            avgCost?: string | null;
+            /** @description Unrealized PnL for the holding: costBasisQuantity x (markPrice - avgCost), quote-denominated. Uses the cost-basis engine's folded quantity so it agrees with the portfolio summary headline. Present only when both a cost-basis checkpoint and a mark price exist. */
+            unrealizedPnl?: string | null;
+            /** @description Unrealized return on the holding's cost basis, as a percentage: unrealizedPnl / (costBasisQuantity x avgCost) x 100. Present only when unrealizedPnl is present and the cost basis is non-zero. */
+            unrealizedRoe?: string | null;
+            /** @description Cumulative realized PnL booked against this holding over its lifetime, gross of fees, quote-denominated. Present only when a cost-basis checkpoint exists for the asset. */
+            cumRealized?: string | null;
         };
         PortfolioAssetsPerformance: {
             pnl?: string | null;
@@ -5547,6 +5847,32 @@ export interface components {
             initialMarginRequired?: string | null;
             maintenanceMarginRequired?: string | null;
             unrealizedPnl?: string | null;
+            /**
+             * @description The largest amount that can actually leave the parent margin account —
+             *      the bound the engine enforces on transfers-out and withdrawals, and
+             *      therefore also the effective ceiling on funding new isolated or
+             *      first-use order capacity, because allocating collateral to a risk
+             *      bucket passes through the same principal-gated door.
+             *
+             *      NOT a clamped `parent_available_collateral`. That field is
+             *      `free_collateral`, an equity figure: it credits settled realized PnL,
+             *      accrued funding, and mark-to-market gains that a transfer-out cannot
+             *      move, so the two can differ without limit. This bound never credits an
+             *      unrealized gain. Under the default capacity basis it also excludes
+             *      non-principal balances such as banked realized PnL:
+             *      `min(deposited principal - bucket allocations,
+             *      free_collateral - max(unrealized_pnl, 0))`, floored at zero. Whatever
+             *      the engine's configured capacity basis, this is the bound its gates
+             *      actually enforce. It agrees with
+             *      `MarginAccountSummary.withdrawable_collateral` up to quote-decimal
+             *      truncation: this surface truncates toward zero at the quote asset's
+             *      precision, while the margin-accounts surface may carry sub-tick tails.
+             *
+             *      Size transfers-out, withdrawals, and new isolated/first-use positions
+             *      from this field; `parent_available_collateral` remains the trading-margin
+             *      headroom for existing cross exposure.
+             */
+            withdrawableCollateral?: string | null;
         };
         PortfolioPerformanceDrawdown: {
             /** @description Positive transfer-neutral loss magnitude */
@@ -5586,6 +5912,24 @@ export interface components {
             maintenanceMarginRequired?: string | null;
             unrealizedPnl?: string | null;
             positionCount?: string | null;
+            /**
+             * @description The largest transfer-out of this risk bucket the engine will actually
+             *      accept — the bound enforced on bucket collateral withdrawals.
+             *
+             *      NOT a clamped `free_collateral`: free collateral is equity headroom and
+             *      credits realized PnL and mark-to-market gains that a transfer-out cannot
+             *      move. This bound is capped by the bucket's settled capacity (its
+             *      allocated collateral, under the default capacity basis), and an
+             *      unrealized gain never raises it.
+             *
+             *      This is the largest accepted transfer-out, NOT a promise that every
+             *      smaller one is accepted: an underwater flat bucket accepts its full
+             *      close-out while refusing partial withdrawals below it. Agrees with the
+             *      risk-bucket rows' `MarginAccountSummary.withdrawable_collateral` up to
+             *      quote-decimal truncation (this surface truncates toward zero; that one
+             *      may carry sub-tick tails).
+             */
+            withdrawableCollateral?: string | null;
         };
         PortfolioSeriesWindow: {
             /**
@@ -5987,7 +6331,7 @@ export interface components {
              */
             price?: string | null;
             /**
-             * @description New quantity (if changing)
+             * @description New TOTAL quantity (if changing). On a partially filled order the replacement rests total minus filled, and collateral is locked for that remainder only (FIX cancel/replace convention: LeavesQty = OrderQty - CumQty). Must exceed the filled amount. Omitted, the replacement keeps the unfilled remainder.
              * @example 0.7
              */
             quantity?: string | null;
@@ -6503,6 +6847,15 @@ export interface components {
              * @description Resolve the full live position size when triggered. Mutually exclusive
              *      with quantity. For compatibility, omitting both quantity and this field
              *      also means full-position close.
+             *
+             *      Attaching a full-close leg to a position SUPERSEDES that position's
+             *      previously active full-close legs of the same condition type: they are
+             *      cancelled in the same engine step that creates the replacement, so moving
+             *      a take-profit or stop-loss is one call with no window in which the
+             *      position holds both levels or neither. Fixed-quantity legs never
+             *      participate — laddered partial exits stack — and a superseded leg's
+             *      OCO sibling is left active rather than dropped. Legs attached to an entry
+             *      order are excluded on both sides.
              */
             closePosition?: boolean | null;
         };
@@ -6825,6 +7178,155 @@ export interface components {
              */
             tradingBalance?: string | null;
         };
+        TwapOrder: {
+            /**
+             * Format: uuid
+             * @description TWAP parent order UUID
+             */
+            twapOrderId?: string | null;
+            /**
+             * Format: uuid
+             * @description Trading pair UUID
+             */
+            tradingPairId?: string | null;
+            /**
+             * @description Order side: BUY or SELL
+             * @example BUY
+             */
+            side?: string | null;
+            /**
+             * @description Trading mode: SPOT or MARGIN
+             * @example SPOT
+             */
+            tradingMode?: string | null;
+            /**
+             * @description Total quantity requested
+             * @example 10
+             */
+            totalQuantity?: string | null;
+            /**
+             * @description Quantity executed so far across all child orders
+             * @example 4.5
+             */
+            executedQuantity?: string | null;
+            /**
+             * @description Notional (quote) value executed so far
+             * @example 157500.00
+             */
+            executedNotional?: string | null;
+            /**
+             * @description Volume-weighted average fill price (executedNotional / executedQuantity); absent until the first fill
+             * @example 35000.00
+             */
+            averageFillPrice?: string | null;
+            /**
+             * @description Execution progress as a decimal fraction (executedQuantity / totalQuantity, 0 to 1)
+             * @example 0.45
+             */
+            progress?: string | null;
+            /**
+             * @description Parent-level limit price; absent when only the slippage band protects child orders
+             * @example 35000.00
+             */
+            limitPrice?: string | null;
+            /**
+             * Format: int32
+             * @description Per-slice protective price band in basis points
+             * @example 100
+             */
+            slippageToleranceBps?: number | null;
+            /**
+             * @description Whether the parent is reduce-only
+             * @example false
+             */
+            reduceOnly?: boolean | null;
+            /**
+             * Format: uuid
+             * @description Margin account UUID for margin TWAP orders
+             */
+            marginAccountId?: string | null;
+            /**
+             * Format: uuid
+             * @description Isolated risk bucket UUID for risk-bucket-scoped margin TWAP orders
+             */
+            riskBucketId?: string | null;
+            /**
+             * @description Leverage for margin TWAP orders
+             * @example 5
+             */
+            leverage?: string | null;
+            /**
+             * @description Whether child orders use the master account balance
+             * @example false
+             */
+            useMasterBalance?: boolean | null;
+            /** @description Strategy key used to group risk buckets */
+            strategyKey?: string | null;
+            /** @description Client-assigned idempotency key */
+            clientTwapId?: string | null;
+            /**
+             * @description Whether seeded size/timing randomization is applied to the schedule
+             * @example true
+             */
+            randomize?: boolean | null;
+            /**
+             * @description Window start (ISO 8601)
+             * @example 2026-08-01T10:00:00Z
+             */
+            startTime?: string | null;
+            /**
+             * @description Window end (ISO 8601). Execution stops hard at this time.
+             * @example 2026-08-01T11:00:00Z
+             */
+            endTime?: string | null;
+            /**
+             * Format: int64
+             * @description Derived base slice interval in milliseconds (stored for audit)
+             * @example 30000
+             */
+            intervalMs?: number | null;
+            /**
+             * Format: int32
+             * @description Number of slices in the planned schedule
+             * @example 120
+             */
+            plannedSlices?: number | null;
+            /**
+             * Format: int32
+             * @description Number of child orders placed so far
+             * @example 54
+             */
+            slicesPlaced?: number | null;
+            /**
+             * Format: int32
+             * @description Number of slices skipped or failed so far (limit price through the market, self-trade prevention, halted market, failed admission). Skips never terminate the parent; the deficit flows into catch-up.
+             * @example 2
+             */
+            slicesSkipped?: number | null;
+            /**
+             * @description Planned time of the next slice (ISO 8601); absent once the parent is terminal
+             * @example 2026-08-01T10:27:30Z
+             */
+            nextSliceAt?: string | null;
+            /**
+             * @description Parent state: PENDING, ACTIVE, COMPLETED, or CANCELLED
+             * @example ACTIVE
+             */
+            state?: string | null;
+            /** @description Terminal cause detail, e.g. an end-of-window shortfall ('ended with shortfall <qty>'); absent for non-terminal parents */
+            terminalReason?: string | null;
+            /**
+             * @description Creation timestamp (ISO 8601)
+             * @example 2026-08-01T09:59:58Z
+             */
+            createdAt?: string | null;
+            /** @description Last update timestamp (ISO 8601) */
+            updatedAt?: string | null;
+            /** @description Cancellation timestamp (ISO 8601) */
+            cancelledAt?: string | null;
+            /** @description Completion timestamp (ISO 8601) */
+            completedAt?: string | null;
+        };
         UpdateLimitRequest: {
             /**
              * Format: uuid
@@ -10301,6 +10803,207 @@ export interface operations {
             };
         };
     };
+    list_twap_orders: {
+        parameters: {
+            query?: {
+                /** @description Page number (1-indexed) */
+                page?: number;
+                /** @description Items per page (max 100) */
+                pageSize?: number;
+                state?: string;
+                /** @description Trading pair identifier (UUID) */
+                tradingPairId?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListTwapOrdersResponse"];
+                };
+            };
+            /** @description Invalid query parameters */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    create_twap_order: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateTwapOrderRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CreateTwapOrderResponse"];
+                };
+            };
+            /** @description Invalid TWAP parameters (window bounds, quantity too small or too large to slice, margin field mismatch) or per-user active TWAP cap reached */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required or delegated-agent session (rejected for TWAP) */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Duplicate clientTwapId for this user and application */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error or matching engine failure */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_twap_order: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                twapOrderId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["TwapOrder"];
+                };
+            };
+            /** @description Invalid TWAP order ID format */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description TWAP order not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    cancel_twap_order: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                twapOrderId: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CancelTwapOrderResponse"];
+                };
+            };
+            /** @description Invalid TWAP order ID or order already terminal */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required or delegated-agent session (rejected for TWAP) */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description TWAP order not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
     get_order_by_id: {
         parameters: {
             query?: never;