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

package/.output/server/node_modules/@kubb/plugin-vue-query/dist/components-_AMBl0g-.js

@@ -0,0 +1,1029 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { getDefaultValue, isOptional } from "@kubb/oas";
+import { getComments, getPathParams } from "@kubb/plugin-oas/utils";
+import { File, Function as Function$1, FunctionParams, Type } from "@kubb/react-fabric";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+import { Client } from "@kubb/plugin-client/components";
+//#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/object.ts
+/**
+* Converts a dot-notation path or string array into an optional-chaining accessor expression.
+*
+* @example
+* getNestedAccessor('pagination.next.id', 'lastPage')
+* // → "lastPage?.['pagination']?.['next']?.['id']"
+*/
+function getNestedAccessor(param, accessor) {
+	const parts = Array.isArray(param) ? param : param.split(".");
+	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return void 0;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+}
+//#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/QueryKey.tsx
+function getParams$6({ pathParamsType, paramsCasing, typeSchemas }) {
+	return FunctionParams.factory({
+		pathParams: {
+			mode: pathParamsType === "object" ? "object" : "inlineSpread",
+			children: getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			})
+		},
+		data: typeSchemas.request?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0
+	});
+}
+__name(getParams$6, "getParams");
+const getTransformer$1 = /* @__PURE__ */ __name(({ operation, schemas, casing }) => {
+	return [
+		new URLPath(operation.path, { casing }).toObject({
+			type: "path",
+			stringify: true
+		}),
+		schemas.queryParams?.name ? "...(params ? [params] : [])" : void 0,
+		schemas.request?.name ? "...(data ? [data] : [])" : void 0
+	].filter(Boolean);
+}, "getTransformer");
+function QueryKey({ name, typeSchemas, paramsCasing, pathParamsType, operation, typeName, transformer = getTransformer$1 }) {
+	const params = getParams$6({
+		pathParamsType,
+		typeSchemas,
+		paramsCasing
+	});
+	const keys = transformer({
+		operation,
+		schemas: typeSchemas,
+		casing: paramsCasing
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1.Arrow, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			export: true,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+QueryKey.getParams = getParams$6;
+QueryKey.getTransformer = getTransformer$1;
+//#endregion
+//#region src/components/QueryOptions.tsx
+function getParams$5({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
+	if (paramsType === "object") {
+		const children = {
+			...getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			data: typeSchemas.request?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+				optional: isOptional(typeSchemas.request?.schema)
+			} : void 0,
+			params: typeSchemas.queryParams?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+				optional: isOptional(typeSchemas.queryParams?.schema)
+			} : void 0,
+			headers: typeSchemas.headerParams?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.queryParams?.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: {
+				type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
+				default: "{}"
+			}
+		});
+	}
+	return FunctionParams.factory({
+		pathParams: {
+			mode: pathParamsType === "object" ? "object" : "inlineSpread",
+			children: getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			default: getDefaultValue(typeSchemas.pathParams?.schema)
+		},
+		data: typeSchemas.request?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0,
+		config: {
+			type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
+			default: "{}"
+		}
+	});
+}
+__name(getParams$5, "getParams");
+function QueryOptions({ name, clientName, dataReturnType, typeSchemas, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const params = getParams$5({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas
+	});
+	const clientParams = Client.getParams({
+		paramsType,
+		paramsCasing,
+		typeSchemas,
+		pathParamsType,
+		isConfigurable: true
+	});
+	const queryKeyParams = QueryKey.getParams({
+		pathParamsType,
+		typeSchemas,
+		paramsCasing
+	});
+	const enabled = Object.entries(queryKeyParams.flatParams).map(([key, item]) => {
+		return item && !item.optional && !item.default ? key : void 0;
+	}).filter(Boolean).join("&& ");
+	const enabledText = enabled ? `enabled: !!(${enabled}),` : "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			children: `
+      const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
+      return queryOptions<${TData}, ${TError}, ${TData}, typeof queryKey>({
+      ${enabledText}
+      queryKey,
+      queryFn: async ({ signal }) => {
+          return ${clientName}(${clientParams.toCall({ transformName(name) {
+				if (name === "config") return "{ ...config, signal: config.signal ?? signal }";
+				return `toValue(${name})`;
+			} })})
+       },
+      })
+`
+		})
+	});
+}
+QueryOptions.getParams = getParams$5;
+//#endregion
+//#region src/components/InfiniteQuery.tsx
+function getParams$4({ paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	if (paramsType === "object") {
+		const children = {
+			...getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			data: typeSchemas.request?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+				optional: isOptional(typeSchemas.request?.schema)
+			} : void 0,
+			params: typeSchemas.queryParams?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+				optional: isOptional(typeSchemas.queryParams?.schema)
+			} : void 0,
+			headers: typeSchemas.headerParams?.name ? {
+				type: `MaybeRefOrGetter<${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
+			},
+			options: {
+				type: `
+{
+  query?: Partial<UseInfiniteQueryOptions<${[
+					TData,
+					TError,
+					"TQueryData",
+					"TQueryKey",
+					"TQueryData"
+				].join(", ")}>> & { client?: QueryClient },
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
+}
+`,
+				default: "{}"
+			}
+		});
+	}
+	return FunctionParams.factory({
+		pathParams: typeSchemas.pathParams?.name ? {
+			mode: pathParamsType === "object" ? "object" : "inlineSpread",
+			children: getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			default: getDefaultValue(typeSchemas.pathParams?.schema)
+		} : void 0,
+		data: typeSchemas.request?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.headerParams?.name}>`,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0,
+		options: {
+			type: `
+{
+  query?: Partial<UseInfiniteQueryOptions<${[
+				TData,
+				TError,
+				"TQueryData",
+				"TQueryKey",
+				"TQueryData"
+			].join(", ")}>> & { client?: QueryClient },
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
+}
+`,
+			default: "{}"
+		}
+	});
+}
+__name(getParams$4, "getParams");
+function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, pathParamsType, paramsCasing, dataReturnType, typeSchemas, operation }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const returnType = `UseInfiniteQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
+	const generics = [
+		`TData = InfiniteData<${TData}>`,
+		`TQueryData = ${TData}`,
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
+	];
+	const queryKeyParams = QueryKey.getParams({
+		pathParamsType,
+		typeSchemas,
+		paramsCasing
+	});
+	const queryOptionsParams = QueryOptions.getParams({
+		paramsType,
+		pathParamsType,
+		typeSchemas,
+		paramsCasing
+	});
+	const params = getParams$4({
+		paramsCasing,
+		paramsType,
+		pathParamsType,
+		dataReturnType,
+		typeSchemas
+	});
+	const queryOptions = `${queryOptionsName}(${queryOptionsParams.toCall()})`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: params.toConstructor(),
+			JSDoc: { comments: getComments(operation) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = (resolvedOptions && 'queryKey' in resolvedOptions ? toValue(resolvedOptions.queryKey) : undefined) ?? ${queryKeyName}(${queryKeyParams.toCall()})
+
+       const query = useInfiniteQuery({
+        ...${queryOptions},
+        ...resolvedOptions,
+        queryKey
+       } as unknown as UseInfiniteQueryOptions<${TData}, ${TError}, ${TData}, TQueryKey, ${TData}>, toValue(queryClient)) as ${returnType}
+
+       query.queryKey = queryKey as TQueryKey
+
+       return query
+       `
+		})
+	});
+}
+InfiniteQuery.getParams = getParams$4;
+//#endregion
+//#region src/components/InfiniteQueryOptions.tsx
+function getParams$3({ paramsType, paramsCasing, pathParamsType, typeSchemas }) {
+	if (paramsType === "object") {
+		const children = {
+			...getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			data: typeSchemas.request?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+				optional: isOptional(typeSchemas.request?.schema)
+			} : void 0,
+			params: typeSchemas.queryParams?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+				optional: isOptional(typeSchemas.queryParams?.schema)
+			} : void 0,
+			headers: typeSchemas.headerParams?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.queryParams?.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: {
+				type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
+				default: "{}"
+			}
+		});
+	}
+	return FunctionParams.factory({
+		pathParams: {
+			mode: pathParamsType === "object" ? "object" : "inlineSpread",
+			children: getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			default: getDefaultValue(typeSchemas.pathParams?.schema)
+		},
+		data: typeSchemas.request?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.headerParams?.name}>`,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0,
+		config: {
+			type: typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
+			default: "{}"
+		}
+	});
+}
+__name(getParams$3, "getParams");
+function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, typeSchemas, paramsType, paramsCasing, dataReturnType, pathParamsType, queryParam, queryKeyName }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const params = getParams$3({
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		typeSchemas
+	});
+	const clientParams = Client.getParams({
+		paramsType,
+		paramsCasing,
+		typeSchemas,
+		pathParamsType,
+		isConfigurable: true
+	});
+	const queryKeyParams = QueryKey.getParams({
+		paramsCasing,
+		pathParamsType,
+		typeSchemas
+	});
+	const hasNewParams = nextParam !== void 0 || previousParam !== void 0;
+	let getNextPageParamExpr;
+	let getPreviousPageParamExpr;
+	if (hasNewParams) {
+		if (nextParam) {
+			const accessor = getNestedAccessor(nextParam, "lastPage");
+			if (accessor) getNextPageParamExpr = `getNextPageParam: (lastPage) => ${accessor}`;
+		}
+		if (previousParam) {
+			const accessor = getNestedAccessor(previousParam, "firstPage");
+			if (accessor) getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => ${accessor}`;
+		}
+	} else if (cursorParam) {
+		getNextPageParamExpr = `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`;
+		getPreviousPageParamExpr = `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`;
+	} else {
+		if (dataReturnType === "full") getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1";
+		else getNextPageParamExpr = "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1";
+		getPreviousPageParamExpr = "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1";
+	}
+	const queryOptions = [
+		`initialPageParam: ${typeof initialPageParam === "string" ? JSON.stringify(initialPageParam) : initialPageParam}`,
+		getNextPageParamExpr,
+		getPreviousPageParamExpr
+	].filter(Boolean);
+	const infiniteOverrideParams = queryParam && typeSchemas.queryParams?.name ? `
+          if (!params) {
+           params = { }
+          }
+          params['${queryParam}'] = pageParam as unknown as ${typeSchemas.queryParams?.name}['${queryParam}']` : "";
+	const enabled = Object.entries(queryKeyParams.flatParams).map(([key, item]) => {
+		return item && !item.optional && !item.default ? key : void 0;
+	}).filter(Boolean).join("&& ");
+	const enabledText = enabled ? `enabled: !!(${enabled}),` : "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			children: `
+      const queryKey = ${queryKeyName}(${queryKeyParams.toCall()})
+      return infiniteQueryOptions<${TData}, ${TError}, ${TData}, typeof queryKey, number>({
+       ${enabledText}
+       queryKey,
+       queryFn: async ({ signal, pageParam }) => {
+          ${infiniteOverrideParams}
+          return ${clientName}(${clientParams.toCall({ transformName(name) {
+				if (name === "config") return "{ ...config, signal: config.signal ?? signal }";
+				return `toValue(${name})`;
+			} })})
+       },
+       ${queryOptions.join(",\n")}
+      })
+`
+		})
+	});
+}
+InfiniteQueryOptions.getParams = getParams$3;
+//#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+function getParams$2({}) {
+	return FunctionParams.factory({});
+}
+__name(getParams$2, "getParams");
+const getTransformer = ({ operation, casing }) => {
+	return [`{ url: '${new URLPath(operation.path, { casing }).toURLPath()}' }`];
+};
+function MutationKey({ name, typeSchemas, pathParamsType, paramsCasing, operation, typeName, transformer = getTransformer }) {
+	const params = getParams$2({
+		pathParamsType,
+		typeSchemas
+	});
+	const keys = transformer({
+		operation,
+		schemas: typeSchemas,
+		casing: paramsCasing
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1.Arrow, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			export: true,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+MutationKey.getParams = getParams$2;
+MutationKey.getTransformer = getTransformer;
+//#endregion
+//#region src/components/Mutation.tsx
+function getParams$1({ paramsCasing, dataReturnType, typeSchemas }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const TRequest = FunctionParams.factory({
+		...getPathParams(typeSchemas.pathParams, {
+			typed: true,
+			casing: paramsCasing,
+			override(item) {
+				return {
+					...item,
+					type: `MaybeRefOrGetter<${item.type}>`
+				};
+			}
+		}),
+		data: typeSchemas.request?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.headerParams?.name}>`,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0
+	}).toConstructor();
+	return FunctionParams.factory({ options: {
+		type: `
+{
+  mutation?: MutationObserverOptions<${[
+			TData,
+			TError,
+			TRequest ? `{${TRequest}}` : "void",
+			"TContext"
+		].join(", ")}> & { client?: QueryClient },
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"},
+}
+`,
+		default: "{}"
+	} });
+}
+__name(getParams$1, "getParams");
+function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType, dataReturnType, typeSchemas, operation, mutationKeyName }) {
+	const mutationKeyParams = MutationKey.getParams({
+		pathParamsType,
+		typeSchemas
+	});
+	const params = getParams$1({
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		typeSchemas
+	});
+	const clientParams = Client.getParams({
+		paramsCasing,
+		paramsType,
+		typeSchemas,
+		pathParamsType,
+		isConfigurable: true
+	});
+	const mutationParams = FunctionParams.factory({
+		...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 dataParams = FunctionParams.factory({ data: {
+		mode: "object",
+		children: Object.entries(mutationParams.params).reduce((acc, [key, value]) => {
+			if (value) acc[key] = {
+				...value,
+				type: void 0
+			};
+			return acc;
+		}, {})
+	} });
+	const TRequest = mutationParams.toConstructor();
+	const generics = [
+		dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`,
+		`ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`,
+		TRequest ? `{${TRequest}}` : "void",
+		"TContext"
+	].join(", ");
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			params: params.toConstructor(),
+			JSDoc: { comments: getComments(operation) },
+			generics: ["TContext"],
+			children: `
+        const { mutation = {}, client: config = {} } = options ?? {}
+        const { client: queryClient, ...mutationOptions } = mutation;
+        const mutationKey = mutationOptions?.mutationKey ?? ${mutationKeyName}(${mutationKeyParams.toCall()})
+
+        return useMutation<${generics}>({
+          mutationFn: async(${dataParams.toConstructor()}) => {
+            return ${clientName}(${clientParams.toCall()})
+          },
+          mutationKey,
+          ...mutationOptions
+        }, queryClient)
+    `
+		})
+	});
+}
+//#endregion
+//#region src/components/Query.tsx
+function getParams({ paramsCasing, paramsType, pathParamsType, dataReturnType, typeSchemas }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	if (paramsType === "object") {
+		const children = {
+			...getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			data: typeSchemas.request?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+				optional: isOptional(typeSchemas.request?.schema)
+			} : void 0,
+			params: typeSchemas.queryParams?.name ? {
+				type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+				optional: isOptional(typeSchemas.queryParams?.schema)
+			} : void 0,
+			headers: typeSchemas.headerParams?.name ? {
+				type: `MaybeRefOrGetter<${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
+			},
+			options: {
+				type: `
+{
+  query?: Partial<UseQueryOptions<${[
+					TData,
+					TError,
+					"TData",
+					"TQueryData",
+					"TQueryKey"
+				].join(", ")}>> & { client?: QueryClient },
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
+}
+`,
+				default: "{}"
+			}
+		});
+	}
+	return FunctionParams.factory({
+		pathParams: typeSchemas.pathParams?.name ? {
+			mode: pathParamsType === "object" ? "object" : "inlineSpread",
+			children: getPathParams(typeSchemas.pathParams, {
+				typed: true,
+				casing: paramsCasing,
+				override(item) {
+					return {
+						...item,
+						type: `MaybeRefOrGetter<${item.type}>`
+					};
+				}
+			}),
+			default: getDefaultValue(typeSchemas.pathParams?.schema)
+		} : void 0,
+		data: typeSchemas.request?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.request?.name}>`,
+			optional: isOptional(typeSchemas.request?.schema)
+		} : void 0,
+		params: typeSchemas.queryParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.queryParams?.name}>`,
+			optional: isOptional(typeSchemas.queryParams?.schema)
+		} : void 0,
+		headers: typeSchemas.headerParams?.name ? {
+			type: `MaybeRefOrGetter<${typeSchemas.headerParams?.name}>`,
+			optional: isOptional(typeSchemas.headerParams?.schema)
+		} : void 0,
+		options: {
+			type: `
+{
+  query?: Partial<UseQueryOptions<${[
+				TData,
+				TError,
+				"TData",
+				"TQueryData",
+				"TQueryKey"
+			].join(", ")}>> & { client?: QueryClient },
+  client?: ${typeSchemas.request?.name ? `Partial<RequestConfig<${typeSchemas.request?.name}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
+}
+`,
+			default: "{}"
+		}
+	});
+}
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, typeSchemas, operation }) {
+	const TData = dataReturnType === "data" ? typeSchemas.response.name : `ResponseConfig<${typeSchemas.response.name}>`;
+	const TError = `ResponseErrorConfig<${typeSchemas.errors?.map((item) => item.name).join(" | ") || "Error"}>`;
+	const returnType = `UseQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
+	const generics = [
+		`TData = ${TData}`,
+		`TQueryData = ${TData}`,
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
+	];
+	const queryKeyParams = QueryKey.getParams({
+		pathParamsType,
+		typeSchemas,
+		paramsCasing
+	});
+	const queryOptionsParams = QueryOptions.getParams({
+		paramsType,
+		pathParamsType,
+		typeSchemas,
+		paramsCasing
+	});
+	const params = getParams({
+		paramsCasing,
+		paramsType,
+		pathParamsType,
+		dataReturnType,
+		typeSchemas
+	});
+	const queryOptions = `${queryOptionsName}(${queryOptionsParams.toCall()})`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function$1, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: params.toConstructor(),
+			JSDoc: { comments: getComments(operation) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = (resolvedOptions && 'queryKey' in resolvedOptions ? toValue(resolvedOptions.queryKey) : undefined) ?? ${queryKeyName}(${queryKeyParams.toCall()})
+
+       const query = useQuery({
+        ...${queryOptions},
+        ...resolvedOptions,
+        queryKey
+       } as unknown as UseQueryOptions<${TData}, ${TError}, TData, ${TData}, TQueryKey>, toValue(queryClient)) as ${returnType}
+
+       query.queryKey = queryKey as TQueryKey
+
+       return query
+       `
+		})
+	});
+}
+Query.getParams = getParams;
+//#endregion
+export { InfiniteQuery as a, camelCase as c, InfiniteQueryOptions as i, pascalCase as l, Mutation as n, QueryOptions as o, MutationKey as r, QueryKey as s, Query as t };
+
+//# sourceMappingURL=components-_AMBl0g-.js.map