@kubb/plugin-client 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/index.js

@@ -5,7 +5,7 @@ import { source as source$2 } from "./templates/config.source.js";
 import path from "node:path";
 import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
 import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { Const, File, Function, jsxRenderer } from "@kubb/renderer-jsx";
+import { Const, File, Function, jsxRendererSync } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 import { pluginZodName } from "@kubb/plugin-zod";
 //#region ../../internals/utils/src/casing.ts
@@ -185,6 +185,26 @@ function isValidVarName(name) {
 	if (!name || reservedWords.has(name)) return false;
 	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
+/**
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
+*
+* Useful for sanitizing OpenAPI schema names or operation IDs that start with
+* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
+* variable, type, or function names.
+*
+* @example
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
+*/
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
+}
 //#endregion
 //#region ../../internals/utils/src/urlPath.ts
 /**
@@ -251,16 +271,16 @@ var URLPath = class {
 	get object() {
 		return this.toObject();
 	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	/** Returns a map of path parameter names, or `null` when the path has no parameters.
 	*
 	* @example
 	* ```ts
 	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
+	* new URLPath('/pet').params         // null
 	* ```
 	*/
 	get params() {
-		return this.getParams();
+		return this.toParamsObject();
 	}
 	#transformParam(raw) {
 		const param = isValidVarName(raw) ? raw : camelCase(raw);
@@ -278,7 +298,7 @@ var URLPath = class {
 	toObject({ type = "path", replacer, stringify } = {}) {
 		const object = {
 			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
+			params: this.toParamsObject()
 		};
 		if (stringify) {
 			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
@@ -294,12 +314,13 @@ var URLPath = class {
 	* @example
 	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
 	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+	toTemplateString({ prefix, replacer } = {}) {
+		const result = this.path.split(/\{([^}]+)\}/).map((part, i) => {
 			if (i % 2 === 0) return part;
 			const param = this.#transformParam(part);
 			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
 	}
 	/**
 	* Extracts all `{param}` segments from the path and returns them as a key-value map.
@@ -308,17 +329,17 @@ var URLPath = class {
 	*
 	* @example
 	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+	* new URLPath('/pet/{petId}/tag/{tagId}').toParamsObject()
 	* // { petId: 'petId', tagId: 'tagId' }
 	* ```
 	*/
-	getParams(replacer) {
+	toParamsObject(replacer) {
 		const params = {};
 		this.#eachParam((_raw, param) => {
 			const key = replacer ? replacer(param) : param;
 			params[key] = key;
 		});
-		return Object.keys(params).length > 0 ? params : void 0;
+		return Object.keys(params).length > 0 ? params : null;
 	}
 	/** Converts the OpenAPI path to Express-style colon syntax.
 	*
@@ -332,6 +353,198 @@ var URLPath = class {
 	}
 };
 //#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.
+*
+* @example
+* ```ts
+* resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+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 ${new URLPath(node.path).URL}}` : 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));
+}
+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;
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+*
+* Returns `null` when grouping is disabled, matching the per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
+* @param options.honorName - When `true`, a user-provided `group.name` overrides the default namer.
+*
+* @example
+* ```ts
+* createGroupConfig(group, { suffix: 'Controller' })                  // plugin-ts, plugin-zod
+* createGroupConfig(group, { suffix: 'Controller', honorName: true }) // plugin-faker, plugin-client, …
+* createGroupConfig(group, { suffix: 'Requests', honorName: true })   // plugin-cypress, plugin-mcp
+* ```
+*/
+function createGroupConfig(group, options) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return `${camelCase(ctx.group)}${options.suffix}`;
+	};
+	return {
+		...group,
+		name: options.honorName && group.name ? group.name : defaultName
+	};
+}
+//#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" });
@@ -342,18 +555,18 @@ function createType(type) {
 	return type ? ast.createParamsType({
 		variant: "reference",
 		name: type
-	}) : void 0;
+	}) : null;
 }
 function createDeclarationLeaf(name, spec) {
 	if (spec.default !== void 0) return ast.createFunctionParameter({
 		name,
-		type: createType(spec.type),
+		type: createType(spec.type) ?? void 0,
 		default: spec.default,
 		rest: spec.mode === "inlineSpread"
 	});
 	return ast.createFunctionParameter({
 		name,
-		type: createType(spec.type),
+		type: createType(spec.type) ?? void 0,
 		optional: !!spec.optional,
 		rest: spec.mode === "inlineSpread"
 	});
@@ -362,14 +575,14 @@ 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 !== void 0).map(([childName, child]) => createDeclarationLeaf(childName, child))
+		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 !== void 0).map(([childName, child]) => ast.createFunctionParameter({
+		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"
 		}))
@@ -384,7 +597,7 @@ function createCallParam(name, spec) {
 * Returns utilities to output constructor signatures (`toConstructor()`) or call expressions (`toCall()`).
 */
 function createFunctionParams(params) {
-	const entries = Object.entries(params).filter(([, spec]) => spec !== void 0);
+	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)) })) ?? "";
@@ -395,106 +608,9 @@ function createFunctionParams(params) {
 	};
 }
 //#endregion
