@kubb/plugin-client 5.0.0-beta.56 → 5.5.2

package/dist/index.js

@@ -1,14 +1,216 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
-import { source } from "./templates/clients/axios.source.js";
-import { source as source$1 } from "./templates/clients/fetch.source.js";
-import { source as source$2 } from "./templates/config.source.js";
+import "./rolldown-runtime-C0LytTxp.js";
+import { Resolver, Url, ast, createResolver, defineGenerator, definePlugin, macroSimplifyUnion } from "kubb/kit";
 import path from "node:path";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { buildJSDoc, stringify } from "@kubb/ast/utils";
-import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { Const, File, Function, jsxRenderer } from "@kubb/renderer-jsx";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
+import { File, Function, jsxRenderer } from "kubb/jsx";
+import { jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+/**
+* Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the
+* current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the
+* same dependency for the same operation in one pass (a query plugin's several hook generators, the
+* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
+*
+* @example Cache `plugin-ts`'s file for the current operation
+* ```ts
+* const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })
+* ```
+*/
+function resolveDependencyOperationFile(options) {
+	const { cache, node, resolver, root, output, group } = options;
+	return cache.ensureItem(`${resolver.pluginName}:operationFile`, () => resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output,
+		group: group ?? void 0
+	}));
+}
+function getOperationLink(node, link) {
+	if (!link) return null;
+	if (typeof link === "function") return link(node) ?? null;
+	return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
+}
+/**
+* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
+* are present and the union, default, and form-data flags the client uses to pick one.
+*/
+function buildContentTypeInfo(contentTypes) {
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function getContentTypeInfo(node) {
+	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
+}
+/**
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
+*/
+function getResponseContentTypeInfo(node) {
+	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
+}
+/**
+* Reads the single base content type of an operation's primary success response, lowercased and
+* stripped of any `; charset=...` suffix. Returns `undefined` when the response declares zero or
+* more than one content type, since neither case has a single type to act on.
+*/
+function getPrimarySuccessContentType(node) {
+	const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? [];
+	if (contentTypes.length !== 1) return void 0;
+	return contentTypes[0].split(";")[0].trim().toLowerCase();
+}
+/**
+* Whether an operation streams its primary success response as Server-Sent Events
+* (`text/event-stream`). The client generator uses this to return a typed event stream instead of a
+* one-shot `RequestResult`.
+*/
+function isEventStream(node) {
+	return getPrimarySuccessContentType(node) === "text/event-stream";
+}
+/**
+* Derives the default `responseType` for an operation from its primary success response.
+*
+* Returns a value only when that response declares a single non-JSON content type. `text/event-stream`
+* and other binary types (`application/octet-stream`, `application/pdf`, `image/*`, `audio/*`,
+* `video/*`) map to a stream or `'blob'`, and other `text/*` maps to `'text'`. Otherwise `undefined`,
+* leaving the runtime client's `Content-Type` auto-detection in charge.
+*/
+function getResponseType(node) {
+	const baseType = getPrimarySuccessContentType(node);
+	if (!baseType) return void 0;
+	if (baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json") return void 0;
+	if (baseType === "text/event-stream") return "stream";
+	if (baseType.startsWith("text/")) return "text";
+	if (baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType)) return "blob";
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
+/**
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
+*/
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
+}
+function buildOperationComments(node, options = {}) {
+	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
+	const linkComment = getOperationLink(node, link);
+	const filteredComments = (linkPosition === "beforeDeprecated" ? [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		linkComment,
+		node.deprecated && "@deprecated"
+	] : [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		node.deprecated && "@deprecated",
+		linkComment
+	]).filter((comment) => Boolean(comment));
+	if (!splitLines) return filteredComments;
+	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
+}
+const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
+/**
+* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
+* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
+* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
+* same parameters once per plugin.
+*/
+function getOperationParameters(node) {
+	const cached = operationParameterGroupsByNode.get(node);
+	if (cached) return cached;
+	const groups = {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+	operationParameterGroupsByNode.set(node, groups);
+	return groups;
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
+}
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
+}
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -48,37 +250,12 @@ function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
-//#region ../../internals/utils/src/fs.ts
-/**
-* Builds a nested file path from a dotted name. Splits on dots that precede a letter
-* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
-* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
-*
-* Empty segments are dropped before joining. They arise when the name starts with a dot
-* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
-* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
-* absolute path, letting generated files escape the configured output directory.
-*
-* @example Nested path from a dotted name
-* `toFilePath('pet.petId') // 'pet/petId'`
-*
-* @example PascalCase the final segment
-* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
-*
-* @example Suffix applied to the final segment only
-* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
-*/
-function toFilePath(name, caseLast = camelCase) {
-	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
-}
-//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
 */
-const reservedWords = new Set([
+const reservedWords = /* @__PURE__ */ new Set([
 	"abstract",
 	"arguments",
 	"boolean",
@@ -173,7 +350,7 @@ const reservedWords = new Set([
 */
 function isValidVarName(name) {
 	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+	return isIdentifier(name);
 }
 /**
 * Returns `name` when it's a syntactically valid JavaScript variable name,
@@ -195,252 +372,21 @@ function ensureValidVarName(name) {
 	if (!name || isValidVarName(name)) return name;
 	return `_${name}`;
 }
-//#endregion
-//#region ../../internals/utils/src/url.ts
-function transformParam(raw, casing) {
-	const param = isValidVarName(raw) ? raw : camelCase(raw);
-	return casing === "camelcase" ? camelCase(param) : param;
-}
-function toParamsObject(path, { replacer, casing } = {}) {
-	const params = {};
-	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
-		const param = transformParam(match[1], casing);
-		const key = replacer ? replacer(param) : param;
-		params[key] = key;
-	}
-	return Object.keys(params).length > 0 ? params : null;
-}
-/**
-* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
-*/
-var Url$1 = class Url$1 {
-	static {
-		__name(this, "Url");
-	}
-	/**
-	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
-	*
-	* @example
-	* Url.canParse('https://petstore.swagger.io/v2') // true
-	* Url.canParse('/pet/{petId}')                   // false
-	*/
-	static canParse(url, base) {
-		return URL.canParse(url, base);
-	}
-	/**
-	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
-	*
-	* @example
-	* Url.toPath('/pet/{petId}') // '/pet/:petId'
-	*/
-	static toPath(path) {
-		return path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-	/**
-	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
-	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
-	* and `casing` controls parameter identifier casing.
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
-	*/
-	static toTemplateString(path, { prefix, replacer, casing } = {}) {
-		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = transformParam(part, casing);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
-	* expression when `stringify` is set.
-	*
-	* @example
-	* Url.toObject('/pet/{petId}')
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	*/
-	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
-		const object = {
-			url: type === "path" ? Url$1.toPath(path) : Url$1.toTemplateString(path, {
-				replacer,
-				casing
-			}),
-			params: toParamsObject(path, {
-				replacer,
-				casing
-			})
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
-};
-//#endregion
-//#region ../../internals/shared/src/operation.ts
 /**
-* Builds the `ResolverFileParams` every operation generator passes to
-* `resolver.resolveFile`: a file named `name`, tagged by the operation's first
-* tag (or `'default'`), at the operation's path. Centralizes the entry object
-* that was repeated at dozens of call sites across the client and query plugins.
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
 *
 * @example
 * ```ts
-* resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
 * ```
 */
-function operationFileEntry(node, name, extname = ".ts") {
-	return {
-		name,
-		extname,
-		tag: node.tags[0] ?? "default",
-		path: node.path
-	};
-}
-function getOperationLink(node, link) {
-	if (!link) return null;
-	if (typeof link === "function") return link(node) ?? null;
-	if (link === "urlPath") return node.path ? `{@link ${Url$1.toPath(node.path)}}` : null;
-	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
-}
-function getContentTypeInfo(node) {
-	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
-	const isMultipleContentTypes = contentTypes.length > 1;
-	return {
-		contentTypes,
-		isMultipleContentTypes,
-		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
-		defaultContentType: contentTypes[0] ?? "application/json",
-		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
-	};
-}
-/**
-* Derives the default `responseType` for an operation from its primary success response.
-*
-* Returns a value only when that response declares a single non-JSON content type — a binary type
-* (`application/octet-stream`, `application/pdf`, `image/*`, `audio/*`, `video/*`) maps to `'blob'`
-* and other `text/*` maps to `'text'`. Otherwise `undefined`, leaving the runtime client's
-* `Content-Type` auto-detection in charge.
-*/
-function getResponseType(node) {
-	const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? [];
-	if (contentTypes.length !== 1) return void 0;
-	const baseType = contentTypes[0].split(";")[0].trim().toLowerCase();
-	if (baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json") return void 0;
-	if (baseType.startsWith("text/")) return "text";
-	if (baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType)) return "blob";
-}
-function buildRequestConfigType(node, resolver) {
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
-	return `${requestName ? `Partial<RequestConfig<${requestName}>>` : "Partial<RequestConfig>"} & { ${["client?: Client", isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null].filter(Boolean).join("; ")} }`;
-}
-function buildOperationComments(node, options = {}) {
-	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
-	const linkComment = getOperationLink(node, link);
-	const filteredComments = (linkPosition === "beforeDeprecated" ? [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		linkComment,
-		node.deprecated && "@deprecated"
-	] : [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		node.deprecated && "@deprecated",
-		linkComment
-	]).filter((comment) => Boolean(comment));
-	if (!splitLines) return filteredComments;
-	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
-}
-function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
-	return {
-		path: params.filter((param) => param.in === "path"),
-		query: params.filter((param) => param.in === "query"),
-		header: params.filter((param) => param.in === "header"),
-		cookie: params.filter((param) => param.in === "cookie")
-	};
-}
-function getStatusCodeNumber(statusCode) {
-	const code = Number(statusCode);
-	return Number.isNaN(code) ? null : code;
-}
-function isSuccessStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 200 && code < 300;
-}
-function isErrorStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 400;
-}
-function getSuccessResponses(responses) {
-	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
-}
-function getOperationSuccessResponses(node) {
-	return getSuccessResponses(node.responses);
-}
-function getPrimarySuccessResponse(node) {
-	return getOperationSuccessResponses(node)[0] ?? null;
-}
-function resolveErrorNames(node, resolver) {
-	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-function resolveSuccessNames(node, resolver) {
-	return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-function resolveStatusCodeNames(node, resolver) {
-	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-/**
-* Builds the discriminated union type string for `dataReturnType: 'full'` return shapes.
-* Each member is `{ status: N; data: StatusNType; statusText: string }`.
-*/
-function buildStatusUnionType(node, resolver) {
-	const members = node.responses.map((r) => {
-		const typeName = resolver.resolveResponseStatusName(node, r.statusCode);
-		const statusCode = Number.parseInt(r.statusCode, 10);
-		return `{ status: ${Number.isNaN(statusCode) ? "number" : String(statusCode)}; data: ${typeName}; statusText: string }`;
-	});
-	if (members.length === 1) return members[0];
-	return `(${members.join(" | ")})`;
-}
-const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
-function resolveOperationTypeNames(node, resolver, options = {}) {
-	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
-	let byResolver = typeNamesByResolver.get(resolver);
-	if (byResolver) {
-		const cached = byResolver.get(cacheKey);
-		if (cached) return cached;
-	} else {
-		byResolver = /* @__PURE__ */ new Map();
-		typeNamesByResolver.set(resolver, byResolver);
-	}
-	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
-	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
-	const exclude = new Set(options.exclude ?? []);
-	const paramNames = [
-		...path.map((param) => resolver.resolvePathParamsName(node, param)),
-		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
-		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
-	];
-	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
-	const result = (options.order === "body-response-first" ? [
-		...bodyAndResponseNames,
-		...paramNames,
-		...responseStatusNames
-	] : [
-		...paramNames,
-		...bodyAndResponseNames,
-		...responseStatusNames
-	]).filter((name) => Boolean(name) && !exclude.has(name));
-	byResolver.set(cacheKey, result);
-	return result;
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 //#endregion
 //#region ../../internals/shared/src/group.ts
@@ -474,1599 +420,653 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
-//#region ../../internals/shared/src/params.ts
-function buildParamsMapping(originalParams, mappedParams) {
-	const mapping = {};
-	let hasChanged = false;
-	originalParams.forEach((param, i) => {
-		const mappedName = mappedParams[i]?.name ?? param.name;
-		mapping[param.name] = mappedName;
-		if (param.name !== mappedName) hasChanged = true;
-	});
-	return hasChanged ? mapping : null;
-}
-//#endregion
-//#region src/functionParams.ts
-const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
-const callPrinter = functionPrinter({ mode: "call" });
-function isGroup(spec) {
-	return "children" in spec;
-}
-function createType(type) {
-	return type ? ast.createParamsType({
-		variant: "reference",
-		name: type
-	}) : null;
-}
-function createDeclarationLeaf(name, spec) {
-	if (spec.default !== void 0) return ast.createFunctionParameter({
-		name,
-		type: createType(spec.type) ?? void 0,
-		default: spec.default,
-		rest: spec.mode === "inlineSpread"
-	});
-	return ast.createFunctionParameter({
-		name,
-		type: createType(spec.type) ?? void 0,
-		optional: !!spec.optional,
-		rest: spec.mode === "inlineSpread"
-	});
-}
-function createDeclarationParam(name, spec) {
-	if (isGroup(spec)) return ast.createParameterGroup({
-		inline: spec.mode === "inlineSpread",
-		default: spec.default,
-		properties: Object.entries(spec.children).filter(([, child]) => child != null).map(([childName, child]) => createDeclarationLeaf(childName, child))
-	});
-	return createDeclarationLeaf(name, spec);
-}
-function createCallParam(name, spec) {
-	if (isGroup(spec)) return ast.createParameterGroup({
-		inline: spec.mode === "inlineSpread",
-		properties: Object.entries(spec.children).filter(([, child]) => child != null).map(([childName, child]) => ast.createFunctionParameter({
-			name: child?.mode === "inlineSpread" ? spec.mode === "inlineSpread" ? child.value ?? childName : `...${child.value ?? childName}` : child?.value ? `${childName}: ${child.value}` : childName,
-			rest: spec.mode === "inlineSpread" && child?.mode === "inlineSpread"
-		}))
-	});
-	return ast.createFunctionParameter({
-		name: spec.value ?? name,
-		rest: spec.mode === "inlineSpread"
-	});
-}
+//#region ../../internals/client/src/builders/generics.ts
 /**
-* Creates function parameter builders for generating function signatures and calls.
-* Returns utilities to output constructor signatures (`toConstructor()`) or call expressions (`toCall()`).
+* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
+* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
+* runtime, so this only names the record and threads `ThrowOnError`.
+*
+* @example
+* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
 */
-function createFunctionParams(params) {
-	const entries = Object.entries(params).filter(([, spec]) => spec != null);
-	return {
-		toConstructor() {
-			return declarationPrinter$4.print(ast.createFunctionParameters({ params: entries.map(([name, spec]) => createDeclarationParam(name, spec)) })) ?? "";
-		},
-		toCall() {
-			return callPrinter.print(ast.createFunctionParameters({ params: entries.map(([name, spec]) => createCallParam(name, spec)) })) ?? "";
-		}
-	};
+function buildRequestResultGenerics({ node, types }) {
+	return `${types.response.responses(node)}, ThrowOnError`;
 }
-//#endregion
-//#region src/utils.ts
 /**
-* Returns `true` when any direction of the parser uses Zod (used for dependency checks).
+* Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
+* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, a plain
+* `Promise<RequestResult>` for the internal `'plain'` shape, or a
+* `Promise` of the runtime's `UnwrappedResult` when `returnType: 'data'` narrows a resolved call
+* down to the bare success body.
+*
+* @example
+* `buildResultType({ node, types, returnType: 'data' }) // 'Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>'`
 */
-function isParserEnabled(parser) {
-	if (!parser) return false;
-	if (parser === "zod") return true;
-	return !!(parser.request || parser.response);
+function buildResultType({ node, types, returnType }) {
+	const generics = buildRequestResultGenerics({
+		node,
+		types
+	});
+	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
+	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
+	return `Unwrappable<RequestResult<${generics}>>`;
 }
+//#endregion
+//#region ../../internals/client/src/builders/returnStatement.ts
 /**
-* Returns `'zod'` when request body parsing is enabled, `null` otherwise.
-* The string shorthand `'zod'` also enables request body parsing (existing behavior).
+* Builds the return statement of a generated operation function. With the default
+* `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
+* The generated code casts that result to the operation's `RequestResult`, then wraps it with
+* `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
+* body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
+* which narrows the resolved value down to the bare success body the same way `RequestResult`
+* already does, using the plugin default when the call leaves `throwOnError` unset.
+* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
+*
+* Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
+* as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
+* straight to `Unwrappable<B>` does not work: the `.then` overload stays pinned to `A`, and `as`
+* rejects that two-generic swap even where `A` and `B` on their own would satisfy it.
+*
+* @example
+* `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
+* @example
+* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
+* @example
+* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
 */
-function resolveRequestParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.request ?? null;
+function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
+	if (returnType === "data") return `return unwrapResult(request(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
+		node,
+		types,
+		returnType
+	})}`;
+	if (returnType === "plain") return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		types
+	})}>>`;
+	return `return withUnwrap(request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		types
+	})}>>)`;
+}
+//#endregion
+//#region ../../internals/client/src/builders/security.ts
+function serializeAuth(auth) {
+	const parts = [`type: '${auth.type}'`];
+	if (auth.scheme) parts.push(`scheme: '${auth.scheme}'`);
+	if (auth.name) parts.push(`name: '${auth.name}'`);
+	if (auth.in) parts.push(`in: '${auth.in}'`);
+	return `{ ${parts.join(", ")} }`;
 }
 /**
-* Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise.
-* Only the object form `{ request: 'zod' }` enables query-params parsing.
-* The string shorthand `'zod'` does not, preserving its existing behavior.
+* Maps an OpenAPI security scheme to the inline `Auth` object, or `null` when the runtime cannot
+* place it (an unresolved `$ref`, or an `apiKey` without a name or outside `header` / `query` /
+* `cookie`). `http` schemes other than `basic` are treated as bearer.
 */
-function resolveQueryParamsParser(parser) {
-	if (!parser || parser === "zod") return null;
-	return parser.request ?? null;
+function resolveSecurityScheme(scheme) {
+	if (!scheme || "$ref" in scheme) return null;
+	if (scheme.type === "apiKey") {
+		if (!scheme.name || scheme.in !== "header" && scheme.in !== "query" && scheme.in !== "cookie") return null;
+		return {
+			type: "apiKey",
+			name: scheme.name,
+			in: scheme.in
+		};
+	}
+	if (scheme.type === "http") return {
+		type: "http",
+		scheme: scheme.scheme?.toLowerCase() === "basic" ? "basic" : "bearer"
+	};
+	if (scheme.type === "oauth2") return { type: "oauth2" };
+	if (scheme.type === "openIdConnect") return { type: "openIdConnect" };
+	return null;
 }
 /**
-* Returns `'zod'` when response-direction parsing is enabled, `null` otherwise.
-* `parser: 'zod'` (string shorthand) maps to response parsing and returns `'zod'`.
+* Derives the per-operation security metadata from the OpenAPI document. The operation's own
+* `security` overrides the global `security` (an explicit empty array disables auth), and every
+* referenced scheme is resolved from `components.securitySchemes` into a flat, de-duplicated list of
+* `Auth` objects the runtime walks in order.
+*
+* @example
+* `getOperationSecurity({ document, method: 'POST', path: '/pet' })`
+* `// [{ type: 'http', scheme: 'bearer' }]`
 */
-function resolveResponseParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.response ?? null;
+function getOperationSecurity({ document, method, path }) {
+	if (!document) return void 0;
+	const requirements = (document.paths?.[path]?.[method.toLowerCase()])?.security ?? document.security;
+	if (!requirements?.length) return void 0;
+	const definitions = document.components?.securitySchemes ?? {};
+	const security = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const requirement of requirements) for (const schemeName of Object.keys(requirement)) {
+		if (seen.has(schemeName)) continue;
+		seen.add(schemeName);
+		const auth = resolveSecurityScheme(definitions[schemeName]);
+		if (auth) security.push(auth);
+	}
+	return security.length ? security : void 0;
 }
 /**
-* Builds HTTP headers array for a client request.
-* Includes Content-Type (if not default) and spreads header parameters if present.
+* Serializes the per-operation security into the literal emitted on each generated call's `security`
+* field. The runtime `resolveAuth` helper walks it, calling the configured `auth` resolver per entry.
+*
+* @example
+* `buildSecurityMetadata({ security: [{ type: 'http', scheme: 'bearer' }] }) // "[{ type: 'http', scheme: 'bearer' }]"`
 */
-function buildHeaders(contentType, hasHeaderParams) {
-	return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null, hasHeaderParams ? "...headers" : null].filter(Boolean);
+function buildSecurityMetadata({ security }) {
+	if (!security?.length) return null;
+	return `[${security.map(serializeAuth).join(", ")}]`;
 }
+//#endregion
+//#region ../../internals/client/src/builders/signature.ts
+const declarationPrinter = functionPrinter({ mode: "declaration" });
 /**
-* Returns the generic type arguments — response, error, and request body — for a generated
-* client call.
+* Builds the grouped-options signature for one operation: a single `options` object whose `TData`
+* is the `<Name>Options` type, and a `RequestResult` return type keyed to the per-status responses
+* record. There are no positional arguments.
 *
-* When `dataReturnType` is `'full'`, the response generic widens to a union of all documented
-* status types. When `parser` is `'zod'` and a request body schema exists, the request type
-* uses `z.output<typeof schema>` to reflect post-transform types (e.g. date coercion).
+* The generated file imports `<Name>Options` and `<Name>Responses` and uses them directly, so no
+* per-operation input type has to be emitted. Both names come from `types`, which is `plugin-ts` or
+* `plugin-zod`'s inferred types (see `resolveOperationTypes`).
 */
-function buildGenerics(node, tsResolver, options = {}) {
-	const allStatusNames = node.responses.map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = options.dataReturnType === "full" ? allStatusNames.length > 0 ? allStatusNames.join(" | ") : tsResolver.resolveResponseName(node) : successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
-	const errorNames = node.responses.filter((r) => Number.parseInt(r.statusCode, 10) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const zodRequestName = options.parser === "zod" && options.zodResolver && node.requestBody?.content?.[0]?.schema ? options.zodResolver.resolveDataName?.(node) ?? null : null;
-	return [
-		responseName,
-		TError,
-		zodRequestName ? `z.output<typeof ${zodRequestName}>` : requestName || "unknown"
-	].filter(Boolean);
+function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDefault }) {
+	const optionsName = types.response.options(node);
+	const { isOptional } = getRequestGroupOptionality(node);
+	return {
+		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
+			name: "options",
+			type: `Options<${optionsName}, ThrowOnError>`,
+			...isOptional ? { default: "{}" } : {}
+		})] })) ?? "",
+		returnType: buildResultType({
+			node,
+			types,
+			returnType
+		}),
+		generics: [`ThrowOnError extends boolean = ${throwOnErrorDefault}`]
+	};
 }
