tapimo 0.0.0 → 0.0.2

package/src/Client.test-d.ts

@@ -0,0 +1,1438 @@
+import { Client } from 'cadent'
+import type * as z from 'zod/mini'
+
+import * as Activities from './apps/activities.js'
+import * as Balances from './apps/balances.js'
+import * as Blocks from './apps/blocks.js'
+import * as Exchanges from './apps/exchanges.js'
+import * as FeeAmm from './apps/fee-amm.js'
+import * as Indexer from './apps/indexer.js'
+import * as Receipts from './apps/receipts.js'
+import * as Rpc from './apps/rpc.js'
+import * as Tokens from './apps/tokens.js'
+import * as Transactions from './apps/transactions.js'
+import * as Transfers from './apps/transfers.js'
+import * as VerifiedTokens from './apps/verified-tokens.js'
+import * as Webhooks from './apps/webhooks.js'
+
+type Access400<code extends string> = code | 'api_key_malformed'
+type PaidAccessStatus = PublicAccessStatus | 402
+type PublicAccessStatus = 400 | 401 | 403 | 429
+
+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
+})
+
+describe('narrows responses by status', () => {
+  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'>()
+        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/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()
+
+    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
+        >()
+        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',
+      },
+    })
+
+    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.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()
+
+    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']
+        >()
+        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',
+      },
+    })
+
+    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']
+        >()
+        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',
+      },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.data[0]!.type).toEqualTypeOf<
+          z.output<
+            typeof Activities.schema.getTransactionActivities.Response
+          >['data'][number]['type']
+        >()
+        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/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' },
+    })
+
+    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']
+        >()
+        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' },
+    })
+
+    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>()
+        // `feeEligible` is best-effort, so it is an optional boolean.
+        expectTypeOf(json.data[0]!.feeEligible).toEqualTypeOf<boolean | undefined>()
+        expectTypeOf(json.data[0]!.token).toEqualTypeOf<
+          z.output<typeof Balances.schema.getAddressBalances.Response>['data'][number]['token']
+        >()
+        // `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/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']
+        >()
+        // `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/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']
+        >()
+        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/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]!.userToken.amount).toEqualTypeOf<
+          z.output<typeof FeeAmm.schema.getFeeAmmPools.Token>['amount']
+        >()
+        expectTypeOf(json.data[0]!.validatorToken.formatted).toEqualTypeOf<
+          z.output<typeof FeeAmm.schema.getFeeAmmPools.Token>['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']
+        >()
+        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('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' },
+    })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
+
+    switch (res.status) {
+      case 200: {
+        const json = await res.json()
+        expectTypeOf(json.data[0]!.type).toEqualTypeOf<
+          z.output<typeof Activities.schema.getAddressActivities.Response>['data'][number]['type']
+        >()
+        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()
+    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.secret).toEqualTypeOf<
+        z.output<typeof Webhooks.schema.createWebhook.Response>['secret']
+      >()
+      void json
+    }
+  })
+
+  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()
+      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()
+      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()
+      expectTypeOf(json.status).toEqualTypeOf<
+        z.output<typeof Webhooks.schema.updateWebhook.Response>['status']
+      >()
+      void json
+    }
+  })
+
+  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
+    }
+  })
+})