@kubb/plugin-react-query 5.9.0-canary.20261029T142044 → 5.10.0-canary.20261103T075950

package/dist/index.cjs

@@ -53,19 +53,19 @@ function operationFileEntry(node, name, extname = ".ts") {
 	};
 }
 /**
-* Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the
-* current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the
+* Resolves a dependency plugin's generated file for `node.operationId`, cached in `memo` (the
+* build's `ctx.memo`) under the resolver's own plugin name and the operation. Several dependents reading the
 * same dependency for the same operation in one pass (a query plugin's several hook generators, the
 * MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
 *
 * @example Cache `plugin-ts`'s file for the current operation
 * ```ts
-* const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })
+* const fileTs = resolveDependencyOperationFile({ memo: ctx.memo, node, resolver: tsResolver, root, output })
 * ```
 */
 function resolveDependencyOperationFile(options) {
-	const { cache, node, resolver, root, output, group } = options;
-	return cache.ensureItem(`${resolver.pluginName}:operationFile`, () => resolver.file({
+	const { memo, node, resolver, root, output, group } = options;
+	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => resolver.file({
 		...operationFileEntry(node, node.operationId),
 		root,
 		output,
@@ -510,7 +510,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.9.0-canary.20261029T142044";
+var version = "5.10.0-canary.20261103T075950";
 // ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
@@ -707,7 +707,7 @@ function resolveImportPath(options) {
 * output root, the same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
 * With plugin-client they come from the user's `importPath` module instead.
 *
-* The result is cached in the current node's `cache` (`ctx.cache`) under the client plugin's name,
+* The result is cached in `memo` (the build's `ctx.memo`) under the client plugin's name and the operation,
 * so several dependents reading the same client plugin for one operation in a single pass
 * (react-query's query/mutation/infinite generators, vue-query, swr, the MCP handler, ...) share
 * one computed result instead of each re-deriving the name and path.
@@ -717,9 +717,9 @@ function resolveImportPath(options) {
 * and import path therefore match the `<op>` actually emitted, even when an `override` changes it.
 */
 function resolveClientOperation(options) {
-	const { clientPlugin, driver, node, root, output, cache } = options;
+	const { clientPlugin, driver, node, root, output, memo } = options;
 	if (!clientPlugin) return null;
-	return cache.ensureItem(`${clientPlugin.pluginName}:clientOperation`, () => {
+	return memo(`${clientPlugin.pluginName}:clientOperation:${node.operationId}`, () => {
 		const resolver = driver.getResolver(clientPlugin.pluginName);
 		const pluginOptions = driver.getPlugin(clientPlugin.pluginName)?.options ?? {};
 		const { exclude, include, override } = pluginOptions;
@@ -759,8 +759,16 @@ function resolveClientOperation(options) {
 * `pluginZod({ inferred: 'codec' })`), banner and footer.
 */
 function resolveHookFile(node, ctx, options) {
-	const { name, output, group, contractOp, keyTypeName, extraTypeNames = [] } = options;
+	const { name, output, group, contractOp, keyTypeName, extraTypeNames = [], returnType = "data" } = options;
 	const { config, root, resolver } = ctx;
+	if (returnType !== "data" && contractOp.returnType === "data") throw new _kubb_kit.Diagnostics.Error({
+		code: _kubb_kit.Diagnostics.code.invalidPluginOptions,
+		severity: "error",
+		message: `Option \`returnType\` is '${returnType}' for ${node.operationId}, but the client plugin has \`returnType: 'data'\` and only returns the response body.`,
+		help: "Set the client plugin's `returnType` to 'full', or set the hook plugin's `returnType` to 'data'.",
+		location: { kind: "config" },
+		plugin: resolver.pluginName
+	});
 	const types = resolveOperationTypes(ctx.driver, resolver.pluginName);
 	const tsResolver = types.resolver;
 	const file = resolver.file({
@@ -770,7 +778,7 @@ function resolveHookFile(node, ctx, options) {
 		group: group ?? void 0
 	});
 	const fileTs = resolveDependencyOperationFile({
-		cache: ctx.cache,
+		memo: ctx.memo,
 		node,
 		resolver: tsResolver,
 		root,
@@ -779,9 +787,10 @@ function resolveHookFile(node, ctx, options) {
 	});
 	const importedTypeNames = [
 		tsResolver.response.options(node),
+		tsResolver.response.responses(node),
 		...extraTypeNames,
 		...resolveOperationTypeNames(node, tsResolver, {
-			exclude: keyTypeName ? [keyTypeName] : void 0,
+			exclude: [keyTypeName, returnType !== "data" ? tsResolver.response.response(node) : null].filter((name) => Boolean(name)),
 			order: "body-response-first",
 			includeParams: false
 		})
@@ -796,6 +805,7 @@ function resolveHookFile(node, ctx, options) {
 		tsResolver,
 		contractOp,
 		importedTypeNames,
+		returnType,
 		banner: resolver.default.banner(ctx.meta, {
 			output,
 			config,
@@ -826,7 +836,11 @@ function HookFile({ hook, imports, children }) {
 				path: contractOp.path
 			}),
 			/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-				name: ["RequestConfig", "ResponseErrorConfig"],
+				name: [
+					"RequestConfig",
+					"ResponseErrorConfig",
+					"RequestResult"
+				],
 				root: contractOp.clientPathIsFile ? file.path : void 0,
 				path: contractOp.clientPath,
 				isTypeOnly: true
@@ -956,11 +970,12 @@ function buildClientCall(node, options) {
 }
 /**
 * Builds the query/mutation body that resolves a `buildClientCall` expression down to the bare
-* success body. `returnType` mirrors the registered client plugin's own `returnType` option: with
+* success body. `clientReturnType` mirrors the registered client plugin's own `returnType` option: with
 * `'data'` the call already resolves to the bare body, so it is returned directly; with `'full'`
 * (the default) the call carries `unwrap()`, so the body calls it instead of destructuring `data`
 * off the full result by hand. With `'plain'` (plugin-client) the call resolves to the user's
-* `RequestResult`, so the body awaits it and reads `data`.
+* `RequestResult`, so the body awaits it and reads `data`. With `returnType` `'full'` the body
+* resolves to the whole `RequestResult`; `resolveHookFile` rejects that for a client that already stripped it.
 *
 * @example
 * ```ts
@@ -969,22 +984,24 @@ function buildClientCall(node, options) {
 * ```
 */
 function buildCallResultBody(call, options = {}) {
-	const { returnType = "full" } = options;
-	if (returnType === "data") return `return await ${call}`;
-	if (returnType === "plain") return `return (await ${call}).data`;
+	const { clientReturnType = "full", returnType = "data" } = options;
+	if (returnType !== "data" || clientReturnType === "data") return `return ${call}`;
+	if (clientReturnType === "plain") return `return (await ${call}).data`;
 	return `return ${call}.unwrap()`;
 }
 /**
 * 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<...>`.
+* With `returnType` `'full'`, `TData` is the client's `RequestResult` over the operation's responses record.
 */
-function buildResponseTypes(node, resolver) {
-	return resolver.memo(`responseTypes:${node.method}\0${node.path}`, () => {
+function buildResponseTypes(node, resolver, options = {}) {
+	const { returnType = "data" } = options;
+	return resolver.memo(`responseTypes:${returnType}:${node.method}\0${node.path}`, () => {
 		const successNames = resolveSuccessNames(node, resolver);
 		const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
 		const errorNames = resolveErrorNames(node, resolver);
 		return {
-			TData: responseName,
+			TData: returnType !== "data" ? `RequestResult<${resolver.response.responses(node)}, true>` : responseName,
 			TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
 		};
 	});
@@ -1213,8 +1230,9 @@ function buildResolvedRequestParams(node) {
 // ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$6 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$3 = (0, _kubb_plugin_ts.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);
+function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, clientReturnType, returnType }) {
+	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver, { returnType });
+	const dataSuffix = returnType === "data" ? "" : ".data";
 	const { queryParamsTypeName, pageParamType } = resolvePageParamType(node, {
 		resolver: tsResolver,
 		initialPageParam,
@@ -1236,21 +1254,24 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitI
 		clientName,
 		signal: true,
 		unwrapName
-	}), { returnType });
+	}), {
+		clientReturnType,
+		returnType
+	});
 	const initialPageParamLiteral = typeof initialPageParam === "string" || typeof initialPageParam === "object" && initialPageParam !== null ? JSON.stringify(initialPageParam) : String(initialPageParam === void 0 ? 0 : initialPageParam);
 	const serializedGetNextPageParam = typeof getNextPageParam === "function" ? getNextPageParam.toString() : getNextPageParam;
 	const getNextPageParamExpr = (() => {
 		if (serializedGetNextPageParam) return `getNextPageParam: ${serializedGetNextPageParam}`;
-		if (nextParam) return `getNextPageParam: (lastPage) => ${getNestedAccessor(nextParam, "lastPage")}`;
-		if (cursorParam) return `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`;
-		return "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1";
+		if (nextParam) return `getNextPageParam: (lastPage) => ${getNestedAccessor(nextParam, `lastPage${dataSuffix}`)}`;
+		if (cursorParam) return `getNextPageParam: (lastPage) => lastPage${dataSuffix}['${cursorParam}']`;
+		return `getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage${dataSuffix}) && lastPage${dataSuffix}.length === 0 ? undefined : lastPageParam + 1`;
 	})();
 	const serializedGetPreviousPageParam = typeof getPreviousPageParam === "function" ? getPreviousPageParam.toString() : getPreviousPageParam;
 	const defaultPreviousThreshold = hasExplicitInitialPageParam ? initialPageParamLiteral : "1";
 	const getPreviousPageParamExpr = (() => {
 		if (serializedGetPreviousPageParam) return `getPreviousPageParam: ${serializedGetPreviousPageParam}`;
-		if (previousParam) return `getPreviousPageParam: (firstPage) => ${getNestedAccessor(previousParam, "firstPage")}`;
-		if (cursorParam) return `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`;
+		if (previousParam) return `getPreviousPageParam: (firstPage) => ${getNestedAccessor(previousParam, `firstPage${dataSuffix}`)}`;
+		if (cursorParam) return `getPreviousPageParam: (firstPage) => firstPage${dataSuffix}['${cursorParam}']`;
 		if (serializedGetNextPageParam || nextParam) return null;
 		return `getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= ${defaultPreviousThreshold} ? undefined : firstPageParam - 1`;
 	})();
@@ -1690,7 +1711,7 @@ function buildHookTypes({ node, tsResolver, infinite, suspense, TData, TError, q
 				`TPageParam = ${pageParamType}`
 			],
 			observerOptionsType: `${observerOptionsName}<TQueryFnData, TError, TData, TQueryKey, TPageParam>`,
-			returnType: `${resultTypeName}<TData, TError> & { queryKey: TQueryKey }`
+			resultType: `${resultTypeName}<TData, TError> & { queryKey: TQueryKey }`
 		};
 	}
 	return {
@@ -1711,15 +1732,15 @@ function buildHookTypes({ node, tsResolver, infinite, suspense, TData, TError, q
 			"TQueryData",
 			"TQueryKey"
 		]).join(", ")}>`,
-		returnType: `${resultTypeName}<TData, ${TError}> & { queryKey: TQueryKey }`
+		resultType: `${resultTypeName}<TData, ${TError}> & { queryKey: TQueryKey }`
 	};
 }
-function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions, suspense, infinite }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions, suspense, infinite, returnType }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
 	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({
+	const { generics, observerOptionsType, resultType } = buildHookTypes({
 		node,
 		tsResolver,
 		infinite,
@@ -1763,7 +1784,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
         ...${queryOptionsName}(${queryOptionsArgs}),${customOptions ? "\n        ...customOptions," : ""}
         ...resolvedOptions,
         queryKey,
-       } as unknown as ${castType}, queryClient) as ${returnType}
+       } as unknown as ${castType}, queryClient) as ${resultType}
 
        queryResult.queryKey = queryKey as TQueryKey
 
@@ -1775,8 +1796,8 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 // src/components/QueryOptions.tsx
 const declarationPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, returnType = "full" }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
+function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, clientReturnType, returnType }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
 	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
 	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
 	const paramsNode = buildQueryOptionsParams(node, { resolver: tsResolver });
@@ -1784,7 +1805,10 @@ function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, return
 	const queryFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: true
-	}), { returnType });
+	}), {
+		clientReturnType,
+		returnType
+	});
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name,
 		isExportable: true,
@@ -1856,7 +1880,7 @@ function createQueryGenerator({ name, variant }) {
 				node,
 				root,
 				output,
-				cache: ctx.cache
+				memo: ctx.memo
 			});
 			if (!contractOp) return null;
 			const importPath = query ? query.importPath : "@tanstack/react-query";
@@ -1871,6 +1895,7 @@ function createQueryGenerator({ name, variant }) {
 				output,
 				group,
 				contractOp,
+				returnType: ctx.options.returnType,
 				keyTypeName: queryKeyTypeName,
 				extraTypeNames: infiniteOptions ? [resolvePageParamType(node, {
 					resolver: tsResolver,
@@ -1917,7 +1942,8 @@ function createQueryGenerator({ name, variant }) {
 							initialPageParam: infiniteOptions.initialPageParam,
 							hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
 							queryParam: infiniteOptions.queryParam,
-							returnType: contractOp.returnType
+							clientReturnType: contractOp.returnType,
+							returnType: hook.returnType
 						})
 					] }) : /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 						name: ["queryOptions"],
@@ -1928,7 +1954,8 @@ function createQueryGenerator({ name, variant }) {
 						queryKeyName,
 						node,
 						tsResolver: hook.tsResolver,
-						returnType: contractOp.returnType
+						clientReturnType: contractOp.returnType,
+						returnType: hook.returnType
 					})] }),
 					(variant !== "query" || query && hooks) && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
 						/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -1952,6 +1979,7 @@ function createQueryGenerator({ name, variant }) {
 							node,
 							tsResolver: hook.tsResolver,
 							customOptions,
+							returnType: hook.returnType,
 							suspense,
 							infinite: infiniteOptions ? {
 								initialPageParam: infiniteOptions.initialPageParam,
@@ -1986,8 +2014,8 @@ function buildMutationConfigParamsNode(node) {
 		default: "{}"
 	})] });
 }
-function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName, returnType = "full" }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
+function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName, clientReturnType, returnType }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
 	const configParamsNode = buildMutationConfigParamsNode(node);
 	const paramsSignature = declarationPrinter$1.print(configParamsNode) ?? "";
 	const groupedParam = buildGroupedRequestParam(node, {
@@ -2002,8 +2030,11 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 		clientName,
 		signal: false,
 		withContentType: true,
+		returnType: clientReturnType
+	}), {
+		clientReturnType,
 		returnType
-	}), { returnType });
+	});
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name,
 		isExportable: true,
@@ -2029,8 +2060,8 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function buildMutationParamsNode(node, options) {
-	const { resolver } = options;
-	const { TData, TError } = buildResponseTypes(node, resolver);
+	const { resolver, returnType } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver, { returnType });
 	return buildHookParams(node, {
 		resolver,
 		withRequest: false,
@@ -2045,18 +2076,21 @@ function buildMutationParamsNode(node, options) {
 }`
 	});
 }
-function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName, customOptions }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
+function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName, customOptions, returnType }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
 	const generics = [
 		TData,
 		TError,
 		resolveMutationRequestType(node, tsResolver),
 		"TContext"
 	].join(", ");
-	const returnType = `UseMutationResult<${generics}>`;
+	const resultType = `UseMutationResult<${generics}>`;
 	const mutationOptionsConfigNode = buildMutationConfigParamsNode(node);
 	const mutationOptionsParamsCall = callPrinter.print(mutationOptionsConfigNode) ?? "";
-	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
+	const paramsNode = buildMutationParamsNode(node, {
+		resolver: tsResolver,
+		returnType
+	});
 	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name,
@@ -2079,7 +2113,7 @@ function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName
           ...baseOptions,${customOptions ? "\n          ...customOptions," : ""}
           mutationKey,
           ...mutationOptions,
-        }, queryClient) as ${returnType}
+        }, queryClient) as ${resultType}
     `
 		})
 	});
@@ -2113,7 +2147,7 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 			node,
 			root,
 			output,
-			cache: ctx.cache
+			memo: ctx.memo
 		});
 		if (!contractOp) return null;
 		const mutationHookName = resolver.mutation.name(node);
@@ -2123,7 +2157,8 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 			name: mutationHookName,
 			output,
 			group,
-			contractOp
+			contractOp,
+			returnType: ctx.options.returnType
 		});
 		const { tsResolver } = hook;
 		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(HookFile, {
@@ -2148,7 +2183,8 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 					mutationKeyName,
 					node,
 					tsResolver,
-					returnType: contractOp.returnType
+					clientReturnType: contractOp.returnType,
+					returnType: hook.returnType
 				}),
 				mutation && hooks && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
 					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -2170,7 +2206,8 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 						mutationKeyName,
 						node,
 						tsResolver,
-						customOptions
+						customOptions,
+						returnType: hook.returnType
 					})
 				] })
 			]
@@ -2305,7 +2342,7 @@ const pluginReactQuery = (0, _kubb_kit.defineExtension)({
 		const { output = {
 			path: "hooks",
 			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;
+		}, group, exclude = [], include, override = [], suspense = false, infinite = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, customOptions, hooks = false, client, returnType = "data", resolver: userResolver, macros: userMacros } = options;
 		const resolver = userResolver ? _kubb_kit.Resolver.merge(resolverReactQuery, userResolver) : resolverReactQuery;
 		(0, _kubb_kit.setResolver)(resolver);
 		if (userMacros?.length) (0, _kubb_kit.setMacros)(userMacros);
@@ -2317,6 +2354,7 @@ const pluginReactQuery = (0, _kubb_kit.defineExtension)({
 				client,
 				plugins: (0, _kubb_kit.useConfig)().plugins
 			}),
+			returnType,
 			queryKey,
 			query: resolveQueryConfig(query, { importPath: "@tanstack/react-query" }),
 			mutationKey,