-//#region src/utils.ts
-/**
-* Extracts documentation comments from an operation node.
-* Includes description, summary, link, and deprecation information.
-*/
-function getComments(node) {
-	return [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		node.path && `{@link ${new URLPath(node.path).URL}}`,
-		node.deprecated && "@deprecated"
-	].filter((x) => Boolean(x)).flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((x) => Boolean(x));
-}
-/**
-* Builds a mapping of original parameter names to their transformed (cased) names.
-* Returns undefined if no names have changed.
-*/
-function buildParamsMapping(originalParams, casedParams) {
-	const mapping = {};
-	let hasChanged = false;
-	originalParams.forEach((param, i) => {
-		const casedName = casedParams[i]?.name ?? param.name;
-		mapping[param.name] = casedName;
-		if (param.name !== casedName) hasChanged = true;
-	});
-	return hasChanged ? mapping : void 0;
-}
-/**
-* Builds HTTP headers array for a client request.
-* Includes Content-Type (if not default) and spreads header parameters if present.
-*/
-function buildHeaders(contentType, hasHeaderParams) {
-	return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : void 0, hasHeaderParams ? "...headers" : void 0].filter(Boolean);
-}
-/**
-* Builds TypeScript generic parameters for a client method.
-* Includes response type, error type, and optional request type.
-*/
-function buildGenerics(node, tsResolver) {
-	const responseName = tsResolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0;
-	const errorNames = node.responses.filter((r) => Number.parseInt(r.statusCode, 10) >= 400).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
-	return [
-		responseName,
-		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
-		requestName || "unknown"
-	].filter(Boolean);
-}
-/**
-* Builds the parameters object for a class-based client method.
-* Includes URL, method, base URL, headers, and request/response data.
-*/
-function buildClassClientParams({ node, path, baseURL, tsResolver, isFormData, headers }) {
-	const queryParamsName = node.parameters.filter((p) => p.in === "query").length > 0 ? tsResolver.resolveQueryParamsName(node, node.parameters.filter((p) => p.in === "query")[0]) : void 0;
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0;
-	return createFunctionParams({ config: {
-		mode: "object",
-		children: {
-			requestConfig: { mode: "inlineSpread" },
-			method: { value: JSON.stringify(node.method.toUpperCase()) },
-			url: { value: path.template },
-			baseURL: baseURL ? { value: JSON.stringify(baseURL) } : void 0,
-			params: queryParamsName ? {} : void 0,
-			data: requestName ? { value: isFormData ? "formData as FormData" : "requestData" } : void 0,
-			headers: headers.length ? { value: `{ ${headers.join(", ")}, ...requestConfig.headers }` } : void 0
-		}
-	} });
-}
-/**
-* Builds the request data parsing line for client methods.
-* Applies Zod validation if configured, otherwise uses data directly.
-*/
-function buildRequestDataLine({ parser, node, zodResolver }) {
-	const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : void 0;
-	if (parser === "zod" && zodRequestName) return `const requestData = ${zodRequestName}.parse(data)`;
-	if (node.requestBody?.content?.[0]?.schema) return "const requestData = data";
-	return "";
-}
-/**
-* Builds the form data conversion line for file upload requests.
-* Returns empty string if not applicable.
-*/
-function buildFormDataLine(isFormData, hasRequest) {
-	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
-}
-/**
-* Builds the return statement for a client method.
-* Applies Zod validation to response data if configured, otherwise returns raw response.
-*/
-function buildReturnStatement({ dataReturnType, parser, node, zodResolver }) {
-	const zodResponseName = zodResolver && parser === "zod" ? zodResolver.resolveResponseName?.(node) : void 0;
-	if (dataReturnType === "full" && parser === "zod" && zodResponseName) return `return {...res, data: ${zodResponseName}.parse(res.data)}`;
-	if (dataReturnType === "data" && parser === "zod" && zodResponseName) return `return ${zodResponseName}.parse(res.data)`;
-	if (dataReturnType === "full" && parser === "client") return "return res";
-	return "return res.data";
-}
-//#endregion
 //#region src/components/Url.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
-function getParams$1({ paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
+function buildUrlParamsNode({ paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
 	const urlNode = {
 		...node,
 		parameters: node.parameters.filter((p) => p.in === "path"),
@@ -507,10 +623,10 @@ function getParams$1({ paramsType, paramsCasing, pathParamsType, node, tsResolve
 		resolver: tsResolver
 	});
 }
-__name(getParams$1, "getParams");
 function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
+	if (!ast.isHttpOperationNode(node)) return null;
 	const path = new URLPath(node.path);
-	const paramsNode = getParams$1({
+	const paramsNode = buildUrlParamsNode({
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -518,9 +634,9 @@ function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsTyp
 		tsResolver
 	});
 	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
-	const originalPathParams = node.parameters.filter((p) => p.in === "path");
-	const casedPathParams = ast.caseParams(originalPathParams, paramsCasing);
-	const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : void 0;
+	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,
@@ -542,56 +658,53 @@ function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsTyp
 		})
 	});
 }
-Url.getParams = getParams$1;
 //#endregion
 //#region src/components/Client.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
-function getParams({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }) {
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0;
+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({
+		extraParams: [...isConfigurable ? [ast.createFunctionParameter({
 			name: "config",
 			type: ast.createParamsType({
 				variant: "reference",
-				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+				name: buildRequestConfigType(node, tsResolver)
 			}),
 			default: "{}"
-		})] : []
+		})] : []]
 	});
 }
 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 path = new URLPath(node.path);
