@kubb/plugin-react-query 5.5.0 → 5.5.1

package/dist/index.js

@@ -1,28 +1,10 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
-import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
+import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 import fs from "node:fs";
-//#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
@@ -92,12 +74,12 @@ function getContentTypeInfo(node) {
 function getResponseContentTypeInfo(node) {
 	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
 }
+const requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 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;
+	return members.length ? `${requestConfigBaseType} & { contentType?: { ${members.join("; ")} } }` : requestConfigBaseType;
 }
 /**
 * Builds the `client?:` option type shared by the generated query hooks (`useQuery`,
@@ -106,7 +88,7 @@ function buildRequestConfigType(node) {
 * content type for.
 */
 function buildClientOptionType() {
-	return `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	return requestConfigBaseType;
 }
 /**
 * Which of the grouped request options an operation carries.
@@ -166,11 +148,19 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
+	const group = (location) => {
+		const seen = /* @__PURE__ */ new Set();
+		return node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		});
+	};
 	const groups = {
-		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"))
+		path: group("path"),
+		query: group("query"),
+		header: group("header"),
+		cookie: group("cookie")
 	};
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
@@ -330,7 +320,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.5.0";
+var version = "5.5.1";
 //#endregion
 //#region ../../internals/client/src/resolveClient.ts
 /**
@@ -374,7 +364,7 @@ const contractPlugins = [
 * @example
 * ```ts
 * resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
-* // { kind: 'error', message: 'No client plugin is registered…' }
+* // { kind: 'error', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
 * ```
 */
 function resolveClient(options) {
@@ -384,7 +374,9 @@ function resolveClient(options) {
 		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.`
+			code: Diagnostics.code.missingDependency,
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
+			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
 		};
 		return {
 			kind: "contract",
@@ -393,7 +385,9 @@ function resolveClient(options) {
 	}
 	if (client !== void 0) return {
 		kind: "error",
-		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'. Drop \`client\` to use the registered client plugin.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
+		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
 	};
 	const registered = contractPlugins.filter(has);
 	if (registered.length === 1) return {
@@ -402,25 +396,40 @@ function resolveClient(options) {
 	};
 	if (registered.length > 1) return {
 		kind: "error",
-		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios' | 'client'\` to choose which client the hooks call, or register a single client plugin.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
+		help: "Set `client: 'fetch' | 'axios' | 'client'` 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`, `@kubb/plugin-fetch`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
+		code: Diagnostics.code.missingDependency,
+		message: "No client plugin is registered.",
+		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` 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.
+* Resolves the contract client during a consumer plugin's setup hook.
+* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
+* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
+* fails fast with the same message.
 */
 function resolveContractClient(options) {
-	const { client, plugins = [] } = options;
+	const { plugin, 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);
+	if (resolved.kind === "error") {
+		const { code, message, help } = resolved;
+		throw new Diagnostics.Error({
+			code,
+			severity: "error",
+			message,
+			help,
+			location: { kind: "config" },
+			plugin
+		});
+	}
 	return resolved;
 }
 //#endregion
@@ -484,12 +493,101 @@ function resolveClientOperation(options) {
 	});
 }
 //#endregion
+//#region ../../internals/tanstack-query/src/components/HookFile.tsx
+/**
+* Resolves what every TanStack hook file shares: its file, the `@kubb/plugin-ts` file and type names, banner and footer.
+*/
+function resolveHookFile(node, ctx, options) {
+	const { name, output, group, contractOp, keyTypeName, extraTypeNames = [] } = options;
+	const { config, root, resolver } = ctx;
+	const pluginTs = ctx.requirePlugin(pluginTsName);
+	const tsResolver = ctx.driver.getResolver(pluginTsName);
+	const file = resolver.file({
+		...operationFileEntry(node, name),
+		root,
+		output,
+		group: group ?? void 0
+	});
+	const fileTs = resolveDependencyOperationFile({
+		cache: ctx.cache,
+		node,
+		resolver: tsResolver,
+		root,
+		output: pluginTs.options?.output ?? output,
+		group: pluginTs.options?.group
+	});
+	const importedTypeNames = [
+		tsResolver.response.options(node),
+		...extraTypeNames,
+		...resolveOperationTypeNames(node, tsResolver, {
+			exclude: keyTypeName ? [keyTypeName] : void 0,
+			order: "body-response-first",
+			includeParams: false
+		})
+	].filter((typeName) => Boolean(typeName));
+	const fileMeta = {
+		path: file.path,
+		baseName: file.baseName
+	};
+	return {
+		file,
+		fileTs,
+		tsResolver,
+		contractOp,
+		importedTypeNames,
+		banner: resolver.default.banner(ctx.meta, {
+			output,
+			config,
+			file: fileMeta
+		}),
+		footer: resolver.default.footer(ctx.meta, {
+			output,
+			config,
+			file: fileMeta
+		})
+	};
+}
+/**
+* The `<File>` shell shared by the TanStack hook generators; renders `children` after the imports.
+*/
+function HookFile({ hook, imports, children }) {
+	const { file, fileTs, contractOp, importedTypeNames, banner, footer } = hook;
+	return /* @__PURE__ */ jsxs(File, {
+		baseName: file.baseName,
+		path: file.path,
+		meta: file.meta,
+		banner,
+		footer,
+		children: [
+			/* @__PURE__ */ jsx(File.Import, {
+				name: [contractOp.name],
+				root: file.path,
+				path: contractOp.path
+			}),
+			/* @__PURE__ */ jsx(File.Import, {
+				name: ["RequestConfig", "ResponseErrorConfig"],
+				root: contractOp.clientPathIsFile ? file.path : void 0,
+				path: contractOp.clientPath,
+				isTypeOnly: true
+			}),
+			imports,
+			fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+				name: Array.from(new Set(importedTypeNames)),
+				root: file.path,
+				path: fileTs.path,
+				isTypeOnly: true
+			}),
+			children
+		]
+	});
+}
+//#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 = [
+const requestGroupOrder = [
 	"path",
 	"query",
 	"body",
@@ -510,7 +608,7 @@ function maybeValueOrGetter(type) {
 * `MaybeRefOrGetter` per group.
 */
 function buildGroupedRequestParam(node, options) {
-	const { resolver, keys = requestGroupOrder$1, memberTypeWrapper } = options;
+	const { resolver, keys = requestGroupOrder, memberTypeWrapper } = options;
 	const { groups, hasRequiredPath, hasRequiredQuery, hasRequiredHeader } = getRequestGroupOptionality(node);
 	const names = keys.filter((key) => groups[key]);
 	if (names.length === 0) return null;
@@ -522,7 +620,7 @@ function buildGroupedRequestParam(node, options) {
 	};
 	const isOptional = names.every((name) => !requiredByGroup[name]);
 	const optionsName = resolver.response.options(node);
-	const omittedKeys = requestGroupOrder$1.filter((key) => !keys.includes(key));
+	const omittedKeys = requestGroupOrder.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) => ({
@@ -583,7 +681,7 @@ function buildClientCall(node, options) {
 	const { groups } = getRequestGroupOptionality(node);
 	return `${clientName}({ ${[
 		"...config",
-		...requestGroupOrder$1.filter((key) => groups[key]).map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		...requestGroupOrder.filter((key) => groups[key]).map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
 		signal ? "signal: config.signal ?? signal" : null,
 		"throwOnError: true"
 	].filter((part) => part !== null).join(", ")} })`;
@@ -793,16 +891,48 @@ function hasQueryKeyParams(node) {
 * grouped `path`/`query`/`body` bindings.
 */
 function buildQueryKeyParams(node, options) {
-	const { resolver } = options;
+	const { resolver, memberTypeWrapper } = options;
 	const groupedParam = buildGroupedRequestParam(node, {
 		resolver,
-		keys: queryKeyGroupOrder
+		keys: queryKeyGroupOrder,
+		memberTypeWrapper
 	});
 	return createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
 }
+/**
+* Builds the hook parameter list: the grouped request param (omitted when `withRequest` is `false`) then `options` typed as `optionsType`.
+*/
+function buildHookParams(node, options) {
+	const { resolver, optionsType, memberTypeWrapper, withRequest = true } = options;
+	const optionsParam = createFunctionParameter({
+		name: "options",
+		type: optionsType,
+		default: "{}"
+	});
+	const groupedParam = withRequest ? buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper
+	}) : null;
+	return createFunctionParameters({ params: [groupedParam, optionsParam].filter((param) => param !== null) });
+}
+/**
+* The `TRequest` type argument of a mutation hook: the options type when the operation takes a request, else `undefined`.
+*/
+function resolveMutationRequestType(node, resolver) {
+	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
+}
+/**
+* Builds the object literal that unwraps each request group's getter before it reaches `queryKey`/`queryOptions`; `null` without a request group.
+*/
+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 ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
-const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
+const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
 const callPrinter$3 = functionPrinter({ mode: "call" });
 function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, returnType = "full" }) {
 	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver);
@@ -822,7 +952,7 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitI
 		resolver: tsResolver,
 		memberTypeWrapper
 	});
-	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
 	const queryFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: true,
@@ -879,20 +1009,20 @@ return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${que
 }
 //#endregion
 //#region ../../internals/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
+const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
 const mutationKeyTransformer = ({ node }) => {
 	if (!node.path) return [];
 	return [`{ url: '${Url.toPath(node.path)}' }`];
 };
-function MutationKey({ name, node, transformer }) {
+function MutationKey({ name, node, transformer, typeName }) {
 	const paramsNode = createFunctionParameters({ params: [] });
-	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
+	const paramsSignature = declarationPrinter$5.print(paramsNode) ?? "";
 	const keys = (transformer ?? mutationKeyTransformer)({
 		node,
 		casing: "camelcase",
 		variant: "mutation"
 	});
-	return /* @__PURE__ */ jsx(File.Source, {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
 		isIndexable: true,
@@ -903,7 +1033,17 @@ function MutationKey({ name, node, transformer }) {
 			singleLine: true,
 			children: `[${keys.join(", ")}] as const`
 		})
-	});
+	}), typeName && /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			export: true,
+			name: typeName,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
 }
 //#endregion
 //#region ../../internals/tanstack-query/src/resolver.ts
@@ -960,7 +1100,7 @@ function createMutationResolver() {
 }
 //#endregion
 //#region ../../internals/tanstack-query/src/components/QueryKey.tsx
-const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
+const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
 const queryKeyTransformer = ({ node, variant }) => {
 	if (!node.path) return [];
 	const { path, query } = getOperationParameters(node);
@@ -973,9 +1113,12 @@ const queryKeyTransformer = ({ node, variant }) => {
 	if (node.requestBody?.content?.[0]?.schema) result.push("...(body !== undefined ? [body] : [])");
 	return result;
 };
-function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "query" }) {
-	const paramsNode = buildQueryKeyParams(node, { resolver: tsResolver });
-	const paramsSignature = declarationPrinter$5.print(paramsNode) ?? "";
+function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "query", memberTypeWrapper, exportType }) {
+	const paramsNode = buildQueryKeyParams(node, {
+		resolver: tsResolver,
+		memberTypeWrapper
+	});
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
 	const keys = (transformer ?? queryKeyTransformer)({
 		node,
 		casing: "camelcase",
@@ -994,9 +1137,12 @@ function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "qu
 		})
 	}), /* @__PURE__ */ jsx(File.Source, {
 		name: typeName,
+		isExportable: exportType,
+		isIndexable: exportType,
 		isTypeOnly: true,
 		children: /* @__PURE__ */ jsx(Type, {
 			name: typeName,
+			export: exportType,
 			children: `ReturnType<typeof ${name}>`
 		})
 	})] });
@@ -1100,30 +1246,6 @@ const customHookOptionsFileGenerator = defineGenerator({
 	}
 });
 //#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
-* ```ts
-* buildResolvedRequestParams(node) // { path: typeof path === 'function' ? path() : path }
-* ```
-*/
-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
@@ -1160,9 +1282,10 @@ const hookOptionsGenerator = defineGenerator({
 			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 { isQuery: isQueryOp, isMutation: isMutationOp } = classifyOperation(node, {
+				query: nodeQuery === false ? query : nodeQuery,
+				mutation: nodeMutation
+			});
 			const isSuspenseOp = !!suspense;
 			const isInfiniteOp = !!nodeInfiniteOptions;
 			if (isQueryOp) {
@@ -1197,9 +1320,7 @@ const hookOptionsGenerator = defineGenerator({
 					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) {
+					if (matchesInfinite(node, nodeInfiniteOptions)) {
 						const infiniteOptionsName = resolver.infiniteQuery.optionsName(node);
 						const infiniteHookName = resolver.infiniteQuery.name(node);
 						const infiniteHookFile = resolver.file({
@@ -1285,50 +1406,87 @@ const hookOptionsGenerator = defineGenerator({
 	}
 });
 //#endregion
-//#region src/components/InfiniteQuery.tsx
-const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
-function buildInfiniteQueryParamsNode(node, options) {
-	const { resolver, pageParamGeneric, observerOptionsName } = options;
-	const optionsParam = createFunctionParameter({
-		name: "options",
-		type: `{
-  query?: Partial<${observerOptionsName}<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
-  client?: ${buildClientOptionType()}
-}`,
-		default: "{}"
-	});
-	const groupedParam = buildGroupedRequestParam(node, {
-		resolver,
-		memberTypeWrapper: maybeValueOrGetter
-	});
-	return createFunctionParameters({ params: [groupedParam, optionsParam].filter((param) => param !== null) });
+//#region src/components/Query.tsx
+const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
+const OBSERVER_OPTIONS_NAMES = {
+	infinite: {
+		suspense: "UseSuspenseInfiniteQueryOptions",
+		standard: "InfiniteQueryObserverOptions"
+	},
+	plain: {
+		suspense: "UseSuspenseQueryOptions",
+		standard: "QueryObserverOptions"
+	}
+};
+function buildHookTypes({ node, tsResolver, infinite, suspense, TData, TError, queryKeyTypeName, observerOptionsName, resultTypeName }) {
+	if (infinite) {
+		const { pageParamType } = resolvePageParamType(node, {
+			resolver: tsResolver,
+			initialPageParam: infinite.initialPageParam,
+			queryParam: infinite.queryParam
+		});
+		return {
+			generics: [
+				`TQueryFnData = ${TData}`,
+				`TError = ${TError}`,
+				"TData = InfiniteData<TQueryFnData>",
+				`TQueryKey extends QueryKey = ${queryKeyTypeName}`,
+				`TPageParam = ${pageParamType}`
+			],
+			observerOptionsType: `${observerOptionsName}<TQueryFnData, TError, TData, TQueryKey, TPageParam>`,
+			returnType: `${resultTypeName}<TData, TError> & { queryKey: TQueryKey }`
+		};
+	}
+	return {
+		generics: suspense ? [`TData = ${TData}`, `TQueryKey extends QueryKey = ${queryKeyTypeName}`] : [
+			`TData = ${TData}`,
+			`TQueryData = ${TData}`,
+			`TQueryKey extends QueryKey = ${queryKeyTypeName}`
+		],
+		observerOptionsType: `${observerOptionsName}<${(suspense ? [
+			TData,
+			TError,
+			"TData",
+			"TQueryKey"
+		] : [
+			TData,
+			TError,
+			"TData",
+			"TQueryData",
+			"TQueryKey"
+		]).join(", ")}>`,
+		returnType: `${resultTypeName}<TData, ${TError}> & { queryKey: TQueryKey }`
+	};
 }
-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
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions, suspense, infinite }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const prefix = suspense ? "UseSuspense" : "Use";
+	const hookName = `${suspense ? "useSuspense" : "use"}${infinite ? "InfiniteQuery" : "Query"}`;
+	const observerOptionsName = OBSERVER_OPTIONS_NAMES[infinite ? "infinite" : "plain"][suspense ? "suspense" : "standard"];
+	const { generics, observerOptionsType, returnType } = buildHookTypes({
+		node,
+		tsResolver,
+		infinite,
+		suspense,
+		TData,
+		TError,
+		queryKeyTypeName,
+		observerOptionsName,
+		resultTypeName: `${prefix}${infinite ? "Infinite" : ""}QueryResult`
 	});
-	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 castType = infinite ? observerOptionsType : observerOptionsName;
 	const resolvedParams = buildResolvedRequestParams(node);
 	const queryKeyArgs = resolvedParams && hasQueryKeyParams(node) ? "resolvedParams" : "";
 	const queryOptionsArgs = resolvedParams ? "resolvedParams, config" : "config";
-	const paramsNode = buildInfiniteQueryParamsNode(node, {
+	const paramsNode = buildHookParams(node, {
 		resolver: tsResolver,
-		pageParamGeneric: "TPageParam",
-		observerOptionsName
+		memberTypeWrapper: maybeValueOrGetter,
+		optionsType: `{
+  query?: Partial<${observerOptionsType}> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`
 	});
-	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -1349,7 +1507,7 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
         ...${queryOptionsName}(${queryOptionsArgs}),${customOptions ? "\n        ...customOptions," : ""}
         ...resolvedOptions,
         queryKey,
-       } as unknown as ${observerOptionsName}<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient) as ${returnType}
+       } as unknown as ${castType}, queryClient) as ${returnType}
 
        queryResult.queryKey = queryKey as TQueryKey
 
@@ -1359,9 +1517,216 @@ function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 	});
 }
 //#endregion
-//#region src/components/MutationOptions.tsx
-const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
+//#region src/components/QueryOptions.tsx
+const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$2 = functionPrinter({ mode: "call" });
+function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, returnType = "full" }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
+	const paramsNode = buildQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	const queryFnBody = buildCallResultBody(buildClientCall(node, {
+		clientName,
+		signal: true
+	}), { returnType });
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+      return queryOptions<${TData}, ${TError}, ${TData}, typeof queryKey>({
+       queryKey,
+       queryFn: async ({ signal }) => {
+          ${queryFnBody}
+       },
+      })
+`
+		})
+	});
+}
+//#endregion
+//#region src/generators/createQueryGenerator.tsx
+const OBSERVER_IMPORTS = {
+	query: ["QueryObserverOptions", "UseQueryResult"],
+	suspenseQuery: ["UseSuspenseQueryOptions", "UseSuspenseQueryResult"],
+	infiniteQuery: ["InfiniteQueryObserverOptions", "UseInfiniteQueryResult"],
+	suspenseInfiniteQuery: ["UseSuspenseInfiniteQueryOptions", "UseSuspenseInfiniteQueryResult"]
+};
+/**
+* Builds the generator for one `useQuery` flavor. `variant` picks the resolver namespace
+* (`resolver.query`, `resolver.suspenseQuery`, ...), the TanStack hook, and the options it needs.
+*/
+function createQueryGenerator({ name, variant }) {
+	const suspense = variant === "suspenseQuery" || variant === "suspenseInfiniteQuery";
+	const infinite = variant === "infiniteQuery" || variant === "suspenseInfiniteQuery";
+	const hookImport = `use${suspense ? "Suspense" : ""}${infinite ? "InfiniteQuery" : "Query"}`;
+	const observerImports = OBSERVER_IMPORTS[variant];
+	return defineGenerator({
+		name,
+		renderer: jsxRenderer,
+		match(node, ctx) {
+			const operationNode = node;
+			if (!ast.isHttpOperationNode(operationNode)) return false;
+			const { query, mutation, infinite: infiniteConfig, suspense: suspenseConfig, hooks } = ctx.options;
+			const { isQuery, isMutation } = classifyOperation(operationNode, {
+				query,
+				mutation
+			});
+			if (!isQuery || isMutation) return false;
+			if (suspense && !suspenseConfig) return false;
+			if (variant === "query") return true;
+			if (!hooks) return false;
+			if (!infinite) return true;
+			const infiniteOptions = infiniteConfig && typeof infiniteConfig === "object" ? infiniteConfig : null;
+			return !!infiniteOptions && matchesInfinite(operationNode, infiniteOptions);
+		},
+		operation(node, ctx) {
+			if (!ast.isHttpOperationNode(node)) return null;
+			const { driver, resolver, root } = ctx;
+			const { output, query, infinite: infiniteConfig, client, group, customOptions, hooks } = ctx.options;
+			const infiniteOptions = infinite && infiniteConfig && typeof infiniteConfig === "object" ? infiniteConfig : null;
+			if (infinite && !infiniteOptions) return null;
+			if (variant === "infiniteQuery" && infiniteOptions) {
+				const pageParamsWarning = getDefaultPageParamsWarning(node, infiniteOptions);
+				if (pageParamsWarning) ctx.warn(pageParamsWarning);
+			}
+			const contractOp = resolveClientOperation({
+				clientPlugin: { pluginName: client.pluginName },
+				driver,
+				node,
+				root,
+				output,
+				cache: ctx.cache
+			});
+			if (!contractOp) return null;
+			const importPath = query ? query.importPath : "@tanstack/react-query";
+			const variantResolver = resolver[variant];
+			const queryName = variantResolver.name(node);
+			const queryOptionsName = variantResolver.optionsName(node);
+			const queryKeyName = variantResolver.keyName(node);
+			const queryKeyTypeName = variantResolver.keyTypeName(node);
+			const tsResolver = driver.getResolver(pluginTsName);
+			const hook = resolveHookFile(node, ctx, {
+				name: queryName,
+				output,
+				group,
+				contractOp,
+				keyTypeName: queryKeyTypeName,
+				extraTypeNames: infiniteOptions ? [resolvePageParamType(node, {
+					resolver: tsResolver,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam
+				}).queryParamsTypeName] : []
+			});
+			return /* @__PURE__ */ jsxs(HookFile, {
+				hook,
+				imports: customOptions && /* @__PURE__ */ jsx(File.Import, {
+					name: [customOptions.name],
+					path: customOptions.importPath
+				}),
+				children: [
+					/* @__PURE__ */ jsx(QueryKey, {
+						name: queryKeyName,
+						typeName: queryKeyTypeName,
+						node,
+						tsResolver: hook.tsResolver,
+						transformer: ctx.options.queryKey,
+						variant
+					}),
+					infiniteOptions ? /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx(File.Import, {
+							name: ["InfiniteData"],
+							isTypeOnly: true,
+							path: importPath
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: ["infiniteQueryOptions"],
+							path: importPath
+						}),
+						/* @__PURE__ */ jsx(InfiniteQueryOptions, {
+							name: queryOptionsName,
+							clientName: contractOp.name,
+							queryKeyName,
+							node,
+							tsResolver: hook.tsResolver,
+							cursorParam: infiniteOptions.cursorParam,
+							nextParam: infiniteOptions.nextParam,
+							previousParam: infiniteOptions.previousParam,
+							getNextPageParam: infiniteOptions.getNextPageParam,
+							getPreviousPageParam: infiniteOptions.getPreviousPageParam,
+							initialPageParam: infiniteOptions.initialPageParam,
+							hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
+							queryParam: infiniteOptions.queryParam,
+							returnType: contractOp.returnType
+						})
+					] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
+						name: ["queryOptions"],
+						path: importPath
+					}), /* @__PURE__ */ jsx(QueryOptions, {
+						name: queryOptionsName,
+						clientName: contractOp.name,
+						queryKeyName,
+						node,
+						tsResolver: hook.tsResolver,
+						returnType: contractOp.returnType
+					})] }),
+					(variant !== "query" || query && hooks) && /* @__PURE__ */ jsxs(Fragment, { children: [
+						/* @__PURE__ */ jsx(File.Import, {
+							name: [hookImport],
+							path: importPath
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: [
+								"QueryKey",
+								"QueryClient",
+								...observerImports
+							],
+							path: importPath,
+							isTypeOnly: true
+						}),
+						/* @__PURE__ */ jsx(Query, {
+							name: queryName,
+							queryOptionsName,
+							queryKeyName,
+							queryKeyTypeName,
+							node,
+							tsResolver: hook.tsResolver,
+							customOptions,
+							suspense,
+							infinite: infiniteOptions ? {
+								initialPageParam: infiniteOptions.initialPageParam,
+								queryParam: infiniteOptions.queryParam
+							} : void 0
+						})
+					] })
+				]
+			});
+		}
+	});
+}
+//#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 = createQueryGenerator({
+	name: "react-infinite-query",
+	variant: "infiniteQuery"
+});
+//#endregion
+//#region src/components/MutationOptions.tsx
+const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
+const callPrinter$1 = functionPrinter({ mode: "call" });
 function buildMutationConfigParamsNode(node) {
 	return createFunctionParameters({ params: [createFunctionParameter({
 		name: "config",
@@ -1372,12 +1737,12 @@ function buildMutationConfigParamsNode(node) {
 function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName, returnType = "full" }) {
 	const { TData, TError } = buildResponseTypes(node, tsResolver);
 	const configParamsNode = buildMutationConfigParamsNode(node);
-	const paramsSignature = declarationPrinter$3.print(configParamsNode) ?? "";
+	const paramsSignature = declarationPrinter$1.print(configParamsNode) ?? "";
 	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
 	const hasMutationParams = groupedParam !== null;
 	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
 	const TRequest = hasMutationParams ? tsResolver.response.options(node) : "undefined";
-	const argBindingStr = hasMutationParams ? callPrinter$2.print(groupedParamsNode) ?? "" : "_";
+	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "_";
 	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: false
@@ -1405,28 +1770,24 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 }
 //#endregion
 //#region src/components/Mutation.tsx
-const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
-const callPrinter$1 = functionPrinter({ mode: "call" });
-function resolveMutationRequestType(node, resolver) {
-	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
-}
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+const callPrinter = functionPrinter({ mode: "call" });
 function buildMutationParamsNode(node, options) {
 	const { resolver } = options;
 	const { TData, TError } = buildResponseTypes(node, resolver);
-	const generics = [
-		TData,
-		TError,
-		resolveMutationRequestType(node, resolver),
-		"TContext"
-	].join(", ");
-	return createFunctionParameters({ params: [createFunctionParameter({
-		name: "options",
-		type: `{
-  mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
+	return buildHookParams(node, {
+		resolver,
+		withRequest: false,
+		optionsType: `{
+  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);
@@ -1438,9 +1799,9 @@ function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName
 	].join(", ");
 	const returnType = `UseMutationResult<${generics}>`;
 	const mutationOptionsConfigNode = buildMutationConfigParamsNode(node);
-	const mutationOptionsParamsCall = callPrinter$1.print(mutationOptionsConfigNode) ?? "";
+	const mutationOptionsParamsCall = callPrinter.print(mutationOptionsConfigNode) ?? "";
 	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
-	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -1468,301 +1829,6 @@ function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName
 	});
 }
 //#endregion
-//#region src/components/Query.tsx
-const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
-function buildQueryParamsNode(node, options) {
-	const { resolver, observerOptionsType } = options;
-	const optionsParam = createFunctionParameter({
-		name: "options",
-		type: `{
-  query?: Partial<${observerOptionsType}> & { client?: QueryClient },
-  client?: ${buildClientOptionType()}
-}`,
-		default: "{}"
-	});
-	const groupedParam = buildGroupedRequestParam(node, {
-		resolver,
-		memberTypeWrapper: maybeValueOrGetter
-	});
-	return createFunctionParameters({ params: [groupedParam, 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 && hasQueryKeyParams(node) ? "resolvedParams" : "";
-	const queryOptionsArgs = resolvedParams ? "resolvedParams, config" : "config";
-	const paramsNode = buildQueryParamsNode(node, {
-		resolver: tsResolver,
-		observerOptionsType
-	});
-	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			returnType: void 0,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig${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 = functionPrinter({ mode: "declaration" });
-const callPrinter = functionPrinter({ mode: "call" });
-function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, returnType = "full" }) {
-	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 = buildCallResultBody(buildClientCall(node, {
-		clientName,
-		signal: true
-	}), { returnType });
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			children: `
-      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
-      return queryOptions<${TData}, ${TError}, ${TData}, typeof queryKey>({
-       queryKey,
-       queryFn: async ({ signal }) => {
-          ${queryFnBody}
-       },
-      })
-`
-		})
-	});
-}
-//#endregion
-//#region src/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 = defineGenerator({
-	name: "react-infinite-query",
-	renderer: jsxRenderer,
-	match(node, ctx) {
-		const operationNode = node;
-		if (!ast.isHttpOperationNode(operationNode)) return false;
-		const { query, mutation, infinite, hooks } = ctx.options;
-		const { isQuery, isMutation } = classifyOperation(operationNode, {
-			query,
-			mutation
-		});
-		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
-		if (!isQuery || isMutation || !infiniteOptions || !hooks) return false;
-		return matchesInfinite(operationNode, infiniteOptions);
-	},
-	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
-		const { output, query, infinite, client, group, customOptions } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
-		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
-		if (!infiniteOptions) return null;
-		const pageParamsWarning = getDefaultPageParamsWarning(node, infiniteOptions);
-		if (pageParamsWarning) ctx.warn(pageParamsWarning);
-		const importPath = query ? query.importPath : "@tanstack/react-query";
-		const contractOp = resolveClientOperation({
-			clientPlugin: { pluginName: client.pluginName },
-			driver,
-			node,
-			root,
-			output,
-			cache: ctx.cache
-		});
-		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: resolveDependencyOperationFile({
-				cache: ctx.cache,
-				node,
-				resolver: tsResolver,
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
-			})
-		};
-		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__ */ jsxs(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__ */ jsx(File.Import, {
-					name: [contractOp.name],
-					root: meta.file.path,
-					path: contractOp.path
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				customOptions && /* @__PURE__ */ jsx(File.Import, {
-					name: [customOptions.name],
-					path: customOptions.importPath
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(QueryKey, {
-					name: queryKeyName,
-					typeName: queryKeyTypeName,
-					node,
-					tsResolver,
-					transformer: ctx.options.queryKey,
-					variant: "infiniteQuery"
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["InfiniteData"],
-					isTypeOnly: true,
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["infiniteQueryOptions"],
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(InfiniteQueryOptions, {
-					name: queryOptionsName,
-					clientName: calledClientName,
-					queryKeyName,
-					node,
-					tsResolver,
-					cursorParam: infiniteOptions.cursorParam,
-					nextParam: infiniteOptions.nextParam,
-					previousParam: infiniteOptions.previousParam,
-					getNextPageParam: infiniteOptions.getNextPageParam,
-					getPreviousPageParam: infiniteOptions.getPreviousPageParam,
-					initialPageParam: infiniteOptions.initialPageParam,
-					hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
-					queryParam: infiniteOptions.queryParam,
-					returnType: contractOp.returnType
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["useInfiniteQuery"],
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: [
-						"QueryKey",
-						"QueryClient",
-						"InfiniteQueryObserverOptions",
-						"UseInfiniteQueryResult"
-					],
-					path: importPath,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(InfiniteQuery, {
-					name: queryName,
-					queryOptionsName,
-					queryKeyName,
-					queryKeyTypeName,
-					node,
-					tsResolver,
-					initialPageParam: infiniteOptions.initialPageParam,
-					queryParam: infiniteOptions.queryParam,
-					customOptions
-				})
-			]
-		});
-	}
-});
-//#endregion
 //#region src/generators/mutationGenerator.tsx
 /**
 * Built-in generator for `useMutation` hooks. Emits one `useFooMutation` hook
@@ -1783,10 +1849,8 @@ const mutationGenerator = defineGenerator({
 	},
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
+		const { driver, resolver, root } = ctx;
 		const { output, mutation, client, group, customOptions, hooks } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
 		const importPath = mutation ? mutation.importPath : "@tanstack/react-query";
 		const contractOp = resolveClientOperation({
 			clientPlugin: { pluginName: client.pluginName },
@@ -1798,72 +1862,22 @@ const mutationGenerator = defineGenerator({
 		});
 		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: resolveDependencyOperationFile({
-				cache: ctx.cache,
-				node,
-				resolver: tsResolver,
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
-			})
-		};
-		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__ */ jsxs(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
-				}
+		const hook = resolveHookFile(node, ctx, {
+			name: mutationHookName,
+			output,
+			group,
+			contractOp
+		});
+		const { tsResolver } = hook;
+		return /* @__PURE__ */ jsxs(HookFile, {
+			hook,
+			imports: customOptions && /* @__PURE__ */ jsx(File.Import, {
+				name: [customOptions.name],
+				path: customOptions.importPath
 			}),
 			children: [
-				/* @__PURE__ */ jsx(File.Import, {
-					name: [contractOp.name],
-					root: meta.file.path,
-					path: contractOp.path
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				customOptions && /* @__PURE__ */ jsx(File.Import, {
-					name: [customOptions.name],
-					path: customOptions.importPath
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
 				/* @__PURE__ */ jsx(MutationKey, {
 					name: mutationKeyName,
 					node,
@@ -1875,7 +1889,7 @@ const mutationGenerator = defineGenerator({
 				}),
 				/* @__PURE__ */ jsx(MutationOptions, {
 					name: mutationOptionsName,
-					clientName: calledClientName,
+					clientName: contractOp.name,
 					mutationKeyName,
 					node,
 					tsResolver,
@@ -1897,7 +1911,6 @@ const mutationGenerator = defineGenerator({
 					}),
 					/* @__PURE__ */ jsx(Mutation, {
 						name: mutationHookName,
-						typeName: mutationTypeName,
 						mutationOptionsName,
 						mutationKeyName,
 						node,
@@ -1916,151 +1929,9 @@ const mutationGenerator = defineGenerator({
 * GET and QUERY operation (configurable via `query.methods`) plus the matching
 * `fooQueryKey` / `fooQueryOptions` helpers.
 */
-const queryGenerator = defineGenerator({
+const queryGenerator = createQueryGenerator({
 	name: "react-query",
-	renderer: jsxRenderer,
-	match(node, ctx) {
-		const operationNode = node;
-		if (!ast.isHttpOperationNode(operationNode)) return false;
-		const { query, mutation } = ctx.options;
-		const { isQuery, isMutation } = classifyOperation(operationNode, {
-			query,
-			mutation
-		});
-		return isQuery && !isMutation;
-	},
-	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
-		const { output, query, client, group, customOptions, hooks } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
-		const importPath = query ? query.importPath : "@tanstack/react-query";
-		const contractOp = resolveClientOperation({
-			clientPlugin: { pluginName: client.pluginName },
-			driver,
-			node,
-			root,
-			output,
-			cache: ctx.cache
-		});
-		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: resolveDependencyOperationFile({
-				cache: ctx.cache,
-				node,
-				resolver: tsResolver,
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
-			})
-		};
-		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__ */ jsxs(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__ */ jsx(File.Import, {
-					name: [contractOp.name],
-					root: meta.file.path,
-					path: contractOp.path
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				customOptions && /* @__PURE__ */ jsx(File.Import, {
-					name: [customOptions.name],
-					path: customOptions.importPath
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(QueryKey, {
-					name: queryKeyName,
-					typeName: queryKeyTypeName,
-					node,
-					tsResolver,
-					transformer: ctx.options.queryKey,
-					variant: "query"
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["queryOptions"],
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(QueryOptions, {
-					name: queryOptionsName,
-					clientName: calledClientName,
-					queryKeyName,
-					node,
-					tsResolver,
-					returnType: contractOp.returnType
-				}),
-				query && hooks && /* @__PURE__ */ jsxs(Fragment, { children: [
-					/* @__PURE__ */ jsx(File.Import, {
-						name: ["useQuery"],
-						path: importPath
-					}),
-					/* @__PURE__ */ jsx(File.Import, {
-						name: [
-							"QueryKey",
-							"QueryClient",
-							"QueryObserverOptions",
-							"UseQueryResult"
-						],
-						path: importPath,
-						isTypeOnly: true
-					}),
-					/* @__PURE__ */ jsx(Query, {
-						name: queryName,
-						queryOptionsName,
-						queryKeyName,
-						queryKeyTypeName,
-						node,
-						tsResolver,
-						customOptions
-					})
-				] })
-			]
-		});
-	}
+	variant: "query"
 });
 //#endregion
 //#region src/generators/suspenseInfiniteQueryGenerator.tsx
@@ -2070,178 +1941,9 @@ const queryGenerator = defineGenerator({
 * semantics with cursor-based pagination. Handlers throw promises while
 * loading and pull additional pages on demand.
 */
-const suspenseInfiniteQueryGenerator = defineGenerator({
+const suspenseInfiniteQueryGenerator = createQueryGenerator({
 	name: "react-suspense-infinite-query",
-	renderer: jsxRenderer,
-	match(node, ctx) {
-		const operationNode = node;
-		if (!ast.isHttpOperationNode(operationNode)) return false;
-		const { query, mutation, infinite, suspense, hooks } = ctx.options;
-		const { isQuery, isMutation } = classifyOperation(operationNode, {
-			query,
-			mutation
-		});
-		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
-		if (!isQuery || isMutation || !suspense || !infiniteOptions || !hooks) return false;
-		return matchesInfinite(operationNode, infiniteOptions);
-	},
-	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
-		const { output, query, infinite, client, group, customOptions } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
-		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
-		if (!infiniteOptions) return null;
-		const importPath = query ? query.importPath : "@tanstack/react-query";
-		const contractOp = resolveClientOperation({
-			clientPlugin: { pluginName: client.pluginName },
-			driver,
-			node,
-			root,
-			output,
-			cache: ctx.cache
-		});
-		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: resolveDependencyOperationFile({
-				cache: ctx.cache,
-				node,
-				resolver: tsResolver,
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
-			})
-		};
-		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__ */ jsxs(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__ */ jsx(File.Import, {
-					name: [contractOp.name],
-					root: meta.file.path,
-					path: contractOp.path
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				customOptions && /* @__PURE__ */ jsx(File.Import, {
-					name: [customOptions.name],
-					path: customOptions.importPath
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(QueryKey, {
-					name: queryKeyName,
-					typeName: queryKeyTypeName,
-					node,
-					tsResolver,
-					transformer: ctx.options.queryKey,
-					variant: "suspenseInfiniteQuery"
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["InfiniteData"],
-					isTypeOnly: true,
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["infiniteQueryOptions"],
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(InfiniteQueryOptions, {
-					name: queryOptionsName,
-					clientName: calledClientName,
-					queryKeyName,
-					node,
-					tsResolver,
-					cursorParam: infiniteOptions.cursorParam,
-					nextParam: infiniteOptions.nextParam,
-					previousParam: infiniteOptions.previousParam,
-					getNextPageParam: infiniteOptions.getNextPageParam,
-					getPreviousPageParam: infiniteOptions.getPreviousPageParam,
-					initialPageParam: infiniteOptions.initialPageParam,
-					hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
-					queryParam: infiniteOptions.queryParam,
-					returnType: contractOp.returnType
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["useSuspenseInfiniteQuery"],
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: [
-						"QueryKey",
-						"QueryClient",
-						"UseSuspenseInfiniteQueryOptions",
-						"UseSuspenseInfiniteQueryResult"
-					],
-					path: importPath,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(InfiniteQuery, {
-					name: queryName,
-					queryOptionsName,
-					queryKeyName,
-					queryKeyTypeName,
-					node,
-					tsResolver,
-					initialPageParam: infiniteOptions.initialPageParam,
-					queryParam: infiniteOptions.queryParam,
-					customOptions,
-					suspense: true
-				})
-			]
-		});
-	}
+	variant: "suspenseInfiniteQuery"
 });
 //#endregion
 //#region src/generators/suspenseQueryGenerator.tsx
@@ -2252,150 +1954,9 @@ const suspenseInfiniteQueryGenerator = defineGenerator({
 * promises while loading and require a `<Suspense>` boundary in the React
 * tree. TanStack Query v5+ only.
 */
-const suspenseQueryGenerator = defineGenerator({
+const suspenseQueryGenerator = createQueryGenerator({
 	name: "react-suspense-query",
-	renderer: jsxRenderer,
-	match(node, ctx) {
-		const operationNode = node;
-		if (!ast.isHttpOperationNode(operationNode)) return false;
-		const { query, mutation, suspense, hooks } = ctx.options;
-		const { isQuery, isMutation } = classifyOperation(operationNode, {
-			query,
-			mutation
-		});
-		return isQuery && !isMutation && !!suspense && hooks;
-	},
-	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
-		const { output, query, client, group, customOptions } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
-		const importPath = query ? query.importPath : "@tanstack/react-query";
-		const contractOp = resolveClientOperation({
-			clientPlugin: { pluginName: client.pluginName },
-			driver,
-			node,
-			root,
-			output,
-			cache: ctx.cache
-		});
-		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: resolveDependencyOperationFile({
-				cache: ctx.cache,
-				node,
-				resolver: tsResolver,
-				root,
-				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
-			})
-		};
-		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__ */ jsxs(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__ */ jsx(File.Import, {
-					name: [contractOp.name],
-					root: meta.file.path,
-					path: contractOp.path
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				customOptions && /* @__PURE__ */ jsx(File.Import, {
-					name: [customOptions.name],
-					path: customOptions.importPath
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(QueryKey, {
-					name: queryKeyName,
-					typeName: queryKeyTypeName,
-					node,
-					tsResolver,
-					transformer: ctx.options.queryKey,
-					variant: "suspenseQuery"
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["queryOptions"],
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(QueryOptions, {
-					name: queryOptionsName,
-					clientName: calledClientName,
-					queryKeyName,
-					node,
-					tsResolver,
-					returnType: contractOp.returnType
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["useSuspenseQuery"],
-					path: importPath
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: [
-						"QueryKey",
-						"QueryClient",
-						"UseSuspenseQueryOptions",
-						"UseSuspenseQueryResult"
-					],
-					path: importPath,
-					isTypeOnly: true
-				}),
-				/* @__PURE__ */ jsx(Query, {
-					name: queryName,
-					queryOptionsName,
-					queryKeyName,
-					queryKeyTypeName,
-					node,
-					tsResolver,
-					customOptions,
-					suspense: true
-				})
-			]
-		});
-	}
+	variant: "suspenseQuery"
 });
 //#endregion
 //#region src/resolvers/resolverReactQuery.ts
@@ -2494,6 +2055,7 @@ const pluginReactQuery = defineExtension({
 		return {
 			output,
 			client: resolveContractClient({
+				plugin: pluginReactQueryName,
 				client,
 				plugins: useConfig().plugins
 			}),