@dokploy/trpc-openapi 0.0.2 → 0.0.4

package/test/generator.test.ts

@@ -1,2897 +0,0 @@
-import { initTRPC } from '@trpc/server';
-import { observable } from '@trpc/server/observable';
-import openAPISchemaValidator from 'openapi-schema-validator';
-import { z } from 'zod';
-
-import {
-  GenerateOpenApiDocumentOptions,
-  OpenApiMeta,
-  generateOpenApiDocument,
-  openApiVersion,
-} from '../src';
-import * as zodUtils from '../src/utils/zod';
-
-// TODO: test for duplicate paths (using getPathRegExp)
-
-const openApiSchemaValidator = new openAPISchemaValidator({ version: openApiVersion });
-
-const t = initTRPC.meta<OpenApiMeta>().context<any>().create();
-
-const defaultDocOpts: GenerateOpenApiDocumentOptions = {
-  title: 'tRPC OpenAPI',
-  version: '1.0.0',
-  baseUrl: 'http://localhost:3000/api',
-};
-
-describe('generator', () => {
-  test('open api version', () => {
-    expect(openApiVersion).toBe('3.0.3');
-  });
-
-  test('with empty router', () => {
-    const appRouter = t.router({});
-
-    const openApiDocument = generateOpenApiDocument(appRouter, {
-      title: 'tRPC OpenAPI',
-      version: '1.0.0',
-      description: 'API documentation',
-      baseUrl: 'http://localhost:3000/api',
-      docsUrl: 'http://localhost:3000/docs',
-      tags: [],
-    });
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument).toMatchInlineSnapshot(`
-      Object {
-        "components": Object {
-          "responses": Object {
-            "error": Object {
-              "content": Object {
-                "application/json": Object {
-                  "schema": Object {
-                    "additionalProperties": false,
-                    "properties": Object {
-                      "code": Object {
-                        "type": "string",
-                      },
-                      "issues": Object {
-                        "items": Object {
-                          "additionalProperties": false,
-                          "properties": Object {
-                            "message": Object {
-                              "type": "string",
-                            },
-                          },
-                          "required": Array [
-                            "message",
-                          ],
-                          "type": "object",
-                        },
-                        "type": "array",
-                      },
-                      "message": Object {
-                        "type": "string",
-                      },
-                    },
-                    "required": Array [
-                      "message",
-                      "code",
-                    ],
-                    "type": "object",
-                  },
-                },
-              },
-              "description": "Error response",
-            },
-          },
-          "securitySchemes": Object {
-            "Authorization": Object {
-              "scheme": "bearer",
-              "type": "http",
-            },
-          },
-        },
-        "externalDocs": Object {
-          "url": "http://localhost:3000/docs",
-        },
-        "info": Object {
-          "description": "API documentation",
-          "title": "tRPC OpenAPI",
-          "version": "1.0.0",
-        },
-        "openapi": "3.0.3",
-        "paths": Object {},
-        "servers": Array [
-          Object {
-            "url": "http://localhost:3000/api",
-          },
-        ],
-        "tags": Array [],
-      }
-    `);
-  });
-
-  test('with missing input', () => {
-    {
-      const appRouter = t.router({
-        noInput: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/no-input' } })
-          .output(z.object({ name: z.string() }))
-          .query(() => ({ name: 'jlalmes' })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.noInput] - Input parser expects a Zod validator');
-    }
-    {
-      const appRouter = t.router({
-        noInput: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/no-input' } })
-          .output(z.object({ name: z.string() }))
-          .mutation(() => ({ name: 'jlalmes' })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[mutation.noInput] - Input parser expects a Zod validator');
-    }
-  });
-
-  test('with missing output', () => {
-    {
-      const appRouter = t.router({
-        noOutput: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/no-output' } })
-          .input(z.object({ name: z.string() }))
-          .query(({ input }) => ({ name: input.name })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.noOutput] - Output parser expects a Zod validator');
-    }
-    {
-      const appRouter = t.router({
-        noOutput: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/no-output' } })
-          .input(z.object({ name: z.string() }))
-          .mutation(({ input }) => ({ name: input.name })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[mutation.noOutput] - Output parser expects a Zod validator');
-    }
-  });
-
-  test('with non-zod parser', () => {
-    {
-      const appRouter = t.router({
-        badInput: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/bad-input' } })
-          .input((arg) => ({ payload: typeof arg === 'string' ? arg : String(arg) }))
-          .output(z.object({ payload: z.string() }))
-          .query(({ input }) => ({ payload: 'Hello world!' })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.badInput] - Input parser expects a Zod validator');
-    }
-    {
-      const appRouter = t.router({
-        badInput: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/bad-input' } })
-          .input(z.object({ payload: z.string() }))
-          .output((arg) => ({ payload: typeof arg === 'string' ? arg : String(arg) }))
-          .query(({ input }) => ({ payload: input.payload })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.badInput] - Output parser expects a Zod validator');
-    }
-  });
-
-  test('with non-object input', () => {
-    {
-      const appRouter = t.router({
-        badInput: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/bad-input' } })
-          .input(z.string())
-          .output(z.null())
-          .query(() => null),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.badInput] - Input parser must be a ZodObject');
-    }
-    {
-      const appRouter = t.router({
-        badInput: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/bad-input' } })
-          .input(z.string())
-          .output(z.null())
-          .mutation(() => null),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[mutation.badInput] - Input parser must be a ZodObject');
-    }
-  });
-
-  test('with object non-string input', () => {
-    // only applies when zod does not support (below version v3.20.0)
-
-    // @ts-expect-error - hack to disable zodSupportsCoerce
-    // eslint-disable-next-line import/namespace
-    zodUtils.zodSupportsCoerce = false;
-
-    {
-      const appRouter = t.router({
-        badInput: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/bad-input' } })
-          .input(z.object({ age: z.number().min(0).max(122) })) // RIP Jeanne Calment
-          .output(z.object({ name: z.string() }))
-          .query(() => ({ name: 'jlalmes' })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.badInput] - Input parser key: "age" must be ZodString');
-    }
-    {
-      const appRouter = t.router({
-        okInput: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/ok-input' } })
-          .input(z.object({ age: z.number().min(0).max(122) }))
-          .output(z.object({ name: z.string() }))
-          .mutation(() => ({ name: 'jlalmes' })),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/ok-input']!.post!.requestBody).toMatchInlineSnapshot(`
-        Object {
-          "content": Object {
-            "application/json": Object {
-              "example": undefined,
-              "schema": Object {
-                "additionalProperties": false,
-                "properties": Object {
-                  "age": Object {
-                    "maximum": 122,
-                    "minimum": 0,
-                    "type": "number",
-                  },
-                },
-                "required": Array [
-                  "age",
-                ],
-                "type": "object",
-              },
-            },
-          },
-          "required": true,
-        }
-      `);
-    }
-
-    // @ts-expect-error - hack to re-enable zodSupportsCoerce
-    // eslint-disable-next-line import/namespace
-    zodUtils.zodSupportsCoerce = true;
-  });
-
-  test('with bad method', () => {
-    const appRouter = t.router({
-      badMethod: t.procedure
-        // @ts-expect-error - bad method
-        .meta({ openapi: { method: 'BAD_METHOD', path: '/bad-method' } })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ name: z.string() }))
-        .query(({ input }) => ({ name: input.name })),
-    });
-
-    expect(() => {
-      generateOpenApiDocument(appRouter, defaultDocOpts);
-    }).toThrowError('[query.badMethod] - Method must be GET, POST, PATCH, PUT or DELETE');
-  });
-
-  test('with duplicate routes', () => {
-    {
-      const appRouter = t.router({
-        procedure1: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/procedure' } })
-          .input(z.object({ name: z.string() }))
-          .output(z.object({ name: z.string() }))
-          .query(({ input }) => ({ name: input.name })),
-        procedure2: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/procedure' } })
-          .input(z.object({ name: z.string() }))
-          .output(z.object({ name: z.string() }))
-          .query(({ input }) => ({ name: input.name })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.procedure2] - Duplicate procedure defined for route GET /procedure');
-    }
-    {
-      const appRouter = t.router({
-        procedure1: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/procedure/' } })
-          .input(z.object({ name: z.string() }))
-          .output(z.object({ name: z.string() }))
-          .query(({ input }) => ({ name: input.name })),
-        procedure2: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/procedure' } })
-          .input(z.object({ name: z.string() }))
-          .output(z.object({ name: z.string() }))
-          .query(({ input }) => ({ name: input.name })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.procedure2] - Duplicate procedure defined for route GET /procedure');
-    }
-  });
-
-  test('with unsupported subscription', () => {
-    const appRouter = t.router({
-      currentName: t.procedure
-        .meta({ openapi: { method: 'PATCH', path: '/current-name' } })
-        .input(z.object({ name: z.string() }))
-        .subscription(({ input }) => {
-          return observable((emit) => {
-            emit.next(input.name);
-            return () => null;
-          });
-        }),
-    });
-
-    expect(() => {
-      generateOpenApiDocument(appRouter, defaultDocOpts);
-    }).toThrowError('[subscription.currentName] - Subscriptions are not supported by OpenAPI v3');
-  });
-
-  test('with void and path parameters', () => {
-    const appRouter = t.router({
-      pathParameters: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/path-parameters/{name}' } })
-        .input(z.void())
-        .output(z.object({ name: z.string() }))
-        .query(() => ({ name: 'asdf' })),
-    });
-
-    expect(() => {
-      generateOpenApiDocument(appRouter, defaultDocOpts);
-    }).toThrowError('[query.pathParameters] - Input parser must be a ZodObject');
-  });
-
-  test('with optional path parameters', () => {
-    const appRouter = t.router({
-      pathParameters: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/path-parameters/{name}' } })
-        .input(z.object({ name: z.string().optional() }))
-        .output(z.object({ name: z.string() }))
-        .query(() => ({ name: 'asdf' })),
-    });
-
-    expect(() => {
-      generateOpenApiDocument(appRouter, defaultDocOpts);
-    }).toThrowError('[query.pathParameters] - Path parameter: "name" must not be optional');
-  });
-
-  test('with missing path parameters', () => {
-    const appRouter = t.router({
-      pathParameters: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/path-parameters/{name}' } })
-        .input(z.object({}))
-        .output(z.object({ name: z.string() }))
-        .query(() => ({ name: 'asdf' })),
-    });
-
-    expect(() => {
-      generateOpenApiDocument(appRouter, defaultDocOpts);
-    }).toThrowError('[query.pathParameters] - Input parser expects key from path: "name"');
-  });
-
-  // test for https://github.com/jlalmes/trpc-openapi/issues/296
-  test('with post & only path paramters', () => {
-    const appRouter = t.router({
-      noBody: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/no-body/{name}' } })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ name: z.string() }))
-        .mutation(({ input }) => ({ name: input.name })),
-      emptyBody: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/empty-body' } })
-        .input(z.object({}))
-        .output(z.object({ name: z.string() }))
-        .mutation(() => ({ name: 'James' })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/no-body/{name}']!.post!.requestBody).toBe(undefined);
-    expect(openApiDocument.paths['/empty-body']!.post!.requestBody).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {},
-              "type": "object",
-            },
-          },
-        },
-        "required": true,
-      }
-    `);
-  });
-
-  test('with valid procedures', () => {
-    const appRouter = t.router({
-      createUser: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/users' } })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ id: z.string(), name: z.string() }))
-        .mutation(({ input }) => ({ id: 'user-id', name: input.name })),
-      readUsers: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/users' } })
-        .input(z.void())
-        .output(z.array(z.object({ id: z.string(), name: z.string() })))
-        .query(() => [{ id: 'user-id', name: 'name' }]),
-      readUser: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/users/{id}' } })
-        .input(z.object({ id: z.string() }))
-        .output(z.object({ id: z.string(), name: z.string() }))
-        .query(({ input }) => ({ id: input.id, name: 'name' })),
-      updateUser: t.procedure
-        .meta({ openapi: { method: 'PATCH', path: '/users/{id}' } })
-        .input(z.object({ id: z.string(), name: z.string().optional() }))
-        .output(z.object({ id: z.string(), name: z.string() }))
-        .mutation(({ input }) => ({ id: input.id, name: input.name ?? 'name' })),
-      deleteUser: t.procedure
-        .meta({ openapi: { method: 'DELETE', path: '/users/{id}' } })
-        .input(z.object({ id: z.string() }))
-        .output(z.void())
-        .mutation(() => undefined),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument).toMatchInlineSnapshot(`
-      Object {
-        "components": Object {
-          "responses": Object {
-            "error": Object {
-              "content": Object {
-                "application/json": Object {
-                  "schema": Object {
-                    "additionalProperties": false,
-                    "properties": Object {
-                      "code": Object {
-                        "type": "string",
-                      },
-                      "issues": Object {
-                        "items": Object {
-                          "additionalProperties": false,
-                          "properties": Object {
-                            "message": Object {
-                              "type": "string",
-                            },
-                          },
-                          "required": Array [
-                            "message",
-                          ],
-                          "type": "object",
-                        },
-                        "type": "array",
-                      },
-                      "message": Object {
-                        "type": "string",
-                      },
-                    },
-                    "required": Array [
-                      "message",
-                      "code",
-                    ],
-                    "type": "object",
-                  },
-                },
-              },
-              "description": "Error response",
-            },
-          },
-          "securitySchemes": Object {
-            "Authorization": Object {
-              "scheme": "bearer",
-              "type": "http",
-            },
-          },
-        },
-        "externalDocs": undefined,
-        "info": Object {
-          "description": undefined,
-          "title": "tRPC OpenAPI",
-          "version": "1.0.0",
-        },
-        "openapi": "3.0.3",
-        "paths": Object {
-          "/users": Object {
-            "get": Object {
-              "description": undefined,
-              "operationId": "readUsers",
-              "parameters": Array [],
-              "requestBody": undefined,
-              "responses": Object {
-                "200": Object {
-                  "content": Object {
-                    "application/json": Object {
-                      "example": undefined,
-                      "schema": Object {
-                        "items": Object {
-                          "additionalProperties": false,
-                          "properties": Object {
-                            "id": Object {
-                              "type": "string",
-                            },
-                            "name": Object {
-                              "type": "string",
-                            },
-                          },
-                          "required": Array [
-                            "id",
-                            "name",
-                          ],
-                          "type": "object",
-                        },
-                        "type": "array",
-                      },
-                    },
-                  },
-                  "description": "Successful response",
-                  "headers": undefined,
-                },
-                "default": Object {
-                  "$ref": "#/components/responses/error",
-                },
-              },
-              "security": undefined,
-              "summary": undefined,
-              "tags": undefined,
-            },
-            "post": Object {
-              "description": undefined,
-              "operationId": "createUser",
-              "parameters": Array [],
-              "requestBody": Object {
-                "content": Object {
-                  "application/json": Object {
-                    "example": undefined,
-                    "schema": Object {
-                      "additionalProperties": false,
-                      "properties": Object {
-                        "name": Object {
-                          "type": "string",
-                        },
-                      },
-                      "required": Array [
-                        "name",
-                      ],
-                      "type": "object",
-                    },
-                  },
-                },
-                "required": true,
-              },
-              "responses": Object {
-                "200": Object {
-                  "content": Object {
-                    "application/json": Object {
-                      "example": undefined,
-                      "schema": Object {
-                        "additionalProperties": false,
-                        "properties": Object {
-                          "id": Object {
-                            "type": "string",
-                          },
-                          "name": Object {
-                            "type": "string",
-                          },
-                        },
-                        "required": Array [
-                          "id",
-                          "name",
-                        ],
-                        "type": "object",
-                      },
-                    },
-                  },
-                  "description": "Successful response",
-                  "headers": undefined,
-                },
-                "default": Object {
-                  "$ref": "#/components/responses/error",
-                },
-              },
-              "security": undefined,
-              "summary": undefined,
-              "tags": undefined,
-            },
-          },
-          "/users/{id}": Object {
-            "delete": Object {
-              "description": undefined,
-              "operationId": "deleteUser",
-              "parameters": Array [
-                Object {
-                  "description": undefined,
-                  "example": undefined,
-                  "in": "path",
-                  "name": "id",
-                  "required": true,
-                  "schema": Object {
-                    "type": "string",
-                  },
-                },
-              ],
-              "requestBody": undefined,
-              "responses": Object {
-                "200": Object {
-                  "content": Object {
-                    "application/json": Object {
-                      "example": undefined,
-                      "schema": Object {},
-                    },
-                  },
-                  "description": "Successful response",
-                  "headers": undefined,
-                },
-                "default": Object {
-                  "$ref": "#/components/responses/error",
-                },
-              },
-              "security": undefined,
-              "summary": undefined,
-              "tags": undefined,
-            },
-            "get": Object {
-              "description": undefined,
-              "operationId": "readUser",
-              "parameters": Array [
-                Object {
-                  "description": undefined,
-                  "example": undefined,
-                  "in": "path",
-                  "name": "id",
-                  "required": true,
-                  "schema": Object {
-                    "type": "string",
-                  },
-                },
-              ],
-              "requestBody": undefined,
-              "responses": Object {
-                "200": Object {
-                  "content": Object {
-                    "application/json": Object {
-                      "example": undefined,
-                      "schema": Object {
-                        "additionalProperties": false,
-                        "properties": Object {
-                          "id": Object {
-                            "type": "string",
-                          },
-                          "name": Object {
-                            "type": "string",
-                          },
-                        },
-                        "required": Array [
-                          "id",
-                          "name",
-                        ],
-                        "type": "object",
-                      },
-                    },
-                  },
-                  "description": "Successful response",
-                  "headers": undefined,
-                },
-                "default": Object {
-                  "$ref": "#/components/responses/error",
-                },
-              },
-              "security": undefined,
-              "summary": undefined,
-              "tags": undefined,
-            },
-            "patch": Object {
-              "description": undefined,
-              "operationId": "updateUser",
-              "parameters": Array [
-                Object {
-                  "description": undefined,
-                  "example": undefined,
-                  "in": "path",
-                  "name": "id",
-                  "required": true,
-                  "schema": Object {
-                    "type": "string",
-                  },
-                },
-              ],
-              "requestBody": Object {
-                "content": Object {
-                  "application/json": Object {
-                    "example": undefined,
-                    "schema": Object {
-                      "additionalProperties": false,
-                      "properties": Object {
-                        "name": Object {
-                          "type": "string",
-                        },
-                      },
-                      "type": "object",
-                    },
-                  },
-                },
-                "required": true,
-              },
-              "responses": Object {
-                "200": Object {
-                  "content": Object {
-                    "application/json": Object {
-                      "example": undefined,
-                      "schema": Object {
-                        "additionalProperties": false,
-                        "properties": Object {
-                          "id": Object {
-                            "type": "string",
-                          },
-                          "name": Object {
-                            "type": "string",
-                          },
-                        },
-                        "required": Array [
-                          "id",
-                          "name",
-                        ],
-                        "type": "object",
-                      },
-                    },
-                  },
-                  "description": "Successful response",
-                  "headers": undefined,
-                },
-                "default": Object {
-                  "$ref": "#/components/responses/error",
-                },
-              },
-              "security": undefined,
-              "summary": undefined,
-              "tags": undefined,
-            },
-          },
-        },
-        "servers": Array [
-          Object {
-            "url": "http://localhost:3000/api",
-          },
-        ],
-        "tags": undefined,
-      }
-    `);
-  });
-
-  test('with disabled', () => {
-    const appRouter = t.router({
-      getMe: t.procedure
-        .meta({ openapi: { enabled: false, method: 'GET', path: '/me' } })
-        .input(z.object({ id: z.string() }))
-        .output(z.object({ id: z.string() }))
-        .query(({ input }) => ({ id: input.id })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(Object.keys(openApiDocument.paths).length).toBe(0);
-  });
-
-  test('with summary, description & tags', () => {
-    const appRouter = t.router({
-      getMe: t.procedure
-        .meta({
-          openapi: {
-            method: 'GET',
-            path: '/metadata/all',
-            summary: 'Short summary',
-            description: 'Verbose description',
-            tags: ['tagA', 'tagB'],
-          },
-        })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ name: z.string() }))
-        .query(({ input }) => ({ name: input.name })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/metadata/all']!.get!.summary).toBe('Short summary');
-    expect(openApiDocument.paths['/metadata/all']!.get!.description).toBe('Verbose description');
-    expect(openApiDocument.paths['/metadata/all']!.get!.tags).toEqual(['tagA', 'tagB']);
-  });
-
-  test('with security', () => {
-    const appRouter = t.router({
-      protectedEndpoint: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/secure/endpoint', protect: true } })
-        .input(z.object({ name: z.string() }))
-        .output(z.object({ name: z.string() }))
-        .query(({ input }) => ({ name: input.name })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/secure/endpoint']!.post!.security).toEqual([
-      { Authorization: [] },
-    ]);
-  });
-
-  test('with schema descriptions', () => {
-    const appRouter = t.router({
-      createUser: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/user' } })
-        .input(
-          z
-            .object({
-              id: z.string().uuid().describe('User ID'),
-              name: z.string().describe('User name'),
-            })
-            .describe('Request body input'),
-        )
-        .output(
-          z
-            .object({
-              id: z.string().uuid().describe('User ID'),
-              name: z.string().describe('User name'),
-            })
-            .describe('User data'),
-        )
-        .mutation(({ input }) => ({ id: input.id, name: 'James' })),
-      getUser: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/user' } })
-        .input(
-          z.object({ id: z.string().uuid().describe('User ID') }).describe('Query string inputs'),
-        )
-        .output(
-          z
-            .object({
-              id: z.string().uuid().describe('User ID'),
-              name: z.string().describe('User name'),
-            })
-            .describe('User data'),
-        )
-        .query(({ input }) => ({ id: input.id, name: 'James' })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/user']!.post!).toMatchInlineSnapshot(`
-      Object {
-        "description": undefined,
-        "operationId": "createUser",
-        "parameters": Array [],
-        "requestBody": Object {
-          "content": Object {
-            "application/json": Object {
-              "example": undefined,
-              "schema": Object {
-                "additionalProperties": false,
-                "description": "Request body input",
-                "properties": Object {
-                  "id": Object {
-                    "description": "User ID",
-                    "format": "uuid",
-                    "type": "string",
-                  },
-                  "name": Object {
-                    "description": "User name",
-                    "type": "string",
-                  },
-                },
-                "required": Array [
-                  "id",
-                  "name",
-                ],
-                "type": "object",
-              },
-            },
-          },
-          "required": true,
-        },
-        "responses": Object {
-          "200": Object {
-            "content": Object {
-              "application/json": Object {
-                "example": undefined,
-                "schema": Object {
-                  "additionalProperties": false,
-                  "description": "User data",
-                  "properties": Object {
-                    "id": Object {
-                      "description": "User ID",
-                      "format": "uuid",
-                      "type": "string",
-                    },
-                    "name": Object {
-                      "description": "User name",
-                      "type": "string",
-                    },
-                  },
-                  "required": Array [
-                    "id",
-                    "name",
-                  ],
-                  "type": "object",
-                },
-              },
-            },
-            "description": "Successful response",
-            "headers": undefined,
-          },
-          "default": Object {
-            "$ref": "#/components/responses/error",
-          },
-        },
-        "security": undefined,
-        "summary": undefined,
-        "tags": undefined,
-      }
-    `);
-    expect(openApiDocument.paths['/user']!.get!).toMatchInlineSnapshot(`
-      Object {
-        "description": undefined,
-        "operationId": "getUser",
-        "parameters": Array [
-          Object {
-            "description": "User ID",
-            "example": undefined,
-            "in": "query",
-            "name": "id",
-            "required": true,
-            "schema": Object {
-              "format": "uuid",
-              "type": "string",
-            },
-          },
-        ],
-        "requestBody": undefined,
-        "responses": Object {
-          "200": Object {
-            "content": Object {
-              "application/json": Object {
-                "example": undefined,
-                "schema": Object {
-                  "additionalProperties": false,
-                  "description": "User data",
-                  "properties": Object {
-                    "id": Object {
-                      "description": "User ID",
-                      "format": "uuid",
-                      "type": "string",
-                    },
-                    "name": Object {
-                      "description": "User name",
-                      "type": "string",
-                    },
-                  },
-                  "required": Array [
-                    "id",
-                    "name",
-                  ],
-                  "type": "object",
-                },
-              },
-            },
-            "description": "Successful response",
-            "headers": undefined,
-          },
-          "default": Object {
-            "$ref": "#/components/responses/error",
-          },
-        },
-        "security": undefined,
-        "summary": undefined,
-        "tags": undefined,
-      }
-    `);
-  });
-
-  test('with void', () => {
-    {
-      const appRouter = t.router({
-        void: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/void' } })
-          .input(z.void())
-          .output(z.void())
-          .query(() => undefined),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/void']!.get!.parameters).toEqual([]);
-      expect(openApiDocument.paths['/void']!.get!.responses[200]).toMatchInlineSnapshot(`
-        Object {
-          "content": Object {
-            "application/json": Object {
-              "example": undefined,
-              "schema": Object {},
-            },
-          },
-          "description": "Successful response",
-          "headers": undefined,
-        }
-      `);
-    }
-    {
-      const appRouter = t.router({
-        void: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/void' } })
-          .input(z.void())
-          .output(z.void())
-          .mutation(() => undefined),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/void']!.post!.requestBody).toMatchInlineSnapshot(`undefined`);
-      expect(openApiDocument.paths['/void']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {},
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-    }
-  });
-
-  test('with null', () => {
-    const appRouter = t.router({
-      null: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/null' } })
-        .input(z.void())
-        .output(z.null())
-        .mutation(() => null),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/null']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "enum": Array [
-                "null",
-              ],
-              "nullable": true,
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with undefined', () => {
-    const appRouter = t.router({
-      undefined: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/undefined' } })
-        .input(z.undefined())
-        .output(z.undefined())
-        .mutation(() => undefined),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/undefined']!.post!.requestBody).toMatchInlineSnapshot(
-      `undefined`,
-    );
-    expect(openApiDocument.paths['/undefined']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "not": Object {},
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with nullish', () => {
-    const appRouter = t.router({
-      nullish: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/nullish' } })
-        .input(z.void())
-        .output(z.string().nullish())
-        .mutation(() => null),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/nullish']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "anyOf": Array [
-                Object {
-                  "not": Object {},
-                },
-                Object {
-                  "nullable": true,
-                  "type": "string",
-                },
-              ],
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with never', () => {
-    const appRouter = t.router({
-      never: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/never' } })
-        .input(z.never())
-        .output(z.never())
-        // @ts-expect-error - cannot return never
-        .mutation(() => undefined),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/never']!.post!.requestBody).toMatchInlineSnapshot(`undefined`);
-    expect(openApiDocument.paths['/never']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "not": Object {},
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with optional query param', () => {
-    const appRouter = t.router({
-      optionalParam: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/optional-param' } })
-        .input(z.object({ one: z.string().optional(), two: z.string() }))
-        .output(z.string().optional())
-        .query(({ input }) => input.one),
-      optionalObject: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/optional-object' } })
-        .input(z.object({ one: z.string().optional(), two: z.string() }).optional())
-        .output(z.string().optional())
-        .query(({ input }) => input?.two),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/optional-param']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "one",
-          "required": false,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "two",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/optional-param']!.get!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "anyOf": Array [
-                Object {
-                  "not": Object {},
-                },
-                Object {
-                  "type": "string",
-                },
-              ],
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-    expect(openApiDocument.paths['/optional-object']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "one",
-          "required": false,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "two",
-          "required": false,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/optional-object']!.get!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "anyOf": Array [
-                Object {
-                  "not": Object {},
-                },
-                Object {
-                  "type": "string",
-                },
-              ],
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with optional request body', () => {
-    const appRouter = t.router({
-      optionalParam: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/optional-param' } })
-        .input(z.object({ one: z.string().optional(), two: z.string() }))
-        .output(z.string().optional())
-        .query(({ input }) => input.one),
-      optionalObject: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/optional-object' } })
-        .input(z.object({ one: z.string().optional(), two: z.string() }).optional())
-        .output(z.string().optional())
-        .query(({ input }) => input?.two),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/optional-param']!.post!.requestBody).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "one": Object {
-                  "type": "string",
-                },
-                "two": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "two",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "required": true,
-      }
-    `);
-    expect(openApiDocument.paths['/optional-param']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "anyOf": Array [
-                Object {
-                  "not": Object {},
-                },
-                Object {
-                  "type": "string",
-                },
-              ],
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-    expect(openApiDocument.paths['/optional-object']!.post!.requestBody).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "one": Object {
-                  "type": "string",
-                },
-                "two": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "two",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "required": false,
-      }
-    `);
-    expect(openApiDocument.paths['/optional-object']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "anyOf": Array [
-                Object {
-                  "not": Object {},
-                },
-                Object {
-                  "type": "string",
-                },
-              ],
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with default', () => {
-    const appRouter = t.router({
-      default: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/default' } })
-        .input(z.object({ payload: z.string().default('James') }))
-        .output(z.string().default('James'))
-        .query(({ input }) => input.payload),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/default']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "payload",
-          "required": false,
-          "schema": Object {
-            "default": "James",
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/default']!.get!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "default": "James",
-              "type": "string",
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with refine', () => {
-    {
-      const appRouter = t.router({
-        refine: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/refine' } })
-          .input(z.object({ a: z.string().refine((arg) => arg.length > 10) }))
-          .output(z.null())
-          .mutation(() => null),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/refine']!.post!.requestBody).toMatchInlineSnapshot(`
-        Object {
-          "content": Object {
-            "application/json": Object {
-              "example": undefined,
-              "schema": Object {
-                "additionalProperties": false,
-                "properties": Object {
-                  "a": Object {
-                    "type": "string",
-                  },
-                },
-                "required": Array [
-                  "a",
-                ],
-                "type": "object",
-              },
-            },
-          },
-          "required": true,
-        }
-      `);
-    }
-    {
-      const appRouter = t.router({
-        objectRefine: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/object-refine' } })
-          .input(z.object({ a: z.string(), b: z.string() }).refine((data) => data.a === data.b))
-          .output(z.null())
-          .mutation(() => null),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/object-refine']!.post!.requestBody).toMatchInlineSnapshot(`
-        Object {
-          "content": Object {
-            "application/json": Object {
-              "example": undefined,
-              "schema": Object {
-                "additionalProperties": false,
-                "properties": Object {
-                  "a": Object {
-                    "type": "string",
-                  },
-                  "b": Object {
-                    "type": "string",
-                  },
-                },
-                "required": Array [
-                  "a",
-                  "b",
-                ],
-                "type": "object",
-              },
-            },
-          },
-          "required": true,
-        }
-      `);
-    }
-  });
-
-  test('with async refine', () => {
-    {
-      const appRouter = t.router({
-        refine: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/refine' } })
-          // eslint-disable-next-line @typescript-eslint/require-await
-          .input(z.object({ a: z.string().refine(async (arg) => arg.length > 10) }))
-          .output(z.null())
-          .mutation(() => null),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/refine']!.post!.requestBody).toMatchInlineSnapshot(`
-        Object {
-          "content": Object {
-            "application/json": Object {
-              "example": undefined,
-              "schema": Object {
-                "additionalProperties": false,
-                "properties": Object {
-                  "a": Object {
-                    "type": "string",
-                  },
-                },
-                "required": Array [
-                  "a",
-                ],
-                "type": "object",
-              },
-            },
-          },
-          "required": true,
-        }
-      `);
-    }
-    {
-      const appRouter = t.router({
-        objectRefine: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/object-refine' } })
-          .input(
-            // eslint-disable-next-line @typescript-eslint/require-await
-            z.object({ a: z.string(), b: z.string() }).refine(async (data) => data.a === data.b),
-          )
-          .output(z.null())
-          .mutation(() => null),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/object-refine']!.post!.requestBody).toMatchInlineSnapshot(`
-        Object {
-          "content": Object {
-            "application/json": Object {
-              "example": undefined,
-              "schema": Object {
-                "additionalProperties": false,
-                "properties": Object {
-                  "a": Object {
-                    "type": "string",
-                  },
-                  "b": Object {
-                    "type": "string",
-                  },
-                },
-                "required": Array [
-                  "a",
-                  "b",
-                ],
-                "type": "object",
-              },
-            },
-          },
-          "required": true,
-        }
-      `);
-    }
-  });
-
-  test('with transform', () => {
-    const appRouter = t.router({
-      transform: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/transform' } })
-        .input(z.object({ age: z.string().transform((input) => parseInt(input)) }))
-        .output(z.object({ age: z.string().transform((input) => parseInt(input)) }))
-        .query(({ input }) => ({ age: input.age.toString() })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/transform']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "age",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-  });
-
-  test('with preprocess', () => {
-    const appRouter = t.router({
-      transform: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/preprocess' } })
-        .input(
-          z.object({
-            payload: z.preprocess((arg) => {
-              if (typeof arg === 'string') {
-                return parseInt(arg);
-              }
-              return arg;
-            }, z.number()),
-          }),
-        )
-        .output(z.number())
-        .query(({ input }) => input.payload),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/preprocess']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "payload",
-          "required": true,
-          "schema": Object {
-            "type": "number",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/preprocess']!.get!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "type": "number",
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with coerce', () => {
-    const appRouter = t.router({
-      transform: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/coerce' } })
-        .input(z.object({ payload: z.number() }))
-        .output(z.number())
-        .query(({ input }) => input.payload),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/coerce']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "payload",
-          "required": true,
-          "schema": Object {
-            "type": "number",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/coerce']!.get!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "type": "number",
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with union', () => {
-    {
-      const appRouter = t.router({
-        union: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/union' } })
-          .input(z.object({ payload: z.string().or(z.object({})) }))
-          .output(z.null())
-          .query(() => null),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.union] - Input parser key: "payload" must be ZodString');
-    }
-    {
-      const appRouter = t.router({
-        union: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/union' } })
-          .input(z.object({ payload: z.string().or(z.literal('James')) }))
-          .output(z.null())
-          .query(() => null),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/union']!.get!.parameters).toMatchInlineSnapshot(`
-        Array [
-          Object {
-            "description": undefined,
-            "example": undefined,
-            "in": "query",
-            "name": "payload",
-            "required": true,
-            "schema": Object {
-              "anyOf": Array [
-                Object {
-                  "type": "string",
-                },
-                Object {
-                  "enum": Array [
-                    "James",
-                  ],
-                  "type": "string",
-                },
-              ],
-            },
-          },
-        ]
-      `);
-    }
-  });
-
-  test('with intersection', () => {
-    const appRouter = t.router({
-      intersection: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/intersection' } })
-        .input(
-          z.object({
-            payload: z.intersection(
-              z.union([z.literal('a'), z.literal('b')]),
-              z.union([z.literal('b'), z.literal('c')]),
-            ),
-          }),
-        )
-        .output(z.null())
-        .query(() => null),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/intersection']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "payload",
-          "required": true,
-          "schema": Object {
-            "allOf": Array [
-              Object {
-                "anyOf": Array [
-                  Object {
-                    "enum": Array [
-                      "a",
-                    ],
-                    "type": "string",
-                  },
-                  Object {
-                    "enum": Array [
-                      "b",
-                    ],
-                    "type": "string",
-                  },
-                ],
-              },
-              Object {
-                "anyOf": Array [
-                  Object {
-                    "enum": Array [
-                      "b",
-                    ],
-                    "type": "string",
-                  },
-                  Object {
-                    "enum": Array [
-                      "c",
-                    ],
-                    "type": "string",
-                  },
-                ],
-              },
-            ],
-          },
-        },
-      ]
-    `);
-  });
-
-  test('with lazy', () => {
-    const appRouter = t.router({
-      lazy: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/lazy' } })
-        .input(z.object({ payload: z.lazy(() => z.string()) }))
-        .output(z.null())
-        .query(() => null),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/lazy']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "payload",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-  });
-
-  test('with literal', () => {
-    const appRouter = t.router({
-      literal: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/literal' } })
-        .input(z.object({ payload: z.literal('literal') }))
-        .output(z.null())
-        .query(() => null),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/literal']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "payload",
-          "required": true,
-          "schema": Object {
-            "enum": Array [
-              "literal",
-            ],
-            "type": "string",
-          },
-        },
-      ]
-    `);
-  });
-
-  test('with enum', () => {
-    const appRouter = t.router({
-      enum: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/enum' } })
-        .input(z.object({ name: z.enum(['James', 'jlalmes']) }))
-        .output(z.null())
-        .query(() => null),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/enum']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "name",
-          "required": true,
-          "schema": Object {
-            "enum": Array [
-              "James",
-              "jlalmes",
-            ],
-            "type": "string",
-          },
-        },
-      ]
-    `);
-  });
-
-  test('with native-enum', () => {
-    {
-      enum InvalidEnum {
-        James,
-        jlalmes,
-      }
-
-      const appRouter = t.router({
-        nativeEnum: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/nativeEnum' } })
-          .input(z.object({ name: z.nativeEnum(InvalidEnum) }))
-          .output(z.null())
-          .query(() => null),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[query.nativeEnum] - Input parser key: "name" must be ZodString');
-    }
-    {
-      enum ValidEnum {
-        James = 'James',
-        jlalmes = 'jlalmes',
-      }
-
-      const appRouter = t.router({
-        nativeEnum: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/nativeEnum' } })
-          .input(z.object({ name: z.nativeEnum(ValidEnum) }))
-          .output(z.null())
-          .query(() => null),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(openApiDocument.paths['/nativeEnum']!.get!.parameters).toMatchInlineSnapshot(`
-        Array [
-          Object {
-            "description": undefined,
-            "example": undefined,
-            "in": "query",
-            "name": "name",
-            "required": true,
-            "schema": Object {
-              "enum": Array [
-                "James",
-                "jlalmes",
-              ],
-              "type": "string",
-            },
-          },
-        ]
-      `);
-    }
-  });
-
-  test('with no refs', () => {
-    const schemas = { emails: z.array(z.string().email()) };
-
-    const appRouter = t.router({
-      refs: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/refs' } })
-        .input(z.object({ allowed: schemas.emails, blocked: schemas.emails }))
-        .output(z.object({ allowed: schemas.emails, blocked: schemas.emails }))
-        .mutation(() => ({ allowed: [], blocked: [] })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/refs']!.post!.requestBody).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "allowed": Object {
-                  "items": Object {
-                    "format": "email",
-                    "type": "string",
-                  },
-                  "type": "array",
-                },
-                "blocked": Object {
-                  "items": Object {
-                    "format": "email",
-                    "type": "string",
-                  },
-                  "type": "array",
-                },
-              },
-              "required": Array [
-                "allowed",
-                "blocked",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "required": true,
-      }
-    `);
-    expect(openApiDocument.paths['/refs']!.post!.responses[200]).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "allowed": Object {
-                  "items": Object {
-                    "format": "email",
-                    "type": "string",
-                  },
-                  "type": "array",
-                },
-                "blocked": Object {
-                  "items": Object {
-                    "format": "email",
-                    "type": "string",
-                  },
-                  "type": "array",
-                },
-              },
-              "required": Array [
-                "allowed",
-                "blocked",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with custom header', () => {
-    const appRouter = t.router({
-      echo: t.procedure
-        .meta({
-          openapi: {
-            method: 'GET',
-            path: '/echo',
-            headers: [
-              {
-                name: 'x-custom-header',
-                required: true,
-                description: 'Some custom header',
-              },
-            ],
-          },
-        })
-        .input(z.object({ id: z.string() }))
-        .output(z.object({ id: z.string() }))
-        .query(({ input }) => ({ id: input.id })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/echo']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": "Some custom header",
-          "in": "header",
-          "name": "x-custom-header",
-          "required": true,
-        },
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "id",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-  });
-
-  test('with DELETE mutation', () => {
-    const appRouter = t.router({
-      deleteMutation: t.procedure
-        .meta({ openapi: { method: 'DELETE', path: '/mutation/delete' } })
-        .input(z.object({ id: z.string() }))
-        .output(z.object({ id: z.string() }))
-        .mutation(({ input }) => ({ id: input.id })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/mutation/delete']!.delete!.requestBody).toMatchInlineSnapshot(
-      `undefined`,
-    );
-    expect(openApiDocument.paths['/mutation/delete']!.delete!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "id",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-  });
-
-  test('with POST query', () => {
-    const appRouter = t.router({
-      postQuery: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/query/post' } })
-        .input(z.object({ id: z.string() }))
-        .output(z.object({ id: z.string() }))
-        .query(({ input }) => ({ id: input.id })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/query/post']!.post!.requestBody).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "id": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "id",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "required": true,
-      }
-    `);
-    expect(openApiDocument.paths['/query/post']!.post!.parameters).toMatchInlineSnapshot(
-      `Array []`,
-    );
-  });
-
-  test('with top-level preprocess', () => {
-    const appRouter = t.router({
-      topLevelPreprocessQuery: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/top-level-preprocess' } })
-        .input(z.preprocess((arg) => arg, z.object({ id: z.string() })))
-        .output(z.preprocess((arg) => arg, z.object({ id: z.string() })))
-        .query(({ input }) => ({ id: input.id })),
-      topLevelPreprocessMutation: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/top-level-preprocess' } })
-        .input(z.preprocess((arg) => arg, z.object({ id: z.string() })))
-        .output(z.preprocess((arg) => arg, z.object({ id: z.string() })))
-        .mutation(({ input }) => ({ id: input.id })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/top-level-preprocess']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "id",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/top-level-preprocess']!.post!.requestBody)
-      .toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "id": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "id",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "required": true,
-      }
-    `);
-  });
-
-  test('with nested routers', () => {
-    const appRouter = t.router({
-      procedure: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/procedure' } })
-        .input(z.object({ payload: z.string() }))
-        .output(z.object({ payload: z.string() }))
-        .query(({ input }) => ({ payload: input.payload })),
-      router: t.router({
-        procedure: t.procedure
-          .meta({ openapi: { method: 'GET', path: '/router/procedure' } })
-          .input(z.object({ payload: z.string() }))
-          .output(z.object({ payload: z.string() }))
-          .query(({ input }) => ({ payload: input.payload })),
-        router: t.router({
-          procedure: t.procedure
-            .meta({ openapi: { method: 'GET', path: '/router/router/procedure' } })
-            .input(z.object({ payload: z.string() }))
-            .output(z.object({ payload: z.string() }))
-            .query(({ input }) => ({ payload: input.payload })),
-        }),
-      }),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths).toMatchInlineSnapshot(`
-      Object {
-        "/procedure": Object {
-          "get": Object {
-            "description": undefined,
-            "operationId": "procedure",
-            "parameters": Array [
-              Object {
-                "description": undefined,
-                "example": undefined,
-                "in": "query",
-                "name": "payload",
-                "required": true,
-                "schema": Object {
-                  "type": "string",
-                },
-              },
-            ],
-            "requestBody": undefined,
-            "responses": Object {
-              "200": Object {
-                "content": Object {
-                  "application/json": Object {
-                    "example": undefined,
-                    "schema": Object {
-                      "additionalProperties": false,
-                      "properties": Object {
-                        "payload": Object {
-                          "type": "string",
-                        },
-                      },
-                      "required": Array [
-                        "payload",
-                      ],
-                      "type": "object",
-                    },
-                  },
-                },
-                "description": "Successful response",
-                "headers": undefined,
-              },
-              "default": Object {
-                "$ref": "#/components/responses/error",
-              },
-            },
-            "security": undefined,
-            "summary": undefined,
-            "tags": undefined,
-          },
-        },
-        "/router/procedure": Object {
-          "get": Object {
-            "description": undefined,
-            "operationId": "router-procedure",
-            "parameters": Array [
-              Object {
-                "description": undefined,
-                "example": undefined,
-                "in": "query",
-                "name": "payload",
-                "required": true,
-                "schema": Object {
-                  "type": "string",
-                },
-              },
-            ],
-            "requestBody": undefined,
-            "responses": Object {
-              "200": Object {
-                "content": Object {
-                  "application/json": Object {
-                    "example": undefined,
-                    "schema": Object {
-                      "additionalProperties": false,
-                      "properties": Object {
-                        "payload": Object {
-                          "type": "string",
-                        },
-                      },
-                      "required": Array [
-                        "payload",
-                      ],
-                      "type": "object",
-                    },
-                  },
-                },
-                "description": "Successful response",
-                "headers": undefined,
-              },
-              "default": Object {
-                "$ref": "#/components/responses/error",
-              },
-            },
-            "security": undefined,
-            "summary": undefined,
-            "tags": undefined,
-          },
-        },
-        "/router/router/procedure": Object {
-          "get": Object {
-            "description": undefined,
-            "operationId": "router-router-procedure",
-            "parameters": Array [
-              Object {
-                "description": undefined,
-                "example": undefined,
-                "in": "query",
-                "name": "payload",
-                "required": true,
-                "schema": Object {
-                  "type": "string",
-                },
-              },
-            ],
-            "requestBody": undefined,
-            "responses": Object {
-              "200": Object {
-                "content": Object {
-                  "application/json": Object {
-                    "example": undefined,
-                    "schema": Object {
-                      "additionalProperties": false,
-                      "properties": Object {
-                        "payload": Object {
-                          "type": "string",
-                        },
-                      },
-                      "required": Array [
-                        "payload",
-                      ],
-                      "type": "object",
-                    },
-                  },
-                },
-                "description": "Successful response",
-                "headers": undefined,
-              },
-              "default": Object {
-                "$ref": "#/components/responses/error",
-              },
-            },
-            "security": undefined,
-            "summary": undefined,
-            "tags": undefined,
-          },
-        },
-      }
-    `);
-  });
-
-  test('with multiple inputs', () => {
-    const appRouter = t.router({
-      query: t.procedure
-        .meta({ openapi: { method: 'GET', path: '/query' } })
-        .input(z.object({ id: z.string() }))
-        .input(z.object({ payload: z.string() }))
-        .output(z.object({ id: z.string(), payload: z.string() }))
-        .query(({ input }) => ({ id: input.id, payload: input.payload })),
-      mutation: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/mutation' } })
-        .input(z.object({ id: z.string() }))
-        .input(z.object({ payload: z.string() }))
-        .output(z.object({ id: z.string(), payload: z.string() }))
-        .mutation(({ input }) => ({ id: input.id, payload: input.payload })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/query']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "id",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "payload",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/mutation']!.post!.requestBody).toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "id": Object {
-                  "type": "string",
-                },
-                "payload": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "id",
-                "payload",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "required": true,
-      }
-    `);
-  });
-
-  test('with content types', () => {
-    {
-      const appRouter = t.router({
-        withNone: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/with-none', contentTypes: [] } })
-          .input(z.object({ payload: z.string() }))
-          .output(z.object({ payload: z.string() }))
-          .mutation(({ input }) => ({ payload: input.payload })),
-      });
-
-      expect(() => {
-        generateOpenApiDocument(appRouter, defaultDocOpts);
-      }).toThrowError('[mutation.withNone] - At least one content type must be specified');
-    }
-    {
-      const appRouter = t.router({
-        withUrlencoded: t.procedure
-          .meta({
-            openapi: {
-              method: 'POST',
-              path: '/with-urlencoded',
-              contentTypes: ['application/x-www-form-urlencoded'],
-            },
-          })
-          .input(z.object({ payload: z.string() }))
-          .output(z.object({ payload: z.string() }))
-          .mutation(({ input }) => ({ payload: input.payload })),
-        withJson: t.procedure
-          .meta({
-            openapi: { method: 'POST', path: '/with-json', contentTypes: ['application/json'] },
-          })
-          .input(z.object({ payload: z.string() }))
-          .output(z.object({ payload: z.string() }))
-          .mutation(({ input }) => ({ payload: input.payload })),
-        withAll: t.procedure
-          .meta({
-            openapi: {
-              method: 'POST',
-              path: '/with-all',
-              contentTypes: ['application/json', 'application/x-www-form-urlencoded'],
-            },
-          })
-          .input(z.object({ payload: z.string() }))
-          .output(z.object({ payload: z.string() }))
-          .mutation(({ input }) => ({ payload: input.payload })),
-        withDefault: t.procedure
-          .meta({ openapi: { method: 'POST', path: '/with-default' } })
-          .input(z.object({ payload: z.string() }))
-          .output(z.object({ payload: z.string() }))
-          .mutation(({ input }) => ({ payload: input.payload })),
-      });
-
-      const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-      expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-      expect(
-        Object.keys((openApiDocument.paths['/with-urlencoded']!.post!.requestBody as any).content),
-      ).toEqual(['application/x-www-form-urlencoded']);
-      expect(
-        Object.keys((openApiDocument.paths['/with-json']!.post!.requestBody as any).content),
-      ).toEqual(['application/json']);
-      expect(
-        Object.keys((openApiDocument.paths['/with-all']!.post!.requestBody as any).content),
-      ).toEqual(['application/json', 'application/x-www-form-urlencoded']);
-      expect(
-        (openApiDocument.paths['/with-all']!.post!.requestBody as any).content['application/json'],
-      ).toEqual(
-        (openApiDocument.paths['/with-all']!.post!.requestBody as any).content[
-          'application/x-www-form-urlencoded'
-        ],
-      );
-      expect(
-        Object.keys((openApiDocument.paths['/with-default']!.post!.requestBody as any).content),
-      ).toEqual(['application/json']);
-    }
-  });
-
-  test('with deprecated', () => {
-    const appRouter = t.router({
-      deprecated: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/deprecated', deprecated: true } })
-        .input(z.object({ payload: z.string() }))
-        .output(z.object({ payload: z.string() }))
-        .mutation(({ input }) => ({ payload: input.payload })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/deprecated']!.post!.deprecated).toEqual(true);
-  });
-
-  test('with security schemes', () => {
-    const appRouter = t.router({
-      protected: t.procedure
-        .meta({ openapi: { method: 'POST', path: '/protected', protect: true } })
-        .input(z.object({ payload: z.string() }))
-        .output(z.object({ payload: z.string() }))
-        .mutation(({ input }) => ({ payload: input.payload })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, {
-      ...defaultDocOpts,
-      securitySchemes: {
-        ApiKey: {
-          type: 'apiKey',
-          in: 'header',
-          name: 'X-API-Key',
-        },
-      },
-    });
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.components!.securitySchemes).toEqual({
-      ApiKey: {
-        type: 'apiKey',
-        in: 'header',
-        name: 'X-API-Key',
-      },
-    });
-    expect(openApiDocument.paths['/protected']!.post!.security).toEqual([{ ApiKey: [] }]);
-  });
-
-  test('with examples', () => {
-    const appRouter = t.router({
-      queryExample: t.procedure
-        .meta({
-          openapi: {
-            method: 'GET',
-            path: '/query-example/{name}',
-            example: {
-              request: { name: 'James', greeting: 'Hello' },
-              response: { output: 'Hello James' },
-            },
-          },
-        })
-        .input(z.object({ name: z.string(), greeting: z.string() }))
-        .output(z.object({ output: z.string() }))
-        .query(({ input }) => ({
-          output: `${input.greeting} ${input.name}`,
-        })),
-      mutationExample: t.procedure
-        .meta({
-          openapi: {
-            method: 'POST',
-            path: '/mutation-example/{name}',
-            example: {
-              request: { name: 'James', greeting: 'Hello' },
-              response: { output: 'Hello James' },
-            },
-          },
-        })
-        .input(z.object({ name: z.string(), greeting: z.string() }))
-        .output(z.object({ output: z.string() }))
-        .mutation(({ input }) => ({
-          output: `${input.greeting} ${input.name}`,
-        })),
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/query-example/{name}']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": "James",
-          "in": "path",
-          "name": "name",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-        Object {
-          "description": undefined,
-          "example": "Hello",
-          "in": "query",
-          "name": "greeting",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/query-example/{name}']!.get!.responses[200])
-      .toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": Object {
-              "output": "Hello James",
-            },
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "output": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "output",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-    expect(openApiDocument.paths['/mutation-example/{name}']!.post!.parameters)
-      .toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": "James",
-          "in": "path",
-          "name": "name",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/mutation-example/{name}']!.post!.requestBody)
-      .toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": Object {
-              "greeting": "Hello",
-            },
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "greeting": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "greeting",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "required": true,
-      }
-    `);
-    expect(openApiDocument.paths['/mutation-example/{name}']!.post!.responses[200])
-      .toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": Object {
-              "output": "Hello James",
-            },
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "output": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "output",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": undefined,
-      }
-    `);
-  });
-
-  test('with response headers', () => {
-    const appRouter = t.router({
-      queryExample: t.procedure
-        .meta({
-          openapi: {
-            method: 'GET',
-            path: '/query-example/{name}',
-            responseHeaders: {
-              "X-RateLimit-Limit": {
-                description: "Request limit per hour.",
-                schema: {
-                  type: "integer"
-                }
-              },
-              "X-RateLimit-Remaining": {
-                description: "The number of requests left for the time window.",
-                schema: {
-                  type: "integer"
-                }
-              }
-            }
-          },
-        })
-        .input(z.object({ name: z.string(), greeting: z.string() }))
-        .output(z.object({ output: z.string() }))
-        .query(({ input }) => ({
-          output: `${input.greeting} ${input.name}`,
-        }))
-    });
-
-    const openApiDocument = generateOpenApiDocument(appRouter, defaultDocOpts);
-
-    expect(openApiSchemaValidator.validate(openApiDocument).errors).toEqual([]);
-    expect(openApiDocument.paths['/query-example/{name}']!.get!.parameters).toMatchInlineSnapshot(`
-      Array [
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "path",
-          "name": "name",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-        Object {
-          "description": undefined,
-          "example": undefined,
-          "in": "query",
-          "name": "greeting",
-          "required": true,
-          "schema": Object {
-            "type": "string",
-          },
-        },
-      ]
-    `);
-    expect(openApiDocument.paths['/query-example/{name}']!.get!.responses[200])
-      .toMatchInlineSnapshot(`
-      Object {
-        "content": Object {
-          "application/json": Object {
-            "example": undefined,
-            "schema": Object {
-              "additionalProperties": false,
-              "properties": Object {
-                "output": Object {
-                  "type": "string",
-                },
-              },
-              "required": Array [
-                "output",
-              ],
-              "type": "object",
-            },
-          },
-        },
-        "description": "Successful response",
-        "headers": Object {
-          "X-RateLimit-Limit": Object {
-            "description": "Request limit per hour.",
-            "schema": Object {
-              "type": "integer",
-            },
-          },
-          "X-RateLimit-Remaining": Object {
-            "description": "The number of requests left for the time window.",
-            "schema": Object {
-              "type": "integer",
-            },
-          },
-        },
-      }
-    `);
-  });
-});