tapimo 0.11.0 → 0.12.0

package/src/internal/EarnVaults.ts

@@ -1,3 +1,4 @@
+import { ZoneId } from 'ox/tempo'
 import {
   ContractFunctionExecutionError,
   ContractFunctionRevertedError,
@@ -161,6 +162,28 @@ export namespace schema {
     })
     .check(z.describe('Onchain identity of an Earn vault.'))
 
+  /** Schema for one curated Earn route through a private Zone. */
+  export const ZoneRoute = z
+    .strictObject({
+      chainId: Schema.ChainId.check(
+        z.describe('Private Zone chain id.'),
+        z.meta({ examples: [1424310001] }),
+      ),
+      deploymentBlock: z
+        .number()
+        .check(
+          z.int(),
+          z.nonnegative(),
+          z.describe('Parent-chain block that deployed the Earn router.'),
+          z.meta({ examples: [31039238] }),
+        ),
+      earnRouter: Schema.Address.check(
+        z.describe('Parent-chain router for this Zone and Earn vault.'),
+        z.meta({ examples: ['0x9144086a79dea966d8bf1b52125ebed8919fc45c'] }),
+      ),
+    })
+    .check(z.describe('Curated Earn route through one private Zone.'))
+
   /** Schema for live state resolved from one Earn vault. */
   export const Discovery = z
     .strictObject({
@@ -228,12 +251,48 @@ export type Discovery = z.output<typeof schema.Discovery>
 /** Onchain identity of an Earn vault. */
 export type ResolveInput = z.output<typeof schema.ResolveInput>
 
+/** Curated Earn route through one private Zone. */
+export type ZoneRoute = z.output<typeof schema.ZoneRoute>
+
+/** Curated Zone route with immutable router bindings resolved onchain. */
+export type ResolvedZoneRoute = ZoneRoute & {
+  /** Tokens accepted by private deposits. */
+  inputTokens: readonly Address[]
+  /** Configured private Zone name. */
+  name: string
+  /** Tokens returned by private redemptions. */
+  outputTokens: readonly Address[]
+}
+
+/** Adds capabilities proven by a verified private Zone route. */
+export function addZoneRouteCapabilities(
+  capabilities: NonNullable<Discovery['capabilities']>,
+): NonNullable<Discovery['capabilities']> {
+  return { ...capabilities, privateRouting: true, routerSwaps: true }
+}
+
+/** Derives a Zone ID from any supported Zone chain-ID scheme. */
+export function deriveZoneId(chainId: number): number {
+  for (const sourceId of [4_217, 42_431] satisfies readonly ZoneId.SourceId[]) {
+    const zoneId = ZoneId.fromChainId(chainId, sourceId)
+    if (zoneId >= 0 && ZoneId.toChainId(zoneId, sourceId) === chainId) return zoneId
+  }
+  throw new InvalidRegistryError(`Chain ${chainId} does not use a supported Zone chain-ID scheme.`)
+}
+
 /** Stable code describing an onchain verification issue. */
 export type VerificationIssueCode =
   | 'chain-mismatch'
   | 'engine-asset-mismatch'
   | 'policy-unsupported'
   | 'read-failed'
+  | 'zone-deployment-block-mismatch'
+  | 'zone-flow-unsupported'
+  | 'zone-id-mismatch'
+  | 'zone-router-invalid'
+  | 'zone-share-mismatch'
+  | 'zone-vault-asset-mismatch'
+  | 'zone-vault-mismatch'
 
 /** One onchain verification issue. */
 export type VerificationIssue = {
@@ -303,6 +362,16 @@ type RouterCapabilities = {
   redeem: boolean
 }
 
+type ZoneRouteBindings = {
+  allowedZoneId: number
+  deposit: boolean
+  earnShare: Address
+  earnVault: Address
+  privateAsset: Address
+  redeem: boolean
+  vaultAsset: Address
+}
+
 type TokenMetadata = Omit<Discovery['assetToken'], 'address'>
 
 const engineBindingsAbi = parseAbi(['function vault() view returns (address)'])
@@ -363,6 +432,139 @@ export declare namespace resolve {
   }
 }
 
+/** Resolves and verifies every curated Zone route for one Earn vault. */
+export async function resolveZoneRoutes(
+  options: resolveZoneRoutes.Options,
+): Promise<ResolvedZoneRoute[]> {
+  const result = z.array(schema.ZoneRoute).safeParse(options.routes)
+  if (!result.success) throw invalid(result.error)
+
+  const chainIds = new Set<number>()
+  const routers = new Set<string>()
+  for (const route of result.data) {
+    if (chainIds.has(route.chainId))
+      throw new InvalidRegistryError(`Zone ${route.chainId} is configured more than once.`)
+    if (routers.has(route.earnRouter))
+      throw new InvalidRegistryError(
+        `Earn router ${route.earnRouter} is configured more than once.`,
+      )
+    chainIds.add(route.chainId)
+    routers.add(route.earnRouter)
+  }
+  if (result.data.length === 0) return []
+
+  const client = options.getClient(options.discovery.chainId)
+  return Promise.all(
+    result.data.map(async (route) => {
+      const zone = options.zones.find((candidate) => candidate.id === route.chainId)
+      if (!zone) throw new InvalidRegistryError(`Zone ${route.chainId} is not configured.`)
+      if (zone.sourceId !== options.discovery.chainId)
+        throw new InvalidRegistryError(
+          `Zone ${route.chainId} does not belong to chain ${options.discovery.chainId}.`,
+        )
+      const expectedZoneId = deriveZoneId(route.chainId)
+
+      const [code, previousCode] = await Promise.all([
+        client.getCode({
+          address: route.earnRouter,
+          blockNumber: BigInt(route.deploymentBlock),
+        }),
+        route.deploymentBlock === 0
+          ? undefined
+          : client.getCode({
+              address: route.earnRouter,
+              blockNumber: BigInt(route.deploymentBlock - 1),
+            }),
+      ])
+      if (!code || code === '0x' || (previousCode !== undefined && previousCode !== '0x'))
+        throw mismatch({
+          discovery: options.discovery,
+          issues: [
+            {
+              actual: String(route.deploymentBlock),
+              code: 'zone-deployment-block-mismatch',
+              message: 'Earn router deployment block does not match its code boundary.',
+            },
+          ],
+        })
+
+      const bindings = await readZoneRouteBindings(client, { earnRouter: route.earnRouter }).catch(
+        (error) => {
+          if (!isMissingOptionalFunctionError(error)) throw error
+          throw mismatch({
+            discovery: options.discovery,
+            issues: [
+              {
+                actual: route.earnRouter,
+                code: 'zone-router-invalid',
+                message: 'Earn router does not expose the required immutable bindings.',
+              },
+            ],
+          })
+        },
+      )
+      const issues: VerificationIssue[] = []
+      if (bindings.allowedZoneId !== expectedZoneId)
+        issues.push({
+          actual: bindings.allowedZoneId.toString(),
+          code: 'zone-id-mismatch',
+          expected: String(expectedZoneId),
+          message: 'Earn router is configured for a different Zone.',
+        })
+      compareAddress(
+        issues,
+        'zone-vault-mismatch',
+        'Earn router is configured for a different Earn vault.',
+        options.discovery.vaultAddress,
+        bindings.earnVault,
+      )
+      compareAddress(
+        issues,
+        'zone-vault-asset-mismatch',
+        'Earn router vault asset does not match the Earn vault.',
+        options.discovery.assetToken.address,
+        bindings.vaultAsset,
+      )
+      compareAddress(
+        issues,
+        'zone-share-mismatch',
+        'Earn router share token does not match the Earn vault.',
+        options.discovery.shareToken.address,
+        bindings.earnShare,
+      )
+      if (!bindings.deposit || !bindings.redeem)
+        issues.push({
+          actual: `deposit=${bindings.deposit},redeem=${bindings.redeem}`,
+          code: 'zone-flow-unsupported',
+          expected: 'deposit=true,redeem=true',
+          message: 'Earn router must support private deposits and redemptions.',
+        })
+      if (issues.length > 0) throw mismatch({ discovery: options.discovery, issues })
+
+      return {
+        ...route,
+        inputTokens: [bindings.privateAsset],
+        name: zone.name,
+        outputTokens: [bindings.privateAsset],
+      }
+    }),
+  )
+}
+
+export declare namespace resolveZoneRoutes {
+  /** Inputs for resolving and verifying curated Zone routes. */
+  type Options = {
+    /** Live state of the Earn vault bound by every router. */
+    discovery: Discovery
+    /** Resolves the parent-chain client used to read each router. */
+    getClient: Viem.GetClient
+    /** Curated Zone routes to verify. */
+    routes: unknown
+    /** Private Zones configured by the API. */
+    zones: readonly Chain[]
+  }
+}
+
 /** Infers the supported engine type from its capability fingerprint. */
 export function classifyEngineType(
   options: classifyEngineType.Options,
@@ -729,6 +931,60 @@ declare namespace readEngineBindings {
   }
 }
 
+async function readZoneRouteBindings(
+  client: Client,
+  options: readZoneRouteBindings.Options,
+): Promise<ZoneRouteBindings> {
+  const [allowedZoneId, earnShare, earnVault, privateAsset, vaultAsset, deposit, redeem] =
+    await Promise.all([
+      client.readContract({
+        abi: Abis.earnRouter,
+        address: options.earnRouter,
+        functionName: 'allowedZoneId',
+      }),
+      client.readContract({
+        abi: Abis.earnRouter,
+        address: options.earnRouter,
+        functionName: 'earnShare',
+      }),
+      client.readContract({
+        abi: Abis.earnRouter,
+        address: options.earnRouter,
+        functionName: 'earnVault',
+      }),
+      client.readContract({
+        abi: Abis.earnRouter,
+        address: options.earnRouter,
+        functionName: 'privateAsset',
+      }),
+      client.readContract({
+        abi: Abis.earnRouter,
+        address: options.earnRouter,
+        functionName: 'vaultAsset',
+      }),
+      client.readContract({
+        abi: Abis.earnRouter,
+        address: options.earnRouter,
+        args: [0],
+        functionName: 'supportsFlow',
+      }),
+      client.readContract({
+        abi: Abis.earnRouter,
+        address: options.earnRouter,
+        args: [1],
+        functionName: 'supportsFlow',
+      }),
+    ])
+  return { allowedZoneId, deposit, earnShare, earnVault, privateAsset, redeem, vaultAsset }
+}
+
+declare namespace readZoneRouteBindings {
+  type Options = {
+    /** Parent-chain Earn router to inspect. */
+    earnRouter: Address
+  }
+}
+
 async function readRouterCapabilities(
   client: Client,
   options: readRouterCapabilities.Options,
@@ -840,6 +1096,27 @@ function compareAddress(
   if (!isAddressEqual(actual, expected)) issues.push({ actual, code, expected, message })
 }
 
+function mismatch(options: mismatch.Options): VerificationError {
+  return new VerificationError({
+    issues: options.issues,
+    snapshot: {
+      assetToken: options.discovery.assetToken,
+      isSynced: options.discovery.state.isAccountingAligned,
+      shareToken: options.discovery.shareToken,
+    },
+    status: 'mismatch',
+  })
+}
+
+declare namespace mismatch {
+  type Options = {
+    /** Live vault state captured with the mismatch. */
+    discovery: Discovery
+    /** Verification issues that rejected the deployment. */
+    issues: readonly VerificationIssue[]
+  }
+}
+
 function unavailable(): VerificationUnavailable {
   return {
     issues: [

package/src/internal/OpenApi.ts

@@ -1,6 +1,13 @@
 import type { Context, Env, MiddlewareHandler, ValidationTargets } from 'hono'
 import type { HasRequiredKeys } from 'hono/utils/types'
-import { resolver, type ResponsesWithResolver, validator } from 'hono-openapi'
+import {
+  describeRoute as core_describeRoute,
+  type DescribeRouteOptions,
+  resolver,
+  type ResponsesWithResolver,
+  uniqueSymbol,
+  validator,
+} from 'hono-openapi'
 import * as z from 'zod/mini'
 import * as Response from './Response.js'
 import * as Schema from './Schema.js'
@@ -41,7 +48,6 @@ const schemaOptions = { options: { override: recoverExamples, unrepresentable: '
 // re-exports because `uniqueSymbol` is a `unique symbol` whose identity is
 // lost when copied through a `const` declaration.
 export {
-  describeRoute,
   type HandlerUniqueProperty,
   resolver,
   type ResponsesWithResolver,
@@ -49,12 +55,53 @@ export {
   validator,
 } from 'hono-openapi'
 
+function cloneResponseContainers(spec: DescribeRouteOptions): DescribeRouteOptions {
+  if (!spec.responses) return spec
+  return {
+    ...spec,
+    responses: Object.fromEntries(
+      Object.entries(spec.responses).map(([status, response]) => [
+        status,
+        !response || !('content' in response)
+          ? response
+          : {
+              ...response,
+              content: Object.fromEntries(
+                Object.entries(response.content ?? {}).map(([mediaType, media]) => [
+                  mediaType,
+                  { ...media },
+                ]),
+              ),
+            },
+      ]),
+    ),
+  }
+}
+
+/** Describes a route without allowing spec generation to mutate reusable response definitions. */
+export function describeRoute(spec: DescribeRouteOptions): MiddlewareHandler {
+  const handler = core_describeRoute(spec)
+  Object.defineProperty(handler, uniqueSymbol, {
+    get: () => ({ spec: cloneResponseContainers(spec) }),
+  })
+  return handler
+}
+
+/** Emits a named OpenAPI component and uses its `$ref` wherever the schema appears. */
+export function component<const schema extends z.ZodMiniType>(
+  schema: schema,
+  name: string,
+): schema {
+  const cloned = schema.clone()
+  z.globalRegistry.add(cloned, { ...z.globalRegistry.get(schema), ref: name })
+  return cloned as schema
+}
+
 /**
  * Standard machine-readable `error.code` values per status, shared API-wide.
  * The reference enumerates `error.code` to these so generated clients narrow it
- * to a literal union instead of an open `string`. 400 and 404 vary per
- * operation; the values here are the API-wide supersets, narrowable per route
- * via the `codes` override in {@link responses.Options}.
+ * to a literal union instead of an open `string`. The values here are shared
+ * defaults; operation-specific codes are supplied through {@link responses.Options}.
  */
 export const errorCodes = {
   400: [
@@ -80,7 +127,7 @@ export const errorCodes = {
     'api_key_malformed',
   ],
   401: ['api_key_missing', 'api_key_invalid', 'unauthorized'],
-  403: ['api_key_forbidden', 'api_key_ip_forbidden', 'limit_exceeded'],
+  403: ['api_key_forbidden', 'api_key_ip_forbidden', 'forbidden'],
   404: [
     'not_found',
     'token_not_found',
@@ -164,11 +211,78 @@ export const rateLimitHeaders = {
 /** Representative `requestId` used in error-body examples. */
 const exampleRequestId = '0a1b2c3d-4e5f-6071-8293-a4b5c6d7e8f9'
 
-/** Builds the `application/json` content for a standard error response: the enumerated-code envelope plus an example body. */
-function errorContent(codes: readonly [string, ...string[]] | undefined, message: string) {
+const standardErrorNames = {
+  400: 'InvalidRequestError',
+  401: 'AuthenticationError',
+  403: 'ForbiddenError',
+  404: 'ResourceNotFoundError',
+  429: 'RateLimitError',
+  500: 'InternalError',
+  501: 'NotImplementedError',
+  502: 'UpstreamError',
+} as const satisfies Record<keyof typeof errorCodes, string>
+
+const reservedErrorNames = new Set<string>(Object.values(standardErrorNames))
+const errorSchemas = new Map<string, z.ZodMiniType>()
+
+function errorName(status: number, codes: readonly string[]) {
+  const standard = errorCodes[status as keyof typeof errorCodes]
+  if (
+    standard &&
+    standard.length === codes.length &&
+    [...standard].sort().every((code, index) => code === codes[index])
+  )
+    return standardErrorNames[status as keyof typeof standardErrorNames]
+  const name = `${codes
+    .map((code) =>
+      code
+        .split('_')
+        .map((part) => `${part[0]?.toUpperCase()}${part.slice(1)}`)
+        .join(''),
+    )
+    .join('Or')}Error`
+  if (reservedErrorNames.has(name)) return `${name.slice(0, -'Error'.length)}${status}Error`
+  return name
+}
+
+function errorSchema(status: number, codes: readonly [string, ...string[]] | undefined) {
+  const defaults = errorCodes[status as keyof typeof errorCodes]
+  if (!codes && !defaults) {
+    const cached = errorSchemas.get('*')
+    if (cached) return cached
+    const schema = component(Schema.errorResponse(), 'ErrorResponse')
+    errorSchemas.set('*', schema)
+    return schema
+  }
+  const normalized = [...(codes ?? defaults ?? [])].sort() as [string, ...string[]]
+  const key = normalized.join('\0')
+  const cached = errorSchemas.get(key)
+  if (cached) return cached
+  const schema = component(Schema.errorResponse(normalized), errorName(status, normalized))
+  errorSchemas.set(key, schema)
+  return schema
+}
+
+function mergeErrorCodes(
+  status: number,
+  codes: readonly string[] | undefined,
+): readonly [string, ...string[]] | undefined {
+  if (!codes) return errorCodes[status as keyof typeof errorCodes]
+  if (status !== 400 && status !== 403)
+    return codes.length ? (codes as [string, ...string[]]) : undefined
+  const baseline = status === 400 ? (['api_key_malformed'] as const) : errorCodes[403]
+  return [...new Set([...baseline, ...codes])] as [string, ...string[]]
+}
+
+/** Builds the `application/json` content for a standard error response: the named enumerated-code envelope plus an example body. */
+function errorContent(
+  status: number,
+  codes: readonly [string, ...string[]] | undefined,
+  message: string,
+) {
   return {
     'application/json': {
-      schema: resolver(Schema.errorResponse(codes), schemaOptions),
+      schema: resolver(errorSchema(status, codes), schemaOptions),
       example: { error: { code: codes?.[0] ?? 'error', message }, requestId: exampleRequestId },
     },
   }
@@ -186,32 +300,30 @@ export const paymentChallenge = {
   headers: { 'WWW-Authenticate': headerRef('WwwAuthenticate') },
 } as const
 
-/** Shared `429` rate-limit response, registered as `components.responses.RateLimited`. */
-const rateLimitedResponse = {
-  content: errorContent(errorCodes[429], 'Rate limit exceeded.'),
-  description:
-    'Rate limit exceeded. On endpoints that accept MPP, over-quota unpaid requests return `402 Payment Required` instead.',
-  headers: { ...rateLimitHeaders },
-}
-
-/** Shared `500` internal-error response, registered as `components.responses.InternalError`. */
-const serverErrorResponse = {
-  content: errorContent(errorCodes[500], 'Internal server error.'),
-  description: 'Internal server error.',
-}
+type ResponseComponentName = 'InternalError' | 'PaymentRequired' | 'RateLimited'
 
 /**
  * Reusable responses registered under `components.responses` (see `App.create`)
  * and `$ref`-erenced from operations, so the uniform `402`/`429`/`500` responses
  * are defined once instead of inlined on every operation.
  */
-export const responseComponents: ResponsesWithResolver = {
-  InternalError: serverErrorResponse,
-  PaymentRequired: paymentChallenge,
-  RateLimited: rateLimitedResponse,
+export function responseComponents(): ResponsesWithResolver {
+  return {
+    InternalError: {
+      content: errorContent(500, errorCodes[500], 'Internal server error.'),
+      description: 'Internal server error.',
+    },
+    PaymentRequired: paymentChallenge,
+    RateLimited: {
+      content: errorContent(429, errorCodes[429], 'Rate limit exceeded.'),
+      description:
+        'Rate limit exceeded. On endpoints that accept MPP, over-quota unpaid requests return `402 Payment Required` instead.',
+      headers: { ...rateLimitHeaders },
+    },
+  }
 }
 
-const responseRef = (name: keyof typeof responseComponents) => ({
+const responseRef = (name: ResponseComponentName) => ({
   $ref: `#/components/responses/${name}`,
 })
 
@@ -232,22 +344,22 @@ export function standardError(
 ): ResponsesWithResolver[string] {
   if (status === 429) return responseRef('RateLimited')
   if (status === 500) return responseRef('InternalError')
-  return { content: errorContent(codes ?? errorCodes[status], description), description }
+  return { content: errorContent(status, mergeErrorCodes(status, codes), description), description }
 }
 
 /**
  * Builds an OpenAPI `responses` map with the API's standard error responses
  * pre-filled, plus the success response (with rate-limit headers):
  *
- * - `400` invalid request, `401` missing/invalid key, `429` rate limited,
- *   `500` internal error, and `502` upstream failure on every operation;
- * - `403`/`404`/`409`/`412`/`413`/`415` only when an `errors` entry is set.
+ * - `400` invalid request, `401` missing/invalid key, `403` forbidden, `429`
+ *   rate limited, `500` internal error, and `502` upstream failure on every operation;
+ * - `404`/`409`/`412`/`413`/`415` only when an `errors` entry is set.
  *
- * `error.code` is enumerated per status from {@link errorCodes}; narrow 400/404
- * to a route's exact codes by passing `{ description, codes }` for that status.
- * `429`/`500` `$ref` the shared {@link responseComponents}. `402` is not emitted
- * here — it is injected per operation from the route's MPP policy during spec
- * generation (see `App.ts`).
+ * `error.code` is enumerated per status from {@link errorCodes}. Operation-level
+ * 400/403 codes merge with shared auth codes; other overrides replace defaults.
+ * The default `429` and `500` `$ref` shared {@link responseComponents}; an exact
+ * operation-level `429` override is emitted inline with the standard headers.
+ * `402` is injected per operation from the route's MPP policy in `App.ts`.
  */
 export function responses<schema extends z.ZodMiniType>(
   options: responses.Options<schema>,
@@ -257,10 +369,11 @@ export function responses<schema extends z.ZodMiniType>(
     const override = errors?.[status as 400]
     const description =
       typeof override === 'string' ? override : (override?.description ?? fallback)
-    const codes =
-      (typeof override === 'object' ? override.codes : undefined) ??
-      errorCodes[status as keyof typeof errorCodes]
-    return { content: errorContent(codes, description), description }
+    const codes = mergeErrorCodes(status, typeof override === 'object' ? override.codes : undefined)
+    return {
+      content: errorContent(status, codes, description),
+      description,
+    }
   }
   return {
     200: {
@@ -279,13 +392,15 @@ export function responses<schema extends z.ZodMiniType>(
     },
     400: error(400, 'Invalid request.'),
     401: error(401, 'Missing or invalid API key.'),
-    ...(errors?.[403] && { 403: error(403, 'Forbidden.') }),
+    403: error(403, 'Forbidden.'),
     ...(errors?.[404] && { 404: error(404, 'Not found.') }),
     ...(errors?.[409] && { 409: error(409, 'Conflict.') }),
     ...(errors?.[412] && { 412: error(412, 'Precondition failed.') }),
     ...(errors?.[413] && { 413: error(413, 'Payload too large.') }),
     ...(errors?.[415] && { 415: error(415, 'Unsupported media type.') }),
-    429: responseRef('RateLimited'),
+    429: errors?.[429]
+      ? { ...error(429, 'Rate limit exceeded.'), headers: { ...rateLimitHeaders } }
+      : responseRef('RateLimited'),
     500: responseRef('InternalError'),
     ...(errors?.[501] && { 501: error(501, 'Not implemented.') }),
     502: error(502, 'Upstream data failure.'),
@@ -295,23 +410,22 @@ export function responses<schema extends z.ZodMiniType>(
 export declare namespace responses {
   /**
    * Override for a standard error response: a description string, or an object
-   * adding the exact `codes` that status can return (narrowing the enum).
+   * adding operation codes. Codes replace defaults except shared 400/403 auth codes.
    */
   type ErrorOverride =
     | string
     | {
         /** Human-readable description of the error response. */
         description?: string | undefined
-        /** Exact `error.code` values this status returns for the operation. */
-        codes?: readonly [string, ...string[]] | undefined
+        /** Operation-specific `error.code` values for this status. */
+        codes?: readonly string[] | undefined
       }
 
   /** Options for building a standard OpenAPI responses map. */
   type Options<schema> = {
     /**
-     * Optional overrides for standard error responses (description and/or exact
-     * `error.code` enum). Setting `403`/`404`/`409`/`412`/`413`/`415` also
-     * includes that status in the map.
+     * Optional overrides for standard error responses. Setting
+     * `404`/`409`/`412`/`413`/`415` includes that status in the map.
      */
     errors?:
       | {
@@ -319,7 +433,7 @@ export declare namespace responses {
           400?: ErrorOverride | undefined
           /** Override for the 401 response. */
           401?: ErrorOverride | undefined
-          /** Override for the 403 response. Setting this includes 403 in the map. */
+          /** Add operation-specific 403 codes or override its description. */
           403?: ErrorOverride | undefined
           /** Override for the 404 response. Setting this includes 404 in the map. */
           404?: ErrorOverride | undefined
@@ -331,6 +445,8 @@ export declare namespace responses {
           413?: ErrorOverride | undefined
           /** Override for the 415 response. Setting this includes 415 in the map. */
           415?: ErrorOverride | undefined
+          /** Override the shared 429 response with operation-specific rate-limit codes. */
+          429?: ErrorOverride | undefined
           /** Override for the 501 response. Setting this includes 501 in the map. */
           501?: ErrorOverride | undefined
           /** Override for the 502 response. */