+//#endregion
+//#region ../../internals/client/src/builders/validatorOptions.ts
 /**
-* Builds the parameters object for a class-based client method.
-* Includes URL, method, base URL, headers, and request/response data.
+* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
+* `'zod'` validates the response only, so it does not enable request parsing.
 */
-function buildClassClientParams({ node, url, baseURL, tsResolver, isFormData, isMultipleContentTypes, hasFormData, headers, zodQueryParamsName }) {
-	const { query: queryParams } = getOperationParameters(node);
-	const queryParamsName = queryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, queryParams[0]) : null;
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
-	const responseType = getResponseType(node);
-	return createFunctionParams({ config: {
-		mode: "object",
-		children: {
-			requestConfig: { mode: "inlineSpread" },
-			method: { value: JSON.stringify(ast.isHttpOperationNode(node) ? node.method.toUpperCase() : "") },
-			url: { value: url },
-			baseURL: baseURL ? { value: JSON.stringify(baseURL) } : null,
-			params: queryParamsName ? zodQueryParamsName ? { value: "requestParams" } : {} : null,
-			data: requestName ? { value: isMultipleContentTypes && hasFormData ? "contentType === 'multipart/form-data' ? formData as FormData : requestData" : isFormData ? "formData as FormData" : "requestData" } : null,
-			contentType: isMultipleContentTypes ? {} : null,
-			responseType: responseType ? { value: JSON.stringify(responseType) } : null,
-			headers: headers.length ? { value: `{ ${headers.join(", ")}, ...requestConfig.headers }` } : null
-		}
-	} });
+function resolveRequestValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? null;
 }
 /**
-* Builds the request data parsing line for client methods.
-* Applies Zod validation when `parser.request === 'zod'`, otherwise assigns data directly.
+* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
+* maps to response parsing.
 */
