@kubb/agent 5.0.0-alpha.34 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/plugin-client/dist/StaticClassClient-bCe7RG_w.js

@@ -0,0 +1,636 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { getComments, getParamsMapping, getPathParams } from "@kubb/plugin-oas/utils";
+import { Const, File, Function as Function$1, FunctionParams } from "@kubb/react-fabric";
+import { getDefaultValue, isOptional } from "@kubb/oas";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+//#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.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	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.
+*/
+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.
+*/
+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`. */
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+	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. */
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+	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.
+	*/
+	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, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
+//#region src/components/Url.tsx
+function getParams$1({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
+	if (paramsType === "object") {
+		const pathParams = getPathParams(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: getPathParams(typeSchemas.pathParams, {
+			typed: true,
+			casing: paramsCasing
+		}),
+		default: getDefaultValue(typeSchemas.pathParams?.schema)
+	} : void 0 });
+}
+__name(getParams$1, "getParams");
+function Url({ name, isExportable = true, isIndexable = true, typeSchemas, baseURL, paramsType, paramsCasing, pathParamsType, operation }) {
+	const path = new URLPath(operation.path);
+	const params = getParams$1({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas
+	});
+	const pathParamsMapping = paramsCasing ? getParamsMapping(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"
+			]
+		})
+	});
+}
+Url.getParams = getParams$1;
+//#endregion
+//#region src/components/Client.tsx
+function getParams({ paramsType, paramsCasing, pathParamsType, typeSchemas, isConfigurable }) {
+	if (paramsType === "object") {
+		const children = {
+			...getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing
+			}),
+			data: typeSchemas.request?.name ? {
+				type: typeSchemas.request?.name,
+				optional: isOptional(typeSchemas.request?.schema)
+			} : void 0,
+			params: typeSchemas.queryParams?.name ? {
+				type: typeSchemas.queryParams?.name,
+				optional: isOptional(typeSchemas.queryParams?.schema)
+			} : void 0,
+			headers: typeSchemas.headerParams?.name ? {
+				type: typeSchemas.headerParams?.name,
+				optional: isOptional(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: getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing
+			}),
+			default: getDefaultValue(typeSchemas.pathParams?.schema)
+		} : void 0,
+		data: typeSchemas.request?.name ? {
+			type: typeSchemas.request?.name,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: typeSchemas.queryParams?.name,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: typeSchemas.headerParams?.name,
+			optional: isOptional(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 Client({ 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();
+	const isFormData = contentType === "multipart/form-data";
+	const pathParamsMapping = paramsCasing ? getParamsMapping(typeSchemas.pathParams, { casing: paramsCasing }) : void 0;
+	const queryParamsMapping = paramsCasing ? getParamsMapping(typeSchemas.queryParams, { casing: paramsCasing }) : void 0;
+	const headerParamsMapping = paramsCasing ? getParamsMapping(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 = Url.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: getComments(operation) },
+			returnType,
+			children: [
+				isConfigurable ? "const { client: request = fetch, ...requestConfig } = config" : "",
+				/* @__PURE__ */ jsx("br", {}),
+				/* @__PURE__ */ jsx("br", {}),
+				!urlName && pathParamsMapping && Object.entries(pathParamsMapping).filter(([originalName, camelCaseName]) => originalName !== camelCaseName && isValidVarName(originalName)).map(([originalName, camelCaseName]) => `const ${originalName} = ${camelCaseName}`).join("\n"),
+				!urlName && 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
+			]
+		})
+	})] });
+}
+Client.getParams = getParams;
+//#endregion
+//#region src/components/ClassClient.tsx
+function buildHeaders$1(contentType, hasHeaderParams) {
+	return [contentType !== "application/json" && contentType !== "multipart/form-data" ? `'Content-Type': '${contentType}'` : void 0, hasHeaderParams ? "...headers" : void 0].filter(Boolean);
+}
+__name(buildHeaders$1, "buildHeaders");
+function buildGenerics$1(typeSchemas) {
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	return [
+		typeSchemas.response.name,
+		TError,
+		typeSchemas.request?.name || "unknown"
+	].filter(Boolean);
+}
+__name(buildGenerics$1, "buildGenerics");
+function buildClientParams$1({ operation, path, baseURL, typeSchemas, isFormData, headers }) {
+	return FunctionParams.factory({ config: {
+		mode: "object",
+		children: {
+			requestConfig: { mode: "inlineSpread" },
+			method: { value: JSON.stringify(operation.method.toUpperCase()) },
+			url: { value: path.template },
+			baseURL: baseURL ? { value: JSON.stringify(baseURL) } : void 0,
+			params: typeSchemas.queryParams?.name ? {} : void 0,
+			data: typeSchemas.request?.name ? { value: isFormData ? "formData as FormData" : "requestData" } : void 0,
+			headers: headers.length ? { value: `{ ${headers.join(", ")}, ...requestConfig.headers }` } : void 0
+		}
+	} });
+}
+__name(buildClientParams$1, "buildClientParams");
+function buildRequestDataLine$1({ parser, zodSchemas, typeSchemas }) {
+	if (parser === "zod" && zodSchemas?.request?.name) return `const requestData = ${zodSchemas.request.name}.parse(data)`;
+	if (typeSchemas?.request?.name) return "const requestData = data";
+	return "";
+}
+__name(buildRequestDataLine$1, "buildRequestDataLine");
+function buildFormDataLine$1(isFormData, hasRequest) {
+	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
+}
+__name(buildFormDataLine$1, "buildFormDataLine");
+function buildReturnStatement$1({ dataReturnType, parser, zodSchemas }) {
+	if (dataReturnType === "full" && parser === "zod" && zodSchemas) return `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`;
+	if (dataReturnType === "data" && parser === "zod" && zodSchemas) return `return ${zodSchemas.response.name}.parse(res.data)`;
+	if (dataReturnType === "full" && parser === "client") return "return res";
+	return "return res.data";
+}
+__name(buildReturnStatement$1, "buildReturnStatement");
+function generateMethod$1({ operation, name, typeSchemas, zodSchemas, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
+	const path = new URLPath(operation.path, { casing: paramsCasing });
+	const contentType = operation.getContentType();
+	const isFormData = contentType === "multipart/form-data";
+	const headers = buildHeaders$1(contentType, !!typeSchemas.headerParams?.name);
+	const generics = buildGenerics$1(typeSchemas);
+	const params = ClassClient.getParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas,
+		isConfigurable: true
+	});
+	const clientParams = buildClientParams$1({
+		operation,
+		path,
+		baseURL,
+		typeSchemas,
+		isFormData,
+		headers
+	});
+	const jsdoc = buildJSDoc(getComments(operation));
+	const requestDataLine = buildRequestDataLine$1({
+		parser,
+		zodSchemas,
+		typeSchemas
+	});
+	const formDataLine = buildFormDataLine$1(isFormData, !!typeSchemas?.request?.name);
+	const returnStatement = buildReturnStatement$1({
+		dataReturnType,
+		parser,
+		zodSchemas
+	});
+	const methodBody = [
+		"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");
+	return `${jsdoc}async ${name}(${params.toConstructor()}) {\n${methodBody}\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(({ operation, name: methodName, typeSchemas, zodSchemas }) => generateMethod$1({
+		operation,
+		name: methodName,
+		typeSchemas,
+		zodSchemas,
+		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/Operations.tsx
+function Operations({ name, operations }) {
+	const operationsObject = {};
+	operations.forEach((operation) => {
+		operationsObject[operation.getOperationId()] = {
+			path: new URLPath(operation.path).URL,
+			method: operation.method
+		};
+	});
+	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/components/StaticClassClient.tsx
+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(typeSchemas) {
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	return [
+		typeSchemas.response.name,
+		TError,
+		typeSchemas.request?.name || "unknown"
+	].filter(Boolean);
+}
+function buildClientParams({ operation, path, baseURL, typeSchemas, isFormData, headers }) {
+	return FunctionParams.factory({ config: {
+		mode: "object",
+		children: {
+			requestConfig: { mode: "inlineSpread" },
+			method: { value: JSON.stringify(operation.method.toUpperCase()) },
+			url: { value: path.template },
+			baseURL: baseURL ? { value: JSON.stringify(baseURL) } : void 0,
+			params: typeSchemas.queryParams?.name ? {} : void 0,
+			data: typeSchemas.request?.name ? { value: isFormData ? "formData as FormData" : "requestData" } : void 0,
+			headers: headers.length ? { value: `{ ${headers.join(", ")}, ...requestConfig.headers }` } : void 0
+		}
+	} });
+}
+function buildRequestDataLine({ parser, zodSchemas, typeSchemas }) {
+	if (parser === "zod" && zodSchemas?.request?.name) return `const requestData = ${zodSchemas.request.name}.parse(data)`;
+	if (typeSchemas?.request?.name) return "const requestData = data";
+	return "";
+}
+function buildFormDataLine(isFormData, hasRequest) {
+	return isFormData && hasRequest ? "const formData = buildFormData(requestData)" : "";
+}
+function buildReturnStatement({ dataReturnType, parser, zodSchemas }) {
+	if (dataReturnType === "full" && parser === "zod" && zodSchemas) return `return {...res, data: ${zodSchemas.response.name}.parse(res.data)}`;
+	if (dataReturnType === "data" && parser === "zod" && zodSchemas) return `return ${zodSchemas.response.name}.parse(res.data)`;
+	if (dataReturnType === "full" && parser === "client") return "return res";
+	return "return res.data";
+}
+function generateMethod({ operation, name, typeSchemas, zodSchemas, baseURL, dataReturnType, parser, paramsType, paramsCasing, pathParamsType }) {
+	const path = new URLPath(operation.path, { casing: paramsCasing });
+	const contentType = operation.getContentType();
+	const isFormData = contentType === "multipart/form-data";
+	const headers = buildHeaders(contentType, !!typeSchemas.headerParams?.name);
+	const generics = buildGenerics(typeSchemas);
+	const params = Client.getParams({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas,
+		isConfigurable: true
+	});
+	const clientParams = buildClientParams({
+		operation,
+		path,
+		baseURL,
+		typeSchemas,
+		isFormData,
+		headers
+	});
+	const jsdoc = buildJSDoc(getComments(operation));
+	const requestDataLine = buildRequestDataLine({
+		parser,
+		zodSchemas,
+		typeSchemas
+	});
+	const formDataLine = buildFormDataLine(isFormData, !!typeSchemas?.request?.name);
+	const returnStatement = buildReturnStatement({
+		dataReturnType,
+		parser,
+		zodSchemas
+	});
+	const methodBody = [
+		"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");
+	return `${jsdoc}  static async ${name}(${params.toConstructor()}) {\n${methodBody}\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(({ operation, name: methodName, typeSchemas, zodSchemas }) => generateMethod({
+		operation,
+		name: methodName,
+		typeSchemas,
+		zodSchemas,
+		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
+export { Url as a, Client as i, Operations as n, camelCase as o, ClassClient as r, pascalCase as s, StaticClassClient as t };
+
+//# sourceMappingURL=StaticClassClient-bCe7RG_w.js.map

package/.output/server/node_modules/@kubb/plugin-client/dist/chunk--u3MIqq1.js

@@ -0,0 +1,8 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+export { __name as t };

package/.output/server/node_modules/@kubb/plugin-client/dist/components.js

@@ -0,0 +1,2 @@
+import { a as Url, i as Client, n as Operations, r as ClassClient, t as StaticClassClient } from "./StaticClassClient-bCe7RG_w.js";
+export { ClassClient, Client, Operations, StaticClassClient, Url };