@kubb/plugin-vue-query 5.5.0 → 5.5.1

package/dist/index.js

@@ -1,27 +1,9 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
+import "./rolldown-runtime-C0LytTxp.js";
+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 { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
-//#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
@@ -91,12 +73,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`,
@@ -105,7 +87,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.
@@ -165,11 +147,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;
@@ -329,7 +319,96 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.5.0";
+var version = "5.5.1";
+//#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
 /**
@@ -614,11 +693,47 @@ const queryKeyGroupOrder = [
 	"query",
 	"body"
 ];
+/**
+* Build QueryKey params as the grouped `{ path, query, body }` object (NO headers, NO config),
+* typed from the operation's `Options` minus `url`. The query key transformer reads the
+* grouped `path`/`query`/`body` bindings.
+*/
+function buildQueryKeyParams(node, options) {
+	const { resolver, memberTypeWrapper } = options;
+	const groupedParam = buildGroupedRequestParam(node, {
+		resolver,
+		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";
+}
 //#endregion
 //#region ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
-const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
-const callPrinter$4 = functionPrinter({ mode: "call" });
-function InfiniteQueryOptions$1({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, returnType = "full" }) {
+const declarationPrinter$5 = 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);
 	const { queryParamsTypeName, pageParamType } = resolvePageParamType(node, {
 		resolver: tsResolver,
@@ -631,12 +746,12 @@ function InfiniteQueryOptions$1({ name, clientName, initialPageParam, hasExplici
 		memberTypeWrapper
 	});
 	const queryKeyParamsNode = createFunctionParameters({ params: groupedKeyParam ? [groupedKeyParam] : [] });
-	const queryKeyParamsCall = callPrinter$4.print(queryKeyParamsNode) ?? "";
+	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
 	const paramsNode = buildQueryOptionsParams(node, {
 		resolver: tsResolver,
 		memberTypeWrapper
 	});
-	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	const paramsSignature = declarationPrinter$5.print(paramsNode) ?? "";
 	const queryFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: true,
@@ -691,23 +806,22 @@ return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${que
 		})
 	});
 }
-__name(InfiniteQueryOptions$1, "InfiniteQueryOptions");
 //#endregion
 //#region ../../internals/tanstack-query/src/components/MutationKey.tsx
-const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
+const declarationPrinter$4 = 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$4.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,
@@ -718,7 +832,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
@@ -773,7 +897,9 @@ function createMutationResolver() {
 		}
 	};
 }
-functionPrinter({ mode: "declaration" });
+//#endregion
+//#region ../../internals/tanstack-query/src/components/QueryKey.tsx
+const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 const queryKeyTransformer = ({ node, variant }) => {
 	if (!node.path) return [];
 	const { path, query } = getOperationParameters(node);
@@ -786,6 +912,40 @@ 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", memberTypeWrapper, exportType }) {
+	const paramsNode = buildQueryKeyParams(node, {
+		resolver: tsResolver,
+		memberTypeWrapper
+	});
+	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
+	const keys = (transformer ?? queryKeyTransformer)({
+		node,
+		casing: "camelcase",
+		variant
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ jsx(File.Source, {
+		name: typeName,
+		isExportable: exportType,
+		isIndexable: exportType,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ jsx(Type, {
+			name: typeName,
+			export: exportType,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
 //#endregion
 //#region ../../internals/client/src/resolveClient.ts
 /**
@@ -829,7 +989,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) {
@@ -839,7 +999,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",
@@ -848,7 +1010,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 {
@@ -857,25 +1021,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
@@ -939,66 +1118,9 @@ function resolveClientOperation(options) {
 	});
 }
 //#endregion
-//#region src/utils.ts
-/**
-* Builds the call to a contract client `<op>` function inside a vue-query composable body. The
-* function takes a single grouped options object, so `config` is spread first, then the operation's
-* request groups are unwrapped with `toValue()`, then the abort `signal` for queries, with
-* `throwOnError: true` pinned last so a caller's config can't flip the query's error semantics.
-* Mutations omit the `signal`.
-*/
-function buildVueClientCall(node, options) {
-	return buildClientCall(node, {
-		...options,
-		unwrapName: (name) => `toValue(${name})`
-	});
-}
-//#endregion
-//#region src/components/QueryKey.tsx
-const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
-function buildQueryKeyParamsNode(node, options) {
-	const groupedParam = buildGroupedRequestParam(node, {
-		resolver: options.resolver,
-		keys: queryKeyGroupOrder,
-		memberTypeWrapper: maybeRefOrGetter
-	});
-	return createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
-}
-function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "query" }) {
-	const paramsNode = buildQueryKeyParamsNode(node, { resolver: tsResolver });
-	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
-	const keys = (transformer ?? queryKeyTransformer)({
-		node,
-		casing: "camelcase",
-		variant
-	});
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function.Arrow, {
-			name,
-			export: true,
-			params: paramsSignature,
-			singleLine: true,
-			children: `[${keys.join(", ")}] as const`
-		})
-	}), /* @__PURE__ */ jsx(File.Source, {
-		name: typeName,
-		isExportable: true,
-		isIndexable: true,
-		isTypeOnly: true,
-		children: /* @__PURE__ */ jsx(Type, {
-			name: typeName,
-			export: true,
-			children: `ReturnType<typeof ${name}>`
-		})
-	})] });
-}
-//#endregion
 //#region src/components/QueryOptions.tsx
-const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
-const callPrinter$3 = functionPrinter({ mode: "call" });
+const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
+const callPrinter$2 = functionPrinter({ mode: "call" });
 function getQueryOptionsParams(node, options) {
 	return buildQueryOptionsParams(node, {
 		resolver: options.resolver,
@@ -1007,13 +1129,17 @@ function getQueryOptionsParams(node, options) {
 }
 function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, returnType = "full" }) {
 	const { TData, TError } = buildResponseTypes(node, tsResolver);
-	const queryKeyParamsNode = buildQueryKeyParamsNode(node, { resolver: tsResolver });
-	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
+	const queryKeyParamsNode = buildQueryKeyParams(node, {
+		resolver: tsResolver,
+		memberTypeWrapper: maybeRefOrGetter
+	});
+	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
 	const paramsNode = getQueryOptionsParams(node, { resolver: tsResolver });
-	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
-	const queryFnBody = buildCallResultBody(buildVueClientCall(node, {
+	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
+	const queryFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
-		signal: true
+		signal: true,
+		unwrapName: (name) => `toValue(${name})`
 	}), { returnType });
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -1036,201 +1162,61 @@ function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, return
 	});
 }
 //#endregion
-//#region src/components/InfiniteQuery.tsx
-const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
-const callPrinter$2 = functionPrinter({ mode: "call" });
-function buildInfiniteQueryParamsNode(node, options) {
-	const { resolver } = options;
-	const { TData, TError } = buildResponseTypes(node, resolver);
-	const optionsParam = createFunctionParameter({
-		name: "options",
-		type: `{
-  query?: Partial<UseInfiniteQueryOptions<${[
-			TData,
-			TError,
-			"TQueryData",
-			"TQueryKey",
-			"TQueryData"
-		].join(", ")}>> & { client?: QueryClient },
-  client?: ${buildClientOptionType()}
-}`,
-		default: "{}"
-	});
-	const groupedParam = buildGroupedRequestParam(node, {
-		resolver,
-		memberTypeWrapper: maybeRefOrGetter
-	});
-	return createFunctionParameters({ params: [groupedParam, optionsParam].filter((param) => param !== null) });
-}
-function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver }) {
+//#region src/components/Query.tsx
+const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
+const callPrinter$1 = functionPrinter({ mode: "call" });
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, infinite }) {
 	const { TData, TError } = buildResponseTypes(node, tsResolver);
-	const returnType = `UseInfiniteQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
+	const optionsName = infinite ? "UseInfiniteQueryOptions" : "UseQueryOptions";
+	const hookName = infinite ? "useInfiniteQuery" : "useQuery";
+	const returnType = `${infinite ? "UseInfiniteQueryReturnType" : "UseQueryReturnType"}<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
 	const generics = [
-		`TData = InfiniteData<${TData}>`,
+		infinite ? `TData = InfiniteData<${TData}>` : `TData = ${TData}`,
 		`TQueryData = ${TData}`,
 		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
 	];
-	const queryKeyParamsNode = buildQueryKeyParamsNode(node, { resolver: tsResolver });
-	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
-	const queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
-	const queryOptionsParamsCall = callPrinter$2.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = buildInfiniteQueryParamsNode(node, { resolver: tsResolver });
-	const paramsSignature = declarationPrinter$2.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			generics: generics.join(", "),
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			children: `
-       const { query: queryConfig = {}, client: config = {} } = options ?? {}
-       const { client: queryClient, ...resolvedOptions } = queryConfig
-       const queryKey = (resolvedOptions && 'queryKey' in resolvedOptions ? toValue(resolvedOptions.queryKey) : undefined) ?? ${queryKeyName}(${queryKeyParamsCall})
-
-       const queryResult = useInfiniteQuery({
-        ...${queryOptionsName}(${queryOptionsParamsCall}),
-        ...resolvedOptions,
-        queryKey
-       } as unknown as UseInfiniteQueryOptions<${TData}, ${TError}, ${TData}, TQueryKey, ${TData}>, toValue(queryClient)) as ${returnType}
-
-       queryResult.queryKey = queryKey as TQueryKey
-
-       return queryResult
-       `
-		})
-	});
-}
-//#endregion
-//#region src/components/InfiniteQueryOptions.tsx
-/**
-* The vue-query flavor of the shared `infiniteQueryOptions` component: request groups accept
-* `MaybeRefOrGetter` values, are unwrapped with `toValue(...)` in the client call, and the emitted
-* `TQueryKey` generic is the imported `QueryKey` type instead of `typeof queryKey`.
-*/
-function InfiniteQueryOptions(props) {
-	return /* @__PURE__ */ jsx(InfiniteQueryOptions$1, {
-		...props,
-		queryKeyType: "QueryKey",
-		memberTypeWrapper: maybeRefOrGetter,
-		unwrapName: (name) => `toValue(${name})`
-	});
-}
-//#endregion
-//#region src/components/Mutation.tsx
-const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
-const callPrinter$1 = functionPrinter({ mode: "call" });
-function resolveMutationRequestType(node, resolver) {
-	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
-}
-function buildMutationParamsNode(node, options) {
-	const { resolver } = options;
-	const { TData, TError } = buildResponseTypes(node, resolver);
-	const TRequest = resolveMutationRequestType(node, resolver);
-	return createFunctionParameters({ params: [createFunctionParameter({
-		name: "options",
-		type: `{
-  mutation?: MutationObserverOptions<${[
-			TData,
-			TError,
-			TRequest,
-			"TContext"
-		].join(", ")}> & { client?: QueryClient },
-  client?: ${buildRequestConfigType(node)},
-}`,
-		default: "{}"
-	})] });
-}
-function Mutation({ name, clientName, node, tsResolver, mutationKeyName, returnType = "full" }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
-	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
-	const hasMutationParams = groupedParam !== null;
-	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
-	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "";
-	const TRequest = resolveMutationRequestType(node, tsResolver);
-	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
-		clientName,
-		signal: false,
-		unwrapName: (name) => `toValue<${TRequest}['${name}']>(${name})`
-	}), { returnType });
-	const generics = [
+	const optionsGenerics = infinite ? [
 		TData,
 		TError,
-		TRequest,
-		"TContext"
-	].join(", ");
-	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
-	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsx(Function, {
-			name,
-			export: true,
-			params: paramsSignature,
-			JSDoc: { comments: buildOperationComments(node) },
-			generics: ["TContext"],
-			children: `
-        const { mutation = {}, client: config = {} } = options ?? {}
-        const { client: queryClient, ...mutationOptions } = mutation;
-        const mutationKey = mutationOptions?.mutationKey ?? ${mutationKeyName}()
-
-        return useMutation<${generics}>({
-          mutationFn: async(${argBindingStr}) => {
-            ${mutationFnBody}
-          },
-          mutationKey,
-          ...mutationOptions
-        }, queryClient)
-    `
-		})
-	});
-}
-//#endregion
-//#region src/components/Query.tsx
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-const callPrinter = functionPrinter({ mode: "call" });
-function buildQueryParamsNode(node, options) {
-	const { resolver } = options;
-	const { TData, TError } = buildResponseTypes(node, resolver);
-	const optionsParam = createFunctionParameter({
-		name: "options",
-		type: `{
-  query?: Partial<UseQueryOptions<${[
-			TData,
-			TError,
-			"TData",
-			"TQueryData",
-			"TQueryKey"
-		].join(", ")}>> & { client?: QueryClient },
-  client?: ${buildClientOptionType()}
-}`,
-		default: "{}"
-	});
-	const groupedParam = buildGroupedRequestParam(node, {
-		resolver,
+		"TQueryData",
+		"TQueryKey",
+		"TQueryData"
+	] : [
+		TData,
+		TError,
+		"TData",
+		"TQueryData",
+		"TQueryKey"
+	];
+	const castGenerics = infinite ? [
+		TData,
+		TError,
+		TData,
+		"TQueryKey",
+		TData
+	] : [
+		TData,
+		TError,
+		"TData",
+		TData,
+		"TQueryKey"
+	];
+	const queryKeyParamsNode = buildQueryKeyParams(node, {
+		resolver: tsResolver,
 		memberTypeWrapper: maybeRefOrGetter
 	});
-	return createFunctionParameters({ params: [groupedParam, optionsParam].filter((param) => param !== null) });
-}
-function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
-	const returnType = `UseQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
-	const generics = [
-		`TData = ${TData}`,
-		`TQueryData = ${TData}`,
-		`TQueryKey extends QueryKey = ${queryKeyTypeName}`
-	];
-	const queryKeyParamsNode = buildQueryKeyParamsNode(node, { resolver: tsResolver });
-	const queryKeyParamsCall = callPrinter.print(queryKeyParamsNode) ?? "";
+	const queryKeyParamsCall = callPrinter$1.print(queryKeyParamsNode) ?? "";
 	const queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
-	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
-	const paramsNode = buildQueryParamsNode(node, { resolver: tsResolver });
-	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	const queryOptionsParamsCall = callPrinter$1.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildHookParams(node, {
+		resolver: tsResolver,
+		memberTypeWrapper: maybeRefOrGetter,
+		optionsType: `{
+  query?: Partial<${optionsName}<${optionsGenerics.join(", ")}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`
+	});
+	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -1246,11 +1232,11 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
        const { client: queryClient, ...resolvedOptions } = queryConfig
        const queryKey = (resolvedOptions && 'queryKey' in resolvedOptions ? toValue(resolvedOptions.queryKey) : undefined) ?? ${queryKeyName}(${queryKeyParamsCall})
 
-       const queryResult = useQuery({
+       const queryResult = ${hookName}({
         ...${queryOptionsName}(${queryOptionsParamsCall}),
         ...resolvedOptions,
         queryKey
-       } as unknown as UseQueryOptions<${TData}, ${TError}, TData, ${TData}, TQueryKey>, toValue(queryClient)) as ${returnType}
+       } as unknown as ${optionsName}<${castGenerics.join(", ")}>, toValue(queryClient)) as ${returnType}
 
        queryResult.queryKey = queryKey as TQueryKey
 
@@ -1284,14 +1270,12 @@ const infiniteQueryGenerator = defineGenerator({
 	},
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
+		const { driver, resolver, root } = ctx;
 		const { output, query, infinite, client, group } = ctx.options;
 		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
 		if (!infiniteOptions) return null;
 		const pageParamsWarning = getDefaultPageParamsWarning(node, infiniteOptions);
 		if (pageParamsWarning) ctx.warn(pageParamsWarning);
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
 		const importPath = query ? query.importPath : "@tanstack/vue-query";
 		const contractOp = resolveClientOperation({
 			clientPlugin: { pluginName: client.pluginName },
@@ -1306,91 +1290,39 @@ const infiniteQueryGenerator = defineGenerator({
 		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 hook = resolveHookFile(node, ctx, {
+			name: queryName,
+			output,
+			group,
+			contractOp,
+			keyTypeName: queryKeyTypeName,
+			extraTypeNames: [resolvePageParamType(node, {
+				resolver: ctx.driver.getResolver(pluginTsName),
+				initialPageParam: infiniteOptions.initialPageParam,
+				queryParam: infiniteOptions.queryParam
+			}).queryParamsTypeName]
 		});
-		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
-				}
-			}),
+		const { tsResolver } = hook;
+		return /* @__PURE__ */ jsxs(HookFile, {
+			hook,
+			imports: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
+				name: ["toValue"],
+				path: "vue"
+			}), /* @__PURE__ */ jsx(File.Import, {
+				name: ["MaybeRefOrGetter"],
+				path: "vue",
+				isTypeOnly: true
+			})] }),
 			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
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["toValue"],
-					path: "vue"
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["MaybeRefOrGetter"],
-					path: "vue",
-					isTypeOnly: true
-				}),
-				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"
+					variant: "infiniteQuery",
+					memberTypeWrapper: maybeRefOrGetter,
+					exportType: true
 				}),
 				/* @__PURE__ */ jsx(File.Import, {
 					name: ["InfiniteData"],
@@ -1403,7 +1335,7 @@ const infiniteQueryGenerator = defineGenerator({
 				}),
 				/* @__PURE__ */ jsx(InfiniteQueryOptions, {
 					name: queryOptionsName,
-					clientName: calledClientName,
+					clientName: contractOp.name,
 					queryKeyName,
 					node,
 					tsResolver,
@@ -1415,7 +1347,10 @@ const infiniteQueryGenerator = defineGenerator({
 					initialPageParam: infiniteOptions.initialPageParam,
 					hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
 					queryParam: infiniteOptions.queryParam,
-					returnType: contractOp.returnType
+					returnType: contractOp.returnType,
+					queryKeyType: "QueryKey",
+					memberTypeWrapper: maybeRefOrGetter,
+					unwrapName: (name) => `toValue(${name})`
 				}),
 				/* @__PURE__ */ jsx(File.Import, {
 					name: ["useInfiniteQuery"],
@@ -1431,21 +1366,87 @@ const infiniteQueryGenerator = defineGenerator({
 					path: importPath,
 					isTypeOnly: true
 				}),
-				/* @__PURE__ */ jsx(InfiniteQuery, {
+				/* @__PURE__ */ jsx(Query, {
 					name: queryName,
 					queryOptionsName,
 					queryKeyName,
 					queryKeyTypeName,
 					node,
 					tsResolver,
-					initialPageParam: infiniteOptions.initialPageParam,
-					queryParam: infiniteOptions.queryParam
+					infinite: true
 				})
 			]
 		});
 	}
 });
 //#endregion
+//#region src/components/Mutation.tsx
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+const callPrinter = functionPrinter({ mode: "call" });
+function buildMutationParamsNode(node, options) {
+	const { resolver } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver);
+	return buildHookParams(node, {
+		resolver,
+		withRequest: false,
+		optionsType: `{
+  mutation?: MutationObserverOptions<${[
+			TData,
+			TError,
+			resolveMutationRequestType(node, resolver),
+			"TContext"
+		].join(", ")}> & { client?: QueryClient },
+  client?: ${buildRequestConfigType(node)},
+}`
+	});
+}
+function Mutation({ name, clientName, node, tsResolver, mutationKeyName, returnType = "full" }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
+	const hasMutationParams = groupedParam !== null;
+	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
+	const argBindingStr = hasMutationParams ? callPrinter.print(groupedParamsNode) ?? "" : "";
+	const TRequest = resolveMutationRequestType(node, tsResolver);
+	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
+		clientName,
+		signal: false,
+		unwrapName: (name) => `toValue<${TRequest}['${name}']>(${name})`
+	}), { returnType });
+	const generics = [
+		TData,
+		TError,
+		TRequest,
+		"TContext"
+	].join(", ");
+	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ jsx(Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			JSDoc: { comments: buildOperationComments(node) },
+			generics: ["TContext"],
+			children: `
+        const { mutation = {}, client: config = {} } = options ?? {}
+        const { client: queryClient, ...mutationOptions } = mutation;
+        const mutationKey = mutationOptions?.mutationKey ?? ${mutationKeyName}()
+
+        return useMutation<${generics}>({
+          mutationFn: async(${argBindingStr}) => {
+            ${mutationFnBody}
+          },
+          mutationKey,
+          ...mutationOptions
+        }, queryClient)
+    `
+		})
+	});
+}
+//#endregion
 //#region src/generators/mutationGenerator.tsx
 /**
 * Built-in generator for `useMutation` composables. Emits one
@@ -1457,10 +1458,8 @@ const mutationGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
+		const { driver, resolver, root } = ctx;
 		const { output, query, mutation, client, group, hooks } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
 		const { isMutation } = classifyOperation(node, {
 			query,
 			mutation
@@ -1477,104 +1476,48 @@ const mutationGenerator = defineGenerator({
 		});
 		if (!contractOp) return null;
 		const mutationHookName = resolver.mutation.name(node);
-		const mutationTypeName = resolver.mutation.typeName(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;
+		const hook = resolveHookFile(node, ctx, {
+			name: mutationHookName,
+			output,
+			group,
+			contractOp
+		});
 		const groups = getRequestGroups(node);
 		const hasRequestGroups = groups.path || groups.query || groups.body || groups.headers;
-		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
-				}),
+		return /* @__PURE__ */ jsxs(HookFile, {
+			hook,
+			imports: /* @__PURE__ */ jsxs(Fragment, { children: [hasRequestGroups && /* @__PURE__ */ jsx(File.Import, {
+				name: ["toValue"],
+				path: "vue"
+			}), /* @__PURE__ */ jsx(File.Import, {
+				name: ["MaybeRefOrGetter"],
+				path: "vue",
+				isTypeOnly: true
+			})] }),
+			children: [/* @__PURE__ */ jsx(MutationKey, {
+				name: mutationKeyName,
+				node,
+				transformer: ctx.options.mutationKey
+			}), mutation && hooks && /* @__PURE__ */ jsxs(Fragment, { children: [
 				/* @__PURE__ */ jsx(File.Import, {
-					name: ["RequestConfig", "ResponseErrorConfig"],
-					root: contractOp.clientPathIsFile ? meta.file.path : void 0,
-					path: contractOp.clientPath,
-					isTypeOnly: true
-				}),
-				hasRequestGroups && /* @__PURE__ */ jsx(File.Import, {
-					name: ["toValue"],
-					path: "vue"
+					name: ["useMutation"],
+					path: importPath
 				}),
 				/* @__PURE__ */ jsx(File.Import, {
-					name: ["MaybeRefOrGetter"],
-					path: "vue",
-					isTypeOnly: true
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: Array.from(new Set(importedTypeNames)),
-					root: meta.file.path,
-					path: meta.fileTs.path,
+					name: ["MutationObserverOptions", "QueryClient"],
+					path: importPath,
 					isTypeOnly: true
 				}),
-				/* @__PURE__ */ jsx(MutationKey, {
-					name: mutationKeyName,
+				/* @__PURE__ */ jsx(Mutation, {
+					name: mutationHookName,
+					clientName: contractOp.name,
 					node,
-					transformer: ctx.options.mutationKey
-				}),
-				mutation && hooks && /* @__PURE__ */ jsxs(Fragment, { children: [
-					/* @__PURE__ */ jsx(File.Import, {
-						name: ["useMutation"],
-						path: importPath
-					}),
-					/* @__PURE__ */ jsx(File.Import, {
-						name: ["MutationObserverOptions", "QueryClient"],
-						path: importPath,
-						isTypeOnly: true
-					}),
-					/* @__PURE__ */ jsx(Mutation, {
-						name: mutationHookName,
-						clientName: calledClientName,
-						typeName: mutationTypeName,
-						node,
-						tsResolver,
-						mutationKeyName,
-						returnType: contractOp.returnType
-					})
-				] })
-			]
+					tsResolver: hook.tsResolver,
+					mutationKeyName,
+					returnType: contractOp.returnType
+				})
+			] })]
 		});
 	}
 });
