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

package/dist/StaticClassClient-D6v3vhZL.js

@@ -1,695 +0,0 @@
-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.
-*
-* 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/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 && !urlName ? 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", {}),
-				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
-			]
-		})
-	})] });
-}
-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-D6v3vhZL.js.map