import { Client } from 'tapimo'
import { Mpp as PublicMpp } from 'tapimo/mpp'
import type * as z from 'zod/mini'

import * as Activities from './apps/data/routes/activities.js'
import * as ApiKeys from './apps/management/routes/api-keys.js'
import * as Balances from './apps/data/routes/balances.js'
import * as Billing from './apps/management/routes/billing.js'
import * as Blocks from './apps/data/routes/blocks.js'
import * as Earn from './apps/data/routes/earn.js'
import type * as EarnRates from './internal/EarnRates.js'
import * as Exchanges from './apps/data/routes/exchanges.js'
import * as Faucet from './apps/management/routes/faucet.js'
import * as FeeAmm from './apps/data/routes/fee-amm.js'
import * as FundingChains from './apps/funding/routes/chains.js'
import * as FundingDepositAddresses from './apps/funding/routes/deposit-addresses.js'
import * as FundingQuotes from './apps/funding/routes/quotes.js'
import * as FundingTransfers from './apps/funding/routes/transfers.js'
import type * as FundingDepositAddress from './internal/funding/DepositAddress.js'
import * as Indexer from './apps/data/routes/indexer.js'
import * as InviteLinks from './apps/management/routes/invite-links.js'
import * as Me from './apps/management/routes/me.js'
import * as Mpp from './apps/mpp/Mpp.js'
import * as Orgs from './apps/management/routes/orgs.js'
import * as OrgWebhooks from './apps/management/routes/webhooks.js'
import * as Receipts from './apps/data/routes/receipts.js'
import * as Rpc from './apps/data/routes/rpc.js'
import * as Scopes from './apps/management/routes/scopes.js'
import * as Tokens from './apps/data/routes/tokens.js'
import * as Transactions from './apps/data/routes/transactions.js'
import * as Transfers from './apps/data/routes/transfers.js'
import * as Valuation from './apps/data/routes/valuation.js'
import * as VerifiedTokenRequests from './apps/management/routes/verified-token-requests.js'
import * as VerifiedTokens from './apps/data/routes/verified-tokens.js'
import * as Webhooks from './apps/data/routes/webhooks.js'
import * as Zones from './apps/data/routes/zones.js'

type Access400<code extends string> = code | 'api_key_malformed'
type PaidAccessStatus = PublicAccessStatus | 402
type PublicAccessStatus = 400 | 401 | 403 | 429
/** Wire shape of a valued Earn vault field. */
type VaultValue = { amount: string; currency: string; decimals: number; formatted: string }
const mppInput = {
  challenge: {
    description: 'Tempo API payment',
    id: 'ch_01j3j1k2l3m4n5p6q7r8s9t0u',
    intent: 'charge',
    method: 'tempo',
    opaque: 'eyJhbGciOiJIUzI1NiJ9',
    realm: 'merchant.example',
    request: { amount: '1', currency: 'USD' },
  },
  payload: { signature: `0x${'aa'.repeat(65)}`, type: 'transaction' },
} satisfies Mpp.RelayInput
/** A `Schema.TokenAmount` carrying its optional nested valuation. */
type ValuedTokenAmount = {
  baseUnits: string
  currency: string
  decimals: number
  formatted: string
  valuation?: { amount: string; currency: string } | null | undefined
}

test('returns typed client', async () => {
  const client = Client.create()
  expectTypeOf(client).toEqualTypeOf<Client.Client>()
  expectTypeOf(Client.defaultUrl).toEqualTypeOf<string>()

  await client.v1.blocks[':block'].$get({ param: { block: 'latest' } })
  // @ts-expect-error unknown routes are not part of the typed API surface
  void client.v1.bogus

  Client.create({
    apiKey: 'foo-bar-baz',
    headers: async () => ({ 'tempo-api-key': 'key_test' }),
    url: Client.defaultUrl,
  })

  const typed: Client.Client = client
  void typed

  expectTypeOf<PublicMpp.RelayInput>().toEqualTypeOf<Mpp.RelayInput>()
})

