@kubb/plugin-zod 5.4.5 → 5.4.7

package/docs/guides/customization.md

@@ -0,0 +1,148 @@
+# Customize generated schemas
+
+Prefix inferred types, change Zod validators, and encode custom request types.
+
+Start with the [Zod plugin configuration](https://kubb.dev/extensions/kubb-labs/plugin-zod#example). Apply these changes to `pluginZod()` in that configuration.
+
+## Prefix inferred types
+
+Enable `inferred` and override `resolver.schema.typeName`.
+
+```typescript [kubb.config.ts]
+import { pluginZod } from '@kubb/plugin-zod'
+
+pluginZod({
+  inferred: true,
+  resolver: {
+    schema: {
+      typeName(name) {
+        return 'Api' + name
+      },
+    },
+  },
+})
+```
+
+The type becomes `ApiPet`. The schema constant stays `petSchema`. The callback receives the cased type name, so no additional casing helper is needed.
+
+## Use numbers for int64 fields
+
+Replace the `bigint` printer handler to validate `int64` fields with `z.int()`.
+
+```typescript [kubb.config.ts]
+import { pluginZod } from '@kubb/plugin-zod'
+
+pluginZod({
+  printer: {
+    nodes: {
+      bigint() {
+        return 'z.int()'
+      },
+    },
+  },
+})
+```
+
+The `integer` handler controls `int32` fields separately. To change integer representation across all plugins, use the adapter's [`integerType`](https://kubb.dev/extensions/kubb-labs/adapter-oas/options#integertype).
+
+## Remove descriptions
+
+Use the [description-removal macro](https://kubb.dev/extensions/kubb-labs/plugin-ts/guides/customization#remove-descriptions) with `pluginZod({ macros: [dropDescriptions] })`. Generated schemas omit description metadata.
+
+## Encode custom types
+
+A direction-aware printer decodes response values and encodes request values. This example converts ISO time strings to `Temporal.PlainTime`.
+
+```typescript [kubb.config.ts]
+import { pluginZod, type PrinterZodNodes } from '@kubb/plugin-zod'
+
+const nodes: PrinterZodNodes = {
+  time() {
+    return this.options.direction === 'encode'
+      ? 'z.instanceof(Temporal.PlainTime).transform((value) => value.toString())'
+      : 'z.iso.time().transform((value) => Temporal.PlainTime.from(value))'
+  },
+}
+
+pluginZod({ inferred: true, printer: { nodes } })
+```
+
+Use a runtime that provides `Temporal`, or add its polyfill through a generated import or banner. Match the OpenAPI format: `time`, `date`, and `date-time` use `time`, `date`, and `datetime` handlers.
+
+The generator emits separate response and input schemas, including through `$ref`:
+
+```typescript [src/gen/zod/slotSchema.ts]
+export const slotSchema = z.object({
+  startsAt: z.iso.time().transform((value) => Temporal.PlainTime.from(value)),
+})
+
+export const slotInputSchema = z.object({
+  startsAt: z.instanceof(Temporal.PlainTime).transform((value) => value.toString()),
+})
+```
+
+> [!IMPORTANT]
+> Use `inferred: true` without `pluginTs` so the client types follow these conversions. Types from `pluginTs` describe the wire format.
+
+For built-in date conversion, set `dateType: 'date'` on the adapter. Generated response schemas convert ISO datetimes to `Date`. Request schemas convert them back with `toISOString()`.
+
+## Import a custom codec
+
+Override a printer node and register the package import with `this.import`. For example, use your package's `myCodec.uint64()` for `int64` fields:
+
+```typescript [kubb.config.ts]
+import { ast } from 'kubb/kit'
+import { pluginZod } from '@kubb/plugin-zod'
+
+pluginZod({
+  printer: {
+    nodes: {
+      bigint() {
+        this.import(ast.factory.createImport({
+          name: ['myCodec'],
+          path: 'my-codec/zod',
+        }))
+        return 'myCodec.uint64()'
+      },
+    },
+  },
+})
+```
+
+Generated files import `myCodec` from `my-codec/zod`. Leave `root` unset on this import to preserve the package specifier. Setting `root` rewrites it as a relative file path.
+
+## Format and type mappings
+
+`@kubb/plugin-zod` maps OpenAPI types and formats to Zod v4:
+
+| OpenAPI type and format                    | Zod                                   | Zod Mini                              | Notes                                                                   |
+| :----------------------------------------- | :------------------------------------ | :------------------------------------ | :---------------------------------------------------------------------- |
+| `integer`                                  | `z.int()`                             | `z.int()`                             | Coerces to `z.coerce.number().int()` when `coercion.numbers` is enabled |
+| `integer`, `format: int32`                 | `z.int32()`                           | `z.int32()`                           | 32-bit signed integer                                                   |
+| `integer`, `format: uint32`                | `z.uint32()`                          | `z.uint32()`                          | 32-bit unsigned integer                                                 |
+| `integer`, `format: int64`                 | `z.bigint()`                          | `z.bigint()`                          | 64-bit integer                                                          |
+| `string`, `format: byte` / `base64`        | `z.base64()`                          | `z.base64()`                          | Base64 string validation                                                |
+| `string`, `format: base64url`              | `z.base64url()`                       | `z.base64url()`                       | URL-safe base64 string validation                                       |
+| `string`, `format: jwt`                    | `z.jwt()`                             | `z.jwt()`                             | JSON Web Token format                                                   |
+| `string`, `format: ulid`                   | `z.ulid()`                            | `z.ulid()`                            | ULID format                                                             |
+| `string`, `format: iban`                   | `z.iban()`                            | `z.iban()`                            | International Bank Account Number                                       |
+| `string`, `format: duration`               | `z.iso.duration()`                    | `z.iso.duration()`                    | ISO 8601 duration format                                                |
+| `string`, `format: uuid`                   | `z.uuid()` (or `z.guid()`)            | `z.uuid()` (or `z.guid()`)            | Configured via `guidType`                                               |
+| `string`, `format: email`                  | `z.email()`                           | `z.email()`                           | Email format                                                            |
+| `string`, `format: uri` / `url`            | `z.url()`                             | `z.url()`                             | URL format                                                              |
+| `string`, `format: ipv4` / `ipv6`          | `z.ipv4()` / `z.ipv6()`               | `z.ipv4()` / `z.ipv6()`               | IP address format                                                       |
+| `string`, `format: date`                   | `z.iso.date()`                        | `z.iso.date()`                        | ISO 8601 date                                                           |
+| `string`, `format: date-time`              | `z.iso.datetime()`                    | `z.string()`                          | ISO 8601 date-time                                                      |
+| `string`, `format: time`                   | `z.iso.time()`                        | `z.iso.time()`                        | ISO 8601 time                                                           |
+| `object`, `additionalProperties: <schema>` | `z.record(z.string(), schema)`        | `z.record(z.string(), schema)`        | Dictionary with no fixed properties                                     |
+| `object`, `additionalProperties: true`     | `z.looseObject(shape)`                | `z.looseObject(shape)`                | Open/passthrough object allowing extra keys                             |
+| `object`, `propertyNames: <schema>`        | `z.record(keySchema, schema)`         | `z.record(keySchema, schema)`         | Dynamic map with validated key schema (e.g. pattern, format)            |
+| `object`, `propertyNames: <enum>`          | `z.partialRecord(enumSchema, schema)` | `z.partialRecord(enumSchema, schema)` | Enum keys may be missing                                                |
+
+## Dictionaries, open objects, and key schemas
+
+OpenAPI 3.1 `propertyNames` validates dictionary keys. Open key schemas use `z.record(keySchema, valueSchema)`, including regex, UUID, and length constraints. Closed keys, such as enums, literals, or unions of enums, use `z.partialRecord` so only present keys are validated. Keys may be missing, as in OpenAPI, and the inferred type is `Partial<Record<Keys, Value>>`.
+
+`patternProperties` combines key regex patterns into an alternation and emits `z.record(z.string().regex(...), valueSchema)`. Zod Mini uses `z.string().check(z.regex(...))` for the key schema.
+
+An `additionalProperties` schema without fixed properties produces a dictionary. With fixed properties, it produces `.catchall(valueSchema)` to preserve that declared shape. `additionalProperties: true` emits `z.looseObject(shape)` to allow undeclared keys.

package/docs/options.md

@@ -0,0 +1,273 @@
+# Options
+
+Pass these options to `pluginZod()`. Shared options link to [Shared plugin options](https://kubb.dev/docs/5.x/reference/plugin-options) for details.
+
+## Options overview
+
+| Option                                                                    | Purpose                                                                | Default                                      |
+| ------------------------------------------------------------------------- | ---------------------------------------------------------------------- | -------------------------------------------- |
+| [`output`](https://kubb.dev/docs/5.x/reference/plugin-options#output)     | Where files are written: `path`, `mode`, `barrel`, `banner`, `footer`. | `{ path: 'zod', barrel: { type: 'named' } }` |
+| [`group`](https://kubb.dev/docs/5.x/reference/plugin-options#group)       | Split output by tag or path: `type`, `name`.                           | None                                         |
+| [`importPath`](#importpath)                                               | Module the generated files import `z` from.                            | `'zod'`, or `'zod/mini'` with `mini`         |
+| [`inferred`](#inferred)                                                   | Emit a `z.infer` alias next to each schema.                            | `false`                                      |
+| [`coercion`](#coercion)                                                   | Coerce input before validation.                                        | `false`                                      |
+| [`guidType`](#guidtype)                                                   | Validator for `format: uuid` properties.                               | `'uuid'`                                     |
+| [`regexType`](#regextype)                                                 | How an OpenAPI `pattern` is written.                                   | `'literal'`                                  |
+| [`compile`](#compile)                                                     | Wrap schemas in `z.compile` for fast-path validation.                  | `false`                                      |
+| [`mini`](#mini)                                                           | Generate Zod Mini schemas.                                             | `false`                                      |
+| [`typeGuards`](#typeguards)                                               | Generate `is*` type guards and `assert*` assertions.                   | `false`                                      |
+| [`include`](https://kubb.dev/docs/5.x/reference/plugin-options#include)   | Keep only operations and schemas that match.                           | None                                         |
+| [`exclude`](https://kubb.dev/docs/5.x/reference/plugin-options#exclude)   | Skip operations and schemas that match.                                | `[]`                                         |
+| [`override`](https://kubb.dev/docs/5.x/reference/plugin-options#override) | Apply different options per pattern.                                   | `[]`                                         |
+| [`resolver`](#resolver)                                                   | Customize generated names and file paths.                              | `resolverZod`                                |
+| [`macros`](https://kubb.dev/docs/5.x/reference/plugin-options#macros)     | Rewrite AST nodes before printing.                                     | `[]`                                         |
+| [`printer`](#printer)                                                     | Replace the handler for a schema type.                                 | None                                         |
+
+## Option details
+
+### importPath
+
+Module the generated files import `z` from. Point it at your own module to re-export Zod.
+
+|          |                             |
+| -------- | --------------------------- |
+| Type     | `string`                    |
+| Required | `false`                     |
+| Default  | `mini ? 'zod/mini' : 'zod'` |
+
+`'zod'` and `'zod/mini'` are imported as `import * as z`. A custom module is imported as `import { z }`, so export `z` by name.
+
+### inferred
+
+Exports a `z.infer<typeof schema>` type next to each schema, so you do not need `@kubb/plugin-ts`. The type takes the PascalCase schema name plus `SchemaType`, so `petSchema` gets `PetSchemaType`.
+
+|          |           |
+| -------- | --------- |
+| Type     | `boolean` |
+| Required | `false`   |
+| Default  | `false`   |
+
+```typescript
+export type PetSchemaType = z.infer<typeof petSchema>
+```
+
+It also writes a `ResponsesSchema` for each operation (one schema per status code) and its inferred type. [`@kubb/plugin-fetch`](https://kubb.dev/extensions/kubb-labs/plugin-fetch) and [`@kubb/plugin-axios`](https://kubb.dev/extensions/kubb-labs/plugin-axios) key their `RequestResult` on it when `@kubb/plugin-ts` is absent.
+
+### coercion
+
+Wraps schemas in `z.coerce` so input is coerced before validation, for form data, query params, and similar string sources. See [Coercion for primitives](https://zod.dev/?id=coercion-for-primitives).
+
+|          |                                                                        |
+| -------- | ---------------------------------------------------------------------- |
+| Type     | `boolean \| { dates?: boolean, strings?: boolean, numbers?: boolean }` |
+| Required | `false`                                                                |
+| Default  | `false`                                                                |
+
+::field-group
+
+:::field{name="false"}
+Coerces nothing and validates strictly, except `bigint` fields (`format: int64`), which always use `z.coerce.bigint()`.
+:::
+
+:::field{name="true"}
+Coerces strings, numbers, and dates with `z.coerce.string()`, `z.coerce.number()` and `z.coerce.date()`.
+:::
+
+:::field{name="{ dates?, strings?, numbers? }"}
+Chooses which primitives to coerce.
+:::
+
+::
+
+> [!NOTE]
+> `dates` coerces only `Date`-typed fields (from `dateType: 'date'`). ISO-string fields are never coerced, and neither are `format: time` fields, because `new Date()` cannot parse a bare `HH:mm:ss`. For a time-of-day type such as `Temporal.PlainTime`, see [Encode custom types](https://kubb.dev/extensions/kubb-labs/plugin-zod/guides/customization#encode-custom-types).
+
+### guidType
+
+Validator used for OpenAPI properties with `format: uuid`.
+
+|          |                    |
+| -------- | ------------------ |
+| Type     | `'uuid' \| 'guid'` |
+| Required | `false`            |
+| Default  | `'uuid'`           |
+
+::field-group
+
+:::field{name="'uuid'"}
+Generates `z.uuid()`, a standard RFC 4122 UUID.
+:::
+
+:::field{name="'guid'"}
+Generates `z.guid()`, which is looser and accepts Microsoft-style GUIDs.
+:::
+
+::
+
+### regexType
+
+Controls how an OpenAPI `pattern` is written inside `.regex(...)`. Use `'constructor'` when a regex literal breaks your build or you need a string pattern.
+
+|          |                              |
+| -------- | ---------------------------- |
+| Type     | `'literal' \| 'constructor'` |
+| Required | `false`                      |
+| Default  | `'literal'`                  |
+
+::field-group
+
+:::field{name="'literal'"}
+Emits a regex literal, such as `.regex(/^[a-z]+$/)`.
+:::
+
+:::field{name="'constructor'"}
+Emits the `RegExp` constructor, such as `.regex(new RegExp('^[a-z]+$'))`.
+:::
+
+::
+
+### compile
+
+Wraps schemas in `z.compile(...)` to generate validation code instead of interpreting the schema on each call. Needs Zod v4.5.0 or higher.
+
+|          |                                   |
+| -------- | --------------------------------- |
+| Type     | `boolean \| { strict?: boolean }` |
+| Required | `false`                           |
+| Default  | `false`                           |
+
+::field-group
+
+:::field{name="false"}
+Leaves schemas uncompiled.
+:::
+
+:::field{name="true"}
+Compiles schemas using `z.compile(...)`.
+:::
+
+:::field{name="{ strict: true }"}
+Passes `{ strict: true }` to `z.compile(...)`, which throws when any part of the schema cannot be compiled into flat JavaScript instead of falling back to the interpreter.
+:::
+
+::
+
+Schemas with circular references (`z.lazy`) and bare `$ref` response aliases stay uncompiled to prevent runtime errors.
+
+### mini
+
+Generates [Zod Mini](https://zod.dev/packages/mini) schemas. They use functions (`z.optional(z.string())`) instead of method chains (`z.string().optional()`), so bundlers can drop unused validators. Also sets the `importPath` default to `'zod/mini'`.
+
+|          |           |
+| -------- | --------- |
+| Type     | `boolean` |
+| Required | `false`   |
+| Default  | `false`   |
+
+### typeGuards
+
+Generates TypeScript type guards (`is*`) and assertion functions (`assert*`) with Zod's `validate` API. Needs Zod v4.6.0 or higher.
+
+|          |                                                 |
+| -------- | ----------------------------------------------- |
+| Type     | `boolean \| { is?: boolean, assert?: boolean }` |
+| Required | `false`                                         |
+| Default  | `false`                                         |
+
+::field-group
+
+:::field{name="false"}
+Generates only the Zod schemas.
+:::
+
+:::field{name="true"}
+Generates both `is<Schema>` type guards and `assert<Schema>` assertion functions.
+:::
+
+:::field{name="{ is?: boolean; assert?: boolean }"}
+Enables type guards or assertions separately.
+:::
+
+::
+
+When [`inferred`](#inferred) is `true`, the guards narrow to the generated type alias such as `PetSchemaType`. When [`mini`](#mini) is `true`, they route through `z.validate` and `z.parse`.
+
+::code-collapse{name="Guards added to petSchema.ts with typeGuards: true"}
+
+```typescript [src/gen/zod/petSchema.ts]
+export const isPet = (data: unknown): data is z.infer<typeof petSchema> => petSchema.validate(data)
+
+export function assertPet(data: unknown): asserts data is z.infer<typeof petSchema> {
+  if (!petSchema.validate(data)) {
+    petSchema.parse(data)
+  }
+}
+```
+
+::
+
+### resolver
+
+Overrides generated file and symbol names. Omitted members keep `resolverZod`. The shared members (`name`, `file`, `imports`) and the `this` context are described under [`resolver`](https://kubb.dev/docs/5.x/reference/plugin-options#resolver).
+
+|          |                              |
+| -------- | ---------------------------- |
+| Type     | `ResolverPatch<ResolverZod>` |
+| Required | `false`                      |
+
+::code-collapse{name="ResolverZod patch members"}
+
+```typescript [Partial override]
+type ResolverZodPatch = {
+  // plus the shared name, file, and imports members
+  schema?: {
+    typeName?(name: string): string
+    type?(name: string): string
+    inputName?(name: string): string
+    inputTypeName?(name: string): string
+    isName?(name: string): string
+    assertName?(name: string): string
+  }
+  param?: {
+    name?(node: OperationNode, param: ParameterNode): string
+    path?(node: OperationNode, param: ParameterNode): string
+    query?(node: OperationNode, param: ParameterNode): string
+    headers?(node: OperationNode, param: ParameterNode): string
+  }
+  response?: {
+    status?(node: OperationNode, statusCode: StatusCode): string
+    body?(node: OperationNode): string
+    responses?(node: OperationNode): string
+    response?(node: OperationNode): string
+    error?(node: OperationNode): string
+    options?(node: OperationNode): string
+  }
+}
+```
+
+::
+
+### printer
+
+Replaces the handler for a schema type such as `'integer'` or `'string'`. Each handler returns the Zod expression as a string, in Zod Mini syntax when `mini: true`. Inside a handler, `this.base(node)` returns the built-in output to wrap and `this.transform(node)` recurses into nested nodes. See the [printer guide](https://kubb.dev/docs/5.x/how-to/printers).
+
+|          |                                                      |
+| -------- | ---------------------------------------------------- |
+| Type     | `{ nodes?: PrinterZodNodes \| PrinterZodMiniNodes }` |
+| Required | `false`                                              |
+
+```typescript
+import { pluginZod } from '@kubb/plugin-zod'
+
+pluginZod({
+  printer: {
+    nodes: {
+      integer() {
+        return 'z.number()'
+      },
+    },
+  },
+})
+```
+
+A handler can read `this.options.direction`, which is `'decode'` for responses and `'encode'` for request bodies and parameters. If it returns a different expression per direction, Kubb also writes an `${name}InputSchema`. Request bodies use it, including bodies that reach the schema through a `$ref`. See [Encode custom types](https://kubb.dev/extensions/kubb-labs/plugin-zod/guides/customization#encode-custom-types).

package/docs/overview.md

@@ -0,0 +1,40 @@
+# Zod
+
+Generates Zod v4 schemas from your OpenAPI spec. Use them to validate API responses, form input, and query params at runtime.
+
+The schemas need no other plugin. With `inferred: true`, the plugin also exports a `z.infer` type next to each schema, so you can skip `@kubb/plugin-ts`. Client plugins such as `@kubb/plugin-fetch` and `@kubb/plugin-axios` use these schemas when you set their `validator` option.
+
+## Setup
+
+Install Zod v4 or higher in the app that uses the generated code. No other plugins are needed.
+
+## Options worth knowing
+
+- `mini` generates Zod Mini schemas for smaller bundles, and switches `importPath` to `zod/mini`.
+- `importPath` sets the module the files import `z` from. The default is `zod`.
+- `inferred` exports a `z.infer` type alias next to each schema.
+- `coercion` wraps schemas in `z.coerce`, so input is converted before validation. Pass an object to coerce only dates, strings, or numbers.
+- `guidType` picks `z.uuid()` (default) or `z.guid()` for `format: uuid`.
+- `regexType` writes a `pattern` as a regex literal (default) or a `RegExp` constructor.
+- `typeGuards` adds `is*` type guards and `assert*` assertions.
+- `compile` wraps schemas in `z.compile` for faster validation.
+
+## Example
+
+```typescript [kubb.config.ts]
+import { defineConfig } from 'kubb/config'
+import { pluginZod } from '@kubb/plugin-zod'
+
+export default defineConfig({
+  input: './petStore.yaml',
+  output: { path: './src/gen' },
+  plugins: [
+    pluginZod({ inferred: true }),
+  ],
+})
+```
+
+## See also
+
+- [Zod](https://zod.dev/)
+- [Zod Mini](https://zod.dev/packages/mini)

package/kubb-extension.json

@@ -0,0 +1,210 @@
+{
+  "$schema": "https://kubb.dev/schemas/kubb-extension.json",
+  "kind": "plugin",
+  "name": "plugin-zod",
+  "export": "pluginZod",
+  "displayName": "Zod",
+  "description": "Generates Zod v4 schemas from your OpenAPI spec so you validate API responses, form input, and query params at runtime.",
+  "category": "validation",
+  "icon": {
+    "light": "https://kubb.dev/feature/zod.svg"
+  },
+  "tags": ["zod", "validation", "schema", "runtime-validation", "codegen", "openapi"],
+  "docs": "https://kubb.dev/extensions/kubb-labs/plugin-zod",
+  "maintainers": [
+    {
+      "name": "Stijn Van Hulle",
+      "github": "stijnvanhulle"
+    }
+  ],
+  "compatibility": {
+    "kubb": ">=5.8.3",
+    "node": ">=22"
+  },
+  "options": [
+    {
+      "key": "outputPath",
+      "path": ["output", "path"],
+      "label": "Output Path",
+      "description": "Output folder for generated files",
+      "type": "text",
+      "default": "zod"
+    },
+    {
+      "key": "barrel",
+      "path": ["output", "barrel"],
+      "label": "Barrel",
+      "description": "How index.ts barrel files are generated",
+      "type": "select",
+      "default": {
+        "type": "named"
+      },
+      "choices": [
+        {
+          "label": "named",
+          "value": {
+            "type": "named"
+          }
+        },
+        {
+          "label": "named (nested)",
+          "value": {
+            "type": "named",
+            "nested": true
+          }
+        },
+        {
+          "label": "all",
+          "value": {
+            "type": "all"
+          }
+        },
+        {
+          "label": "all (nested)",
+          "value": {
+            "type": "all",
+            "nested": true
+          }
+        },
+        {
+          "label": "false (disabled)",
+          "value": false
+        }
+      ]
+    },
+    {
+      "key": "outputMode",
+      "path": ["output", "mode"],
+      "label": "Output Mode",
+      "description": "How the plugin consolidates its code into files. File mode writes everything into a single file, so the output path must include a file extension and cannot be grouped.",
+      "type": "select",
+      "default": "directory",
+      "choices": [
+        {
+          "label": "directory (one file per schema)",
+          "value": "directory"
+        },
+        {
+          "label": "file (single file)",
+          "value": "file"
+        }
+      ]
+    },
+    {
+      "key": "group",
+      "path": ["group"],
+      "label": "Group",
+      "description": "Group generated operations by OpenAPI tag or path",
+      "type": "select",
+      "default": null,
+      "choices": [
+        {
+          "label": "none",
+          "value": null
+        },
+        {
+          "label": "by tag",
+          "value": {
+            "type": "tag"
+          }
+        },
+        {
+          "label": "by path",
+          "value": {
+            "type": "path"
+          }
+        }
+      ]
+    },
+    {
+      "key": "excludeTags",
+      "path": ["exclude"],
+      "label": "Exclude Tags",
+      "description": "Comma-separated OpenAPI tags to exclude from generation",
+      "type": "list",
+      "item": {
+        "type": "tag",
+        "pattern": "$item"
+      }
+    },
+    {
+      "key": "includeTags",
+      "path": ["include"],
+      "label": "Include Tags",
+      "description": "Comma-separated OpenAPI tags to include. Only operations with these tags are generated",
+      "type": "list",
+      "item": {
+        "type": "tag",
+        "pattern": "$item"
+      }
+    },
+    {
+      "key": "mini",
+      "path": ["mini"],
+      "label": "Zod Mini",
+      "description": "Use Zod Mini functional API for better tree-shaking",
+      "type": "boolean",
+      "default": false
+    },
+    {
+      "key": "importPath",
+      "path": ["importPath"],
+      "label": "Import Path",
+      "description": "Module specifier used in the import statement",
+      "type": "text",
+      "default": "zod"
+    },
+    {
+      "key": "guidType",
+      "path": ["guidType"],
+      "label": "GUID Type",
+      "description": "Validator used for OpenAPI format: uuid",
+      "type": "select",
+      "default": "uuid",
+      "choices": [
+        {
+          "label": "uuid",
+          "value": "uuid"
+        },
+        {
+          "label": "guid",
+          "value": "guid"
+        }
+      ]
+    },
+    {
+      "key": "regexType",
+      "path": ["regexType"],
+      "label": "Regex Type",
+      "description": "Output form for an OpenAPI pattern inside .regex(...)",
+      "type": "select",
+      "default": "literal",
+      "choices": [
+        {
+          "label": "literal",
+          "value": "literal"
+        },
+        {
+          "label": "constructor",
+          "value": "constructor"
+        }
+      ]
+    },
+    {
+      "key": "inferred",
+      "path": ["inferred"],
+      "label": "Inferred",
+      "description": "Export a z.infer type alias next to every generated schema",
+      "type": "boolean",
+      "default": false
+    },
+    {
+      "key": "coercion",
+      "path": ["coercion"],
+      "label": "Coercion",
+      "description": "Wrap schemas in z.coerce so input is coerced before validation",
+      "type": "boolean",
+      "default": false
+    }
+  ]
+}