tapimo 0.13.0 → 0.14.0

package/dist/apps/data/routes/exchanges.js

@@ -157,7 +157,7 @@ export var schema;
      * are absent on the base (no-`include`) response and best-effort when
      * requested (a token whose metadata is unavailable keeps just `address`).
      */
-    schema.PairToken = Schema.describe(z.object({
+    schema.PairToken = OpenApi.component(Schema.describe(z.object({
         address: Schema.tokenAddress(Tokens.tokenExample.address).check(z.describe('TIP-20 token contract address — the `0x`-prefixed 20-byte identifier for this token.'), z.meta({ examples: [Tokens.tokenExample.address] })),
         currency: z
             .optional(z.string())
@@ -177,14 +177,13 @@ export var schema;
         verified: z
             .optional(z.boolean())
             .check(z.describe('Whether Tempo has verified this token metadata.'), z.meta({ examples: [true] })),
-    }), 'One side of a trading pair (with metadata when requested via `include=tokens`).');
-    /** A token amount carrying its nominal value in the requested denomination. */
-    const ValuedAmount = z.extend(Schema.TokenAmount, {
+    }), 'One side of a trading pair (with metadata when requested via `include=tokens`).'), 'ExchangePairToken');
+    const ValuedAmount = OpenApi.component(Schema.describe(z.extend(Schema.TokenAmount, {
         valuation: z
             .optional(z.nullable(Valuation.schema.Value))
             .check(z.describe('The amount’s nominal value in the requested `valuation.currency`. `null` when the token is ' +
             'unverified, its display currency has no rate, or rates were unavailable.')),
-    });
+    }), 'A token amount carrying its nominal value in the requested denomination.'), 'ExchangeValuedAmount');
     /** Schemas for creating an executable exchange quote. */
     let createQuote;
     (function (createQuote) {
@@ -210,7 +209,7 @@ export var schema;
         })
             .check(z.describe('Query parameters for creating an exchange quote.'));
         /** Quote request with one pinned side and caller-selected slippage. */
-        createQuote.Request = z
+        createQuote.Request = OpenApi.component(z
             .strictObject({
             account: z
                 .optional(Schema.Address)
@@ -227,26 +226,26 @@ export var schema;
         })
             .check(z.refine((request) => request.sourceToken !== request.destinationToken, {
             error: 'Source and destination tokens must differ.',
-        }), z.describe('Request for an executable quote from the configured exchange providers.'));
+        }), z.describe('Request for an executable quote from the configured exchange providers.')), 'CreateExchangeQuoteRequest');
         /** One call in the unsigned Tempo transaction plan. */
-        createQuote.Call = z
+        createQuote.Call = OpenApi.component(z
             .object({
             data: Schema.Hex.check(z.describe('ABI-encoded call data.'), z.meta({ examples: ['0x095ea7b3'] })),
             to: Schema.Address.check(z.describe('Contract or precompile that receives the call.'), z.meta({ examples: [Addresses.stablecoinDex] })),
             value: Schema.Quantity.check(z.describe('Native token value sent with the call.'), z.meta({ examples: ['0x0'] })),
         })
-            .check(z.describe('One unsigned call in the Tempo transaction plan.'));
+            .check(z.describe('One unsigned call in the Tempo transaction plan.')), 'ExchangeQuoteCall');
         const QuoteToken = Schema.describe(z.partial(z.omit(Tokens.schema.Token, { id: true }), {
             logoUri: true,
             verified: true,
         }), 'A token referenced by an exchange quote, with RPC metadata and optional enrichments.');
