@kubb/plugin-client 5.0.0-alpha.27 → 5.0.0-alpha.29

package/dist/index.js

@@ -1,79 +1,1907 @@
-import "./chunk--u3MIqq1.js";
-import { o as camelCase } from "./StaticClassClient-D6v3vhZL.js";
-import { a as classClientGenerator, i as clientGenerator, n as operationsGenerator, r as groupedClientGenerator, t as staticClassClientGenerator } from "./generators-C0t5dIvZ.js";
+import { t as __name } from "./chunk--u3MIqq1.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 path from "node:path";
-import { createPlugin, getBarrelFiles, getMode } from "@kubb/core";
-import { OperationGenerator, pluginOasName } from "@kubb/plugin-oas";
+import { caseParams, createFunctionParameter, createOperationParams, createTypeNode, transform, walk } from "@kubb/ast";
+import { functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { Const, File, Function as Function$1, FunctionParams } from "@kubb/react-fabric";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+import { createPlugin, defineGenerator, definePresets, defineResolver, getBarrelFiles, getPreset, runGeneratorOperation, runGeneratorOperations } from "@kubb/core";
 import { pluginZodName } from "@kubb/plugin-zod";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+*/
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region ../../internals/utils/src/jsdoc.ts
+/**
+* Builds a JSDoc comment block from an array of lines.
+* Returns `fallback` when `comments` is empty so callers always get a usable string.
+*
+* @example
+* ```ts
+* buildJSDoc(['@type string', '@example hello'])
+* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
+* ```
+*/
+function buildJSDoc(comments, options = {}) {
+	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
+	if (comments.length === 0) return fallback;
+	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
+/**
+* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+*
+* @example
+* const p = new URLPath('/pet/{petId}')
+* p.URL      // '/pet/:petId'
+* p.template // '`/pet/${petId}`'
+*/
+var URLPath = class {
+	/**
+	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+	*/
+	path;
+	#options;
+	constructor(path, options = {}) {
+		this.path = path;
+		this.#options = options;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
+	* ```
+	*/
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	*
+	* @example
+	* ```ts
+	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+	* new URLPath('/pet/{petId}').isURL                       // false
+	* ```
+	*/
+	get isURL() {
+		try {
+			return !!new URL(this.path).href;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+	*/
+	get template() {
+		return this.toTemplateString();
+	}
+	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').object
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	* ```
+	*/
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
+	* new URLPath('/pet').params         // undefined
+	* ```
+	*/
+	get params() {
+		return this.getParams();
+	}
+	#transformParam(raw) {
+		const param = isValidVarName(raw) ? raw : camelCase(raw);
+		return this.#options.casing === "camelcase" ? camelCase(param) : param;
+	}
+	/**
+	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	*/
+	#eachParam(fn) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		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;
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	* An optional `replacer` can transform each extracted parameter name before interpolation.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+	*/
+	toTemplateString({ prefix = "", replacer } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* Extracts all `{param}` segments from the path and returns them as a key-value map.
+	* An optional `replacer` transforms each parameter name in both key and value positions.
+	* Returns `undefined` when no path parameters are found.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+	* // { petId: 'petId', tagId: 'tagId' }
+	* ```
+	*/
+	getParams(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;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+	* ```
+	*/
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
+//#region src/utils.ts
+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));
+}
+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;
+}
+function buildHeaders(contentType, hasHeaderParams) {
+	return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : void 0, hasHeaderParams ? "...headers" : void 0].filter(Boolean);
+}
+function buildGenerics(node, tsResolver) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const requestName = node.requestBody?.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);
+}
+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?.schema ? tsResolver.resolveDataName(node) : void 0;
+	return FunctionParams.factory({ 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
+		}
+	} });
+}
+function buildRequestDataLine({ parser, node, zodResolver }) {
+	const zodRequestName = zodResolver && parser === "zod" && node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : void 0;
+	if (parser === "zod" && zodRequestName) return `const requestData = ${zodRequestName}.parse(data)`;
+	if (node.requestBody?.schema) return "const requestData = data";
+	return "";
+}
+function buildFormDataLine(isFormData, hasRequest) {
+	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
+}
+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$2({ paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
+	return createOperationParams({
+		...node,
+		parameters: node.parameters.filter((p) => p.in === "path"),
+		requestBody: void 0
+	}, {
+		paramsType: paramsType === "object" ? "object" : "inline",
+		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
+		paramsCasing,
+		resolver: tsResolver
+	});
+}
+__name(getParams$2, "getParams");
+function Url({ name, isExportable = true, isIndexable = true, baseURL, paramsType, paramsCasing, pathParamsType, node, tsResolver }) {
+	const path = new URLPath(node.path);
+	const paramsNode = getParams$2({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		node,
+		tsResolver
+	});
+	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
+	const originalPathParams = node.parameters.filter((p) => p.in === "path");
+	const casedPathParams = caseParams(originalPathParams, paramsCasing);
+	const pathParamsMapping = paramsCasing ? buildParamsMapping(originalPathParams, casedPathParams) : void 0;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: /* @__PURE__ */ jsxs(Function$1, {
+			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: ${path.toTemplateString({ prefix: baseURL })} as const }`
+				}),
+				/* @__PURE__ */ jsx("br", {}),
+				"return res"
+			]
+		})
+	});
+}
+Url.getParams = getParams$2;
+//#endregion
+//#region src/components/Client.tsx
+const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
+function getParams$1({ paramsType, paramsCasing, pathParamsType, node, tsResolver, isConfigurable }) {
+	const requestName = node.requestBody?.schema ? tsResolver.resolveDataName(node) : void 0;
+	return createOperationParams(node, {
+		paramsType,
+		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
+		paramsCasing,
+		resolver: tsResolver,
+		extraParams: isConfigurable ? [createFunctionParameter({
+			name: "config",
+			type: createTypeNode({
+				variant: "reference",
+				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
+			}),
+			default: "{}"
+		})] : []
+	});
+}
+__name(getParams$1, "getParams");
+function Client({ name, isExportable = true, isIndexable = true, returnType, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType, node, tsResolver, zodResolver, urlName, children, isConfigurable = true }) {
+	const path = new URLPath(node.path);
+	const contentType = node.requestBody?.contentType ?? "application/json";
+	const isFormData = contentType === "multipart/form-data";
+	const originalPathParams = node.parameters.filter((p) => p.in === "path");
+	const casedPathParams = caseParams(originalPathParams, paramsCasing);
+	const originalQueryParams = node.parameters.filter((p) => p.in === "query");
+	const casedQueryParams = caseParams(originalQueryParams, paramsCasing);
+	const originalHeaderParams = node.parameters.filter((p) => p.in === "header");
+	const casedHeaderParams = 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?.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?.schema ? zodResolver.resolveDataName?.(node) : void 0;
+	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 generics = [
+		responseName,
+		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+		requestName || "unknown"
+	].filter(Boolean);
+	const paramsNode = getParams$1({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		node,
+		tsResolver,
+		isConfigurable
+	});
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	const urlParamsNode = Url.getParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		node,
+		tsResolver
+	});
+	const urlParamsCall = functionPrinter({ mode: "call" }).print(urlParamsNode) ?? "";
+	const clientParams = FunctionParams.factory({ config: {
+		mode: "object",
+		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
+		}
+	} });
+	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"
+	] });
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: /* @__PURE__ */ jsxs(Function$1, {
+			name,
+			async: true,
+			export: isExportable,
+			params: paramsSignature,
+			JSDoc: { comments: getComments(node) },
+			returnType,
+			children: [
+				isConfigurable ? "const { client: request = fetch, ...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"),
+				pathParamsMapping && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__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", {}),
+					/* @__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", {}),
+					/* @__PURE__ */ jsx("br", {})
+				] }),
+				parser === "zod" && zodRequestName ? `const requestData = ${zodRequestName}.parse(data)` : requestName && "const requestData = data",
+				/* @__PURE__ */ jsx("br", {}),
+				isFormData && 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()})`,
+				/* @__PURE__ */ jsx("br", {}),
+				childrenElement
+			]
+		})
+	})] });
+}
+Client.getParams = getParams$1;
+//#endregion
+//#region src/components/ClientLegacy.tsx
+function isSchemaRequired(schema) {
+	if (!schema) return false;
+	return Array.isArray(schema.required) ? !!schema.required.length : !!schema.required;
+}
+function isSchemaOptional(schema) {
+	return !isSchemaRequired(schema);
+}
+function isAllOptionalDeep(schema) {
+	if (!schema) return true;
+	if (Array.isArray(schema.required) && schema.required.length > 0) return false;
+	if (schema.allOf) return schema.allOf.every(isAllOptionalDeep);
+	return true;
+}
+function getSchemaDefaultValue(schema) {
+	if (!schema || !isSchemaOptional(schema)) return void 0;
+	if (schema.type === "array") return "[]";
+	if (schema.anyOf || schema.oneOf) {
+		const variants = schema.anyOf || schema.oneOf;
+		if (!Array.isArray(variants)) return void 0;
+		if (variants.some(isAllOptionalDeep)) return "{}";
+		return;
+	}
+	if (schema.type === "object" || schema.properties) return "{}";
+}
+function legacyGetPathParams(operationSchema, options = {}) {
+	if (!operationSchema?.schema?.properties || !operationSchema.name) return {};
+	const requiredFields = Array.isArray(operationSchema.schema.required) ? operationSchema.schema.required : [];
+	return Object.entries(operationSchema.schema.properties).reduce((acc, [name]) => {
+		if (!name) return acc;
+		let paramName = name;
+		if (options.casing === "camelcase") paramName = camelCase(name);
+		else if (!isValidVarName(name)) paramName = camelCase(name);
+		const accessName = options.casing === "camelcase" ? camelCase(name) : name;
+		acc[paramName] = {
+			default: void 0,
+			type: options.typed ? `${operationSchema.name}["${accessName}"]` : void 0,
+			optional: !requiredFields.includes(name)
+		};
+		return acc;
+	}, {});
+}
+function legacyGetParamsMapping(operationSchema, options = {}) {
+	if (!operationSchema?.schema?.properties) return void 0;
+	const allEntries = [];
+	let hasTransformation = false;
+	Object.entries(operationSchema.schema.properties).forEach(([originalName]) => {
+		let transformedName = originalName;
+		if (options.casing === "camelcase") transformedName = camelCase(originalName);
+		else if (!isValidVarName(originalName)) transformedName = camelCase(originalName);
+		allEntries.push([originalName, transformedName]);
+		if (transformedName !== originalName) hasTransformation = true;
+	});
+	if (options.casing === "camelcase" && hasTransformation) return Object.fromEntries(allEntries);
+	const mapping = {};
+	allEntries.forEach(([originalName, transformedName]) => {
+		if (transformedName !== originalName) mapping[originalName] = transformedName;
+	});
+	return Object.keys(mapping).length > 0 ? mapping : void 0;
+}
+function legacyGetComments(operation) {
+	return [
+		operation.getDescription?.() && `@description ${operation.getDescription()}`,
+		operation.getSummary?.() && `@summary ${operation.getSummary()}`,
+		operation.path && `{@link ${new URLPath(operation.path).URL}}`,
+		operation.isDeprecated?.() && "@deprecated"
+	].filter((x) => Boolean(x)).flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((x) => Boolean(x));
+}
+function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas, isConfigurable }) {
+	if (paramsType === "object") {
+		const children = {
+			...legacyGetPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing
+			}),
+			data: typeSchemas.request?.name ? {
+				type: typeSchemas.request?.name,
+				optional: isSchemaOptional(typeSchemas.request?.schema)
+			} : void 0,
+			params: typeSchemas.queryParams?.name ? {
+				type: typeSchemas.queryParams?.name,
+				optional: isSchemaOptional(typeSchemas.queryParams?.schema)
+			} : void 0,
+			headers: typeSchemas.headerParams?.name ? {
+				type: typeSchemas.headerParams?.name,
+				optional: isSchemaOptional(typeSchemas.headerParams?.schema)
+			} : void 0
+		};
+		const allChildrenAreOptional = Object.values(children).every((child) => !child || child.optional);
+		return FunctionParams.factory({
+			data: {
+				mode: "object",
+				children,
+				default: allChildrenAreOptional ? "{}" : void 0
+			},
+			config: isConfigurable ? {
+				type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
+				default: "{}"
+			} : void 0
+		});
+	}
+	return FunctionParams.factory({
+		pathParams: typeSchemas.pathParams?.name ? {
+			mode: pathParamsType === "object" ? "object" : "inlineSpread",
+			children: legacyGetPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing
+			}),
+			default: getSchemaDefaultValue(typeSchemas.pathParams?.schema)
+		} : void 0,
+		data: typeSchemas.request?.name ? {
+			type: typeSchemas.request?.name,
+			optional: isSchemaOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: typeSchemas.queryParams?.name,
+			optional: isSchemaOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: typeSchemas.headerParams?.name,
+			optional: isSchemaOptional(typeSchemas.headerParams?.schema)
+		} : void 0,
+		config: isConfigurable ? {
+			type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
+			default: "{}"
+		} : void 0
+	});
+}
+function ClientLegacy({ name, isExportable = true, isIndexable = true, returnType, typeSchemas, baseURL, dataReturnType, parser, zodSchemas, paramsType, paramsCasing, pathParamsType, operation, urlName, children, isConfigurable = true }) {
+	const path = new URLPath(operation.path);
+	const contentType = operation.getContentType?.() ?? "application/json";
+	const isFormData = contentType === "multipart/form-data";
+	const pathParamsMapping = paramsCasing && !urlName ? legacyGetParamsMapping(typeSchemas.pathParams, { casing: paramsCasing }) : void 0;
+	const queryParamsMapping = paramsCasing ? legacyGetParamsMapping(typeSchemas.queryParams, { casing: paramsCasing }) : void 0;
+	const headerParamsMapping = paramsCasing ? legacyGetParamsMapping(typeSchemas.headerParams, { casing: paramsCasing }) : void 0;
+	const headers = [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : void 0, typeSchemas.headerParams?.name ? headerParamsMapping ? "...mappedHeaders" : "...headers" : void 0].filter(Boolean);
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const generics = [
+		typeSchemas.response.name,
+		TError,
+		typeSchemas.request?.name || "unknown"
+	].filter(Boolean);
+	const params = getParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas,
+		isConfigurable
+	});
+	const urlParams = UrlLegacy.getParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas
+	});
+	const clientParams = FunctionParams.factory({ config: {
+		mode: "object",
+		children: {
+			method: { value: JSON.stringify(operation.method.toUpperCase()) },
+			url: { value: urlName ? `${urlName}(${urlParams.toCall()}).url.toString()` : path.template },
+			baseURL: baseURL && !urlName ? { value: `\`${baseURL}\`` } : void 0,
+			params: typeSchemas.queryParams?.name ? queryParamsMapping ? { value: "mappedParams" } : {} : void 0,
+			data: typeSchemas.request?.name ? { 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
+		}
+	} });
+	const childrenElement = children ? children : /* @__PURE__ */ jsxs(Fragment, { children: [
+		dataReturnType === "full" && parser === "zod" && zodSchemas && `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`,
+		dataReturnType === "data" && parser === "zod" && zodSchemas && `return ${zodSchemas.response.name}.parse(res.data)`,
+		dataReturnType === "full" && parser === "client" && "return res",
+		dataReturnType === "data" && parser === "client" && "return res.data"
+	] });
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: /* @__PURE__ */ jsxs(Function$1, {
+			name,
+			async: true,
+			export: isExportable,
+			params: params.toConstructor(),
+			JSDoc: { comments: legacyGetComments(operation) },
+			returnType,
+			children: [
+				isConfigurable ? "const { client: request = fetch, ...requestConfig } = config" : "",
+				/* @__PURE__ */ jsx("br", {}),
+				/* @__PURE__ */ jsx("br", {}),
+				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName)).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
+				pathParamsMapping && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("br", {}), /* @__PURE__ */ jsx("br", {})] }),
+				queryParamsMapping && typeSchemas.queryParams?.name && /* @__PURE__ */ jsxs(Fragment, { children: [
+					`const mappedParams = params ? { ${Object.entries(queryParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": params.${camelCaseName}`).join(", ")} } : undefined`,
+					/* @__PURE__ */ jsx("br", {}),
+					/* @__PURE__ */ jsx("br", {})
+				] }),
+				headerParamsMapping && typeSchemas.headerParams?.name && /* @__PURE__ */ jsxs(Fragment, { children: [
+					`const mappedHeaders = headers ? { ${Object.entries(headerParamsMapping).map(([originalName, camelCaseName]) => `"${originalName}": headers.${camelCaseName}`).join(", ")} } : undefined`,
+					/* @__PURE__ */ jsx("br", {}),
+					/* @__PURE__ */ jsx("br", {})
+				] }),
+				parser === "zod" && zodSchemas?.request?.name ? `const requestData = ${zodSchemas.request.name}.parse(data)` : typeSchemas?.request?.name && "const requestData = data",
+				/* @__PURE__ */ jsx("br", {}),
+				isFormData && typeSchemas?.request?.name && "const formData = buildFormData(requestData)",
+				/* @__PURE__ */ jsx("br", {}),
+				isConfigurable ? `const res = await request<${generics.join(", ")}>(${clientParams.toCall()})` : `const res = await fetch<${generics.join(", ")}>(${clientParams.toCall()})`,
+				/* @__PURE__ */ jsx("br", {}),
+				childrenElement
+			]
+		})
+	})] });
+}
+ClientLegacy.getParams = getParams;
+function getUrlParams({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
+	if (paramsType === "object") {
+		const pathParams = legacyGetPathParams(typeSchemas.pathParams, {
+			typed: true,
+			casing: paramsCasing
+		});
+		return FunctionParams.factory({ data: {
+			mode: "object",
+			children: { ...pathParams }
+		} });
+	}
+	return FunctionParams.factory({ pathParams: typeSchemas.pathParams?.name ? {
+		mode: pathParamsType === "object" ? "object" : "inlineSpread",
+		children: legacyGetPathParams(typeSchemas.pathParams, {
+			typed: true,
+			casing: paramsCasing
+		}),
+		default: getSchemaDefaultValue(typeSchemas.pathParams?.schema)
+	} : void 0 });
+}
+function UrlLegacy({ name, isExportable = true, isIndexable = true, typeSchemas, baseURL, paramsType, paramsCasing, pathParamsType, operation }) {
+	const path = new URLPath(operation.path);
+	const params = getUrlParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas
+	});
+	const pathParamsMapping = paramsCasing ? legacyGetParamsMapping(typeSchemas.pathParams, { casing: paramsCasing }) : void 0;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: /* @__PURE__ */ jsxs(Function$1, {
+			name,
+			export: isExportable,
+			params: params.toConstructor(),
+			children: [
+				pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName)).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
+				pathParamsMapping && /* @__PURE__ */ jsx("br", {}),
+				/* @__PURE__ */ jsx(Const, {
+					name: "res",
+					children: `{ method: '${operation.method.toUpperCase()}', url: ${path.toTemplateString({ prefix: baseURL })} as const }`
+				}),
+				/* @__PURE__ */ jsx("br", {}),
+				"return res"
+			]
+		})
+	});
+}
+UrlLegacy.getParams = getUrlParams;
+//#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 }) {
+	const path = new URLPath(node.path, { casing: paramsCasing });
+	const contentType = node.requestBody?.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 generics = buildGenerics(node, tsResolver);
+	const paramsNode = ClassClient.getParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		node,
+		tsResolver,
+		isConfigurable: true
+	});
+	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
+	const clientParams = buildClassClientParams({
+		node,
+		path,
+		baseURL,
+		tsResolver,
+		isFormData,
+		headers
+	});
+	const jsdoc = buildJSDoc(getComments(node));
+	const requestDataLine = buildRequestDataLine({
+		parser,
+		node,
+		zodResolver
+	});
+	const formDataLine = buildFormDataLine(isFormData, !!node.requestBody?.schema);
+	const returnStatement = buildReturnStatement({
+		dataReturnType,
+		parser,
+		node,
+		zodResolver
+	});
+	return `${jsdoc}async ${name}(${paramsSignature}) {\n${[
+		"const { client: request = fetch, ...requestConfig } = mergeConfig(this.#config, config)",
+		"",
+		requestDataLine,
+		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]
+	});
+}
+ClassClient.getParams = Client.getParams;
+//#endregion
+//#region src/components/WrapperClient.tsx
+function WrapperClient({ name, classNames, isExportable = true, isIndexable = true }) {
+	const classCode = `export class ${name} {
+${classNames.map((className) => `  readonly ${camelCase(className)}: ${className}`).join("\n")}
+
+  constructor(config: Partial<RequestConfig> & { client?: Client } = {}) {
+${classNames.map((className) => `    this.${camelCase(className)} = 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 [
+		node.requestBody?.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));
+}
+__name(resolveTypeImportNames$1, "resolveTypeImportNames");
+function resolveZodImportNames$1(node, zodResolver) {
+	return [zodResolver.resolveResponseName?.(node), node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : void 0].filter((n) => Boolean(n));
+}
+__name(resolveZodImportNames$1, "resolveZodImportNames");
+const classClientGenerator = defineGenerator({
+	name: "classClient",
+	type: "react",
+	Operations({ nodes, options, config, driver, resolver, adapter, plugin }) {
+		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, wrapper } = options;
+		const baseURL = options.baseURL ?? adapter.rootNode?.meta?.baseURL;
+		const root = path.resolve(config.root, config.output.path);
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs?.resolver) return null;
+		const tsResolver = pluginTs.resolver;
+		const tsPluginOptions = pluginTs.options;
+		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : void 0;
+		const zodResolver = pluginZod?.resolver;
+		function buildOperationData(node) {
+			const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+			const typeFile = tsResolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: tsPluginOptions?.output ?? output,
+				group: tsPluginOptions?.group
+			});
+			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: pluginZod.options.output ?? output,
+				group: pluginZod.options.group
+			}) : void 0;
+			return {
+				node: transformedNode,
+				name: resolver.resolveName(transformedNode.operationId),
+				tsResolver,
+				zodResolver,
+				typeFile,
+				zodFile
+			};
+		}
+		const controllers = nodes.reduce((acc, operationNode) => {
+			const tag = operationNode.tags[0];
+			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? pascalCase(tag) : "Client";
+			if (!tag && !group) {
+				const name = "ApiClient";
+				const file = resolver.resolveFile({
+					name,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				});
+				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]
+				});
+			} else if (tag) {
+				const name = groupName;
+				const file = resolver.resolveFile({
+					name,
+					extname: ".ts",
+					tag
+				}, {
+					root,
+					output,
+					group
+				});
+				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$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);
+				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 } = parser === "zod" ? collectZodImports(ops) : {
+				zodImportsByFile: /* @__PURE__ */ new Map(),
+				zodFilesByPath: /* @__PURE__ */ new Map()
+			};
+			const hasFormData = ops.some((op) => op.node.requestBody?.contentType === "multipart/form-data");
+			return /* @__PURE__ */ jsxs(File, {
+				baseName: file.baseName,
+				path: file.path,
+				meta: file.meta,
+				banner: resolver.resolveBanner(adapter.rootNode, {
+					output,
+					config
+				}),
+				footer: resolver.resolveFooter(adapter.rootNode, {
+					output,
+					config
+				}),
+				children: [
+					importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx(File.Import, {
+							name: "fetch",
+							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: ["fetch"],
+							root: file.path,
+							path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: ["mergeConfig"],
+							root: file.path,
+							path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: [
+								"Client",
+								"RequestConfig",
+								"ResponseErrorConfig"
+							],
+							root: file.path,
+							path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
+							isTypeOnly: true
+						})
+					] }),
+					hasFormData && /* @__PURE__ */ jsx(File.Import, {
+						name: ["buildFormData"],
+						root: file.path,
+						path: path.resolve(config.root, config.output.path, ".kubb/config.ts")
+					}),
+					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);
+					}),
+					parser === "zod" && 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 (wrapper) {
+			const wrapperFile = resolver.resolveFile({
+				name: wrapper.className,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group
+			});
+			files.push(/* @__PURE__ */ jsxs(File, {
+				baseName: wrapperFile.baseName,
+				path: wrapperFile.path,
+				meta: wrapperFile.meta,
+				banner: resolver.resolveBanner(adapter.rootNode, {
+					output,
+					config
+				}),
+				footer: resolver.resolveFooter(adapter.rootNode, {
+					output,
+					config
+				}),
+				children: [
+					importPath ? /* @__PURE__ */ jsx(File.Import, {
+						name: ["Client", "RequestConfig"],
+						path: importPath,
+						isTypeOnly: true
+					}) : /* @__PURE__ */ jsx(File.Import, {
+						name: ["Client", "RequestConfig"],
+						root: wrapperFile.path,
+						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
+						isTypeOnly: true
+					}),
+					controllers.map(({ name, file }) => /* @__PURE__ */ jsx(File.Import, {
+						name: [name],
+						root: wrapperFile.path,
+						path: file.path
+					}, name)),
+					/* @__PURE__ */ jsx(WrapperClient, {
+						name: wrapper.className,
+						classNames: controllers.map(({ name }) => name)
+					})
+				]
+			}, wrapperFile.path));
+		}
+		return files;
+	}
+});
+//#endregion
+//#region src/generators/clientGenerator.tsx
+const clientGenerator = defineGenerator({
+	name: "client",
+	type: "react",
+	Operation({ node, adapter, options, config, driver, resolver, plugin }) {
+		const { output, urlType, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath, group } = options;
+		const baseURL = options.baseURL ?? adapter.rootNode?.meta?.baseURL;
+		const root = path.resolve(config.root, config.output.path);
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs?.resolver) return null;
+		const tsResolver = pluginTs.resolver;
+		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : void 0;
+		const zodResolver = pluginZod?.resolver;
+		const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+		const casedParams = caseParams(transformedNode.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(transformedNode, p)),
+			...queryParams.map((p) => tsResolver.resolveQueryParamsName(transformedNode, p)),
+			...headerParams.map((p) => tsResolver.resolveHeaderParamsName(transformedNode, p)),
+			transformedNode.requestBody?.schema ? tsResolver.resolveDataName(transformedNode) : void 0,
+			tsResolver.resolveResponseName(transformedNode),
+			...transformedNode.responses.map((res) => tsResolver.resolveResponseStatusName(transformedNode, res.statusCode))
+		].filter(Boolean);
+		const importedZodNames = zodResolver && parser === "zod" ? [zodResolver.resolveResponseName?.(transformedNode), transformedNode.requestBody?.schema ? zodResolver.resolveDataName?.(transformedNode) : void 0].filter(Boolean) : [];
+		const meta = {
+			name: resolver.resolveName(transformedNode.operationId),
+			urlName: `get${resolver.resolveName(transformedNode.operationId).charAt(0).toUpperCase()}${resolver.resolveName(transformedNode.operationId).slice(1)}Url`,
+			file: resolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output,
+				group
+			}),
+			fileTs: tsResolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group
+			}),
+			fileZod: zodResolver && pluginZod?.options ? zodResolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: pluginZod.options.output ?? output,
+				group: pluginZod.options.group
+			}) : void 0
+		};
+		const isFormData = transformedNode.requestBody?.contentType === "multipart/form-data";
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: [
+				importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
+					name: "fetch",
+					path: importPath
+				}), /* @__PURE__ */ jsx(File.Import, {
+					name: [
+						"Client",
+						"RequestConfig",
+						"ResponseErrorConfig"
+					],
+					path: importPath,
+					isTypeOnly: true
+				})] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
+					name: ["fetch"],
+					root: meta.file.path,
+					path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
+				}), /* @__PURE__ */ jsx(File.Import, {
+					name: [
+						"Client",
+						"RequestConfig",
+						"ResponseErrorConfig"
+					],
+					root: meta.file.path,
+					path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
+					isTypeOnly: true
+				})] }),
+				isFormData && transformedNode.requestBody?.schema && /* @__PURE__ */ jsx(File.Import, {
+					name: ["buildFormData"],
+					root: meta.file.path,
+					path: path.resolve(config.root, config.output.path, ".kubb/config.ts")
+				}),
+				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: transformedNode,
+					tsResolver,
+					isIndexable: urlType === "export",
+					isExportable: urlType === "export"
+				}),
+				/* @__PURE__ */ jsx(Client, {
+					name: meta.name,
+					urlName: meta.urlName,
+					baseURL,
+					dataReturnType,
+					pathParamsType,
+					paramsCasing,
+					paramsType,
+					node: transformedNode,
+					tsResolver,
+					zodResolver,
+					parser
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/groupedClientGenerator.tsx
+const groupedClientGenerator = defineGenerator({
+	name: "groupedClient",
+	type: "react",
+	Operations({ nodes, options, config, resolver, adapter, plugin }) {
+		const { output, group } = options;
+		const root = path.resolve(config.root, config.output.path);
+		return nodes.reduce((acc, operationNode) => {
+			if (group?.type === "tag") {
+				const tag = operationNode.tags[0];
+				const name = tag ? group?.name?.({ group: camelCase(tag) }) : void 0;
+				if (!tag || !name) return acc;
+				const transformedNode = plugin.transformer ? transform(operationNode, plugin.transformer) : operationNode;
+				const file = resolver.resolveFile({
+					name,
+					extname: ".ts",
+					tag
+				}, {
+					root,
+					output,
+					group
+				});
+				const clientFile = resolver.resolveFile({
+					name: transformedNode.operationId,
+					extname: ".ts",
+					tag: transformedNode.tags[0] ?? "default",
+					path: transformedNode.path
+				}, {
+					root,
+					output,
+					group
+				});
+				const client = {
+					name: resolver.resolveName(transformedNode.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(adapter.rootNode, {
+					output,
+					config
+				}),
+				footer: resolver.resolveFooter(adapter.rootNode, {
+					output,
+					config
+				}),
+				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$1, {
+						export: true,
+						name,
+						children: `return { ${clients.map((client) => client.name).join(", ")} }`
+					})
+				})]
+			}, file.path);
+		});
+	}
+});
+//#endregion
+//#region src/components/Operations.tsx
+function Operations({ name, nodes }) {
+	const operationsObject = {};
+	nodes.forEach((node) => {
+		operationsObject[node.operationId] = {
+			path: new URLPath(node.path).URL,
+			method: node.method.toLowerCase()
+		};
+	});
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Const, {
+			name,
+			export: true,
+			children: JSON.stringify(operationsObject, void 0, 2)
+		})
+	});
+}
+//#endregion
+//#region src/generators/operationsGenerator.tsx
+const operationsGenerator = defineGenerator({
+	name: "client",
+	type: "react",
+	Operations({ nodes, options, config, resolver, adapter }) {
+		const { output, group } = options;
+		const root = path.resolve(config.root, config.output.path);
+		const name = "operations";
+		const file = resolver.resolveFile({
+			name,
+			extname: ".ts"
+		}, {
+			root,
+			output,
+			group
+		});
+		return /* @__PURE__ */ jsx(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: resolver.resolveBanner(adapter.rootNode, {
+				output,
+				config
+			}),
+			footer: resolver.resolveFooter(adapter.rootNode, {
+				output,
+				config
+			}),
+			children: /* @__PURE__ */ jsx(Operations, {
+				name,
+				nodes
+			})
+		});
+	}
+});
+//#endregion
+//#region src/components/StaticClassClient.tsx
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+function generateMethod({ node, name, tsResolver, zodResolver, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
+	const path = new URLPath(node.path, { casing: paramsCasing });
+	const contentType = node.requestBody?.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 generics = buildGenerics(node, tsResolver);
+	const paramsNode = Client.getParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		node,
+		tsResolver,
+		isConfigurable: true
+	});
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	const clientParams = buildClassClientParams({
+		node,
+		path,
+		baseURL,
+		tsResolver,
+		isFormData,
+		headers
+	});
+	const jsdoc = buildJSDoc(getComments(node));
+	const requestDataLine = buildRequestDataLine({
+		parser,
+		node,
+		zodResolver
+	});
+	const formDataLine = buildFormDataLine(isFormData, !!node.requestBody?.schema);
+	const returnStatement = buildReturnStatement({
+		dataReturnType,
+		parser,
+		node,
+		zodResolver
+	});
+	return `${jsdoc}  static async ${name}(${paramsSignature}) {\n${[
+		"const { client: request = fetch, ...requestConfig } = mergeConfig(this.#config, config)",
+		"",
+		requestDataLine,
+		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]
+	});
+}
+StaticClassClient.getParams = Client.getParams;
+//#endregion
+//#region src/generators/staticClassClientGenerator.tsx
+function resolveTypeImportNames(node, tsResolver) {
+	return [
+		node.requestBody?.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));
+}
+function resolveZodImportNames(node, zodResolver) {
+	return [zodResolver.resolveResponseName?.(node), node.requestBody?.schema ? zodResolver.resolveDataName?.(node) : void 0].filter((n) => Boolean(n));
+}
+const staticClassClientGenerator = defineGenerator({
+	name: "staticClassClient",
+	type: "react",
+	Operations({ nodes, options, config, driver, resolver, adapter, plugin }) {
+		const { output, group, dataReturnType, paramsCasing, paramsType, pathParamsType, parser, importPath } = options;
+		const baseURL = options.baseURL ?? adapter.rootNode?.meta?.baseURL;
+		const root = path.resolve(config.root, config.output.path);
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs?.resolver) return null;
+		const tsResolver = pluginTs.resolver;
+		const tsPluginOptions = pluginTs.options;
+		const pluginZod = parser === "zod" ? driver.getPlugin(pluginZodName) : void 0;
+		const zodResolver = pluginZod?.resolver;
+		function buildOperationData(node) {
+			const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+			const typeFile = tsResolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: tsPluginOptions?.output ?? output,
+				group: tsPluginOptions?.group
+			});
+			const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile({
+				name: transformedNode.operationId,
+				extname: ".ts",
+				tag: transformedNode.tags[0] ?? "default",
+				path: transformedNode.path
+			}, {
+				root,
+				output: pluginZod.options.output ?? output,
+				group: pluginZod.options.group
+			}) : void 0;
+			return {
+				node: transformedNode,
+				name: resolver.resolveName(transformedNode.operationId),
+				tsResolver,
+				zodResolver,
+				typeFile,
+				zodFile
+			};
+		}
+		const controllers = nodes.reduce((acc, operationNode) => {
+			const tag = operationNode.tags[0];
+			const groupName = tag ? group?.name?.({ group: camelCase(tag) }) ?? pascalCase(tag) : "Client";
+			if (!tag && !group) {
+				const name = "ApiClient";
+				const file = resolver.resolveFile({
+					name,
+					extname: ".ts"
+				}, {
+					root,
+					output,
+					group
+				});
+				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]
+				});
+			} else if (tag) {
+				const name = groupName;
+				const file = resolver.resolveFile({
+					name,
+					extname: ".ts",
+					tag
+				}, {
+					root,
+					output,
+					group
+				});
+				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
+			};
+		}
+		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);
+				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
+			};
+		}
+		return controllers.map(({ name, file, operations: ops }) => {
+			const { typeImportsByFile, typeFilesByPath } = collectTypeImports(ops);
+			const { zodImportsByFile, zodFilesByPath } = parser === "zod" ? collectZodImports(ops) : {
+				zodImportsByFile: /* @__PURE__ */ new Map(),
+				zodFilesByPath: /* @__PURE__ */ new Map()
+			};
+			const hasFormData = ops.some((op) => op.node.requestBody?.contentType === "multipart/form-data");
+			return /* @__PURE__ */ jsxs(File, {
+				baseName: file.baseName,
+				path: file.path,
+				meta: file.meta,
+				banner: resolver.resolveBanner(adapter.rootNode, {
+					output,
+					config
+				}),
+				footer: resolver.resolveFooter(adapter.rootNode, {
+					output,
+					config
+				}),
+				children: [
+					importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx(File.Import, {
+							name: "fetch",
+							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: ["fetch"],
+							root: file.path,
+							path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: ["mergeConfig"],
+							root: file.path,
+							path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: [
+								"Client",
+								"RequestConfig",
+								"ResponseErrorConfig"
+							],
+							root: file.path,
+							path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
+							isTypeOnly: true
+						})
+					] }),
+					hasFormData && /* @__PURE__ */ jsx(File.Import, {
+						name: ["buildFormData"],
+						root: file.path,
+						path: path.resolve(config.root, config.output.path, ".kubb/config.ts")
+					}),
+					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);
+					}),
+					parser === "zod" && 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(StaticClassClient, {
+						name,
+						operations: ops,
+						baseURL,
+						dataReturnType,
+						pathParamsType,
+						paramsCasing,
+						paramsType,
+						parser
+					})
+				]
+			}, file.path);
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverClient.ts
+/**
+* Resolver for `@kubb/plugin-client` that provides the default naming
+* and path-resolution helpers used by the plugin.
+*
+* @example
+* ```ts
+* import { resolverClient } from '@kubb/plugin-client'
+*
+* resolverClient.default('list pets', 'function') // -> 'listPets'
+* resolverClient.resolveName('show pet by id')    // -> 'showPetById'
+* ```
+*/
+const resolverClient = defineResolver(() => ({
+	name: "default",
+	pluginName: "plugin-client",
+	default(name, type) {
+		return camelCase(name, { isFile: type === "file" });
+	},
+	resolveName(name) {
+		return this.default(name, "function");
+	}
+}));
+//#endregion
+//#region src/resolvers/resolverClientLegacy.ts
+/**
+* Legacy resolver for `@kubb/plugin-client` that provides backward-compatible
+* naming conventions matching the v4 behavior.
+*
+* @example
+* ```ts
+* import { resolverClientLegacy } from '@kubb/plugin-client'
+*
+* resolverClientLegacy.default('list pets', 'function') // -> 'listPets'
+* resolverClientLegacy.resolveName('show pet by id')    // -> 'showPetById'
+* ```
+*/
+const resolverClientLegacy = defineResolver(() => ({
+	name: "kubbV4",
+	pluginName: "plugin-client",
+	default(name, type) {
+		return camelCase(name, { isFile: type === "file" });
+	},
+	resolveName(name) {
+		return this.default(name, "function");
+	}
+}));
+//#endregion
+//#region src/presets.ts
+/**
+* Built-in preset registry for `@kubb/plugin-client`.
+*
+* - `default` — uses `resolverClient` with v5 naming conventions.
+* - `kubbV4`  — uses `resolverClientLegacy` with backward-compatible naming.
+*
+* Note: Unlike plugin-ts/plugin-zod, generators are not defined here because
+* plugin-client selects generators dynamically based on `clientType`, `group`,
+* and `operations` options. Generator selection happens in `plugin.ts`.
+*/
+const presets = definePresets({
+	default: {
+		name: "default",
+		resolver: resolverClient
+	},
+	kubbV4: {
+		name: "kubbV4",
+		resolver: resolverClientLegacy
+	}
+});
+//#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-client`, used to identify the plugin
+* in driver lookups and warnings.
+*/
 const pluginClientName = "plugin-client";