-	const contentType = node.requestBody?.content?.[0]?.contentType ?? "application/json";
-	const isFormData = contentType === "multipart/form-data";
-	const originalPathParams = node.parameters.filter((p) => p.in === "path");
-	const casedPathParams = ast.caseParams(originalPathParams, paramsCasing);
-	const originalQueryParams = node.parameters.filter((p) => p.in === "query");
-	const casedQueryParams = ast.caseParams(originalQueryParams, paramsCasing);
-	const originalHeaderParams = node.parameters.filter((p) => p.in === "header");
-	const casedHeaderParams = ast.caseParams(originalHeaderParams, paramsCasing);
-	const pathParamsMapping = paramsCasing && !urlName ? buildParamsMapping(originalPathParams, casedPathParams) : void 0;
-	const queryParamsMapping = paramsCasing ? buildParamsMapping(originalQueryParams, casedQueryParams) : void 0;
-	const headerParamsMapping = paramsCasing ? buildParamsMapping(originalHeaderParams, casedHeaderParams) : void 0;
-	const requestName = node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0;
-	const responseName = tsResolver.resolveResponseName(node);
-	const queryParamsName = originalQueryParams.length > 0 ? tsResolver.resolveQueryParamsName(node, originalQueryParams[0]) : void 0;
-	const headerParamsName = originalHeaderParams.length > 0 ? tsResolver.resolveHeaderParamsName(node, originalHeaderParams[0]) : void 0;
-	const zodResponseName = zodResolver && parser === "zod" ? zodResolver.resolveResponseName?.(node) : void 0;
-	const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : void 0;
+	const { defaultContentType: contentType, isMultipleContentTypes, hasFormData } = getContentTypeInfo(node);
+	const isFormData = !isMultipleContentTypes && contentType === "multipart/form-data";
+	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 zodResponseName = zodResolver && parser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
+	const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
 	const errorNames = node.responses.filter((r) => {
 		return Number.parseInt(r.statusCode, 10) >= 400;
 	}).map((r) => tsResolver.resolveResponseStatusName(node, r.statusCode));
-	const headers = [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : void 0, headerParamsName ? headerParamsMapping ? "...mappedHeaders" : "...headers" : void 0].filter(Boolean);
+	const headers = [!isMultipleContentTypes && contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null, headerParamsName ? headerParamsMapping ? "...mappedHeaders" : "...headers" : null].filter(Boolean);
 	const generics = [
 		responseName,
 		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
 		requestName || "unknown"
 	].filter(Boolean);
-	const paramsNode = getParams({
+	const paramsNode = buildClientParamsNode({
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -600,7 +713,7 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 		isConfigurable
 	});
 	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
-	const urlParamsNode = Url.getParams({
+	const urlParamsNode = buildUrlParamsNode({
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -613,18 +726,20 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 		children: {
 			method: { value: JSON.stringify(node.method.toUpperCase()) },
 			url: { value: urlName ? `${urlName}(${urlParamsCall}).url.toString()` : path.template },
-			baseURL: baseURL && !urlName ? { value: `\`${baseURL}\`` } : void 0,
-			params: queryParamsName ? queryParamsMapping ? { value: "mappedParams" } : {} : void 0,
-			data: requestName ? { value: isFormData ? "formData as FormData" : "requestData" } : void 0,
-			requestConfig: isConfigurable ? { mode: "inlineSpread" } : void 0,
-			headers: headers.length ? { value: isConfigurable ? `{ ${headers.join(", ")}, ...requestConfig.headers }` : `{ ${headers.join(", ")} }` } : void 0
+			baseURL: baseURL && !urlName ? { value: `\`${baseURL}\`` } : null,
+			params: queryParamsName ? 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: JSON.stringify(responseType) } : null,
+			requestConfig: isConfigurable ? { mode: "inlineSpread" } : null,
+			headers: headers.length ? { value: isConfigurable ? `{ ${headers.join(", ")}, ...requestConfig.headers }` : `{ ${headers.join(", ")} }` } : null
 		}
 	} });
 	const childrenElement = children ? children : /* @__PURE__ */ jsxs(Fragment, { children: [
 		dataReturnType === "full" && parser === "zod" && zodResponseName && `return {...res, data: ${zodResponseName}.parse(res.data)}`,
 		dataReturnType === "data" && parser === "zod" && zodResponseName && `return ${zodResponseName}.parse(res.data)`,
-		dataReturnType === "full" && parser === "client" && "return res",
-		dataReturnType === "data" && parser === "client" && "return res.data"
+		dataReturnType === "full" && parser !== "zod" && "return res",
+		dataReturnType === "data" && parser !== "zod" && "return res.data"
 	] });
 	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -635,10 +750,14 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 			async: true,
 			export: isExportable,
 			params: paramsSignature,
-			JSDoc: { comments: getComments(node) },
+			JSDoc: { comments: buildOperationComments(node, {
+				link: "urlPath",
+				linkPosition: "beforeDeprecated",
+				splitLines: true
+			}) },
 			returnType,
 			children: [
-				isConfigurable ? "const { client: request = fetch, ...requestConfig } = config" : "",
+				isConfigurable ? `const { client: request = client, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ""}...requestConfig } = config` : "",
 				/* @__PURE__ */ jsx("br", {}),
 				/* @__PURE__ */ jsx("br", {}),
 				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => isValidVarName(originalName) && originalName !== camelCaseName).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
@@ -655,26 +774,104 @@ function Client({ name, isExportable = true, isIndexable = true, returnType, bas
 				] }),
 				parser === "zod" && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && "const requestData = data",
 				/* @__PURE__ */ jsx("br", {}),
-				isFormData && requestName && "const formData = buildFormData(requestData)",
+				(isFormData || isMultipleContentTypes && hasFormData) && requestName && "const formData = buildFormData(requestData)",
 				/* @__PURE__ */ jsx("br", {}),
-				isConfigurable ? `const res = await request<${generics.join(", ")}>(${clientParams.toCall()})` : `const res = await fetch<${generics.join(", ")}>(${clientParams.toCall()})`,
+				isConfigurable ? `const res = await request<${generics.join(", ")}>(${clientParams.toCall()})` : `const res = await client<${generics.join(", ")}>(${clientParams.toCall()})`,
 				/* @__PURE__ */ jsx("br", {}),
 				childrenElement
 			]
 		})
 	})] });
 }