-        const DestinationToken = z.extend(QuoteToken, {
+        const DestinationToken = OpenApi.component(Schema.describe(z.extend(QuoteToken, {
             address: DestinationTokenAddress.check(z.describe('TIP-20 token the swap receives.')),
-        });
-        const SourceToken = z.extend(QuoteToken, {
+        }), 'The token received by an exchange quote.'), 'ExchangeQuoteDestinationToken');
+        const SourceToken = OpenApi.component(Schema.describe(z.extend(QuoteToken, {
             address: SourceTokenAddress.check(z.describe('TIP-20 token the swap spends.')),
-        });
-        createQuote.Transaction = z
+        }), 'The token spent by an exchange quote.'), 'ExchangeQuoteSourceToken');
+        createQuote.Transaction = OpenApi.component(z
             .object({
             calls: z.array(createQuote.Call).check(z.minLength(1), z.describe('Calls to execute in order.'), z.meta({
                 examples: [
@@ -262,17 +261,17 @@ export var schema;
             })),
             chainId: Schema.ChainId.check(z.describe('Tempo chain where these calls execute.')),
         })
-            .check(z.describe('Unsigned Tempo transaction plan.'));
+            .check(z.describe('Unsigned Tempo transaction plan.')), 'ExchangeQuoteTransaction');
         /** Response-level valuation rate provenance. */
-        createQuote.Meta = z
+        createQuote.Meta = OpenApi.component(z
             .object({
             valuation: z
                 .optional(Valuation.schema.Pricing)
                 .check(z.describe('Rate provenance for amount valuations. Present when conversion rates were consulted.')),
         })
-            .check(z.describe('Response-level resources attached to this quote.'));
+            .check(z.describe('Response-level resources attached to this quote.')), 'ExchangeQuoteMeta');
         /** Provider-neutral EIP-712 payload to sign before finalizing a quote. */
-        createQuote.TypedData = z
+        createQuote.TypedData = OpenApi.component(z
             .object({
             domain: z.record(z.string(), z.unknown()).check(z.describe('EIP-712 signing domain.'), z.meta({
                 examples: [
@@ -324,7 +323,7 @@ export var schema;
                 ],
             })),
         })
-            .check(z.describe('EIP-712 payload the wallet must sign before execution can continue.'));
+            .check(z.describe('EIP-712 payload the wallet must sign before execution can continue.')), 'ExchangeQuoteTypedData');
         const Provider = z
             .string()
             .check(z.describe('Provider selected for this route.'), z.meta({ examples: ['nativeDex'] }));
@@ -332,20 +331,23 @@ export var schema;
             gasEstimate: Schema.DecimalString.check(z.describe('Estimated network fee in the chain native token’s base unit.'), z.meta({ examples: ['150000000000000'] })),
             provider: Provider,
         };
