@kubb/plugin-zod 5.0.0-alpha.33 → 5.0.0-alpha.35

package/dist/index.d.ts

@@ -1,9 +1,6 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import * as _$_kubb_ast0 from "@kubb/ast";
-import { OperationParamsResolver } from "@kubb/ast";
 import * as _$_kubb_core0 from "@kubb/core";
-import { CompatibilityPreset, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, PrinterFactoryOptions, PrinterPartial, ResolvePathOptions, Resolver, UserGroup } from "@kubb/core";
-import { OperationNode, ParameterNode, SchemaNode, StatusCode, Visitor } from "@kubb/ast/types";
+import { CompatibilityPreset, Exclude, Generator, Group, Include, Output, Override, PluginFactoryOptions, PrinterFactoryOptions, PrinterPartial, ResolvePathOptions, Resolver, UserGroup, ast } from "@kubb/core";
 
 //#region src/printers/printerZod.d.ts
 /**
@@ -57,7 +54,7 @@ type PrinterZodFactory = PrinterFactoryOptions<'zod', PrinterZodOptions, string,
  * const code = printer.print(stringSchemaNode) // "z.string()"
  * ```
  */
-declare const printerZod: (options?: PrinterZodOptions | undefined) => _$_kubb_ast0.Printer<PrinterZodFactory>;
+declare const printerZod: (options?: any) => ast.Printer<PrinterFactoryOptions<"zod", PrinterZodOptions, string, string>>;
 //#endregion
 //#region src/printers/printerZodMini.d.ts
 /**
@@ -111,14 +108,14 @@ type PrinterZodMiniFactory = PrinterFactoryOptions<'zod-mini', PrinterZodMiniOpt
  * const code = printer.print(optionalStringNode) // "z.optional(z.string())"
  * ```
  */
-declare const printerZodMini: (options?: PrinterZodMiniOptions | undefined) => _$_kubb_ast0.Printer<PrinterZodMiniFactory>;
+declare const printerZodMini: (options?: any) => ast.Printer<PrinterFactoryOptions<"zod-mini", PrinterZodMiniOptions, string, string>>;
 //#endregion
 //#region src/types.d.ts
 /**
  * The concrete resolver type for `@kubb/plugin-zod`.
  * Extends the base `Resolver` with zod-specific naming helpers.
  */
