@kubb/plugin-vue-query 5.0.0-alpha.9 → 5.0.0-beta.15

package/dist/components-1cEftHJm.cjs

@@ -0,0 +1,1276 @@
+//#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");
+//#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);
+}
+//#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 null;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+}
+//#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/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.toParamsObject();
+	}
+	#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.toParamsObject()
+		};
+		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}').toParamsObject()
+	* // { petId: 'petId', tagId: 'tagId' }
+	* ```
+	*/
+	toParamsObject(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 ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$7 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const mutationKeyTransformer = ({ node, casing }) => {
+	return [`{ url: '${new URLPath(node.path, { casing }).toURLPath()}' }`];
+};
+function MutationKey({ name, paramsCasing, node, transformer = mutationKeyTransformer }) {
+	const paramsNode = _kubb_core.ast.createFunctionParameters({ params: [] });
+	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	const keys = transformer({
+		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/shared/src/operation.ts
+function getOperationLink(node, link) {
+	if (!link) return;
+	if (typeof link === "function") return link(node);
+	if (link === "urlPath") return node.path ? `{@link ${new URLPath(node.path).URL}}` : void 0;
+	return `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}`;
+}
+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) : void 0;
+	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
+	return `${requestName ? `Partial<RequestConfig<${requestName}>>` : "Partial<RequestConfig>"} & { ${["client?: Client", isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : void 0].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) ? void 0 : code;
+}
+function isErrorStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== void 0 && code >= 400;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+}
+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) : void 0, 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/utils.ts
+/**
+* Collects the Zod schema import names for an operation (response + request body).
+*
+* Returns an empty array when no resolver is provided or the operation has no request body schema.
+*/
+function resolveZodSchemaNames(node, zodResolver) {
+	if (!zodResolver) return [];
+	return [zodResolver.resolveResponseName?.(node), node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : void 0].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 `undefined` 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 void 0;
+	const firstParam = params[0];
+	const groupName = resolver.resolveQueryParamsName(node, firstParam);
+	if (groupName === resolver.resolveParamName(node, firstParam)) return void 0;
+	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)
+	}) : void 0;
+	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 });
+}
+function buildEnabledCheck(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.join(" && ");
+}
+(0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const queryKeyTransformer = ({ node, casing }) => {
+	const path = new URLPath(node.path, { casing });
+	const hasQueryParams = getOperationParameters(node).query.length > 0;
+	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
+	return [
+		path.toObject({
+			type: "path",
+			stringify: true
+		}),
+		hasQueryParams ? "...(params ? [params] : [])" : void 0,
+		hasRequestBody ? "...(data ? [data] : [])" : void 0
+	].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 = queryKeyTransformer }) {
+	const paramsNode = buildQueryKeyParamsNode(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$5.print(paramsNode) ?? "";
+	const keys = transformer({
+		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) {
+	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	return wrapWithMaybeRefOrGetter(_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: "{}"
+		})]
+	}), (name) => name === "config");
+}
+function QueryOptions({ name, clientName, dataReturnType, node, tsResolver, paramsCasing, paramsType, pathParamsType, queryKeyName }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const paramsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	const clientCallStr = (callPrinter$4.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$4.print(queryKeyParamsNode) ?? "";
+	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
+	const enabledText = enabledSource ? `enabled: () => ${enabledSource.split(" && ").map((n) => `!!toValue(${n.trim()})`).join(" && ")},` : "";
+	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}
+       queryKey,
+       queryFn: async ({ signal }) => {
+          return ${clientName}(${addToValueCalls$1(clientCallStr)})
+       },
+      })
+`
+		})
+	});
+}
+/**
+* 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) {
+	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(${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(${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 responseName = resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 queryOptionsParamsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const queryOptionsParamsCall = callPrinter$3.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildInfiniteQueryParamsNode(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		resolver: tsResolver
+	});
+	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 responseName = tsResolver.resolveResponseName(node);
+	const queryFnDataType = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 : void 0;
+	})() : void 0;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : void 0;
+	const pageParamType = queryParamType ? isInitialPageParamDefined ? `NonNullable<${queryParamType}>` : queryParamType : fallbackPageParamType;
+	const paramsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	const clientCallStr = (callPrinter$2.print(paramsNode) ?? "").replace(/\bconfig\b(?=[^,]*$)/, "{ ...config, signal: config.signal ?? signal }");
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, {
+		pathParamsType,
+		paramsCasing,
+		resolver: tsResolver
+	});
+	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
+	const enabledSource = buildEnabledCheck(queryKeyParamsNode);
+	const enabledText = enabledSource ? `enabled: () => ${enabledSource.split(" && ").map((n) => `!!toValue(${n.trim()})`).join(" && ")},` : "";
+	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 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}
+       queryKey,
+       queryFn: async ({ signal, pageParam }) => {
+          ${infiniteOverrideParams}
+          return ${clientName}(${addToValueCalls(clientCallStr)})
+        },
+       ${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}
+       queryKey,
+       queryFn: async ({ signal }) => {
+          return ${clientName}(${addToValueCalls(clientCallStr)})
+        },
+       ${queryOptionsArr.join(",\n")}
+      })
+`
+		})
+	});
+}
+function addToValueCalls(callStr) {
+	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(${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(${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 responseName = resolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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}}` : "void",
+				"TContext"
+			].join(", ")}> & { client?: QueryClient },
+  client?: ${buildRequestConfigType(node, resolver)},
+}`
+		}),
+		default: "{}"
+	})] });
+}
+function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType, dataReturnType, node, tsResolver, mutationKeyName }) {
+	const responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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}}` : "void",
+		"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 responseName = resolver.resolveResponseName(node);
+	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
+	const errorNames = resolveErrorNames(node, resolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 responseName = tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = dataReturnType === "data" ? responseName : `ResponseConfig<${responseName}>`;
+	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 queryOptionsParamsNode = getQueryOptionsParams(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		resolver: tsResolver
+	});
+	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildQueryParamsNode(node, {
+		paramsType,
+		paramsCasing,
+		pathParamsType,
+		dataReturnType,
+		resolver: tsResolver
+	});
+	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, "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-1cEftHJm.cjs.map