-        const ApprovalRequired = {
-            approval: z.object({
-                calls: z.array(createQuote.Call).check(z.minLength(1), z.describe('Approval calls to confirm before requesting a fresh quote.'), z.meta({
-                    examples: [
-                        [
-                            {
-                                data: exampleApprovalCall.data,
-                                to: exampleApprovalCall.to,
-                                value: '0x0',
-                            },
-                        ],
+        const Approval = OpenApi.component(z
+            .object({
+            calls: z.array(createQuote.Call).check(z.minLength(1), z.describe('Approval calls to confirm before requesting a fresh quote.'), z.meta({
+                examples: [
+                    [
+                        {
+                            data: exampleApprovalCall.data,
+                            to: exampleApprovalCall.to,
+                            value: '0x0',
+                        },
                     ],
-                })),
-            }),
+                ],
+            })),
+        })
+            .check(z.describe('Token approval calls required before requesting a fresh quote.')), 'ExchangeQuoteApproval');
+        const ApprovalRequired = {
+            approval: Approval,
             status: z
                 .literal('approvalRequired')
                 .check(z.describe('Confirm the approvals, then request a fresh quote.'), z.meta({ examples: ['approvalRequired'] })),
@@ -366,44 +368,63 @@ export var schema;
             typedData: createQuote.TypedData,
         };
         const ExactSource = {
-            destinationAmount: ValuedAmount.check(z.describe('Quoted destination amount.')),
-            destinationAmountMin: ValuedAmount.check(z.describe('Minimum destination amount after slippage.')),
+            destinationAmount: ValuedAmount,
+            destinationAmountMin: ValuedAmount,
             destinationToken: DestinationToken,
             meta: z.optional(createQuote.Meta).check(z.describe('Valuation rate provenance for this quote.')),
             mode: z
                 .literal('exactSource')
                 .check(z.describe('The source amount is fixed and the destination has a minimum.'), z.meta({ examples: ['exactSource'] })),
-            sourceAmount: ValuedAmount.check(z.describe('Exact source amount.')),
-            sourceToken: SourceToken.check(z.describe('Token spent by the swap.')),
+            sourceAmount: ValuedAmount,
+            sourceToken: SourceToken,
         };
         const ExactDestination = {
-            destinationAmount: ValuedAmount.check(z.describe('Exact destination amount.')),
-            destinationToken: DestinationToken.check(z.describe('Token received by the swap.')),
+            destinationAmount: ValuedAmount,
+            destinationToken: DestinationToken,
             meta: z.optional(createQuote.Meta).check(z.describe('Valuation rate provenance for this quote.')),
             mode: z
                 .literal('exactDestination')
                 .check(z.describe('The destination amount is fixed and the source has a maximum.'), z.meta({ examples: ['exactDestination'] })),
-            sourceAmount: ValuedAmount.check(z.describe('Quoted source amount.')),
-            sourceAmountMax: ValuedAmount.check(z.describe('Maximum source amount after slippage.')),
+            sourceAmount: ValuedAmount,
+            sourceAmountMax: ValuedAmount,
             sourceToken: SourceToken,
         };
+        const ExactSourceApprovalRequired = OpenApi.component(z
+            .object({ ...ApprovalRequired, ...ExactSource, ...Quote })
+            .check(z.describe('An exact-source quote that requires token approval.')), 'ExchangeQuoteExactSourceApprovalRequired');
+        const ExactSourceReady = OpenApi.component(z
+            .object({ ...ExactSource, ...Quote, ...Ready })
+            .check(z.describe('An exact-source quote ready to execute.')), 'ExchangeQuoteExactSourceReady');
+        const ExactSourceSignatureRequired = OpenApi.component(z
+            .object({ ...ExactSource, ...Quote, ...SignatureRequired })
+            .check(z.describe('An exact-source quote that requires a signature.')), 'ExchangeQuoteExactSourceSignatureRequired');
+        const ExactDestinationApprovalRequired = OpenApi.component(z
+            .object({ ...ApprovalRequired, ...ExactDestination, ...Quote })
+            .check(z.describe('An exact-destination quote that requires token approval.')), 'ExchangeQuoteExactDestinationApprovalRequired');
+        const ExactDestinationReady = OpenApi.component(z
+            .object({ ...ExactDestination, ...Quote, ...Ready })
+            .check(z.describe('An exact-destination quote ready to execute.')), 'ExchangeQuoteExactDestinationReady');
+        const ExactDestinationSignatureRequired = OpenApi.component(z
+            .object({ ...ExactDestination, ...Quote, ...SignatureRequired })
+            .check(z.describe('An exact-destination quote that requires a signature.')), 'ExchangeQuoteExactDestinationSignatureRequired');
         /** Provider-neutral quote and the action needed to execute it. */
-        createQuote.Response = z
+        createQuote.Response = OpenApi.component(z
             .union([
-            z.object({ ...ApprovalRequired, ...ExactSource, ...Quote }),
-            z.object({ ...ExactSource, ...Quote, ...Ready }),
-            z.object({ ...ExactSource, ...Quote, ...SignatureRequired }),
-            z.object({ ...ApprovalRequired, ...ExactDestination, ...Quote }),
-            z.object({ ...ExactDestination, ...Quote, ...Ready }),
-            z.object({ ...ExactDestination, ...Quote, ...SignatureRequired }),
+            ExactSourceApprovalRequired,
+            ExactSourceReady,
+            ExactSourceSignatureRequired,
+            ExactDestinationApprovalRequired,
+            ExactDestinationReady,
+            ExactDestinationSignatureRequired,
         ])
-            .check(z.describe('Provider-neutral exchange quote with its next execution action.'));
+            .check(z.describe('Provider-neutral exchange quote with its next execution action.')), 'ExchangeQuote');
     })(createQuote = schema.createQuote || (schema.createQuote = {}));
     /** Schemas for finishing a quote after a provider-requested signature. */
     let executeQuote;
     (function (executeQuote) {
         /** Signed continuation request. */
-        executeQuote.Request = z.strictObject({
+        executeQuote.Request = OpenApi.component(z
+            .strictObject({
             account: Schema.Address.check(z.describe('Wallet that signed and will execute the swap.'), z.meta({ examples: ['0x1111111111111111111111111111111111111111'] })),
             continuation: z
                 .string()
@@ -412,14 +433,17 @@ export var schema;
                 .string()
                 .check(z.minLength(1), z.describe('Provider that issued the continuation.'), z.meta({ examples: ['uniswap'] })),
             signature: Schema.Hex.check(z.refine((value) => value.length === 132, { error: 'Signature must be 65 bytes.' }), z.describe('65-byte EIP-712 signature requested by the quote.'), z.meta({ examples: [`0x${'11'.repeat(65)}`] })),
-        });
+        })
+            .check(z.describe('Request to finalize a provider quote after signing its typed data.')), 'FinalizeExchangeQuoteRequest');
         /** Final transaction plan. */
-        executeQuote.Response = z.object({
+        executeQuote.Response = OpenApi.component(z
+            .object({
             provider: z
                 .string()
                 .check(z.describe('Provider that built the transaction.'), z.meta({ examples: ['uniswap'] })),
             transaction: createQuote.Transaction,
-        });
+        })
+            .check(z.describe('Final unsigned transaction plan for a signed provider quote.')), 'FinalizedExchangeQuote');
     })(executeQuote = schema.executeQuote || (schema.executeQuote = {}));
     /** Schemas for the getPairs operation. */
     let getPairs;
