@kubb/plugin-zod 5.0.0-beta.4 → 5.0.0-beta.42

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import * as _$_kubb_core0 from "@kubb/core";
+import { t as __name } from "./chunk-C0LytTxp.js";
 import { Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
 import { AdapterOas } from "@kubb/adapter-oas";
 
@@ -51,12 +50,21 @@ type PrinterZodOptions = {
   /**
    * Properties to exclude using `.omit({ key: true })`.
    */
-  keysToOmit?: Array<string>;
+  keysToOmit?: Array<string> | null;
   /**
    * Schema names that form circular dependency chains.
    * Properties referencing these emit lazy getters wrapping refs in `z.lazy(() => …)`.
    */
   cyclicSchemas?: ReadonlySet<string>;
+  /**
+   * Print direction for `dateType: 'date'` fields (`Date` in TypeScript):
+   * - `'output'` (default) — decode the wire `string` into a `Date` (response bodies).
+   * - `'input'` — encode a `Date` back into the wire `string` (request bodies/params).
+   *
+   * Diverging the directions requires the generator to emit an `${name}InputSchema`
+   * variant for each date-bearing component.
+   */
+  direction?: 'input' | 'output';
   /**
    * Custom handler map for node type overrides.
    */
@@ -121,7 +129,7 @@ type PrinterZodMiniOptions = {
   /**
    * Properties to exclude using `.omit({ key: true })`.
    */
-  keysToOmit?: Array<string>;
+  keysToOmit?: Array<string> | null;
   /**
    * Schema names that form circular dependency chains.
    * Properties referencing these emit lazy getters wrapping refs in `z.lazy(() => …)`.
@@ -166,6 +174,21 @@ type ResolverZod = Resolver & ast.OperationParamsResolver & {
    * `resolver.resolveSchemaTypeName('pet') // → 'Pet'`
    */
   resolveSchemaTypeName(this: ResolverZod, name: string): string;
+  /**
+   * Resolves the schema function name for the request (input) direction of a
+   * date-bearing component, where `Date` is encoded back to a wire `string`.
+   *
+   * @example Input schema names
+   * `resolver.resolveInputSchemaName('order') // → 'orderInputSchema'`
+   */
+  resolveInputSchemaName(this: ResolverZod, name: string): string;
+  /**
+   * Resolves the inferred type name for the request (input) direction variant.
+   *
+   * @example Input schema type names
+   * `resolver.resolveInputSchemaTypeName('order') // → 'OrderInputSchema'`
+   */
+  resolveInputSchemaTypeName(this: ResolverZod, name: string): string;
   /**
    * Resolves the generated type name from the schema.
    *
@@ -222,41 +245,53 @@ type ResolverZod = Resolver & ast.OperationParamsResolver & {
 };
 type Options = {
   /**
-   * @default 'zod'
+   * Where the generated Zod schemas are written and how they are exported.
+   *
+   * @default { path: 'zod', barrel: { type: 'named' } }
    */
   output?: Output;
   /**
-   * Group the Zod schemas based on the provided name.
+   * Split generated files into subfolders based on the operation's tag.
    */
   group?: Group;
   /**
-   * Tags, operations, or paths to exclude from generation.
+   * Skip operations matching at least one entry in the list.
    */
   exclude?: Array<Exclude>;
   /**
-   * Tags, operations, or paths to include in generation.
+   * Restrict generation to operations matching at least one entry in the list.
    */
   include?: Array<Include>;
   /**
-   * Override options for specific tags, operations, or paths.
+   * Apply a different options object to operations matching a pattern.
    */
   override?: Array<Override<ResolvedOptions>>;
   /**
-   * Import path for Zod package.
+   * Module specifier used in the `import { z } from '...'` statement.
+   * Use `'zod/mini'` for the tree-shakeable bundle.
    *
    * @default 'zod'
    */
   importPath?: 'zod' | 'zod/mini' | (string & {});
   /**
-   * Add TypeScript type annotations to generated schemas.
+   * Tie each Zod schema to its TypeScript type from `@kubb/plugin-ts`. Requires
+   * `@kubb/plugin-ts` in the plugins list. TypeScript fails compilation when the
+   * schema drifts from the type.
    */
   typed?: boolean;
   /**
-   * Return schemas as inferred types using `z.infer`.
+   * Export a `z.infer<typeof schema>` type alias next to every generated schema.
+   * Lets the Zod schema act as the single source of truth.
    */
   inferred?: boolean;
   /**
-   * Apply coercion to string values or configure coercion per type.
+   * Wrap schemas in `z.coerce` so input is coerced before validation. Useful for
+   * form data and query params where everything arrives as a string.
+   * - `true` coerces strings, numbers, and dates.
+   * - Object form picks per-primitive coercion.
+   *
+   * @default false
+   * @see https://zod.dev/?id=coercion-for-primitives
    */
   coercion?: boolean | {
     dates?: boolean;
@@ -264,50 +299,59 @@ type Options = {
     numbers?: boolean;
   };
   /**
-   * Generate operation-level schemas (grouped by operationId).
+   * Emit an `operations.ts` file with request body, query/path params, and per-status
+   * response schemas grouped by operation.
    */
   operations?: boolean;
   /**
-   * Validator to use for UUID format: `uuid` or `guid`.
+   * Validator for `format: uuid` properties.
+   * - `'uuid'` — `z.uuid()`. Standard RFC 4122.
+   * - `'guid'` — `z.guid()`. Accepts Microsoft-style GUIDs.
    *
    * @default 'uuid'
    */
   guidType?: 'uuid' | 'guid';
   /**
-   * Use Zod Mini's functional API for better tree-shaking.
+   * Switch to Zod Mini's functional API for better tree-shaking. Also defaults
+   * `importPath` to `'zod/mini'`.
    *
    * @default false
+   * @beta
    */
   mini?: boolean;
   /**
-   * Callback to wrap the generated schema output.
-   *
-   * Useful for adding metadata like `.openapi()` or extension helpers.
+   * Wrap the generated Zod schema string with extra calls. Receives the raw output
+   * and the originating `SchemaNode`. Useful for round-tripping OpenAPI metadata
+   * back into Zod (e.g. `.openapi(...)`).
    */
   wrapOutput?: (arg: {
     output: string;
     schema: ast.SchemaNode;
   }) => string | undefined;
   /**
-   * Apply casing to parameter names.
+   * Rename properties inside path/query/header schemas. Body schemas are unaffected.
+   *
+   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
    */
   paramsCasing?: 'camelcase';
   /**
-   * Additional generators alongside the default generators.
+   * Custom generators that run alongside the built-in Zod generators.
    */
   generators?: Array<Generator<PluginZod>>;
   /**
-   * Override naming conventions for schema names and types.
+   * Override how schema and operation names are built. Methods you omit fall back
+   * to the default `resolverZod`.
    */
   resolver?: Partial<ResolverZod> & ThisType<ResolverZod>;
   /**
-   * Override printer node handlers to customize rendering of specific schema types.
+   * Replace the Zod handler for a specific schema type (`'integer'`, `'date'`, ...).
+   * When `mini: true`, overrides target the Zod Mini printer instead.
    */
   printer?: {
     nodes?: PrinterZodNodes | PrinterZodMiniNodes;
   };
   /**
-   * AST visitor to transform schema and operation nodes.
+   * AST visitor applied to each schema or operation node before printing.
    */
   transformer?: ast.Visitor;
 };
@@ -316,7 +360,7 @@ type ResolvedOptions = {
   exclude: Array<Exclude>;
   include: Array<Include> | undefined;
   override: Array<Override<ResolvedOptions>>;
-  group: Group | undefined;
+  group: Group | null;
   typed: NonNullable<Options['typed']>;
   inferred: NonNullable<Options['inferred']>;
   importPath: NonNullable<Options['importPath']>;
@@ -338,36 +382,60 @@ declare global {
 }
 //#endregion
 //#region src/generators/zodGenerator.d.ts
-declare const zodGenerator: _$_kubb_core0.Generator<PluginZod, unknown>;
+/**
+ * Built-in generator for `@kubb/plugin-zod`. Emits one Zod schema per
+ * schema in the spec plus per-operation request/response/parameter schemas.
+ * When `mini: true`, schemas use the Zod Mini functional API instead of
+ * chainable methods.
+ */
+declare const zodGenerator: import("@kubb/core").Generator<PluginZod, unknown>;
 //#endregion
 //#region src/plugin.d.ts
 /**
- * Canonical plugin name for `@kubb/plugin-zod`, used in driver lookups and warnings.
+ * Canonical plugin name for `@kubb/plugin-zod`. Used for driver lookups and
+ * cross-plugin dependency references.
  */
 declare const pluginZodName = "plugin-zod";
 /**
- * Generates Zod validation schemas from an OpenAPI specification.
- * Walks schemas and operations, delegates to generators, and writes barrel files
- * based on the configured `barrelType`.
+ * Generates Zod v4 schemas from an OpenAPI spec. Use them to validate API
+ * responses at runtime, build form schemas, or feed back into router libraries
+ * that consume Zod (tRPC, Hono, Elysia). Pair with `@kubb/plugin-client` and
+ * set the client's `parser: 'zod'` to validate every response automatically.
  *
- * @example Zod schema generator
+ * @example
  * ```ts
- * import pluginZod from '@kubb/plugin-zod'
+ * import { defineConfig } from 'kubb'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginZod } from '@kubb/plugin-zod'
+ *
  * export default defineConfig({
- *   plugins: [pluginZod({ output: { path: 'zod' } })]
+ *   input: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginZod({
+ *       output: { path: './zod' },
+ *       typed: true,
+ *     }),
+ *   ],
  * })
  * ```
  */
-declare const pluginZod: (options?: Options | undefined) => _$_kubb_core0.Plugin<PluginZod>;
+declare const pluginZod: (options?: Options | undefined) => import("@kubb/core").Plugin<PluginZod>;
 //#endregion
 //#region src/resolvers/resolverZod.d.ts
 /**
- * Naming convention resolver for Zod plugin.
+ * Default resolver used by `@kubb/plugin-zod`. Decides the names and file
+ * paths for every generated Zod schema. Schemas use camelCase with a
+ * `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase.
  *
- * Provides default naming helpers using camelCase with a `Schema` suffix for schemas.
+ * @example Resolve schema and type names
+ * ```ts
+ * import { resolverZod } from '@kubb/plugin-zod'
  *
- * @example
- * `resolverZod.default('list pets', 'function')  // → 'listPetsSchema'`
+ * resolverZod.default('list pets', 'function') // 'listPetsSchema'
+ * resolverZod.resolveSchemaTypeName('pet')     // 'PetSchema'
+ * ```
  */
 declare const resolverZod: ResolverZod;
 //#endregion