tapimo 0.10.2 → 0.12.0

package/src/apps/management/routes/api-keys.ts

@@ -18,76 +18,79 @@ import * as ManagementError from '../Error.js'
 /** Zod schemas owned by the API-keys resource. */
 export namespace schema {
   /** One API key: metadata only — the token appears once, at mint. */
-  export const Key = Schema.describe(
-    z.object({
-      allowedIps: ApiKey.schema.AllowedIps.check(
-        z.describe(
-          'Client IP addresses and CIDR ranges allowed to use this key. An empty list means unrestricted.',
-        ),
-        z.meta({ examples: [['203.0.113.0/24', '2001:db8::1']] }),
-      ),
-      createdAt: z
-        .string()
-        .check(
-          z.describe('When the key was minted (ISO 8601).'),
-          z.meta({ examples: ['2026-01-01T00:00:00.000Z'] }),
-        ),
-      createdBy: z
-        .optional(z.string())
-        .check(
-          z.describe('Identity that minted the key (`usr_…`, or `super_admin`).'),
-          z.meta({ examples: ['usr_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
-        ),
-      environment: z
-        .enum(['production', 'sandbox'])
-        .check(z.describe('Key environment.'), z.meta({ examples: ['sandbox'] })),
-      expiresAt: z
-        .optional(z.string())
-        .check(
-          z.describe('When the key expires (ISO 8601). Absent for a non-expiring key.'),
-          z.meta({ examples: ['2027-01-01T00:00:00.000Z'] }),
-        ),
-      id: z
-        .string()
-        .check(
-          z.describe('Opaque key id (`key_…`).'),
-          z.meta({ examples: ['key_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
-        ),
-      lastUsedAt: z
-        .optional(z.string())
-        .check(
-          z.describe('When the key last authenticated a request (ISO 8601).'),
-          z.meta({ examples: ['2026-07-21T12:34:56.000Z'] }),
-        ),
-      name: z
-        .optional(z.string())
-        .check(z.describe('Human-readable key name.'), z.meta({ examples: ['CI'] })),
-      orgId: z
-        .string()
-        .check(
-          z.describe('Owning organization id (`org_…`).'),
-          z.meta({ examples: ['org_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
-        ),
-      projectId: z.optional(z.string()).check(
-        z.describe('Attributed project id (`prj_…`).'), // prettier-ignore
-        z.meta({ examples: ['prj_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
-      ),
-      scopes: z
-        .array(z.string().check(z.minLength(1)))
-        .check(
+  export const Key = OpenApi.component(
+    Schema.describe(
+      z.object({
+        allowedIps: ApiKey.schema.AllowedIps.check(
           z.describe(
-            "Granted scopes. '*' and non-self-serve scopes appear only on keys minted by the super admin.",
+            'Client IP addresses and CIDR ranges allowed to use this key. An empty list means unrestricted.',
           ),
-          z.meta({ examples: [['data:read']] }),
+          z.meta({ examples: [['203.0.113.0/24', '2001:db8::1']] }),
         ),
-      tokenLast4: z
-        .string()
-        .check(
-          z.describe('Last 4 characters of the plaintext token.'),
-          z.meta({ examples: ['a1b2'] }),
+        createdAt: z.iso
+          .datetime()
+          .check(
+            z.describe('When the key was minted (ISO 8601).'),
+            z.meta({ examples: ['2026-01-01T00:00:00.000Z'] }),
+          ),
+        createdBy: z
+          .optional(z.string())
+          .check(
+            z.describe('Identity that minted the key (`usr_…`, or `super_admin`).'),
+            z.meta({ examples: ['usr_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
+          ),
+        environment: z
+          .enum(['production', 'sandbox'])
+          .check(z.describe('Key environment.'), z.meta({ examples: ['sandbox'] })),
+        expiresAt: z
+          .optional(z.iso.datetime())
+          .check(
+            z.describe('When the key expires (ISO 8601). Absent for a non-expiring key.'),
+            z.meta({ examples: ['2027-01-01T00:00:00.000Z'] }),
+          ),
+        id: z
+          .string()
+          .check(
+            z.describe('Opaque key id (`key_…`).'),
+            z.meta({ examples: ['key_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
+          ),
+        lastUsedAt: z
+          .optional(z.iso.datetime())
+          .check(
+            z.describe('When the key last authenticated a request (ISO 8601).'),
+            z.meta({ examples: ['2026-07-21T12:34:56.000Z'] }),
+          ),
+        name: z
+          .optional(z.string())
+          .check(z.describe('Human-readable key name.'), z.meta({ examples: ['CI'] })),
+        orgId: z
+          .string()
+          .check(
+            z.describe('Owning organization id (`org_…`).'),
+            z.meta({ examples: ['org_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
+          ),
+        projectId: z.optional(z.string()).check(
+          z.describe('Attributed project id (`prj_…`).'), // prettier-ignore
+          z.meta({ examples: ['prj_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
         ),
-    }),
-    'An API key: metadata only — the token appears once, at mint.',
+        scopes: z
+          .array(z.string().check(z.minLength(1)))
+          .check(
+            z.describe(
+              "Granted scopes. '*' and non-self-serve scopes appear only on keys minted by the super admin.",
+            ),
+            z.meta({ examples: [['data:read']] }),
+          ),
+        tokenLast4: z
+          .string()
+          .check(
+            z.describe('Last 4 characters of the plaintext token.'),
+            z.meta({ examples: ['a1b2'] }),
+          ),
+      }),
+      'An API key: metadata only — the token appears once, at mint.',
+    ),
+    'ApiKey',
   )
 
   /** Path parameters addressing a project's key collection. */
@@ -145,52 +148,69 @@ export namespace schema {
     .check(z.describe('Path parameters for one API key.'))
 
   /** Request body minting a key. The wildcard scope is not issuable here. */
-  export const KeyBody = z
-    .object({
-      allowedIps: z
-        .optional(ApiKey.schema.AllowedIps)
-        .check(
-          z.describe(
-            'Client IP addresses and CIDR ranges allowed to use the key. Omit or use an empty list for unrestricted access.',
-          ),
-          z.meta({ examples: [['203.0.113.0/24']] }),
-        ),
-      environment: z
-        ._default(z.enum(['production', 'sandbox']), 'production')
-        .check(z.describe('Key environment.'), z.meta({ examples: ['sandbox'] })),
-      name: z
-        .optional(z.string().check(z.minLength(1), z.maxLength(100)))
-        .check(z.describe('Human-readable key name.'), z.meta({ examples: ['CI'] })),
-      scopes: z
-        ._default(
-          z.array(
-            z.string().check(
-              z.minLength(1),
-              z.refine((scope) => scope !== Scope.wildcard),
+  export const CreateApiKeyRequest = OpenApi.component(
+    z
+      .object({
+        allowedIps: z
+          .optional(ApiKey.schema.AllowedIps)
+          .check(
+            z.describe(
+              'Client IP addresses and CIDR ranges allowed to use the key. Omit or use an empty list for unrestricted access.',
             ),
+            z.meta({ examples: [['203.0.113.0/24']] }),
           ),
-          [],
-        )
-        .check(z.describe('Scopes to grant.'), z.meta({ examples: [['data:read']] })),
-    })
-    .check(z.describe('Fields for minting an API key.'))
+        environment: z
+          ._default(z.enum(['production', 'sandbox']), 'production')
+          .check(z.describe('Key environment.'), z.meta({ examples: ['sandbox'] })),
+        name: z
+          .optional(z.string().check(z.minLength(1), z.maxLength(100)))
+          .check(z.describe('Human-readable key name.'), z.meta({ examples: ['CI'] })),
+        scopes: z
+          ._default(
+            z.array(
+              z.string().check(
+                z.minLength(1),
+                z.refine((scope) => scope !== Scope.wildcard),
+              ),
+            ),
+            [],
+          )
+          .check(z.describe('Scopes to grant.'), z.meta({ examples: [['data:read']] })),
+      })
+      .check(z.describe('Fields for minting an API key.')),
+    'CreateApiKeyRequest',
+  )
 
   /** Schemas for the createApiKey operation. */
   export namespace createApiKey {
     /** The minted key plus its one-time token. */
-    export const Response = Schema.describe(
-      z.extend(Key, {
-        token: z
-          .string()
-          .check(
-            z.describe('The plaintext token — shown once, unrecoverable afterward.'),
-            z.meta({ examples: ['tempo_sandbox:sk:…'] }),
-          ),
-      }),
-      'The minted key, including its one-time token.',
+    export const Response = OpenApi.component(
+      Schema.describe(
+        z.extend(Key, {
+          token: z
+            .string()
+            .check(
+              z.describe('The plaintext token — shown once, unrecoverable afterward.'),
+              z.meta({ examples: ['tempo_sandbox:sk:…'] }),
+            ),
+        }),
+        'The minted key, including its one-time token.',
+      ),
+      'CreateApiKeyResponse',
     )
   }
 
+  /** Non-paginated list of API key metadata. */
+  export const ApiKeyList = OpenApi.component(
+    Schema.describe(
+      z.object({
+        data: z.array(Key).check(z.describe('The API keys, newest first.')),
+      }),
+      'A non-paginated list of API key metadata.',
+    ),
+    'ApiKeyList',
+  )
+
   /** Schemas for the listApiKeys operation. */
   export namespace listApiKeys {
     /** Query parameters filtering a project's keys. */
@@ -199,12 +219,7 @@ export namespace schema {
       .check(z.describe("Query parameters for a project's API keys."))
 
     /** Non-paginated list of a project's keys. */
-    export const Response = Schema.describe(
-      z.object({
-        data: z.array(Key).check(z.describe("The project's keys, newest first.")),
-      }),
-      "A non-paginated list of a project's API keys (metadata only).",
-    )
+    export const Response = ApiKeyList
   }
 
   /** Schemas for the listOrgApiKeys operation. */
@@ -215,44 +230,43 @@ export namespace schema {
       .check(z.describe("Query parameters for an organization's API keys."))
 
     /** Non-paginated list of every key in the organization. */
-    export const Response = Schema.describe(
-      z.object({
-        data: z
-          .array(Key)
-          .check(z.describe("The organization's keys across all projects, newest first.")),
-      }),
-      "A non-paginated list of an organization's API keys (metadata only).",
-    )
+    export const Response = ApiKeyList
   }
 
   /** Schemas for the revokeApiKey operation. */
   export namespace revokeApiKey {
     /** Confirmation that the key was revoked. */
-    export const Response = z
-      .object({
-        id: z
-          .string()
-          .check(
-            z.describe('ID of the key that was revoked.'),
-            z.meta({ examples: ['key_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
-          ),
-      })
-      .check(z.describe('Confirmation that the key was revoked.'))
+    export const Response = OpenApi.component(
+      z
+        .object({
+          id: z
+            .string()
+            .check(
+              z.describe('ID of the key that was revoked.'),
+              z.meta({ examples: ['key_1a2b3c4d5e6f7g8h9j0k1m2n'] }),
+            ),
+        })
+        .check(z.describe('Confirmation that the key was revoked.')),
+      'RevokeApiKeyResponse',
+    )
   }
 
   /** Schemas for the updateApiKey operation. */
   export namespace updateApiKey {
     /** Request body replacing or clearing a key's IP allowlist. */
-    export const Body = z
-      .object({
-        allowedIps: ApiKey.schema.AllowedIps.check(
-          z.describe(
-            'Replacement client IP/CIDR allowlist. Use an empty list for unrestricted access.',
+    export const Body = OpenApi.component(
+      z
+        .object({
+          allowedIps: ApiKey.schema.AllowedIps.check(
+            z.describe(
+              'Replacement client IP/CIDR allowlist. Use an empty list for unrestricted access.',
+            ),
+            z.meta({ examples: [['203.0.113.0/24']] }),
           ),
-          z.meta({ examples: [['203.0.113.0/24']] }),
-        ),
-      })
-      .check(z.describe("Fields for updating an API key's network access."))
+        })
+        .check(z.describe("Fields for updating an API key's network access.")),
+      'UpdateApiKeyRequest',
+    )
   }
 }
 
@@ -271,7 +285,7 @@ export function apiKeys(options: apiKeys.Options = {}) {
         code: 'param_invalid',
         message: 'Check the path parameters and try again.',
       }),
-      OpenApi.validate('json', schema.KeyBody, {
+      OpenApi.validate('json', schema.CreateApiKeyRequest, {
         code: 'body_invalid',
         message: 'Check the request body and try again.',
       }),
@@ -281,11 +295,18 @@ export function apiKeys(options: apiKeys.Options = {}) {
         operationId: 'createApiKey',
         responses: OpenApi.responses({
           errors: {
+            400: {
+              codes: ['body_invalid', 'param_invalid'],
+              description: 'Malformed API key, invalid path, or invalid body.',
+            },
             403: {
               codes: ['scope_not_issuable'],
               description: 'The requested scopes are not issuable.',
             },
-            404: 'No accessible project was found for this id.',
+            404: {
+              codes: ['api_keys_not_enabled', 'organization_not_found', 'project_not_found'],
+              description: 'No accessible project or API key surface was found.',
+            },
           },
           success: {
             description: 'The minted key, including its one-time token.',
@@ -298,6 +319,7 @@ export function apiKeys(options: apiKeys.Options = {}) {
       async (c) => {
         if (Auth.narrowAccess) return Auth.superAdminAccessError(c)
         if (Auth.narrowScope) return Auth.ensureProjectError(c)
+        if (Auth.narrowOrgRole) return Auth.ensureOrgRoleError(c)
         if (OpenApi.narrowValidation)
           return OpenApi.validationError(c, {
             code: 'param_invalid',
@@ -379,8 +401,14 @@ export function apiKeys(options: apiKeys.Options = {}) {
         operationId: 'listApiKeys',
         responses: OpenApi.responses({
           errors: {
-            400: { codes: ['query_invalid'], description: 'Invalid query parameters.' },
-            404: 'No accessible project was found for this id.',
+            400: {
+              codes: ['param_invalid', 'query_invalid'],
+              description: 'Malformed API key, invalid path, or invalid query.',
+            },
+            404: {
+              codes: ['api_keys_not_enabled', 'organization_not_found', 'project_not_found'],
+              description: 'No accessible project or API key surface was found.',
+            },
           },
           success: {
             description: "The project's keys, newest first (metadata only).",
@@ -441,8 +469,14 @@ export function apiKeys(options: apiKeys.Options = {}) {
         operationId: 'listOrgApiKeys',
         responses: OpenApi.responses({
           errors: {
-            400: { codes: ['query_invalid'], description: 'Invalid query parameters.' },
-            404: 'No accessible organization was found for this id.',
+            400: {
+              codes: ['param_invalid', 'query_invalid'],
+              description: 'Malformed API key, invalid path, or invalid query.',
+            },
+            404: {
+              codes: ['api_keys_not_enabled', 'organization_not_found'],
+              description: 'No accessible organization or API key surface was found.',
+            },
           },
           success: {
             description: "The organization's keys across all projects, newest first (metadata only).", // prettier-ignore
@@ -504,7 +538,19 @@ export function apiKeys(options: apiKeys.Options = {}) {
         operationId: 'updateApiKey',
         responses: OpenApi.responses({
           errors: {
-            404: 'No accessible API key was found for this id.',
+            400: {
+              codes: ['body_invalid', 'param_invalid'],
+              description: 'Malformed API key, invalid path, or invalid body.',
+            },
+            404: {
+              codes: [
+                'api_key_not_found',
+                'api_keys_not_enabled',
+                'organization_not_found',
+                'project_not_found',
+              ],
+              description: 'No accessible API key or API key surface was found.',
+            },
           },
           success: {
             description: 'The updated API key metadata.',
@@ -517,6 +563,7 @@ export function apiKeys(options: apiKeys.Options = {}) {
       async (c) => {
         if (Auth.narrowAccess) return Auth.accessError(c)
         if (Auth.narrowScope) return Auth.ensureProjectError(c)
+        if (Auth.narrowOrgRole) return Auth.ensureOrgRoleError(c)
         if (OpenApi.narrowValidation)
           return OpenApi.validationError(c, {
             code: 'param_invalid',
@@ -561,7 +608,18 @@ export function apiKeys(options: apiKeys.Options = {}) {
         hide: hidden,
         operationId: 'revokeApiKey',
         responses: OpenApi.responses({
-          errors: { 404: 'No accessible API key was found for this id.' },
+          errors: {
+            400: { codes: ['param_invalid'], description: 'Malformed API key or invalid path.' },
+            404: {
+              codes: [
+                'api_key_not_found',
+                'api_keys_not_enabled',
+                'organization_not_found',
+                'project_not_found',
+              ],
+              description: 'No accessible API key or API key surface was found.',
+            },
+          },
           success: {
             description: 'Confirmation that the key was revoked.',
             schema: schema.revokeApiKey.Response,
@@ -573,6 +631,7 @@ export function apiKeys(options: apiKeys.Options = {}) {
       async (c) => {
         if (Auth.narrowAccess) return Auth.accessError(c)
         if (Auth.narrowScope) return Auth.ensureProjectError(c)
+        if (Auth.narrowOrgRole) return Auth.ensureOrgRoleError(c)
         if (OpenApi.narrowValidation)
           return OpenApi.validationError(c, {
             code: 'param_invalid',

package/src/apps/management/routes/billing.test.ts

@@ -77,6 +77,215 @@ function createApp(
   })
 }
 
+test('publishes generator-ready OpenAPI contracts', async () => {
+  const spec = await (await createApp().request('/openapi.json')).json()
+  const billing = spec.paths['/v1/orgs/{orgId}/billing']
+  const checkout = spec.paths['/v1/orgs/{orgId}/billing/stripe/checkout'].post
+  const manage = spec.paths['/v1/orgs/{orgId}/billing/stripe/manage'].post
+  const methods = spec.paths['/v1/orgs/{orgId}/billing/payment-methods'].get
+  const remove = spec.paths['/v1/orgs/{orgId}/billing/payment-methods/{methodId}'].delete
+
+  expect({
+    checkout: {
+      errors: {
+        400: checkout.responses[400].content['application/json'].schema,
+        403: checkout.responses[403].content['application/json'].schema,
+        404: checkout.responses[404].content['application/json'].schema,
+        501: checkout.responses[501].content['application/json'].schema,
+      },
+      operationId: checkout.operationId,
+      response: checkout.responses[200].content['application/json'].schema,
+    },
+    components: [
+      'Billing',
+      'BillingPaymentMethod',
+      'BillingPaymentMethodList',
+      'BillingSession',
+      'BillingSpendLimit',
+      'BillingTransactionFeeLimit',
+      'UpdateBillingRequest',
+    ].filter((name) => spec.components.schemas[name]),
+    get: {
+      errors: {
+        400: billing.get.responses[400].content['application/json'].schema,
+        404: billing.get.responses[404].content['application/json'].schema,
+      },
+      operationId: billing.get.operationId,
+      response: billing.get.responses[200].content['application/json'].schema,
+    },
+    manage: {
+      errors: {
+        400: manage.responses[400].content['application/json'].schema,
+        403: manage.responses[403].content['application/json'].schema,
+        404: manage.responses[404].content['application/json'].schema,
+        501: manage.responses[501].content['application/json'].schema,
+      },
+      operationId: manage.operationId,
+      response: manage.responses[200].content['application/json'].schema,
+    },
+    methods: {
+      errors: {
+        400: methods.responses[400].content['application/json'].schema,
+        404: methods.responses[404].content['application/json'].schema,
+        501: methods.responses[501].content['application/json'].schema,
+      },
+      operationId: methods.operationId,
+      response: methods.responses[200].content['application/json'].schema,
+    },
+    remove: {
+      errors: {
+        400: remove.responses[400].content['application/json'].schema,
+        403: remove.responses[403].content['application/json'].schema,
+        404: remove.responses[404].content['application/json'].schema,
+        501: remove.responses[501].content['application/json'].schema,
+      },
+      operationId: remove.operationId,
+      response: remove.responses[200].content['application/json'].schema,
+    },
+    timestamps: {
+      billing: spec.components.schemas.Billing.properties.updatedAt.format,
+      paymentMethod: spec.components.schemas.BillingPaymentMethod.properties.createdAt.format,
+    },
+    update: {
+      errors: {
+        400: billing.patch.responses[400].content['application/json'].schema,
+        403: billing.patch.responses[403].content['application/json'].schema,
+        404: billing.patch.responses[404].content['application/json'].schema,
+      },
+      operationId: billing.patch.operationId,
+      request: billing.patch.requestBody.content['application/json'].schema,
+      response: billing.patch.responses[200].content['application/json'].schema,
+    },
+  }).toMatchInlineSnapshot(`
+    {
+      "checkout": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidOrQueryInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ApiKeyForbiddenOrApiKeyIpForbiddenOrBillingSourceDisabledOrForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/OrganizationNotFoundError",
+          },
+          "501": {
+            "$ref": "#/components/schemas/NotImplementedError",
+          },
+        },
+        "operationId": "createStripeCheckout",
+        "response": {
+          "$ref": "#/components/schemas/BillingSession",
+        },
+      },
+      "components": [
+        "Billing",
+        "BillingPaymentMethod",
+        "BillingPaymentMethodList",
+        "BillingSession",
+        "BillingSpendLimit",
+        "BillingTransactionFeeLimit",
+        "UpdateBillingRequest",
+      ],
+      "get": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidOrQueryInvalidError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/OrganizationNotFoundError",
+          },
+        },
+        "operationId": "getBilling",
+        "response": {
+          "$ref": "#/components/schemas/Billing",
+        },
+      },
+      "manage": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidOrQueryInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/BillingNotFoundOrOrganizationNotFoundError",
+          },
+          "501": {
+            "$ref": "#/components/schemas/NotImplementedError",
+          },
+        },
+        "operationId": "createStripeManage",
+        "response": {
+          "$ref": "#/components/schemas/BillingSession",
+        },
+      },
+      "methods": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidOrQueryInvalidError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/OrganizationNotFoundError",
+          },
+          "501": {
+            "$ref": "#/components/schemas/NotImplementedError",
+          },
+        },
+        "operationId": "getBillingPaymentMethods",
+        "response": {
+          "$ref": "#/components/schemas/BillingPaymentMethodList",
+        },
+      },
+      "remove": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrParamInvalidOrQueryInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/BillingNotFoundOrOrganizationNotFoundOrPaymentMethodNotFoundError",
+          },
+          "501": {
+            "$ref": "#/components/schemas/NotImplementedError",
+          },
+        },
+        "operationId": "deleteBillingPaymentMethod",
+        "response": {
+          "$ref": "#/components/schemas/Billing",
+        },
+      },
+      "timestamps": {
+        "billing": "date-time",
+        "paymentMethod": "date-time",
+      },
+      "update": {
+        "errors": {
+          "400": {
+            "$ref": "#/components/schemas/ApiKeyMalformedOrBodyInvalidOrParamInvalidOrQueryInvalidError",
+          },
+          "403": {
+            "$ref": "#/components/schemas/ForbiddenError",
+          },
+          "404": {
+            "$ref": "#/components/schemas/OrganizationNotFoundError",
+          },
+        },
+        "operationId": "updateBilling",
+        "request": {
+          "$ref": "#/components/schemas/UpdateBillingRequest",
+        },
+        "response": {
+          "$ref": "#/components/schemas/Billing",
+        },
+      },
+    }
+  `)
+})
+
 /** RequestInit presenting the given token. */
 function as(token: string) {
   return { headers: { 'tempo-api-key': token } } as const