-function buildRequestDataLine({ parser, node, zodResolver }) {
-	const requestParser = resolveRequestParser(parser);
-	const zodRequestName = zodResolver && requestParser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
-	if (requestParser === "zod" && zodRequestName) return `const requestData = ${zodRequestName}.parse(data)`;
-	if (node.requestBody?.content?.[0]?.schema) return "const requestData = data";
-	return "";
+function resolveResponseValidator(validator) {
+	if (!validator) return null;
+	if (validator === "zod") return "zod";
+	return validator.response ?? null;
 }
 /**
-* Builds the query parameters parsing line for client methods.
-* Returns an empty string when no query params exist or query-params parsing is not enabled.
-* Only the object form `parser: { request: 'zod' }` triggers this. `parser: 'zod'` does not.
+* Resolves the zod expression a generated client validates a success response with. Only success
+* (2xx) bodies reach the parse under the throw-on-error contract, so the success-only
+* `<operation>ResponseSchema` is used; error bodies are never zod-parsed.
 */
-function buildQueryParamsLine({ parser, node, zodResolver }) {
-	if (resolveQueryParamsParser(parser) !== "zod" || !zodResolver) return "";
-	const { query: queryParams } = getOperationParameters(node);
-	if (queryParams.length === 0) return "";
-	const zodQueryParamsName = zodResolver.resolveQueryParamsName?.(node, queryParams[0]);
-	if (!zodQueryParamsName) return "";
-	return `const requestParams = ${zodQueryParamsName}.parse(params)`;
+function buildZodResponseParse(node, zodResolver) {
+	const name = zodResolver.response.response(node);
+	return name ? {
+		expression: name,
+		importNames: [name]
+	} : null;
 }
 /**
-* Builds the form data conversion line for file upload requests.
-* Returns empty string if not applicable.
+* Resolves the zod expression a generated client validates an error body with on the non-throw path.
+* Uses the error-only `<operation>ErrorSchema` (the union of non-2xx statuses); returns `null` when the
+* operation documents no error responses with a schema.
 */
-function buildFormDataLine(isFormData, hasRequest) {
-	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
+function buildZodErrorParse(node, zodResolver) {
+	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
+	const name = zodResolver.response.error?.(node);
+	return name ? {
+		expression: name,
+		importNames: [name]
+	} : null;
 }
+//#endregion
+//#region ../../internals/client/src/builders/validator.ts
 /**
-* Builds the return statement for a client method.
-* When `dataReturnType` is `'full'`, casts the response to the status-discriminated union type.
-* When `parser.response` is `'zod'`, pipes the response body through the Zod schema before returning.
+* Builds the validator-hook references for one operation. Request validation runs before the send;
+* response validation runs on the success body only. Returns `null` references when the matching
+* direction is disabled or the schema is absent.
 */
-function buildReturnStatement({ dataReturnType, parser, node, zodResolver, tsResolver }) {
-	const responseParser = resolveResponseParser(parser);
-	const zodResponseName = zodResolver && responseParser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
-	if (dataReturnType === "full" && tsResolver) {
-		const unionType = buildStatusUnionType(node, tsResolver);
-		if (responseParser === "zod" && zodResponseName) return `return {...res, data: ${zodResponseName}.parse(res.data)} as ${unionType}`;
-		return `return res as ${unionType}`;
-	}
-	if (dataReturnType === "data" && responseParser === "zod" && zodResponseName) return `return ${zodResponseName}.parse(res.data)`;
-	return "return res.data";
+function buildValidatorHooks({ node, validator, zodResolver }) {
+	const importedZodNames = [];
+	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) : null;
+	const request = zodRequestName ?? null;
+	if (zodRequestName) importedZodNames.push(zodRequestName);
+	const responseParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
+	const response = responseParse ? responseParse.expression : null;
+	if (responseParse) importedZodNames.push(...responseParse.importNames);
+	const errorParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
+	const error = errorParse ? errorParse.expression : null;
+	if (errorParse) importedZodNames.push(...errorParse.importNames);
+	return {
+		request,
+		response,
+		error,
+		importedZodNames
+	};
 }
 //#endregion
-//#region src/components/Url.tsx
-const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
-function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
-	const urlNode = {
-		...node,
-		parameters: node.parameters.filter((p) => p.in === "path"),
-		requestBody: void 0
+//#region ../../internals/client/src/builders/styles.ts
+/**
+* Renders a parameter name as an object-literal key, quoted when it is not a bare identifier.
+* Path keys are camelCased to match the URL template placeholders. Query, header, and cookie keys
+* keep the spec name, matching the remapped keys the runtime serializes.
+*/
+function toKey(name, location) {
+	const key = location === "path" ? camelCase(name) : name;
+	return isValidVarName(key) ? key : JSON.stringify(key);
+}
+/**
+* Serializes one parameter's metadata into a `{ style, explode }` literal, or `null` when the
+* parameter carries neither. Path and query carry the serialization `style`; header and cookie use a
+* fixed style (`simple` and `form`), so only `explode` is emitted for them.
+*/
+function serializeParameter(parameter) {
+	const parts = [];
+	if ((parameter.in === "path" || parameter.in === "query") && parameter.style) parts.push(`style: '${parameter.style}'`);
+	if (parameter.explode !== void 0) parts.push(`explode: ${parameter.explode}`);
+	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
+}
+/**
+* Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
+* Path entries are keyed by the camelCased name to match the URL template placeholders; query,
+* header, and cookie entries keep the spec name to match the keys the runtime serializes.
+* Only parameters whose source defines `style` or `explode` are emitted, so calls without
+* serialization metadata keep the runtime defaults and existing output is unchanged. Returns `null`
+* when no parameter carries metadata.
+*
+* @example
+* ```ts
+* // a path param with { style: 'matrix', explode: true } and a query param with { explode: false }
+* buildStyles({ node }) // "{ path: { id: { style: 'matrix', explode: true } }, query: { tags: { explode: false } } }"
+* ```
+*/
+function buildStyles({ node }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const groups = {
+		path: [],
+		query: [],
+		header: [],
+		cookie: []
 	};
-	return ast.createOperationParams(urlNode, {
-		paramsType: paramsType === "object" ? "object" : "inline",
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver: tsResolver
-	});
+	for (const parameter of node.parameters) {
+		const literal = serializeParameter(parameter);
+		if (!literal) continue;
+		groups[parameter.in].push(`${toKey(parameter.name, parameter.in)}: ${literal}`);
+	}
+	const locations = Object.keys(groups).filter((location) => groups[location].length > 0);
+	if (locations.length === 0) return null;
+	return `{ ${locations.map((location) => `${location}: { ${groups[location].join(", ")} }`).join(", ")} }`;
 }
-function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
+//#endregion
+//#region ../../internals/client/src/components/Operation.tsx
+/**
+* Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
+* single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
+* type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
+* the source.
+*/
+function Operation({ name, node, types, zodResolver, validator, returnType, throwOnErrorDefault, security, isExportable = true, isIndexable = true }) {
 	if (!ast.isHttpOperationNode(node)) return null;
-	const paramsNode = buildUrlParamsNode({
-		paramsType,
-		paramsCasing,
-		pathParamsType,
+	const signature = buildGroupedOptionsSignature({
 		node,
-		tsResolver
-	});
-	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
-	const { path: originalPathParams } = getOperationParameters(node);
-	const { path: casedPathParams } = getOperationParameters(node, { paramsCasing });
-	const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : null;
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable,
-		isIndexable,
-		children: /* @__PURE__ */ jsxs(Function, {
-			name,
-			export: isExportable,
-			params: paramsSignature,
-			children: [
-				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
-				pathParamsMapping && Object.keys(pathParamsMapping).length > 0 && /* @__PURE__ */ jsx("br", {}),
-				/* @__PURE__ */ jsx(Const, {
-					name: "res",
-					children: `{ method: '${node.method.toUpperCase()}', url: ${Url$1.toTemplateString(node.path, { prefix: baseURL })} as const }`
-				}),
-				/* @__PURE__ */ jsx("br", {}),
-				"return res"
-			]
-		})
+		types,
+		returnType,
+		throwOnErrorDefault
 	});
-}
-//#endregion
-//#region src/components/Client.tsx
-const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
-function buildClientParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }) {
-	return ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver: tsResolver,
-		extraParams: [...isConfigurable ? [ast.createFunctionParameter({
-			name: "config",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
-			default: "{}"
-		})] : []]
+	const validators = buildValidatorHooks({
+		node,
+		validator,
+		zodResolver
 	});
-}
-function Client({ name, isExportable = true, isIndexable = true, returnType, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType, node, tsResolver, zodResolver, urlName, children, isConfigurable = true }) {
-	if (!ast.isHttpOperationNode(node)) return null;
-	const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node);
-	const isFormData = !isMultipleContentTypes && contentType === "multipart/form-data";
+	const securityLiteral = buildSecurityMetadata({ security });
+	const stylesLiteral = buildStyles({ node });
+	const { defaultContentType } = getContentTypeInfo(node);
+	const bakedRequestContentType = Boolean(node.requestBody?.content?.[0]?.schema) && defaultContentType !== "application/json" ? defaultContentType : null;
+	const mergeContentType = Boolean(bakedRequestContentType) && getResponseContentTypeInfo(node).isMultipleContentTypes;
+	const contentTypeLiteral = !bakedRequestContentType ? null : mergeContentType ? `contentType: { request: '${bakedRequestContentType}', ...(typeof contentType === 'string' ? { request: contentType } : contentType) }` : `contentType: { request: '${bakedRequestContentType}' }`;
+	const eventStream = isEventStream(node);
 	const responseType = getResponseType(node);
-	const { path: originalPathParams, query: originalQueryParams, header: originalHeaderParams } = getOperationParameters(node);
-	const { path: casedPathParams, query: casedQueryParams, header: casedHeaderParams } = getOperationParameters(node, { paramsCasing });
-	const pathParamsMapping = paramsCasing && !urlName ? buildParamsMapping(originalPathParams, casedPathParams) : null;
-	const queryParamsMapping = paramsCasing ? buildParamsMapping(originalQueryParams, casedQueryParams) : null;
-	const headerParamsMapping = paramsCasing ? buildParamsMapping(originalHeaderParams, casedHeaderParams) : null;
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : null;
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const queryParamsName = originalQueryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, originalQueryParams[0]) : null;
-	const headerParamsName = originalHeaderParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, originalHeaderParams[0]) : null;
-	const requestParser = resolveRequestParser(parser);
-	const responseParser = resolveResponseParser(parser);
-	const zodResponseName = zodResolver && responseParser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
-	const zodRequestName = zodResolver && requestParser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
-	const queryParamsParser = resolveQueryParamsParser(parser);
-	const zodQueryParamsName = zodResolver && queryParamsParser === "zod" && originalQueryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, originalQueryParams[0]) : null;
-	const errorNames = node.responses.filter((r) => {
-		return Number.parseInt(r.statusCode, 10) >= 400;
-	}).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
-	const headers = [!isMultipleContentTypes && contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null, headerParamsName ? headerParamsMapping ? "...mappedHeaders" : "...headers" : null].filter(Boolean);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const allStatusNames = node.responses.map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
-	const generics = [
-		dataReturnType === "full" ? allStatusNames.length > 0 ? allStatusNames.join(" | ") : responseName : responseName,
-		TError,
-		parser === "zod" && zodRequestName ? `z.output<typeof ${zodRequestName}>` : requestName || "unknown"
+	const responseTypeLiteral = responseType ? `responseType: '${responseType}'` : null;
+	const validatorEntries = [
+		validators.request ? `request: ${validators.request}` : null,
+		validators.response ? `response: ${validators.response}` : null,
+		validators.error ? `error: ${validators.error}` : null
 	].filter(Boolean);
-	const paramsNode = buildClientParamsNode({
-		paramsType,
-		paramsCasing,
-		pathParamsType,
+	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
+	const callConfig = `{ ${[
+		`method: '${node.method.toUpperCase()}'`,
+		`url: '${node.path}'`,
+		securityLiteral ? `security: ${securityLiteral}` : null,
+		stylesLiteral ? `styles: ${stylesLiteral}` : null,
+		validatorLiteral,
+		contentTypeLiteral,
+		responseTypeLiteral,
+		"...config",
+		`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
+	].filter(Boolean).join(", ")} }`;
+	const eventType = `SuccessOf<${types.response.responses(node)}>`;
+	const functionReturnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
+	const returnStatement = eventStream ? `return toEventStream<${eventType}>(request(${callConfig}))` : buildReturnStatement({
 		node,
-		tsResolver,
-		isConfigurable
+		types,
+		callConfig,
+		returnType,
+		throwOnErrorDefault
 	});
-	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
-	const urlParamsNode = buildUrlParamsNode({
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		node,
-		tsResolver
-	});
-	const urlParamsCall = functionPrinter({ mode: "call" }).print(urlParamsNode) ?? "";
-	const clientParams = createFunctionParams({ config: {
-		mode: "object",
-		children: {
-			method: { value: stringify(node.method.toUpperCase()) },
-			url: { value: urlName ? `${urlName}(${urlParamsCall}).url.toString()` : Url$1.toTemplateString(node.path) },
-			baseURL: baseURL && !urlName ? { value: `\`${baseURL}\`` } : null,
-			params: queryParamsName ? zodQueryParamsName ? { value: "requestParams" } : queryParamsMapping ? { value: "mappedParams" } : {} : null,
-			data: requestName ? { value: isMultipleContentTypes && hasFormData ? "contentType === 'multipart/form-data' ? formData as FormData : requestData" : isFormData ? "formData as FormData" : "requestData" } : null,
-			contentType: isConfigurable && isMultipleContentTypes ? {} : null,
-			responseType: responseType ? { value: stringify(responseType) } : null,
-			requestConfig: isConfigurable ? { mode: "inlineSpread" } : null,
-			headers: headers.length ? { value: isConfigurable ? `{ ${headers.join(", ")}, ...requestConfig.headers }` : `{ ${headers.join(", ")} }` } : null
-		}
-	} });
-	const statusUnionType = dataReturnType === "full" ? buildStatusUnionType(node, tsResolver) : null;
-	const childrenElement = children ? children : /* @__PURE__ */ jsxs(Fragment, { children: [
-		dataReturnType === "full" && responseParser === "zod" && zodResponseName && statusUnionType && `return {...res, data: ${zodResponseName}.parse(res.data)} as ${statusUnionType}`,
-		dataReturnType === "full" && responseParser !== "zod" && statusUnionType && `return res as ${statusUnionType}`,
-		dataReturnType === "data" && responseParser === "zod" && zodResponseName && `return ${zodResponseName}.parse(res.data)`,
-		dataReturnType === "data" && responseParser !== "zod" && "return res.data"
-	] });
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx(File.Source, {
+	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable,
 		isIndexable,
 		children: /* @__PURE__ */ jsxs(Function, {
 			name,
-			async: true,
 			export: isExportable,
-			params: paramsSignature,
+			generics: signature.generics,
+			params: signature.paramsSignature,
+			returnType: functionReturnType,
 			JSDoc: { comments: buildOperationComments(node, {
 				link: "urlPath",
 				linkPosition: "beforeDeprecated",
 				splitLines: true
 			}) },
-			returnType,
 			children: [
-				isConfigurable ? `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ""}...requestConfig } = config` : "",
+				mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
 				/* @__PURE__ */ jsx("br", {}),
-				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
-				pathParamsMapping && /* @__PURE__ */ jsx("br", {}),
-				queryParamsMapping && queryParamsName && /* @__PURE__ */ jsxs(Fragment, { children: [`const mappedParams = params ? { ${Object.entries(queryParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": params.${camelCaseName}`).join(", ")} } : undefined`, /* @__PURE__ */ jsx("br", {})] }),
-				headerParamsMapping && headerParamsName && /* @__PURE__ */ jsxs(Fragment, { children: [`const mappedHeaders = headers ? { ${Object.entries(headerParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": headers.${camelCaseName}`).join(", ")} } : undefined`, /* @__PURE__ */ jsx("br", {})] }),
-				requestParser === "zod" && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && "const requestData = data",
-				zodQueryParamsName && `const requestParams = ${zodQueryParamsName}.parse(params)`,
-				(isFormData || isMultipleContentTypes && hasFormData) && requestName && "const formData = buildFormData(requestData)",
-				/* @__PURE__ */ jsx("br", {}),
-				isConfigurable ? `const res = await request<${generics.join(", ")}>(${clientParams.toCall()})` : `const res = await client<${generics.join(", ")}>(${clientParams.toCall()})`,
-				/* @__PURE__ */ jsx("br", {}),
-				childrenElement
+				returnStatement
 			]
 		})
-	})] });
-}
-//#endregion
-//#region src/components/ClassClient.tsx
-const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
-function generateMethod$1({ node, name, tsResolver, zodResolver, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
-	if (!ast.isHttpOperationNode(node)) return "";
-	const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node);
-	const isFormData = !isMultipleContentTypes && contentType === "multipart/form-data";
-	const { header: headerParams } = getOperationParameters(node);
-	const headerParamsName = headerParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, headerParams[0]) : null;
-	const headers = isMultipleContentTypes ? headerParamsName ? ["...headers"] : [] : buildHeaders(contentType, !!headerParamsName);
-	const generics = buildGenerics(node, tsResolver, {
-		dataReturnType,
-		zodResolver,
-		parser
-	});
-	const paramsNode = buildClientParamsNode({
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		node,
-		tsResolver,
-		isConfigurable: true
-	});
-	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
-	const { query: queryParams } = getOperationParameters(node);
-	const zodQueryParamsName = zodResolver && resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null;
-	const clientParams = buildClassClientParams({
-		node,
-		url: Url$1.toTemplateString(node.path, { casing: paramsCasing }),
-		baseURL,
-		tsResolver,
-		isFormData,
-		isMultipleContentTypes,
-		hasFormData,
-		headers,
-		zodQueryParamsName
-	});
-	const jsdoc = buildJSDoc(buildOperationComments(node, {
-		link: "urlPath",
-		linkPosition: "beforeDeprecated",
-		splitLines: true
-	}));
-	const requestDataLine = buildRequestDataLine({
-		parser,
-		node,
-		zodResolver
-	});
-	const queryParamsLine = buildQueryParamsLine({
-		parser,
-		node,
-		zodResolver
-	});
-	const formDataLine = buildFormDataLine(isFormData || isMultipleContentTypes && hasFormData, !!node.requestBody?.content?.[0]?.schema);
-	const returnStatement = buildReturnStatement({
-		dataReturnType,
-		parser,
-		node,
-		zodResolver,
-		tsResolver
-	});
-	return `${jsdoc}async ${name}(${paramsSignature}) {\n${[
-		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
-		"",
-		requestDataLine,
-		queryParamsLine,
-		formDataLine,
-		`const res = await request<${generics.join(", ")}>(${clientParams.toCall()})`,
-		returnStatement
-	].filter(Boolean).map((line) => `    ${line}`).join("\n")}\n  }`;
-}
-__name(generateMethod$1, "generateMethod");
-function ClassClient({ name, isExportable = true, isIndexable = true, operations, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType, children }) {
-	const classCode = `export class ${name} {
-  #config: Partial<RequestConfig> & { client?: Client }
-
-  constructor(config: Partial<RequestConfig> & { client?: Client } = {}) {
-    this.#config = config
-  }
-
-${operations.map(({ node, name: methodName, tsResolver, zodResolver }) => generateMethod$1({
-		node,
-		name: methodName,
-		tsResolver,
-		zodResolver,
-		baseURL,
-		dataReturnType,
-		parser,
-		paramsType,
-		paramsCasing,
-		pathParamsType
-	})).join("\n\n")}
-}`;
-	return /* @__PURE__ */ jsxs(File.Source, {
-		name,
-		isExportable,
-		isIndexable,
-		children: [classCode, children]
-	});
-}
-//#endregion
-//#region src/components/WrapperClient.tsx
-function WrapperClient({ name, controllers, isExportable = true, isIndexable = true }) {
-	const classCode = `export class ${name} {
-${controllers.map(({ className, propertyName }) => `  readonly ${propertyName}: ${className}`).join("\n")}
-
-  constructor(config: Partial<RequestConfig> & { client?: Client } = {}) {
-${controllers.map(({ className, propertyName }) => `    this.${propertyName} = new ${className}(config)`).join("\n")}
-  }
-}`;
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable,
-		isIndexable,
-		children: classCode
 	});
 }
 //#endregion