-Client.getParams = getParams;
+//#endregion
+//#region src/utils.ts
+/**
+* Builds HTTP headers array for a client request.
+* Includes Content-Type (if not default) and spreads header parameters if present.
+*/
+function buildHeaders(contentType, hasHeaderParams) {
+	return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : null, hasHeaderParams ? "...headers" : null].filter(Boolean);
+}
+/**
+* Builds TypeScript generic parameters for a client method.
+* Includes response type, error type, and optional request type.
+*/
+function buildGenerics(node, tsResolver) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = 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));
+	return [
+		responseName,
+		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+		requestName || "unknown"
+	].filter(Boolean);
+}
+/**
+* Builds the parameters object for a class-based client method.
+* Includes URL, method, base URL, headers, and request/response data.
+*/
+function buildClassClientParams({ node, path, baseURL, tsResolver, isFormData, isMultipleContentTypes, hasFormData, headers }) {
+	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: path.template },
+			baseURL: baseURL ? { value: JSON.stringify(baseURL) } : null,
+			params: queryParamsName ? {} : 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
+		}
+	} });
+}
+/**
+* Builds the request data parsing line for client methods.
+* Applies Zod validation if configured, otherwise uses data directly.
+*/
+function buildRequestDataLine({ parser, node, zodResolver }) {
+	const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null;
+	if (parser === "zod" && zodRequestName) return `const requestData = ${zodRequestName}.parse(data)`;
+	if (node.requestBody?.content?.[0]?.schema) return "const requestData = data";
+	return "";
+}
+/**
+* Builds the form data conversion line for file upload requests.
+* Returns empty string if not applicable.
+*/
+function buildFormDataLine(isFormData, hasRequest) {
+	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
+}
+/**
+* Builds the return statement for a client method.
+* Applies Zod validation to response data if configured, otherwise returns raw response.
+*/
+function buildReturnStatement({ dataReturnType, parser, node, zodResolver }) {
+	const zodResponseName = zodResolver && parser === "zod" ? zodResolver.resolveResponseName?.(node) : null;
+	if (dataReturnType === "full" && parser === "zod" && zodResponseName) return `return {...res, data: ${zodResponseName}.parse(res.data)}`;
+	if (dataReturnType === "data" && parser === "zod" && zodResponseName) return `return ${zodResponseName}.parse(res.data)`;
+	if (dataReturnType === "full" && parser !== "zod") return "return res";
+	return "return res.data";
+}
 //#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 path = new URLPath(node.path, { casing: paramsCasing });
-	const contentType = node.requestBody?.content?.[0]?.contentType ?? "application/json";
-	const isFormData = contentType === "multipart/form-data";
-	const headers = buildHeaders(contentType, !!(node.parameters.filter((p) => p.in === "header").length > 0 ? tsResolver.resolveHeaderParamsName(node, node.parameters.filter((p) => p.in === "header")[0]) : void 0));
+	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);
-	const paramsNode = ClassClient.getParams({
+	const paramsNode = buildClientParamsNode({
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -689,15 +886,21 @@ function generateMethod$1({ node, name, tsResolver, zodResolver, baseURL, dataRe
 		baseURL,
 		tsResolver,
 		isFormData,
+		isMultipleContentTypes,
+		hasFormData,
 		headers
 	});
-	const jsdoc = buildJSDoc(getComments(node));
+	const jsdoc = buildJSDoc(buildOperationComments(node, {
+		link: "urlPath",
+		linkPosition: "beforeDeprecated",
+		splitLines: true
+	}));
 	const requestDataLine = buildRequestDataLine({
 		parser,
 		node,
 		zodResolver
 	});
-	const formDataLine = buildFormDataLine(isFormData, !!node.requestBody?.content?.[0]?.schema);
+	const formDataLine = buildFormDataLine(isFormData || isMultipleContentTypes && hasFormData, !!node.requestBody?.content?.[0]?.schema);
 	const returnStatement = buildReturnStatement({
 		dataReturnType,
 		parser,
@@ -705,7 +908,7 @@ function generateMethod$1({ node, name, tsResolver, zodResolver, baseURL, dataRe
 		zodResolver
 	});
 	return `${jsdoc}async ${name}(${paramsSignature}) {\n${[
-		"const { client: request = fetch, ...requestConfig } = mergeConfig(this.#config, config)",
+		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
 		"",
 		requestDataLine,
 		formDataLine,
@@ -742,15 +945,14 @@ ${operations.map(({ node, name: methodName, tsResolver, zodResolver }) => genera
 		children: [classCode, children]
 	});
 }
-ClassClient.getParams = Client.getParams;
 //#endregion
 //#region src/components/WrapperClient.tsx
-function WrapperClient({ name, classNames, isExportable = true, isIndexable = true }) {
+function WrapperClient({ name, controllers, isExportable = true, isIndexable = true }) {
 	const classCode = `export class ${name} {
-${classNames.map((className) => `  readonly ${camelCase(className)}: ${className}`).join("\n")}
+${controllers.map(({ className, propertyName }) => `  readonly ${propertyName}: ${className}`).join("\n")}
 
   constructor(config: Partial<RequestConfig> & { client?: Client } = {}) {
-${classNames.map((className) => `    this.${camelCase(className)} = new ${className}(config)`).join("\n")}
+${controllers.map(({ className, propertyName }) => `    this.${propertyName} = new ${className}(config)`).join("\n")}
   }
 }`;
 	return /* @__PURE__ */ jsx(File.Source, {
@@ -763,54 +965,42 @@ ${classNames.map((className) => `    this.${camelCase(className)} = new ${classN
 //#endregion
 //#region src/generators/classClientGenerator.tsx
 function resolveTypeImportNames$1(node, tsResolver) {
-	return [
-		node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0,
-		tsResolver.resolveResponseName(node),
-		...node.parameters.filter((p) => p.in === "path").map((p) => tsResolver.resolvePathParamsName(node, p)),
-		...node.parameters.filter((p) => p.in === "query").map((p) => tsResolver.resolveQueryParamsName(node, p)),
-		...node.parameters.filter((p) => p.in === "header").map((p) => tsResolver.resolveHeaderParamsName(node, p)),
-		...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode))
-	].filter((n) => Boolean(n));
+	return resolveOperationTypeNames(node, tsResolver, { order: "body-response-first" });
 }
 __name(resolveTypeImportNames$1, "resolveTypeImportNames");
 function resolveZodImportNames$1(node, zodResolver) {
-	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : void 0].filter((n) => Boolean(n));
+	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter((n) => Boolean(n));
 }
 __name(resolveZodImportNames$1, "resolveZodImportNames");
+/**
+* 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.
+*/
 const classClientGenerator = defineGenerator({
 	name: "classClient",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	operations(nodes, ctx) {
-		const { adapter, config, driver, resolver, root } = ctx;
+		const { config, driver, resolver, root } = ctx;
 		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, sdk } = ctx.options;
-		const baseURL = ctx.options.baseURL ?? adapter.inputNode?.meta?.baseURL;
+		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 = parser === "zod" ? driver.getPlugin(pluginZodName) : void 0;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : void 0;
+		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 		function buildOperationData(node) {
-			const typeFile = tsResolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+			const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
 				root,
 				output: tsPluginOptions?.output ?? output,
 				group: tsPluginOptions?.group
 			});
-			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
 				root,
 				output: pluginZod.options?.output ?? output,
-				group: pluginZod.options?.group
-			}) : void 0;
+				group: pluginZod.options?.group ?? void 0
+			}) : null;
 			return {
 				node,
 				name: resolver.resolveName(node.operationId),
@@ -821,27 +1011,31 @@ const classClientGenerator = defineGenerator({
 			};
 		}
 		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) }) ?? pascalCase(tag) : "Client";