@@ -453,9 +477,9 @@ export var schema;
         })
             .check(...Schema.pageChecks(), z.describe('Filters, pagination, and sorting options for listing exchange trading pairs.'));
         /** A single trading pair on the stablecoin DEX. */
-        getPairs.Pair = z
+        getPairs.Pair = OpenApi.component(z
             .object({
-            base: schema.PairToken.check(z.describe('Base token — the asset whose price is quoted in the pair.')),
+            base: schema.PairToken,
             blockNumber: z
                 .number()
                 .check(z.int(), z.nonnegative(), z.describe('Block number where the pair was created.'), z.meta({ examples: [23456789] })),
@@ -466,23 +490,25 @@ export var schema;
                 .string()
                 .check(z.regex(/^\d+$/), z.describe('Liquidity signal for the pair: the base-token balance held by the DEX, returned as a decimal integer string in the token’s smallest units. Present only when `sort=liquidity`.')))
                 .check(z.describe('Liquidity signal for the pair, present only when you request `sort=liquidity`.'), z.meta({ examples: ['1000000'] })),
-            quote: schema.PairToken.check(z.describe('Quote token — the asset used to price the base token.')),
+            quote: schema.PairToken,
             timestamp: z.iso
                 .datetime()
                 .check(z.describe('Block timestamp when the pair was created.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
             transactionHash: Schema.Hash.check(z.describe('Transaction hash for the transaction that created the pair.')),
         })
-            .check(z.describe('One trading pair on Tempo’s built-in stablecoin exchange.'));
+            .check(z.describe('One trading pair on Tempo’s built-in stablecoin exchange.')), 'ExchangePair');
+        /** Response metadata requested through `include`, such as capped counts. */
+        getPairs.Meta = OpenApi.component(Schema.CountMeta, 'ExchangePairListMeta');
         /** Page of trading pairs on the stablecoin DEX, ordered by creation. */
-        getPairs.Response = z
+        getPairs.Response = OpenApi.component(z
             .object({
             data: z.array(getPairs.Pair).check(z.describe('Trading pairs returned on this page.')),
             meta: z
-                .optional(Schema.CountMeta)
+                .optional(getPairs.Meta)
                 .check(z.describe('Response-level resources requested with `include`, such as `totalCount`.')),
             nextCursor: Schema.NextCursor,
         })
-            .check(z.describe('A paginated list of trading pairs on Tempo’s built-in stablecoin exchange.'));
+            .check(z.describe('A paginated list of trading pairs on Tempo’s built-in stablecoin exchange.')), 'ExchangePairList');
     })(getPairs = schema.getPairs || (schema.getPairs = {}));
     /** Schemas for the getPair operation (single trading pair detail). */
     let getPair;
@@ -555,12 +581,12 @@ export var schema;
             'transaction expands one fill group into a variable number of swap rows, so a ' +
             'positional `page` has no stable meaning on this feed.'));
         /** One swap-side token with RPC metadata and optional curated fields. */
-        getSwaps.SwapSide = Schema.describe(Tokens.schema.TokenReference, 'A token referenced by one side of a swap.');
+        getSwaps.SwapSide = OpenApi.component(Schema.describe(Tokens.schema.TokenReference, 'A token referenced by one side of a swap.'), 'ExchangeSwapToken');
         /** A single maker-order fill within a swap, framed from the taker's perspective. */
-        getSwaps.Fill = z
+        getSwaps.Fill = OpenApi.component(z
             .object({
-            destinationAmount: ValuedAmount.check(z.describe('Amount the taker received in this fill.')),
-            destinationToken: getSwaps.SwapSide.check(z.describe('Token the taker received in this fill.')),
+            destinationAmount: ValuedAmount,
+            destinationToken: getSwaps.SwapSide,
             logIndex: z
                 .number()
                 .check(z.int(), z.nonnegative(), z.describe('Log index of this fill within its block.'), z.meta({ examples: [0] })),
@@ -572,10 +598,10 @@ export var schema;
             price: z
                 .string()
                 .check(z.regex(/^\d+(\.\d+)?$/), z.describe('Quote-per-base price at fill time, returned as a fixed-decimal string with 5 decimal places. This value is direction-independent and works well for charts.'), z.meta({ examples: ['1.00000'] })),
-            sourceAmount: ValuedAmount.check(z.describe('Amount the taker sent in this fill.')),
-            sourceToken: getSwaps.SwapSide.check(z.describe('Token the taker sent in this fill.')),
+            sourceAmount: ValuedAmount,
+            sourceToken: getSwaps.SwapSide,
         })
-            .check(z.describe('One maker-order fill within a swap, described from the taker’s perspective.'));
+            .check(z.describe('One maker-order fill within a swap, described from the taker’s perspective.')), 'ExchangeSwapFill');
         /**
          * A single logical taker swap on the stablecoin DEX: every maker-order
          * fill one taker's swap produced in one transaction, assembled into a
@@ -583,13 +609,13 @@ export var schema;
          * intermediate token, e.g. pathUSD) are one row; the intermediate hops
          * are visible via `route` and `fills`.
          */
