@kubb/plugin-react-query 5.0.0-beta.10 → 5.0.0-beta.101

package/dist/index.cjs

@@ -2,200 +2,2319 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_components = require("./components-HwdCDefj.cjs");
-const require_generators = require("./generators-CcOmnTPa.cjs");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let kubb_kit = require("kubb/kit");
 let node_path = require("node:path");
-node_path = require_components.__toESM(node_path, 1);
-let _kubb_core = require("@kubb/core");
-let _kubb_plugin_client = require("@kubb/plugin-client");
-let _kubb_plugin_client_templates_clients_axios_source = require("@kubb/plugin-client/templates/clients/axios.source");
-let _kubb_plugin_client_templates_clients_fetch_source = require("@kubb/plugin-client/templates/clients/fetch.source");
-let _kubb_plugin_client_templates_config_source = require("@kubb/plugin-client/templates/config.source");
+node_path = __toESM(node_path, 1);
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
-let _kubb_plugin_zod = require("@kubb/plugin-zod");
-//#region src/resolvers/resolverReactQuery.ts
-function capitalize(name) {
-	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+let kubb_jsx = require("kubb/jsx");
+let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: 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.file(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;
+	return node.path ? `{@link ${kubb_kit.Url.toPath(node.path)}}` : null;
+}
+/**
+* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
+* are present and the union, default, and form-data flags the client uses to pick one.
+*/
+function buildContentTypeInfo(contentTypes) {
+	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 getContentTypeInfo(node) {
+	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
+}
+/**
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
+*/
+function getResponseContentTypeInfo(node) {
+	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
+}
+function buildRequestConfigType(node) {
+	const request = getContentTypeInfo(node);
+	const response = getResponseContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
+	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : 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) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.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 getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
+}
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
+}
+function resolveSuccessNames(node, resolver) {
+	return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
+}
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const cacheKey = `${node.operationId}\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);
+	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.param.path(node, param)),
+		...query.map((param) => resolver.param.query(node, param)),
+		...header.map((param) => resolver.param.headers(node, param))
+	];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(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/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);
+}
+/**
+* Uppercases only the first character of `text`, leaving the rest untouched.
+* Unlike {@link pascalCase} it never re-splits word boundaries or strips characters.
+*
+* @example
+* `capitalize('getPetById') // 'GetPetById'`
+*/
+function capitalize(text) {
+	return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+//#endregion
+//#region ../../internals/utils/src/strings.ts
+/**
+* Renders a dotted path or string array as an optional-chaining accessor expression rooted at
+* `accessor`. Returns `null` for an empty path.
+*
+* @example
+* ```ts
+* getNestedAccessor('pagination.next.id', 'lastPage')
+* // "lastPage?.['pagination']?.['next']?.['id']"
+* ```
+*/
+function getNestedAccessor(param, accessor) {
+	const parts = Array.isArray(param) ? param : param.split(".");
+	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#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."
+	};
+}
+/**
+* Resolves the contract client during a consumer plugin's setup hook. Extracts the plugin names
+* from the raw `plugins` config, applies {@link resolveClient}, and throws the diagnostic on a
+* misconfiguration so every consumer fails fast with the same message.
+*/
+function resolveContractClient(options) {
+	const { client, plugins = [] } = options;
+	const resolved = resolveClient({
+		client,
+		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
+	});
+	if (resolved.kind === "error") throw new Error(resolved.message);
+	return resolved;
+}
+//#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);
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.name(node.operationId),
+		path: file.path,
+		clientPath: node_path.default.resolve(root, ".kubb/client.ts")
+	};
+}
+//#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$1 = [
+	"path",
+	"query",
+	"body",
+	"headers"
+];
+function maybeValueOrGetter(type) {
+	return `${type} | (() => ${type})`;
+}
+/**
+* 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 `Options`. `keys` narrows the emitted groups, used by the query key which
+* never carries `headers`.
+*
+* By default the whole group is typed as the single `Options` reference. When
+* `memberTypeWrapper` is set, each group is emitted as its own member typed from the matching
+* `Options['<group>']` slice and wrapped, used by vue-query to apply
+* `MaybeRefOrGetter` per group.
+*/
+function buildGroupedRequestParam(node, options) {
+	const { resolver, keys = requestGroupOrder$1, 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 optionsName = resolver.response.options(node);
+	const omittedKeys = requestGroupOrder$1.filter((key) => !keys.includes(key));
+	const optionsType = omittedKeys.length > 0 ? `Omit<${optionsName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : optionsName;
+	if (memberTypeWrapper) {
+		const members = names.map((name) => ({
+			name,
+			type: memberTypeWrapper(`${optionsType}['${name}']`),
+			optional: !requiredByGroup[name]
+		}));
+		return (0, _kubb_plugin_ts.createFunctionParameter)({
+			name: (0, _kubb_plugin_ts.createObjectBindingPattern)({ elements: names.map((name) => ({ name })) }),
+			type: (0, _kubb_plugin_ts.createTypeLiteral)({ members }),
+			optional: false,
+			...isOptional ? { default: "{}" } : {}
+		});
+	}
+	return (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: (0, _kubb_plugin_ts.createObjectBindingPattern)({ elements: names.map((name) => ({ name })) }),
+		type: optionsType,
+		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 (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper
+	}), (0, _kubb_plugin_ts.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.
+*
+* When `unwrapName` is set, each request group is passed as an explicit member unwrapped through it,
+* used by vue-query to resolve refs and getters with `toValue(...)` at call time.
+*
+* @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, unwrapName } = options;
+	const { groups } = getRequestGroupOptionality(node);
+	return `${clientName}({ ${[
+		"...config",
+		...requestGroupOrder$1.filter((key) => groups[key]).map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		signal ? "signal: config.signal ?? signal" : null,
+		"throwOnError: true"
+	].filter((part) => part !== null).join(", ")} })`;
+}
+/**
+* Builds the `TData` / `TError` type expressions shared by every generated hook, joining the resolved
+* success responses into `TData` and wrapping the error responses in `ResponseErrorConfig<...>`.
+*/
+function buildResponseTypes(node, resolver) {
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	return {
+		TData: responseName,
+		TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
+	};
+}
+function resolveFallbackPageParamType(initialPageParam) {
+	if (typeof initialPageParam === "number") return "number";
+	if (typeof initialPageParam === "boolean") return "boolean";
+	if (typeof initialPageParam !== "string") return "unknown";
+	if (!initialPageParam.includes(" as ")) return "string";
+	return initialPageParam.split(" as ").at(-1) ?? "unknown";
+}
+/**
+* Resolves the `TPageParam` generic for the infinite-query hooks. Prefers the type read from the
+* configured `queryParam` on the operation's query object, and falls back to the type inferred from
+* `initialPageParam` when that parameter type is unavailable. Also returns the query params type name
+* so callers can reuse it when rewriting the paginated request.
+*/
+function resolvePageParamType(node, { resolver, initialPageParam, queryParam }) {
+	const firstQueryParam = getOperationParameters(node).query[0];
+	const groupName = firstQueryParam ? resolver.param.query(node, firstQueryParam) : null;
+	const queryParamsTypeName = groupName !== (firstQueryParam ? resolver.param.name(node, firstQueryParam) : null) ? groupName : null;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
+	if (!queryParamType) return {
+		queryParamsTypeName,
+		pageParamType: resolveFallbackPageParamType(initialPageParam)
+	};
+	return {
+		queryParamsTypeName,
+		pageParamType: initialPageParam !== void 0 && initialPageParam !== null ? `NonNullable<${queryParamType}>` : queryParamType
+	};
+}
+/**
+* Applies the shared query defaults during plugin setup: `false` disables query generation, and an
+* object merges over `methods: ['GET']` and the plugin's runtime `importPath`.
+*/
+function resolveQueryConfig(query, options) {
+	if (query === false) return false;
+	return {
+		importPath: options.importPath,
+		methods: ["GET"],
+		...query
+	};
+}
+/**
+* Applies the shared mutation defaults during plugin setup: `false` disables mutation generation,
+* and an object merges over `methods: ['POST', 'PUT', 'PATCH', 'DELETE']` and the plugin's runtime
+* `importPath`.
+*/
+function resolveMutationConfig(mutation, options) {
+	if (mutation === false) return false;
+	return {
+		importPath: options.importPath,
+		methods: [
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE"
+		],
+		...mutation
+	};
+}
+/**
+* Classifies an operation as a query or a mutation from the resolved `query` / `mutation` method lists.
+* `query: false` still marks the operation as a query so the query-family generators keep matching it,
+* and a method already claimed by `query` never counts as a mutation.
+*/
+function classifyOperation(node, { query, mutation }) {
+	const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+	const queryMethods = new Set(query ? query.methods : []);
+	return {
+		isQuery,
+		isMutation: mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
+	};
+}
+/**
+* Applies the shared infinite-query defaults during plugin setup: a falsy value disables infinite
+* queries, and an object merges over `queryParam: 'id'` and `initialPageParam: 0` with the cursor
+* paths cleared.
+*/
+function resolveInfiniteConfig(infinite) {
+	if (!infinite) return false;
+	return {
+		queryParam: "id",
+		initialPageParam: 0,
+		cursorParam: null,
+		nextParam: null,
+		previousParam: null,
+		...infinite
+	};
+}
+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 ?? {};
+}
+/**
+* Build QueryKey params as the grouped `{ path, query, body }` object (NO headers, NO config),
+* typed from the operation's `Options` 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 (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedParam ? [groupedParam] : [] });
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
+const declarationPrinter$7 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter$3 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function InfiniteQueryOptions({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName }) {
+	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver);
+	const { queryParamsTypeName, pageParamType } = resolvePageParamType(node, {
+		resolver: tsResolver,
+		initialPageParam,
+		queryParam
+	});
+	const groupedKeyParam = buildGroupedRequestParam(node, {
+		resolver: tsResolver,
+		keys: [
+			"path",
+			"query",
+			"body"
+		],
+		memberTypeWrapper
+	});
+	const queryKeyParamsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedKeyParam ? [groupedKeyParam] : [] });
+	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
+	const paramsNode = buildQueryOptionsParams(node, {
+		resolver: tsResolver,
+		memberTypeWrapper
+	});
+	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	const queryFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: true,
+		unwrapName
+	})}
+    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}` : "";
+	const queryFnArgs = infiniteOverrideParams ? "{ signal, pageParam }" : "{ signal }";
+	const queryFnStatements = infiniteOverrideParams ? `${infiniteOverrideParams}\n    ${queryFnBody}` : queryFnBody;
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, ${queryKeyType}, ${pageParamType}>({
+  queryKey,
+  queryFn: async (${queryFnArgs}) => {
+    ${queryFnStatements}
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
+`
+		})
+	});
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$6 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const mutationKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	return [`{ url: '${kubb_kit.Url.toPath(node.path)}' }`];
+};
+function MutationKey({ name, node, transformer }) {
+	const paramsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: [] });
+	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	});
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/resolver.ts
+/**
+* Builds the shared query namespace for a variant. Spread the result into
+* `createResolver` once per variant the plugin supports.
+*
+* @example
+* ```ts
+* createResolver<PluginReactQuery>({
+*   query: createQueryResolver(),
+*   suspenseQuery: createQueryResolver('Suspense'),
+* })
+* ```
+*/
+function createQueryResolver(variant = "") {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}${variant}`;
+		},
+		optionsName(node) {
+			return `${this.name(node.operationId)}${variant}QueryOptions`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}${variant}QueryKey`;
+		},
+		keyTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
+		},
+		clientName(node) {
+			return `${this.name(node.operationId)}${variant}`;
+		}
+	};
 }
 /**
-* Naming convention resolver for React Query plugin.
+* Builds the shared mutation namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`optionsName`,
+* `typeName`, `argTypeName`) next to it.
 *
-* Provides default naming helpers using camelCase for functions and file paths.
+* @example
+* ```ts
+* createResolver<PluginSwr>({ mutation: { ...createMutationResolver(), argTypeName(node) {...} } })
+* ```
+*/
+function createMutationResolver() {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}MutationKey`;
+		}
+	};
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/QueryKey.tsx
+const declarationPrinter$5 = (0, _kubb_plugin_ts.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: '${kubb_kit.Url.toPath(node.path)}', params: path }` : `{ url: '${kubb_kit.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$5.print(paramsNode) ?? "";
+	const keys = (transformer ?? queryKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name: typeName,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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 = (0, kubb_kit.defineGenerator)({
+	name: "react-query-custom-hook-options-file",
+	renderer: kubb_jsx.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.hook.optionsName();
+		const customHookOptionsName = resolver.hook.customOptionsName();
+		const reactQueryImportPath = query ? query.importPath : "@tanstack/react-query";
+		let hookFilePath;
+		const firstNode = nodes[0];
+		if (firstNode) {
+			const hookName = resolver.query.name(firstNode);
+			hookFilePath = resolver.file({
+				name: hookName,
+				extname: ".ts",
+				tag: firstNode.tags[0] ?? "default",
+				path: firstNode.path,
+				root,
+				output,
+				group: group ?? void 0
+			}).path;
+		} else hookFilePath = node_path.default.resolve(root, "index.ts");
+		const ensureExtension = (filePath, extname) => {
+			if (node_path.default.extname(filePath) === "") return filePath + extname;
+			return filePath;
+		};
+		const basePath = node_path.default.dirname(hookFilePath);
+		const actualFilePath = ensureExtension(importPath, ".ts");
+		const file = {
+			baseName: node_path.default.basename(actualFilePath),
+			name: node_path.default.basename(actualFilePath, node_path.default.extname(actualFilePath)),
+			path: node_path.default.resolve(basePath, actualFilePath)
+		};
+		if (node_fs.default.existsSync(file.path)) return null;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: file.baseName,
+			path: file.path,
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["QueryClient"],
+					path: reactQueryImportPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["useQueryClient"],
+					path: reactQueryImportPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [hookOptionsName],
+					root: file.path,
+					path: node_path.default.resolve(root, "./index.ts")
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File.Source, {
+					name: file.name,
+					isExportable: true,
+					isIndexable: true,
+					children: [/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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/utils.ts
+const requestGroupOrder = [
+	"path",
+	"query",
+	"body",
+	"headers"
+];
+/**
+* Builds the object literal that resolves each request group to a concrete value, unwrapping a getter
+* once before the value reaches the plain `queryKey`/`queryOptions` helpers. A getter must never reach a
+* React Query key, which is hashed structurally. Returns `null` when the operation carries no request group.
 *
 * @example
-* `resolverReactQuery.default('list pets', 'function')  // → 'listPets'`
+* ```ts
+* buildResolvedRequestParams(node) // { path: typeof path === 'function' ? path() : path }
+* ```
 */
-const resolverReactQuery = (0, _kubb_core.defineResolver)(() => ({
-	name: "default",
+function buildResolvedRequestParams(node) {
+	const groups = getRequestGroups(node);
+	const names = requestGroupOrder.filter((key) => groups[key]);
+	if (names.length === 0) return null;
+	return `{ ${names.map((name) => `${name}: typeof ${name} === 'function' ? ${name}() : ${name}`).join(", ")} }`;
+}
+//#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 = (0, kubb_kit.defineGenerator)({
+	name: "react-query-hook-options",
+	renderer: kubb_jsx.jsxRenderer,
+	operations(nodes, ctx) {
+		const { resolver, config, root } = ctx;
+		const { output, customOptions, query, mutation, suspense, infinite, group, override, hooks } = ctx.options;
+		if (!customOptions || !hooks) return null;
+		const name = resolver.hook.optionsName();
+		const resolvedFile = resolver.file({
+			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 (!kubb_kit.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.query.optionsName(node);
+				const queryHookName = resolver.query.name(node);
+				const queryHookFile = resolver.file({
+					...operationFileEntry(node, queryHookName),
+					root,
+					output,
+					group: group ?? void 0
+				});
+				imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [queryOptionsName],
+					root: hookOptionsFile.path,
+					path: queryHookFile.path
+				}));
+				hookOptions[queryHookName] = `Partial<ReturnType<typeof ${queryOptionsName}>>`;
+				if (isSuspenseOp) {
+					const suspenseOptionsName = resolver.suspenseQuery.optionsName(node);
+					const suspenseHookName = resolver.suspenseQuery.name(node);
+					const suspenseHookFile = resolver.file({
+						...operationFileEntry(node, suspenseHookName),
+						root,
+						output,
+						group: group ?? void 0
+					});
+					imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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).query.map((p) => p.name);
+					if (nodeInfiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === nodeInfiniteOptions.queryParam) : false) {
+						const infiniteOptionsName = resolver.infiniteQuery.optionsName(node);
+						const infiniteHookName = resolver.infiniteQuery.name(node);
+						const infiniteHookFile = resolver.file({
+							...operationFileEntry(node, infiniteHookName),
+							root,
+							output,
+							group: group ?? void 0
+						});
+						imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+							name: [infiniteOptionsName],
+							root: hookOptionsFile.path,
+							path: infiniteHookFile.path
+						}));
+						hookOptions[infiniteHookName] = `Partial<ReturnType<typeof ${infiniteOptionsName}>>`;
+						if (isSuspenseOp) {
+							const suspenseInfiniteOptionsName = resolver.suspenseInfiniteQuery.optionsName(node);
+							const suspenseInfiniteHookName = resolver.suspenseInfiniteQuery.name(node);
+							const suspenseInfiniteHookFile = resolver.file({
+								...operationFileEntry(node, suspenseInfiniteHookName),
+								root,
+								output,
+								group: group ?? void 0
+							});
+							imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+								name: [suspenseInfiniteOptionsName],
+								root: hookOptionsFile.path,
+								path: suspenseInfiniteHookFile.path
+							}));
+							hookOptions[suspenseInfiniteHookName] = `Partial<ReturnType<typeof ${suspenseInfiniteOptionsName}>>`;
+						}
+					}
+				}
+			}
+			if (isMutationOp) {
+				const mutationOptionsName = resolver.mutation.optionsName(node);
+				const mutationHookName = resolver.mutation.name(node);
+				const mutationHookFile = resolver.file({
+					...operationFileEntry(node, mutationHookName),
+					root,
+					output,
+					group: group ?? void 0
+				});
+				imports.push(/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [mutationOptionsName],
+					root: hookOptionsFile.path,
+					path: mutationHookFile.path
+				}));
+				hookOptions[mutationHookName] = `Partial<ReturnType<typeof ${mutationOptionsName}>>`;
+			}
+		}
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: hookOptionsFile.baseName,
+			path: hookOptionsFile.path,
+			meta: hookOptionsFile.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: hookOptionsFile.path,
+					baseName: hookOptionsFile.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: hookOptionsFile.path,
+					baseName: hookOptionsFile.baseName
+				}
+			}),
+			children: [imports, /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+				name,
+				isExportable: true,
+				isIndexable: true,
+				isTypeOnly: true,
+				children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Type, {
+					export: true,
+					name,
+					children: `{ ${Object.keys(hookOptions).map((key) => `${JSON.stringify(key)}: ${hookOptions[key]}`).join(", ")} }`
+				})
+			})]
+		});
+	}
+});
+//#endregion
+//#region src/components/InfiniteQuery.tsx
+const declarationPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function buildInfiniteQueryParamsNode(node, options) {
+	const { resolver, pageParamGeneric, observerOptionsName } = options;
+	const optionsParam = (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "options",
+		type: `{
+  query?: Partial<${observerOptionsName}<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper: maybeValueOrGetter
+	}), optionsParam].filter((param) => param !== null) });
+}
+function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, initialPageParam, queryParam, customOptions, suspense }) {
+	const { TData: responseType, TError: errorType } = buildResponseTypes(node, tsResolver);
+	const { pageParamType } = resolvePageParamType(node, {
+		resolver: tsResolver,
+		initialPageParam,
+		queryParam
+	});
+	const hookName = suspense ? "useSuspenseInfiniteQuery" : "useInfiniteQuery";
+	const observerOptionsName = suspense ? "UseSuspenseInfiniteQueryOptions" : "InfiniteQueryObserverOptions";
+	const returnType = `${suspense ? "UseSuspenseInfiniteQueryResult" : "UseInfiniteQueryResult"}<TData, TError> & { queryKey: TQueryKey }`;
+	const generics = [
+		`TQueryFnData = ${responseType}`,
+		`TError = ${errorType}`,
+		"TData = InfiniteData<TQueryFnData>",
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
+		`TPageParam = ${pageParamType}`
+	];
+	const resolvedParams = buildResolvedRequestParams(node);
+	const queryKeyArgs = resolvedParams ? "resolvedParams" : "";
+	const queryOptionsArgs = resolvedParams ? "resolvedParams, config" : "config";
+	const paramsNode = buildInfiniteQueryParamsNode(node, {
+		resolver: tsResolver,
+		pageParamGeneric: "TPageParam",
+		observerOptionsName
+	});
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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${resolvedParams ? `\n       const resolvedParams = ${resolvedParams}` : ""}
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyArgs})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+
+       const queryResult = ${hookName}({
+        ...${queryOptionsName}(${queryOptionsArgs}),${customOptions ? "\n        ...customOptions," : ""}
+        ...resolvedOptions,
+        queryKey,
+       } as unknown as ${observerOptionsName}<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
+
+       queryResult.queryKey = queryKey as TQueryKey
+
+       return queryResult
+       `
+		})
+	});
+}
+//#endregion
+//#region src/components/MutationOptions.tsx
+const declarationPrinter$3 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function buildMutationConfigParamsNode(node) {
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "config",
+		type: buildRequestConfigType(node),
+		default: "{}"
+	})] });
+}
+function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const configParamsNode = buildMutationConfigParamsNode(node);
+	const paramsSignature = declarationPrinter$3.print(configParamsNode) ?? "";
+	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
+	const hasMutationParams = groupedParam !== null;
+	const groupedParamsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedParam ? [groupedParam] : [] });
+	const TRequest = hasMutationParams ? tsResolver.response.options(node) : "undefined";
+	const argBindingStr = hasMutationParams ? callPrinter$2.print(groupedParamsNode) ?? "" : "_";
+	const mutationFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: false
+	})}
+          return data`;
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function resolveMutationRequestType(node, resolver) {
+	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
+}
+function buildMutationParamsNode(node, options) {
+	const { resolver } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver);
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "options",
+		type: `{
+  mutation?: UseMutationOptions<${[
+			TData,
+			TError,
+			resolveMutationRequestType(node, resolver),
+			"TContext"
+		].join(", ")}> & { client?: QueryClient },
+  client?: ${buildRequestConfigType(node)},
+}`,
+		default: "{}"
+	})] });
+}
+function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName, customOptions }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const generics = [
+		TData,
+		TError,
+		resolveMutationRequestType(node, tsResolver),
+		"TContext"
+	].join(", ");
+	const returnType = `UseMutationResult<${generics}>`;
+	const mutationOptionsConfigNode = buildMutationConfigParamsNode(node);
+	const mutationOptionsParamsCall = callPrinter$1.print(mutationOptionsConfigNode) ?? "";
+	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function buildQueryParamsNode(node, options) {
+	const { resolver, observerOptionsType } = options;
+	const optionsParam = (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "options",
+		type: `{
+  query?: Partial<${observerOptionsType}> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper: maybeValueOrGetter
+	}), optionsParam].filter((param) => param !== null) });
+}
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions, suspense }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const hookName = suspense ? "useSuspenseQuery" : "useQuery";
+	const observerOptionsName = suspense ? "UseSuspenseQueryOptions" : "QueryObserverOptions";
+	const observerOptionsType = suspense ? `${observerOptionsName}<${[
+		TData,
+		TError,
+		"TData",
+		"TQueryKey"
+	].join(", ")}>` : `${observerOptionsName}<${[
+		TData,
+		TError,
+		"TData",
+		"TQueryData",
+		"TQueryKey"
+	].join(", ")}>`;
+	const returnType = `${suspense ? "UseSuspenseQueryResult" : "UseQueryResult"}<TData, ${TError}> & { queryKey: TQueryKey }`;
+	const generics = suspense ? [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`] : [
+		`TData = ${TData}`,
+		`TQueryData = ${TData}`,
+		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
+	];
+	const resolvedParams = buildResolvedRequestParams(node);
+	const queryKeyArgs = resolvedParams ? "resolvedParams" : "";
+	const queryOptionsArgs = resolvedParams ? "resolvedParams, config" : "config";
+	const paramsNode = buildQueryParamsNode(node, {
+		resolver: tsResolver,
+		observerOptionsType
+	});
+	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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${resolvedParams ? `\n       const resolvedParams = ${resolvedParams}` : ""}
+       const queryKey = resolvedOptions?.queryKey ?? ${queryKeyName}(${queryKeyArgs})${customOptions ? `\n       const customOptions = ${customOptions.name}({ hookName: '${name}', operationId: '${node.operationId}' })` : ""}
+
+       const queryResult = ${hookName}({
+        ...${queryOptionsName}(${queryOptionsArgs}),${customOptions ? "\n        ...customOptions," : ""}
+        ...resolvedOptions,
+        queryKey,
+       } as unknown as ${observerOptionsName}, queryClient) as ${returnType}
+
+       queryResult.queryKey = queryKey as TQueryKey
+
+       return queryResult
+       `
+		})
+	});
+}
+//#endregion
+//#region src/components/QueryOptions.tsx
+const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function QueryOptions({ name, clientName, node, tsResolver, queryKeyName }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
+	const paramsNode = buildQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	const queryFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: true
+	})}
+          return data`;
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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/generators/infiniteQueryGenerator.tsx
+/**
+* Built-in generator for `useInfiniteQuery` hooks. Enabled when
+* `pluginReactQuery({ infinite: { ... }, hooks: true })`. Emits one
+* `useFooInfiniteQuery` hook per query operation, wiring the configured
+* `nextParam` / `previousParam` paths into TanStack Query's cursor-based
+* pagination.
+*/
+const infiniteQueryGenerator = (0, kubb_kit.defineGenerator)({
+	name: "react-infinite-query",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, infinite, client, group, customOptions, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isQuery, isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
+		if (!isQuery || isMutation || !infiniteOptions || !hooks) return null;
+		const normalizeKey = (key) => key.replace(/\?$/, "");
+		const queryParamKeys = getOperationParameters(node).query.map((p) => p.name);
+		if (!(infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false)) 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.infiniteQuery.name(node);
+		const queryOptionsName = resolver.infiniteQuery.optionsName(node);
+		const queryKeyName = resolver.infiniteQuery.keyName(node);
+		const queryKeyTypeName = resolver.infiniteQuery.keyTypeName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, queryName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const { queryParamsTypeName } = resolvePageParamType(node, {
+			resolver: tsResolver,
+			initialPageParam: infiniteOptions.initialPageParam,
+			queryParam: infiniteOptions.queryParam
+		});
+		const importedTypeNames = [
+			tsResolver.response.options(node),
+			queryParamsTypeName,
+			...resolveOperationTypeNames(node, tsResolver, {
+				exclude: [queryKeyTypeName],
+				order: "body-response-first",
+				includeParams: false
+			})
+		].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["InfiniteData"],
+					isTypeOnly: true,
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["infiniteQueryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["useInfiniteQuery"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [
+						"QueryKey",
+						"QueryClient",
+						"InfiniteQueryObserverOptions",
+						"UseInfiniteQueryResult"
+					],
+					path: importPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.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 = (0, kubb_kit.defineGenerator)({
+	name: "react-query-mutation",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, client, group, customOptions, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		if (!isMutation) 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.mutation.name(node);
+		const mutationTypeName = resolver.mutation.typeName(node);
+		const mutationOptionsName = resolver.mutation.optionsName(node);
+		const mutationKeyName = resolver.mutation.keyName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, mutationHookName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(MutationKey, {
+					name: mutationKeyName,
+					node,
+					transformer: ctx.options.mutationKey
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["mutationOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(MutationOptions, {
+					name: mutationOptionsName,
+					clientName: calledClientName,
+					mutationKeyName,
+					node,
+					tsResolver
+				}),
+				mutation && hooks && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: ["useMutation"],
+						path: importPath
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: [
+							"UseMutationOptions",
+							"UseMutationResult",
+							"QueryClient"
+						],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.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 = (0, kubb_kit.defineGenerator)({
+	name: "react-query",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, client, group, customOptions, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isQuery, isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		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.query.name(node);
+		const queryOptionsName = resolver.query.optionsName(node);
+		const queryKeyName = resolver.query.keyName(node);
+		const queryKeyTypeName = resolver.query.keyTypeName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, queryName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
+			exclude: [queryKeyTypeName],
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["queryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver
+				}),
+				query && hooks && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: ["useQuery"],
+						path: importPath
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: [
+							"QueryKey",
+							"QueryClient",
+							"QueryObserverOptions",
+							"UseQueryResult"
+						],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Query, {
+						name: queryName,
+						queryOptionsName,
+						queryKeyName,
+						queryKeyTypeName,
+						node,
+						tsResolver,
+						customOptions
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/suspenseInfiniteQueryGenerator.tsx
+/**
+* Built-in generator for `useSuspenseInfiniteQuery` hooks. Enabled when
+* `suspense`, `infinite`, and `hooks` are all configured. Combines suspense
+* semantics with cursor-based pagination. Handlers throw promises while
+* loading and pull additional pages on demand.
+*/
+const suspenseInfiniteQueryGenerator = (0, kubb_kit.defineGenerator)({
+	name: "react-suspense-infinite-query",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, infinite, suspense, client, group, customOptions, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isQuery, isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		const isSuspense = !!suspense;
+		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
+		if (!isQuery || isMutation || !isSuspense || !infiniteOptions || !hooks) return null;
+		const normalizeKey = (key) => key.replace(/\?$/, "");
+		const queryParamKeys = getOperationParameters(node).query.map((p) => p.name);
+		if (!(infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false)) 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.suspenseInfiniteQuery.name(node);
+		const queryOptionsName = resolver.suspenseInfiniteQuery.optionsName(node);
+		const queryKeyName = resolver.suspenseInfiniteQuery.keyName(node);
+		const queryKeyTypeName = resolver.suspenseInfiniteQuery.keyTypeName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, queryName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const rawQueryParams = getOperationParameters(node).query;
+		const queryParamsTypeName = rawQueryParams.length > 0 && tsResolver.param.query(node, rawQueryParams[0]) !== tsResolver.param.name(node, rawQueryParams[0]) ? tsResolver.param.query(node, rawQueryParams[0]) : null;
+		const importedTypeNames = [
+			tsResolver.response.options(node),
+			queryParamsTypeName,
+			...resolveOperationTypeNames(node, tsResolver, {
+				order: "body-response-first",
+				includeParams: false
+			})
+		].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["InfiniteData"],
+					isTypeOnly: true,
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["infiniteQueryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["useSuspenseInfiniteQuery"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [
+						"QueryKey",
+						"QueryClient",
+						"UseSuspenseInfiniteQueryOptions",
+						"UseSuspenseInfiniteQueryResult"
+					],
+					path: importPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(InfiniteQuery, {
+					name: queryName,
+					queryOptionsName,
+					queryKeyName,
+					queryKeyTypeName,
+					node,
+					tsResolver,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam,
+					customOptions,
+					suspense: true
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/suspenseQueryGenerator.tsx
+/**
+* Built-in generator for `useSuspenseQuery` hooks. Enabled when
+* `pluginReactQuery({ suspense: {}, hooks: true })`. 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 = (0, kubb_kit.defineGenerator)({
+	name: "react-suspense-query",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, suspense, client, group, customOptions, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isQuery, isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		if (!isQuery || isMutation || !!!suspense || !hooks) 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.suspenseQuery.name(node);
+		const queryOptionsName = resolver.suspenseQuery.optionsName(node);
+		const queryKeyName = resolver.suspenseQuery.keyName(node);
+		const queryKeyTypeName = resolver.suspenseQuery.keyTypeName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, queryName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
+			exclude: [queryKeyTypeName],
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				customOptions && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["queryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["useSuspenseQuery"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [
+						"QueryKey",
+						"QueryClient",
+						"UseSuspenseQueryOptions",
+						"UseSuspenseQueryResult"
+					],
+					path: importPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Query, {
+					name: queryName,
+					queryOptionsName,
+					queryKeyName,
+					queryKeyTypeName,
+					node,
+					tsResolver,
+					customOptions,
+					suspense: true
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverReactQuery.ts
+/**
+* Default resolver used by `@kubb/plugin-react-query`. Decides the names and
+* file paths for every generated TanStack Query hook (`useFoo`,
+* `useFooSuspense`, `useFooInfinite`, ...) and its companion helpers
+* (`fooQueryKey`, `fooQueryOptions`).
+*
+* Functions and files use the built-in camelCase casing; hooks get the `use`
+* prefix; suspense and infinite variants are suffixed with `Suspense`/`Infinite`.
+*
+* @example Resolve hook and helper names
+* ```ts
+* import { resolverReactQuery } from '@kubb/plugin-react-query'
+*
+* resolverReactQuery.query.name(operationNode)       // 'useGetPetById'
+* resolverReactQuery.mutation.name(operationNode)    // 'useUpdatePet'
+* resolverReactQuery.query.keyName(operationNode)     // 'getPetByIdQueryKey'
+* resolverReactQuery.query.optionsName(operationNode) // 'getPetByIdQueryOptions'
+* ```
+*/
+const resolverReactQuery = (0, kubb_kit.createResolver)({
 	pluginName: "plugin-react-query",
-	default(name, type) {
-		return require_components.camelCase(name, { isFile: type === "file" });
-	},
-	resolveName(name) {
-		return this.default(name, "function");
-	},
-	resolvePathName(name, type) {
-		return this.default(name, type);
-	},
-	resolveQueryName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}`;
-	},
-	resolveSuspenseQueryName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}Suspense`;
-	},
-	resolveInfiniteQueryName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}Infinite`;
-	},
-	resolveSuspenseInfiniteQueryName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}SuspenseInfinite`;
-	},
-	resolveMutationName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}`;
-	},
-	resolveQueryOptionsName(node) {
-		return `${this.resolveName(node.operationId)}QueryOptions`;
-	},
-	resolveSuspenseQueryOptionsName(node) {
-		return `${this.resolveName(node.operationId)}SuspenseQueryOptions`;
-	},
-	resolveInfiniteQueryOptionsName(node) {
-		return `${this.resolveName(node.operationId)}InfiniteQueryOptions`;
-	},
-	resolveSuspenseInfiniteQueryOptionsName(node) {
-		return `${this.resolveName(node.operationId)}SuspenseInfiniteQueryOptions`;
-	},
-	resolveMutationOptionsName(node) {
-		return `${this.resolveName(node.operationId)}MutationOptions`;
-	},
-	resolveQueryKeyName(node) {
-		return `${this.resolveName(node.operationId)}QueryKey`;
-	},
-	resolveSuspenseQueryKeyName(node) {
-		return `${this.resolveName(node.operationId)}SuspenseQueryKey`;
-	},
-	resolveInfiniteQueryKeyName(node) {
-		return `${this.resolveName(node.operationId)}InfiniteQueryKey`;
-	},
-	resolveSuspenseInfiniteQueryKeyName(node) {
-		return `${this.resolveName(node.operationId)}SuspenseInfiniteQueryKey`;
-	},
-	resolveMutationKeyName(node) {
-		return `${this.resolveName(node.operationId)}MutationKey`;
-	},
-	resolveQueryKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}QueryKey`;
-	},
-	resolveSuspenseQueryKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}SuspenseQueryKey`;
-	},
-	resolveInfiniteQueryKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}InfiniteQueryKey`;
-	},
-	resolveSuspenseInfiniteQueryKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}SuspenseInfiniteQueryKey`;
-	},
-	resolveMutationTypeName(node) {
-		return capitalize(this.resolveName(node.operationId));
-	},
-	resolveClientName(node) {
-		return this.resolveName(node.operationId);
-	},
-	resolveSuspenseClientName(node) {
-		return `${this.resolveName(node.operationId)}Suspense`;
-	},
-	resolveInfiniteClientName(node) {
-		return `${this.resolveName(node.operationId)}Infinite`;
-	},
-	resolveSuspenseInfiniteClientName(node) {
-		return `${this.resolveName(node.operationId)}SuspenseInfinite`;
-	},
-	resolveHookOptionsName() {
-		return "HookOptions";
+	query: createQueryResolver(),
+	suspenseQuery: createQueryResolver("Suspense"),
+	infiniteQuery: createQueryResolver("Infinite"),
+	suspenseInfiniteQuery: createQueryResolver("SuspenseInfinite"),
+	mutation: {
+		...createMutationResolver(),
+		optionsName(node) {
+			return `${this.name(node.operationId)}MutationOptions`;
+		},
+		typeName(node) {
+			return capitalize(this.name(node.operationId));
+		}
 	},
-	resolveCustomHookOptionsName() {
-		return "getCustomHookOptions";
+	hook: {
+		optionsName() {
+			return "HookOptions";
+		},
+		customOptionsName() {
+			return "getCustomHookOptions";
+		}
 	}
-}));
+});
 //#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-react-query`. Used for driver lookups