+/**
+* The `@kubb/plugin-client` plugin factory.
+*
+* Generates type-safe HTTP client functions (or classes) from an OpenAPI/AST `RootNode`.
+* Walks operations, delegates rendering to the active generators,
+* and writes barrel files based on `output.barrelType`.
+*
+* @example
+* ```ts
+* import { pluginClient } from '@kubb/plugin-client'
+*
+* export default defineConfig({
+*   plugins: [pluginClient({ output: { path: 'clients' } })],
+* })
+* ```
+*/
 const pluginClient = createPlugin((options) => {
 	const { output = {
 		path: "clients",
 		barrelType: "named"
-	}, group, urlType = false, exclude = [], include, override = [], transformers = {}, dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, baseURL, paramsCasing, clientType = "function", parser = "client", client = "axios", importPath, contentType, bundle = false, wrapper } = options;
+	}, group, urlType = false, exclude = [], include, override = [], dataReturnType = "data", paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", operations = false, paramsCasing, clientType = "function", parser = "client", client = "axios", importPath, bundle = false, wrapper, baseURL, compatibilityPreset = "default", resolver: userResolver, transformer: userTransformer } = options;
 	const resolvedImportPath = importPath ?? (!bundle ? `@kubb/plugin-client/clients/${client}` : void 0);
-	const defaultGenerators = [
-		clientType === "staticClass" ? staticClassClientGenerator : clientType === "class" ? classClientGenerator : clientGenerator,
-		group && clientType === "function" ? groupedClientGenerator : void 0,
-		operations ? operationsGenerator : void 0
-	].filter((x) => Boolean(x));
-	const generators = options.generators ?? defaultGenerators;
+	const preset = getPreset({
+		preset: compatibilityPreset,
+		presets,
+		resolver: userResolver,
+		transformer: userTransformer,
+		generators: options.generators ?? [
+			clientType === "staticClass" ? staticClassClientGenerator : clientType === "class" ? classClientGenerator : clientGenerator,
+			group && clientType === "function" ? groupedClientGenerator : void 0,
+			operations ? operationsGenerator : void 0
+		].filter((x) => Boolean(x))
+	});
+	let resolveNameWarning = false;
+	let resolvePathWarning = false;
 	return {
 		name: pluginClientName,
-		options: {
-			client,
-			clientType,
-			bundle,
-			output,
-			group,
-			parser,
-			dataReturnType,
-			importPath: resolvedImportPath,
-			paramsType,
-			paramsCasing,
-			pathParamsType,
-			baseURL,
-			urlType,
-			wrapper
+		get resolver() {
+			return preset.resolver;
+		},
+		get transformer() {
+			return preset.transformer;
 		},
-		pre: [pluginOasName, parser === "zod" ? pluginZodName : void 0].filter(Boolean),
+		get options() {
+			return {
+				client,
+				clientType,
+				bundle,
+				output,
+				group: group ? {
+					...group,
+					name: group.name ? group.name : (ctx) => {
+						if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+						return `${camelCase(ctx.group)}Controller`;
+					}
+				} : void 0,
+				parser,
+				dataReturnType,
+				importPath: resolvedImportPath,
+				baseURL,
+				paramsType,
+				paramsCasing,
+				pathParamsType,
+				urlType,
+				wrapper,
+				resolver: preset.resolver
+			};
+		},
+		pre: [pluginTsName, parser === "zod" ? pluginZodName : void 0].filter(Boolean),
 		resolvePath(baseName, pathMode, options) {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
- /**
-			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
-			*/
-			return path.resolve(root, output.path);
-			if (group && (options?.group?.path || options?.group?.tag)) {
-				const groupName = group?.name ? group.name : (ctx) => {
-					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
-					return `${camelCase(ctx.group)}Controller`;
-				};
-				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+			if (!resolvePathWarning) {
+				this.events.emit("warn", "Do not use resolvePath for pluginClient, use resolverClient.resolvePath instead");
+				resolvePathWarning = true;
 			}
-			return path.resolve(root, output.path, baseName);
+			return this.plugin.resolver.resolvePath({
+				baseName,
+				pathMode,
+				tag: options?.group?.tag,
+				path: options?.group?.path
+			}, {
+				root: path.resolve(this.config.root, this.config.output.path),
+				output,
+				group: this.plugin.options.group
+			});
 		},
 		resolveName(name, type) {
-			const resolvedName = camelCase(name, { isFile: type === "file" });
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
+			if (!resolveNameWarning) {
+				this.events.emit("warn", "Do not use resolveName for pluginClient, use resolverClient.default instead");
+				resolveNameWarning = true;
+			}
+			return this.plugin.resolver.default(name, type);
 		},
 		async install() {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			const mode = getMode(path.resolve(root, output.path));
-			const oas = await this.getOas();
-			const baseURL = await this.getBaseURL();
-			if (bundle && !this.plugin.options.importPath) await this.addFile({
+			const { config, fabric, plugin, adapter, rootNode, driver } = this;
+			const root = path.resolve(config.root, config.output.path);
+			const resolver = preset.resolver;
+			if (!adapter) throw new Error("Plugin cannot work without adapter being set");
+			if (bundle && !plugin.options.importPath) await this.addFile({
 				baseName: "fetch.ts",
 				path: path.resolve(root, ".kubb/fetch.ts"),
 				sources: [{
 					name: "fetch",
-					value: this.plugin.options.client === "fetch" ? source$1 : source,
+					value: plugin.options.client === "fetch" ? source$1 : source,
 					isExportable: true,
 					isIndexable: true
 				}],
@@ -92,22 +1920,32 @@ const pluginClient = createPlugin((options) => {
 				imports: [],
 				exports: []
 			});
-			const files = await new OperationGenerator(baseURL ? {
-				...this.plugin.options,
-				baseURL
-			} : this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
+			const collectedOperations = [];
+			const generatorContext = {
+				generators: preset.generators,
+				plugin,
+				resolver,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...files);
+				fabric,
+				adapter,
+				config,
+				driver
+			};
+			await walk(rootNode, {
+				depth: "shallow",
+				async operation(operationNode) {
+					if (resolver.resolveOptions(operationNode, {
+						options: plugin.options,
+						exclude,
+						include,
+						override
+					}) !== null) collectedOperations.push(operationNode);
+					await runGeneratorOperation(operationNode, generatorContext);
+				}
+			});
+			await runGeneratorOperations(collectedOperations, generatorContext);
 			const barrelFiles = await getBarrelFiles(this.fabric.files, {
 				type: output.barrelType ?? "named",
 				root,
@@ -119,6 +1957,6 @@ const pluginClient = createPlugin((options) => {
 	};
 });
 //#endregion
-export { pluginClient, pluginClientName };
+export { Client, ClientLegacy, UrlLegacy, classClientGenerator, clientGenerator, groupedClientGenerator, operationsGenerator, pluginClient, pluginClientName, presets, resolverClient, resolverClientLegacy, staticClassClientGenerator };
 
 //# sourceMappingURL=index.js.map