-        getSwaps.Swap = z
+        getSwaps.Swap = OpenApi.component(z
             .object({
             blockNumber: z
                 .number()
                 .check(z.int(), z.nonnegative(), z.describe('Block number where the swap was included.'), z.meta({ examples: [23456789] })),
-            destinationAmount: ValuedAmount.check(z.describe('Total amount the taker received in this swap.')),
-            destinationToken: getSwaps.SwapSide.check(z.describe('Destination token for the final hop.')),
+            destinationAmount: ValuedAmount,
+            destinationToken: getSwaps.SwapSide,
             filledAt: z.iso
                 .datetime()
                 .check(z.describe('Block timestamp when the swap was filled onchain.'), z.meta({ examples: ['2024-01-01T00:00:00Z'] })),
@@ -611,12 +637,12 @@ export var schema;
             route: z
                 .array(Schema.TokenAddress)
                 .check(z.describe('Token path for the swap, from source through any intermediate tokens to destination. `route.length - 1` is the hop count; two entries means a direct swap.')),
-            sourceAmount: ValuedAmount.check(z.describe('Total amount the taker sent in this swap.')),
-            sourceToken: getSwaps.SwapSide.check(z.describe('Source token for the first hop.')),
+            sourceAmount: ValuedAmount,
+            sourceToken: getSwaps.SwapSide,
             taker: Schema.Address.check(z.describe('Taker address that initiated the swap.')),
             transactionHash: Schema.Hash.check(z.describe('Transaction hash for the transaction containing the swap.')),
         })
-            .check(z.describe('One logical taker swap on Tempo’s built-in stablecoin exchange.'));
+            .check(z.describe('One logical taker swap on Tempo’s built-in stablecoin exchange.')), 'ExchangeSwap');
         /**
          * Page of swaps. A row is one logical taker swap — the fills of one
          * `(transaction, taker)` group chained source → destination — so the
@@ -625,15 +651,15 @@ export var schema;
          * taker may have its rows split across consecutive pages.
          */
         /** Page-level resources: valuation rate provenance. */
-        getSwaps.Meta = z
+        getSwaps.Meta = OpenApi.component(z
             .object({
             valuation: z
                 .optional(Valuation.schema.Pricing)
                 .check(z.describe('Rate provenance for amount valuations. Present when conversion rates were ' +
                 'consulted; absent when every value was identity-valued or rates were unavailable.')),
         })
-            .check(z.describe('Page-level resources attached to this response.'));
-        getSwaps.Response = z
+            .check(z.describe('Page-level resources attached to this response.')), 'ExchangeSwapListMeta');
+        getSwaps.Response = OpenApi.component(z
             .object({
             data: z.array(getSwaps.Swap).check(z.describe('Swaps returned on this page.')),
             meta: z
@@ -641,7 +667,7 @@ export var schema;
                 .check(z.describe('Page-level resources, such as valuation rate provenance.')),
             nextCursor: Schema.NextCursor,
         })
-            .check(z.describe('A paginated list of swaps on Tempo’s built-in stablecoin exchange.'));
+            .check(z.describe('A paginated list of swaps on Tempo’s built-in stablecoin exchange.')), 'ExchangeSwapList');
     })(getSwaps = schema.getSwaps || (schema.getSwaps = {}));
     /** Schemas for the getPairOhlc operation (candlestick aggregations). */
     let getPairOhlc;
@@ -695,7 +721,7 @@ export var schema;
          * and low are the extrema across all fills in the bucket. Volumes are
          * the sum of per-fill base- and quote-side amounts in base units.
          */
-        getPairOhlc.Bucket = z
+        getPairOhlc.Bucket = OpenApi.component(z
             .object({
             close: z
                 .string()
@@ -727,22 +753,22 @@ export var schema;
             })
                 .check(z.describe('Total filled volume in this bucket, split by pair side.')),
         })
