@kubb/plugin-react-query 5.0.0-beta.64 → 5.0.0-beta.73

package/dist/index.js

@@ -1,14 +1,39 @@
-import "./chunk-C0LytTxp.js";
-import { d as queryKeyTransformer, h as mutationKeyTransformer, y as camelCase } from "./components-Ds-e_nnK.js";
-import { a as infiniteQueryGenerator, i as mutationGenerator, n as suspenseInfiniteQueryGenerator, o as hookOptionsGenerator, r as queryGenerator, s as customHookOptionsFileGenerator, t as suspenseQueryGenerator } from "./generators-nnZhtlrk.js";
+import "./rolldown-runtime-C0LytTxp.js";
 import path from "node:path";
-import { ast, definePlugin, defineResolver } from "@kubb/core";
-import { isParserEnabled, pluginClientName } from "@kubb/plugin-client";
-import { source } from "@kubb/plugin-client/templates/clients/axios.source";
-import { source as source$1 } from "@kubb/plugin-client/templates/clients/fetch.source";
-import { source as source$2 } from "@kubb/plugin-client/templates/config.source";
-import { pluginTsName } from "@kubb/plugin-ts";
+import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
+import { File, Function, Type, jsxRenderer } from "@kubb/renderer-jsx";
+import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import fs from "node:fs";
+import { getNestedAccessor } from "@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/fs.ts
 /**
 * Builds a nested file path from a dotted name. Splits on dots that precede a letter
@@ -34,6 +59,393 @@ function toFilePath(name, caseLast = camelCase) {
 	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).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/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}\``;
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off the
+	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``. Parameter
+	* names are camelCased to match the generated `path` type, and `prefix` is prepended inside the
+	* literal. Shared by the client and cypress generators that pass a grouped `path` object.
+	*
+	* @example
+	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
+	*/
+	static toGroupedTemplateString(path, { prefix } = {}) {
+		return Url.toTemplateString(path, {
+			prefix,
+			casing: "camelcase",
+			replacer: (name) => `path.${name}`
+		});
+	}
+	/**
+	* 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/params.ts
+const caseParamsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Applies camelCase to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged. Results are cached per input array.
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	const cached = caseParamsCache.get(params);
+	if (cached) return cached;
+	const result = params.map((param) => ({
+		...param,
+		name: camelCase(param.name)
+	}));
+	caseParamsCache.set(params, result);
+	return result;
+}
+//#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) {
+	const { isMultipleContentTypes, contentTypeUnion } = getContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const contentTypeProp = isMultipleContentTypes ? `contentType?: ${contentTypeUnion}` : null;
+	return contentTypeProp ? `${configType} & { ${contentTypeProp} }` : configType;
+}
+/**
+* Builds the `client?:` option type shared by the generated query hooks (`useQuery`,
+* `useInfiniteQuery`, `useSWR`, ...). Unlike {@link buildRequestConfigType}, it never adds a
+* `contentType?:` member: query hooks wrap GET operations, which carry no request body to select a
+* content type for.
+*/
+function buildClientOptionType() {
+	return `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
+/**
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
+*/
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
+}
+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 = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
+	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));
+}
+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.includeParams === false ? "noparams" : ""}\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 = options.includeParams === false ? [] : [
+		...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/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -65,6 +477,2060 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
+//#region ../../internals/client/src/builders/parser.ts
+/**
+* Returns `true` when any direction of the parser uses zod (used for dependency checks).
+*/
+function isParserEnabled(parser) {
+	if (!parser) return false;
+	if (parser === "zod") return true;
+	return Boolean(parser.request || parser.response);
+}
+//#endregion
+//#region ../../internals/client/src/resolveClient.ts
+/**
+* Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
+* operation, shared so the selection rules and diagnostics stay in one place.
+*
+* Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
+* contract client plugin (plugin-fetch or plugin-axios) and never emits its own inline client:
+*
+* - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
+*   imports and calls them.
+* - `error` — no client plugin is registered, several are registered without a selector, or the
+*   requested one is missing.
+*
+* The `client` string selects explicitly (`'fetch'` / `'axios'`); when it is unset a lone registered
+* contract client plugin is picked up automatically.
+*/
+const pluginFetchName = "plugin-fetch";
+const pluginAxiosName = "plugin-axios";
+const selectorToPlugin = {
+	fetch: pluginFetchName,
+	axios: pluginAxiosName
+};
+const contractPlugins = [pluginFetchName, pluginAxiosName];
+/**
+* Applies the `client` resolution rules. See the module comment for the strategy shape.
+*
+* @example
+* ```ts
+* resolveClient({ client: 'fetch', pluginNames: ['plugin-ts', 'plugin-fetch'] })
+* // { kind: 'contract', pluginName: 'plugin-fetch' }
+* ```
+*
+* @example
+* ```ts
+* resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
+* // { kind: 'error', message: 'No client plugin is registered…' }
+* ```
+*/
+function resolveClient(options) {
+	const { client, pluginNames } = options;
+	const has = (name) => pluginNames.includes(name);
+	if (client === "fetch" || client === "axios") {
+		const pluginName = selectorToPlugin[client];
+		if (!has(pluginName)) return {
+			kind: "error",
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`. Add it, or drop \`client\` to use a different client plugin.`
+		};
+		return {
+			kind: "contract",
+			pluginName
+		};
+	}
+	const registered = contractPlugins.filter(has);
+	if (registered.length === 1) return {
+		kind: "contract",
+		pluginName: registered[0]
+	};
+	if (registered.length > 1) return {
+		kind: "error",
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios'\` to choose which client the hooks call, or register a single client plugin.`
+	};
+	return {
+		kind: "error",
+		message: "No client plugin is registered. Add `@kubb/plugin-axios` or `@kubb/plugin-fetch` to `plugins` so the generated code has an HTTP client to call."
+	};
+}
+//#endregion
+//#region ../../internals/client/src/resolveClientOperation.ts
+/**
+* Resolves the contract client `<op>` a consumer (query hook, MCP handler) imports, by looking up
+* the registered contract client plugin's resolver and output. Works for any contract client plugin
+* (plugin-fetch or plugin-axios). Returns `null` when no contract plugin is in play (the inline
+* path). The plugin injects `.kubb/client.ts` at the global output root, the same path consumers
+* read `RequestConfig` / `ResponseErrorConfig` from.
+*/
+function resolveClientOperation(options) {
+	const { clientPlugin, driver, node, root, output } = options;
+	if (!clientPlugin) return null;
+	const resolver = driver.getResolver(clientPlugin.pluginName);
+	if (!resolver) return null;
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.resolveFile(operationFileEntry(node, node.operationId), {
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.resolveName(node.operationId),
+		path: file.path,
+		clientPath: path.resolve(root, ".kubb/client.ts")
+	};
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$10 = functionPrinter({ mode: "declaration" });
+const mutationKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	return [`{ url: '${Url.toPath(node.path)}' }`];
+};
+function MutationKey({ name, node, transformer }) {
+	const paramsNode = createFunctionParameters({ params: [] });
+	const paramsSignature = declarationPrinter$10.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	});
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/utils.ts
+/**
+* The grouped request options, ordered for both the destructured signature and the
+* call passed to the underlying client.
+*/
+const requestGroupOrder = [
+	"path",
+	"query",
+	"body",
+	"headers"
+];
+/**
+* Builds the grouped `{ path, query, body, headers }` parameter that mirrors the client
+* function signature. Only the groups the operation carries are emitted, typed from the
+* operation's `RequestConfig`. `keys` narrows the emitted groups, used by the query key which
+* never carries `headers`.
+*
+* By default the whole group is typed as the single `RequestConfig` reference. When
+* `memberTypeWrapper` is set, each group is emitted as its own member typed from the matching
+* `RequestConfig['<group>']` slice and wrapped, used by vue-query to apply
+* `MaybeRefOrGetter` per group.
+*/
+function buildGroupedRequestParam(node, options) {
+	const { resolver, keys = requestGroupOrder, memberTypeWrapper } = options;
+	const { groups, hasRequiredPath, hasRequiredQuery, hasRequiredHeader } = getRequestGroupOptionality(node);
+	const names = keys.filter((key) => groups[key]);
+	if (names.length === 0) return null;
+	const requiredByGroup = {
+		path: hasRequiredPath,
+		query: hasRequiredQuery,
+		body: groups.body,
+		headers: hasRequiredHeader
+	};
+	const isOptional = names.every((name) => !requiredByGroup[name]);
+	const requestConfigName = resolver.resolveRequestConfigName(node);
+	const omittedKeys = requestGroupOrder.filter((key) => !keys.includes(key));
+	const requestConfigType = omittedKeys.length > 0 ? `Omit<${requestConfigName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : requestConfigName;
+	if (memberTypeWrapper) {
+		const members = names.map((name) => ({
+			name,
+			type: memberTypeWrapper(`${requestConfigType}['${name}']`),
+			optional: !requiredByGroup[name]
+		}));
+		return createFunctionParameter({
+			name: createObjectBindingPattern({ elements: names.map((name) => ({ name })) }),
+			type: createTypeLiteral({ members }),
+			optional: false,
+			...isOptional ? { default: "{}" } : {}
+		});
+	}
+	return createFunctionParameter({
+		name: createObjectBindingPattern({ elements: names.map((name) => ({ name })) }),
+		type: requestConfigType,
+		optional: false,
+		...isOptional ? { default: "{}" } : {}
+	});
+}
+/**
+* Builds the shared `({ path, query, body, headers }, config = {})` parameter list for a
+* TanStack query-options function. The leading parameter mirrors the client signature, and the
+* trailing `config` is a partial `RequestConfig` minus the grouped data-shape keys, which are passed
+* explicitly. Framework plugins wrap the result when needed, for example vue-query applies `MaybeRefOrGetter`.
+*/
+function buildQueryOptionsParams(node, options) {
+	const { resolver, memberTypeWrapper } = options;
+	return createFunctionParameters({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper
+	}), createFunctionParameter({
+		name: "config",
+		type: `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`,
+		default: "{}"
+	})].filter((param) => param !== null) });
+}
+/**
+* Builds the call to a client `<op>` function inside a query/mutation hook body. The function takes
+* a single grouped options object, so the operation's request groups are passed as
+* shorthand alongside the spread `config`, with `throwOnError: true` pinned last so a caller's config
+* can't flip the query's error semantics. Queries thread the TanStack `signal`; mutations omit it.
+*
+* @example
+* ```ts
+* buildClientCall(node, { clientName: 'getPetById', signal: true })
+* // getPetById({ path, ...config, signal: config.signal ?? signal, throwOnError: true })
+* ```
+*/
+function buildClientCall(node, options) {
+	const { clientName, signal = false } = options;
+	const { groups } = getRequestGroupOptionality(node);
+	return `${clientName}({ ${[
+		"...config",
+		...requestGroupOrder.filter((key) => groups[key]),
+		signal ? "signal: config.signal ?? signal" : null,
+		"throwOnError: true"
+	].filter((part) => part !== null).join(", ")} })`;
+}
+function matchesPattern(node, ov) {
+	const { type, pattern } = ov;
+	const matches = (value) => typeof pattern === "string" ? value === pattern : pattern.test(value);
+	if (type === "operationId") return matches(node.operationId);
+	if (type === "tag") return node.tags.some((t) => matches(t));
+	if (type === "path") return node.path !== void 0 && matches(node.path);
+	if (type === "method") return node.method !== void 0 && matches(node.method);
+	return false;
+}
+/**
+* Resolves per-operation overrides (first matching override wins).
+*
+* @example
+* ```ts
+* const opts = resolveOperationOverrides(node, override)
+* const queryOpts = 'query' in opts ? opts.query : defaultQuery
+* ```
+*/
+function resolveOperationOverrides(node, override) {
+	if (!override) return {};
+	return override.find((ov) => matchesPattern(node, ov))?.options ?? {};
+}
+/**
+* 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, { paramsCasing: "original" });
+	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));
+}
+/**
+* Build QueryKey params as the grouped `{ path, query, body }` object (NO headers, NO config),
+* typed from the operation's `RequestConfig` minus `url`. The query key transformer reads the
+* grouped `path`/`query`/`body` bindings.
+*/
+function buildQueryKeyParams(node, options) {
+	const { resolver } = options;
+	const groupedParam = buildGroupedRequestParam(node, {
+		resolver,
+		keys: [
+			"path",
+			"query",
+			"body"
+		]
+	});
+	return createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/QueryKey.tsx
+const declarationPrinter$9 = functionPrinter({ mode: "declaration" });
+const queryKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	const hasPathParams = getOperationParameters(node).path.length > 0;
+	const hasQueryParams = getOperationParameters(node).query.length > 0;
+	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
+	return [
+		hasPathParams ? `{ url: '${Url.toPath(node.path)}', params: path }` : `{ url: '${Url.toPath(node.path)}' }`,
+		hasQueryParams ? "...(query ? [query] : [])" : null,
+		hasRequestBody ? "...(body ? [body] : [])" : null
+	].filter(Boolean);
+};
+function QueryKey({ name, node, tsResolver, typeName, transformer }) {
+	const paramsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$9.print(paramsNode) ?? "";
+	const keys = (transformer ?? queryKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+//#endregion
+//#region src/generators/customHookOptionsFileGenerator.tsx
+/**
+* Scaffolds the user-editable `useCustomHookOptions` file when
+* `pluginReactQuery({ customOptions: { ... } })` is configured. The file is
+* only created when it does not already exist, so user edits persist across
+* regeneration.
+*/
+const customHookOptionsFileGenerator = defineGenerator({
+	name: "react-query-custom-hook-options-file",
+	renderer: jsxRenderer,
+	operations(nodes, ctx) {
+		const { resolver, root } = ctx;
+		const { output, customOptions, query, group } = ctx.options;
+		if (!customOptions) return null;
+		const { importPath, name } = customOptions;
+		const hookOptionsName = resolver.resolveHookOptionsName();
+		const customHookOptionsName = resolver.resolveCustomHookOptionsName();
+		const reactQueryImportPath = query ? query.importPath : "@tanstack/react-query";
+		let hookFilePath;
+		const firstNode = nodes[0];
+		if (firstNode) {
+			const hookName = resolver.resolveQueryName(firstNode);
+			hookFilePath = resolver.resolveFile({
+				name: hookName,
+				extname: ".ts",
+				tag: firstNode.tags[0] ?? "default",
+				path: firstNode.path
+			}, {
+				root,
+				output,
+				group: group ?? void 0
+			}).path;
+		} else hookFilePath = path.resolve(root, "index.ts");
+		const ensureExtension = (filePath, extname) => {
+			if (path.extname(filePath) === "") return filePath + extname;
+			return filePath;
+		};
+		const basePath = path.dirname(hookFilePath);
+		const actualFilePath = ensureExtension(importPath, ".ts");
+		const file = {
+			baseName: path.basename(actualFilePath),
+			name: path.basename(actualFilePath, path.extname(actualFilePath)),
+			path: path.resolve(basePath, actualFilePath)
+		};
+		if (fs.existsSync(file.path)) return null;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["QueryClient"],
+					path: reactQueryImportPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["useQueryClient"],
+					path: reactQueryImportPath
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [hookOptionsName],
+					root: file.path,
+					path: path.resolve(root, "./index.ts")
+				}),
+				/* @__PURE__ */ jsxs(File.Source, {
+					name: file.name,
+					isExportable: true,
+					isIndexable: true,
+					children: [/* @__PURE__ */ jsx(Function, {
+						name: customHookOptionsName,
+						params: "{ queryClient }: { queryClient: QueryClient }",
+						returnType: `Partial<${hookOptionsName}>`,
+						children: `return {
+              // TODO: Define custom hook options here
+              // Example:
+              // useUpdatePetHook: {
+              //   onSuccess: () => {
+              //     void queryClient.invalidateQueries({ queryKey: ['pet'] })
+              //   }
+              // }
+            }`
+					}), /* @__PURE__ */ jsx(Function, {
+						name,
+						generics: `T extends keyof ${hookOptionsName}`,
+						params: "{ hookName, operationId }: { hookName: T, operationId: string }",
+						returnType: `${hookOptionsName}[T]`,
+						export: true,
+						children: `const queryClient = useQueryClient()
+            const customOptions = ${customHookOptionsName}({ queryClient })
+            return customOptions[hookName] ?? {}`
+					})]
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/hookOptionsGenerator.tsx
+/**
+* Emits the `HookOptions` type used by `customOptions`. Enabled when
+* `pluginReactQuery({ customOptions: { ... } })`. The generated type lists
+* every hook keyed by name so user-supplied options stay in sync with the
+* generated hooks at compile time.
+*/
+const hookOptionsGenerator = defineGenerator({
+	name: "react-query-hook-options",
+	renderer: jsxRenderer,
+	operations(nodes, ctx) {
+		const { resolver, config, root } = ctx;
+		const { output, customOptions, query, mutation, suspense, infinite, group, override } = ctx.options;
+		if (!customOptions) return null;
+		const name = resolver.resolveHookOptionsName();
+		const resolvedFile = resolver.resolveFile({
+			name,
+			extname: ".ts"
+		}, {
+			root,
+			output,
+			group: group ?? void 0
+		});
+		const hookOptionsFile = {
+			...resolvedFile,
+			baseName: `${name}.ts`,
+			path: resolvedFile.path.replace(/[^/\\]+\.ts$/, `${name}.ts`)
+		};
+		const imports = [];
+		const hookOptions = {};
+		for (const node of nodes) {
+			if (!ast.isHttpOperationNode(node)) continue;
+			const opOverrides = resolveOperationOverrides(node, override);
+			const nodeQuery = "query" in opOverrides ? opOverrides.query : query;
+			const nodeMutation = "mutation" in opOverrides ? opOverrides.mutation : mutation;
+			const nodeInfinite = "infinite" in opOverrides ? opOverrides.infinite : infinite;
+			const nodeInfiniteOptions = nodeInfinite && typeof nodeInfinite === "object" ? nodeInfinite : null;
+			const isQueryOp = nodeQuery === false ? !!query && query.methods.some((m) => node.method.toLowerCase() === m.toLowerCase()) : !!nodeQuery && nodeQuery.methods.some((m) => node.method.toLowerCase() === m.toLowerCase());
+			const nodeQueryMethods = new Set(nodeQuery ? nodeQuery.methods : []);
+			const isMutationOp = nodeMutation !== false && !isQueryOp && (nodeMutation ? nodeMutation.methods : []).some((m) => !nodeQueryMethods.has(m) && node.method.toLowerCase() === m.toLowerCase());
+			const isSuspenseOp = !!suspense;
+			const isInfiniteOp = !!nodeInfiniteOptions;
+			if (isQueryOp) {
+				const queryOptionsName = resolver.resolveQueryOptionsName(node);
+				const queryHookName = resolver.resolveQueryName(node);
+				const queryHookFile = resolver.resolveFile(operationFileEntry(node, queryHookName), {
+					root,
+					output,
+					group: group ?? void 0
+				});
+				imports.push(/* @__PURE__ */ jsx(File.Import, {
+					name: [queryOptionsName],
+					root: hookOptionsFile.path,
+					path: queryHookFile.path
+				}));
+				hookOptions[queryHookName] = `Partial<ReturnType<typeof ${queryOptionsName}>>`;
+				if (isSuspenseOp) {
+					const suspenseOptionsName = resolver.resolveSuspenseQueryOptionsName(node);
+					const suspenseHookName = resolver.resolveSuspenseQueryName(node);
+					const suspenseHookFile = resolver.resolveFile(operationFileEntry(node, suspenseHookName), {
+						root,
+						output,
+						group: group ?? void 0
+					});
+					imports.push(/* @__PURE__ */ jsx(File.Import, {
+						name: [suspenseOptionsName],
+						root: hookOptionsFile.path,
+						path: suspenseHookFile.path
+					}));
+					hookOptions[suspenseHookName] = `Partial<ReturnType<typeof ${suspenseOptionsName}>>`;
+				}
+				if (isInfiniteOp) {
+					const normalizeKey = (key) => key.replace(/\?$/, "");
+					const queryParamKeys = getOperationParameters(node, { paramsCasing: "original" }).query.map((p) => p.name);
+					if (nodeInfiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === nodeInfiniteOptions.queryParam) : false) {
+						const infiniteOptionsName = resolver.resolveInfiniteQueryOptionsName(node);
+						const infiniteHookName = resolver.resolveInfiniteQueryName(node);
+						const infiniteHookFile = resolver.resolveFile(operationFileEntry(node, infiniteHookName), {
+							root,
+							output,
+							group: group ?? void 0
+						});
+						imports.push(/* @__PURE__ */ jsx(File.Import, {
+							name: [infiniteOptionsName],
+							root: hookOptionsFile.path,
+							path: infiniteHookFile.path
+						}));
+						hookOptions[infiniteHookName] = `Partial<ReturnType<typeof ${infiniteOptionsName}>>`;
+						if (isSuspenseOp) {
+							const suspenseInfiniteOptionsName = resolver.resolveSuspenseInfiniteQueryOptionsName(node);
+							const suspenseInfiniteHookName = resolver.resolveSuspenseInfiniteQueryName(node);
+							const suspenseInfiniteHookFile = resolver.resolveFile(operationFileEntry(node, suspenseInfiniteHookName), {
+								root,
+								output,
+								group: group ?? void 0
+							});
+							imports.push(/* @__PURE__ */ jsx(File.Import, {
+								name: [suspenseInfiniteOptionsName],
+								root: hookOptionsFile.path,
+								path: suspenseInfiniteHookFile.path
+							}));
+							hookOptions[suspenseInfiniteHookName] = `Partial<ReturnType<typeof ${suspenseInfiniteOptionsName}>>`;
+						}
+					}
+				}
+			}
+			if (isMutationOp) {
+				const mutationOptionsName = resolver.resolveMutationOptionsName(node);
+				const mutationHookName = resolver.resolveMutationName(node);
+				const mutationHookFile = resolver.resolveFile(operationFileEntry(node, mutationHookName), {
+					root,
+					output,
+					group: group ?? void 0
+				});
+				imports.push(/* @__PURE__ */ jsx(File.Import, {
+					name: [mutationOptionsName],
+					root: hookOptionsFile.path,
+					path: mutationHookFile.path
+				}));
+				hookOptions[mutationHookName] = `Partial<ReturnType<typeof ${mutationOptionsName}>>`;
+			}
+		}
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: hookOptionsFile.baseName,
+			path: hookOptionsFile.path,
+			meta: hookOptionsFile.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: hookOptionsFile.path,
+					baseName: hookOptionsFile.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: hookOptionsFile.path,
+					baseName: hookOptionsFile.baseName
+				}
+			}),
+			children: [imports, /* @__PURE__ */ jsx(File.Source, {
+				name,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: /* @__PURE__ */ jsx(Type, {
+					export: true,
+					name,
+					children: `{ ${Object.keys(hookOptions).map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`).join(", ")} }`
+				})
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/components/QueryOptions.tsx
+const declarationPrinter$8 = functionPrinter({ mode: "declaration" });
+const callPrinter$8 = functionPrinter({ mode: "call" });
+function getQueryOptionsParams(node, options) {
+	return buildQueryOptionsParams(node, options);
+}
+function QueryOptions({ name, clientName, node, tsResolver, queryKeyName }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = responseName;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$8.print(queryKeyParamsNode) ?? "";
+	const paramsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$8.print(paramsNode) ?? "";
+	const queryFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: true
+	})}
+          return data`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+      return queryOptions<${TData}, ${TError}, ${TData}, typeof queryKey>({
+       queryKey,
+       queryFn: async ({ signal }) => {
+          ${queryFnBody}
+       },
+      })
+`
+		})
+	});
+}
+//#endregion
+//#region src/components/InfiniteQuery.tsx
+const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
+const callPrinter$7 = functionPrinter({ mode: "call" });
+function buildInfiniteQueryParamsNode(node, options) {
+	const { resolver, pageParamGeneric } = options;
+	const optionsParam = createFunctionParameter({
+		name: "options",
+		type: `{
+  query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return createFunctionParameters({ params: [buildGroupedRequestParam(node, { resolver }), optionsParam].filter((param) => param !== null) });
+}
+function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, initialPageParam, queryParam, customOptions }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const responseType = responseName;
+	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, { paramsCasing: "original" }).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 returnType = "UseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }";
+	const generics = [
+		`TQueryFnData = ${responseType}`,
+		`TError = ${errorType}`,
+		"TData = InfiniteData<TQueryFnData>",
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
+		`TPageParam = ${pageParamType}`
+	];
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$7.print(queryKeyParamsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const queryOptionsParamsCall = callPrinter$7.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildInfiniteQueryParamsNode(node, {
+		resolver: tsResolver,
+		pageParamGeneric: "TPageParam"
+	});
+	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: paramsSignature,
+			returnType: void 0,
+			JSDoc: { comments: buildOperationComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+
+       const queryResult = useInfiniteQuery({
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
+        ...resolvedOptions,
+        queryKey,
+       } as unknown as InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
+
+       queryResult.queryKey = queryKey as TQueryKey
+
+       return queryResult
+       `
+		})
+	});
+}
+//#endregion
+//#region src/components/InfiniteQueryOptions.tsx
+const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
+const callPrinter$6 = functionPrinter({ mode: "call" });
+function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, queryParam, queryKeyName }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const queryFnDataType = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	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, { paramsCasing: "original" }).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 = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$6.print(queryKeyParamsNode) ?? "";
+	const paramsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
+	const queryFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: true
+	})}
+    return data`;
+	const hasNewParams = nextParam != null || previousParam != null;
+	const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
+		if (hasNewParams) {
+			const nextAccessor = nextParam ? getNestedAccessor(nextParam, "lastPage") : null;
+			const prevAccessor = previousParam ? 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 ["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 ? `query = {
+      ...(query ?? {}),
+      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
+    } as ${queryParamsTypeName}` : "";
+	if (infiniteOverrideParams) return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
+  queryKey,
+  queryFn: async ({ signal, pageParam }) => {
+    ${infiniteOverrideParams}
+    ${queryFnBody}
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
+`
+		})
+	});
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
+  queryKey,
+  queryFn: async ({ signal }) => {
+    ${queryFnBody}
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
+`
+		})
+	});
+}
+//#endregion
+//#region src/components/MutationOptions.tsx
+const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
+const callPrinter$5 = functionPrinter({ mode: "call" });
+function buildMutationConfigParamsNode(node) {
+	return createFunctionParameters({ params: [createFunctionParameter({
+		name: "config",
+		type: buildRequestConfigType(node),
+		default: "{}"
+	})] });
+}
+function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const TData = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
+	const configParamsNode = buildMutationConfigParamsNode(node);
+	const paramsSignature = declarationPrinter$5.print(configParamsNode) ?? "";
+	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
+	const hasMutationParams = groupedParam !== null;
+	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
+	const TRequest = hasMutationParams ? tsResolver.resolveRequestConfigName(node) : "undefined";
+	const argBindingStr = hasMutationParams ? callPrinter$5.print(groupedParamsNode) ?? "" : "_";
+	const mutationFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: false
+	})}
+          return data`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			generics: ["TContext = unknown"],
+			children: `
+      const mutationKey = ${mutationKeyName}()
+      return mutationOptions<${TData}, ${TError}, ${TRequest}, TContext>({
+        mutationKey,
+        mutationFn: async(${argBindingStr}) => {
+          ${mutationFnBody}
+        },
+      })
+`
+		})
+	});
+}
+//#endregion
+//#region src/components/Mutation.tsx
+const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
+const callPrinter$4 = functionPrinter({ mode: "call" });
+function resolveMutationRequestType(node, resolver) {
+	return buildGroupedRequestParam(node, { resolver }) ? resolver.resolveRequestConfigName(node) : "undefined";
+}
+function buildMutationParamsNode(node, options) {
+	const { resolver } = options;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	return createFunctionParameters({ params: [createFunctionParameter({
+		name: "options",
+		type: `{
+  mutation?: UseMutationOptions<${[
+			responseName,
+			`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+			resolveMutationRequestType(node, resolver),
+			"TContext"
+		].join(", ")}> & { client?: QueryClient },
+  client?: ${buildRequestConfigType(node)},
+}`,
+		default: "{}"
+	})] });
+}
+function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName, customOptions }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const generics = [
+		responseName,
+		`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+		resolveMutationRequestType(node, tsResolver),
+		"TContext"
+	].join(", ");
+	const returnType = `UseMutationResult<${generics}>`;
+	const mutationOptionsConfigNode = buildMutationConfigParamsNode(node);
+	const mutationOptionsParamsCall = callPrinter$4.print(mutationOptionsConfigNode) ?? "";
+	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ 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}()
+
+        const baseOptions = ${mutationOptionsName}(${mutationOptionsParamsCall}) as UseMutationOptions<${generics}>${customOptions ? `\n        const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' }) as UseMutationOptions<${generics}>` : ""}
+
+        return useMutation<${generics}>({
+          ...baseOptions,${customOptions ? "\n          ...customOptions," : ""}
+          mutationKey,
+          ...mutationOptions,
+        }, queryClient) as ${returnType}
+    `
+		})
+	});
+}
+//#endregion
+//#region src/components/Query.tsx
+const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
+const callPrinter$3 = functionPrinter({ mode: "call" });
+function buildQueryParamsNode(node, options) {
+	const { resolver } = options;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	const optionsParam = createFunctionParameter({
+		name: "options",
+		type: `{
+  query?: Partial<QueryObserverOptions<${[
+			responseName,
+			`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+			"TData",
+			"TQueryData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return createFunctionParameters({ params: [buildGroupedRequestParam(node, { resolver }), optionsParam].filter((param) => param !== null) });
+}
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = responseName;
+	const returnType = `UseQueryResult<TData, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}> & { queryKey: TQueryKey }`;
+	const generics = [
+		`TData = ${TData}`,
+		`TQueryData = ${TData}`,
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
+	];
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const queryOptionsParamsCall = callPrinter$3.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildQueryParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: paramsSignature,
+			returnType: void 0,
+			JSDoc: { comments: buildOperationComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+
+       const queryResult = useQuery({
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
+        ...resolvedOptions,
+        queryKey,
+       } as unknown as QueryObserverOptions, queryClient) as ${returnType}
+
+       queryResult.queryKey = queryKey as TQueryKey
+
+       return queryResult
+       `
+		})
+	});
+}
+//#endregion
+//#region src/components/SuspenseInfiniteQuery.tsx
+const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
+const callPrinter$2 = functionPrinter({ mode: "call" });
+function buildSuspenseInfiniteQueryParamsNode(node, options) {
+	const { resolver, pageParamGeneric } = options;
+	const optionsParam = createFunctionParameter({
+		name: "options",
+		type: `{
+  query?: Partial<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return createFunctionParameters({ params: [buildGroupedRequestParam(node, { resolver }), optionsParam].filter((param) => param !== null) });
+}
+function SuspenseInfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions, initialPageParam, queryParam }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const responseType = responseName;
+	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, { paramsCasing: "original" }).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 returnType = "UseSuspenseInfiniteQueryResult<TData, TError> & { queryKey: TQueryKey }";
+	const generics = [
+		`TQueryFnData = ${responseType}`,
+		`TError = ${errorType}`,
+		"TData = InfiniteData<TQueryFnData>",
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
+		`TPageParam = ${pageParamType}`
+	];
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const queryOptionsParamsCall = callPrinter$2.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildSuspenseInfiniteQueryParamsNode(node, {
+		resolver: tsResolver,
+		pageParamGeneric: "TPageParam"
+	});
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: paramsSignature,
+			returnType: void 0,
+			JSDoc: { comments: buildOperationComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+
+       const queryResult = useSuspenseInfiniteQuery({
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
+        ...resolvedOptions,
+        queryKey,
+       } as unknown as UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
+
+       queryResult.queryKey = queryKey as TQueryKey
+
+       return queryResult
+       `
+		})
+	});
+}
+//#endregion
+//#region src/components/SuspenseInfiniteQueryOptions.tsx
+const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
+const callPrinter$1 = functionPrinter({ mode: "call" });
+function SuspenseInfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, queryParam, queryKeyName }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const queryFnDataType = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	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, { paramsCasing: "original" }).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 paramsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
+	const queryFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: true
+	})}
+    return data`;
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$1.print(queryKeyParamsNode) ?? "";
+	const hasNewParams = nextParam != null || previousParam != null;
+	const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
+		if (hasNewParams) {
+			const nextAccessor = nextParam ? getNestedAccessor(nextParam, "lastPage") : null;
+			const prevAccessor = previousParam ? 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 ["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 ? `query = {
+      ...(query ?? {}),
+      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
+    } as ${queryParamsTypeName}` : "";
+	if (infiniteOverrideParams) return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
+  queryKey,
+  queryFn: async ({ signal, pageParam }) => {
+    ${infiniteOverrideParams}
+    ${queryFnBody}
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
+`
+		})
+	});
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, typeof queryKey, ${pageParamType}>({
+  queryKey,
+  queryFn: async ({ signal }) => {
+    ${queryFnBody}
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
+`
+		})
+	});
+}
+//#endregion
+//#region src/components/SuspenseQuery.tsx
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+const callPrinter = functionPrinter({ mode: "call" });
+function buildSuspenseQueryParamsNode(node, options) {
+	const { resolver } = options;
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	const optionsParam = createFunctionParameter({
+		name: "options",
+		type: `{
+  query?: Partial<UseSuspenseQueryOptions<${[
+			responseName,
+			`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`,
+			"TData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return createFunctionParameters({ params: [buildGroupedRequestParam(node, { resolver }), optionsParam].filter((param) => param !== null) });
+}
+function SuspenseQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions }) {
+	const successNames = resolveSuccessNames(node, tsResolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : tsResolver.resolveResponseName(node);
+	const errorNames = resolveErrorNames(node, tsResolver);
+	const TData = responseName;
+	const returnType = `UseSuspenseQueryResult<TData, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}> & { queryKey: TQueryKey }`;
+	const generics = [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`];
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
+	const queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildSuspenseQueryParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: paramsSignature,
+			returnType: void 0,
+			JSDoc: { comments: buildOperationComments(node) },
+			children: `
+       const { query: queryConfig = {}, client: config = {} } = options ?? {}
+       const { client: queryClient, ...resolvedOptions } = queryConfig
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyParamsCall})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+
+       const queryResult = useSuspenseQuery({
+        ...${queryOptionsName}(${queryOptionsParamsCall}),${customOptions ? "\n        ...customOptions," : ""}
+        ...resolvedOptions,
+        queryKey,
+       } as unknown as UseSuspenseQueryOptions, queryClient) as ${returnType}
+
+       queryResult.queryKey = queryKey as TQueryKey
+
+       return queryResult
+       `
+		})
+	});
+}
+//#endregion
+//#region src/generators/infiniteQueryGenerator.tsx
+/**
+* Built-in generator for `useInfiniteQuery` hooks. Enabled when
+* `pluginReactQuery({ infinite: { ... } })`. Emits one `useFooInfiniteQuery`
+* hook per query operation, wiring the configured `nextParam` /
+* `previousParam` paths into TanStack Query's cursor-based pagination.
+*/
+const infiniteQueryGenerator = defineGenerator({
+	name: "react-infinite-query",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, infinite, parser, client, group, customOptions } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+		const queryMethods = new Set(query ? query.methods : []);
+		const isMutation = mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase());
+		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
+		if (!isQuery || isMutation || !infiniteOptions) return null;
+		const normalizeKey = (key) => key.replace(/\?$/, "");
+		const queryParamKeys = getOperationParameters(node, { paramsCasing: "original" }).query.map((p) => p.name);
+		const hasQueryParam = infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false;
+		const hasCursorParam = !infiniteOptions.cursorParam || true;
+		if (!hasQueryParam || !hasCursorParam) return null;
+		const importPath = query ? query.importPath : "@tanstack/react-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const queryName = resolver.resolveInfiniteQueryName(node);
+		const queryOptionsName = resolver.resolveInfiniteQueryOptionsName(node);
+		const queryKeyName = resolver.resolveInfiniteQueryKeyName(node);
+		const queryKeyTypeName = resolver.resolveInfiniteQueryKeyTypeName(node);
+		const meta = {
+			file: resolver.resolveFile(operationFileEntry(node, queryName), {
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const rawQueryParams = getOperationParameters(node, { paramsCasing: "original" }).query;
+		const queryParamsTypeName = rawQueryParams.length > 0 && tsResolver.resolveQueryParamsName(node, rawQueryParams[0]) !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? tsResolver.resolveQueryParamsName(node, rawQueryParams[0]) : null;
+		const importedTypeNames = [
+			tsResolver.resolveRequestConfigName(node),
+			queryParamsTypeName,
+			...resolveOperationTypeNames(node, tsResolver, {
+				exclude: [queryKeyTypeName],
+				order: "body-response-first",
+				includeParams: false
+			})
+		].filter((name) => Boolean(name));
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+		const fileZod = zodResolver ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+			root,
+			output: pluginZod?.options?.output ?? output,
+			group: pluginZod?.options?.group ?? void 0
+		}) : null;
+		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser);
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: zodSchemaNames,
+					root: meta.file.path,
+					path: fileZod.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ jsx(File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["InfiniteData"],
+					isTypeOnly: true,
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["infiniteQueryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(InfiniteQueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver,
+					cursorParam: infiniteOptions.cursorParam,
+					nextParam: infiniteOptions.nextParam,
+					previousParam: infiniteOptions.previousParam,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["useInfiniteQuery"],
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [
+						"QueryKey",
+						"QueryClient",
+						"InfiniteQueryObserverOptions",
+						"UseInfiniteQueryResult"
+					],
+					path: importPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(InfiniteQuery, {
+					name: queryName,
+					queryOptionsName,
+					queryKeyName,
+					queryKeyTypeName,
+					node,
+					tsResolver,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam,
+					customOptions
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/mutationGenerator.tsx
+/**
+* Built-in generator for `useMutation` hooks. Emits one `useFooMutation` hook
+* per POST/PUT/DELETE operation (configurable via `mutation.methods`) plus
+* the matching `fooMutationKey` / `fooMutationOptions` helpers.
+*/
+const mutationGenerator = defineGenerator({
+	name: "react-query-mutation",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, parser, client, group, customOptions } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+		const queryMethods = new Set(query ? query.methods : []);
+		if (!(mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase()))) return null;
+		const importPath = mutation ? mutation.importPath : "@tanstack/react-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const mutationHookName = resolver.resolveMutationName(node);
+		const mutationTypeName = resolver.resolveMutationTypeName(node);
+		const mutationOptionsName = resolver.resolveMutationOptionsName(node);
+		const mutationKeyName = resolver.resolveMutationKeyName(node);
+		const meta = {
+			file: resolver.resolveFile(operationFileEntry(node, mutationHookName), {
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, {
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+		const fileZod = zodResolver ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+			root,
+			output: pluginZod?.options?.output ?? output,
+			group: pluginZod?.options?.group ?? void 0
+		}) : null;
+		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser);
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: zodSchemaNames,
+					root: meta.file.path,
+					path: fileZod.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ jsx(File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(MutationKey, {
+					name: mutationKeyName,
+					node,
+					transformer: ctx.options.mutationKey
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["mutationOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(MutationOptions, {
+					name: mutationOptionsName,
+					clientName: calledClientName,
+					mutationKeyName,
+					node,
+					tsResolver
+				}),
+				mutation && /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(File.Import, {
+						name: ["useMutation"],
+						path: importPath
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: [
+							"UseMutationOptions",
+							"UseMutationResult",
+							"QueryClient"
+						],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ jsx(Mutation, {
+						name: mutationHookName,
+						typeName: mutationTypeName,
+						mutationOptionsName,
+						mutationKeyName,
+						node,
+						tsResolver,
+						customOptions
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/queryGenerator.tsx
+/**
+* Built-in generator for `useQuery` hooks. Emits one `useFooQuery` hook per
+* GET operation (configurable via `query.methods`) plus the matching
+* `fooQueryKey` / `fooQueryOptions` helpers.
+*/
+const queryGenerator = defineGenerator({
+	name: "react-query",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, parser, client, group, customOptions } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+		const queryMethods = new Set(query ? query.methods : []);
+		const isMutation = mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase());
+		if (!isQuery || isMutation) return null;
+		const importPath = query ? query.importPath : "@tanstack/react-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const queryName = resolver.resolveQueryName(node);
+		const queryOptionsName = resolver.resolveQueryOptionsName(node);
+		const queryKeyName = resolver.resolveQueryKeyName(node);
+		const queryKeyTypeName = resolver.resolveQueryKeyTypeName(node);
+		const meta = {
+			file: resolver.resolveFile(operationFileEntry(node, queryName), {
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, {
+			exclude: [queryKeyTypeName],
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+		const fileZod = zodResolver ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+			root,
+			output: pluginZod?.options?.output ?? output,
+			group: pluginZod?.options?.group ?? void 0
+		}) : null;
+		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser);
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: zodSchemaNames,
+					root: meta.file.path,
+					path: fileZod.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ jsx(File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["queryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(QueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver
+				}),
+				query && /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(File.Import, {
+						name: ["useQuery"],
+						path: importPath
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: [
+							"QueryKey",
+							"QueryClient",
+							"QueryObserverOptions",
+							"UseQueryResult"
+						],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ jsx(Query, {
+						name: queryName,
+						queryOptionsName,
+						queryKeyName,
+						queryKeyTypeName,
+						node,
+						tsResolver,
+						customOptions
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/suspenseInfiniteQueryGenerator.tsx
+/**
+* Built-in generator for `useSuspenseInfiniteQuery` hooks. Enabled when both
+* `suspense` and `infinite` are configured. Combines suspense semantics with
+* cursor-based pagination — handlers throw promises while loading and pull
+* additional pages on demand.
+*/
+const suspenseInfiniteQueryGenerator = defineGenerator({
+	name: "react-suspense-infinite-query",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, infinite, suspense, parser, client, group, customOptions } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+		const queryMethods = new Set(query ? query.methods : []);
+		const isMutation = mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase());
+		const isSuspense = !!suspense;
+		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
+		if (!isQuery || isMutation || !isSuspense || !infiniteOptions) return null;
+		const normalizeKey = (key) => key.replace(/\?$/, "");
+		const queryParamKeys = getOperationParameters(node, { paramsCasing: "original" }).query.map((p) => p.name);
+		const hasQueryParam = infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false;
+		const hasCursorParam = !infiniteOptions.cursorParam || true;
+		if (!hasQueryParam || !hasCursorParam) return null;
+		const importPath = query ? query.importPath : "@tanstack/react-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const queryName = resolver.resolveSuspenseInfiniteQueryName(node);
+		const queryOptionsName = resolver.resolveSuspenseInfiniteQueryOptionsName(node);
+		const queryKeyName = resolver.resolveSuspenseInfiniteQueryKeyName(node);
+		const queryKeyTypeName = resolver.resolveSuspenseInfiniteQueryKeyTypeName(node);
+		const meta = {
+			file: resolver.resolveFile(operationFileEntry(node, queryName), {
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const rawQueryParams = getOperationParameters(node, { paramsCasing: "original" }).query;
+		const queryParamsTypeName = rawQueryParams.length > 0 && tsResolver.resolveQueryParamsName(node, rawQueryParams[0]) !== tsResolver.resolveParamName(node, rawQueryParams[0]) ? tsResolver.resolveQueryParamsName(node, rawQueryParams[0]) : null;
+		const importedTypeNames = [
+			tsResolver.resolveRequestConfigName(node),
+			queryParamsTypeName,
+			...resolveOperationTypeNames(node, tsResolver, {
+				order: "body-response-first",
+				includeParams: false
+			})
+		].filter((name) => Boolean(name));
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+		const fileZod = zodResolver ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+			root,
+			output: pluginZod?.options?.output ?? output,
+			group: pluginZod?.options?.group ?? void 0
+		}) : null;
+		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser);
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: zodSchemaNames,
+					root: meta.file.path,
+					path: fileZod.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ jsx(File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["InfiniteData"],
+					isTypeOnly: true,
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["infiniteQueryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(SuspenseInfiniteQueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver,
+					cursorParam: infiniteOptions.cursorParam,
+					nextParam: infiniteOptions.nextParam,
+					previousParam: infiniteOptions.previousParam,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["useSuspenseInfiniteQuery"],
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [
+						"QueryKey",
+						"QueryClient",
+						"UseSuspenseInfiniteQueryOptions",
+						"UseSuspenseInfiniteQueryResult"
+					],
+					path: importPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(SuspenseInfiniteQuery, {
+					name: queryName,
+					queryOptionsName,
+					queryKeyName,
+					queryKeyTypeName,
+					node,
+					tsResolver,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam,
+					customOptions
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/suspenseQueryGenerator.tsx
+/**
+* Built-in generator for `useSuspenseQuery` hooks. Enabled when
+* `pluginReactQuery({ suspense: {} })`. Emits one `useFooSuspenseQuery` hook
+* per query operation. Suspense queries throw promises while loading and
+* require a `<Suspense>` boundary in the React tree. TanStack Query v5+ only.
+*/
+const suspenseQueryGenerator = defineGenerator({
+	name: "react-suspense-query",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, suspense, parser, client, group, customOptions } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+		const queryMethods = new Set(query ? query.methods : []);
+		const isMutation = mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase());
+		if (!isQuery || isMutation || !!!suspense) return null;
+		const importPath = query ? query.importPath : "@tanstack/react-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const queryName = resolver.resolveSuspenseQueryName(node);
+		const queryOptionsName = resolver.resolveSuspenseQueryOptionsName(node);
+		const queryKeyName = resolver.resolveSuspenseQueryKeyName(node);
+		const queryKeyTypeName = resolver.resolveSuspenseQueryKeyTypeName(node);
+		const meta = {
+			file: resolver.resolveFile(operationFileEntry(node, queryName), {
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, {
+			exclude: [queryKeyTypeName],
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+		const fileZod = zodResolver ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+			root,
+			output: pluginZod?.options?.output ?? output,
+			group: pluginZod?.options?.group ?? void 0
+		}) : null;
+		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, parser);
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: zodSchemaNames,
+					root: meta.file.path,
+					path: fileZod.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ jsx(File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ jsx(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["queryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ jsx(QueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver
+				}),
+				suspense && /* @__PURE__ */ jsxs(Fragment, { children: [
+					/* @__PURE__ */ jsx(File.Import, {
+						name: ["useSuspenseQuery"],
+						path: importPath
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: [
+							"QueryKey",
+							"QueryClient",
+							"UseSuspenseQueryOptions",
+							"UseSuspenseQueryResult"
+						],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ jsx(SuspenseQuery, {
+						name: queryName,
+						queryOptionsName,
+						queryKeyName,
+						queryKeyTypeName,
+						node,
+						tsResolver,
+						customOptions
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
 //#region src/resolvers/resolverReactQuery.ts
 function capitalize(name) {
 	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
@@ -215,10 +2681,8 @@ const pluginReactQuery = definePlugin((options) => {
 	const { output = {
 		path: "hooks",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], parser = false, suspense = {}, infinite = false, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, customOptions, paramsCasing, client, resolver: userResolver, macros: userMacros, generators: userGenerators = [] } = options;
-	const clientName = client?.client ?? "axios";
-	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
-	const selectedGenerators = options.generators ?? [
+	}, group, exclude = [], include, override = [], parser = false, suspense = {}, infinite = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, customOptions, client, resolver: userResolver, macros: userMacros } = options;
+	const selectedGenerators = [
 		queryGenerator,
 		suspenseQueryGenerator,
 		infiniteQueryGenerator,
@@ -237,17 +2701,18 @@ const pluginReactQuery = definePlugin((options) => {
 				...resolverReactQuery,
 				...userResolver
 			} : resolverReactQuery;
+			const resolvedClient = resolveClient({
+				client,
+				pluginNames: (ctx.config.plugins ?? []).map((p) => p.name).filter((name) => Boolean(name))
+			});
+			if (resolvedClient.kind === "error") throw new Error(resolvedClient.message);
+			const resolvedClientDescriptor = {
+				kind: "contract",
+				pluginName: resolvedClient.pluginName
+			};
 			ctx.setOptions({
 				output,
-				client: {
-					bundle: client?.bundle,
-					baseURL: client?.baseURL,
-					client: clientName,
-					clientType: client?.clientType ?? "function",
-					importPath: clientImportPath,
-					dataReturnType: client?.dataReturnType ?? "data",
-					paramsCasing
-				},
+				client: resolvedClientDescriptor,
 				queryKey,
 				query: query === false ? false : {
 					importPath: "@tanstack/react-query",
@@ -279,9 +2744,6 @@ const pluginReactQuery = definePlugin((options) => {
 					...customOptions
 				} : null,
 				parser,
-				paramsType,
-				pathParamsType,
-				paramsCasing,
 				group: groupConfig,
 				exclude,
 				include,
@@ -291,29 +2753,6 @@ const pluginReactQuery = definePlugin((options) => {
 			ctx.setResolver(resolver);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			for (const gen of selectedGenerators) ctx.addGenerator(gen);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
-			const root = path.resolve(ctx.config.root, ctx.config.output.path);
-			const hasClientPlugin = !!ctx.config.plugins?.some((p) => p.name === pluginClientName);
-			if (client?.bundle && !hasClientPlugin && !clientImportPath) ctx.injectFile({
-				baseName: "client.ts",
-				path: path.resolve(root, ".kubb/client.ts"),
-				sources: [ast.factory.createSource({
-					name: "client",
-					nodes: [ast.factory.createText(clientName === "fetch" ? source$1 : source)],
-					isExportable: true,
-					isIndexable: true
-				})]
-			});
-			if (!hasClientPlugin) ctx.injectFile({
-				baseName: "config.ts",
-				path: path.resolve(root, ".kubb/config.ts"),
-				sources: [ast.factory.createSource({
-					name: "config",
-					nodes: [ast.factory.createText(source$2)],
-					isExportable: false,
-					isIndexable: false
-				})]
-			});
 		} }
 	};
 });