@kubb/plugin-zod 5.0.0-beta.79 → 5.0.0-beta.81

package/dist/index.d.ts

@@ -55,7 +55,8 @@ type OperationParamsResolver = {
  *
  * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function
  * replaces the built-in handler for that node type. Use `this.transform` to
- * recurse into nested schema nodes, and `this.options` to read printer options.
+ * recurse into nested schema nodes, `this.base` to reuse the output of the
+ * handler being replaced, and `this.options` to read printer options.
  *
  * @example Override the `date` handler
  * ```ts
@@ -63,7 +64,20 @@ type OperationParamsResolver = {
  *   printer: {
  *     nodes: {
  *       date(node) {
- *         return 'z.string().date()'
+ *         return 'z.iso.date()'
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * @example Wrap the built-in output
+ * ```ts
+ * pluginZod({
+ *   printer: {
+ *     nodes: {
+ *       object(node) {
+ *         return `${this.base(node)}.openapi(${JSON.stringify({ description: node.description })})`
  *       },
  *     },
  *   },
@@ -93,10 +107,6 @@ type PrinterZodOptions = {
    * Date format in the OpenAPI spec (`'date'` or `'date-time'`).
    */
   dateType?: AdapterOas['resolvedOptions']['dateType'];
-  /**
-   * Hook to transform generated Zod schema before output.
-   */
-  wrapOutput?: PluginZod['resolvedOptions']['wrapOutput'];
   /**
    * Transforms raw schema names into valid JavaScript identifiers.
    */
@@ -112,8 +122,8 @@ type PrinterZodOptions = {
   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).
+   * - `'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.
@@ -154,7 +164,8 @@ declare const printerZod: (options?: PrinterZodOptions | undefined) => ast.Print
  *
  * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`). The function
  * replaces the built-in handler for that node type. Use `this.transform` to
- * recurse into nested schema nodes, and `this.options` to read printer options.
+ * recurse into nested schema nodes, `this.base` to reuse the output of the
+ * handler being replaced, and `this.options` to read printer options.
  *
  * @example Override the `date` handler
  * ```ts
@@ -185,10 +196,6 @@ type PrinterZodMiniOptions = {
    * @default 'literal'
    */
   regexType?: PluginZod['resolvedOptions']['regexType'];
-  /**
-   * Hook to transform generated Zod schema before output.
-   */
-  wrapOutput?: PluginZod['resolvedOptions']['wrapOutput'];
   /**
    * Transforms raw schema names into valid JavaScript identifiers.
    */
@@ -218,7 +225,7 @@ type PrinterZodMiniOptions = {
  */
 type PrinterZodMiniFactory = ast.PrinterFactoryOptions<'zod-mini', PrinterZodMiniOptions, string, string>;
 /**
- * Zod v4 **Mini** printer built with `definePrinter`.
+ * Zod v4 Mini printer built with `definePrinter`.
  *
  * Converts a `SchemaNode` AST into a Zod v4 code string using the functional API
  * (`z.optional(z.string())`) for improved tree-shaking. See {@link printerZod} for the chainable API.
@@ -350,12 +357,6 @@ type Options = OutputOptions & {
    * @default mini ? 'zod/mini' : 'zod'
    */
   importPath?: 'zod' | 'zod/mini' | (string & {});
-  /**
-   * 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;
   /**
    * Export a `z.infer<typeof schema>` type alias next to every generated schema.
    * Lets the Zod schema act as the single source of truth.
@@ -367,6 +368,10 @@ type Options = OutputOptions & {
    * - `true` coerces strings, numbers, and dates.
    * - Object form picks per-primitive coercion.
    *
+   * `dates` applies to fields typed as `Date` (adapter `dateType: 'date'`): they
+   * validate with `z.coerce.date()` instead of the string-to-Date codec. Fields
+   * kept as ISO strings (`z.iso.date()`, `z.iso.datetime()`) are never coerced.
+   *
    * @default false
    * @see https://zod.dev/?id=coercion-for-primitives
    */
@@ -377,16 +382,16 @@ type Options = OutputOptions & {
   };
   /**
    * Validator for `format: uuid` properties.
-   * - `'uuid'` — `z.uuid()`. Standard RFC 4122.
-   * - `'guid'` — `z.guid()`. Accepts Microsoft-style GUIDs.
+   * - `'uuid'`: `z.uuid()`. Standard RFC 4122.
+   * - `'guid'`: `z.guid()`. Accepts Microsoft-style GUIDs.
    *
    * @default 'uuid'
    */
   guidType?: 'uuid' | 'guid';
   /**
    * Output form for an OpenAPI `pattern` inside `.regex(...)`.
-   * - `'literal'` — a regex literal: `.regex(/^[a-z]+$/)`.
-   * - `'constructor'` — the `RegExp` constructor: `.regex(new RegExp("^[a-z]+$"))`.
+   * - `'literal'`: a regex literal, `.regex(/^[a-z]+$/)`.
+   * - `'constructor'`: the `RegExp` constructor, `.regex(new RegExp("^[a-z]+$"))`.
    *
    * @default 'literal'
    */
@@ -399,15 +404,6 @@ type Options = OutputOptions & {
    * @beta
    */
   mini?: boolean;
-  /**
-   * 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;
   /**
    * Override how schema and operation names are built. Methods you omit fall back
    * to the default `resolverZod`.
@@ -431,14 +427,12 @@ type ResolvedOptions = {
   include: Array<Include> | undefined;
   override: Array<Override<ResolvedOptions>>;
   group: Group | null;
-  typed: NonNullable<Options['typed']>;
   inferred: NonNullable<Options['inferred']>;
   importPath: NonNullable<Options['importPath']>;
   coercion: NonNullable<Options['coercion']>;
   guidType: NonNullable<Options['guidType']>;
   regexType: NonNullable<Options['regexType']>;
   mini: NonNullable<Options['mini']>;
-  wrapOutput: Options['wrapOutput'];
   printer: Options['printer'];
 };
 type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, ResolverZod>;
@@ -485,7 +479,7 @@ declare const pluginZodName = "plugin-zod";
  *     pluginTs(),
  *     pluginZod({
  *       output: { path: './zod' },
- *       typed: true,
+ *       inferred: true,
  *     }),
  *   ],
  * })

package/dist/index.js

@@ -410,6 +410,46 @@ function collectCodecRefNames(node) {
 	return ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? extractRefName(n.ref) ?? void 0 : void 0 });
 }
 /**
+* Whether the node is a plain inline object whose shape can be lifted into an `.extend({ … })`
+* argument. A catchall, `patternProperties`, or a nullable/optional wrapper cannot, so those stay
+* on `.and(…)`.
+*/
+function isPlainInlineObject(node) {
+	return node.type === "object" && !node.nullable && !node.optional && !node.nullish && node.additionalProperties === void 0 && !node.patternProperties;
+}
+/**
+* Whether a node renders as a bare Zod object — one that accepts `.extend(…)` and can be a
+* `z.discriminatedUnion` option. Covers object nodes, `$ref`s that resolve to (or are still
+* unresolved) objects, single-member unions of an object, and object-composable `allOf`.
+*
+* `cyclicSchemas` bounds the recursion: a ref into a cycle renders as `z.lazy(…)`, not an object.
+*/
+function isObjectSchemaNode(node, cyclicSchemas) {
+	if (node.nullable || node.optional || node.nullish) return false;
+	if (node.type === "object") return true;
+	if (node.type === "ref") {
+		const refName = (node.ref ? extractRefName(node.ref) : void 0) ?? node.name;
+		if (refName && cyclicSchemas?.has(refName)) return false;
+		const resolved = syncSchemaRef(node);
+		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
+	}
+	if (node.type === "union") {
+		const members = node.members ?? [];
+		return members.length === 1 && isObjectSchemaNode(members[0], cyclicSchemas);
+	}
+	return isObjectComposableIntersection(node, cyclicSchemas);
+}
+/**
+* Whether an `allOf` is a pure object composition — an object base plus inline object members whose
+* shapes merge with `.extend(…)`. These stay a Zod object instead of a `ZodIntersection`, which
+* `z.discriminatedUnion` rejects.
+*/
+function isObjectComposableIntersection(node, cyclicSchemas) {
+	if (node.type !== "intersection") return false;
+	const [first, ...rest] = node.members ?? [];
+	return !!first && isObjectSchemaNode(first, cyclicSchemas) && rest.every(isPlainInlineObject);
+}
+/**
 * Format a default value as a code-level literal.
 * Objects become `{}`, primitives become their string representation, strings are quoted.
 */
@@ -617,6 +657,41 @@ function getMemberConstraint({ member, regexType }) {
 	}) || void 0;
 }
 /**
+* Builds the `{ key: value, … }` shape for an object node, shared by the `z.object(...)` and
+* `.extend(...)` renderings so they stay in lockstep.
+*/
+function buildZodObjectShape(ctx, node) {
+	const objectNode = ast.narrowSchema(node, "object");
+	if (!objectNode) return "{}";
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(mapSchemaProperties(objectNode, (schema) => {
+		const hasSelfRef = isCyclic(schema);
+		const savedCyclicSchemas = ctx.options.cyclicSchemas;
+		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
+		const baseOutput = ctx.transform(schema) ?? ctx.transform(ast.factory.createSchema({ type: "unknown" }));
+		if (hasSelfRef) ctx.options.cyclicSchemas = savedCyclicSchemas;
+		return baseOutput;
+	}).map(({ name: propName, property, output: baseOutput }) => {
+		const { schema } = property;
+		const meta = syncSchemaRef(schema);
+		const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
+		const value = applyModifiers({
+			value: baseOutput,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || property.required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default,
+			description: descriptionToApply,
+			examples: meta.examples
+		});
+		return isCyclic(schema) ? lazyGetter({
+			name: propName,
+			body: value
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
+}
+/**
 * Zod v4 printer built with `definePrinter`.
 *
 * Converts a `SchemaNode` AST into a Zod v4 code string using the chainable API
@@ -657,7 +732,10 @@ const printerZod = ast.createPrinter((options) => {
 			},
 			date(node) {
 				const codec = getCodec(node);
-				if (codec) return this.options.direction === "input" ? codec.encode(node) : codec.decode(node);
+				if (codec) {
+					if (this.options.direction === "input") return codec.encode(node);
+					return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : codec.decode(node);
+				}
 				return "z.iso.date()";
 			},
 			datetime(node) {
@@ -710,38 +788,8 @@ const printerZod = ast.createPrinter((options) => {
 				return resolvedName;
 			},
 			object(node) {
-				const isCyclic = (schema) => this.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
-				const entries = mapSchemaProperties(node, (schema) => {
-					const hasSelfRef = isCyclic(schema);
-					const savedCyclicSchemas = this.options.cyclicSchemas;
-					if (hasSelfRef) this.options.cyclicSchemas = void 0;
-					const baseOutput = this.transform(schema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
-					return baseOutput;
-				}).map(({ name: propName, property, output: baseOutput }) => {
-					const { schema } = property;
-					const meta = syncSchemaRef(schema);
-					const wrappedOutput = this.options.wrapOutput ? this.options.wrapOutput({
-						output: baseOutput,
-						schema
-					}) || baseOutput : baseOutput;
-					const descriptionToApply = schema.type !== "ref" && meta.type === "ref" ? void 0 : meta.description;
-					const value = applyModifiers({
-						value: wrappedOutput,
-						schema,
-						nullable: meta.nullable,
-						optional: schema.optional || property.required === false,
-						nullish: schema.nullish,
-						defaultValue: meta.default,
-						description: descriptionToApply,
-						examples: meta.examples
-					});
-					return isCyclic(schema) ? lazyGetter({
-						name: propName,
-						body: value
-					}) : `${objectKey(propName)}: ${value}`;
-				});
-				const objectBase = `z.object(${buildObject(entries)})`;
+				const entries = node.properties ?? [];
+				const objectBase = `z.object(${buildZodObjectShape(this, node)})`;
 				return (() => {
 					const patterns = node.patternProperties ? Object.entries(node.patternProperties) : [];
 					if (node.additionalProperties && node.additionalProperties !== true) {
@@ -781,7 +829,7 @@ const printerZod = ast.createPrinter((options) => {
 				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember$1(output, schema, cyclicSchemaNames) : output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
-				const allDiscriminable = nodeMembers.every((m) => (m.type === "ref" ? syncSchemaRef(m) : m).type !== "intersection");
+				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
 				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
 				return `z.union(${buildList(members)})`;
 			},
@@ -792,6 +840,7 @@ const printerZod = ast.createPrinter((options) => {
 				if (!first) return "";
 				const firstBase = this.transform(first);
 				if (!firstBase) return "";
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `${acc}.extend(${buildZodObjectShape(this, member)})`, firstBase);
 				return rest.reduce((acc, member) => {
 					const constraint = getMemberConstraint({
 						member,
@@ -801,9 +850,9 @@ const printerZod = ast.createPrinter((options) => {
 					const transformed = this.transform(member);
 					return transformed ? `${acc}.and(${transformed})` : acc;
 				}, firstBase);
-			},
-			...options.nodes
+			}
 		},
+		overrides: options.nodes,
 		print(node) {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
@@ -847,7 +896,39 @@ function getMemberConstraintMini({ member, regexType }) {
 	}) || void 0;
 }
 /**
-* Zod v4 **Mini** printer built with `definePrinter`.
+* Builds the `{ key: value, … }` shape for an object node with the functional `zod/mini` modifiers,
+* shared by the `z.object(...)` and `z.extend(...)` renderings so they stay in lockstep.
+*/
+function buildZodMiniObjectShape(ctx, node) {
+	const objectNode = ast.narrowSchema(node, "object");
+	if (!objectNode) return "{}";
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	return buildObject(mapSchemaProperties(objectNode, (schema) => {
+		const hasSelfRef = isCyclic(schema);
+		const savedCyclicSchemas = ctx.options.cyclicSchemas;
+		if (hasSelfRef) ctx.options.cyclicSchemas = void 0;
+		const baseOutput = ctx.transform(schema) ?? ctx.transform(ast.factory.createSchema({ type: "unknown" }));
+		if (hasSelfRef) ctx.options.cyclicSchemas = savedCyclicSchemas;
+		return baseOutput;
+	}).map(({ name: propName, property, output: baseOutput }) => {
+		const { schema } = property;
+		const meta = syncSchemaRef(schema);
+		const value = applyMiniModifiers({
+			value: baseOutput,
+			schema,
+			nullable: meta.nullable,
+			optional: schema.optional || property.required === false,
+			nullish: schema.nullish,
+			defaultValue: meta.default
+		});
+		return isCyclic(schema) ? lazyGetter({
+			name: propName,
+			body: value
+		}) : `${objectKey(propName)}: ${value}`;
+	}));
+}
+/**
+* Zod v4 Mini printer built with `definePrinter`.
 *
 * Converts a `SchemaNode` AST into a Zod v4 code string using the functional API
 * (`z.optional(z.string())`) for improved tree-shaking. See {@link printerZod} for the chainable API.
@@ -859,6 +940,7 @@ function getMemberConstraintMini({ member, regexType }) {
 * ```
 */
 const printerZodMini = ast.createPrinter((options) => {
+	const cyclicSchemaNames = options.cyclicSchemas;
 	return {
 		name: "zod-mini",
 		options,
@@ -933,34 +1015,8 @@ const printerZodMini = ast.createPrinter((options) => {
 				return resolvedName;
 			},
 			object(node) {
-				const isCyclic = (schema) => this.options.cyclicSchemas != null && containsCircularRef(schema, { circularSchemas: this.options.cyclicSchemas });
-				const entries = mapSchemaProperties(node, (schema) => {
-					const hasSelfRef = isCyclic(schema);
-					const savedCyclicSchemas = this.options.cyclicSchemas;
-					if (hasSelfRef) this.options.cyclicSchemas = void 0;
-					const baseOutput = this.transform(schema) ?? this.transform(ast.factory.createSchema({ type: "unknown" }));
-					if (hasSelfRef) this.options.cyclicSchemas = savedCyclicSchemas;
-					return baseOutput;
-				}).map(({ name: propName, property, output: baseOutput }) => {
-					const { schema } = property;
-					const meta = syncSchemaRef(schema);
-					const value = applyMiniModifiers({
-						value: this.options.wrapOutput ? this.options.wrapOutput({
-							output: baseOutput,
-							schema
-						}) || baseOutput : baseOutput,
-						schema,
-						nullable: meta.nullable,
-						optional: schema.optional || property.required === false,
-						nullish: schema.nullish,
-						defaultValue: meta.default
-					});
-					return isCyclic(schema) ? lazyGetter({
-						name: propName,
-						body: value
-					}) : `${objectKey(propName)}: ${value}`;
-				});
-				const objectBase = `z.object(${buildObject(entries)})`;
+				const entries = node.properties ?? [];
+				const objectBase = `z.object(${buildZodMiniObjectShape(this, node)})`;
 				const patterns = node.patternProperties ? Object.entries(node.patternProperties) : [];
 				if (node.additionalProperties && node.additionalProperties !== true) {
 					const catchallType = this.transform(node.additionalProperties);
@@ -998,7 +1054,7 @@ const printerZodMini = ast.createPrinter((options) => {
 				const members = mapSchemaMembers(node, (memberNode) => this.transform(memberNode)).map(({ schema, output }) => output && node.strategy === "one" ? strictOneOfMember(output, schema) : output).filter(Boolean);
 				if (members.length === 0) return "";
 				if (members.length === 1) return members[0];
-				const allDiscriminable = nodeMembers.every((m) => (m.type === "ref" ? syncSchemaRef(m) : m).type !== "intersection");
+				const allDiscriminable = nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemaNames));
 				if (node.discriminatorPropertyName && allDiscriminable) return `z.discriminatedUnion(${stringify(node.discriminatorPropertyName)}, ${buildList(members)})`;
 				return `z.union(${buildList(members)})`;
 			},
@@ -1009,6 +1065,7 @@ const printerZodMini = ast.createPrinter((options) => {
 				if (!first) return "";
 				const firstBase = this.transform(first);
 				if (!firstBase) return "";
+				if (rest.length > 0 && isObjectComposableIntersection(node, cyclicSchemaNames)) return rest.reduce((acc, member) => `z.extend(${acc}, ${buildZodMiniObjectShape(this, member)})`, firstBase);
 				return rest.reduce((acc, member) => {
 					const constraint = getMemberConstraintMini({
 						member,
@@ -1018,9 +1075,9 @@ const printerZodMini = ast.createPrinter((options) => {
 					const transformed = this.transform(member);
 					return transformed ? `z.intersection(${acc}, ${transformed})` : acc;
 				}, firstBase);
-			},
-			...options.nodes
+			}
 		},
+		overrides: options.nodes,
 		print(node) {
 			const { keysToOmit } = this.options;
 			const transformed = this.transform(node);
@@ -1050,12 +1107,12 @@ const zodPrinterCache = /* @__PURE__ */ new WeakMap();
 const zodMiniPrinterCache = /* @__PURE__ */ new WeakMap();
 /**
 * Returns the cached `output`/`input` direction printers for a resolver, building them on
-* first use. The `input` printer encodes `Date → string` for request bodies; `output` decodes
+* first use. The `input` printer encodes `Date → string` for request bodies, and `output` decodes
 * `string → Date` for responses. Schemas without `dateType: 'date'` fields print identically.
 */
 function getStdPrinters(resolver, params) {
 	const cached = zodPrinterCache.get(resolver);
-	if (cached && cached.coercion === params.coercion && cached.guidType === params.guidType && cached.regexType === params.regexType && cached.dateType === params.dateType) return {
+	if (cached && cached.coercion === params.coercion && cached.guidType === params.guidType && cached.regexType === params.regexType && cached.dateType === params.dateType && cached.nodes === params.nodes) return {
 		output: cached.output,
 		input: cached.input
 	};
@@ -1077,7 +1134,8 @@ function getStdPrinters(resolver, params) {
 		coercion: params.coercion,
 		guidType: params.guidType,
 		regexType: params.regexType,
-		dateType: params.dateType
+		dateType: params.dateType,
+		nodes: params.nodes
 	});
 	return {
 		output,
@@ -1086,7 +1144,7 @@ function getStdPrinters(resolver, params) {
 }
 function getMiniPrinter(resolver, params) {
 	const cached = zodMiniPrinterCache.get(resolver);
-	if (cached && cached.guidType === params.guidType && cached.regexType === params.regexType) return cached.printer;
+	if (cached && cached.guidType === params.guidType && cached.regexType === params.regexType && cached.nodes === params.nodes) return cached.printer;
 	const p = printerZodMini({
 		...params,
 		resolver
@@ -1094,7 +1152,8 @@ function getMiniPrinter(resolver, params) {
 	zodMiniPrinterCache.set(resolver, {
 		printer: p,
 		guidType: params.guidType,
-		regexType: params.regexType
+		regexType: params.regexType,
+		nodes: params.nodes
 	});
 	return p;
 }
@@ -1109,7 +1168,7 @@ const zodGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, regexType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
+		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = adapter.options.dateType;
 		if (!node.name) return;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
@@ -1163,7 +1222,6 @@ const zodGenerator = defineGenerator({
 			guidType,
 			regexType,
 			dateType,
-			wrapOutput,
 			cyclicSchemas,
 			nameMapping,
 			nodes: printer?.nodes
@@ -1171,7 +1229,6 @@ const zodGenerator = defineGenerator({
 		const schemaPrinter = mini ? getMiniPrinter(resolver, {
 			guidType,
 			regexType,
-			wrapOutput,
 			cyclicSchemas,
 			nameMapping,
 			nodes: printer?.nodes
@@ -1231,7 +1288,7 @@ const zodGenerator = defineGenerator({
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
-		const { output, coercion, guidType, regexType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
+		const { output, coercion, guidType, regexType, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = adapter.options.dateType;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const params = caseParams(node.parameters, "camelcase");
@@ -1265,7 +1322,6 @@ const zodGenerator = defineGenerator({
 			const schemaPrinter = mini ? keysToOmit?.length ? printerZodMini({
 				guidType,
 				regexType,
-				wrapOutput,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
@@ -1274,7 +1330,6 @@ const zodGenerator = defineGenerator({
 			}) : getMiniPrinter(resolver, {
 				guidType,
 				regexType,
-				wrapOutput,
 				cyclicSchemas,
 				nameMapping,
 				nodes: printer?.nodes
@@ -1283,7 +1338,6 @@ const zodGenerator = defineGenerator({
 				guidType,
 				regexType,
 				dateType,
-				wrapOutput,
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
@@ -1295,7 +1349,6 @@ const zodGenerator = defineGenerator({
 				guidType,
 				regexType,
 				dateType,
-				wrapOutput,
 				cyclicSchemas,
 				nameMapping,
 				nodes: printer?.nodes
@@ -1549,7 +1602,7 @@ const pluginZodName = "plugin-zod";
 *     pluginTs(),
 *     pluginZod({
 *       output: { path: './zod' },
-*       typed: true,
+*       inferred: true,
 *     }),
 *   ],
 * })
@@ -1559,7 +1612,7 @@ const pluginZod = definePlugin((options) => {
 	const { output = {
 		path: "zod",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], typed = false, mini = false, guidType = "uuid", regexType = "literal", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, printer, resolver: userResolver, macros: userMacros } = options;
+	}, group, exclude = [], include, override = [], mini = false, guidType = "uuid", regexType = "literal", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, printer, resolver: userResolver, macros: userMacros } = options;
 	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginZodName,
@@ -1571,14 +1624,12 @@ const pluginZod = definePlugin((options) => {
 				include,
 				override,
 				group: groupConfig,
-				typed,
 				importPath,
 				coercion,
 				inferred,
 				guidType,
 				regexType,
 				mini,
-				wrapOutput,
 				printer
 			});
 			ctx.setResolver(userResolver ? {