-            .check(z.describe('One OHLC candle bucket for charting a trading pair.'));
+            .check(z.describe('One OHLC candle bucket for charting a trading pair.')), 'ExchangeOhlcBucket');
         /** Page of candlestick buckets for a single trading pair. */
-        getPairOhlc.Response = z
+        getPairOhlc.Response = OpenApi.component(z
             .object({
-            base: schema.PairToken.check(z.describe('Base side of the trading pair.')),
+            base: schema.PairToken,
             data: z
                 .array(getPairOhlc.Bucket)
                 .check(z.describe('OHLC candle buckets ordered oldest to newest; empty buckets are omitted.')),
             interval: getPairOhlc.Interval,
-            quote: schema.PairToken.check(z.describe('Quote side of the trading pair.')),
+            quote: schema.PairToken,
             truncated: z
                 .boolean()
                 .check(z.describe('`true` when the fill scan hit its hard cap, meaning OHLC values were computed from only the most recent fills.'), z.meta({ examples: [false] })),
             window: getPairOhlc.Window,
         })
-            .check(z.describe('OHLC candle data for one trading pair over a rolling time window.'));
+            .check(z.describe('OHLC candle data for one trading pair over a rolling time window.')), 'ExchangePairOhlc');
     })(getPairOhlc = schema.getPairOhlc || (schema.getPairOhlc = {}));
     /** Schemas shared by the order detail and order fills handlers. */
     let order;
@@ -754,11 +780,11 @@ export var schema;
         })
             .check(z.describe('Path parameters for routes that look up one order.'));
         /** The pair the order is placed against. */
-        order.Pair = Schema.describe(z.object({
-            base: schema.PairToken.check(z.describe('Base side of the pair; the order trades this token.')),
+        order.Pair = OpenApi.component(Schema.describe(z.object({
+            base: schema.PairToken,
             key: Schema.Hash.check(z.describe('On-chain key for this `(base, quote)` trading pair.')),
-            quote: schema.PairToken.check(z.describe('Quote side of the trading pair.')),
-        }), 'The trading pair the order belongs to.');
+            quote: schema.PairToken,
+        }), 'The trading pair the order belongs to.'), 'ExchangeOrderPair');
     })(order = schema.order || (schema.order = {}));
     /** Schemas for the getOrder operation. */
     let getOrder;
@@ -796,7 +822,7 @@ export var schema;
          * over time and would otherwise force this resource to revalidate on
          * every new fill.
          */
-        getOrder.Response = Schema.describe(z.object({
+        getOrder.Response = OpenApi.component(Schema.describe(z.object({
             amount: Schema.DecimalString.check(z.describe('Initial order size, returned as a decimal integer string in base-token smallest units.')),
             flipTick: z
                 .number()
@@ -824,7 +850,7 @@ export var schema;
             tick: z
                 .number()
                 .check(z.int(), z.describe('On-chain signed tick, scaled by `1/priceScale`; use `price` for the decoded ratio.'), z.meta({ examples: [0] })),
-        }), 'A single DEX order with live onchain state.');
+        }), 'A single DEX order with live onchain state.'), 'ExchangeOrder');
     })(getOrder = schema.getOrder || (schema.getOrder = {}));
     /** Schemas for the getOrders operation (the resting-order feed, optionally pair-scoped). */
     let getOrders;
@@ -875,8 +901,7 @@ export var schema;
          * Orders for which `remaining <= 0` or that have an `OrderCancelled`
          * event are excluded from the response.
          */
-        getOrders.RestingOrder = z
-            .object({
+        getOrders.RestingOrder = Schema.describe(z.object({
             amount: Schema.DecimalString.check(z.describe('Original placed amount, returned as a decimal integer string in base-token smallest units.')),
             blockNumber: z
                 .number()
@@ -904,27 +929,26 @@ export var schema;
                 .number()
                 .check(z.int(), z.describe('Order tick as a signed offset from peg; one tick equals `1/priceScale`.'), z.meta({ examples: [0] })),
             transactionHash: Schema.Hash.check(z.describe('Transaction hash for the transaction that placed the order.')),
-        })
-            .check(z.describe('One resting maker order on Tempo’s built-in stablecoin exchange.'));
+        }), 'One resting maker order on Tempo’s built-in stablecoin exchange.');
         /** A resting maker order annotated with the trading pair it belongs to. */