+			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveGroupName("Client");
 			if (!tag && !group) {
-				const name = "ApiClient";
+				const name = resolver.resolveClassName("ApiClient");
 				const file = resolver.resolveFile({
 					name,
 					extname: ".ts"
 				}, {
 					root,
 					output,
-					group
+					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]
 				});
-			} else if (tag) {
+				return acc;
+			}
+			if (tag) {
 				const name = groupName;
 				const file = resolver.resolveFile({
 					name,
@@ -850,13 +1044,14 @@ const classClientGenerator = defineGenerator({
 				}, {
 					root,
 					output,
-					group
+					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]
 				});
@@ -904,23 +1099,31 @@ const classClientGenerator = defineGenerator({
 				zodImportsByFile: /* @__PURE__ */ new Map(),
 				zodFilesByPath: /* @__PURE__ */ new Map()
 			};
-			const hasFormData = ops.some((op) => op.node.requestBody?.content?.[0]?.contentType === "multipart/form-data");
+			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(adapter.inputNode, {
+				banner: resolver.resolveBanner(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: file.path,
+						baseName: file.baseName
+					}
 				}),
-				footer: resolver.resolveFooter(adapter.inputNode, {
+				footer: resolver.resolveFooter(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: file.path,
+						baseName: file.baseName
+					}
 				}),
 				children: [
 					importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
 						/* @__PURE__ */ jsx(File.Import, {
-							name: "fetch",
+							name: "client",
 							path: importPath
 						}),
 						/* @__PURE__ */ jsx(File.Import, {
@@ -938,7 +1141,7 @@ const classClientGenerator = defineGenerator({
 						})
 					] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
 						/* @__PURE__ */ jsx(File.Import, {
-							name: ["fetch"],
+							name: ["client"],
 							root: file.path,
 							path: path.resolve(root, ".kubb/client.ts")
 						}),
@@ -1006,19 +1209,27 @@ const classClientGenerator = defineGenerator({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			});
 			files.push(/* @__PURE__ */ jsxs(File, {
 				baseName: sdkFile.baseName,
 				path: sdkFile.path,
 				meta: sdkFile.meta,
-				banner: resolver.resolveBanner(adapter.inputNode, {
+				banner: resolver.resolveBanner(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: sdkFile.path,
+						baseName: sdkFile.baseName
+					}
 				}),
-				footer: resolver.resolveFooter(adapter.inputNode, {
+				footer: resolver.resolveFooter(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: sdkFile.path,
+						baseName: sdkFile.baseName
+					}
 				}),
 				children: [
 					importPath ? /* @__PURE__ */ jsx(File.Import, {
@@ -1038,7 +1249,10 @@ const classClientGenerator = defineGenerator({
 					}, name)),
 					/* @__PURE__ */ jsx(WrapperClient, {
 						name: sdk.className,
-						classNames: controllers.map(({ name }) => name)
+						controllers: controllers.map(({ name, propertyName }) => ({
+							className: name,
+							propertyName
+						}))
 					})
 				]
 			}, sdkFile.path));
@@ -1048,81 +1262,69 @@ const classClientGenerator = defineGenerator({
 });
 //#endregion
 //#region src/generators/clientGenerator.tsx
+/**
+* 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).
+*/
 const clientGenerator = defineGenerator({
 	name: "client",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	operation(node, ctx) {
-		const { adapter, config, driver, resolver, root } = 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 ?? adapter.inputNode?.meta?.baseURL;
+		const baseURL = ctx.options.baseURL ?? ctx.meta.baseURL;
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
-		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : void 0;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : void 0;
-		const casedParams = ast.caseParams(node.parameters, paramsCasing);
-		const pathParams = casedParams.filter((p) => p.in === "path");
-		const queryParams = casedParams.filter((p) => p.in === "query");
-		const headerParams = casedParams.filter((p) => p.in === "header");
-		const importedTypeNames = [
-			...pathParams.map((p) => tsResolver.resolvePathParamsName(node, p)),
-			...queryParams.map((p) => tsResolver.resolveQueryParamsName(node, p)),
-			...headerParams.map((p) => tsResolver.resolveHeaderParamsName(node, p)),
-			node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0,
-			tsResolver.resolveResponseName(node),
-			...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode))
-		].filter(Boolean);
-		const importedZodNames = zodResolver && parser === "zod" ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : void 0].filter(Boolean) : [];
+		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+		const importedTypeNames = resolveOperationTypeNames(node, tsResolver, { paramsCasing });
+		const importedZodNames = zodResolver && parser === "zod" ? [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null].filter((name) => Boolean(name)) : [];
 		const meta = {
 			name: resolver.resolveName(node.operationId),
-			urlName: `get${resolver.resolveName(node.operationId).charAt(0).toUpperCase()}${resolver.resolveName(node.operationId).slice(1)}Url`,
-			file: resolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+			urlName: resolver.resolveUrlName(node),
+			file: resolver.resolveFile(operationFileEntry(node, node.operationId), {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}),
-			fileTs: tsResolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
 				root,
 				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
+				group: pluginTs.options?.group ?? void 0
 			}),
-			fileZod: zodResolver && pluginZod?.options ? zodResolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+			fileZod: zodResolver && pluginZod?.options ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
 				root,
 				output: pluginZod.options.output ?? output,
-				group: pluginZod.options?.group
-			}) : void 0
+				group: pluginZod.options?.group ?? void 0
+			}) : null
 		};
