@dokploy/trpc-openapi 0.0.1

package/test/generator.test.ts

@@ -0,0 +1,2897 @@
+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",
+            },
+          },
+        },
+      }
+    `);
+  });
+});