-//#region src/generators/classClientGenerator.tsx
-function resolveTypeImportNames$1(node, tsResolver) {
-	return resolveOperationTypeNames(node, tsResolver, { order: "body-response-first" });
-}
-__name(resolveTypeImportNames$1, "resolveTypeImportNames");
-function resolveZodImportNames$1(node, zodResolver, parser) {
-	const { query: queryParams } = getOperationParameters(node);
-	return [
-		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
-		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
-	].filter((n) => Boolean(n));
-}
-__name(resolveZodImportNames$1, "resolveZodImportNames");
+//#region ../../internals/client/src/resolveOperationTypes.ts
 /**
-* Built-in `operations` generator for `@kubb/plugin-client` when
-* `clientType: 'class'`. Emits one class per tag, with one instance method
-* per operation and a shared constructor for request configuration.
+* Warning a client generator reports when neither plugin can supply the operation types, so the
+* pipeline says why nothing was generated instead of silently emitting no files.
 */
-const classClientGenerator = defineGenerator({
-	name: "classClient",
-	renderer: jsxRenderer,
-	operations(nodes, ctx) {
-		const { config, driver, resolver, root } = ctx;
-		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, sdk } = ctx.options;
-		const baseURL = ctx.options.baseURL ?? ctx.meta.baseURL;
-		const pluginTs = driver.getPlugin(pluginTsName);
-		if (!pluginTs) return null;
-		const tsResolver = driver.getResolver(pluginTsName);
-		const tsPluginOptions = pluginTs.options;
-		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-		function buildOperationData(node) {
-			const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
-				root,
-				output: tsPluginOptions?.output ?? output,
-				group: tsPluginOptions?.group
-			});
-			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
-				root,
-				output: pluginZod.options?.output ?? output,
-				group: pluginZod.options?.group ?? void 0
-			}) : null;
-			return {
-				node,
-				name: resolver.resolveName(node.operationId),
-				tsResolver,
-				zodResolver,
-				typeFile,
-				zodFile
-			};
-		}
-		const controllers = nodes.reduce((acc, operationNode) => {
-			if (!ast.isHttpOperationNode(operationNode)) return acc;
-			const tag = operationNode.tags[0];
-			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveClassName("Client");
-			if (!tag && !group) {
-				const name = resolver.resolveClassName("ApiClient");
-				const file = resolver.resolveFile({
-					name,
-					extname: ".ts"
-				}, {
-					root,
-					output,
-					group: group ?? void 0
-				});
-				const operationData = buildOperationData(operationNode);
-				const previous = acc.find((item) => item.file.path === file.path);
-				if (previous) previous.operations.push(operationData);
-				else acc.push({
-					name,
-					propertyName: resolver.resolveClientPropertyName(name),
-					file,
-					operations: [operationData]
-				});
-				return acc;
-			}
-			if (tag) {
-				const name = groupName;
-				const file = resolver.resolveFile({
-					name,
-					extname: ".ts",
-					tag
-				}, {
-					root,
-					output,
-					group: group ?? void 0
-				});
-				const operationData = buildOperationData(operationNode);
-				const previous = acc.find((item) => item.file.path === file.path);
-				if (previous) previous.operations.push(operationData);
-				else acc.push({
-					name,
-					propertyName: resolver.resolveClientPropertyName(name),
-					file,
-					operations: [operationData]
-				});
-			}
-			return acc;
-		}, []);
-		function collectTypeImports(ops) {
-			const typeImportsByFile = /* @__PURE__ */ new Map();
-			const typeFilesByPath = /* @__PURE__ */ new Map();
-			ops.forEach((op) => {
-				const names = resolveTypeImportNames$1(op.node, tsResolver);
-				if (!typeImportsByFile.has(op.typeFile.path)) typeImportsByFile.set(op.typeFile.path, /* @__PURE__ */ new Set());
-				const imports = typeImportsByFile.get(op.typeFile.path);
-				names.forEach((n) => {
-					imports.add(n);
-				});
-				typeFilesByPath.set(op.typeFile.path, op.typeFile);
-			});
-			return {
-				typeImportsByFile,
-				typeFilesByPath
-			};
-		}
-		function collectZodImports(ops) {
-			const zodImportsByFile = /* @__PURE__ */ new Map();
-			const zodFilesByPath = /* @__PURE__ */ new Map();
-			ops.forEach((op) => {
-				if (!op.zodFile || !zodResolver) return;
-				const names = resolveZodImportNames$1(op.node, zodResolver, parser);
-				if (!zodImportsByFile.has(op.zodFile.path)) zodImportsByFile.set(op.zodFile.path, /* @__PURE__ */ new Set());
-				const imports = zodImportsByFile.get(op.zodFile.path);
-				names.forEach((n) => {
-					imports.add(n);
-				});
-				zodFilesByPath.set(op.zodFile.path, op.zodFile);
-			});
-			return {
-				zodImportsByFile,
-				zodFilesByPath
-			};
-		}
-		const files = controllers.map(({ name, file, operations: ops }) => {
-			const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops);
-			const { zodImportsByFile, zodFilesByPath } = isParserEnabled(parser) ? collectZodImports(ops) : {
-				zodImportsByFile: /* @__PURE__ */ new Map(),
-				zodFilesByPath: /* @__PURE__ */ new Map()
-			};
-			const hasFormData = ops.some((op) => op.node.requestBody?.content?.some((e) => e.contentType === "multipart/form-data") ?? false);
-			return /* @__PURE__ */ jsxs(File, {
-				baseName: file.baseName,
-				path: file.path,
-				meta: file.meta,
-				banner: resolver.resolveBanner(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: file.path,
-						baseName: file.baseName
-					}
-				}),
-				footer: resolver.resolveFooter(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: file.path,
-						baseName: file.baseName
-					}
-				}),
-				children: [
-					importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-						/* @__PURE__ */ jsx(File.Import, {
-							name: "client",
-							path: importPath
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["mergeConfig"],
-							path: importPath
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: [
-								"Client",
-								"RequestConfig",
-								"ResponseErrorConfig"
-							],
-							path: importPath,
-							isTypeOnly: true
-						})
-					] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["client"],
-							root: file.path,
-							path: path.resolve(root, ".kubb/client.ts")
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["mergeConfig"],
-							root: file.path,
-							path: path.resolve(root, ".kubb/client.ts")
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: [
-								"Client",
-								"RequestConfig",
-								"ResponseErrorConfig"
-							],
-							root: file.path,
-							path: path.resolve(root, ".kubb/client.ts"),
-							isTypeOnly: true
-						})
-					] }),
-					hasFormData && /* @__PURE__ */ jsx(File.Import, {
-						name: ["buildFormData"],
-						root: file.path,
-						path: path.resolve(root, ".kubb/config.ts")
-					}),
-					parser === "zod" && zodResolver && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
-						name: ["z"],
-						path: "zod",
-						isTypeOnly: true
-					}),
-					Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
-						const typeFile = typeFilesByPath.get(filePath);
-						if (!typeFile) return null;
-						const importNames = Array.from(importSet).filter(Boolean);
-						if (importNames.length === 0) return null;
-						return /* @__PURE__ */ jsx(File.Import, {
-							name: importNames,
-							root: file.path,
-							path: typeFile.path,
-							isTypeOnly: true
-						}, filePath);
-					}),
-					isParserEnabled(parser) && Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
-						const zodFile = zodFilesByPath.get(filePath);
-						if (!zodFile) return null;
-						const importNames = Array.from(importSet).filter(Boolean);
-						if (importNames.length === 0) return null;
-						return /* @__PURE__ */ jsx(File.Import, {
-							name: importNames,
-							root: file.path,
-							path: zodFile.path
-						}, filePath);
-					}),
-					/* @__PURE__ */ jsx(ClassClient, {
-						name,
-						operations: ops,
-						baseURL,
-						dataReturnType,
-						pathParamsType,
-						paramsCasing,
-						paramsType,
-						parser
-					})
-				]
-			}, file.path);
-		});
-		if (sdk) {
-			const sdkFile = resolver.resolveFile({
-				name: sdk.className,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group: group ?? void 0
-			});
-			files.push(/* @__PURE__ */ jsxs(File, {
-				baseName: sdkFile.baseName,
-				path: sdkFile.path,
-				meta: sdkFile.meta,
-				banner: resolver.resolveBanner(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: sdkFile.path,
-						baseName: sdkFile.baseName
-					}
-				}),
-				footer: resolver.resolveFooter(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: sdkFile.path,
-						baseName: sdkFile.baseName
-					}
-				}),
-				children: [
-					importPath ? /* @__PURE__ */ jsx(File.Import, {
-						name: ["Client", "RequestConfig"],
-						path: importPath,
-						isTypeOnly: true
-					}) : /* @__PURE__ */ jsx(File.Import, {
-						name: ["Client", "RequestConfig"],
-						root: sdkFile.path,
-						path: path.resolve(root, ".kubb/client.ts"),
-						isTypeOnly: true
-					}),
-					controllers.map(({ name, file }) => /* @__PURE__ */ jsx(File.Import, {
-						name: [name],
-						root: sdkFile.path,
-						path: file.path
-					}, name)),
-					/* @__PURE__ */ jsx(WrapperClient, {
-						name: sdk.className,
-						controllers: controllers.map(({ name, propertyName }) => ({
-							className: name,
-							propertyName
-						}))
-					})
-				]
-			}, sdkFile.path));
-		}
-		return /* @__PURE__ */ jsx(Fragment, { children: files });
-	}
-});
-//#endregion
-//#region src/generators/clientGenerator.tsx
+const MISSING_OPERATION_TYPES_WARNING = "Skipped: no operation types available. Add `pluginTs()`, or `pluginZod({ inferred: true })` to type the client from its zod schemas.";
 /**
-* Built-in operation generator for `@kubb/plugin-client`. Emits one async
-* function per OpenAPI operation, plus the matching URL helper. Used when
-* `clientType: 'function'` (the default).
+* Picks the plugin a generated client takes its `Options` and `Responses` types from.
+*
+* `plugin-ts` wins whenever it is in the pipeline, so existing configs keep the types they generate
+* today. Without it, `pluginZod({ inferred: true })` takes over: its inferred options and responses
+* types are built from the same shared schemas as the `plugin-ts` ones, so a client typed off
+* `z.infer` carries what the codecs decode to (a `Temporal` instance, a `Date`) rather than the raw
+* wire type. Returns `null` when neither is available, leaving the caller nothing to type against.
+*
+* @example
+* ```ts
+* const types = resolveOperationTypes(ctx.driver)
+* if (!types) return null
+* types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
+* ```
 */