-type ResolverZod = Resolver & OperationParamsResolver & {
+type ResolverZod = Resolver & ast.OperationParamsResolver & {
   /**
    * Resolves a camelCase schema function name with a `Schema` suffix.
    */
@@ -153,42 +150,42 @@ type ResolverZod = Resolver & OperationParamsResolver & {
    * @example
    * resolver.resolveResponseStatusName(node, 200) // → 'listPetsStatus200Schema'
    */
-  resolveResponseStatusName(this: ResolverZod, node: OperationNode, statusCode: StatusCode): string;
+  resolveResponseStatusName(this: ResolverZod, node: ast.OperationNode, statusCode: ast.StatusCode): string;
   /**
    * Resolves the name for the collection of all operation responses.
    *
    * @example
    * resolver.resolveResponsesName(node) // → 'listPetsResponsesSchema'
    */
-  resolveResponsesName(this: ResolverZod, node: OperationNode): string;
+  resolveResponsesName(this: ResolverZod, node: ast.OperationNode): string;
   /**
    * Resolves the name for the union of all operation responses.
    *
    * @example
    * resolver.resolveResponseName(node) // → 'listPetsResponseSchema'
    */
-  resolveResponseName(this: ResolverZod, node: OperationNode): string;
+  resolveResponseName(this: ResolverZod, node: ast.OperationNode): string;
   /**
    * Resolves the name for an operation's grouped path parameters type.
    *
    * @example
    * resolver.resolvePathParamsName(node, param) // → 'deletePetPathPetIdSchema'
    */
-  resolvePathParamsName(this: ResolverZod, node: OperationNode, param: ParameterNode): string;
+  resolvePathParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string;
   /**
    * Resolves the name for an operation's grouped query parameters type.
    *
    * @example
    * resolver.resolveQueryParamsName(node, param) // → 'findPetsByStatusQueryStatusSchema'
    */
-  resolveQueryParamsName(this: ResolverZod, node: OperationNode, param: ParameterNode): string;
+  resolveQueryParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string;
   /**
    * Resolves the name for an operation's grouped header parameters type.
    *
    * @example
    * resolver.resolveHeaderParamsName(node, param) // → 'deletePetHeaderApiKeySchema'
    */
-  resolveHeaderParamsName(this: ResolverZod, node: OperationNode, param: ParameterNode): string;
+  resolveHeaderParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string;
 };
 type Options = {
   /**
@@ -273,7 +270,7 @@ type Options = {
    */
   wrapOutput?: (arg: {
     output: string;
-    schema: SchemaNode;
+    schema: ast.SchemaNode;
   }) => string | undefined;
   /**
    * How to style your params, by default no casing is applied
@@ -321,7 +318,7 @@ type Options = {
    * A single AST visitor applied to each SchemaNode/OperationNode before printing.
    * When a visitor method returns `null` or `undefined`, the preset transformer's result is used instead.
    */
-  transformer?: Visitor;
+  transformer?: ast.Visitor;
 };
 type ResolvedOptions = {
   output: Output;
@@ -351,10 +348,10 @@ declare global {
 }
 //#endregion
 //#region src/generators/zodGenerator.d.ts
-declare const zodGenerator: _$_kubb_core0.Generator<PluginZod>;
+declare const zodGenerator: _$_kubb_core0.Generator<PluginZod, unknown>;
 //#endregion
 //#region src/generators/zodGeneratorLegacy.d.ts
-declare const zodGeneratorLegacy: _$_kubb_core0.Generator<PluginZod>;
+declare const zodGeneratorLegacy: _$_kubb_core0.Generator<PluginZod, unknown>;
 //#endregion
 //#region src/plugin.d.ts
 /**
@@ -377,7 +374,7 @@ declare const pluginZodName = "plugin-zod";
  * })
  * ```
  */
-declare const pluginZod: (options?: Options | undefined) => _$_kubb_core0.UserPluginWithLifeCycle<PluginZod>;
+declare const pluginZod: (options?: Options | undefined) => _$_kubb_core0.HookStylePlugin<PluginZod>;
 //#endregion
 //#region src/resolvers/resolverZod.d.ts
 /**

package/dist/index.js

@@ -1,7 +1,6 @@
 import "./chunk--u3MIqq1.js";
-import { caseParams, createProperty, createSchema, extractRefName, narrowSchema, syncSchemaRef } from "@kubb/ast";
-import { createPlugin, defineGenerator, definePresets, definePrinter, defineResolver, getPreset, mergeGenerators } from "@kubb/core";
-import { Const, File, Type } from "@kubb/renderer-jsx";
+import { ast, defineGenerator, definePlugin, definePrinter, defineResolver } from "@kubb/core";
+import { Const, File, Type, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -372,7 +371,7 @@ function containsSelfRef(node, { schemaName, resolver, visited = /* @__PURE__ */
 	if (visited.has(node)) return false;
 	visited.add(node);
 	if (node.type === "ref" && node.ref) {
-		const rawName = extractRefName(node.ref) ?? node.name;
+		const rawName = ast.extractRefName(node.ref) ?? node.name;
 		return (rawName ? resolver?.default(rawName, "function") ?? rawName : node.name) === schemaName;
 	}
 	if (node.type === "object") {
@@ -475,7 +474,7 @@ const printerZod = definePrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return void 0;
-				const refName = node.ref ? extractRefName(node.ref) ?? node.name : node.name;
+				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
 				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.schemaName != null && resolvedName === this.options.schemaName) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
@@ -483,7 +482,7 @@ const printerZod = definePrinter((options) => {
 			object(node) {
 				let result = `z.object({\n    ${node.properties.map((prop) => {
 					const { name: propName, schema } = prop;
-					const meta = syncSchemaRef(schema);
+					const meta = ast.syncSchemaRef(schema);
 					const isNullable = meta.nullable;
 					const isOptional = schema.optional;
 					const isNullish = schema.nullish;
@@ -491,7 +490,7 @@ const printerZod = definePrinter((options) => {
 						schemaName: this.options.schemaName,
 						resolver: this.options.resolver
 					});
-					const baseOutput = this.transform(schema) ?? this.transform(createSchema({ type: "unknown" }));
+					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
 					const resolvedOutput = hasSelfRef ? baseOutput.replaceAll(`z.lazy(() => ${this.options.schemaName})`, this.options.schemaName) : baseOutput;
 					const value = applyModifiers({
 						value: this.options.wrapOutput ? this.options.wrapOutput({
@@ -510,12 +509,12 @@ const printerZod = definePrinter((options) => {
 				if (node.additionalProperties && node.additionalProperties !== true) {
 					const catchallType = this.transform(node.additionalProperties);
 					if (catchallType) result += `.catchall(${catchallType})`;
-				} else if (node.additionalProperties === true) result += `.catchall(${this.transform(createSchema({ type: "unknown" }))})`;
+				} else if (node.additionalProperties === true) result += `.catchall(${this.transform(ast.createSchema({ type: "unknown" }))})`;
 				else if (node.additionalProperties === false) result += ".strict()";
 				return result;
 			},
 			array(node) {
-				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
+				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthConstraints(node)}`;
 				if (node.unique) result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`;
 				return result;
 			},
@@ -539,19 +538,19 @@ const printerZod = definePrinter((options) => {
 				if (!base) return "";
 				for (const member of rest) {
 					if (member.primitive === "string") {
-						const c = lengthConstraints(narrowSchema(member, "string") ?? {});
+						const c = lengthConstraints(ast.narrowSchema(member, "string") ?? {});
 						if (c) {
 							base += c;
 							continue;
 						}
 					} else if (member.primitive === "number" || member.primitive === "integer") {
-						const c = numberConstraints(narrowSchema(member, "number") ?? narrowSchema(member, "integer") ?? {});
+						const c = numberConstraints(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
 						if (c) {
 							base += c;
 							continue;
 						}
 					} else if (member.primitive === "array") {
-						const c = lengthConstraints(narrowSchema(member, "array") ?? {});
+						const c = lengthConstraints(ast.narrowSchema(member, "array") ?? {});
 						if (c) {
 							base += c;
 							continue;
@@ -568,7 +567,7 @@ const printerZod = definePrinter((options) => {
 			const { keysToOmit } = this.options;
 			let base = this.transform(node);
 			if (!base) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.syncSchemaRef(node);
 			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
 			return applyModifiers({
 				value: base,
@@ -654,7 +653,7 @@ const printerZodMini = definePrinter((options) => {
 			},
 			ref(node) {
 				if (!node.name) return void 0;
-				const refName = node.ref ? extractRefName(node.ref) ?? node.name : node.name;
+				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
 				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.schemaName != null && resolvedName === this.options.schemaName) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
@@ -662,7 +661,7 @@ const printerZodMini = definePrinter((options) => {
 			object(node) {
 				return `z.object({\n    ${node.properties.map((prop) => {
 					const { name: propName, schema } = prop;
-					const meta = syncSchemaRef(schema);
+					const meta = ast.syncSchemaRef(schema);
 					const isNullable = meta.nullable;
 					const isOptional = schema.optional;
 					const isNullish = schema.nullish;
@@ -670,7 +669,7 @@ const printerZodMini = definePrinter((options) => {
 						schemaName: this.options.schemaName,
 						resolver: this.options.resolver
 					});
-					const baseOutput = this.transform(schema) ?? this.transform(createSchema({ type: "unknown" }));
+					const baseOutput = this.transform(schema) ?? this.transform(ast.createSchema({ type: "unknown" }));
 					const resolvedOutput = hasSelfRef ? baseOutput.replaceAll(`z.lazy(() => ${this.options.schemaName})`, this.options.schemaName) : baseOutput;
 					const value = applyMiniModifiers({
 						value: this.options.wrapOutput ? this.options.wrapOutput({
@@ -687,7 +686,7 @@ const printerZodMini = definePrinter((options) => {
 				}).join(",\n    ")}\n    })`;
 			},
 			array(node) {
-				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
+				let result = `z.array(${(node.items ?? []).map((item) => this.transform(item)).filter(Boolean).join(", ") || this.transform(ast.createSchema({ type: "unknown" }))})${lengthChecksMini(node)}`;
 				if (node.unique) result += `.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`;
 				return result;
 			},
@@ -711,19 +710,19 @@ const printerZodMini = definePrinter((options) => {
 				if (!base) return "";
 				for (const member of rest) {
 					if (member.primitive === "string") {
-						const c = lengthChecksMini(narrowSchema(member, "string") ?? {});
+						const c = lengthChecksMini(ast.narrowSchema(member, "string") ?? {});
 						if (c) {
 							base += c;
 							continue;
 						}
 					} else if (member.primitive === "number" || member.primitive === "integer") {
-						const c = numberChecksMini(narrowSchema(member, "number") ?? narrowSchema(member, "integer") ?? {});
+						const c = numberChecksMini(ast.narrowSchema(member, "number") ?? ast.narrowSchema(member, "integer") ?? {});
 						if (c) {
 							base += c;
 							continue;
 						}
 					} else if (member.primitive === "array") {
-						const c = lengthChecksMini(narrowSchema(member, "array") ?? {});
+						const c = lengthChecksMini(ast.narrowSchema(member, "array") ?? {});
 						if (c) {
 							base += c;
 							continue;
@@ -740,7 +739,7 @@ const printerZodMini = definePrinter((options) => {
 			const { keysToOmit } = this.options;
 			let base = this.transform(node);
 			if (!base) return null;
-			const meta = syncSchemaRef(node);
+			const meta = ast.syncSchemaRef(node);
 			if (keysToOmit?.length && meta.primitive === "object" && !(meta.type === "union" && meta.discriminatorPropertyName)) base = `${base}.omit({ ${keysToOmit.map((k) => `"${k}": true`).join(", ")} })`;
 			return applyMiniModifiers({
 				value: base,
@@ -756,11 +755,12 @@ const printerZodMini = definePrinter((options) => {
 //#region src/generators/zodGenerator.tsx
 const zodGenerator = defineGenerator({
 	name: "zod",
-	schema(node, options) {
-		const { adapter, config, resolver, root } = this;
-		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options;
+	renderer: jsxRenderer,
+	schema(node, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
 		if (!node.name) return;
-		const mode = this.getMode(output);
+		const mode = ctx.getMode(output);
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveSchemaName(schemaName),
@@ -831,12 +831,12 @@ const zodGenerator = defineGenerator({
 			]
 		});
 	},
-	operation(node, options) {
-		const { adapter, config, resolver, root } = this;
-		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options;
-		const mode = this.getMode(output);
+	operation(node, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options;
+		const mode = ctx.getMode(output);
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const params = caseParams(node.parameters, paramsCasing);
+		const params = ast.caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -933,9 +933,9 @@ const zodGenerator = defineGenerator({
 			]
 		});
 	},
-	operations(nodes, options) {
-		const { adapter, config, resolver, root } = this;
-		const { output, importPath, group, operations, paramsCasing } = options;
+	operations(nodes, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, importPath, group, operations, paramsCasing } = ctx.options;
 		if (!operations) return;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const meta = { file: resolver.resolveFile({
@@ -950,7 +950,7 @@ const zodGenerator = defineGenerator({
 			return {
 				node,
 				data: buildSchemaNames(node, {
-					params: caseParams(node.parameters, paramsCasing),
+					params: ast.caseParams(node.parameters, paramsCasing),
 					resolver
 				})
 			};
@@ -1008,12 +1008,12 @@ const zodGenerator = defineGenerator({
 //#endregion
 //#region src/generators/zodGeneratorLegacy.tsx
 function buildGroupedParamsSchema({ params, optional }) {
-	return createSchema({
+	return ast.createSchema({
 		type: "object",
 		optional,
 		primitive: "object",
 		properties: params.map((param) => {
-			return createProperty({
+			return ast.createProperty({
 				name: param.name,
 				required: param.required,
 				schema: param.schema
@@ -1028,72 +1028,72 @@ function buildLegacyResponsesSchemaNode(node, { resolver }) {
 		return !Number.isNaN(code) && code >= 200 && code < 300;
 	});
 	const errorResponses = node.responses.filter((res) => res.statusCode === "default" || Number(res.statusCode) >= 400);
-	const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? createSchema({
+	const responseSchema = successResponses.length > 0 ? successResponses.length === 1 ? ast.createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
-	}) : createSchema({
+	}) : ast.createSchema({
 		type: "union",
-		members: successResponses.map((res) => createSchema({
+		members: successResponses.map((res) => ast.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
-	}) : createSchema({ type: "any" });
-	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? createSchema({
+	}) : ast.createSchema({ type: "any" });
+	const errorsSchema = errorResponses.length > 0 ? errorResponses.length === 1 ? ast.createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, errorResponses[0].statusCode)
-	}) : createSchema({
+	}) : ast.createSchema({
 		type: "union",
-		members: errorResponses.map((res) => createSchema({
+		members: errorResponses.map((res) => ast.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
-	}) : createSchema({ type: "any" });
-	const properties = [createProperty({
+	}) : ast.createSchema({ type: "any" });
+	const properties = [ast.createProperty({
 		name: "Response",
 		required: true,
 		schema: responseSchema
 	})];
-	if (!isGet && node.requestBody?.schema) properties.push(createProperty({
+	if (!isGet && node.requestBody?.schema) properties.push(ast.createProperty({
 		name: "Request",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolveDataName(node)
 		})
 	}));
 	const queryParam = node.parameters.find((p) => p.in === "query");
-	if (queryParam) properties.push(createProperty({
+	if (queryParam) properties.push(ast.createProperty({
 		name: "QueryParams",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolveQueryParamsName(node, queryParam)
 		})
 	}));
 	const pathParam = node.parameters.find((p) => p.in === "path");
-	if (pathParam) properties.push(createProperty({
+	if (pathParam) properties.push(ast.createProperty({
 		name: "PathParams",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolvePathParamsName(node, pathParam)
 		})
 	}));
 	const headerParam = node.parameters.find((p) => p.in === "header");
-	if (headerParam) properties.push(createProperty({
+	if (headerParam) properties.push(ast.createProperty({
 		name: "HeaderParams",
 		required: true,
-		schema: createSchema({
+		schema: ast.createSchema({
 			type: "ref",
 			name: resolver.resolveHeaderParamsName(node, headerParam)
 		})
 	}));
-	properties.push(createProperty({
+	properties.push(ast.createProperty({
 		name: "Errors",
 		required: true,
 		schema: errorsSchema
 	}));
-	return createSchema({
+	return ast.createSchema({
 		type: "object",
 		primitive: "object",
 		properties
@@ -1104,14 +1104,14 @@ function buildLegacyResponseUnionSchemaNode(node, { resolver }) {
 		const code = Number(res.statusCode);
 		return !Number.isNaN(code) && code >= 200 && code < 300;
 	});
-	if (successResponses.length === 0) return createSchema({ type: "any" });
-	if (successResponses.length === 1) return createSchema({
+	if (successResponses.length === 0) return ast.createSchema({ type: "any" });
+	if (successResponses.length === 1) return ast.createSchema({
 		type: "ref",
 		name: resolver.resolveResponseStatusName(node, successResponses[0].statusCode)
 	});
-	return createSchema({
+	return ast.createSchema({
 		type: "union",
-		members: successResponses.map((res) => createSchema({
+		members: successResponses.map((res) => ast.createSchema({
 			type: "ref",
 			name: resolver.resolveResponseStatusName(node, res.statusCode)
 		}))
@@ -1145,11 +1145,12 @@ function buildLegacySchemaNames(node, params, resolver) {
 }
 const zodGeneratorLegacy = defineGenerator({
 	name: "zod-legacy",
-	schema(node, options) {
-		const { adapter, config, resolver, root } = this;
-		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = options;
+	renderer: jsxRenderer,
+	schema(node, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, printer } = ctx.options;
 		if (!node.name) return;
-		const mode = this.getMode(output);
+		const mode = ctx.getMode(output);
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const imports = adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveSchemaName(schemaName),
@@ -1220,12 +1221,12 @@ const zodGeneratorLegacy = defineGenerator({
 			]
 		});
 	},
-	operation(node, options) {
-		const { adapter, config, resolver, root } = this;
-		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = options;
-		const mode = this.getMode(output);
+	operation(node, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options;
+		const mode = ctx.getMode(output);
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const params = caseParams(node.parameters, paramsCasing);
+		const params = ast.caseParams(node.parameters, paramsCasing);
 		const meta = { file: resolver.resolveFile({
 			name: node.operationId,
 			extname: ".ts",
@@ -1360,9 +1361,9 @@ const zodGeneratorLegacy = defineGenerator({
 			]
 		});
 	},
-	operations(nodes, options) {
-		const { adapter, config, resolver, root } = this;
-		const { output, importPath, group, operations, paramsCasing } = options;
+	operations(nodes, ctx) {
+		const { adapter, config, resolver, root } = ctx;
+		const { output, importPath, group, operations, paramsCasing } = ctx.options;
 		if (!operations) return;
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
 		const meta = { file: resolver.resolveFile({
@@ -1376,7 +1377,7 @@ const zodGeneratorLegacy = defineGenerator({
 		const transformedOperations = nodes.map((node) => {
 			return {
 				node,
-				data: buildLegacySchemaNames(node, caseParams(node.parameters, paramsCasing), resolver)
+				data: buildLegacySchemaNames(node, ast.caseParams(node.parameters, paramsCasing), resolver)
 			};
 		});
 		const imports = transformedOperations.flatMap(({ node, data }) => {
@@ -1430,9 +1431,6 @@ const zodGeneratorLegacy = defineGenerator({
 	}
 });
 //#endregion
-//#region package.json
-var version = "5.0.0-alpha.33";
-//#endregion
 //#region src/resolvers/resolverZod.ts
 /**
 * Default resolver for `@kubb/plugin-zod`.
@@ -1551,30 +1549,6 @@ const resolverZodLegacy = defineResolver(() => {
 	};
 });
 //#endregion
-//#region src/presets.ts
-/**
-* Built-in preset registry for `@kubb/plugin-zod`.
-*
-* - `default` — uses `resolverZod` and `zodGenerator` (current naming conventions).
-* - `kubbV4` — uses `resolverZodLegacy` and `zodGeneratorLegacy` (Kubb v4 naming conventions).
-*
-* Note: `printerZodMini` is selected at runtime by the generator when `mini: true` is set.
-*/
-const presets = definePresets({
-	default: {
-		name: "default",
-		resolver: resolverZod,
-		generators: [zodGenerator],
-		printer: printerZod
-	},
-	kubbV4: {
-		name: "kubbV4",
-		resolver: resolverZodLegacy,
-		generators: [zodGeneratorLegacy],
-		printer: printerZod
-	}
-});
-//#endregion
 //#region src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-zod`, used to identify the plugin in driver lookups and warnings.
@@ -1596,43 +1570,30 @@ const pluginZodName = "plugin-zod";
 * })
 * ```
 */
-const pluginZod = createPlugin((options) => {
+const pluginZod = definePlugin((options) => {
 	const { output = {
 		path: "zod",
 		barrelType: "named"
-	}, group, exclude = [], include, override = [], dateType = "string", typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, compatibilityPreset = "default", resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const preset = getPreset({
-		preset: compatibilityPreset,
-		presets,
-		resolver: userResolver,
-		transformer: userTransformer,
-		generators: userGenerators
-	});
-	const mergedGenerator = mergeGenerators(preset.generators ?? []);
-	let resolveNameWarning = false;
-	let resolvePathWarning = false;
+	}, group, exclude = [], include, override = [], dateType = "string", typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [], compatibilityPreset = "default" } = options;
+	const defaultResolver = compatibilityPreset === "kubbV4" ? resolverZodLegacy : resolverZod;
+	const defaultGenerator = compatibilityPreset === "kubbV4" ? zodGeneratorLegacy : zodGenerator;
+	const groupConfig = group ? {
+		...group,
+		name: (ctx) => {
+			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+			return `${camelCase(ctx.group)}Controller`;
+		}
+	} : void 0;
 	return {
 		name: pluginZodName,
-		version,
-		get resolver() {
-			return preset.resolver;
-		},
-		get transformer() {
-			return preset.transformer;
-		},
-		get options() {
-			return {
+		options,
+		hooks: { "kubb:plugin:setup"(ctx) {
+			ctx.setOptions({
 				output,
 				exclude,
 				include,
 				override,
-				group: group ? {
-					...group,
-					name: (ctx) => {
-						if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-						return `${camelCase(ctx.group)}Controller`;
-					}
-				} : void 0,
+				group: groupConfig,
 				dateType,
 				typed,
 				importPath,
@@ -1644,43 +1605,15 @@ const pluginZod = createPlugin((options) => {
 				wrapOutput,
 				paramsCasing,
 				printer
-			};
-		},
-		resolvePath(baseName, pathMode, options) {
-			if (!resolvePathWarning) {
-				this.warn("Do not use resolvePath for pluginZod, use resolverZod.resolvePath instead");
-				resolvePathWarning = true;
-			}
-			return this.plugin.resolver.resolvePath({
-				baseName,
-				pathMode,
-				tag: options?.group?.tag,
-				path: options?.group?.path
-			}, {
-				root: this.root,
-				output,
-				group: this.plugin.options.group
 			});
-		},
-		resolveName(name, type) {
-			if (!resolveNameWarning) {
-				this.warn("Do not use resolveName for pluginZod, use resolverZod.default instead");
-				resolveNameWarning = true;
-			}
-			return this.plugin.resolver.default(name, type);
-		},
-		async schema(node, options) {
-			return mergedGenerator.schema?.call(this, node, options);
-		},
-		async operation(node, options) {
-			return mergedGenerator.operation?.call(this, node, options);
-		},
-		async operations(nodes, options) {
-			return mergedGenerator.operations?.call(this, nodes, options);
-		},
-		async buildStart() {
-			await this.openInStudio({ ast: true });
-		}
+			ctx.setResolver(userResolver ? {
+				...defaultResolver,
+				...userResolver
+			} : defaultResolver);
+			if (userTransformer) ctx.setTransformer(userTransformer);
+			ctx.addGenerator(defaultGenerator);
+			for (const gen of userGenerators) ctx.addGenerator(gen);
+		} }
 	};
 });
 //#endregion