-        getOrders.Order = z
-            .extend(getOrders.RestingOrder, {
+        getOrders.Order = OpenApi.component(Schema.describe(z.extend(getOrders.RestingOrder, {
             pair: order.Pair,
-        })
-            .check(z.describe('A resting maker order plus its trading pair.'));
+        }), 'A resting maker order plus its trading pair.'), 'ExchangeRestingOrder');
+        /** Response metadata requested through `include`, such as capped counts. */
+        getOrders.Meta = OpenApi.component(Schema.CountMeta, 'ExchangeOrderListMeta');
         /** Page of resting maker orders, each annotated with its trading pair. */
-        getOrders.Response = z
+        getOrders.Response = OpenApi.component(z
             .object({
             data: z.array(getOrders.Order).check(z.describe('Resting orders returned on this page.')),
             meta: z
-                .optional(Schema.CountMeta)
+                .optional(getOrders.Meta)
                 .check(z.describe('Response-level resources requested with `include`, such as `totalCount`.')),
             nextCursor: Schema.NextCursor,
             truncated: z
                 .boolean()
                 .check(z.describe('`true` when the `OrderPlaced` scan hit its hard cap, meaning the resting set was computed from only the most recent placements.'), z.meta({ examples: [false] })),
         })
-            .check(z.describe('A paginated list of resting maker orders on Tempo’s built-in stablecoin exchange.'));
+            .check(z.describe('A paginated list of resting maker orders on Tempo’s built-in stablecoin exchange.')), 'ExchangeOrderList');
     })(getOrders = schema.getOrders || (schema.getOrders = {}));
     /** Schemas for the getOrderFills operation. */
     let getOrderFills;
@@ -947,7 +971,7 @@ export var schema;
          * rate are constant across all fills, so they live on the `Order`
          * resource rather than being repeated per row.
          */
-        getOrderFills.Fill = z
+        getOrderFills.Fill = OpenApi.component(z
             .object({
             amountFilled: Schema.DecimalString.check(z.describe('Base-side amount filled by this event, returned as a decimal integer string in base-token smallest units.')),
             blockNumber: z
@@ -969,17 +993,19 @@ export var schema;
             taker: Schema.Address.check(z.describe('Taker address that submitted the incoming order.')),
             transactionHash: Schema.Hash.check(z.describe('Transaction hash for the transaction containing the fill.')),
         })
-            .check(z.describe('One `OrderFilled` event against this order.'));
+            .check(z.describe('One `OrderFilled` event against this order.')), 'ExchangeOrderFill');
+        /** Response metadata requested through `include`, such as capped counts. */
+        getOrderFills.Meta = OpenApi.component(Schema.CountMeta, 'ExchangeOrderFillListMeta');
         /** Paginated page of fills for one order. */
-        getOrderFills.Response = z
+        getOrderFills.Response = OpenApi.component(z
             .object({
             data: z.array(getOrderFills.Fill).check(z.describe('Fills returned on this page.')),
             meta: z
-                .optional(Schema.CountMeta)
+                .optional(getOrderFills.Meta)
                 .check(z.describe('Response-level resources requested with `include`.')),
             nextCursor: Schema.NextCursor,
         })
-            .check(z.describe('A paginated list of fill events for one DEX order.'));
+            .check(z.describe('A paginated list of fill events for one DEX order.')), 'ExchangeOrderFillList');
     })(getOrderFills = schema.getOrderFills || (schema.getOrderFills = {}));
     /** Schemas for the getPairDepth operation (orderbook depth aggregation). */
     let getPairDepth;
@@ -1023,11 +1049,13 @@ export var schema;
          * side, starting from the best (peg-adjacent) populated tick and walking
          * outward.
          */
-        getPairDepth.Level = z
+        getPairDepth.Level = OpenApi.component(z
             .object({
             cumulativeSize: Schema.DecimalString.check(z.describe('Running sum of `size` from the best populated tick outward to this level, in base-token smallest units.')),
             id: z.string().check(z.describe('Stable API id built from the pair key, orderbook side, and tick.'), z.meta({
-                examples: ['0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-bid-0'],
+                examples: [
+                    '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665-bid-0',
+                ],
             })),
             price: z
                 .string()
@@ -1037,20 +1065,20 @@ export var schema;
                 .number()
                 .check(z.int(), z.describe('Signed price tick (`int16`), always a multiple of the DEX tick spacing.'), z.meta({ examples: [0] })),
         })
-            .check(z.describe('One price level in the orderbook depth response.'));
+            .check(z.describe('One price level in the orderbook depth response.')), 'ExchangeDepthLevel');
         /** Orderbook depth (cumulative size per tick) for a single trading pair. */
