@kubb/plugin-vue-query 5.0.0-beta.56 → 5.0.0-beta.73

package/dist/components-D3xIZ9FA.cjs

@@ -1,1315 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", {
-	value,
-	configurable: true
-});
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let _kubb_core = require("@kubb/core");
-let _kubb_plugin_ts = require("@kubb/plugin-ts");
-let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
-let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
-let _kubb_ast_utils = require("@kubb/ast/utils");
-//#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;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
-*/
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* 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) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-//#endregion
-//#region ../../internals/utils/src/url.ts
-function transformParam(raw, casing) {
-	const param = isValidVarName(raw) ? raw : camelCase(raw);
-	return casing === "camelcase" ? camelCase(param) : param;
-}
-function toParamsObject(path, { replacer, casing } = {}) {
-	const params = {};
-	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
-		const param = transformParam(match[1], casing);
-		const key = replacer ? replacer(param) : param;
-		params[key] = key;
-	}
-	return Object.keys(params).length > 0 ? params : null;
-}
-/**
-* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
-*/
-var Url = class Url {
-	/**
-	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
-	*
-	* @example
-	* Url.canParse('https://petstore.swagger.io/v2') // true
-	* Url.canParse('/pet/{petId}')                   // false
-	*/
-	static canParse(url, base) {
-		return URL.canParse(url, base);
-	}
-	/**
-	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
-	*
-	* @example
-	* Url.toPath('/pet/{petId}') // '/pet/:petId'
-	*/
-	static toPath(path) {
-		return path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-	/**
-	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
-	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
-	* and `casing` controls parameter identifier casing.
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
-	*/
-	static toTemplateString(path, { prefix, replacer, casing } = {}) {
-		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = transformParam(part, casing);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
-	/**
-	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
-	* expression when `stringify` is set.
-	*
-	* @example
-	* Url.toObject('/pet/{petId}')
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	*/
-	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
-		const object = {
-			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
-				replacer,
-				casing
-			}),
-			params: toParamsObject(path, {
-				replacer,
-				casing
-			})
-		};
-		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;
-	}
-};
-//#endregion
-//#region ../../internals/shared/src/operation.ts
-/**
-* Builds the `ResolverFileParams` every operation generator passes to
-* `resolver.resolveFile`: a file named `name`, tagged by the operation's first
-* tag (or `'default'`), at the operation's path. Centralizes the entry object
-* that was repeated at dozens of call sites across the client and query plugins.
-*
-* @example
-* ```ts
-* resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
-* ```
-*/
-function operationFileEntry(node, name, extname = ".ts") {
-	return {
-		name,
-		extname,
-		tag: node.tags[0] ?? "default",
-		path: node.path
-	};
-}
-function getOperationLink(node, link) {
-	if (!link) return null;
-	if (typeof link === "function") return link(node) ?? null;
-	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
-	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
-}
-function getContentTypeInfo(node) {
-	const contentTypes = node.requestBody?.content?.map((e) => e.contentType) ?? [];
-	const isMultipleContentTypes = contentTypes.length > 1;
-	return {
-		contentTypes,
-		isMultipleContentTypes,
-		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
-		defaultContentType: contentTypes[0] ?? "application/json",
-		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
-	};
-}
-function buildRequestConfigType(node, resolver) {
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
-	return `${requestName ? `Partial<RequestConfig<${requestName}>>` : "Partial<RequestConfig>"} & { ${["client?: Client", isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null].filter(Boolean).join("; ")} }`;
-}
-function buildOperationComments(node, options = {}) {
-	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
-	const linkComment = getOperationLink(node, link);
-	const filteredComments = (linkPosition === "beforeDeprecated" ? [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		linkComment,
-		node.deprecated && "@deprecated"
-	] : [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		node.deprecated && "@deprecated",
-		linkComment
-	]).filter((comment) => Boolean(comment));
-	if (!splitLines) return filteredComments;
-	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
-}
-function getOperationParameters(node, options = {}) {
-	const params = _kubb_core.ast.caseParams(node.parameters, options.paramsCasing);
-	return {
-		path: params.filter((param) => param.in === "path"),
-		query: params.filter((param) => param.in === "query"),
-		header: params.filter((param) => param.in === "header"),
-		cookie: params.filter((param) => param.in === "cookie")
-	};
-}
-function getStatusCodeNumber(statusCode) {
-	const code = Number(statusCode);
-	return Number.isNaN(code) ? null : code;
-}
-function isSuccessStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 200 && code < 300;
-}
-function isErrorStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 400;
-}
-function resolveErrorNames(node, resolver) {
-	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-function resolveSuccessNames(node, resolver) {
-	return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-function resolveStatusCodeNames(node, resolver) {
-	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
-}
-/**
-* Builds the discriminated union type string for `dataReturnType: 'full'` return shapes.
-* Each member is `{ status: N; data: StatusNType; statusText: string }`.
-*/
-function buildStatusUnionType(node, resolver) {
-	const members = node.responses.map((r) => {
-		const typeName = resolver.resolveResponseStatusName(node, r.statusCode);
-		const statusCode = Number.parseInt(r.statusCode, 10);
-		return `{ status: ${Number.isNaN(statusCode) ? "number" : String(statusCode)}; data: ${typeName}; statusText: string }`;
-	});
-	if (members.length === 1) return members[0];
-	return `(${members.join(" | ")})`;
-}
-const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
-function resolveOperationTypeNames(node, resolver, options = {}) {
-	const cacheKey = `${node.operationId}\0${options.paramsCasing ?? ""}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${(options.exclude ?? []).join(",")}`;
-	let byResolver = typeNamesByResolver.get(resolver);
-	if (byResolver) {
-		const cached = byResolver.get(cacheKey);
-		if (cached) return cached;
-	} else {
-		byResolver = /* @__PURE__ */ new Map();
-		typeNamesByResolver.set(resolver, byResolver);
-	}
-	const { path, query, header } = getOperationParameters(node, { paramsCasing: options.paramsCasing });
-	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
-	const exclude = new Set(options.exclude ?? []);
-	const paramNames = [
-		...path.map((param) => resolver.resolvePathParamsName(node, param)),
-		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
-		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
-	];
-	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
-	const result = (options.order === "body-response-first" ? [
-		...bodyAndResponseNames,
-		...paramNames,
-		...responseStatusNames
-	] : [
-		...paramNames,
-		...bodyAndResponseNames,
-		...responseStatusNames
-	]).filter((name) => Boolean(name) && !exclude.has(name));
-	byResolver.set(cacheKey, result);
-	return result;
-}
-//#endregion
-//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$7 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const mutationKeyTransformer = ({ node }) => {
-	if (!node.path) return [];
-	return [`{ url: '${Url.toPath(node.path)}' }`];
-};
-function MutationKey({ name, paramsCasing, node, transformer }) {
-	const paramsNode = _kubb_core.ast.createFunctionParameters({ params: [] });
-	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
-	const keys = (transformer ?? mutationKeyTransformer)({
-		node,
-		casing: paramsCasing
-	});
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function.Arrow, {
-			name,
-			export: true,
-			params: paramsSignature,
-			singleLine: true,
-			children: `[${keys.join(", ")}] as const`
-		})
-	});
-}
-//#endregion
-//#region ../../internals/tanstack-query/src/utils.ts
-/**
-* Builds the shared `(…params, config = {})` parameter list for a TanStack
-* query-options function. The trailing `config` parameter is typed as a partial
-* `RequestConfig` with an optional `client`. Framework plugins wrap the result
-* when needed, for example vue-query applies `MaybeRefOrGetter`.
-*/
-function buildQueryOptionsParams(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
-	return _kubb_core.ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [_kubb_core.ast.createFunctionParameter({
-			name: "config",
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
-			}),
-			default: "{}"
-		})]
-	});
-}
-/**
-* Returns `'zod'` when response-direction parsing is enabled.
-* The string shorthand `'zod'` also enables response parsing.
-*/
-function resolveResponseParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.response ?? null;
-}
-/**
-* Returns `'zod'` when request body parsing is enabled.
-* The string shorthand `'zod'` also enables request body parsing (existing behavior).
-*/
-function resolveRequestParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.request ?? null;
-}
-/**
-* Returns `'zod'` when query-params parsing is enabled.
-* Only the object form `{ request: 'zod' }` enables this. `parser: 'zod'` does not.
-*/
-function resolveQueryParamsParser(parser) {
-	if (!parser || parser === "zod") return null;
-	return parser.request ?? null;
-}
-/**
-* Collects the Zod schema import names for an operation based on the active parser directions.
-*
-* - `parser: 'zod'`: response and request body names (backward-compatible behavior).
-* - `parser: { request: 'zod' }`: request body and query params names.
-* - `parser: { response: 'zod' }`: response name only.
-* - `parser: { request: 'zod', response: 'zod' }`: all three.
-*
-* Returns an empty array when no resolver is provided or `parser` is falsy.
-*/
-function resolveZodSchemaNames(node, zodResolver, parser) {
-	if (!zodResolver || !parser) return [];
-	const { query: queryParams } = getOperationParameters(node);
-	return [
-		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
-		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
-	].filter((n) => Boolean(n));
-}
-/**
-* Resolve the type for a single path parameter.
-*
-* - When the resolver's group name differs from the individual param name
-*   (e.g. kubbV4) → `GroupName['paramName']` (member access).
-* - When they match (v5 default) → `TypeName` (direct reference).
-*/
-function resolvePathParamType(node, param, resolver) {
-	const individualName = resolver.resolveParamName(node, param);
-	const groupName = resolver.resolvePathParamsName(node, param);
-	if (groupName !== individualName) return _kubb_core.ast.createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return _kubb_core.ast.createParamsType({
-		variant: "reference",
-		name: individualName
-	});
-}
-/**
-* Derive a query-params group type from the resolver.
-* Returns `null` when no query params exist or when the group name
-* equals the individual param name (no real group).
-*/
-function resolveQueryGroupType(node, params, resolver) {
-	if (!params.length) return null;
-	const firstParam = params[0];
-	const groupName = resolver.resolveQueryParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Build a single `FunctionParameterNode` for a query or header group.
-*/
-function buildGroupParam(name, node, params, groupType, resolver) {
-	if (groupType) return [_kubb_core.ast.createFunctionParameter({
-		name,
-		type: groupType.type,
-		optional: groupType.optional
-	})];
-	if (params.length) {
-		const structProps = params.map((p) => ({
-			name: p.name,
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: resolver.resolveParamName(node, p)
-			}),
-			optional: !p.required
-		}));
-		return [_kubb_core.ast.createFunctionParameter({
-			name,
-			type: _kubb_core.ast.createParamsType({
-				variant: "struct",
-				properties: structProps
-			}),
-			optional: params.every((p) => !p.required)
-		})];
-	}
-	return [];
-}
-/**
-* Build QueryKey params: pathParams + data + queryParams (NO headers, NO config).
-*/
-function buildQueryKeyParams(node, options) {
-	const { pathParamsType, paramsCasing, resolver } = options;
-	const casedParams = _kubb_core.ast.caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const queryGroupType = resolveQueryGroupType(node, queryParams, resolver);
-	const bodyType = node.requestBody?.content?.[0]?.schema ? _kubb_core.ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : null;
-	const bodyRequired = node.requestBody?.required ?? false;
-	const params = [];
-	if (pathParams.length) {
-		const pathChildren = pathParams.map((p) => _kubb_core.ast.createFunctionParameter({
-			name: p.name,
-			type: resolvePathParamType(node, p, resolver),
-			optional: !p.required
-		}));
-		params.push({
-			kind: "ParameterGroup",
-			properties: pathChildren,
-			inline: pathParamsType === "inline",
-			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
-		});
-	}
-	if (bodyType) params.push(_kubb_core.ast.createFunctionParameter({
-		name: "data",
-		type: bodyType,
-		optional: !bodyRequired
-	}));
-	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
-	return _kubb_core.ast.createFunctionParameters({ params });
-}
-/**
-* Collect the names of the required params (no default) that drive the `enabled`
-* guard. These are exactly the params that should be made optional in the
-* generated signatures so callers can pass `undefined` to reach the disabled state.
-*/
-function getEnabledParamNames(paramsNode) {
-	const required = [];
-	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
-		const group = param;
-		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
-	} else {
-		const fp = param;
-		if (!fp.optional && fp.default === void 0) required.push(fp.name);
-	}
-	return required;
-}
-/**
-* Return a copy of `paramsNode` with the named params marked optional.
-*
-* Used to align signatures with the `enabled` guard: the guard already disables
-* the query while a param is falsy, so the param should accept `undefined`. The
-* change is type-only — the `queryFn` keeps calling the client with a non-null
-* assertion (see `injectNonNullAssertions`), so the emitted runtime is unchanged.
-*/
-function markParamsOptional(paramsNode, names) {
-	if (names.length === 0) return paramsNode;
-	const nameSet = new Set(names);
-	const params = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((child) => nameSet.has(child.name) ? _kubb_core.ast.createFunctionParameter({
-					name: child.name,
-					type: child.type,
-					rest: child.rest,
-					optional: true
-				}) : child)
-			};
-		}
-		const fp = param;
-		return nameSet.has(fp.name) ? _kubb_core.ast.createFunctionParameter({
-			name: fp.name,
-			type: fp.type,
-			rest: fp.rest,
-			optional: true
-		}) : fp;
-	});
-	return _kubb_core.ast.createFunctionParameters({ params });
-}
-(0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const queryKeyTransformer = ({ node, casing }) => {
-	if (!node.path) return [];
-	const hasQueryParams = getOperationParameters(node).query.length > 0;
-	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
-	return [
-		Url.toObject(node.path, {
-			type: "path",
-			stringify: true,
-			casing
-		}),
-		hasQueryParams ? "...(params ? [params] : [])" : null,
-		hasRequestBody ? "...(data ? [data] : [])" : null
-	].filter(Boolean);
-};
-//#endregion
-//#region src/utils.ts
-function printType(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
-function wrapWithMaybeRefOrGetter(paramsNode, skip) {
-	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? _kubb_core.ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType(p.type)}>`
-					}) : p.type
-				}))
-			};
-		}
-		const fp = param;
-		if (skip?.(fp.name)) return fp;
-		return {
-			...fp,
-			type: fp.type ? _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType(fp.type)}>`
-			}) : fp.type
-		};
-	});
-	return _kubb_core.ast.createFunctionParameters({ params: wrappedParams });
-}
-//#endregion
-//#region src/components/QueryKey.tsx
-const declarationPrinter$5 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-function buildQueryKeyParamsNode(node, options) {
-	return wrapWithMaybeRefOrGetter(buildQueryKeyParams(node, options));
-}
-function QueryKey({ name, node, tsResolver, paramsCasing, pathParamsType, typeName, transformer }) {
-	const baseParamsNode = buildQueryKeyParamsNode(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const paramsNode = markParamsOptional(baseParamsNode, getEnabledParamNames(baseParamsNode));
-	const paramsSignature = declarationPrinter$5.print(paramsNode) ?? "";
-	const keys = (transformer ?? queryKeyTransformer)({
-		node,
-		casing: paramsCasing
-	});
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function.Arrow, {
-			name,
-			export: true,
-			params: paramsSignature,
-			singleLine: true,
-			children: `[${keys.join(", ")}] as const`
-		})
-	}), /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name: typeName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Type, {
-			name: typeName,
-			export: true,
-			children: `ReturnType<typeof ${name}>`
-		})
-	})] });
-}
-//#endregion
-//#region src/components/QueryOptions.tsx
-const declarationPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const callPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-function getQueryOptionsParams(node, options) {
-	return wrapWithMaybeRefOrGetter(buildQueryOptionsParams(node, options), (name) => name === "config");
-}
-function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$4.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const enabledText = enabledNames.length ? `enabled: () => ${enabledNames.map((n) => `!!toValue(${n})`).join(" && ")},` : "";
-	const paramsNode = markParamsOptional(getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
-	const clientCallStr = (callPrinter$4.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return queryOptions<${TData}, ${TError}, ${TData}>({${enabledText ? `\n       ${enabledText}` : ""}
-       queryKey,
-       queryFn: async ({ signal }) => {
-          return ${clientName}(${addToValueCalls$1(clientCallStr, enabledNames)})
-       },
-      })
-`
-		})
-	});
-}
-/**
-* Wraps parameter names with `toValue()` in the client call string,
-* except for 'config'-related params (which are already plain objects).
-*
-* Handles both inline params (`petId, config`) and object shorthand
-* params (`{ petId }, config`) by expanding to `{ petId: toValue(petId) }`.
-*/
-function addToValueCalls$1(callStr, enabledNames = []) {
-	const optional = new Set(enabledNames);
-	let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner) => {
-		if (inner.includes(":") || inner.includes("...")) return match;
-		return `{ ${inner.split(",").map((k) => k.trim()).filter(Boolean).map((k) => `${k}: toValue(${optional.has(k) ? `${k}!` : k})`).join(", ")} }`;
-	});
-	result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name) => {
-		if (name === "config" || name === "signal" || name === "undefined") return match;
-		if (match.includes("toValue(")) return match;
-		return `toValue(${optional.has(name) ? `${name}!` : name})`;
-	});
-	return result;
-}
-__name(addToValueCalls$1, "addToValueCalls");
-//#endregion
-//#region src/components/InfiniteQuery.tsx
-const declarationPrinter$3 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const callPrinter$3 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-function buildInfiniteQueryParamsNode(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	const successNames = resolveSuccessNames(node, resolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const errorNames = resolveErrorNames(node, resolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = _kubb_core.ast.createFunctionParameter({
-		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
-  query?: Partial<UseInfiniteQueryOptions<${[
-				TData,
-				TError,
-				"TQueryData",
-				"TQueryKey",
-				"TQueryData"
-			].join(", ")}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
-		default: "{}"
-	});
-	return wrapWithMaybeRefOrGetter(_kubb_core.ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [optionsParam]
-	}), (name) => name === "options");
-}
-function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const returnType = `UseInfiniteQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
-	const generics = [
-		`TData = InfiniteData<${TData}>`,
-		`TQueryData = ${TData}`,
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
-	];
-	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const queryOptionsParamsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const queryOptionsParamsCall = callPrinter$3.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = markParamsOptional(buildInfiniteQueryParamsNode(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = (resolvedOptions && 'queryKey' in resolvedOptions ? toValue(resolvedOptions.queryKey) : undefined) ?? ${queryKeyName}(${queryKeyParamsCall})
-
-       const query = useInfiniteQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),
-        ...resolvedOptions,
-        queryKey
-       } as unknown as UseInfiniteQueryOptions<${TData}, ${TError}, ${TData}, TQueryKey, ${TData}>, toValue(queryClient)) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `
-		})
-	});
-}
-//#endregion
-//#region src/components/InfiniteQueryOptions.tsx
-const declarationPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const callPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, paramsCasing, paramsType, dataReturnType, pathParamsType, queryParam, queryKeyName }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const queryFnDataType = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const errorType = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const isInitialPageParamDefined = initialPageParam !== void 0 && initialPageParam !== null;
-	const fallbackPageParamType = typeof initialPageParam === "number" ? "number" : typeof initialPageParam === "string" ? initialPageParam.includes(" as ") ? (() => {
-		const parts = initialPageParam.split(" as ");
-		return parts[parts.length - 1] ?? "unknown";
-	})() : "string" : typeof initialPageParam === "boolean" ? "boolean" : "unknown";
-	const rawQueryParams = getOperationParameters(node).query;
-	const queryParamsTypeName = rawQueryParams.length > 0 ? (() => {
-		const groupName = tsResolver.resolveQueryParamsName(node, rawQueryParams[0]);
-		return groupName !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? groupName : null;
-	})() : null;
-	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
-	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
-	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const enabledText = enabledNames.length ? `enabled: () => ${enabledNames.map((n) => `!!toValue(${n})`).join(" && ")},` : "";
-	const paramsNode = markParamsOptional(getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
-	const clientCallStr = (callPrinter$2.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
-	const hasNewParams = nextParam != null || previousParam != null;
-	const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
-		if (hasNewParams) {
-			const nextAccessor = nextParam ? (0, _kubb_ast_utils.getNestedAccessor)(nextParam, "lastPage") : null;
-			const prevAccessor = previousParam ? (0, _kubb_ast_utils.getNestedAccessor)(previousParam, "firstPage") : null;
-			return [nextAccessor ? `getNextPageParam: (lastPage) => ${nextAccessor}` : null, prevAccessor ? `getPreviousPageParam: (firstPage) => ${prevAccessor}` : null];
-		}
-		if (cursorParam) return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`];
-		return [dataReturnType === "full" ? "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage.data) && lastPage.data.length === 0 ? undefined : lastPageParam + 1" : "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1", "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1"];
-	})();
-	const queryOptionsArr = [
-		`initialPageParam: ${typeof initialPageParam === "string" ? JSON.stringify(initialPageParam) : initialPageParam}`,
-		getNextPageParamExpr,
-		getPreviousPageParamExpr
-	].filter(Boolean);
-	const infiniteOverrideParams = queryParam && queryParamsTypeName ? `params = {
-      ...(params ?? {}),
-      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
-    } as ${queryParamsTypeName}` : "";
-	if (infiniteOverrideParams) return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
-  queryKey,
-  queryFn: async ({ signal, pageParam }) => {
-    ${infiniteOverrideParams}
-    return ${clientName}(${addToValueCalls(clientCallStr, enabledNames)})
-  },
-  ${queryOptionsArr.join(",\n  ")}
-})
-`
-		})
-	});
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, QueryKey, ${pageParamType}>({${enabledText ? `\n  ${enabledText}` : ""}
-  queryKey,
-  queryFn: async ({ signal }) => {
-    return ${clientName}(${addToValueCalls(clientCallStr, enabledNames)})
-  },
-  ${queryOptionsArr.join(",\n  ")}
-})
-`
-		})
-	});
-}
-function addToValueCalls(callStr, enabledNames = []) {
-	const optional = new Set(enabledNames);
-	let result = callStr.replace(/\{\s*([\w,\s]+)\s*\}(?=\s*,)/g, (match, inner) => {
-		if (inner.includes(":") || inner.includes("...")) return match;
-		return `{ ${inner.split(",").map((k) => k.trim()).filter(Boolean).map((k) => `${k}: toValue(${optional.has(k) ? `${k}!` : k})`).join(", ")} }`;
-	});
-	result = result.replace(/(?<![{.:?])\b(\w+)\b(?=\s*,)/g, (match, name) => {
-		if (name === "config" || name === "signal" || name === "undefined") return match;
-		if (match.includes("toValue(")) return match;
-		return `toValue(${optional.has(name) ? `${name}!` : name})`;
-	});
-	return result;
-}
-//#endregion
-//#region src/components/Mutation.tsx
-const declarationPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const callPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-const keysPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "keys" });
-function createMutationArgParams(node, options) {
-	return _kubb_core.ast.createOperationParams(node, {
-		paramsType: "inline",
-		pathParamsType: "inline",
-		paramsCasing: options.paramsCasing,
-		resolver: options.resolver
-	});
-}
-function buildMutationParamsNode(node, options) {
-	const { paramsCasing, dataReturnType, resolver } = options;
-	const successNames = resolveSuccessNames(node, resolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, resolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const wrappedParamsNode = wrapWithMaybeRefOrGetter(createMutationArgParams(node, {
-		paramsCasing,
-		resolver
-	}));
-	const TRequestWrapped = wrappedParamsNode.params.length > 0 ? declarationPrinter$1.print(wrappedParamsNode) ?? "" : "";
-	return _kubb_core.ast.createFunctionParameters({ params: [_kubb_core.ast.createFunctionParameter({
-		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
-  mutation?: MutationObserverOptions<${[
-				TData,
-				TError,
-				TRequestWrapped ? `{${TRequestWrapped}}` : "undefined",
-				"TContext"
-			].join(", ")}> & { client?: QueryClient },
-  client?: ${buildRequestConfigType(node, resolver)},
-}`
-		}),
-		default: "{}"
-	})] });
-}
-function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType, dataReturnType, node, tsResolver, mutationKeyName }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const mutationArgParamsNode = createMutationArgParams(node, {
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const hasMutationParams = mutationArgParamsNode.params.length > 0;
-	const TRequest = hasMutationParams ? declarationPrinter$1.print(mutationArgParamsNode) ?? "" : "";
-	const argKeysStr = hasMutationParams ? keysPrinter.print(mutationArgParamsNode) ?? "" : "";
-	const generics = [
-		TData,
-		TError,
-		TRequest ? `{${TRequest}}` : "undefined",
-		"TContext"
-	].join(", ");
-	const mutationKeyParamsNode = _kubb_core.ast.createFunctionParameters({ params: [] });
-	const mutationKeyParamsCall = callPrinter$1.print(mutationKeyParamsNode) ?? "";
-	const clientCallParamsNode = _kubb_core.ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver: tsResolver,
-		extraParams: [_kubb_core.ast.createFunctionParameter({
-			name: "config",
-			type: _kubb_core.ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
-			default: "{}"
-		})]
-	});
-	const clientCallStr = callPrinter$1.print(clientCallParamsNode) ?? "";
-	const paramsNode = buildMutationParamsNode(node, {
-		paramsCasing,
-		dataReturnType,
-		resolver: tsResolver
-	});
-	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			generics: ["TContext"],
-			children: `
-        const { mutation = {}, client: config = {} } = options ?? {}
-        const { client: queryClient, ...mutationOptions } = mutation;
-        const mutationKey = mutationOptions?.mutationKey ?? ${mutationKeyName}(${mutationKeyParamsCall})
-
-        return useMutation<${generics}>({
-          mutationFn: async(${hasMutationParams ? `{ ${argKeysStr} }` : ""}) => {
-            return ${clientName}(${clientCallStr})
-          },
-          mutationKey,
-          ...mutationOptions
-        }, queryClient)
-    `
-		})
-	});
-}
-//#endregion
-//#region src/components/Query.tsx
-const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
-const callPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-function buildQueryParamsNode(node, options) {
-	const { paramsType, paramsCasing, pathParamsType, dataReturnType, resolver } = options;
-	const successNames = resolveSuccessNames(node, resolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
-	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const errorNames = resolveErrorNames(node, resolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = _kubb_core.ast.createFunctionParameter({
-		name: "options",
-		type: _kubb_core.ast.createParamsType({
-			variant: "reference",
-			name: `{
-  query?: Partial<UseQueryOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
-  client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
-		default: "{}"
-	});
-	return wrapWithMaybeRefOrGetter(_kubb_core.ast.createOperationParams(node, {
-		paramsType,
-		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
-		paramsCasing,
-		resolver,
-		extraParams: [optionsParam]
-	}), (name) => name === "options");
-}
-function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsType, paramsCasing, pathParamsType, dataReturnType, node, tsResolver }) {
-	const successNames = resolveSuccessNames(node, tsResolver);
-	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
-	const errorNames = resolveErrorNames(node, tsResolver);
-	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, tsResolver);
-	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const returnType = `UseQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
-	const generics = [
-		`TData = ${TData}`,
-		`TQueryData = ${TData}`,
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
-	];
-	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
-		pathParamsType,
-		paramsCasing,
-		resolver: tsResolver
-	});
-	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
-	const enabledNames = getEnabledParamNames(queryKeyParamsNode);
-	const queryOptionsParamsNode = getQueryOptionsParams(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		resolver: tsResolver
-	});
-	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = markParamsOptional(buildQueryParamsNode(node, {
-		paramsType,
-		paramsCasing,
-		pathParamsType,
-		dataReturnType,
-		resolver: tsResolver
-	}), enabledNames);
-	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = (resolvedOptions && 'queryKey' in resolvedOptions ? toValue(resolvedOptions.queryKey) : undefined) ?? ${queryKeyName}(${queryKeyParamsCall})
-
-       const query = useQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),
-        ...resolvedOptions,
-        queryKey
-       } as unknown as UseQueryOptions<${TData}, ${TError}, TData, ${TData}, TQueryKey>, toValue(queryClient)) as ${returnType}
-
-       query.queryKey = queryKey as TQueryKey
-
-       return query
-       `
-		})
-	});
-}
-//#endregion
-Object.defineProperty(exports, "InfiniteQuery", {
-	enumerable: true,
-	get: function() {
-		return InfiniteQuery;
-	}
-});
-Object.defineProperty(exports, "InfiniteQueryOptions", {
-	enumerable: true,
-	get: function() {
-		return InfiniteQueryOptions;
-	}
-});
-Object.defineProperty(exports, "Mutation", {
-	enumerable: true,
-	get: function() {
-		return Mutation;
-	}
-});
-Object.defineProperty(exports, "MutationKey", {
-	enumerable: true,
-	get: function() {
-		return MutationKey;
-	}
-});
-Object.defineProperty(exports, "Query", {
-	enumerable: true,
-	get: function() {
-		return Query;
-	}
-});
-Object.defineProperty(exports, "QueryKey", {
-	enumerable: true,
-	get: function() {
-		return QueryKey;
-	}
-});
-Object.defineProperty(exports, "QueryOptions", {
-	enumerable: true,
-	get: function() {
-		return QueryOptions;
-	}
-});
-Object.defineProperty(exports, "__name", {
-	enumerable: true,
-	get: function() {
-		return __name;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
-Object.defineProperty(exports, "camelCase", {
-	enumerable: true,
-	get: function() {
-		return camelCase;
-	}
-});
-Object.defineProperty(exports, "getOperationParameters", {
-	enumerable: true,
-	get: function() {
-		return getOperationParameters;
-	}
-});
-Object.defineProperty(exports, "mutationKeyTransformer", {
-	enumerable: true,
-	get: function() {
-		return mutationKeyTransformer;
-	}
-});
-Object.defineProperty(exports, "operationFileEntry", {
-	enumerable: true,
-	get: function() {
-		return operationFileEntry;
-	}
-});
-Object.defineProperty(exports, "queryKeyTransformer", {
-	enumerable: true,
-	get: function() {
-		return queryKeyTransformer;
-	}
-});
-Object.defineProperty(exports, "resolveOperationTypeNames", {
-	enumerable: true,
-	get: function() {
-		return resolveOperationTypeNames;
-	}
-});
-Object.defineProperty(exports, "resolveZodSchemaNames", {
-	enumerable: true,
-	get: function() {
-		return resolveZodSchemaNames;
-	}
-});
-
-//# sourceMappingURL=components-D3xIZ9FA.cjs.map