describe('narrows responses by status', () => {
  test('POST /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId/rotate', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
      ':projectId{prj_[A-Za-z0-9_-]+}'
    ]['api-keys'][':keyId{key_[A-Za-z0-9_-]+}'].rotate.$post({
      param: { keyId: 'key_test', orgId: 'org_test', projectId: 'prj_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof ApiKeys.schema.rotateApiKey.Response>>()
    }
  })

  test('POST /v1/orgs/:orgId/api-keys/:keyId/rotate', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['api-keys'][
      ':keyId{key_[A-Za-z0-9_-]+}'
    ].rotate.$post({ param: { keyId: 'key_test', orgId: 'org_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof ApiKeys.schema.rotateApiKey.Response>>()
    }
  })

  test('DELETE /v1/orgs/:orgId/api-keys/:keyId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['api-keys'][
      ':keyId{key_[A-Za-z0-9_-]+}'
    ].$delete({ param: { keyId: 'key_test', orgId: 'org_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 429 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof ApiKeys.schema.revokeApiKey.Response>>()
    }
  })

  test('POST /v1/mpp/validate', async () => {
    const client = Client.create()
    const res = await client.v1.mpp.validate.$post({ json: mppInput })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<Mpp.VerifyResponse>()
      return
    }
  })

  test('POST /v1/mpp/broadcast', async () => {
    const client = Client.create()
    const res = await client.v1.mpp.broadcast.$post({ json: mppInput })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<Mpp.BroadcastResponse>()
      return
    }
  })

  test('GET /v1/blocks', async () => {
    const client = Client.create()
    const res = await client.v1.blocks.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.number).toEqualTypeOf<
          z.output<typeof Blocks.schema.getBlocks.Response>['data'][number]['number']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 401: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_invalid' | 'api_key_missing'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 402: {
        const text = await res.text()
        expectTypeOf(text).toEqualTypeOf<string>()
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'api_key_ip_forbidden'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 429: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'payment_required' | 'rate_limit_exceeded'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/earn/vaults', async () => {
    const client = Client.create()
    const res = await client.v1.earn.vaults.$get({
      query: {
        'apy.window': '24h',
        capability: 'deposit',
        'engine.type': 'erc4626',
        include: 'access,apy,capabilities,token.logoUri,tvl,zone,zones',
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVaults.Response>>()
      expectTypeOf(json.data[0]!.access?.status).toEqualTypeOf<'allowlisted' | 'open' | undefined>()
      // `apy` and `tvl` are include-gated, so both are absent unless requested.
      expectTypeOf(json.data[0]!.apy).toEqualTypeOf<EarnRates.Apy | null | undefined>()
      expectTypeOf(json.data[0]!.apy?.methodology).toEqualTypeOf<
        'share-price-growth-annualized:v1' | undefined
      >()
      expectTypeOf(json.data[0]!.apy?.net).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.data[0]!.apy?.window).toEqualTypeOf<
        '1h' | '1d' | '7d' | '30d' | undefined
      >()
      expectTypeOf(json.data[0]!.assetToken.address).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.data[0]!.capabilities?.deposit).toEqualTypeOf<boolean | undefined>()
      expectTypeOf(json.data[0]!.engine.type).toEqualTypeOf<'erc4626' | 'veda' | null>()
      expectTypeOf(json.data[0]!.instantLiquidity).toEqualTypeOf<string | null>()
      expectTypeOf(json.data[0]!.instantLiquidityValue).toEqualTypeOf<
        VaultValue | null | undefined
      >()
      expectTypeOf(json.data[0]!.sharePrice?.amount).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.data[0]!.slug).toEqualTypeOf<string | null>()
      expectTypeOf(json.data[0]!.state.openRedeemRequestCount).toEqualTypeOf<number>()
      expectTypeOf(json.data[0]!.state.totalAssets).toEqualTypeOf<string>()
      expectTypeOf(json.data[0]!.tvl).toEqualTypeOf<VaultValue | null | undefined>()
      expectTypeOf(json.data[0]!.tvl?.currency).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.data[0]!.vaultAddress).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.data[0]!.verified).toEqualTypeOf<boolean>()
      expectTypeOf(json.data[0]!.zone?.chainId).toEqualTypeOf<number | undefined>()
      expectTypeOf(json.data[0]!.zones?.[0]?.deploymentBlock).toEqualTypeOf<number | undefined>()
      expectTypeOf(json.data[0]!.zones?.[0]?.earnRouter).toEqualTypeOf<`0x${string}` | undefined>()
      expectTypeOf(json.meta?.valuation?.basis).toEqualTypeOf<'nominal' | undefined>()
      void json
      return
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
      void json
      return
    }
    if (res.status === 502) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
      void json
      return
    }
  })

  test('GET /v1/earn/vaults/verified', async () => {
    const client = Client.create()
    const res = await client.v1.earn.vaults.verified.$get({
      query: {
        'apy.window': '7d',
        include: 'access,apy,capabilities,token.logoUri,tvl,zone,zones',
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<
        z.output<typeof Earn.schema.getVerifiedEarnVaults.Response>
      >()
      expectTypeOf(json.data[0]!.engine.type).toEqualTypeOf<'erc4626' | 'veda'>()
      expectTypeOf(json.data[0]!.instantLiquidity).toEqualTypeOf<string | null>()
      expectTypeOf(json.data[0]!.slug).toEqualTypeOf<string>()
      expectTypeOf(json.data[0]!.state.feesActive).toEqualTypeOf<boolean>()
      expectTypeOf(json.data[0]!.tvl).toEqualTypeOf<VaultValue | null | undefined>()
      expectTypeOf(json.data[0]!.tvl?.formatted).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.data[0]!.verified).toEqualTypeOf<true>()
      expectTypeOf(json.data[0]!.zones?.[0]?.chainId).toEqualTypeOf<number | undefined>()
      expectTypeOf(json.meta?.valuation?.source).toEqualTypeOf<string | undefined>()
      void json
      return
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
      void json
      return
    }
    if (res.status === 502) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
      void json
      return
    }
  })

  test('GET /v1/earn/addresses/:address/positions', async () => {
    const client = Client.create()
    const res = await client.v1.earn.addresses[':address'].positions.$get({
      param: { address: `0x${'bb'.repeat(20)}` },
      query: { include: 'earnings', 'valuation.currency': 'USD', verified: 'true' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<
        z.output<typeof Earn.schema.getEarnAddressPositions.Response>
      >()
      expectTypeOf(json.data[0]!.assetAmount.amount).toEqualTypeOf<string>()
      expectTypeOf(json.data[0]!.assetAmount.currency).toEqualTypeOf<string>()
      expectTypeOf(json.data[0]!.assetToken.address).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.data[0]!.assetToken.decimals).toEqualTypeOf<number>()
      expectTypeOf(json.data[0]!.id).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.data[0]!.lifetimeCashFlows?.status).toEqualTypeOf<
        'complete' | 'incomplete_history' | undefined
      >()
      if (json.data[0]!.lifetimeCashFlows?.status === 'complete') {
        expectTypeOf(json.data[0]!.lifetimeCashFlows.totalDeposited).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.lifetimeCashFlows.totalWithdrawn).toEqualTypeOf<string>()
      }
      expectTypeOf(json.data[0]!.shareAmount.amount).toEqualTypeOf<string>()
      expectTypeOf(json.data[0]!.shareAmount.decimals).toEqualTypeOf<number>()
      expectTypeOf(json.data[0]!.shareAmount.formatted).toEqualTypeOf<string>()
      expectTypeOf(json.data[0]!.shareToken.symbol).toEqualTypeOf<string>()
      expectTypeOf(json.data[0]!.valuation).toEqualTypeOf<
        { amount: string; currency: string } | null | undefined
      >()
      expectTypeOf(json.data[0]!.vaultAddress).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.data[0]!.verified).toEqualTypeOf<boolean>()
      expectTypeOf(json.meta?.valuation?.basis).toEqualTypeOf<'nominal' | undefined>()
      expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
      void json
      return
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        Access400<
          'chain_id_invalid' | 'chain_id_unsupported' | 'positions_invalid' | 'query_invalid'
        >
      >()
      void json
      return
    }
    if (res.status === 502) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
      void json
      return
    }
  })

  test('GET /v1/earn/vaults/:vaultId', async () => {
    const client = Client.create()
    const res = await client.v1.earn.vaults[':vaultId'].$get({
      param: { vaultId: `0x${'aa'.repeat(20)}` },
      query: { 'apy.window': '1h', include: 'token.logoUri,tvl' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVault.Response>>()
      // `apy` and `tvl` are include-gated, so both are absent unless requested.
      expectTypeOf(json.apy).toEqualTypeOf<EarnRates.Apy | null | undefined>()
      expectTypeOf(json.apy?.asOf).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.assetToken.address).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.engine.type).toEqualTypeOf<'erc4626' | 'veda' | null>()
      expectTypeOf(json.instantLiquidity).toEqualTypeOf<string | null>()
      expectTypeOf(json.instantLiquidityValue).toEqualTypeOf<VaultValue | null | undefined>()
      expectTypeOf(json.label).toEqualTypeOf<string>()
      expectTypeOf(json.meta?.valuation?.asOf).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.sharePrice?.decimals).toEqualTypeOf<number | undefined>()
      expectTypeOf(json.slug).toEqualTypeOf<string | null>()
      expectTypeOf(json.state.depositsPaused).toEqualTypeOf<boolean>()
      expectTypeOf(json.tvl).toEqualTypeOf<VaultValue | null | undefined>()
      expectTypeOf(json.tvl?.amount).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.vaultAddress).toEqualTypeOf<`0x${string}`>()
      void json
      return
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid' | 'vault_id_invalid'>>()
      void json
      return
    }
    if (res.status === 404) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'earn_vault_not_found'>()
      void json
      return
    }
    if (res.status === 502) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
      void json
      return
    }
  })

  test('GET /v1/earn/vaults/:vaultId/positions/:address', async () => {
    const client = Client.create()
    const res = await client.v1.earn.vaults[':vaultId'].positions[':address'].$get({
      param: {
        address: `0x${'bb'.repeat(20)}`,
        vaultId: `0x${'aa'.repeat(20)}`,
      },
      query: { asOf: '2026-07-21T09:00:00.000Z' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVaultPosition.Response>>()
      expectTypeOf(json.account).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.assetAllowance).toEqualTypeOf<string>()
      expectTypeOf(json.assetBalance).toEqualTypeOf<string>()
      expectTypeOf(json.assetToken).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.asOf).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.block?.number).toEqualTypeOf<number | undefined>()
      expectTypeOf(json.block?.timestamp).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.id).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.shareAllowance).toEqualTypeOf<string>()
      expectTypeOf(json.shareBalance).toEqualTypeOf<string>()
      expectTypeOf(json.shareToken).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.value).toEqualTypeOf<string>()
      void json
      return
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        Access400<
          'chain_id_invalid' | 'chain_id_unsupported' | 'position_invalid' | 'query_invalid'
        >
      >()
      void json
      return
    }
    if (res.status === 404) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'earn_vault_not_found'>()
      void json
      return
    }
    if (res.status === 502) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
      void json
      return
    }
  })

  test('GET /v1/earn/vaults/:vaultId/earnings/:address', async () => {
    const client = Client.create()
    const res = await client.v1.earn.vaults[':vaultId'].earnings[':address'].$get({
      param: {
        address: `0x${'bb'.repeat(20)}`,
        vaultId: `0x${'aa'.repeat(20)}`,
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof Earn.schema.getEarnVaultEarnings.Response>>()
      expectTypeOf(json.account).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.assetToken).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.currentValue).toEqualTypeOf<string>()
      expectTypeOf(json.id).toEqualTypeOf<`0x${string}`>()
      expectTypeOf(json.period).toEqualTypeOf<'30d' | 'active' | 'lifetime'>()
      expectTypeOf(json.status).toEqualTypeOf<
        'complete' | 'incomplete_cost_basis' | 'pending_redemption'
      >()
      if (json.status === 'complete' && json.period === 'active')
        expectTypeOf(json.activeEarnings).toEqualTypeOf<string>()
      if (json.status === 'complete' && json.period === 'lifetime')
        expectTypeOf({
          lifetimeEarnings: json.lifetimeEarnings,
          totalDeposited: json.totalDeposited,
          totalWithdrawn: json.totalWithdrawn,
        }).toEqualTypeOf<{
          lifetimeEarnings: string
          totalDeposited: string
          totalWithdrawn: string
        }>()
      if (json.status === 'pending_redemption' && json.period === 'lifetime')
        expectTypeOf({
          totalDeposited: json.totalDeposited,
          totalWithdrawn: json.totalWithdrawn,
        }).toEqualTypeOf<{
          totalDeposited: string
          totalWithdrawn: string
        }>()
      if (json.status === 'complete' && json.period === '30d')
        expectTypeOf(json.windowEarnings).toEqualTypeOf<string>()
      void json
      return
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        Access400<
          'chain_id_invalid' | 'chain_id_unsupported' | 'earnings_invalid' | 'query_invalid'
        >
      >()
      void json
      return
    }
    if (res.status === 404) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'earn_vault_not_found'>()
      void json
      return
    }
    if (res.status === 502) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
      void json
      return
    }
  })

  test('GET /v1/me', async () => {
    const client = Client.create()
    const res = await client.v1.me.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<z.output<typeof Me.schema.User>['id']>()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'user_not_found'>()
        void json
        return
      }
    }
  })

  test('GET /v1/scopes', async () => {
    const client = Client.create()
    const res = await client.v1.scopes.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.scope).toEqualTypeOf<
          z.output<typeof Scopes.schema.getScopes.Response>['data'][number]['scope']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
        void json
        return
      }
    }
  })

  test('POST /v1/orgs', async () => {
    const client = Client.create()
    const res = await client.v1.orgs.$post({ json: { name: 'Acme' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<z.output<typeof Orgs.schema.Organization>['id']>()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$get({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.name).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
    }
  })

  test('POST /v1/orgs/:orgId/faucet', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].faucet.$post({
      json: { address: '0xbe058e1c4df8a4366a387bf595b284246a93039e' },
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 429 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.tokens).toEqualTypeOf<
          z.output<typeof Faucet.schema.FundResponse>['tokens']
        >()
        expectTypeOf(json.tokens[0]!.amount).toEqualTypeOf<
          z.output<typeof Faucet.schema.FundResponse>['tokens'][number]['amount']
        >()
        expectTypeOf(json.tokens[0]!.token.symbol).toEqualTypeOf<string>()
        // @ts-expect-error token metadata is nested under `token`
        void json.tokens[0]!.symbol
        // @ts-expect-error quantities are nested under `amount`
        void json.tokens[0]!.token.amount
        expectTypeOf(json.transactionHashes).toEqualTypeOf<
          z.output<typeof Faucet.schema.FundResponse>['transactionHashes']
        >()
        void json
        return
      }
      case 429: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'rate_limit_exceeded'>()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/billing', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing.$get({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.enabledSources).toEqualTypeOf<('stripe' | 'tempo')[]>()
        expectTypeOf(json.status).toEqualTypeOf<z.output<typeof Billing.schema.Billing>['status']>()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/usage/sponsorships', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].usage.sponsorships.$get({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.count).toEqualTypeOf<number>()
        expectTypeOf(json.data[0]!.failed).toEqualTypeOf<number>()
        expectTypeOf(json.data[0]!.feeTotal).toEqualTypeOf<{ amount: string; currency: 'usd' }>()
        expectTypeOf(json.data[0]!.timestamp).toEqualTypeOf<string>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'param_invalid' | 'query_invalid'>>()
        void json
        return
      }
    }
  })

  test('PATCH /v1/orgs/:orgId/billing', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing.$patch({
      json: { spendLimit: { amount: '250' }, txFeeLimit: null },
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.enabledSources).toEqualTypeOf<('stripe' | 'tempo')[]>()
        expectTypeOf(json.spendLimit).toEqualTypeOf<
          z.output<typeof Billing.schema.SpendLimit> | undefined
        >()
        expectTypeOf(json.spend).toEqualTypeOf<z.output<typeof Billing.schema.Billing>['spend']>()
        void json
        return
      }
    }
  })

  test('POST /v1/orgs/:orgId/billing/stripe/checkout', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing.stripe.checkout.$post({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 501 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.url).toEqualTypeOf<string>()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'api_key_forbidden' | 'api_key_ip_forbidden' | 'billing_source_disabled' | 'forbidden'
        >()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
    }
  })

  test('POST /v1/orgs/:orgId/billing/stripe/manage', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing.stripe.manage.$post({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 501 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.url).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'billing_not_found' | 'organization_not_found'
        >()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/billing/payment-methods', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing['payment-methods'].$get({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 501 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.provider).toEqualTypeOf<'stripe'>()
        expectTypeOf(json.data[0]!.default).toEqualTypeOf<boolean>()
        expectTypeOf(json.data[0]!.card).toEqualTypeOf<
          { brand: string; expMonth: number; expYear: number; last4: string } | undefined
        >()
        void json
        return
      }
      case 501: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'billing_unconfigured'>()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId/billing/payment-methods/:methodId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing['payment-methods'][
      ':methodId{pm_[A-Za-z0-9_-]+}'
    ].$delete({ param: { methodId: 'pm_test', orgId: 'org_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 501 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.status).toEqualTypeOf<'active' | 'canceled' | 'none' | 'past_due'>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'billing_not_found' | 'organization_not_found' | 'payment_method_not_found'
        >()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$delete({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'sponsorships_unreported'>()
        void json
        return
      }
    }
  })

  test('POST /v1/orgs/:orgId/verified-token-requests', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['verified-token-requests'].$post(
      {
        json: {
          address: '0x20c00000000000000000000000000000000000aa',
          chainId: 4217,
          currency: 'USD',
          decimals: 6,
          name: 'Test USD',
          symbol: 'tUSD',
        },
        param: { orgId: 'org_test' },
      },
    )

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 409 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.status).toEqualTypeOf<
          z.output<typeof VerifiedTokenRequests.schema.VerifiedTokenRequest>['status']
        >()
        expectTypeOf(json.reviewNote).toEqualTypeOf<string | null>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          | 'request_limit_reached'
          | 'request_pending_exists'
          | 'verified_symbol_exists'
          | 'verified_token_exists'
        >()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/verified-token-requests', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['verified-token-requests'].$get({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.id).toEqualTypeOf<
          z.output<typeof VerifiedTokenRequests.schema.VerifiedTokenRequest>['id']
        >()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId/verified-token-requests/:requestId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['verified-token-requests'][
      ':requestId{vtr_[A-Za-z0-9_-]+}'
    ].$delete({ param: { orgId: 'org_test', requestId: 'vtr_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 409 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'organization_not_found' | 'verified_token_request_not_found'
        >()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'request_not_pending'>()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/projects/:projectId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
      ':projectId{prj_[A-Za-z0-9_-]+}'
    ].$get({ param: { orgId: 'org_test', projectId: 'prj_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.environments[0]).toEqualTypeOf<'production' | 'sandbox' | undefined>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'organization_not_found' | 'project_not_found'
        >()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId/projects/:projectId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
      ':projectId{prj_[A-Za-z0-9_-]+}'
    ].$delete({ param: { orgId: 'org_test', projectId: 'prj_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'organization_not_found' | 'project_not_found'
        >()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
        >()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].$delete({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
        >()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'sponsorships_unreported'>()
        void json
        return
      }
    }
  })

  test('POST /v1/orgs/:orgId/projects/:projectId/api-keys', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
      ':projectId{prj_[A-Za-z0-9_-]+}'
    ]['api-keys'].$post({
      json: { allowedIps: ['203.0.113.0/24'], scopes: ['data:read'] },
      param: { orgId: 'org_test', projectId: 'prj_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.token).toEqualTypeOf<string>()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        expectTypeOf(json.allowedIps).toEqualTypeOf<readonly string[]>()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden' | 'scope_not_issuable'>()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/api-keys', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['api-keys'].$get({
      // The environment filter is optional (defaults to production server-side).
      query: { environment: 'sandbox' },
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.id).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.environment).toEqualTypeOf<'production' | 'sandbox'>()
        expectTypeOf(json.data[0]!.allowedIps).toEqualTypeOf<readonly string[]>()
        // Absent on org-wide keys minted without project attribution.
        expectTypeOf(json.data[0]!.projectId).toEqualTypeOf<string | undefined>()
        void json
        return
      }
    }
  })

  test('PATCH /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
      ':projectId{prj_[A-Za-z0-9_-]+}'
    ]['api-keys'][':keyId{key_[A-Za-z0-9_-]+}'].$patch({
      json: { allowedIps: [] },
      param: { keyId: 'key_test', orgId: 'org_test', projectId: 'prj_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.allowedIps).toEqualTypeOf<readonly string[]>()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
        >()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId/projects/:projectId/api-keys/:keyId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].projects[
      ':projectId{prj_[A-Za-z0-9_-]+}'
    ]['api-keys'][':keyId{key_[A-Za-z0-9_-]+}'].$delete({
      param: { keyId: 'key_test', orgId: 'org_test', projectId: 'prj_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
        >()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          | 'api_key_not_found'
          | 'api_keys_not_enabled'
          | 'organization_not_found'
          | 'project_not_found'
        >()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/usage/requests', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].usage.requests.$get({
      param: { orgId: 'org_test' },
      query: { projectId: 'prj_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 501 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.from).toEqualTypeOf<string>()
        expectTypeOf(json.interval).toEqualTypeOf<'day' | 'hour'>()
        expectTypeOf(json.to).toEqualTypeOf<string>()
        expectTypeOf(json.totals.requests).toEqualTypeOf<number>()
        expectTypeOf(json.byKey[0]?.apiKeyId).toEqualTypeOf<string | undefined>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
      case 501: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'analytics_unconfigured'>()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs/:orgId/members', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].members.$get({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.role).toEqualTypeOf<'admin' | 'member' | 'owner'>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
    }
  })

  test('PATCH /v1/orgs/:orgId/members/:userId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].members[
      ':userId{usr_[A-Za-z0-9_-]+}'
    ].$patch({ json: { role: 'admin' }, param: { orgId: 'org_test', userId: 'usr_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
        >()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'member_not_found' | 'organization_not_found'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'last_owner'>()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId/members/:userId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].members[
      ':userId{usr_[A-Za-z0-9_-]+}'
    ].$delete({ param: { orgId: 'org_test', userId: 'usr_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 409 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.userId).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'member_not_found' | 'organization_not_found'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'last_owner'>()
        void json
        return
      }
    }
  })

  test('POST /v1/orgs/:orgId/invitations', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].invitations.$post({
      json: { email: 'dev@example.com', role: 'member' },
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.email).toEqualTypeOf<string>()
        expectTypeOf(json.role).toEqualTypeOf<'admin' | 'member' | 'owner'>()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'api_key_forbidden' | 'api_key_ip_forbidden' | 'forbidden'
        >()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
    }
  })

  test('DELETE /v1/orgs/:orgId/invitations/:invitationId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].invitations[
      ':invitationId{inv_[A-Za-z0-9_-]+}'
    ].$delete({ param: { invitationId: 'inv_test', orgId: 'org_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 404) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        'invitation_not_found' | 'organization_not_found'
      >()
      void json
    }
  })

  test('POST /v1/orgs/:orgId/invite-links', async () => {
    const client = Client.create()
    const orgLinks = client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['invite-links']
    const res = await orgLinks.$post({
      json: { allowedEmailDomains: ['example.com'], name: 'Community' },
      param: { orgId: 'org_test' },
    })
    await orgLinks.$post({ json: { name: 'Unrestricted' }, param: { orgId: 'org_test' } })
    await orgLinks.$post({
      json: { allowedEmailDomains: null },
      param: { orgId: 'org_test' },
    })

    type Input = Parameters<typeof orgLinks.$post>[0]
    expectTypeOf<Input['json']['allowedEmailDomains']>().toEqualTypeOf<
      readonly string[] | null | undefined
    >()
    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<readonly string[] | null>()
        expectTypeOf(json.allowedEmailDomains).toEqualTypeOf<
          z.output<typeof InviteLinks.schema.InviteLink>['allowedEmailDomains']
        >()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'organization_not_found'>()
        void json
        return
      }
    }
  })

  test('PATCH /v1/orgs/:orgId/invite-links/:inviteLinkId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}']['invite-links'][
      ':inviteLinkId{iln_[A-Za-z0-9_-]+}'
    ].$patch({
      json: { enabled: false },
      param: { inviteLinkId: 'iln_test', orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    switch (res.status) {
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'invite_link_not_found' | 'organization_not_found'
        >()
        void json
        return
      }
    }
  })

  test('POST /v1/invite-links/accept', async () => {
    const client = Client.create()
    const res = await client.v1['invite-links'].accept.$post({ json: { token: 'lnk_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 403) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'forbidden' | 'invite_link_email_forbidden'>()
      void json
    }
  })

  test('POST /v1/invitations/:invitationId/accept', async () => {
    const client = Client.create()
    const res = await client.v1.invitations[':invitationId{inv_[A-Za-z0-9_-]+}'].accept.$post({
      param: { invitationId: 'inv_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.role).toEqualTypeOf<'admin' | 'member' | 'owner'>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'invitation_not_found'>()
        void json
        return
      }
    }
  })

  test('POST /v1/invitations/:invitationId/decline', async () => {
    const client = Client.create()
    const res = await client.v1.invitations[':invitationId{inv_[A-Za-z0-9_-]+}'].decline.$post({
      param: { invitationId: 'inv_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'invitation_not_found'>()
        void json
        return
      }
    }
  })

  test('GET /v1/orgs', async () => {
    const client = Client.create()
    const res = await client.v1.orgs.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.id).toEqualTypeOf<
          z.output<typeof Orgs.schema.listOrganizations.Response>['data'][number]['id']
        >()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'api_key_ip_forbidden'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/blocks/:block', async () => {
    const client = Client.create()
    const res = await client.v1.blocks[':block'].$get({ param: { block: '1' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.hash).toEqualTypeOf<z.output<typeof Blocks.schema.Block>['hash']>()
        expectTypeOf(json.number).toEqualTypeOf<z.output<typeof Blocks.schema.Block>['number']>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'block_invalid' | 'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'block_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/transactions', async () => {
    const client = Client.create()
    const res = await client.v1.transactions.$get({
      query: { include: 'feeToken.logoUri,feeToken.verified' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.hash).toEqualTypeOf<
          z.output<typeof Transactions.schema.Transaction>['hash']
        >()
        expectTypeOf(json.data[0]!.meta.receipt?.status).toEqualTypeOf<
          z.output<typeof Receipts.schema.Receipt>['status'] | undefined
        >()
        expectTypeOf(json.data[0]!.meta.receipt?.gasUsed).toEqualTypeOf<
          z.output<typeof Receipts.schema.Receipt>['gasUsed'] | undefined
        >()
        expectTypeOf(json.data[0]!.meta.receipt?.feeAmount).toEqualTypeOf<
          ValuedTokenAmount | undefined
        >()
        expectTypeOf(json.data[0]!.feeToken).toEqualTypeOf<
          z.output<typeof Tokens.schema.TokenReference> | undefined
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/transactions/:transactionHash', async () => {
    const client = Client.create()
    const res = await client.v1.transactions[':transactionHash'].$get({
      param: {
        transactionHash: '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665',
      },
      query: { include: 'feeToken.logoUri,feeToken.verified' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.hash).toEqualTypeOf<
          z.output<typeof Transactions.schema.Transaction>['hash']
        >()
        expectTypeOf(json.meta.receipt?.status).toEqualTypeOf<
          z.output<typeof Receipts.schema.Receipt>['status'] | undefined
        >()
        expectTypeOf(json.meta.receipt?.feeAmount).toEqualTypeOf<ValuedTokenAmount | undefined>()
        expectTypeOf(json.feeToken).toEqualTypeOf<
          z.output<typeof Tokens.schema.TokenReference> | undefined
        >()
        expectTypeOf(json.sender).toEqualTypeOf<
          z.output<typeof Transactions.schema.Transaction>['sender']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'query_invalid' | 'transaction_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'transaction_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/transactions/receipts', async () => {
    const client = Client.create()
    const res = await client.v1.transactions.receipts.$get({
      query: { include: 'feeToken.logoUri,feeToken.verified' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.transactionHash).toEqualTypeOf<
          z.output<typeof Receipts.schema.Receipt>['transactionHash']
        >()
        expectTypeOf(json.data[0]!.feeAmount).toEqualTypeOf<ValuedTokenAmount>()
        expectTypeOf(json.data[0]!.feeToken).toEqualTypeOf<
          z.output<typeof Tokens.schema.TokenReference> | undefined
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/transactions/:transactionHash/receipt', async () => {
    const client = Client.create()
    const res = await client.v1.transactions[':transactionHash'].receipt.$get({
      param: {
        transactionHash: '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665',
      },
      query: { include: 'feeToken.logoUri,feeToken.verified' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.transactionHash).toEqualTypeOf<
          z.output<typeof Receipts.schema.Receipt>['transactionHash']
        >()
        expectTypeOf(json.sender).toEqualTypeOf<
          z.output<typeof Receipts.schema.Receipt>['sender']
        >()
        expectTypeOf(json.feeAmount).toEqualTypeOf<ValuedTokenAmount>()
        expectTypeOf(json.feeToken).toEqualTypeOf<
          z.output<typeof Tokens.schema.TokenReference> | undefined
        >()
        expectTypeOf(json.meta.valuation).toEqualTypeOf<
          z.output<typeof Valuation.schema.Pricing> | undefined
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'query_invalid' | 'transaction_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'receipt_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/transactions/:transactionHash/activities', async () => {
    const client = Client.create()
    const res = await client.v1.transactions[':transactionHash'].activities.$get({
      param: {
        transactionHash: '0x4845ae2098724ab26a5d89370dce5124d044be6a5acc164afc348662de67d474',
      },
      query: {
        chainId: '4217',
        include: 'zones,token.logoUri,token.verified',
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.chainId).toEqualTypeOf<number>()
        expectTypeOf(json.data[0]!.type).toEqualTypeOf<
          z.output<
            typeof Activities.schema.getTransactionActivities.Response
          >['data'][number]['type']
        >()
        const item = json.data[0]!
        if (item.type === 'swap') {
          expectTypeOf(item.data.destinationAmount).toEqualTypeOf<ValuedTokenAmount>()
          // @ts-expect-error token references do not contain quantities
          void item.data.destinationToken.amount
          expectTypeOf(item.data.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
          expectTypeOf(item.data.sourceToken.currency).toEqualTypeOf<string>()
          expectTypeOf(item.data.sourceToken.decimals).toEqualTypeOf<number>()
          expectTypeOf(item.data.sourceToken.logoUri).toEqualTypeOf<string | undefined>()
          expectTypeOf(item.data.sourceToken.name).toEqualTypeOf<string>()
          expectTypeOf(item.data.sourceToken.symbol).toEqualTypeOf<string>()
          expectTypeOf(item.data.sourceToken.verified).toEqualTypeOf<boolean | undefined>()
        }
        if (item.type === 'session-closed') {
          expectTypeOf(item.data.refundAmount).toEqualTypeOf<ValuedTokenAmount | undefined>()
          // @ts-expect-error token references do not contain quantities
          void item.data.refund?.amount
        }
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'query_invalid' | 'transaction_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'transaction_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'transaction_ambiguous'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/tokens', async () => {
    const client = Client.create()
    const res = await client.v1.tokens.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.address).toEqualTypeOf<
          z.output<typeof Tokens.schema.getTokens.Response>['data'][number]['address']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/tokens/:token', async () => {
    const client = Client.create()
    const res = await client.v1.tokens[':token'].$get({
      param: { token: '0x20c0000000000000000000000000000000000000' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.address).toEqualTypeOf<
          z.output<typeof Tokens.schema.getToken.Response>['address']
        >()
        expectTypeOf(json.symbol).toEqualTypeOf<
          z.output<typeof Tokens.schema.getToken.Response>['symbol']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid' | 'token_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'token_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/tokens/:symbol', async () => {
    const client = Client.create()
    const res = await client.v1.tokens[':symbol{[A-Za-z][A-Za-z0-9._]{0,63}}'].$get({
      param: { symbol: 'USDC.e' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.address).toEqualTypeOf<
          z.output<typeof Tokens.schema.getToken.Response>['address']
        >()
        expectTypeOf(json.symbol).toEqualTypeOf<
          z.output<typeof Tokens.schema.getToken.Response>['symbol']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid' | 'symbol_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'token_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/tokens/:token/holders', async () => {
    const client = Client.create()
    const res = await client.v1.tokens[':token'].holders.$get({
      param: { token: '0x20c0000000000000000000000000000000000000' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.address).toEqualTypeOf<
          z.output<typeof Tokens.schema.getTokenHolders.Response>['data'][number]['address']
        >()
        // `meta` (opt-in `include=token`/`include=totalCount`) is optional.
        expectTypeOf(json.meta).toEqualTypeOf<
          z.output<typeof Tokens.schema.getTokenHolders.Response>['meta']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid' | 'token_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/tokens/:token/transactions', async () => {
    const client = Client.create()
    const res = await client.v1.tokens[':token'].transactions.$get({
      param: { token: '0x20c0000000000000000000000000000000000000' },
      query: { include: 'feeToken.logoUri,feeToken.verified' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.hash).toEqualTypeOf<
          z.output<typeof Transactions.schema.Transaction>['hash']
        >()
        expectTypeOf(json.data[0]!.feeToken).toEqualTypeOf<
          z.output<typeof Tokens.schema.TokenReference> | undefined
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid' | 'token_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/addresses/:address/balances', async () => {
    const client = Client.create()
    const res = await client.v1.addresses[':address'].balances.$get({
      param: { address: '0x0000000000000000000000000000000000000000' },
      query: {},
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.amount).toEqualTypeOf<
          z.output<typeof Balances.schema.getAddressBalances.Response>['data'][number]['amount']
        >()
        expectTypeOf(json.data[0]!.formatted).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.currency).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.decimals).toEqualTypeOf<number>()
        // `feeEligible` is best-effort, so it is an optional boolean.
        expectTypeOf(json.data[0]!.feeEligible).toEqualTypeOf<boolean | undefined>()
        expectTypeOf(json.data[0]!.token.logoUri).toEqualTypeOf<string | undefined>()
        expectTypeOf(json.data[0]!.token.verified).toEqualTypeOf<boolean>()
        // `valuation` is opt-in, then null for unverified or unpriceable holdings.
        expectTypeOf(json.data[0]!.valuation).toEqualTypeOf<
          | {
              amount: string
              currency: string
            }
          | null
          | undefined
        >()
        // `meta` (opt-in `include=totalCount` capped count) is optional.
        expectTypeOf(json.meta).toEqualTypeOf<
          z.output<typeof Balances.schema.getAddressBalances.Response>['meta']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'address_invalid' | 'query_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/addresses/:address/balances/:token', async () => {
    const client = Client.create()
    const res = await client.v1.addresses[':address'].balances[':token'].$get({
      param: {
        address: '0x0000000000000000000000000000000000000000',
        token: '0x20c0000000000000000000000000000000000000',
      },
      query: {},
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.amount).toEqualTypeOf<string>()
        expectTypeOf(json.formatted).toEqualTypeOf<string>()
        expectTypeOf(json.token).toEqualTypeOf<z.output<typeof Tokens.schema.Token>>()
        expectTypeOf(json.valuation).toEqualTypeOf<
          z.output<typeof Balances.schema.getAddressBalances.Balance>['valuation']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'address_invalid' | 'query_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'token_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/addresses/:address/valuation', async () => {
    const client = Client.create()
    const res = await client.v1.addresses[':address'].valuation.$get({
      param: { address: '0x0000000000000000000000000000000000000000' },
      query: { currency: 'AUD' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.amount).toEqualTypeOf<string>()
        expectTypeOf(json.currency).toEqualTypeOf<string>()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        // `pricing` is `null` when no currency conversion was needed.
        expectTypeOf(json.pricing).toEqualTypeOf<
          z.output<typeof Valuation.schema.getAddressValuation.Response>['pricing']
        >()
        expectTypeOf(json.unpriced).toEqualTypeOf<string[]>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'address_invalid' | 'query_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/transfers', async () => {
    const client = Client.create()
    const res = await client.v1.transfers.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.transactionHash).toEqualTypeOf<
          z.output<typeof Transfers.schema.getTransfers.Response>['data'][number]['transactionHash']
        >()
        expectTypeOf(json.data[0]!.memo).toEqualTypeOf<
          z.output<typeof Transfers.schema.getTransfers.Transfer>['memo']
        >()
        expectTypeOf(json.data[0]!.attribution).toEqualTypeOf<
          z.output<typeof Transfers.schema.getTransfers.Transfer>['attribution']
        >()
        expectTypeOf(json.data[0]!.destinationAmount).toEqualTypeOf<ValuedTokenAmount | undefined>()
        expectTypeOf(json.data[0]!.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
        expectTypeOf(json.data[0]!.sourceToken.currency).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.sourceToken.decimals).toEqualTypeOf<number>()
        expectTypeOf(json.data[0]!.sourceToken.name).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.sourceToken.symbol).toEqualTypeOf<string>()
        // @ts-expect-error token references do not contain quantities
        void json.data[0]!.sourceToken.amount
        // @ts-expect-error valuations belong to amount fields
        void json.data[0]!.sourceToken.valuation
        // @ts-expect-error destination token references do not contain quantities
        void json.data[0]!.destinationToken?.amount
        // @ts-expect-error destination valuations belong to amount fields
        void json.data[0]!.destinationToken?.valuation
        // `meta` (the opt-in `include=totalCount` capped count) is optional.
        expectTypeOf(json.meta).toEqualTypeOf<
          z.output<typeof Transfers.schema.getTransfers.Response>['meta']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/quotes', async () => {
    const client = Client.create()
    const res = await client.v1.funding.quotes.$get({
      query: {
        provider: 'across',
        sourceAmount: '1000000',
        sourceChain: 'base',
        sourceToken: 'USDC',
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.destinationAmount).toEqualTypeOf<{
          baseUnits: string
          currency: string
          decimals: number
          formatted: string
        }>()
        expectTypeOf(json.data[0]!.destinationAmountMin).toEqualTypeOf<
          | {
              baseUnits: string
              currency: string
              decimals: number
              formatted: string
            }
          | undefined
        >()
        expectTypeOf(json.data[0]!.sourceAmount).toEqualTypeOf<
          z.output<
            typeof FundingQuotes.schema.quoteFunding.Response
          >['data'][number]['sourceAmount']
        >()
        // @ts-expect-error token references do not contain quantities
        void json.data[0]!.sourceToken.amount
        // @ts-expect-error provider details no longer duplicate destination amounts
        void json.data[0]!.quote.outputAmount
        expectTypeOf(json.data[0]!.provider.id).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.quote.expiresAt).toEqualTypeOf<string | undefined>()
        expectTypeOf(json.data[0]!.destinationChain.addressFormat).toEqualTypeOf<
          'base58' | 'base58check' | 'hex'
        >()
        expectTypeOf(json.data[0]!.sourceChain.addressFormat).toEqualTypeOf<
          'base58' | 'base58check' | 'hex'
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/chains', async () => {
    const client = Client.create()
    const res = await client.v1.funding.chains.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.tokens[0]!.symbol).toEqualTypeOf<
          z.output<
            typeof FundingChains.schema.getFundingChains.Response
          >['data'][number]['tokens'][number]['symbol']
        >()
        expectTypeOf(json.data[0]!.addressFormat).toEqualTypeOf<'base58' | 'base58check' | 'hex'>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/providers', async () => {
    const client = Client.create()
    const res = await client.v1.funding.providers.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.id).toEqualTypeOf<string>()
        // @ts-expect-error providers no longer expose deployment configuration state
        void json.data[0]!.status
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('POST /v1/funding/deposit-addresses', async () => {
    const client = Client.create()
    const json = {
      amount: '100000000',
      destinationToken: '0x20c00000000000000000000014f22ca97301eb73',
      recipient: `0x${'11'.repeat(20)}`,
      refundAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
      sourceChain: 'tron:0x2b6653dc',
      sourceToken: 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t',
    } as const
    // @ts-expect-error `Idempotency-Key` is required for deposit-address creation.
    void client.v1.funding['deposit-addresses'].$post({ json })
    const res = await client.v1.funding['deposit-addresses'].$post({
      header: { 'idempotency-key': 'funding_01k1c5j8q8p0be6j5v9m6d1e4r' },
      json,
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        expectTypeOf(json.status).toEqualTypeOf<
          z.output<
            typeof FundingDepositAddresses.schema.createFundingDepositAddress.Response
          >['status']
        >()
        expectTypeOf(json.subsidize).toEqualTypeOf<boolean>()
        if ('quote' in json) {
          expectTypeOf(json.destinationAmount.baseUnits).toEqualTypeOf<string>()
          expectTypeOf(json.fees).toEqualTypeOf<
            z.output<typeof FundingDepositAddress.schema.CreatedFundingDepositAddress>['fees']
          >()
          expectTypeOf(json.quote.sampledAt).toEqualTypeOf<string>()
          expectTypeOf(json.sourceAmount.baseUnits).toEqualTypeOf<string>()
        }
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'deposit_address_not_available'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'idempotency_conflict' | 'idempotency_in_progress'
        >()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/deposit-addresses/:id', async () => {
    const client = Client.create()
    const res = await client.v1.funding['deposit-addresses'][':id{fda_[A-Za-z0-9_-]+}'].$get({
      param: { id: 'fda_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.status).toEqualTypeOf<
          z.output<typeof FundingDepositAddresses.schema.DepositAddress>['status']
        >()
        expectTypeOf(json.sourceChain.kind).toEqualTypeOf<'evm' | 'solana' | 'tron'>()
        expectTypeOf(json.subsidize).toEqualTypeOf<boolean>()
        // @ts-expect-error provider routing remains private
        void json.providerOutputToken
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_found'>()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/deposit-addresses', async () => {
    const client = Client.create()
    const res = await client.v1.funding['deposit-addresses'].$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.status).toEqualTypeOf<
          z.output<typeof FundingDepositAddresses.schema.DepositAddress>['status']
        >()
        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
        void json
        return
      }
    }
  })

  test('POST /v1/funding/deposit-addresses/:id/reconcile', async () => {
    const client = Client.create()
    const res = await client.v1.funding['deposit-addresses'][
      ':id{fda_[A-Za-z0-9_-]+}'
    ].reconcile.$post({ param: { id: 'fda_test' } })

    expectTypeOf(res.status).toEqualTypeOf<202 | 400 | 401 | 403 | 404 | 409 | 429 | 501 | 502>()

    switch (res.status) {
      case 202: {
        expectTypeOf(await res.text()).toEqualTypeOf<string>()
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_found'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_address_not_active'>()
        void json
        return
      }
      case 501: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'not_implemented'>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/deposits', async () => {
    const client = Client.create()
    void client.v1.funding.deposits.$get()
    void client.v1.funding.deposits.$get({
      query: { depositAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8' },
    })
    const res = await client.v1.funding.deposits.$get({
      query: {
        depositAddress: 'TJRabPrwbZy45sbavfcjinPJC18kjpRTv8',
        destinationToken: 'usdt0',
        include: 'totalCount',
        provider: 'relay',
        recipient: `0x${'11'.repeat(20)}`,
        sourceChain: 'tron',
        sourceToken: 'usdt',
        status: 'detected',
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.recipient).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.status).toEqualTypeOf<
          z.output<typeof FundingDepositAddresses.schema.Deposit>['status']
        >()
        expectTypeOf(json.meta).toEqualTypeOf<
          z.output<typeof FundingDepositAddresses.schema.listFundingDeposits.Response>['meta']
        >()
        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/deposits/:id', async () => {
    const client = Client.create()
    const res = await client.v1.funding.deposits[':id{fdp_[A-Za-z0-9_-]+}'].$get({
      param: { id: 'fdp_001785792060000_2ZPE2gvateYEQ0dQslgvkhjx' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.detectionTrigger).toEqualTypeOf<
          'chain' | 'manual' | 'poll' | 'webhook' | undefined
        >()
        expectTypeOf(json.destinationAmountRequired).toEqualTypeOf<
          z.output<typeof FundingDepositAddresses.schema.Deposit>['destinationAmountRequired']
        >()
        expectTypeOf(json.sourceTransferIndex).toEqualTypeOf<number | undefined>()
        expectTypeOf(json.statusReason).toEqualTypeOf<
          z.output<typeof FundingDepositAddresses.schema.Deposit>['statusReason']
        >()
        // @ts-expect-error provider request identifiers remain private
        void json.providerRequestIds
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'funding_deposit_not_found'>()
        void json
        return
      }
    }
  })

  test('GET /v1/funding/transfers', async () => {
    const client = Client.create()
    const res = await client.v1.funding.transfers.$get({ query: {} })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.id).toEqualTypeOf<string>()
        expectTypeOf(json.data[0]!.status).toEqualTypeOf<
          z.output<typeof FundingTransfers.schema.Transfer>['status']
        >()
        expectTypeOf(json.data[0]!.version).toEqualTypeOf<number>()
        // Transfer reads never expose the executable action.
        // @ts-expect-error `action` is a creation-only field
        void json.data[0]!.action
        // `meta` (opt-in `include=totalCount` count) is optional.
        expectTypeOf(json.meta).toEqualTypeOf<
          z.output<typeof FundingTransfers.schema.listFundingTransfers.Response>['meta']
        >()
        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('POST /v1/funding/transfers', async () => {
    const client = Client.create()
    const json = {
      amount: '1000000',
      destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
      mode: 'exactSource',
      provider: 'stargate',
      recipient: `0x${'11'.repeat(20)}`,
      sender: `0x${'22'.repeat(20)}`,
      sourceChain: 'eip155:8453',
      sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
    } as const
    // @ts-expect-error `Idempotency-Key` is required for funding transfer creation.
    void client.v1.funding.transfers.$post({ json })
    const res = await client.v1.funding.transfers.$post({
      header: { 'idempotency-key': 'funding_01k1c5j8q8p0be6j5v9m6d1e4r' },
      json,
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.action.type).toEqualTypeOf<'evm:calls'>()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        expectTypeOf(json.status).toEqualTypeOf<
          z.output<typeof FundingTransfers.schema.createFundingTransfer.Response>['status']
        >()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'quote_not_available'>()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          'idempotency_conflict' | 'idempotency_in_progress'
        >()
        void json
        return
      }
    }
  })

  test('POST /v1/funding/transfers/vault', async () => {
    const client = Client.create()
    const json = {
      amount: '1000000',
      mode: 'exactSource',
      recipient: `0x${'11'.repeat(20)}`,
      sender: `0x${'22'.repeat(20)}`,
      sourceChain: 'eip155:8453',
      sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
      vaultAddress: `0x${'f4'.repeat(20)}`,
    } as const
    // @ts-expect-error `Idempotency-Key` is required for vault transfer creation.
    void client.v1.funding.transfers.vault.$post({ json })
    const res = await client.v1.funding.transfers.vault.$post({
      header: { 'idempotency-key': 'funding_vault_01k1c5j8q8p0be6j5v9m6d1e4r' },
      json,
    })

    expectTypeOf(res.status).toEqualTypeOf<400 | 501 | PublicAccessStatus>()
    if (res.status === 501) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'not_implemented'>()
      void json
    }
  })

  test('POST /v1/funding/transfers/zone', async () => {
    const client = Client.create()
    const json = {
      amount: '1000000',
      destinationChain: 'eip155:421700001',
      destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
      mode: 'exactSource',
      recipient: `0x${'11'.repeat(20)}`,
      recipientFallback: `0x${'33'.repeat(20)}`,
      sender: `0x${'22'.repeat(20)}`,
      sourceChain: 'eip155:8453',
      sourceToken: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
    } as const
    // @ts-expect-error `Idempotency-Key` is required for Zone transfer creation.
    void client.v1.funding.transfers.zone.$post({ json })
    const res = await client.v1.funding.transfers.zone.$post({
      header: { 'idempotency-key': 'funding_zone_01k1c5j8q8p0be6j5v9m6d1e4r' },
      json,
    })

    expectTypeOf(res.status).toEqualTypeOf<400 | 501 | PublicAccessStatus>()
    if (res.status === 501) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'not_implemented'>()
      void json
    }
  })

  test('GET /v1/funding/transfers/:id', async () => {
    const client = Client.create()
    const res = await client.v1.funding.transfers[':id{ftr_[A-Za-z0-9_-]+}'].$get({
      param: { id: 'ftr_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.id).toEqualTypeOf<string>()
        expectTypeOf(json.status).toEqualTypeOf<
          z.output<typeof FundingTransfers.schema.getFundingTransfer.Response>['status']
        >()
        expectTypeOf(json.statusReason).toEqualTypeOf<
          z.output<typeof FundingTransfers.schema.getFundingTransfer.Response>['statusReason']
        >()
        // @ts-expect-error `action` is a creation-only field
        void json.action
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'funding_transfer_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('POST /v1/funding/transfers/:id/source-transactions', async () => {
    const client = Client.create()
    const res = await client.v1.funding.transfers[':id{ftr_[A-Za-z0-9_-]+}'][
      'source-transactions'
    ].$post({
      json: { transactionHash: `0x${'51'.repeat(32)}` },
      param: { id: 'ftr_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 409 | 501 | 502 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.sourceTransactionHashes).toEqualTypeOf<string[] | undefined>()
        expectTypeOf(json.status).toEqualTypeOf<
          z.output<
            typeof FundingTransfers.schema.registerFundingTransferSourceTransaction.Response
          >['status']
        >()
        void json
        return
      }
      case 409: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          | 'funding_transfer_not_awaiting_source'
          | 'source_transaction_conflict'
          | 'source_transaction_pending'
        >()
        void json
        return
      }
    }
  })

  test('GET /v1/exchange/swaps', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.swaps.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.transactionHash).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getSwaps.Response>['data'][number]['transactionHash']
        >()
        expectTypeOf(json.data[0]!.destinationAmount).toEqualTypeOf<ValuedTokenAmount>()
        expectTypeOf(json.data[0]!.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
        expectTypeOf(json.data[0]!.fills[0]!.destinationAmount).toEqualTypeOf<ValuedTokenAmount>()
        expectTypeOf(json.data[0]!.fills[0]!.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
        // @ts-expect-error token references do not contain quantities
        void json.data[0]!.sourceToken.amount
        // @ts-expect-error token references do not contain quantities
        void json.data[0]!.fills[0]!.destinationToken.amount
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('POST /v1/exchange/quotes', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.quotes.$post({
      json: {
        account: '0x1111111111111111111111111111111111111111',
        amount: '1000000',
        destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
        mode: 'exactSource',
        slippageBps: 50,
        sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
      },
      query: { include: 'token.logoUri,token.verified' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.destinationAmount).toEqualTypeOf<ValuedTokenAmount>()
        // @ts-expect-error token references do not contain quantities
        void json.destinationToken.amount
        expectTypeOf(json.destinationToken.logoUri).toEqualTypeOf<string | undefined>()
        expectTypeOf(json.destinationToken.symbol).toEqualTypeOf<string>()
        expectTypeOf(json.destinationToken.verified).toEqualTypeOf<boolean | undefined>()
        expectTypeOf(json.meta?.valuation).toEqualTypeOf<
          z.output<typeof Valuation.schema.Pricing> | undefined
        >()
        expectTypeOf(json.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
        // @ts-expect-error token references do not contain quantities
        void json.sourceToken.amount
        expectTypeOf(json.sourceToken.logoUri).toEqualTypeOf<string | undefined>()
        expectTypeOf(json.sourceToken.symbol).toEqualTypeOf<string>()
        expectTypeOf(json.sourceToken.verified).toEqualTypeOf<boolean | undefined>()
        expectTypeOf(json.gasEstimate).toEqualTypeOf<string>()
        if (json.status === 'approvalRequired')
          expectTypeOf(json.approval.calls[0]!.data).toEqualTypeOf<
            z.output<typeof Exchanges.schema.createQuote.Call>['data']
          >()
        if (json.status === 'signatureRequired') {
          expectTypeOf(json.continuation).toEqualTypeOf<string>()
          expectTypeOf(json.typedData.primaryType).toEqualTypeOf<string>()
        }
        if (json.status === 'ready')
          expectTypeOf(json.transaction.calls[0]!.data).toEqualTypeOf<
            z.output<typeof Exchanges.schema.createQuote.Call>['data']
          >()
        if (json.mode === 'exactSource') {
          expectTypeOf(json.destinationAmountMin).toEqualTypeOf<ValuedTokenAmount>()
          // @ts-expect-error slippage quantities live on destinationAmountMin
          void json.destinationToken.minimumAmount
          // @ts-expect-error exact-source responses do not carry a maximum source amount
          void json.sourceAmountMax
          // @ts-expect-error token references do not contain quantities
          void json.sourceToken.maximumAmount
        } else {
          expectTypeOf(json.sourceAmountMax).toEqualTypeOf<ValuedTokenAmount>()
          // @ts-expect-error slippage quantities live on sourceAmountMax
          void json.sourceToken.maximumAmount
          // @ts-expect-error exact-destination responses do not carry a minimum destination amount
          void json.destinationAmountMin
          // @ts-expect-error token references do not contain quantities
          void json.destinationToken.minimumAmount
        }
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'body_invalid' | 'query_invalid' | 'quote_amount_out_of_range'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'quote_not_available'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('QUERY /v1/exchange/quotes', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.quotes.$query({
      json: {
        account: '0x1111111111111111111111111111111111111111',
        amount: '1000000',
        destinationToken: '0x20c000000000000000000000b9537d11c60e8b50',
        mode: 'exactSource',
        slippageBps: 50,
        sourceToken: '0x20c0000000000000000000008f5425160ebe5525',
      },
      query: { include: 'token.logoUri,token.verified' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.destinationAmount).toEqualTypeOf<ValuedTokenAmount>()
      expectTypeOf(json.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
      expectTypeOf(json.destinationToken.logoUri).toEqualTypeOf<string | undefined>()
      expectTypeOf(json.sourceToken.verified).toEqualTypeOf<boolean | undefined>()
    }
  })

  test('POST /v1/exchange/quotes/execute', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.quotes.execute.$post({
      json: {
        account: '0x1111111111111111111111111111111111111111',
        continuation: 'eyJxdW90ZSI6e319',
        provider: 'uniswap',
        signature: `0x${'11'.repeat(65)}`,
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.provider).toEqualTypeOf<string>()
        expectTypeOf(json.transaction.calls[0]!.data).toEqualTypeOf<
          z.output<typeof Exchanges.schema.createQuote.Call>['data']
        >()
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<
            'body_invalid' | 'query_invalid' | 'swap_continuation_invalid' | 'swap_provider_invalid'
          >
        >()
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        return
      }
    }
  })

  test('GET /v1/exchange/pairs', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.pairs.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.key).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getPairs.Response>['data'][number]['key']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/exchange/orders', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.orders.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.orderId).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getOrders.Response>['data'][number]['orderId']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'pair_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/exchange/orders/:orderId', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.orders[':orderId'].$get({
      param: { orderId: '1' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.orderId).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getOrder.Response>['orderId']
        >()
        expectTypeOf(json.remaining).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getOrder.Response>['remaining']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'order_invalid' | 'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'order_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/exchange/orders/:orderId/fills', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.orders[':orderId'].fills.$get({
      param: { orderId: '1' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.transactionHash).toEqualTypeOf<
          z.output<
            typeof Exchanges.schema.getOrderFills.Response
          >['data'][number]['transactionHash']
        >()
        // `meta` (opt-in `include=totalCount` capped count) is optional.
        expectTypeOf(json.meta).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getOrderFills.Response>['meta']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'order_invalid' | 'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/exchange/pairs/:base', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.pairs[':base'].$get({
      param: { base: '0x20c0000000000000000000000000000000000000' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.key).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getPair.Response>['key']
        >()
        expectTypeOf(json.base.address).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getPair.Response>['base']['address']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'pair_invalid' | 'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'pair_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/exchange/pairs/:base/ohlc', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.pairs[':base'].ohlc.$get({
      param: { base: '0x20c0000000000000000000000000000000000000' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.interval).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getPairOhlc.Response>['interval']
        >()
        expectTypeOf(json.data[0]!.open).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getPairOhlc.Response>['data'][number]['open']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'pair_invalid' | 'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'pair_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/exchange/pairs/:base/depth', async () => {
    const client = Client.create()
    const res = await client.v1.exchange.pairs[':base'].depth.$get({
      param: { base: '0x20c0000000000000000000000000000000000000' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.asks[0]!.price).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getPairDepth.Response>['asks'][number]['price']
        >()
        expectTypeOf(json.base.address).toEqualTypeOf<
          z.output<typeof Exchanges.schema.getPairDepth.Response>['base']['address']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'pair_invalid' | 'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'pair_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/fee-amm/pools', async () => {
    const client = Client.create()
    const res = await client.v1['fee-amm'].pools.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.poolId).toEqualTypeOf<
          z.output<typeof FeeAmm.schema.getFeeAmmPools.Pool>['poolId']
        >()
        expectTypeOf(json.data[0]!.userToken.address).toEqualTypeOf<
          z.output<typeof FeeAmm.schema.getFeeAmmPools.Token>['address']
        >()
        expectTypeOf(json.data[0]!.userAmount).toEqualTypeOf<
          z.output<typeof FeeAmm.schema.getFeeAmmPools.Pool>['userAmount']
        >()
        expectTypeOf(json.data[0]!.validatorAmount).toEqualTypeOf<
          z.output<typeof FeeAmm.schema.getFeeAmmPools.Pool>['validatorAmount']
        >()
        // @ts-expect-error token references do not contain quantities
        void json.data[0]!.userToken.amount
        // @ts-expect-error token references do not contain formatted quantities
        void json.data[0]!.validatorToken.formatted
        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/fee-amm/mints', async () => {
    const client = Client.create()
    const res = await client.v1['fee-amm'].mints.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.minter).toEqualTypeOf<
          z.output<typeof FeeAmm.schema.getFeeAmmMints.Mint>['minter']
        >()
        expectTypeOf(json.data[0]!.liquidity).toEqualTypeOf<
          z.output<typeof FeeAmm.schema.getFeeAmmMints.Mint>['liquidity']
        >()
        expectTypeOf(json.nextCursor).toEqualTypeOf<string | null>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/verified-tokens', async () => {
    const client = Client.create()
    const res = await client.v1['verified-tokens'].$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.address).toEqualTypeOf<
          z.output<typeof VerifiedTokens.schema.Token>['address']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/verified-tokens/currencies', async () => {
    const client = Client.create()
    const res = await client.v1['verified-tokens'].currencies.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!).toEqualTypeOf<string>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'query_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/verified-tokens/:address', async () => {
    const client = Client.create()
    const res = await client.v1['verified-tokens'][':address'].$get({
      param: { address: '0x20c0000000000000000000000000000000000000' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.address).toEqualTypeOf<
          z.output<typeof VerifiedTokens.schema.Token>['address']
        >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'address_invalid' | 'query_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 404: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'verified_token_not_found'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/indexer/query', async () => {
    const client = Client.create()
    const res = await client.v1.indexer.query.$get({
      query: { chainId: '42431', sql: 'select 1' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 422 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.columns[0]!).toEqualTypeOf<
          z.output<typeof Indexer.schema.Response>['columns'][number]
        >()
        expectTypeOf(json.row_count).toEqualTypeOf<
          z.output<typeof Indexer.schema.Response>['row_count']
        >()
        expectTypeOf(json.engine).toEqualTypeOf<'postgres' | 'clickhouse' | 'tiered' | undefined>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        if ('ok' in json) {
          expectTypeOf(json.error).toEqualTypeOf<string>()
          expectTypeOf(json.ok).toEqualTypeOf<false>()
        } else {
          expectTypeOf(json.error.code).toEqualTypeOf<'api_key_malformed'>()
        }
        void json
        return
      }
      case 422: {
        const json = await res.json()
        expectTypeOf(json.error).toEqualTypeOf<string>()
        expectTypeOf(json.ok).toEqualTypeOf<false>()
        void json
        return
      }
    }
  })

  test('GET /v1/zones/withdrawals/:senderTag', async () => {
    const client = Client.create()
    const res = await client.v1.zones.withdrawals[':senderTag'].$get({
      param: {
        senderTag: '0x61fc42a734cb44acef497ea0bed612c691195623244136e0739e1929569e2487',
      },
      query: { chainId: '421700001' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429 | 502>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json).toEqualTypeOf<
          z.output<typeof Zones.schema.listZoneWithdrawals.Response>
        >()
        const withdrawal = json.data[0]!
        expectTypeOf(withdrawal.blockNumber).toEqualTypeOf<number>()
        expectTypeOf(withdrawal.id).toEqualTypeOf<string>()
        expectTypeOf(withdrawal.logIndex).toEqualTypeOf<number>()
        expectTypeOf(withdrawal.status).toEqualTypeOf<'completed' | 'failed'>()
        expectTypeOf(withdrawal.transactionHash).toEqualTypeOf<`0x${string}`>()
        expectTypeOf(withdrawal.zoneStatus).toEqualTypeOf<'completed' | 'pending'>()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<
            'chain_id_invalid' | 'chain_id_unsupported' | 'query_invalid' | 'sender_tag_invalid'
          >
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 401: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_invalid' | 'api_key_missing'>()
        void json
        return
      }
      case 403: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'api_key_ip_forbidden'>()
        void json
        return
      }
      case 429: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'payment_required' | 'rate_limit_exceeded'>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        void json
        return
      }
    }
  })

  test('POST /rpc/:chain', async () => {
    const client = Client.create()
    const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}?'].$post({
      param: { chain: undefined },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        if (Array.isArray(json))
          expectTypeOf(json[0]!.jsonrpc).toEqualTypeOf<
            z.output<typeof Rpc.schema.Response>['jsonrpc']
          >()
        else
          expectTypeOf(json.jsonrpc).toEqualTypeOf<
            z.output<typeof Rpc.schema.Response>['jsonrpc']
          >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'chain_id_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('POST /rpc/:chain testnet shortcut', async () => {
    const client = Client.create()
    const res = await client.rpc[':chain{(mainnet|testnet|[0-9]+)}?'].$post({
      param: { chain: 'testnet' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | PublicAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        if (Array.isArray(json))
          expectTypeOf(json[0]!.jsonrpc).toEqualTypeOf<
            z.output<typeof Rpc.schema.Response>['jsonrpc']
          >()
        else
          expectTypeOf(json.jsonrpc).toEqualTypeOf<
            z.output<typeof Rpc.schema.Response>['jsonrpc']
          >()
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<Access400<'chain_id_invalid'>>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/addresses/:address/activities', async () => {
    const client = Client.create()
    const res = await client.v1.addresses[':address'].activities.$get({
      param: { address: '0x0000000000000000000000000000000000000000' },
      query: {
        chainId: '4217',
        include: 'zones,token.logoUri,token.verified',
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()

    switch (res.status) {
      case 200: {
        const json = await res.json()
        expectTypeOf(json.data[0]!.chainId).toEqualTypeOf<number | undefined>()
        expectTypeOf(json.data[0]!.type).toEqualTypeOf<
          z.output<typeof Activities.schema.getAddressActivities.Response>['data'][number]['type']
        >()
        const entry = json.data[0]!
        if (entry.type === 'transfer') {
          expectTypeOf(entry.data.destinationAmount).toEqualTypeOf<ValuedTokenAmount | undefined>()
          expectTypeOf(entry.data.sourceAmount).toEqualTypeOf<ValuedTokenAmount>()
          // @ts-expect-error token references do not contain quantities
          void entry.data.sourceToken.amount
          expectTypeOf(entry.data.sourceToken.currency).toEqualTypeOf<string>()
          expectTypeOf(entry.data.sourceToken.decimals).toEqualTypeOf<number>()
          expectTypeOf(entry.data.sourceToken.name).toEqualTypeOf<string>()
          expectTypeOf(entry.data.sourceToken.symbol).toEqualTypeOf<string>()
        }
        void json
        return
      }
      case 400: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<
          Access400<'address_invalid' | 'query_invalid'>
        >()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
      case 502: {
        const json = await res.json()
        expectTypeOf(json.error.code).toEqualTypeOf<'upstream_error'>()
        expectTypeOf(json.error.message).toEqualTypeOf<string>()
        void json
        return
      }
    }
  })

  test('GET /v1/webhooks/event-types', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks['event-types'].$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | PaidAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.data[0]!.type).toEqualTypeOf<Webhooks.EventType>()
      void json
    }
  })

  test('POST /v1/webhooks', async () => {
    const client = Client.create()
    void client.v1.webhooks.$post({
      json: {
        destination: { type: 'url', url: 'https://example.com/webhook' },
        eventType: 'funding:deposit.updated',
        filters: {
          depositAddressId: 'fda_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
          recipient: `0x${'11'.repeat(20)}`,
          status: 'completed',
        },
      },
    })
    void client.v1.webhooks.$post({
      json: {
        destination: { type: 'url', url: 'https://example.com/webhook' },
        eventType: 'funding:transfer.updated',
        filters: {
          id: 'ftr_001785792000000_2ZPE2gvateYEQ0dQslgvkhjx',
          status: 'completed',
        },
      },
    })
    const res = await client.v1.webhooks.$post({
      json: {
        destination: { type: 'url', url: 'https://example.com/webhook' },
        eventType: 'token:transfer',
        filters: {},
      },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 403 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.destination.type).toEqualTypeOf<'betterstack' | 'slack' | 'url'>()
      if (json.destination.type === 'betterstack')
        expectTypeOf(json.destination.token).toEqualTypeOf<string>()
      if (json.destination.type === 'slack')
        expectTypeOf(json.destination.url).toEqualTypeOf<string>()
      expectTypeOf(json.secret).toEqualTypeOf<
        z.output<typeof Webhooks.schema.createWebhook.Response>['secret']
      >()
      void json
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        Access400<
          | 'body_invalid'
          | 'chain_id_unsupported'
          | 'event_type_unsupported'
          | 'filters_invalid'
          | 'url_invalid'
        >
      >()
    }
    if (res.status === 403) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        'api_key_forbidden' | 'api_key_ip_forbidden' | 'limit_exceeded'
      >()
    }
  })

  test('GET /v1/webhooks', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks.$get()

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      const destination = json.data[0]!.destination
      if (destination.type === 'betterstack')
        expectTypeOf(destination.token).toEqualTypeOf<'[redacted]'>()
      if (destination.type === 'slack')
        expectTypeOf(destination.url).toEqualTypeOf<'https://hooks.slack.com/…'>()
      expectTypeOf(json.data[0]!.id).toEqualTypeOf<
        z.output<typeof Webhooks.schema.listWebhooks.Response>['data'][number]['id']
      >()
      // `meta` (opt-in `include=totalCount` count) is optional.
      expectTypeOf(json.meta).toEqualTypeOf<
        z.output<typeof Webhooks.schema.listWebhooks.Response>['meta']
      >()
      void json
    }
  })

  test('GET /v1/webhooks/:id', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks[':id{wh_[A-Za-z0-9_-]+}'].$get({
      param: { id: 'wh_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      if (json.destination.type === 'betterstack')
        expectTypeOf(json.destination.token).toEqualTypeOf<'[redacted]'>()
      if (json.destination.type === 'slack')
        expectTypeOf(json.destination.url).toEqualTypeOf<'https://hooks.slack.com/…'>()
      expectTypeOf(json.id).toEqualTypeOf<
        z.output<typeof Webhooks.schema.getWebhook.Response>['id']
      >()
      void json
    }
  })

  test('GET /v1/webhooks/:id/deliveries', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks[':id{wh_[A-Za-z0-9_-]+}'].deliveries.$get({
      param: { id: 'wh_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.data[0]!.id).toEqualTypeOf<
        z.output<typeof Webhooks.schema.listWebhookDeliveries.Response>['data'][number]['id']
      >()
      // `meta` (opt-in `include=totalCount` count) is optional.
      expectTypeOf(json.meta).toEqualTypeOf<
        z.output<typeof Webhooks.schema.listWebhookDeliveries.Response>['meta']
      >()
      void json
    }
  })

  test('POST /v1/webhooks/:id/ping', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks[':id{wh_[A-Za-z0-9_-]+}'].ping.$post({
      param: { id: 'wh_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.delivered).toEqualTypeOf<
        z.output<typeof Webhooks.schema.pingWebhook.Response>['delivered']
      >()
      void json
    }
  })

  test('POST /v1/webhooks/:id/deliveries/:deliveryId/retry', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks[':id{wh_[A-Za-z0-9_-]+}'].deliveries[
      ':deliveryId'
    ].retry.$post({
      param: { deliveryId: 'whd_test', id: 'wh_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.eventId).toEqualTypeOf<
        z.output<typeof Webhooks.schema.retryWebhookDelivery.Response>['eventId']
      >()
      void json
    }
  })

  test('PATCH /v1/webhooks/:id', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks[':id{wh_[A-Za-z0-9_-]+}'].$patch({
      json: { status: 'paused' },
      param: { id: 'wh_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 403 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      if (json.destination.type === 'betterstack')
        expectTypeOf(json.destination.token).toEqualTypeOf<'[redacted]'>()
      if (json.destination.type === 'slack')
        expectTypeOf(json.destination.url).toEqualTypeOf<'https://hooks.slack.com/…'>()
      expectTypeOf(json.status).toEqualTypeOf<
        z.output<typeof Webhooks.schema.updateWebhook.Response>['status']
      >()
      void json
    }
    if (res.status === 400) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        Access400<
          | 'body_invalid'
          | 'destination_transition_invalid'
          | 'filters_invalid'
          | 'param_invalid'
          | 'url_invalid'
        >
      >()
    }
  })

  test('DELETE /v1/webhooks/:id', async () => {
    const client = Client.create()
    const res = await client.v1.webhooks[':id{wh_[A-Za-z0-9_-]+}'].$delete({
      param: { id: 'wh_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PublicAccessStatus>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.id).toEqualTypeOf<
        z.output<typeof Webhooks.schema.deleteWebhook.Response>['id']
      >()
      void json
    }
  })

  test('POST /v1/orgs/:orgId/webhooks', async () => {
    const client = Client.create()
    void client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks.$post({
      // @ts-expect-error Organization webhook creation requires an explicit chain id.
      json: {
        destination: { type: 'url', url: 'https://example.com/webhook' },
        eventType: 'token:transfer',
        filters: {},
      },
      param: { orgId: 'org_test' },
    })
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks.$post({
      json: {
        chainId: 4217,
        destination: { type: 'url', url: 'https://example.com/webhook' },
        eventType: 'token:transfer',
        filters: {},
      },
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      if ('secret' in json) {
        expectTypeOf(json.destination.type).toEqualTypeOf<'url'>()
        expectTypeOf(json.secret).toEqualTypeOf<string>()
      } else expectTypeOf(json.destination.type).toEqualTypeOf<'betterstack' | 'slack'>()
      expectTypeOf(json.status).toEqualTypeOf<
        z.output<typeof OrgWebhooks.schema.createWebhook.Response>['status']
      >()
    }
    if (res.status === 403) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'forbidden' | 'limit_exceeded'>()
    }
  })

  test('GET /v1/orgs/:orgId/webhooks', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks.$get({
      param: { orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.data[0]!.id).toEqualTypeOf<string>()
    }
  })

  test('GET /v1/orgs/:orgId/webhooks/:id/deliveries', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks[
      ':id{wh_[A-Za-z0-9_-]+}'
    ].deliveries.$get({
      param: { id: 'wh_test', orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.data[0]!.id).toEqualTypeOf<
        z.output<typeof OrgWebhooks.schema.listWebhookDeliveries.Response>['data'][number]['id']
      >()
      expectTypeOf(json.meta).toEqualTypeOf<
        z.output<typeof OrgWebhooks.schema.listWebhookDeliveries.Response>['meta']
      >()
      void json
    }
  })

  test('GET /v1/orgs/:orgId/webhooks/:id/deliveries/:deliveryId', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks[
      ':id{wh_[A-Za-z0-9_-]+}'
    ].deliveries[':deliveryId'].$get({
      param: { deliveryId: 'whd_test', id: 'wh_test', orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.envelope.type).toEqualTypeOf<
        z.output<typeof OrgWebhooks.schema.getWebhookDelivery.Response>['envelope']['type']
      >()
      if (json.envelope.type === 'block:created')
        expectTypeOf(json.envelope.data.number).toEqualTypeOf<number>()
      if (json.envelope.type === 'funding:deposit.updated')
        expectTypeOf(json.envelope.data.status).toEqualTypeOf<
          z.output<typeof Webhooks.schema.FundingDepositEvent>['status']
        >()
      if (json.envelope.type === 'funding:transfer.updated')
        expectTypeOf(json.envelope.data.status).toEqualTypeOf<
          z.output<typeof Webhooks.schema.FundingTransferEvent>['status']
        >()
      expectTypeOf(json.requestUrl).toEqualTypeOf<string>()
      void json
    }
    if (res.status === 404) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<
        | 'delivery_not_found'
        | 'organization_not_found'
        | 'webhook_not_found'
        | 'webhooks_not_enabled'
      >()
    }
  })

  test('POST /v1/orgs/:orgId/webhooks/:id/deliveries/:deliveryId/retry', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks[
      ':id{wh_[A-Za-z0-9_-]+}'
    ].deliveries[':deliveryId'].retry.$post({
      param: { deliveryId: 'whd_test', id: 'wh_test', orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.eventId).toEqualTypeOf<
        z.output<typeof OrgWebhooks.schema.retryWebhookDelivery.Response>['eventId']
      >()
      void json
    }
    if (res.status === 403) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
    }
  })

  test('PATCH /v1/orgs/:orgId/webhooks/:id', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks[
      ':id{wh_[A-Za-z0-9_-]+}'
    ].$patch({
      json: { status: 'paused' },
      param: { id: 'wh_test', orgId: 'org_test' },
    })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json.status).toEqualTypeOf<
        z.output<typeof OrgWebhooks.schema.Subscription>['status']
      >()
    }
    if (res.status === 403) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
    }
  })

  test('DELETE /v1/orgs/:orgId/webhooks/:id', async () => {
    const client = Client.create()
    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].webhooks[
      ':id{wh_[A-Za-z0-9_-]+}'
    ].$delete({ param: { id: 'wh_test', orgId: 'org_test' } })

    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 502>()

    if (res.status === 200) {
      const json = await res.json()
      expectTypeOf(json).toEqualTypeOf<z.output<typeof OrgWebhooks.schema.DeleteResponse>>()
    }
    if (res.status === 403) {
      const json = await res.json()
      expectTypeOf(json.error.code).toEqualTypeOf<'forbidden'>()
    }
  })
})