-		const isFormData = node.requestBody?.content?.[0]?.contentType === "multipart/form-data";
+		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(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
-					name: "fetch",
+					name: "client",
 					path: importPath
 				}), /* @__PURE__ */ jsx(File.Import, {
 					name: [
@@ -1133,7 +1335,7 @@ const clientGenerator = defineGenerator({
 					path: importPath,
 					isTypeOnly: true
 				})] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
-					name: ["fetch"],
+					name: ["client"],
 					root: meta.file.path,
 					path: path.resolve(root, ".kubb/client.ts")
 				}), /* @__PURE__ */ jsx(File.Import, {
@@ -1146,7 +1348,7 @@ const clientGenerator = defineGenerator({
 					path: path.resolve(root, ".kubb/client.ts"),
 					isTypeOnly: true
 				})] }),
-				isFormData && node.requestBody?.content?.[0]?.schema && /* @__PURE__ */ jsx(File.Import, {
+				hasFormData && /* @__PURE__ */ jsx(File.Import, {
 					name: ["buildFormData"],
 					root: meta.file.path,
 					path: path.resolve(root, ".kubb/config.ts")
@@ -1192,16 +1394,22 @@ const clientGenerator = defineGenerator({
 });
 //#endregion
 //#region src/generators/groupedClientGenerator.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.
+*/
 const groupedClientGenerator = defineGenerator({
 	name: "groupedClient",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	operations(nodes, ctx) {
-		const { config, resolver, adapter, root } = 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) }) : void 0;
+				const name = tag ? group?.name?.({ group: camelCase(tag) }) : null;
 				if (!tag || !name) return acc;
 				const file = resolver.resolveFile({
 					name,
@@ -1210,7 +1418,7 @@ const groupedClientGenerator = defineGenerator({
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				});
 				const clientFile = resolver.resolveFile({
 					name: operationNode.operationId,
@@ -1220,7 +1428,7 @@ const groupedClientGenerator = defineGenerator({
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				});
 				const client = {
 					name: resolver.resolveName(operationNode.operationId),
@@ -1240,13 +1448,23 @@ const groupedClientGenerator = defineGenerator({
 				baseName: file.baseName,
 				path: file.path,
 				meta: file.meta,
-				banner: resolver.resolveBanner(adapter.inputNode, {
+				banner: resolver.resolveBanner(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: file.path,
+						baseName: file.baseName,
+						isAggregation: true
+					}
 				}),
-				footer: resolver.resolveFooter(adapter.inputNode, {
+				footer: resolver.resolveFooter(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: file.path,
+						baseName: file.baseName,
+						isAggregation: true
+					}
 				}),
 				children: [clients.map((client) => /* @__PURE__ */ jsx(File.Import, {
 					name: [client.name],
@@ -1271,6 +1489,7 @@ const groupedClientGenerator = defineGenerator({
 function Operations({ name, nodes }) {
 	const operationsObject = {};
 	nodes.forEach((node) => {
+		if (!ast.isHttpOperationNode(node)) return;
 		operationsObject[node.operationId] = {
 			path: new URLPath(node.path).URL,
 			method: node.method.toLowerCase()
@@ -1289,11 +1508,17 @@ function Operations({ name, nodes }) {
 }
 //#endregion
 //#region src/generators/operationsGenerator.tsx
+/**
+* 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",
-	renderer: jsxRenderer,
+	renderer: jsxRendererSync,
 	operations(nodes, ctx) {
-		const { config, resolver, adapter, root } = ctx;
+		const { config, resolver, root } = ctx;
 		const { output, group } = ctx.options;
 		const name = "operations";
 		const file = resolver.resolveFile({
@@ -1302,23 +1527,31 @@ const operationsGenerator = defineGenerator({
 		}, {
 			root,
 			output,
-			group
+			group: group ?? void 0
 		});
 		return /* @__PURE__ */ jsx(File, {
 			baseName: file.baseName,
 			path: file.path,
 			meta: file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
 			}),
 			children: /* @__PURE__ */ jsx(Operations, {
 				name,
-				nodes
+				nodes: nodes.filter(ast.isHttpOperationNode)
 			})
 		});
 	}
@@ -1327,12 +1560,15 @@ const operationsGenerator = defineGenerator({
 //#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 path = new URLPath(node.path, { casing: paramsCasing });
-	const contentType = node.requestBody?.content?.[0]?.contentType ?? "application/json";
-	const isFormData = contentType === "multipart/form-data";
-	const headers = buildHeaders(contentType, !!(node.parameters.filter((p) => p.in === "header").length > 0 ? tsResolver.resolveHeaderParamsName(node, node.parameters.filter((p) => p.in === "header")[0]) : void 0));
+	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);
-	const paramsNode = Client.getParams({
+	const paramsNode = buildClientParamsNode({
 		paramsType,
 		paramsCasing,
 		pathParamsType,
@@ -1347,15 +1583,21 @@ function generateMethod({ node, name, tsResolver, zodResolver, baseURL, dataRetu
 		baseURL,
 		tsResolver,
 		isFormData,
+		isMultipleContentTypes,
+		hasFormData,
 		headers
 	});
-	const jsdoc = buildJSDoc(getComments(node));
+	const jsdoc = buildJSDoc(buildOperationComments(node, {
+		link: "urlPath",
+		linkPosition: "beforeDeprecated",
+		splitLines: true
+	}));
 	const requestDataLine = buildRequestDataLine({
 		parser,
 		node,
 		zodResolver
 	});
-	const formDataLine = buildFormDataLine(isFormData, !!node.requestBody?.content?.[0]?.schema);
+	const formDataLine = buildFormDataLine(isFormData || isMultipleContentTypes && hasFormData, !!node.requestBody?.content?.[0]?.schema);
 	const returnStatement = buildReturnStatement({
 		dataReturnType,
 		parser,
@@ -1363,7 +1605,7 @@ function generateMethod({ node, name, tsResolver, zodResolver, baseURL, dataRetu
 		zodResolver
 	});
 	return `${jsdoc}  static async ${name}(${paramsSignature}) {\n${[
-		"const { client: request = fetch, ...requestConfig } = mergeConfig(this.#config, config)",
+		`const { client: request = client, ${isMultipleContentTypes ? `contentType = ${JSON.stringify(contentType)}, ` : ""}...requestConfig } = mergeConfig(this.#config, config)`,
 		"",
 		requestDataLine,
 		formDataLine,
@@ -1391,56 +1633,44 @@ function StaticClassClient({ name, isExportable = true, isIndexable = true, oper
 		children: [classCode, children]
 	});
 }
-StaticClassClient.getParams = Client.getParams;
 //#endregion
 //#region src/generators/staticClassClientGenerator.tsx
 function resolveTypeImportNames(node, tsResolver) {
-	return [
-		node.requestBody?.content?.[0]?.schema ? tsResolver.resolveDataName(node) : void 0,
-		tsResolver.resolveResponseName(node),
-		...node.parameters.filter((p) => p.in === "path").map((p) => tsResolver.resolvePathParamsName(node, p)),
-		...node.parameters.filter((p) => p.in === "query").map((p) => tsResolver.resolveQueryParamsName(node, p)),
-		...node.parameters.filter((p) => p.in === "header").map((p) => tsResolver.resolveHeaderParamsName(node, p)),
-		...node.responses.map((res) => tsResolver.resolveResponseStatusName(node, res.statusCode))
-	].filter((n) => Boolean(n));
+	return resolveOperationTypeNames(node, tsResolver, { order: "body-response-first" });
 }
 function resolveZodImportNames(node, zodResolver) {
-	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : void 0].filter((n) => Boolean(n));
+	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : 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,
+	renderer: jsxRendererSync,
 	operations(nodes, ctx) {
-		const { adapter, config, driver, resolver, root } = ctx;
+		const { config, driver, resolver, root } = ctx;
 		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = ctx.options;
-		const baseURL = ctx.options.baseURL ?? adapter.inputNode?.meta?.baseURL;
+		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 = parser === "zod" ? driver.getPlugin(pluginZodName) : void 0;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : void 0;
+		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 		function buildOperationData(node) {
-			const typeFile = tsResolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+			const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
 				root,
 				output: tsPluginOptions?.output ?? output,
 				group: tsPluginOptions?.group
 			});
-			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
 				root,
 				output: pluginZod.options?.output ?? output,
-				group: pluginZod.options?.group
-			}) : void 0;
+				group: pluginZod.options?.group ?? void 0
+			}) : null;
 			return {
 				node,
 				name: resolver.resolveName(node.operationId),
@@ -1451,17 +1681,18 @@ const staticClassClientGenerator = defineGenerator({
 			};
 		}
 		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) }) ?? pascalCase(tag) : "Client";
+			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.resolveGroupName(tag) : resolver.resolveGroupName("Client");
 			if (!tag && !group) {
-				const name = "ApiClient";
+				const name = resolver.resolveClassName("ApiClient");
 				const file = resolver.resolveFile({
 					name,
 					extname: ".ts"
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				});
 				const operationData = buildOperationData(operationNode);
 				const previous = acc.find((item) => item.file.path === file.path);
@@ -1471,7 +1702,9 @@ const staticClassClientGenerator = defineGenerator({
 					file,
 					operations: [operationData]
 				});
-			} else if (tag) {
+				return acc;
+			}
+			if (tag) {
 				const name = groupName;
 				const file = resolver.resolveFile({
 					name,
@@ -1480,7 +1713,7 @@ const staticClassClientGenerator = defineGenerator({
 				}, {
 					root,
 					output,
-					group
+					group: group ?? void 0
 				});
 				const operationData = buildOperationData(operationNode);
 				const previous = acc.find((item) => item.file.path === file.path);
@@ -1534,23 +1767,31 @@ const staticClassClientGenerator = defineGenerator({
 				zodImportsByFile: /* @__PURE__ */ new Map(),
 				zodFilesByPath: /* @__PURE__ */ new Map()
 			};
-			const hasFormData = ops.some((op) => op.node.requestBody?.content?.[0]?.contentType === "multipart/form-data");
+			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(adapter.inputNode, {
+				banner: resolver.resolveBanner(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: file.path,
+						baseName: file.baseName
+					}
 				}),
-				footer: resolver.resolveFooter(adapter.inputNode, {
+				footer: resolver.resolveFooter(ctx.meta, {
 					output,
-					config
+					config,
+					file: {
+						path: file.path,
+						baseName: file.baseName
+					}
 				}),
 				children: [
 					importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
 						/* @__PURE__ */ jsx(File.Import, {
-							name: "fetch",
+							name: "client",
 							path: importPath
 						}),
 						/* @__PURE__ */ jsx(File.Import, {
@@ -1568,7 +1809,7 @@ const staticClassClientGenerator = defineGenerator({
 						})
 					] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
 						/* @__PURE__ */ jsx(File.Import, {
-							name: ["fetch"],
+							name: ["client"],
 							root: file.path,
 							path: path.resolve(root, ".kubb/client.ts")
 						}),
@@ -1634,39 +1875,75 @@ const staticClassClientGenerator = defineGenerator({
 //#endregion
 //#region src/resolvers/resolverClient.ts
 /**
-* Naming convention resolver for client plugin.
+* 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.
 *
-* Provides default naming helpers using camelCase for functions and file paths.
+* @example Resolve client function and class names
+* ```ts
+* import { resolverClient } from '@kubb/plugin-client'
 *
-* @example
-* `resolverClient.default('list pets', 'function')  // → 'listPets'`
+* resolverClient.default('list pets', 'function') // 'listPets'
+* resolverClient.resolveClassName('pet')          // 'Pet'
+* resolverClient.resolveUrlName(operationNode)    // 'getShowPetByIdUrl'
+* ```
 */
-const resolverClient = defineResolver((ctx) => ({
+const resolverClient = defineResolver(() => ({
 	name: "default",
 	pluginName: "plugin-client",
 	default(name, type) {
-		return camelCase(name, { isFile: type === "file" });
+		const resolved = camelCase(name, { isFile: type === "file" });
+		return type === "file" ? resolved : ensureValidVarName(resolved);
 	},
 	resolveName(name) {
-		return ctx.default(name, "function");
+		return this.default(name, "function");
+	},
+	resolvePathName(name, type) {
+		return this.default(name, type);
+	},
+	resolveClassName(name) {
+		return ensureValidVarName(pascalCase(name));
+	},
+	resolveGroupName(name) {
+		return ensureValidVarName(pascalCase(name));
+	},
+	resolveClientPropertyName(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/plugin.ts
 /**
-* Canonical plugin name for `@kubb/plugin-client`, used in driver lookups and warnings.
+* Canonical plugin name for `@kubb/plugin-client`. Used for driver lookups and
+* cross-plugin dependency references.
 */
 const pluginClientName = "plugin-client";
 /**
-* Generates type-safe HTTP client functions or classes from an OpenAPI specification.
-* Creates client APIs by walking operations and delegating to generators.
-* Writes barrel files based on the configured `barrelType`.
+* 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`.
 *
-* @example Client generator
+* @example
 * ```ts
-* import pluginClient from '@kubb/plugin-client'
+* import { defineConfig } from 'kubb'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginClient } from '@kubb/plugin-client'
+*
 * export default defineConfig({
-*   plugins: [pluginClient({ output: { path: 'clients' } })]
+*   input: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginClient({
+*       output: { path: './clients' },
+*       client: 'fetch',
+*     }),
+*   ],
 * })
 * ```
 */
@@ -1674,24 +1951,21 @@ const pluginClient = definePlugin((options) => {
 	const { output = {
 		path: "clients",
 		barrelType: "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 = "client", client = "axios", importPath, bundle = false, sdk, baseURL, resolver: userResolver, transformer: userTransformer } = options;
+	}, 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 : void 0,
-		operations ? operationsGenerator : void 0
+		group && clientType === "function" ? groupedClientGenerator : null,
+		operations ? operationsGenerator : null
 	].filter((x) => Boolean(x));
-	const groupConfig = group ? {
-		...group,
-		name: group.name ? group.name : (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+	const groupConfig = createGroupConfig(group, {
+		suffix: "Controller",
+		honorName: true
+	});
 	return {
 		name: pluginClientName,
 		options,
-		dependencies: [pluginTsName, parser === "zod" ? pluginZodName : void 0].filter(Boolean),
+		dependencies: [pluginTsName, parser === "zod" ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
 		hooks: { "kubb:plugin:setup"(ctx) {
 			const resolver = userResolver ? {
 				...resolverClient,