@@ -1590,10 +1533,8 @@ const queryGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
+		const { driver, resolver, root } = ctx;
 		const { output, query, mutation, client, group, hooks } = ctx.options;
-		const pluginTs = ctx.requirePlugin(pluginTsName);
-		const tsResolver = driver.getResolver(pluginTsName);
 		const { isQuery, isMutation } = classifyOperation(node, {
 			query,
 			mutation
@@ -1613,82 +1554,34 @@ const queryGenerator = defineGenerator({
 		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
-				}
-			}),
+		const hook = resolveHookFile(node, ctx, {
+			name: queryName,
+			output,
+			group,
+			contractOp,
+			keyTypeName: queryKeyTypeName
+		});
+		const { tsResolver } = hook;
+		return /* @__PURE__ */ jsxs(HookFile, {
+			hook,
+			imports: /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
+				name: ["toValue"],
+				path: "vue"
+			}), /* @__PURE__ */ jsx(File.Import, {
+				name: ["MaybeRefOrGetter"],
+				path: "vue",
+				isTypeOnly: true
+			})] }),
 			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
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["toValue"],
-					path: "vue"
-				}),
-				/* @__PURE__ */ jsx(File.Import, {
-					name: ["MaybeRefOrGetter"],
-					path: "vue",
-					isTypeOnly: true
-				}),
-				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"
+					variant: "query",
+					memberTypeWrapper: maybeRefOrGetter,
+					exportType: true
 				}),
 				/* @__PURE__ */ jsx(File.Import, {
 					name: ["queryOptions"],
@@ -1696,7 +1589,7 @@ const queryGenerator = defineGenerator({
 				}),
 				/* @__PURE__ */ jsx(QueryOptions, {
 					name: queryOptionsName,
-					clientName: calledClientName,
+					clientName: contractOp.name,
 					queryKeyName,
 					node,
 					tsResolver,
@@ -1812,6 +1705,7 @@ const pluginVueQuery = defineExtension({
 		return {
 			output,
 			client: resolveContractClient({
+				plugin: pluginVueQueryName,
 				client,
 				plugins: useConfig().plugins
 			}),