-const clientGenerator = defineGenerator({
-	name: "client",
-	renderer: jsxRenderer,
-	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
-		const { output, urlType, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, group } = ctx.options;
-		const baseURL = ctx.options.baseURL ?? ctx.meta.baseURL;
-		const pluginTs = driver.getPlugin(pluginTsName);
-		if (!pluginTs) return null;
-		const tsResolver = driver.getResolver(pluginTsName);
-		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-		const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing });
-		const { query: queryParams } = getOperationParameters(node);
-		const importedZodNames = zodResolver ? [
-			resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
-			resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-			resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
-		].filter((name) => Boolean(name)) : [];
-		const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) ?? null : null;
-		const meta = {
-			name: resolver.resolveName(node.operationId),
-			urlName: resolver.resolveUrlName(node),
-			file: resolver.resolveFile(operationFileEntry(node, node.operationId), {
-				root,
-				output,
-				group: group ?? void 0
-			}),
-			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group ?? void 0
-			}),
-			fileZod: zodResolver && pluginZod?.options ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
-				root,
-				output: pluginZod.options.output ?? output,
-				group: pluginZod.options?.group ?? void 0
-			}) : null
+function resolveOperationTypes(driver) {
+	const pluginTs = driver.getPlugin(pluginTsName);
+	if (pluginTs) {
+		const resolver = driver.getResolver(pluginTsName);
+		return {
+			response: resolver.response,
+			resolver,
+			output: pluginTs.options?.output,
+			group: pluginTs.options?.group
 		};
-		const hasFormData = node.requestBody?.content?.some((e) => e.contentType === "multipart/form-data") ?? false;
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: meta.file.baseName,
-			path: meta.file.path,
-			meta: meta.file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
-			footer: resolver.resolveFooter(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
-			children: [
-				importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
-					name: "client",
-					path: importPath
-				}), /* @__PURE__ */ jsx(File.Import, {
-					name: [
-						"Client",
-						"RequestConfig",
-						"ResponseErrorConfig"
-					],
-					path: importPath,
-					isTypeOnly: true
-				})] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
-					name: ["client"],
-					root: meta.file.path,
-					path: path.resolve(root, ".kubb/client.ts")
-				}), /* @__PURE__ */ jsx(File.Import, {
-					name: [
-						"Client",
-						"RequestConfig",
-						"ResponseErrorConfig"
-					],
-					root: meta.file.path,
-					path: path.resolve(root, ".kubb/client.ts"),
-					isTypeOnly: true
-				})] }),
-				hasFormData && /* @__PURE__ */ jsx(File.Import, {
-					name: ["buildFormData"],
-					root: meta.file.path,
-					path: path.resolve(root, ".kubb/config.ts")
-				}),
-				zodRequestName && /* @__PURE__ */ jsx(File.Import, {
-					name: ["z"],
-					path: "zod",
-					isTypeOnly: true
-				}),
-				meta.fileZod && importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: importedZodNames,
-					root: meta.file.path,
-					path: meta.fileZod.path
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(Url, {
-					name: meta.urlName,
-					baseURL,
-					pathParamsType,
-					paramsCasing,
-					paramsType,
-					node,
-					tsResolver,
-					isIndexable: urlType === "export",
-					isExportable: urlType === "export"
-				}),
-				/* @__PURE__ */ jsx(Client, {
-					name: meta.name,
-					urlName: meta.urlName,
-					baseURL,
-					dataReturnType,
-					pathParamsType,
-					paramsCasing,
-					paramsType,
-					node,
-					tsResolver,
-					zodResolver,
-					parser
-				})
-			]
-		});
 	}
