@kubb/plugin-react-query 5.9.0-canary.20261029T145027 → 5.9.1

package/dist/index.d.cts

@@ -415,6 +415,11 @@ type Options = OutputOptions & {
    * A client plugin must be registered. The hooks always call its `<op>`.
    */
   client?: ClientSelector;
+  /**
+   * Shape of the value the hooks resolve to: `'data'` is the success body, `'full'` the client's whole `RequestResult` so a hook can read response headers. `'full'` needs a client plugin whose own `returnType` is `'full'` or `'plain'`.
+   * @default 'data'
+   */
+  returnType?: 'data' | 'full';
   /**
    * Skip operations matching at least one entry in the list.
    */
@@ -502,6 +507,7 @@ type ResolvedOptions = {
    * The resolved contract client the generators import and call.
    */
   client: ResolvedClient;
+  returnType?: 'data' | 'full';
   /**
    * Resolved infinite query configuration, or `false` when infinite queries are disabled.
    */

package/dist/index.d.ts

@@ -415,6 +415,11 @@ type Options = OutputOptions & {
    * A client plugin must be registered. The hooks always call its `<op>`.
    */
   client?: ClientSelector;
+  /**
+   * Shape of the value the hooks resolve to: `'data'` is the success body, `'full'` the client's whole `RequestResult` so a hook can read response headers. `'full'` needs a client plugin whose own `returnType` is `'full'` or `'plain'`.
+   * @default 'data'
+   */
+  returnType?: 'data' | 'full';
   /**
    * Skip operations matching at least one entry in the list.
    */
@@ -502,6 +507,7 @@ type ResolvedOptions = {
    * The resolved contract client the generators import and call.
    */
   client: ResolvedClient;
+  returnType?: 'data' | 'full';
   /**
    * Resolved infinite query configuration, or `false` when infinite queries are disabled.
    */

package/dist/index.js

@@ -85,12 +85,18 @@ function getPrimarySuccessContentType(node) {
 	return contentTypes[0].split(";")[0].trim().toLowerCase();
 }
 /**
-* Whether an operation streams its primary success response as Server-Sent Events
-* (`text/event-stream`). The client generator uses this to return a typed event stream instead of a
-* one-shot `RequestResult`.
+* The `text/event-stream` content of the primary success response, when it is the only content type. A response that also
+* declares another type stays a normal call with its query hooks.
+*/
+function getEventStreamContent(node) {
+	return getPrimarySuccessContentType(node) === "text/event-stream" ? getPrimarySuccessResponse(node)?.content?.[0] : void 0;
+}
+/**
+* Whether an operation streams its primary success response as Server-Sent Events (`text/event-stream`). The client
+* generator uses this to return a typed event stream instead of a one-shot `RequestResult`.
 */
 function isEventStream(node) {
-	return getPrimarySuccessContentType(node) === "text/event-stream";
+	return getEventStreamContent(node) !== void 0;
 }
 const requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 function buildRequestConfigType(node) {
@@ -158,6 +164,22 @@ function buildOperationComments(node, options = {}) {
 }
 const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 /**
+* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
+* per property, typed and serialized like any other.
+* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
+*/
+function spreadQuerystring(param) {
+	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
+	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
+	if (schema?.type !== "object" || !formEncoded) return [param];
+	return schema.properties.map((property) => ast.factory.createParameter({
+		name: property.name,
+		in: "query",
+		schema: property.schema,
+		required: param.required && property.required
+	}));
+}
+/**
 * Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
 * group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
 * (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
@@ -166,17 +188,18 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
-	const group = (location) => {
+	const dedupe = (params) => {
 		const seen = /* @__PURE__ */ new Set();
-		return node.parameters.filter((param) => {
-			if (param.in !== location || seen.has(param.name)) return false;
+		return params.filter((param) => {
+			if (seen.has(param.name)) return false;
 			seen.add(param.name);
 			return true;
 		});
 	};
+	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
 	const groups = {
 		path: group("path"),
-		query: group("query"),
+		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
 		header: group("header"),
 		cookie: group("cookie")
 	};
@@ -479,11 +502,11 @@ function createGroupConfig(group) {
 }
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.14.6",
+	"kubb": ">=5.16.0",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.9.0-canary.20261029T145027";
+var version = "5.9.1";
 // ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
@@ -732,8 +755,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 Diagnostics.Error({
+		code: 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({
@@ -752,9 +783,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
 		})
@@ -769,6 +801,7 @@ function resolveHookFile(node, ctx, options) {
 		tsResolver,
 		contractOp,
 		importedTypeNames,
+		returnType,
 		banner: resolver.default.banner(ctx.meta, {
 			output,
 			config,
@@ -799,7 +832,11 @@ function HookFile({ hook, imports, children }) {
 				path: contractOp.path
 			}),
 			/* @__PURE__ */ jsx(File.Import, {
-				name: ["RequestConfig", "ResponseErrorConfig"],
+				name: [
+					"RequestConfig",
+					"ResponseErrorConfig",
+					"RequestResult"
+				],
 				root: contractOp.clientPathIsFile ? file.path : void 0,
 				path: contractOp.clientPath,
 				isTypeOnly: true
@@ -929,11 +966,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
@@ -942,22 +980,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"}>`
 		};
 	});
@@ -1186,8 +1226,9 @@ function buildResolvedRequestParams(node) {
 // ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 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);
+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,
@@ -1209,21 +1250,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`;
 	})();
@@ -1663,7 +1707,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 {
@@ -1684,15 +1728,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,
@@ -1736,7 +1780,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
 
@@ -1748,8 +1792,8 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 // 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);
+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 });
@@ -1757,7 +1801,10 @@ function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, return
 	const queryFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: true
-	}), { returnType });
+	}), {
+		clientReturnType,
+		returnType
+	});
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -1844,6 +1891,7 @@ function createQueryGenerator({ name, variant }) {
 				output,
 				group,
 				contractOp,
+				returnType: ctx.options.returnType,
 				keyTypeName: queryKeyTypeName,
 				extraTypeNames: infiniteOptions ? [resolvePageParamType(node, {
 					resolver: tsResolver,
@@ -1890,7 +1938,8 @@ function createQueryGenerator({ name, variant }) {
 							initialPageParam: infiniteOptions.initialPageParam,
 							hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
 							queryParam: infiniteOptions.queryParam,
-							returnType: contractOp.returnType
+							clientReturnType: contractOp.returnType,
+							returnType: hook.returnType
 						})
 					] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
 						name: ["queryOptions"],
@@ -1901,7 +1950,8 @@ function createQueryGenerator({ name, variant }) {
 						queryKeyName,
 						node,
 						tsResolver: hook.tsResolver,
-						returnType: contractOp.returnType
+						clientReturnType: contractOp.returnType,
+						returnType: hook.returnType
 					})] }),
 					(variant !== "query" || query && hooks) && /* @__PURE__ */ jsxs(Fragment, { children: [
 						/* @__PURE__ */ jsx(File.Import, {
@@ -1925,6 +1975,7 @@ function createQueryGenerator({ name, variant }) {
 							node,
 							tsResolver: hook.tsResolver,
 							customOptions,
+							returnType: hook.returnType,
 							suspense,
 							infinite: infiniteOptions ? {
 								initialPageParam: infiniteOptions.initialPageParam,
@@ -1959,8 +2010,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, {
@@ -1975,8 +2026,11 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 		clientName,
 		signal: false,
 		withContentType: true,
+		returnType: clientReturnType
+	}), {
+		clientReturnType,
 		returnType
-	}), { returnType });
+	});
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -2002,8 +2056,8 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 const callPrinter = 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,
@@ -2018,18 +2072,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__ */ jsx(File.Source, {
 		name,
@@ -2052,7 +2109,7 @@ function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName
           ...baseOptions,${customOptions ? "\n          ...customOptions," : ""}
           mutationKey,
           ...mutationOptions,
-        }, queryClient) as ${returnType}
+        }, queryClient) as ${resultType}
     `
 		})
 	});
@@ -2096,7 +2153,8 @@ const mutationGenerator = defineGenerator({
 			name: mutationHookName,
 			output,
 			group,
-			contractOp
+			contractOp,
+			returnType: ctx.options.returnType
 		});
 		const { tsResolver } = hook;
 		return /* @__PURE__ */ jsxs(HookFile, {
@@ -2121,7 +2179,8 @@ const mutationGenerator = defineGenerator({
 					mutationKeyName,
 					node,
 					tsResolver,
-					returnType: contractOp.returnType
+					clientReturnType: contractOp.returnType,
+					returnType: hook.returnType
 				}),
 				mutation && hooks && /* @__PURE__ */ jsxs(Fragment, { children: [
 					/* @__PURE__ */ jsx(File.Import, {
@@ -2143,7 +2202,8 @@ const mutationGenerator = defineGenerator({
 						mutationKeyName,
 						node,
 						tsResolver,
-						customOptions
+						customOptions,
+						returnType: hook.returnType
 					})
 				] })
 			]
@@ -2278,7 +2338,7 @@ const pluginReactQuery = 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 ? Resolver.merge(resolverReactQuery, userResolver) : resolverReactQuery;
 		setResolver(resolver);
 		if (userMacros?.length) setMacros(userMacros);
@@ -2290,6 +2350,7 @@ const pluginReactQuery = defineExtension({
 				client,
 				plugins: useConfig().plugins
 			}),
+			returnType,
 			queryKey,
 			query: resolveQueryConfig(query, { importPath: "@tanstack/react-query" }),
 			mutationKey,