@kubb/plugin-zod 5.8.0-canary.20261029T124214 → 5.8.1

package/dist/index.cjs

@@ -2,9 +2,9 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-let kubb_kit = require("kubb/kit");
-let kubb_jsx = require("kubb/jsx");
-let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
+let _kubb_kit = require("@kubb/kit");
+let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
+let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
 // ../../internals/shared/src/operation.ts
 /**
 * Maps a content type to the PascalCase suffix used to name per-content-type variants
@@ -94,7 +94,7 @@ function hasRequestContentTypeChoice(node) {
 function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
 	const { path, query, header } = getOperationParameters(node);
 	const hasBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const createNever = () => kubb_kit.ast.factory.createSchema({
+	const createNever = () => _kubb_kit.ast.factory.createSchema({
 		type: "never",
 		primitive: void 0,
 		optional: true
@@ -116,22 +116,22 @@ function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
 			resolve: resolver.param.headers
 		}
 	];
-	const createOptions = (body, extra = []) => kubb_kit.ast.factory.createSchema({
+	const createOptions = (body, extra = []) => _kubb_kit.ast.factory.createSchema({
 		type: "object",
 		primitive: "object",
 		deprecated: node.deprecated,
 		properties: [
-			kubb_kit.ast.factory.createProperty({
+			_kubb_kit.ast.factory.createProperty({
 				name: "body",
 				required: hasBody,
 				schema: body
 			}),
 			...groups.map(({ name, params, resolve }) => {
 				const required = params.some((param) => param.required);
-				return kubb_kit.ast.factory.createProperty({
+				return _kubb_kit.ast.factory.createProperty({
 					name,
 					required,
-					schema: params.length > 0 ? kubb_kit.ast.factory.createSchema({
+					schema: params.length > 0 ? _kubb_kit.ast.factory.createSchema({
 						type: "ref",
 						name: resolve.call(resolver.param, node, params[0]),
 						optional: !required
@@ -142,25 +142,25 @@ function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
 		]
 	});
 	const variants = pairContentTypes && hasRequestContentTypeChoice(node) ? resolveContentTypeVariants(node.requestBody?.content ?? [], resolver.response.body(node)) : [];
-	if (variants.length < 2) return createOptions(hasBody ? kubb_kit.ast.factory.createSchema({
+	if (variants.length < 2) return createOptions(hasBody ? _kubb_kit.ast.factory.createSchema({
 		type: "ref",
 		name: resolver.response.body(node)
 	}) : createNever());
-	return kubb_kit.ast.factory.createSchema({
+	return _kubb_kit.ast.factory.createSchema({
 		type: "union",
-		members: variants.map((variant, index) => createOptions(kubb_kit.ast.factory.createSchema({
+		members: variants.map((variant, index) => createOptions(_kubb_kit.ast.factory.createSchema({
 			type: "ref",
 			name: variant.name
-		}), [kubb_kit.ast.factory.createProperty({
+		}), [_kubb_kit.ast.factory.createProperty({
 			name: "contentType",
 			required: index > 0,
-			schema: kubb_kit.ast.factory.createSchema({
+			schema: _kubb_kit.ast.factory.createSchema({
 				type: "object",
 				primitive: "object",
-				properties: [kubb_kit.ast.factory.createProperty({
+				properties: [_kubb_kit.ast.factory.createProperty({
 					name: "request",
 					required: true,
-					schema: kubb_kit.ast.factory.createSchema({
+					schema: _kubb_kit.ast.factory.createSchema({
 						type: "enum",
 						enumValues: [variant.contentType]
 					})
@@ -178,26 +178,26 @@ function buildOptionsSchema(node, resolver, { pairContentTypes = false } = {}) {
 function buildResponseRecordEntry(node, res, resolver) {
 	const statusName = resolver.response.status(node, res.statusCode);
 	const variants = (res.content ?? []).filter((entry) => entry.schema);
-	if (variants.length <= 1) return kubb_kit.ast.factory.createSchema({
+	if (variants.length <= 1) return _kubb_kit.ast.factory.createSchema({
 		type: "ref",
 		name: statusName
 	});
-	return kubb_kit.ast.factory.createSchema({
+	return _kubb_kit.ast.factory.createSchema({
 		type: "union",
-		members: resolveContentTypeVariants(variants, statusName).map((variant) => kubb_kit.ast.factory.createSchema({
+		members: resolveContentTypeVariants(variants, statusName).map((variant) => _kubb_kit.ast.factory.createSchema({
 			type: "object",
 			primitive: "object",
-			properties: [kubb_kit.ast.factory.createProperty({
+			properties: [_kubb_kit.ast.factory.createProperty({
 				name: "contentType",
 				required: true,
-				schema: kubb_kit.ast.factory.createSchema({
+				schema: _kubb_kit.ast.factory.createSchema({
 					type: "enum",
 					enumValues: [variant.contentType]
 				})
-			}), kubb_kit.ast.factory.createProperty({
+			}), _kubb_kit.ast.factory.createProperty({
 				name: "data",
 				required: true,
-				schema: kubb_kit.ast.factory.createSchema({
+				schema: _kubb_kit.ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				})
@@ -215,10 +215,10 @@ function buildResponseRecordEntry(node, res, resolver) {
 * SDK's `RequestResult<XResponses>`) resolvable instead of pointing at a missing export.
 */
 function buildResponses(node, resolver) {
-	return kubb_kit.ast.factory.createSchema({
+	return _kubb_kit.ast.factory.createSchema({
 		type: "object",
 		primitive: "object",
-		properties: node.responses.map((res) => kubb_kit.ast.factory.createProperty({
+		properties: node.responses.map((res) => _kubb_kit.ast.factory.createProperty({
 			name: String(res.statusCode),
 			required: true,
 			schema: buildResponseRecordEntry(node, res, resolver)
@@ -250,8 +250,8 @@ function getSuccessResponses(responses) {
 * ```
 */
 function getOasAdapter(adapter) {
-	if (adapter.name !== "oas") throw new kubb_kit.Diagnostics.Error({
-		code: kubb_kit.Diagnostics.code.adapterRequired,
+	if (adapter.name !== "oas") throw new _kubb_kit.Diagnostics.Error({
+		code: _kubb_kit.Diagnostics.code.adapterRequired,
 		severity: "error",
 		message: `Expected the OpenAPI adapter (adapterOas), but received "${adapter.name}".`,
 		help: "Set `adapter: adapterOas()` in kubb.config.ts.",
@@ -584,9 +584,9 @@ function lazyGetter({ name, body }) {
 * @example Suffix applied to the final segment only
 * `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
 */
-function toFilePath(name, caseLast = kubb_kit.camelCase) {
+function toFilePath(name, caseLast = _kubb_kit.camelCase) {
 	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : (0, kubb_kit.camelCase)(part)).filter(Boolean).join("/");
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : (0, _kubb_kit.camelCase)(part)).filter(Boolean).join("/");
 }
 // ../../internals/shared/src/resolver.ts
 /**
@@ -708,7 +708,7 @@ function createCasedFile(caseLast) {
 * Names of the schemas in a circular reference chain, computed once per build.
 */
 function getCircularNames(ctx) {
-	return ctx.memo("circularNames:set", () => kubb_kit.ast.findCircularSchemas(ctx.driver.inputNode?.schemas ?? []));
+	return ctx.memo("circularNames:set", () => _kubb_kit.ast.findCircularSchemas(ctx.driver.inputNode?.schemas ?? []));
 }
 // ../../internals/shared/src/group.ts
 /**
@@ -733,7 +733,7 @@ function createGroupConfig(group) {
 	if (!group) return null;
 	const defaultName = (ctx) => {
 		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return (0, kubb_kit.camelCase)(ctx.group);
+		return (0, _kubb_kit.camelCase)(ctx.group);
 	};
 	return {
 		...group,
@@ -784,14 +784,14 @@ function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuar
 	const printerImports = printer.drainImports();
 	if (!output) return;
 	const needsAnnotation = cyclic && node.type !== "object";
-	const isBare = kubb_kit.ast.isBareRef(node, printer.options.keysToOmit);
-	const isCyclic = Boolean(cyclic || printer.options.cyclicSchemas && (0, kubb_kit.containsCircularRef)(node, { circularSchemas: printer.options.cyclicSchemas }));
+	const isBare = _kubb_kit.ast.isBareRef(node, printer.options.keysToOmit);
+	const isCyclic = Boolean(cyclic || printer.options.cyclicSchemas && (0, _kubb_kit.containsCircularRef)(node, { circularSchemas: printer.options.cyclicSchemas }));
 	const value = Boolean(compile) && !isBare && !isCyclic ? typeof compile === "object" && compile.strict ? `z.compile(${output}, { strict: true })` : `z.compile(${output})` : output;
 	const targetType = inferTypeName ?? `z.infer<typeof ${name}>`;
 	const shouldGenerateIs = isName && (typeof typeGuards === "object" ? typeGuards.is ?? true : Boolean(typeGuards));
 	const shouldGenerateAssert = assertName && (typeof typeGuards === "object" ? typeGuards.assert ?? true : Boolean(typeGuards));
-	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [
-		printerImports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
+		printerImports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 			name: imp.name,
 			path: imp.path,
 			root: imp.root,
@@ -802,44 +802,44 @@ function Zod({ name, node, printer, inferTypeName, inferKind = "infer", typeGuar
 			imp.path,
 			imp.name
 		].join("-"))),
-		/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 			name,
 			isExportable: true,
 			isIndexable: true,
-			children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Const, {
+			children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Const, {
 				export: true,
 				name,
 				type: needsAnnotation ? "z.ZodType" : void 0,
 				children: value
 			})
 		}),
-		inferTypeName && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		inferTypeName && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 			name: inferTypeName,
 			isExportable: true,
 			isIndexable: true,
 			isTypeOnly: true,
-			children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Type, {
+			children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Type, {
 				export: true,
 				name: inferTypeName,
 				children: `z.${inferKind}<typeof ${name}>`
 			})
 		}),
-		shouldGenerateIs && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		shouldGenerateIs && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 			name: isName,
 			isExportable: true,
 			isIndexable: true,
-			children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Const, {
+			children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Const, {
 				export: true,
 				name: isName,
 				JSDoc: { comments: [`Type guard for {@link ${name}}`] },
 				children: mini ? `(data: unknown): data is ${targetType} => z.validate(${name}, data)` : `(data: unknown): data is ${targetType} => ${name}.validate(data)`
 			})
 		}),
-		shouldGenerateAssert && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		shouldGenerateAssert && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 			name: assertName,
 			isExportable: true,
 			isIndexable: true,
-			children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
 				export: true,
 				name: assertName,
 				params: "data: unknown",
@@ -869,7 +869,7 @@ function shouldCoerce(coercion, type) {
 */
 function isClosedKeySchema(node) {
 	if (!node) return false;
-	const resolved = (0, kubb_kit.syncSchemaRef)(node);
+	const resolved = (0, _kubb_kit.syncSchemaRef)(node);
 	if (resolved.type === "enum") return true;
 	if (resolved.type === "union") {
 		const members = resolved.members ?? [];
@@ -907,9 +907,9 @@ function isObjectSchemaNode(node, cyclicSchemas) {
 		return !(!hasProperties && (hasTypedAdditionalProperties || hasPatternProperties || node.propertyNames));
 	}
 	if (node.type === "ref") {
-		const refName = kubb_kit.ast.resolveRefName(node);
+		const refName = _kubb_kit.ast.resolveRefName(node);
 		if (refName && cyclicSchemas?.has(refName)) return false;
-		const resolved = (0, kubb_kit.syncSchemaRef)(node);
+		const resolved = (0, _kubb_kit.syncSchemaRef)(node);
 		return resolved.type === "ref" || isObjectSchemaNode(resolved, cyclicSchemas);
 	}
 	if (node.type === "union") {
@@ -932,23 +932,23 @@ function preserveRequiredProperties(members) {
 	const hasRequiredProperty = ({ node, propertyName, seen = /* @__PURE__ */ new Set() }) => {
 		if (seen.has(node)) return false;
 		seen.add(node);
-		const resolved = (0, kubb_kit.syncSchemaRef)(node);
-		const composition = kubb_kit.ast.narrowSchema(resolved, kubb_kit.ast.schemaTypes.intersection) ?? kubb_kit.ast.narrowSchema(resolved, kubb_kit.ast.schemaTypes.union);
+		const resolved = (0, _kubb_kit.syncSchemaRef)(node);
+		const composition = _kubb_kit.ast.narrowSchema(resolved, _kubb_kit.ast.schemaTypes.intersection) ?? _kubb_kit.ast.narrowSchema(resolved, _kubb_kit.ast.schemaTypes.union);
 		if (composition) {
-			if (composition.type === kubb_kit.ast.schemaTypes.union && composition.members?.length !== 1) return false;
+			if (composition.type === _kubb_kit.ast.schemaTypes.union && composition.members?.length !== 1) return false;
 			return composition.members?.some((child) => hasRequiredProperty({
 				node: child,
 				propertyName,
 				seen
 			})) ?? false;
 		}
-		return kubb_kit.ast.resolveSchemaProperties({
+		return _kubb_kit.ast.resolveSchemaProperties({
 			node: resolved,
 			propertyName
 		}).some((property) => property.required !== false && !property.schema.optional && !property.schema.nullish);
 	};
 	return members.map((member, index) => {
-		const object = kubb_kit.ast.narrowSchema(member, kubb_kit.ast.schemaTypes.object);
+		const object = _kubb_kit.ast.narrowSchema(member, _kubb_kit.ast.schemaTypes.object);
 		if (!object || index === 0) return member;
 		return {
 			...object,
@@ -992,14 +992,14 @@ function formatDefault(value) {
 */
 function defaultLiteral(node, value) {
 	if (value === null) return null;
-	const resolved = node ? (0, kubb_kit.syncSchemaRef)(node) : void 0;
-	if (resolved && kubb_kit.ast.narrowSchema(resolved, "bigint")) {
+	const resolved = node ? (0, _kubb_kit.syncSchemaRef)(node) : void 0;
+	if (resolved && _kubb_kit.ast.narrowSchema(resolved, "bigint")) {
 		if (typeof value === "bigint") return `BigInt(${value})`;
 		if (typeof value === "number" && Number.isInteger(value)) return `BigInt(${value})`;
 		return null;
 	}
-	if (resolved && kubb_kit.ast.narrowSchema(resolved, "array")) return Array.isArray(value) ? JSON.stringify(value) : null;
-	const enumNode = resolved ? kubb_kit.ast.narrowSchema(resolved, "enum") : void 0;
+	if (resolved && _kubb_kit.ast.narrowSchema(resolved, "array")) return Array.isArray(value) ? JSON.stringify(value) : null;
+	const enumNode = resolved ? _kubb_kit.ast.narrowSchema(resolved, "enum") : void 0;
 	if (enumNode) {
 		const values = enumNode.namedEnumValues?.map((member) => member.value) ?? enumNode.enumValues ?? [];
 		if (values.length) {
@@ -1155,7 +1155,7 @@ function modifierDepth(schema) {
 * `.unwrap()`, so its printer passes `._zod.def.innerType` as the `step`.
 */
 function omitUnwrapChain(node, step = ".unwrap()") {
-	const ref = kubb_kit.ast.narrowSchema(node, "ref");
+	const ref = _kubb_kit.ast.narrowSchema(node, "ref");
 	if (!ref) return "";
 	const target = ref.schema ?? ref;
 	const depth = modifierDepth(target) + (target.default !== void 0 ? 1 : 0);
@@ -1201,12 +1201,12 @@ function strictOneOfNode(node) {
 */
 function getMemberConstraint({ member, regexType, lengths, numbers }) {
 	if (member.primitive === "string") return lengths({
-		...kubb_kit.ast.narrowSchema(member, "string") ?? {},
+		..._kubb_kit.ast.narrowSchema(member, "string") ?? {},
 		regexType
 	}) || void 0;
-	if (member.primitive === "number" || member.primitive === "integer") return numbers(kubb_kit.ast.narrowSchema(member, "number") ?? kubb_kit.ast.narrowSchema(member, "integer") ?? {}) || void 0;
+	if (member.primitive === "number" || member.primitive === "integer") return numbers(_kubb_kit.ast.narrowSchema(member, "number") ?? _kubb_kit.ast.narrowSchema(member, "integer") ?? {}) || void 0;
 	if (member.primitive === "array") return lengths({
-		...kubb_kit.ast.narrowSchema(member, "array") ?? {},
+		..._kubb_kit.ast.narrowSchema(member, "array") ?? {},
 		regexType
 	}) || void 0;
 }
@@ -1214,14 +1214,14 @@ function getMemberConstraint({ member, regexType, lengths, numbers }) {
 * Builds the `{ key: value, … }` shape shared by the `z.object(...)` and `.extend(...)` renderings.
 */
 function buildObjectShape(ctx, node, renderProperty) {
-	const objectNode = kubb_kit.ast.narrowSchema(node, "object");
+	const objectNode = _kubb_kit.ast.narrowSchema(node, "object");
 	if (!objectNode) return "{}";
-	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && (0, kubb_kit.containsCircularRef)(schema, { circularSchemas: ctx.options.cyclicSchemas });
+	const isCyclic = (schema) => ctx.options.cyclicSchemas != null && (0, _kubb_kit.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(kubb_kit.ast.factory.createSchema({ type: "unknown" }));
+		const baseOutput = ctx.transform(schema) ?? ctx.transform(_kubb_kit.ast.factory.createSchema({ type: "unknown" }));
 		if (hasSelfRef) ctx.options.cyclicSchemas = savedCyclicSchemas;
 		return baseOutput;
 	}).map(({ name, property, output: value }) => {
@@ -1231,7 +1231,7 @@ function buildObjectShape(ctx, node, renderProperty) {
 			value,
 			schema,
 			required: property.required,
-			meta: (0, kubb_kit.syncSchemaRef)(schema),
+			meta: (0, _kubb_kit.syncSchemaRef)(schema),
 			cyclic: isCyclic(schema)
 		});
 	}));
@@ -1243,7 +1243,7 @@ function printWithOmit(ctx, node, modify, mini = false) {
 	const { keysToOmit } = ctx.options;
 	const transformed = ctx.transform(node);
 	if (!transformed) return null;
-	const meta = (0, kubb_kit.syncSchemaRef)(node);
+	const meta = (0, _kubb_kit.syncSchemaRef)(node);
 	return modify((() => {
 		if (!keysToOmit?.length || meta.primitive !== "object" || meta.type === "union" && meta.discriminatorPropertyName) return transformed;
 		const unwrap = omitUnwrapChain(node, mini ? "._zod.def.innerType" : ".unwrap()");
@@ -1263,6 +1263,37 @@ function printWithOmit(ctx, node, modify, mini = false) {
 }
 // src/printers/zodNodes.ts
 /**
+* Reads a union of bare single-value enums as one enum, except under `xor` or an enum override, which need each member.
+* Only a numeric union with a `format` coerces, because it printed as `z.coerce.number()` before the adapter kept its values.
+*/
+function getLiteralUnion({ node, options }) {
+	if (node.strategy === "one" && options.oneOfType === "xor" || options.nodes?.enum) return void 0;
+	const values = (node.members ?? []).map((member) => {
+		const enumNode = _kubb_kit.ast.narrowSchema(member, _kubb_kit.ast.schemaTypes.enum);
+		return enumNode && !enumNode.name && !enumNode.nullable && !enumNode.namedEnumValues && enumNode.enumValues?.length === 1 ? enumNode.enumValues[0] : void 0;
+	});
+	if (!values.length || !values.every((value) => value !== void 0 && value !== null)) return void 0;
+	return {
+		values,
+		coerce: !!node.format && values.every((value) => typeof value === "number") && shouldCoerce(options.coercion, "numbers")
+	};
+}
+/**
+* Whether a discriminated union member's discriminator property prints as a coerced literal union.
+*/
+function hasCoercedDiscriminator({ member, propertyName, options }) {
+	return _kubb_kit.ast.resolveSchemaProperties({
+		node: member,
+		propertyName
+	}).some(({ schema }) => {
+		const resolved = (0, _kubb_kit.syncSchemaRef)(schema);
+		return resolved.type === "union" && !!getLiteralUnion({
+			node: resolved,
+			options
+		})?.coerce;
+	});
+}
+/**
 * Builds the scalar handlers both dialects share. They never recurse into children. The temporal
 * scalars and `bigint` differ per dialect, so each printer adds its own.
 */
@@ -1343,7 +1374,7 @@ function buildZodNodes(dialect, cyclicSchemas) {
 		...buildScalarNodes(dialect),
 		ref(node) {
 			if (!node.name) return null;
-			const refName = kubb_kit.ast.resolveRefName(node);
+			const refName = _kubb_kit.ast.resolveRefName(node);
 			if (!refName) return null;
 			const useInputVariant = node.ref != null && (dialect.useInputVariant?.(node, this.options) ?? false);
 			const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.schema.inputName(refName) ?? refName : this.options.resolver?.name(refName) ?? refName : node.name;
@@ -1367,14 +1398,14 @@ function buildZodNodes(dialect, cyclicSchemas) {
 						return catchallType ? dialect.catchall(objectBase, catchallType) : objectBase;
 					}
 					if (entries.length === 0 && patterns.length === 0 && propertyNamesKeySchema && !isStrict) {
-						const unknownType = this.transform(kubb_kit.ast.factory.createSchema({ type: kubb_kit.ast.schemaTypes.unknown }));
+						const unknownType = this.transform(_kubb_kit.ast.factory.createSchema({ type: _kubb_kit.ast.schemaTypes.unknown }));
 						return `${recordFn}(${propertyNamesKeySchema}, ${unknownType})`;
 					}
 					if (node.additionalProperties === true) return objectBase;
 					if (isStrict) return objectBase;
 					if (patterns.length > 0) {
 						const values = patterns.map(([, valueSchema]) => {
-							const valueType = this.transform(valueSchema) ?? this.transform(kubb_kit.ast.factory.createSchema({ type: kubb_kit.ast.schemaTypes.unknown }));
+							const valueType = this.transform(valueSchema) ?? this.transform(_kubb_kit.ast.factory.createSchema({ type: _kubb_kit.ast.schemaTypes.unknown }));
 							return valueSchema.nullable ? dialect.nullable(valueType) : valueType;
 						});
 						const distinct = [...new Set(values)];
@@ -1391,7 +1422,7 @@ function buildZodNodes(dialect, cyclicSchemas) {
 			});
 		},
 		array(node) {
-			const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(kubb_kit.ast.factory.createSchema({ type: kubb_kit.ast.schemaTypes.unknown }))})${dialect.lengths({
+			const base = `z.array(${mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean).join(", ") || this.transform(_kubb_kit.ast.factory.createSchema({ type: _kubb_kit.ast.schemaTypes.unknown }))})${dialect.lengths({
 				...node,
 				regexType: this.options.regexType
 			})}`;
@@ -1401,8 +1432,21 @@ function buildZodNodes(dialect, cyclicSchemas) {
 			return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 		},
 		union(node) {
+			const literalUnion = getLiteralUnion({
+				node,
+				options: this.options
+			});
+			if (literalUnion) {
+				const schema = buildEnum(literalUnion.values);
+				return literalUnion.coerce ? dialect.coercedNumber(schema) : schema;
+			}
 			const nodeMembers = node.members ?? [];
-			const isDiscriminated = !!node.discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemas));
+			const { discriminatorPropertyName } = node;
+			const isDiscriminated = !!discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemas)) && !nodeMembers.some((m) => hasCoercedDiscriminator({
+				member: m,
+				propertyName: discriminatorPropertyName,
+				options: this.options
+			}));
 			const isXor = node.strategy === "one" && !isDiscriminated && this.options.oneOfType === "xor";
 			const isStrict = node.strategy === "one" && !isXor && !unionsWithSiblings.has(node);
 			const members = mapSchemaMembers(node, (memberNode) => this.transform(isStrict ? strictOneOfNode(memberNode) : memberNode)).map(({ schema, output }) => output && isStrict && dialect.strictMember ? dialect.strictMember(output, schema, cyclicSchemas) : output).filter(Boolean);
@@ -1415,7 +1459,7 @@ function buildZodNodes(dialect, cyclicSchemas) {
 		intersection(node) {
 			const members = node.members ?? [];
 			if (members.length === 0) return "";
-			const hasSiblingProperties = members.some((member) => member.type === kubb_kit.ast.schemaTypes.object && member.properties.length > 0);
+			const hasSiblingProperties = members.some((member) => member.type === _kubb_kit.ast.schemaTypes.object && member.properties.length > 0);
 			const transform = (member) => {
 				if (!hasSiblingProperties) return this.transform(member);
 				unionsWithSiblings.add(member);
@@ -1446,13 +1490,13 @@ function buildZodNodes(dialect, cyclicSchemas) {
 }
 // src/printers/printerZod.ts
 function strictOneOfMember(member, node, cyclicSchemas) {
-	if (node.type === kubb_kit.ast.schemaTypes.ref) {
+	if (node.type === _kubb_kit.ast.schemaTypes.ref) {
 		if (member.startsWith("z.lazy(")) return member;
-		const refName = kubb_kit.ast.resolveRefName(node);
+		const refName = _kubb_kit.ast.resolveRefName(node);
 		if (refName && cyclicSchemas?.has(refName)) return member;
-		const schema = (0, kubb_kit.syncSchemaRef)(node);
+		const schema = (0, _kubb_kit.syncSchemaRef)(node);
 		if (schema.nullable || schema.optional || node.nullable || node.optional) return member;
-		if (schema.type === kubb_kit.ast.schemaTypes.object && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
+		if (schema.type === _kubb_kit.ast.schemaTypes.object && (schema.additionalProperties === void 0 || schema.additionalProperties === false)) return `${member}.strict()`;
 	}
 	return member;
 }
@@ -1468,7 +1512,7 @@ function buildZodObjectShape(ctx, node) {
 			optional: schema.optional || required === false,
 			nullish: schema.nullish,
 			defaultValue: meta.default,
-			description: schema.type !== kubb_kit.ast.schemaTypes.ref && meta.type === kubb_kit.ast.schemaTypes.ref ? void 0 : meta.description,
+			description: schema.type !== _kubb_kit.ast.schemaTypes.ref && meta.type === _kubb_kit.ast.schemaTypes.ref ? void 0 : meta.description,
 			examples: meta.examples
 		});
 		if (!cyclic) return `${objectKey(name)}: ${body}`;
@@ -1489,21 +1533,21 @@ function buildZodObjectShape(ctx, node) {
 function recursiveGetterType({ ctx, schema, required }) {
 	function baseType(schema) {
 		if (ctx.options.nodes?.[schema.type]) return void 0;
-		if (schema.type === kubb_kit.ast.schemaTypes.ref) {
+		if (schema.type === _kubb_kit.ast.schemaTypes.ref) {
 			const saved = ctx.options.cyclicSchemas;
 			ctx.options.cyclicSchemas = void 0;
 			const name = ctx.transform(schema);
 			ctx.options.cyclicSchemas = saved;
 			return name ? `typeof ${name}` : void 0;
 		}
-		if (schema.type === kubb_kit.ast.schemaTypes.array && schema.items?.length === 1) {
+		if (schema.type === _kubb_kit.ast.schemaTypes.array && schema.items?.length === 1) {
 			const item = baseType(schema.items[0]);
 			return item ? `z.ZodArray<${item}>` : void 0;
 		}
 	}
 	const base = baseType(schema);
 	if (!base) return void 0;
-	const meta = (0, kubb_kit.syncSchemaRef)(schema);
+	const meta = (0, _kubb_kit.syncSchemaRef)(schema);
 	const optional = schema.optional || required === false;
 	const wrapped = (() => {
 		if (schema.nullish || meta.nullable && optional) return `z.ZodOptional<z.ZodNullable<${base}>>`;
@@ -1518,12 +1562,12 @@ function recursiveGetterType({ ctx, schema, required }) {
 * `direction` themselves, so {@link containsDirectionalNode} probes their children instead.
 */
 const CONTAINER_TYPES = /* @__PURE__ */ new Set([
-	kubb_kit.ast.schemaTypes.object,
-	kubb_kit.ast.schemaTypes.array,
-	kubb_kit.ast.schemaTypes.tuple,
-	kubb_kit.ast.schemaTypes.union,
-	kubb_kit.ast.schemaTypes.intersection,
-	kubb_kit.ast.schemaTypes.ref
+	_kubb_kit.ast.schemaTypes.object,
+	_kubb_kit.ast.schemaTypes.array,
+	_kubb_kit.ast.schemaTypes.tuple,
+	_kubb_kit.ast.schemaTypes.union,
+	_kubb_kit.ast.schemaTypes.intersection,
+	_kubb_kit.ast.schemaTypes.ref
 ]);
 /**
 * Runs the node's effective handler (a `printer.nodes` override, else the built-in) once per
@@ -1554,7 +1598,7 @@ function variesByDirection({ node, printerOptions }) {
 */
 function containsDirectionalNode({ node, printerOptions }) {
 	if (!node) return false;
-	return kubb_kit.ast.findSchema(node, {
+	return _kubb_kit.ast.findSchema(node, {
 		predicate: (schema) => variesByDirection({
 			node: schema,
 			printerOptions
@@ -1566,10 +1610,10 @@ function containsDirectionalNode({ node, printerOptions }) {
 * Names of the `$ref` schemas the generator should route to their input (encode) variant.
 */
 function collectDirectionalRefNames({ node, printerOptions }) {
-	return kubb_kit.ast.collectSync(node, { schema: (n) => n.type === kubb_kit.ast.schemaTypes.ref && n.ref && containsDirectionalNode({
+	return _kubb_kit.ast.collectSync(node, { schema: (n) => n.type === _kubb_kit.ast.schemaTypes.ref && n.ref && containsDirectionalNode({
 		node: n,
 		printerOptions
-	}) ? kubb_kit.ast.resolveRefName(n) ?? void 0 : void 0 });
+	}) ? _kubb_kit.ast.resolveRefName(n) ?? void 0 : void 0 });
 }
 /**
 * Handlers that never recurse into children, so {@link variesByDirection} can call one directly
@@ -1588,6 +1632,7 @@ const standardDialect = {
 	patternKey: patternKeySchema,
 	objectShape: buildZodObjectShape,
 	coercedInt: "z.coerce.number().int()",
+	coercedNumber: (schema) => `z.coerce.number().pipe(${schema})`,
 	catchall: (object, value) => `${object}.catchall(${value})`,
 	nullable: (value) => `${value}.nullable()`,
 	unique: (array) => `${array}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`,
@@ -1635,7 +1680,7 @@ const scalarNodes = {
 * const code = printer.print(stringNode) // "z.string()"
 * ```
 */
-const printerZod = kubb_kit.ast.createPrinter((options) => {
+const printerZod = _kubb_kit.ast.createPrinter((options) => {
 	return {
 		name: "zod",
 		options,
@@ -1696,13 +1741,14 @@ const miniDialect = {
 	patternKey: patternKeySchemaMini,
 	objectShape: buildZodMiniObjectShape,
 	coercedInt: "z.coerce.number().check(z.int())",
+	coercedNumber: (schema) => `z.pipe(z.coerce.number(), ${schema})`,
 	catchall: (object, value) => `z.catchall(${object}, ${value})`,
 	nullable: (value) => `z.nullable(${value})`,
 	unique: (array) => `${array}.check(z.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" }))`,
 	extend: (base, shape) => `z.extend(${base}, ${shape})`,
 	intersection: (left, right) => `z.intersection(${left}, ${right})`
 };
-const printerZodMini = kubb_kit.ast.createPrinter((options) => {
+const printerZodMini = _kubb_kit.ast.createPrinter((options) => {
 	return {
 		name: "zod-mini",
 		options,
@@ -1777,9 +1823,9 @@ function getPrinter(resolver, options, mini, direction) {
 * When `mini: true`, schemas use the Zod Mini functional API instead of
 * chainable methods.
 */
-const zodGenerator = (0, kubb_kit.defineGenerator)({
+const zodGenerator = (0, _kubb_kit.defineGenerator)({
 	name: "zod",
-	renderer: kubb_jsx.jsxRenderer,
+	renderer: _kubb_renderer_jsx.jsxRenderer,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
 		const { output, coercion, guidType, regexType, oneOfType, compile, mini, inferred, typeGuards, importPath, group, printer } = ctx.options;
@@ -1835,7 +1881,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 		const isName = typeGuards ? resolver.schema.isName(node.name) : null;
 		const assertName = typeGuards ? resolver.schema.assertName(node.name) : null;
 		const schemaPrinter = getPrinter(resolver, printerOptions, mini, "decode");
-		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
@@ -1856,12 +1902,12 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 				}
 			}),
 			children: [
-				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 					name: isZodImport ? "z" : ["z"],
 					path: importPath,
 					isNameSpace: isZodImport
 				}),
-				imports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+				imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
@@ -1870,7 +1916,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 					imp.path,
 					imp.name
 				].join("-"))),
-				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Zod, {
+				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Zod, {
 					name: meta.name,
 					node,
 					printer: schemaPrinter,
@@ -1883,7 +1929,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 					cyclic: cyclicSchemas.has(node.name),
 					compile
 				}),
-				hasDirectionalNode && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Zod, {
+				hasDirectionalNode && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Zod, {
 					name: resolver.schema.inputName(node.name),
 					node,
 					printer: getPrinter(resolver, printerOptions, mini, "encode"),
@@ -1900,7 +1946,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 		});
 	},
 	operation(node, ctx) {
-		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		if (!_kubb_kit.ast.isHttpOperationNode(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
 		const { output, coercion, guidType, regexType, oneOfType, compile, mini, inferred, importPath, group, printer } = ctx.options;
 		const dateType = getOasAdapter(adapter).options.dateType;
@@ -1941,7 +1987,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 				...printerOptions,
 				keysToOmit
 			}, mini, direction);
-			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [imports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 				root: meta.file.path,
 				path: imp.path,
 				name: imp.name
@@ -1949,7 +1995,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 				name,
 				imp.path,
 				imp.name
-			].join("-"))), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Zod, {
+			].join("-"))), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Zod, {
 				name,
 				node: schema,
 				printer: schemaPrinter,
@@ -1961,14 +2007,14 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 		}
 		function buildContentTypeVariants(entries, baseName, decorate, direction) {
 			const variants = resolveContentTypeVariants(entries, baseName);
-			const unionSchema = kubb_kit.ast.factory.createSchema({
+			const unionSchema = _kubb_kit.ast.factory.createSchema({
 				type: "union",
-				members: variants.map((variant) => kubb_kit.ast.factory.createSchema({
+				members: variants.map((variant) => _kubb_kit.ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				}))
 			});
-			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [variants.map((variant) => renderSchemaEntry({
+			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [variants.map((variant) => renderSchemaEntry({
 				schema: decorate ? decorate(variant.schema) : variant.schema,
 				name: variant.name,
 				keysToOmit: variant.keysToOmit,
@@ -1980,17 +2026,17 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 			})] });
 		}
 		function buildResponseUnion({ responses, name, fallbackUnknown }) {
-			if (new Set(responses.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? kubb_kit.ast.collectImportedRefNames(entry.schema).map((refName) => resolver.name(refName)) : []))).has(name)) return null;
-			const members = responses.map((res) => kubb_kit.ast.factory.createSchema({
+			if (new Set(responses.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? _kubb_kit.ast.collectImportedRefNames(entry.schema).map((refName) => resolver.name(refName)) : []))).has(name)) return null;
+			const members = responses.map((res) => _kubb_kit.ast.factory.createSchema({
 				type: "ref",
 				name: resolver.response.status(node, res.statusCode)
 			}));
 			if (fallbackUnknown && members.length === 0) return renderSchemaEntry({
-				schema: kubb_kit.ast.factory.createSchema({ type: "unknown" }),
+				schema: _kubb_kit.ast.factory.createSchema({ type: "unknown" }),
 				name
 			});
 			return renderSchemaEntry({
-				schema: members.length === 1 ? members[0] : kubb_kit.ast.factory.createSchema({
+				schema: members.length === 1 ? members[0] : _kubb_kit.ast.factory.createSchema({
 					type: "union",
 					members
 				}),
@@ -2061,10 +2107,10 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 				params: header
 			}
 		].filter(({ params }) => params.length > 0).map(({ kind, params }) => renderSchemaEntry({
-			schema: kubb_kit.ast.factory.createSchema({
+			schema: _kubb_kit.ast.factory.createSchema({
 				type: "object",
 				primitive: "object",
-				properties: params.map((param) => kubb_kit.ast.factory.createProperty({
+				properties: params.map((param) => _kubb_kit.ast.factory.createProperty({
 					name: param.name,
 					required: param.required,
 					schema: param.schema
@@ -2082,7 +2128,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 			schema: buildResponses(node, resolver),
 			name: resolver.response.responses(node)
 		}) : null;
-		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
@@ -2103,7 +2149,7 @@ const zodGenerator = (0, kubb_kit.defineGenerator)({
 				}
 			}),
 			children: [
-				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 					name: isZodImport ? "z" : ["z"],
 					path: importPath,
 					isNameSpace: isZodImport
@@ -2126,7 +2172,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.8.0-canary.20261029T124214";
+var version = "5.8.1";
 // src/resolvers/resolverZod.ts
 /**
 * Default resolver used by `@kubb/plugin-zod`. Decides the names and file
@@ -2143,18 +2189,18 @@ var version = "5.8.0-canary.20261029T124214";
 * resolverZod.schema.typeName('pet')     // 'PetSchemaType'
 * ```
 */
-const resolverZod = (0, kubb_kit.createResolver)({
+const resolverZod = (0, _kubb_kit.createResolver)({
 	pluginName: "plugin-zod",
 	name(name) {
-		return this.memo(`name:${name}`, () => ensureValidVarName((0, kubb_kit.camelCase)(name, { suffix: "schema" })));
+		return this.memo(`name:${name}`, () => ensureValidVarName((0, _kubb_kit.camelCase)(name, { suffix: "schema" })));
 	},
-	file: createCasedFile((part) => (0, kubb_kit.camelCase)(part, { suffix: "schema" })),
+	file: createCasedFile((part) => (0, _kubb_kit.camelCase)(part, { suffix: "schema" })),
 	schema: {
 		typeName(name) {
-			return this.memo(`typeName:${name}`, () => ensureValidVarName((0, kubb_kit.pascalCase)(name, { suffix: "schema type" })));
+			return this.memo(`typeName:${name}`, () => ensureValidVarName((0, _kubb_kit.pascalCase)(name, { suffix: "schema type" })));
 		},
 		type(name) {
-			return this.memo(`type:${name}`, () => ensureValidVarName((0, kubb_kit.pascalCase)(name, { suffix: "type" })));
+			return this.memo(`type:${name}`, () => ensureValidVarName((0, _kubb_kit.pascalCase)(name, { suffix: "type" })));
 		},
 		inputName(name) {
 			return this.name(`${name} input`);
@@ -2163,10 +2209,10 @@ const resolverZod = (0, kubb_kit.createResolver)({
 			return this.schema.typeName(`${name} input`);
 		},
 		isName(name) {
-			return ensureValidVarName((0, kubb_kit.camelCase)(name, { prefix: "is" }));
+			return ensureValidVarName((0, _kubb_kit.camelCase)(name, { prefix: "is" }));
 		},
 		assertName(name) {
-			return ensureValidVarName((0, kubb_kit.camelCase)(name, { prefix: "assert" }));
+			return ensureValidVarName((0, _kubb_kit.camelCase)(name, { prefix: "assert" }));
 		}
 	},
 	param: createOperationParamResolver(),
@@ -2220,7 +2266,7 @@ const pluginZodName = "plugin-zod";
 * })
 * ```
 */
-const pluginZod = (0, kubb_kit.defineExtension)({
+const pluginZod = (0, _kubb_kit.defineExtension)({
 	kind: "plugin",
 	meta: {
 		name: pluginZodName,
@@ -2232,9 +2278,9 @@ const pluginZod = (0, kubb_kit.defineExtension)({
 			path: "zod",
 			barrel: { type: "named" }
 		}, group, exclude = [], include, override = [], compile = false, mini = false, guidType = "uuid", regexType = "literal", oneOfType = "union", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, typeGuards = false, printer, resolver: userResolver, macros: userMacros } = options;
-		(0, kubb_kit.setResolver)(userResolver ? kubb_kit.Resolver.merge(resolverZod, userResolver) : resolverZod);
-		if (userMacros?.length) (0, kubb_kit.setMacros)(userMacros);
-		(0, kubb_kit.addGenerator)(zodGenerator);
+		(0, _kubb_kit.setResolver)(userResolver ? _kubb_kit.Resolver.merge(resolverZod, userResolver) : resolverZod);
+		if (userMacros?.length) (0, _kubb_kit.setMacros)(userMacros);
+		(0, _kubb_kit.addGenerator)(zodGenerator);
 		return {
 			output,
 			exclude,