-        getPairDepth.Response = z
+        getPairDepth.Response = OpenApi.component(z
             .object({
             asks: z
                 .array(getPairDepth.Level)
                 .check(z.describe('Ask-side levels, where makers sell base and takers buy it, ordered from best lowest ask outward.')),
-            base: schema.PairToken.check(z.describe('Base side of the trading pair.')),
+            base: schema.PairToken,
             bids: z
                 .array(getPairDepth.Level)
                 .check(z.describe('Bid-side levels, where makers buy base and takers sell it, ordered from best highest bid outward.')),
-            quote: schema.PairToken.check(z.describe('Quote side of the trading pair.')),
+            quote: schema.PairToken,
         })
-            .check(z.describe('Orderbook depth for one trading pair, with cumulative size at each tick.'));
+            .check(z.describe('Orderbook depth for one trading pair, with cumulative size at each tick.')), 'ExchangePairDepth');
     })(getPairDepth = schema.getPairDepth || (schema.getPairDepth = {}));
 })(schema || (schema = {}));
 /**
@@ -1086,7 +1114,15 @@ export function exchanges(options = {}) {
         operationId: 'createExchangeQuote',
         responses: OpenApi.responses({
             errors: {
-                400: { codes: ['body_invalid', 'query_invalid', 'quote_amount_out_of_range'] },
+                400: {
+                    codes: [
+                        'body_invalid',
+                        'chain_id_invalid',
+                        'chain_id_unsupported',
+                        'query_invalid',
+                        'quote_amount_out_of_range',
+                    ],
+                },
                 404: {
                     codes: ['quote_not_available'],
                     description: 'No configured provider can price an executable exchange for these terms.',
@@ -1372,6 +1408,8 @@ export function exchanges(options = {}) {
                 400: {
                     codes: [
                         'body_invalid',
+                        'chain_id_invalid',
+                        'chain_id_unsupported',
                         'query_invalid',
                         'swap_continuation_invalid',
                         'swap_provider_invalid',
@@ -1455,6 +1493,9 @@ export function exchanges(options = {}) {
         operationId: 'getSwaps',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'query_invalid'],
+                },
                 502: 'The indexer or Tempo RPC could not serve the exchange data right now.',
             },
             success: {
@@ -1600,7 +1641,12 @@ export function exchanges(options = {}) {
         description: 'List trading pairs available on Tempo’s built-in stablecoin exchange.',
         operationId: 'getPairs',
         responses: OpenApi.responses({
-            errors: { 502: 'The indexer could not serve the exchange data right now.' },
+            errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'query_invalid'],
+                },
+                502: 'The indexer could not serve the exchange data right now.',
+            },
             success: {
                 description: 'A page of exchange trading pairs.',
                 schema: schema.getPairs.Response,
@@ -1700,6 +1746,9 @@ export function exchanges(options = {}) {
         operationId: 'getPair',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'pair_invalid', 'query_invalid'],
+                },
                 404: {
                     description: 'No exchange pair was found for that base token.',
                     codes: ['pair_not_found'],
@@ -1781,6 +1830,9 @@ export function exchanges(options = {}) {
         operationId: 'getOrders',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'query_invalid'],
+                },
                 404: {
                     description: 'No exchange pair was found for the requested `base` filter.',
                     codes: ['pair_not_found'],
@@ -1897,6 +1949,9 @@ export function exchanges(options = {}) {
         operationId: 'getOrder',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'order_invalid', 'query_invalid'],
+                },
                 404: {
                     description: 'No exchange order was found for that id.',
                     codes: ['order_not_found'],
@@ -1989,7 +2044,12 @@ export function exchanges(options = {}) {
         description: 'List fills for one order. A fill records an execution against the maker order.',
         operationId: 'getOrderFills',
         responses: OpenApi.responses({
-            errors: { 502: 'The indexer could not serve the exchange data right now.' },
+            errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'order_invalid', 'query_invalid'],
+                },
+                502: 'The indexer could not serve the exchange data right now.',
+            },
             success: {
                 description: 'A page of fills for one order.',
                 schema: schema.getOrderFills.Response,
@@ -2065,6 +2125,9 @@ export function exchanges(options = {}) {
         operationId: 'getPairOhlc',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'pair_invalid', 'query_invalid'],
+                },
                 404: {
                     description: 'No exchange pair was found for that base token.',
                     codes: ['pair_not_found'],
@@ -2162,6 +2225,9 @@ export function exchanges(options = {}) {
         operationId: 'getPairDepth',
         responses: OpenApi.responses({
             errors: {
+                400: {
+                    codes: ['chain_id_invalid', 'chain_id_unsupported', 'pair_invalid', 'query_invalid'],
+                },
                 404: {
                     description: 'No exchange pair was found for that base token.',
                     codes: ['pair_not_found'],