-});
+	const pluginZod = driver.getPlugin(pluginZodName);
+	if (!pluginZod?.options?.inferred) return null;
+	const resolver = driver.getResolver(pluginZodName);
+	return {
+		response: {
+			options: resolver.response.options,
+			responses: (node) => resolver.schema.type(resolver.response.responses(node))
+		},
+		resolver,
+		output: pluginZod.options.output,
+		group: pluginZod.options.group
+	};
+}
 //#endregion
-//#region src/generators/groupedClientGenerator.tsx
+//#region ../../internals/client/src/generators/clientGenerator.tsx
 /**
-* Emits one aggregate file per tag/group when `group` is configured. Each
-* file re-exports every client function for that group, so callers can
-* `import { petController } from './gen/clients'` instead of importing
-* each operation individually.
+* Builds the built-in per-operation generator shared by the client plugins (`@kubb/plugin-fetch`,
+* `@kubb/plugin-axios`). Emits one async function per OpenAPI operation using the shared
+* `Operation` component: a grouped `<Name>Request` type and a function that forwards a single
+* `options` object to the bundled `client` and returns the `Unwrappable<RequestResult>`. Only the
+* generator `name` differs between plugins. Every other resolution, import, and rendering step is
+* identical.
 */
-const groupedClientGenerator = defineGenerator({
-	name: "groupedClient",
-	renderer: jsxRenderer,
-	operations(nodes, ctx) {
-		const { config, resolver, root } = ctx;
-		const { output, group } = ctx.options;
-		return /* @__PURE__ */ jsx(Fragment, { children: nodes.reduce((acc, operationNode) => {
-			if (group?.type === "tag") {
-				const tag = operationNode.tags[0];
-				const name = tag ? group?.name?.({ group: camelCase(tag) }) : null;
-				if (!tag || !name) return acc;
-				const file = resolver.resolveFile({
-					name,
-					extname: ".ts",
-					tag
-				}, {
-					root,
-					output,
-					group: group ?? void 0
-				});
-				const clientFile = resolver.resolveFile({
-					name: operationNode.operationId,
-					extname: ".ts",
-					tag: operationNode.tags[0] ?? "default",
-					path: operationNode.path
-				}, {
+function createClientGenerator(name, resolveClientPath) {
+	return defineGenerator({
+		name,
+		renderer: jsxRenderer,
+		operation(node, ctx) {
+			if (!ast.isHttpOperationNode(node)) return null;
+			const { config, driver, resolver, root } = ctx;
+			const { output, validator, returnType, throwOnErrorDefault, group } = ctx.options;
+			const types = resolveOperationTypes(driver);
+			if (!types) {
+				ctx.warn(MISSING_OPERATION_TYPES_WARNING);
+				return null;
+			}
+			const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(pluginZodName) : null;
+			const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+			const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+			const importedTypeNames = [types.response.options(node), types.response.responses(node)];
+			const importedZodNames = zodResolver ? [
+				resolveResponseValidator(validator) === "zod" ? zodResolver.response.response?.(node) : null,
+				resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
+				resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body?.(node) : null
+			].filter((name) => Boolean(name)) : [];
+			const meta = {
+				name: resolver.name(node.operationId),
+				file: resolver.file({
+					...operationFileEntry(node, node.operationId),
 					root,
 					output,
 					group: group ?? void 0
-				});
-				const client = {
-					name: resolver.resolveName(operationNode.operationId),
-					file: clientFile
-				};
-				const previous = acc.find((item) => item.file.path === file.path);
-				if (previous) previous.clients.push(client);
-				else acc.push({
-					name,
-					file,
-					clients: [client]
-				});
-			}
-			return acc;
-		}, []).map(({ name, file, clients }) => {
-			return /* @__PURE__ */ jsxs(File, {
-				baseName: file.baseName,
-				path: file.path,
-				meta: file.meta,
-				banner: resolver.resolveBanner(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: file.path,
-						baseName: file.baseName,
-						isAggregation: true
-					}
 				}),
-				footer: resolver.resolveFooter(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: file.path,
-						baseName: file.baseName,
-						isAggregation: true
-					}
-				}),
-				children: [clients.map((client) => /* @__PURE__ */ jsx(File.Import, {
-					name: [client.name],
-					root: file.path,
-					path: client.file.path
-				}, client.name)), /* @__PURE__ */ jsx(File.Source, {
-					name,
-					isExportable: true,
-					isIndexable: true,
-					children: /* @__PURE__ */ jsx(Function, {
-						export: true,
-						name,
-						children: `return { ${clients.map((client) => client.name).join(", ")} }`
-					})
-				})]
-			}, file.path);
-		}) });
-	}
-});
-//#endregion
-//#region src/generators/operationsGenerator.ts
-/**
-* Generates an `operations.ts` file that re-exports every operation grouped
-* by HTTP method. Enabled when `pluginClient({ operations: true })`. Useful
-* for building meta-tooling on top of the generated client (route
-* registries, API explorers).
-*/
-const operationsGenerator = defineGenerator({
-	name: "client",
-	operations(nodes, ctx) {
-		const { config, resolver, root } = ctx;
-		const { output, group } = ctx.options;
-		const name = "operations";
-		const file = resolver.resolveFile({
-			name,
-			extname: ".ts"
-		}, {
-			root,
-			output,
-			group: group ?? void 0
-		});
-		const operationsObject = {};
-		for (const node of nodes) {
-			if (!ast.isHttpOperationNode(node)) continue;
-			operationsObject[node.operationId] = {
-				path: Url$1.toPath(node.path),
-				method: node.method.toLowerCase()
-			};
-		}
-		return [ast.createFile({
-			baseName: file.baseName,
-			path: file.path,
-			meta: file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: file.path,
-					baseName: file.baseName
-				}
-			}),
-			footer: resolver.resolveFooter(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: file.path,
-					baseName: file.baseName
-				}
-			}),
-			sources: [ast.createSource({
-				name,
-				isExportable: true,
-				isIndexable: true,
-				nodes: [ast.createConst({
-					name,
-					export: true,
-					nodes: [ast.createText(JSON.stringify(operationsObject, void 0, 2))]
-				})]
-			})]
-		})];
-	}
-});
-//#endregion
-//#region src/components/StaticClassClient.tsx
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-function generateMethod({ node, name, tsResolver, zodResolver, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
-	if (!ast.isHttpOperationNode(node)) return "";
-	const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node);
-	const isFormData = !isMultipleContentTypes && contentType === "multipart/form-data";
-	const { header: headerParams } = getOperationParameters(node);
-	const headerParamsName = headerParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, headerParams[0]) : null;
-	const headers = isMultipleContentTypes ? headerParamsName ? ["...headers"] : [] : buildHeaders(contentType, !!headerParamsName);
-	const generics = buildGenerics(node, tsResolver, {
-		dataReturnType,
-		zodResolver,
-		parser
-	});
-	const paramsNode = buildClientParamsNode({
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		node,
-		tsResolver,
-		isConfigurable: true
-	});
-	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
-	const { query: queryParams } = getOperationParameters(node);
-	const zodQueryParamsName = zodResolver && resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null;
-	const clientParams = buildClassClientParams({
-		node,
-		url: Url$1.toTemplateString(node.path, { casing: paramsCasing }),
-		baseURL,
-		tsResolver,
-		isFormData,
-		isMultipleContentTypes,
-		hasFormData,
-		headers,
-		zodQueryParamsName
-	});
-	const jsdoc = buildJSDoc(buildOperationComments(node, {
-		link: "urlPath",
-		linkPosition: "beforeDeprecated",
-		splitLines: true
-	}));
-	const requestDataLine = buildRequestDataLine({
-		parser,
-		node,
-		zodResolver
-	});
-	const queryParamsLine = buildQueryParamsLine({
-		parser,
-		node,
-		zodResolver
-	});
-	const formDataLine = buildFormDataLine(isFormData || isMultipleContentTypes && hasFormData, !!node.requestBody?.content?.[0]?.schema);
-	const returnStatement = buildReturnStatement({
-		dataReturnType,
-		parser,
-		node,
-		zodResolver,
-		tsResolver
-	});
-	return `${jsdoc}  static async ${name}(${paramsSignature}) {\n${[
-		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
-		"",
-		requestDataLine,
-		queryParamsLine,
-		formDataLine,
-		`const res = await request<${generics.join(", ")}>(${clientParams.toCall()})`,
-		returnStatement
-	].filter(Boolean).map((line) => `    ${line}`).join("\n")}\n  }`;
-}
-function StaticClassClient({ name, isExportable = true, isIndexable = true, operations, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType, children }) {
-	const classCode = `export class ${name} {\n  static #config: Partial<RequestConfig> & { client?: Client } = {}\n\n${operations.map(({ node, name: methodName, tsResolver, zodResolver }) => generateMethod({
-		node,
-		name: methodName,
-		tsResolver,
-		zodResolver,
-		baseURL,
-		dataReturnType,
-		parser,
-		paramsType,
-		paramsCasing,
-		pathParamsType
-	})).join("\n\n")}\n}`;
-	return /* @__PURE__ */ jsxs(File.Source, {
-		name,
-		isExportable,
-		isIndexable,
-		children: [classCode, children]
-	});
-}
-//#endregion
-//#region src/generators/staticClassClientGenerator.tsx
-function resolveTypeImportNames(node, tsResolver) {
-	return resolveOperationTypeNames(node, tsResolver, { order: "body-response-first" });
-}
-function resolveZodImportNames(node, zodResolver, parser) {
-	const { query: queryParams } = getOperationParameters(node);
-	return [
-		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
-		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
-	].filter((n) => Boolean(n));
-}
-/**
-* Built-in `operations` generator for `@kubb/plugin-client` when
-* `clientType: 'staticClass'`. Emits one class per tag, with a static method
-* per operation so callers can use `Pet.getPetById(...)` without
-* instantiating the class.
-*/
-const staticClassClientGenerator = defineGenerator({
-	name: "staticClassClient",
-	renderer: jsxRenderer,
-	operations(nodes, ctx) {
-		const { config, driver, resolver, root } = ctx;
-		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = ctx.options;
-		const baseURL = ctx.options.baseURL ?? ctx.meta.baseURL;
-		const pluginTs = driver.getPlugin(pluginTsName);
-		if (!pluginTs) return null;
-		const tsResolver = driver.getResolver(pluginTsName);
-		const tsPluginOptions = pluginTs.options;
-		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-		function buildOperationData(node) {
-			const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
-				root,
-				output: tsPluginOptions?.output ?? output,
-				group: tsPluginOptions?.group
-			});
-			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
-				root,
-				output: pluginZod.options?.output ?? output,
-				group: pluginZod.options?.group ?? void 0
-			}) : null;
-			return {
-				node,
-				name: resolver.resolveName(node.operationId),
-				tsResolver,
-				zodResolver,
-				typeFile,
-				zodFile
-			};
-		}
-		const controllers = nodes.reduce((acc, operationNode) => {
-			if (!ast.isHttpOperationNode(operationNode)) return acc;
-			const tag = operationNode.tags[0];
-			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveClassName("Client");
-			if (!tag && !group) {
-				const name = resolver.resolveClassName("ApiClient");
-				const file = resolver.resolveFile({
-					name,
-					extname: ".ts"
-				}, {
+				fileTypes: resolveDependencyOperationFile({
+					cache: ctx.cache,
+					node,
+					resolver: types.resolver,
 					root,
-					output,
-					group: group ?? void 0
-				});
-				const operationData = buildOperationData(operationNode);
-				const previous = acc.find((item) => item.file.path === file.path);
-				if (previous) previous.operations.push(operationData);
-				else acc.push({
-					name,
-					file,
-					operations: [operationData]
-				});
-				return acc;
-			}
-			if (tag) {
-				const name = groupName;
-				const file = resolver.resolveFile({
-					name,
-					extname: ".ts",
-					tag
-				}, {
+					output: types.output ?? output,
+					group: types.group
+				}),
+				fileZod: zodResolver && pluginZod?.options ? zodResolver.file({
+					...operationFileEntry(node, node.operationId),
 					root,
-					output,
-					group: group ?? void 0
-				});
-				const operationData = buildOperationData(operationNode);
-				const previous = acc.find((item) => item.file.path === file.path);
-				if (previous) previous.operations.push(operationData);
-				else acc.push({
-					name,
-					file,
-					operations: [operationData]
-				});
-			}
-			return acc;
-		}, []);
-		function collectTypeImports(ops) {
-			const typeImportsByFile = /* @__PURE__ */ new Map();
-			const typeFilesByPath = /* @__PURE__ */ new Map();
-			ops.forEach((op) => {
-				const names = resolveTypeImportNames(op.node, tsResolver);
-				if (!typeImportsByFile.has(op.typeFile.path)) typeImportsByFile.set(op.typeFile.path, /* @__PURE__ */ new Set());
-				const imports = typeImportsByFile.get(op.typeFile.path);
-				names.forEach((n) => {
-					imports.add(n);
-				});
-				typeFilesByPath.set(op.typeFile.path, op.typeFile);
-			});
-			return {
-				typeImportsByFile,
-				typeFilesByPath
+					output: pluginZod.options.output ?? output,
+					group: pluginZod.options?.group ?? void 0
+				}) : null
 			};
-		}
-		function collectZodImports(ops) {
-			const zodImportsByFile = /* @__PURE__ */ new Map();
-			const zodFilesByPath = /* @__PURE__ */ new Map();
-			ops.forEach((op) => {
-				if (!op.zodFile || !zodResolver) return;
-				const names = resolveZodImportNames(op.node, zodResolver, parser);
-				if (!zodImportsByFile.has(op.zodFile.path)) zodImportsByFile.set(op.zodFile.path, /* @__PURE__ */ new Set());
-				const imports = zodImportsByFile.get(op.zodFile.path);
-				names.forEach((n) => {
-					imports.add(n);
-				});
-				zodFilesByPath.set(op.zodFile.path, op.zodFile);
+			const security = getOperationSecurity({
+				document: ctx.adapter.document,
+				method: node.method,
+				path: node.path
 			});
-			return {
-				zodImportsByFile,
-				zodFilesByPath
-			};
-		}
-		return /* @__PURE__ */ jsx(Fragment, { children: controllers.map(({ name, file, operations: ops }) => {
-			const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops);
-			const { zodImportsByFile, zodFilesByPath } = isParserEnabled(parser) ? collectZodImports(ops) : {
-				zodImportsByFile: /* @__PURE__ */ new Map(),
-				zodFilesByPath: /* @__PURE__ */ new Map()
-			};
-			const hasFormData = ops.some((op) => op.node.requestBody?.content?.some((e) => e.contentType === "multipart/form-data") ?? false);
+			const customClientPath = resolveClientPath?.(ctx.options, root);
+			const clientPath = customClientPath ?? path.resolve(root, ".kubb/client.ts");
+			const clientRoot = customClientPath === void 0 ? meta.file.path : void 0;
+			const eventStream = isEventStream(node);
+			const clientValueImports = (() => {
+				if (eventStream) return ["client", "toEventStream"];
+				if (returnType === "plain") return ["client"];
+				if (returnType === "data") return ["client", "unwrapResult"];
+				return ["client", "withUnwrap"];
+			})();
+			const clientTypeImports = (() => {
+				if (eventStream) return [
+					"Options",
+					"EventStreamResult",
+					"SuccessOf"
+				];
+				if (returnType === "plain") return ["Options", "RequestResult"];
+				if (returnType === "data") return ["Options", "UnwrappedResult"];
+				return [
+					"Options",
+					"Unwrappable",
+					"RequestResult"
+				];
+			})();
 			return /* @__PURE__ */ jsxs(File, {
-				baseName: file.baseName,
-				path: file.path,
-				meta: file.meta,
-				banner: resolver.resolveBanner(ctx.meta, {
+				baseName: meta.file.baseName,
+				path: meta.file.path,
+				meta: meta.file.meta,
+				banner: resolver.default.banner(ctx.meta, {
 					output,
 					config,
 					file: {
-						path: file.path,
-						baseName: file.baseName
+						path: meta.file.path,
+						baseName: meta.file.baseName
 					}
 				}),
-				footer: resolver.resolveFooter(ctx.meta, {
+				footer: resolver.default.footer(ctx.meta, {
 					output,
 					config,
 					file: {
-						path: file.path,
-						baseName: file.baseName
+						path: meta.file.path,
+						baseName: meta.file.baseName
 					}
 				}),
 				children: [
-					importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
-						/* @__PURE__ */ jsx(File.Import, {
-							name: "client",
-							path: importPath
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["mergeConfig"],
-							path: importPath
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: [
-								"Client",
-								"RequestConfig",
-								"ResponseErrorConfig"
-							],
-							path: importPath,
-							isTypeOnly: true
-						})
-					] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["client"],
-							root: file.path,
-							path: path.resolve(root, ".kubb/client.ts")
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["mergeConfig"],
-							root: file.path,
-							path: path.resolve(root, ".kubb/client.ts")
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: [
-								"Client",
-								"RequestConfig",
-								"ResponseErrorConfig"
-							],
-							root: file.path,
-							path: path.resolve(root, ".kubb/client.ts"),
-							isTypeOnly: true
-						})
-					] }),
-					hasFormData && /* @__PURE__ */ jsx(File.Import, {
-						name: ["buildFormData"],
-						root: file.path,
-						path: path.resolve(root, ".kubb/config.ts")
+					/* @__PURE__ */ jsx(File.Import, {
+						name: clientValueImports,
+						root: clientRoot,
+						path: clientPath
 					}),
-					parser === "zod" && zodResolver && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
-						name: ["z"],
-						path: "zod",
+					/* @__PURE__ */ jsx(File.Import, {
+						name: clientTypeImports,
+						root: clientRoot,
+						path: clientPath,
 						isTypeOnly: true
 					}),
-					Array.from(typeImportsByFile.entries()).map(([filePath, importSet]) => {
-						const typeFile = typeFilesByPath.get(filePath);
-						if (!typeFile) return null;
-						const importNames = Array.from(importSet).filter(Boolean);
-						if (importNames.length === 0) return null;
-						return /* @__PURE__ */ jsx(File.Import, {
-							name: importNames,
-							root: file.path,
-							path: typeFile.path,
-							isTypeOnly: true
-						}, filePath);
+					meta.fileTypes && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+						name: Array.from(new Set(importedTypeNames)),
+						root: meta.file.path,
+						path: meta.fileTypes.path,
+						isTypeOnly: true
 					}),
-					isParserEnabled(parser) && Array.from(zodImportsByFile.entries()).map(([filePath, importSet]) => {
-						const zodFile = zodFilesByPath.get(filePath);
-						if (!zodFile) return null;
-						const importNames = Array.from(importSet).filter(Boolean);
-						if (importNames.length === 0) return null;
-						return /* @__PURE__ */ jsx(File.Import, {
-							name: importNames,
-							root: file.path,
-							path: zodFile.path
-						}, filePath);
+					meta.fileZod && importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+						name: importedZodNames,
+						root: meta.file.path,
+						path: meta.fileZod.path
 					}),
-					/* @__PURE__ */ jsx(StaticClassClient, {
-						name,
-						operations: ops,
-						baseURL,
-						dataReturnType,
-						pathParamsType,
-						paramsCasing,
-						paramsType,
-						parser
+					/* @__PURE__ */ jsx(Operation, {
+						name: meta.name,
+						node,
+						types,
+						zodResolver,
+						validator,
+						returnType,
+						throwOnErrorDefault,
+						security
 					})
 				]
-			}, file.path);
-		}) });
-	}
-});
+			});
+		}
+	});
+}
+//#endregion
+//#region ../../internals/client/src/macros.ts
+/**
+* Macros the client plugins apply by default, ahead of any user macros. `macroSimplifyUnion`
+* drops union members a broader scalar already covers, keeping the generated response and error
+* unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
+*/
+const defaultMacros = [macroSimplifyUnion];
 //#endregion
