tapimo 0.5.3 → 0.7.0

package/src/Client.test-d.ts

@@ -1,4 +1,5 @@
 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'
@@ -6,23 +7,49 @@ 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 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 Funding from './apps/data/routes/funding.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'
 
 type Access400<code extends string> = code | 'api_key_malformed'
 type PaidAccessStatus = PublicAccessStatus | 402
 type PublicAccessStatus = 400 | 401 | 403 | 429
+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()
@@ -41,9 +68,49 @@ test('returns typed client', async () => {
 
   const typed: Client.Client = client
   void typed
+
+  expectTypeOf<PublicMpp.RelayInput>().toEqualTypeOf<Mpp.RelayInput>()
 })
 
 describe('narrows responses by status', () => {
+  test('POST /v1/mpp/verify', async () => {
+    const client = Client.create()
+    const res = await client.v1.mpp.verify.$post({ json: mppInput })
+
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 429 | 503>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<Mpp.VerifyResponse>()
+      return
+    }
+
+    if (res.status === 503) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<Mpp.Unavailable>()
+      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 | 503>()
+
+    if (res.status === 200) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<Mpp.BroadcastResponse>()
+      return
+    }
+
+    if (res.status === 503) {
+      const json = await res.json()
+      expectTypeOf(json).toEqualTypeOf<Mpp.Unavailable>()
+      return
+    }
+  })
+
   test('GET /v1/blocks', async () => {
     const client = Client.create()
     const res = await client.v1.blocks.$get()
@@ -200,24 +267,57 @@ describe('narrows responses by status', () => {
     }
   })
 
-  test('GET /v1/orgs/:orgId/billing', async () => {
+  test('POST /v1/orgs/:orgId/faucet', async () => {
     const client = Client.create()
-    const res = await client.v1.orgs[':orgId{org_[A-Za-z0-9_-]+}'].billing.$get({
+    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 | 404 | 501 | 502 | PublicAccessStatus>()
+    expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 401 | 403 | 404 | 429 | 502>()
 
     switch (res.status) {
       case 200: {
         const json = await res.json()
-        expectTypeOf(json.status).toEqualTypeOf<z.output<typeof Billing.schema.Billing>['status']>()
+        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 501: {
+      case 429: {
         const json = await res.json()
-        expectTypeOf(json.error.code).toEqualTypeOf<'billing_unconfigured'>()
+        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
       }
@@ -236,6 +336,7 @@ describe('narrows responses by 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
@@ -257,11 +358,12 @@ describe('narrows responses by status', () => {
       param: { orgId: 'org_test' },
     })
 
-    expectTypeOf(res.status).toEqualTypeOf<200 | 404 | 501 | 502 | PublicAccessStatus>()
+    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
         >()
@@ -269,9 +371,35 @@ describe('narrows responses by status', () => {
         void json
         return
       }
-      case 501: {
+    }
+  })
+
+  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.error.code).toEqualTypeOf<'billing_unconfigured'>()
+        expectTypeOf(json.url).toEqualTypeOf<string>()
+        void json
+        return
+      }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<
+          'api_key_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
       }
@@ -388,6 +516,112 @@ describe('narrows responses by status', () => {
     }
   })
 
+  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[
@@ -459,6 +693,12 @@ describe('narrows responses by status', () => {
         void json
         return
       }
+      case 403: {
+        const json = await res.json()
+        expectTypeOf(json.error.code).toEqualTypeOf<'forbidden' | 'scope_not_issuable'>()
+        void json
+        return
+      }
     }
   })
 
@@ -581,6 +821,48 @@ describe('narrows responses by status', () => {
     }
   })
 
+  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>()
+
+    if (res.status === 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
+    }
+  })
+
+  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({
@@ -701,7 +983,9 @@ describe('narrows responses by status', () => {
 
   test('GET /v1/transactions', async () => {
     const client = Client.create()
-    const res = await client.v1.transactions.$get()
+    const res = await client.v1.transactions.$get({
+      query: { include: 'feeToken.logoUri,feeToken.verified' },
+    })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
 
@@ -717,6 +1001,12 @@ describe('narrows responses by status', () => {
         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
       }
@@ -743,6 +1033,7 @@ describe('narrows responses by status', () => {
       param: {
         transactionHash: '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665',
       },
+      query: { include: 'feeToken.logoUri,feeToken.verified' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
@@ -756,6 +1047,10 @@ describe('narrows responses by status', () => {
         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']
         >()
@@ -790,7 +1085,9 @@ describe('narrows responses by status', () => {
 
   test('GET /v1/transactions/receipts', async () => {
     const client = Client.create()
-    const res = await client.v1.transactions.receipts.$get()
+    const res = await client.v1.transactions.receipts.$get({
+      query: { include: 'feeToken.logoUri,feeToken.verified' },
+    })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
 
@@ -800,6 +1097,10 @@ describe('narrows responses by status', () => {
         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
       }
@@ -826,6 +1127,7 @@ describe('narrows responses by status', () => {
       param: {
         transactionHash: '0x515801d7f9a5ac705e793e85904c9c69b3f1694b465cc8fb6ba3f0298dc82665',
       },
+      query: { include: 'feeToken.logoUri,feeToken.verified' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
@@ -839,6 +1141,13 @@ describe('narrows responses by status', () => {
         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.pricing).toEqualTypeOf<
+          z.output<typeof Valuation.schema.Pricing> | undefined
+        >()
         void json
         return
       }
@@ -874,6 +1183,7 @@ describe('narrows responses by status', () => {
       param: {
         transactionHash: '0x4845ae2098724ab26a5d89370dce5124d044be6a5acc164afc348662de67d474',
       },
+      query: { include: 'token.logoUri,token.verified' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 404 | 502 | PaidAccessStatus>()
@@ -886,6 +1196,24 @@ describe('narrows responses by status', () => {
             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
       }
@@ -1077,6 +1405,7 @@ describe('narrows responses by status', () => {
     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>()
@@ -1087,6 +1416,9 @@ describe('narrows responses by status', () => {
         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
       }
@@ -1111,6 +1443,7 @@ describe('narrows responses by status', () => {
     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>()
@@ -1122,11 +1455,17 @@ describe('narrows responses by status', () => {
           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).toEqualTypeOf<
-          z.output<typeof Balances.schema.getAddressBalances.Response>['data'][number]['token']
-        >()
+        expectTypeOf(json.data[0]!.token.logoUri).toEqualTypeOf<string | undefined>()
+        expectTypeOf(json.data[0]!.token.verified).toEqualTypeOf<boolean>()
+        // `valuation` is `null` for unverified or unpriceable holdings.
+        expectTypeOf(json.data[0]!.valuation).toEqualTypeOf<{
+          amount: string
+          currency: string
+        } | null>()
         // `meta` (opt-in `include=totalCount` capped count) is optional.
         expectTypeOf(json.meta).toEqualTypeOf<
           z.output<typeof Balances.schema.getAddressBalances.Response>['meta']
@@ -1153,6 +1492,48 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('GET /v1/addresses/:address/valuation', async () => {
+    const client = Client.create()
+    const res = await client.v1.addresses[':address'].valuation.$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.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()
@@ -1171,6 +1552,20 @@ describe('narrows responses by status', () => {
         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']
@@ -1211,14 +1606,32 @@ describe('narrows responses by status', () => {
     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 Funding.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<
-          'across' | 'relay' | 'rhino' | 'squid'
+          'across' | 'relay' | 'rhino' | 'squid' | 'symbiosis'
         >()
         expectTypeOf(json.data[0]!.quote.expiresAt).toEqualTypeOf<string | undefined>()
-        expectTypeOf(json.data[0]!.quote.outputAmount).toEqualTypeOf<string>()
         void json
         return
       }
@@ -1303,6 +1716,14 @@ describe('narrows responses by status', () => {
         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
       }
@@ -1323,6 +1744,90 @@ describe('narrows responses by status', () => {
     }
   })
 
+  test('POST /v1/exchange/quotes', async () => {
+    const client = Client.create()
+    const res = await client.v1.exchange.quotes.$post({
+      json: {
+        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?.pricing).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.transaction.calls[0]!.data).toEqualTypeOf<
+          z.output<
+            typeof Exchanges.schema.createQuote.Response
+          >['transaction']['calls'][number]['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('GET /v1/exchange/pairs', async () => {
     const client = Client.create()
     const res = await client.v1.exchange.pairs.$get()
@@ -1625,12 +2130,16 @@ describe('narrows responses by status', () => {
         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]!.userAmount).toEqualTypeOf<
+          z.output<typeof FeeAmm.schema.getFeeAmmPools.Pool>['userAmount']
         >()
-        expectTypeOf(json.data[0]!.validatorToken.formatted).toEqualTypeOf<
-          z.output<typeof FeeAmm.schema.getFeeAmmPools.Token>['formatted']
+        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
@@ -1902,6 +2411,7 @@ describe('narrows responses by status', () => {
     const client = Client.create()
     const res = await client.v1.addresses[':address'].activities.$get({
       param: { address: '0x0000000000000000000000000000000000000000' },
+      query: { include: 'token.logoUri,token.verified' },
     })
 
     expectTypeOf(res.status).toEqualTypeOf<200 | 400 | 502 | PaidAccessStatus>()
@@ -1912,6 +2422,17 @@ describe('narrows responses by status', () => {
         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
       }
@@ -1971,6 +2492,16 @@ describe('narrows responses by status', () => {
       >()
       void json
     }
+    if (res.status === 400) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<
+        Access400<'body_invalid' | 'chain_id_unsupported' | 'filters_invalid' | 'url_invalid'>
+      >()
+    }
+    if (res.status === 403) {
+      const json = await res.json()
+      expectTypeOf(json.error.code).toEqualTypeOf<'api_key_forbidden' | 'limit_exceeded'>()
+    }
   })
 
   test('GET /v1/webhooks', async () => {
@@ -2095,6 +2626,18 @@ describe('narrows responses by 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 () => {
@@ -2113,4 +2656,174 @@ describe('narrows responses by status', () => {
       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>()
+      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'>()
+    }
+  })
 })