+* and cross-plugin dependency references.
+*/
 const pluginReactQueryName = "plugin-react-query";
-const pluginReactQuery = (0, _kubb_core.definePlugin)((options) => {
+/**
+* Generates one TanStack Query hook per OpenAPI operation for React. Queries
+* become `useFoo`, with `useFooSuspense` and `useFooInfinite` variants.
+* Mutations become `useFoo`. Each hook is fully typed: query keys, input
+* variables, response data, and error shape all come from the spec.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginReactQuery } from '@kubb/plugin-react-query'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginReactQuery({
+*       output: { path: './hooks' },
+*       suspense: {},
+*     }),
+*   ],
+* })
+* ```
+*/
+const pluginReactQuery = (0, kubb_kit.definePlugin)((options) => {
 	const { output = {
 		path: "hooks",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], parser = "client", suspense = {}, infinite = false, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", mutation = {}, query = {}, mutationKey = require_components.mutationKeyTransformer, queryKey = require_components.queryKeyTransformer, customOptions, paramsCasing, client, resolver: userResolver, transformer: userTransformer, 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 ?? [
-		require_generators.queryGenerator,
-		require_generators.suspenseQueryGenerator,
-		require_generators.infiniteQueryGenerator,
-		require_generators.suspenseInfiniteQueryGenerator,
-		require_generators.mutationGenerator,
-		require_generators.hookOptionsGenerator,
-		require_generators.customHookOptionsFileGenerator
-	].filter((generator) => Boolean(generator));
-	const groupConfig = group ? {
-		...group,
-		name: group.name ? group.name : (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${require_components.camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], suspense = false, infinite = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, customOptions, hooks = false, client, resolver: userResolver, macros: userMacros } = options;
+	const selectedGenerators = [
+		queryGenerator,
+		suspenseQueryGenerator,
+		infiniteQueryGenerator,
+		suspenseInfiniteQueryGenerator,
+		mutationGenerator,
+		hookOptionsGenerator,
+		customHookOptionsFileGenerator
+	];
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginReactQueryName,
 		options,
-		dependencies: [_kubb_plugin_ts.pluginTsName, parser === "zod" ? _kubb_plugin_zod.pluginZodName : void 0].filter((dependency) => Boolean(dependency)),
+		dependencies: [_kubb_plugin_ts.pluginTsName],
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverReactQuery,
-				...userResolver
-			} : resolverReactQuery;
+			const resolver = userResolver ? kubb_kit.Resolver.merge(resolverReactQuery, userResolver) : resolverReactQuery;
 			ctx.setOptions({
 				output,
-				client: {
-					bundle: client?.bundle,
-					baseURL: client?.baseURL,
-					client: clientName,
-					clientType: client?.clientType ?? "function",
-					importPath: clientImportPath,
-					dataReturnType: client?.dataReturnType ?? "data",
-					paramsCasing
-				},
+				client: resolveContractClient({
+					client,
+					plugins: ctx.config.plugins
+				}),
 				queryKey,
-				query: query === false ? false : {
-					importPath: "@tanstack/react-query",
-					methods: ["get"],
-					...query
-				},
+				query: resolveQueryConfig(query, { importPath: "@tanstack/react-query" }),
 				mutationKey,
-				mutation: mutation === false ? false : {
-					importPath: "@tanstack/react-query",
-					methods: [
-						"post",
-						"put",
-						"patch",
-						"delete"
-					],
-					...mutation
-				},
-				infinite: infinite ? {
-					queryParam: "id",
-					initialPageParam: 0,
-					cursorParam: void 0,
-					nextParam: void 0,
-					previousParam: void 0,
-					...infinite
-				} : false,
+				mutation: resolveMutationConfig(mutation, { importPath: "@tanstack/react-query" }),
+				infinite: resolveInfiniteConfig(infinite),
 				suspense,
 				customOptions: customOptions ? {
 					name: "useCustomHookOptions",
 					...customOptions
-				} : void 0,
-				parser,
-				paramsType,
-				pathParamsType,
-				paramsCasing,
+				} : null,
+				hooks,
 				group: groupConfig,
 				exclude,
 				include,
@@ -203,31 +2322,8 @@ const pluginReactQuery = (0, _kubb_core.definePlugin)((options) => {
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
-			for (const gen of selectedGenerators) ctx.addGenerator(gen);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
-			const root = node_path.default.resolve(ctx.config.root, ctx.config.output.path);
-			const hasClientPlugin = !!ctx.config.plugins?.some((p) => p.name === _kubb_plugin_client.pluginClientName);
-			if (client?.bundle && !hasClientPlugin && !clientImportPath) ctx.injectFile({
-				baseName: "fetch.ts",
-				path: node_path.default.resolve(root, ".kubb/fetch.ts"),
-				sources: [_kubb_core.ast.createSource({
-					name: "fetch",
-					nodes: [_kubb_core.ast.createText(clientName === "fetch" ? _kubb_plugin_client_templates_clients_fetch_source.source : _kubb_plugin_client_templates_clients_axios_source.source)],
-					isExportable: true,
-					isIndexable: true
-				})]
-			});
-			if (!hasClientPlugin) ctx.injectFile({
-				baseName: "config.ts",
-				path: node_path.default.resolve(root, ".kubb/config.ts"),
-				sources: [_kubb_core.ast.createSource({
-					name: "config",
-					nodes: [_kubb_core.ast.createText(_kubb_plugin_client_templates_config_source.source)],
-					isExportable: false,
-					isIndexable: false
-				})]
-			});
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(...selectedGenerators);
 		} }
 	};
 });
@@ -235,5 +2331,6 @@ const pluginReactQuery = (0, _kubb_core.definePlugin)((options) => {
 exports.default = pluginReactQuery;
 exports.pluginReactQuery = pluginReactQuery;
 exports.pluginReactQueryName = pluginReactQueryName;
+exports.resolverReactQuery = resolverReactQuery;
 
 //# sourceMappingURL=index.cjs.map