-//#region src/resolvers/resolverClient.ts
+//#region ../../internals/client/src/resolver.ts
 /**
-* Default resolver used by `@kubb/plugin-client`. Decides the names and file
-* paths for every generated client function or class. Functions and files use
-* camelCase; classes and tag groups use PascalCase.
+* Default resolver shared by the client plugins. Functions and files inherit the built-in camelCase
+* `name` and `file`; classes and tag groups use PascalCase.
 *
-* @example Resolve client function and class names
+* @example
 * ```ts
-* import { resolverClient } from '@kubb/plugin-client'
-*
-* resolverClient.default('list pets', 'function') // 'listPets'
-* resolverClient.resolveClassName('pet')          // 'Pet'
-* resolverClient.resolveGroupName('pet')          // 'PetClient'
-* resolverClient.resolveUrlName(operationNode)    // 'getShowPetByIdUrl'
+* resolverClient.name('show pet by id')  // 'showPetById'
+* resolverClient.groupName('pet')        // 'PetClient'
 * ```
 */
-const resolverClient = defineResolver(() => ({
-	name: "default",
-	pluginName: "plugin-client",
-	default(name, type) {
-		if (type === "file") return toFilePath(name);
-		return ensureValidVarName(camelCase(name));
-	},
-	resolveName(name) {
-		return this.default(name, "function");
-	},
-	resolvePathName(name, type) {
-		return this.default(name, type);
-	},
-	resolveClassName(name) {
+const resolverClient = createResolver({
+	pluginName: "plugin-contract-client",
+	className(name) {
 		return ensureValidVarName(pascalCase(name));
 	},
-	resolveGroupName(name) {
+	groupName(name) {
 		return ensureValidVarName(pascalCase(`${name} Client`));
 	},
-	resolveClientPropertyName(name) {
+	propertyName(name) {
 		return ensureValidVarName(camelCase(name));
-	},
-	resolveUrlName(node) {
-		const name = this.resolveName(node.operationId);
-		return `get${name.charAt(0).toUpperCase()}${name.slice(1)}Url`;
 	}
-}));
+});
+//#endregion
+//#region src/generators/clientGenerator.tsx
+/**
+* Built-in operation generator for `@kubb/plugin-client`. Emits one async function per OpenAPI
+* operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
+* that forwards a single `options` object to the user-provided client module and returns the `RequestResult`.
+*/
+const clientGenerator = createClientGenerator("client", (options) => options.importPath);
 //#endregion
 //#region src/plugin.ts
 /**
-* Canonical plugin name for `@kubb/plugin-client`. Used for driver lookups and
-* cross-plugin dependency references.
+* Canonical plugin name for `@kubb/plugin-client`.
 */
 const pluginClientName = "plugin-client";
 /**
-* Generates one HTTP client function per OpenAPI operation. Each function has
-* typed path params, query params, body, and response, so callers use the API
-* like any other typed function. Ships with `axios` and `fetch` runtimes; bring
-* your own by setting `importPath`.
+* Generates typed operations that call a client module owned by your application.
+* The module at `importPath` must export the runtime helpers and types used by generated operations.
+* Kubb does not copy or inject a transport implementation.
 *
 * @example
 * ```ts
-* import { defineConfig } from 'kubb'
-* import { pluginTs } from '@kubb/plugin-ts'
-* import { pluginClient } from '@kubb/plugin-client'
-*
-* export default defineConfig({
-*   input: { path: './petStore.yaml' },
-*   output: { path: './src/gen' },
-*   plugins: [
-*     pluginTs(),
-*     pluginClient({
-*       output: { path: './clients' },
-*       client: 'fetch',
-*     }),
-*   ],
-* })
+* pluginClient({ importPath: '../api/client' })
 * ```
 */
 const pluginClient = definePlugin((options) => {
 	const { output = {
 		path: "clients",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], urlType = false, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, paramsCasing, clientType = options.sdk ? "class" : "function", parser = false, client = "axios", importPath, bundle = false, sdk, baseURL, resolver: userResolver, transformer: userTransformer } = options;
-	const resolvedImportPath = importPath ?? (!bundle ? `@kubb/plugin-client/clients/${client}` : void 0);
-	const selectedGenerators = options.generators ?? [
-		clientType === "staticClass" ? staticClassClientGenerator : clientType === "class" ? classClientGenerator : clientGenerator,
-		group && clientType === "function" ? groupedClientGenerator : null,
-		operations ? operationsGenerator : null
-	].filter((x) => Boolean(x));
-	const groupConfig = createGroupConfig(group);
+	}, exclude = [], include, override = [], importPath, throwOnErrorDefault = true, validator = false, group, resolver: userResolver } = options;
+	const resolved = {
+		output,
+		exclude,
+		include,
+		override,
+		group: createGroupConfig(group),
+		importPath,
+		baseURL: void 0,
+		throwOnErrorDefault,
+		validator,
+		returnType: "plain",
+		sdk: void 0,
+		resolver: userResolver ? Resolver.merge(resolverClient, userResolver) : resolverClient
+	};
 	return {
 		name: pluginClientName,
 		options,
-		dependencies: [pluginTsName, isParserEnabled(parser) ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
+		dependencies: [pluginTsName, pluginZodName],
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverClient,
-				...userResolver
-			} : resolverClient;
-			ctx.setOptions({
-				client,
-				clientType,
-				bundle,
-				output,
-				exclude,
-				include,
-				override,
-				group: groupConfig,
-				parser,
-				dataReturnType,
-				importPath: resolvedImportPath,
-				baseURL,
-				paramsType,
-				paramsCasing,
-				pathParamsType,
-				urlType,
-				sdk,
-				resolver
-			});
-			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
-			for (const gen of selectedGenerators) ctx.addGenerator(gen);
-			const root = path.resolve(ctx.config.root, ctx.config.output.path);
-			if (!resolvedImportPath?.startsWith(".")) {
-				const isInlineSource = bundle && !resolvedImportPath;
-				ctx.injectFile({
-					baseName: "client.ts",
-					path: path.resolve(root, ".kubb/client.ts"),
-					sources: [ast.createSource({
-						name: "client",
-						nodes: isInlineSource ? [ast.createText(client === "fetch" ? source$1 : source)] : [],
-						isExportable: true,
-						isIndexable: true
-					})],
-					exports: !isInlineSource && resolvedImportPath ? [ast.createExport({ path: resolvedImportPath })] : []
-				});
-			}
-			ctx.injectFile({
-				baseName: "config.ts",
-				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [ast.createSource({
-					name: "config",
-					nodes: [ast.createText(source$2)],
-					isExportable: false,
-					isIndexable: false
-				})]
-			});
+			if (validator && !ctx.config.plugins?.some((plugin) => plugin.name === pluginZodName)) throw new Error(`${pluginClientName}: \`validator\` needs ${pluginZodName}. Add pluginZod() to the plugins or set \`validator: false\`.`);
+			ctx.setOptions(resolved);
+			ctx.setResolver(resolved.resolver);
+			ctx.setMacros([...defaultMacros, ...options.macros ?? []]);
+			ctx.addGenerator(clientGenerator);
 		} }
 	};
 });
 //#endregion
-export { Client, classClientGenerator, clientGenerator, pluginClient as default, pluginClient, groupedClientGenerator, isParserEnabled, operationsGenerator, pluginClientName, resolveQueryParamsParser, resolveRequestParser, resolveResponseParser, resolverClient, staticClassClientGenerator };
+export { pluginClient as default, pluginClient, pluginClientName };
 
 //# sourceMappingURL=index.js.map