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

package/dist/index.cjs

@@ -2,149 +2,1673 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_components = require("./components-X0P-3W2G.cjs");
-const require_generators = require("./generators-BE3KD0IR.cjs");
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let kubb_kit = require("kubb/kit");
 let node_path = require("node:path");
-node_path = require_components.__toESM(node_path, 1);
-let _kubb_core = require("@kubb/core");
-let _kubb_plugin_client = require("@kubb/plugin-client");
-let _kubb_plugin_client_templates_clients_axios_source = require("@kubb/plugin-client/templates/clients/axios.source");
-let _kubb_plugin_client_templates_clients_fetch_source = require("@kubb/plugin-client/templates/clients/fetch.source");
-let _kubb_plugin_client_templates_config_source = require("@kubb/plugin-client/templates/config.source");
+node_path = __toESM(node_path, 1);
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
-let _kubb_plugin_zod = require("@kubb/plugin-zod");
-//#region src/resolvers/resolverVueQuery.ts
-function capitalize(name) {
-	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+let kubb_jsx = require("kubb/jsx");
+let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+function getOperationLink(node, link) {
+	if (!link) return null;
+	if (typeof link === "function") return link(node) ?? null;
+	return node.path ? `{@link ${kubb_kit.Url.toPath(node.path)}}` : null;
+}
+/**
+* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
+* are present and the union, default, and form-data flags the client uses to pick one.
+*/
+function buildContentTypeInfo(contentTypes) {
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+function getContentTypeInfo(node) {
+	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
+}
+/**
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
+*/
+function getResponseContentTypeInfo(node) {
+	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
+}
+function buildRequestConfigType(node) {
+	const request = getContentTypeInfo(node);
+	const response = getResponseContentTypeInfo(node);
+	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
+	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : configType;
+}
+/**
+* Builds the `client?:` option type shared by the generated query hooks (`useQuery`,
+* `useInfiniteQuery`, `useSWR`, ...). Unlike {@link buildRequestConfigType}, it never adds a
+* `contentType?:` member: query hooks wrap GET operations, which carry no request body to select a
+* content type for.
+*/
+function buildClientOptionType() {
+	return `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
+/**
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
+*/
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
+}
+function buildOperationComments(node, options = {}) {
+	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
+	const linkComment = getOperationLink(node, link);
+	const filteredComments = (linkPosition === "beforeDeprecated" ? [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		linkComment,
+		node.deprecated && "@deprecated"
+	] : [
+		node.description && `@description ${node.description}`,
+		node.summary && `@summary ${node.summary}`,
+		node.deprecated && "@deprecated",
+		linkComment
+	]).filter((comment) => Boolean(comment));
+	if (!splitLines) return filteredComments;
+	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
+}
+function getOperationParameters(node) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+}
+function getStatusCodeNumber(statusCode) {
+	const code = Number(statusCode);
+	return Number.isNaN(code) ? null : code;
+}
+function isSuccessStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 200 && code < 300;
+}
+function isErrorStatusCode(statusCode) {
+	const code = getStatusCodeNumber(statusCode);
+	return code !== null && code >= 400;
+}
+function getSuccessResponses(responses) {
+	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
+}
+function getOperationSuccessResponses(node) {
+	return getSuccessResponses(node.responses);
+}
+function getPrimarySuccessResponse(node) {
+	return getOperationSuccessResponses(node)[0] ?? null;
+}
+function resolveErrorNames(node, resolver) {
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
+}
+function resolveSuccessNames(node, resolver) {
+	return node.responses.filter((response) => isSuccessStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
+}
+function resolveStatusCodeNames(node, resolver) {
+	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
+}
+const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+function resolveOperationTypeNames(node, resolver, options = {}) {
+	const cacheKey = `${node.operationId}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${options.includeParams === false ? "noparams" : ""}\0${(options.exclude ?? []).join(",")}`;
+	let byResolver = typeNamesByResolver.get(resolver);
+	if (byResolver) {
+		const cached = byResolver.get(cacheKey);
+		if (cached) return cached;
+	} else {
+		byResolver = /* @__PURE__ */ new Map();
+		typeNamesByResolver.set(resolver, byResolver);
+	}
+	const { path, query, header } = getOperationParameters(node);
+	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
+	const exclude = new Set(options.exclude ?? []);
+	const paramNames = options.includeParams === false ? [] : [
+		...path.map((param) => resolver.param.path(node, param)),
+		...query.map((param) => resolver.param.query(node, param)),
+		...header.map((param) => resolver.param.headers(node, param))
+	];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)];
+	const result = (options.order === "body-response-first" ? [
+		...bodyAndResponseNames,
+		...paramNames,
+		...responseStatusNames
+	] : [
+		...paramNames,
+		...bodyAndResponseNames,
+		...responseStatusNames
+	]).filter((name) => Boolean(name) && !exclude.has(name));
+	byResolver.set(cacheKey, result);
+	return result;
+}
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Uppercases only the first character of `text`, leaving the rest untouched.
+* Unlike {@link pascalCase} it never re-splits word boundaries or strips characters.
+*
+* @example
+* `capitalize('getPetById') // 'GetPetById'`
+*/
+function capitalize(text) {
+	return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+//#endregion
+//#region ../../internals/utils/src/strings.ts
+/**
+* Renders a dotted path or string array as an optional-chaining accessor expression rooted at
+* `accessor`. Returns `null` for an empty path.
+*
+* @example
+* ```ts
+* getNestedAccessor('pagination.next.id', 'lastPage')
+* // "lastPage?.['pagination']?.['next']?.['id']"
+* ```
+*/
+function getNestedAccessor(param, accessor) {
+	const parts = Array.isArray(param) ? param : param.split(".");
+	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
+	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/utils.ts
+/**
+* The grouped request options, ordered for both the destructured signature and the
+* call passed to the underlying client.
+*/
+const requestGroupOrder = [
+	"path",
+	"query",
+	"body",
+	"headers"
+];
+/**
+* Widens a request-group member type so a generated TanStack hook accepts either the value or a
+* deferred value. Both plugins apply this through the `memberTypeWrapper` of `buildGroupedRequestParam`;
+* they only differ in how the deferred form is later resolved.
+*
+* `maybeRefOrGetter` is used by vue-query, which keeps the ref/getter live and unwraps it lazily with
+* `toValue` because vue-query keys are reactive. `maybeValueOrGetter` is used by react-query, which
+* resolves the getter once at the hook boundary and forwards a plain value because React Query hashes
+* keys structurally and cannot hold a function.
+*/
+function maybeRefOrGetter(type) {
+	return `MaybeRefOrGetter<${type}>`;
+}
+/**
+* Builds the grouped `{ path, query, body, headers }` parameter that mirrors the client
+* function signature. Only the groups the operation carries are emitted, typed from the
+* operation's `Options`. `keys` narrows the emitted groups, used by the query key which
+* never carries `headers`.
+*
+* By default the whole group is typed as the single `Options` reference. When
+* `memberTypeWrapper` is set, each group is emitted as its own member typed from the matching
+* `Options['<group>']` slice and wrapped, used by vue-query to apply
+* `MaybeRefOrGetter` per group.
+*/
+function buildGroupedRequestParam(node, options) {
+	const { resolver, keys = requestGroupOrder, memberTypeWrapper } = options;
+	const { groups, hasRequiredPath, hasRequiredQuery, hasRequiredHeader } = getRequestGroupOptionality(node);
+	const names = keys.filter((key) => groups[key]);
+	if (names.length === 0) return null;
+	const requiredByGroup = {
+		path: hasRequiredPath,
+		query: hasRequiredQuery,
+		body: groups.body,
+		headers: hasRequiredHeader
+	};
+	const isOptional = names.every((name) => !requiredByGroup[name]);
+	const optionsName = resolver.response.options(node);
+	const omittedKeys = requestGroupOrder.filter((key) => !keys.includes(key));
+	const optionsType = omittedKeys.length > 0 ? `Omit<${optionsName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : optionsName;
+	if (memberTypeWrapper) {
+		const members = names.map((name) => ({
+			name,
+			type: memberTypeWrapper(`${optionsType}['${name}']`),
+			optional: !requiredByGroup[name]
+		}));
+		return (0, _kubb_plugin_ts.createFunctionParameter)({
+			name: (0, _kubb_plugin_ts.createObjectBindingPattern)({ elements: names.map((name) => ({ name })) }),
+			type: (0, _kubb_plugin_ts.createTypeLiteral)({ members }),
+			optional: false,
+			...isOptional ? { default: "{}" } : {}
+		});
+	}
+	return (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: (0, _kubb_plugin_ts.createObjectBindingPattern)({ elements: names.map((name) => ({ name })) }),
+		type: optionsType,
+		optional: false,
+		...isOptional ? { default: "{}" } : {}
+	});
+}
+/**
+* Builds the shared `({ path, query, body, headers }, config = {})` parameter list for a
+* TanStack query-options function. The leading parameter mirrors the client signature, and the
+* trailing `config` is a partial `RequestConfig` minus the grouped data-shape keys, which are passed
+* explicitly. Framework plugins wrap the result when needed, for example vue-query applies `MaybeRefOrGetter`.
+*/
+function buildQueryOptionsParams(node, options) {
+	const { resolver, memberTypeWrapper } = options;
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper
+	}), (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "config",
+		type: `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`,
+		default: "{}"
+	})].filter((param) => param !== null) });
 }
 /**
-* Naming convention resolver for Vue Query plugin.
+* Builds the call to a client `<op>` function inside a query/mutation hook body. The function takes
+* a single grouped options object, so the operation's request groups are passed as
+* shorthand alongside the spread `config`, with `throwOnError: true` pinned last so a caller's config
+* can't flip the query's error semantics. Queries thread the TanStack `signal`; mutations omit it.
 *
-* Provides default naming helpers using camelCase for functions and file paths.
+* When `unwrapName` is set, each request group is passed as an explicit member unwrapped through it,
+* used by vue-query to resolve refs and getters with `toValue(...)` at call time.
+*
+* @example
+* ```ts
+* buildClientCall(node, { clientName: 'getPetById', signal: true })
+* // getPetById({ path, ...config, signal: config.signal ?? signal, throwOnError: true })
+* ```
+*/
+function buildClientCall(node, options) {
+	const { clientName, signal = false, unwrapName } = options;
+	const { groups } = getRequestGroupOptionality(node);
+	return `${clientName}({ ${[
+		"...config",
+		...requestGroupOrder.filter((key) => groups[key]).map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		signal ? "signal: config.signal ?? signal" : null,
+		"throwOnError: true"
+	].filter((part) => part !== null).join(", ")} })`;
+}
+/**
+* Builds the `TData` / `TError` type expressions shared by every generated hook, joining the resolved
+* success responses into `TData` and wrapping the error responses in `ResponseErrorConfig<...>`.
+*/
+function buildResponseTypes(node, resolver) {
+	const successNames = resolveSuccessNames(node, resolver);
+	const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
+	const errorNames = resolveErrorNames(node, resolver);
+	return {
+		TData: responseName,
+		TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
+	};
+}
+function resolveFallbackPageParamType(initialPageParam) {
+	if (typeof initialPageParam === "number") return "number";
+	if (typeof initialPageParam === "boolean") return "boolean";
+	if (typeof initialPageParam !== "string") return "unknown";
+	if (!initialPageParam.includes(" as ")) return "string";
+	return initialPageParam.split(" as ").at(-1) ?? "unknown";
+}
+/**
+* Resolves the `TPageParam` generic for the infinite-query hooks. Prefers the type read from the
+* configured `queryParam` on the operation's query object, and falls back to the type inferred from
+* `initialPageParam` when that parameter type is unavailable. Also returns the query params type name
+* so callers can reuse it when rewriting the paginated request.
+*/
+function resolvePageParamType(node, { resolver, initialPageParam, queryParam }) {
+	const firstQueryParam = getOperationParameters(node).query[0];
+	const groupName = firstQueryParam ? resolver.param.query(node, firstQueryParam) : null;
+	const queryParamsTypeName = groupName !== (firstQueryParam ? resolver.param.name(node, firstQueryParam) : null) ? groupName : null;
+	const queryParamType = queryParam && queryParamsTypeName ? `${queryParamsTypeName}['${queryParam}']` : null;
+	if (!queryParamType) return {
+		queryParamsTypeName,
+		pageParamType: resolveFallbackPageParamType(initialPageParam)
+	};
+	return {
+		queryParamsTypeName,
+		pageParamType: initialPageParam !== void 0 && initialPageParam !== null ? `NonNullable<${queryParamType}>` : queryParamType
+	};
+}
+/**
+* Applies the shared query defaults during plugin setup: `false` disables query generation, and an
+* object merges over `methods: ['GET']` and the plugin's runtime `importPath`.
+*/
+function resolveQueryConfig(query, options) {
+	if (query === false) return false;
+	return {
+		importPath: options.importPath,
+		methods: ["GET"],
+		...query
+	};
+}
+/**
+* Applies the shared mutation defaults during plugin setup: `false` disables mutation generation,
+* and an object merges over `methods: ['POST', 'PUT', 'PATCH', 'DELETE']` and the plugin's runtime
+* `importPath`.
+*/
+function resolveMutationConfig(mutation, options) {
+	if (mutation === false) return false;
+	return {
+		importPath: options.importPath,
+		methods: [
+			"POST",
+			"PUT",
+			"PATCH",
+			"DELETE"
+		],
+		...mutation
+	};
+}
+/**
+* Classifies an operation as a query or a mutation from the resolved `query` / `mutation` method lists.
+* `query: false` still marks the operation as a query so the query-family generators keep matching it,
+* and a method already claimed by `query` never counts as a mutation.
 */
-const resolverVueQuery = (0, _kubb_core.defineResolver)(() => ({
-	name: "default",
+function classifyOperation(node, { query, mutation }) {
+	const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+	const queryMethods = new Set(query ? query.methods : []);
+	return {
+		isQuery,
+		isMutation: mutation !== false && !isQuery && (mutation ? mutation.methods : []).some((method) => !queryMethods.has(method) && node.method.toLowerCase() === method.toLowerCase())
+	};
+}
+/**
+* Applies the shared infinite-query defaults during plugin setup: a falsy value disables infinite
+* queries, and an object merges over `queryParam: 'id'` and `initialPageParam: 0` with the cursor
+* paths cleared.
+*/
+function resolveInfiniteConfig(infinite) {
+	if (!infinite) return false;
+	return {
+		queryParam: "id",
+		initialPageParam: 0,
+		cursorParam: null,
+		nextParam: null,
+		previousParam: null,
+		...infinite
+	};
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
+const declarationPrinter$7 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter$4 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function InfiniteQueryOptions$1({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName }) {
+	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver);
+	const { queryParamsTypeName, pageParamType } = resolvePageParamType(node, {
+		resolver: tsResolver,
+		initialPageParam,
+		queryParam
+	});
+	const groupedKeyParam = buildGroupedRequestParam(node, {
+		resolver: tsResolver,
+		keys: [
+			"path",
+			"query",
+			"body"
+		],
+		memberTypeWrapper
+	});
+	const queryKeyParamsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedKeyParam ? [groupedKeyParam] : [] });
+	const queryKeyParamsCall = callPrinter$4.print(queryKeyParamsNode) ?? "";
+	const paramsNode = buildQueryOptionsParams(node, {
+		resolver: tsResolver,
+		memberTypeWrapper
+	});
+	const paramsSignature = declarationPrinter$7.print(paramsNode) ?? "";
+	const queryFnBody = `const { data } = await ${buildClientCall(node, {
+		clientName,
+		signal: true,
+		unwrapName
+	})}
+    return data`;
+	const hasNewParams = nextParam != null || previousParam != null;
+	const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
+		if (hasNewParams) {
+			const nextAccessor = nextParam ? getNestedAccessor(nextParam, "lastPage") : null;
+			const prevAccessor = previousParam ? getNestedAccessor(previousParam, "firstPage") : null;
+			return [nextAccessor ? `getNextPageParam: (lastPage) => ${nextAccessor}` : null, prevAccessor ? `getPreviousPageParam: (firstPage) => ${prevAccessor}` : null];
+		}
+		if (cursorParam) return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`];
+		return ["getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1", "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1"];
+	})();
+	const queryOptionsArr = [
+		`initialPageParam: ${typeof initialPageParam === "string" ? JSON.stringify(initialPageParam) : initialPageParam}`,
+		getNextPageParamExpr,
+		getPreviousPageParamExpr
+	].filter(Boolean);
+	const infiniteOverrideParams = queryParam && queryParamsTypeName ? `query = {
+      ...(query ?? {}),
+      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
+    } as ${queryParamsTypeName}` : "";
+	const queryFnArgs = infiniteOverrideParams ? "{ signal, pageParam }" : "{ signal }";
+	const queryFnStatements = infiniteOverrideParams ? `${infiniteOverrideParams}\n    ${queryFnBody}` : queryFnBody;
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, ${queryKeyType}, ${pageParamType}>({
+  queryKey,
+  queryFn: async (${queryFnArgs}) => {
+    ${queryFnStatements}
+  },
+  ${queryOptionsArr.join(",\n  ")}
+})
+`
+		})
+	});
+}
+__name(InfiniteQueryOptions$1, "InfiniteQueryOptions");
+//#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+const declarationPrinter$6 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const mutationKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	return [`{ url: '${kubb_kit.Url.toPath(node.path)}' }`];
+};
+function MutationKey({ name, node, transformer }) {
+	const paramsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: [] });
+	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
+	const keys = (transformer ?? mutationKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	});
+}
+//#endregion
+//#region ../../internals/tanstack-query/src/resolver.ts
+/**
+* Builds the shared query namespace for a variant. Spread the result into
+* `createResolver` once per variant the plugin supports.
+*
+* @example
+* ```ts
+* createResolver<PluginReactQuery>({
+*   query: createQueryResolver(),
+*   suspenseQuery: createQueryResolver('Suspense'),
+* })
+* ```
+*/
+function createQueryResolver(variant = "") {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}${variant}`;
+		},
+		optionsName(node) {
+			return `${this.name(node.operationId)}${variant}QueryOptions`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}${variant}QueryKey`;
+		},
+		keyTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
+		},
+		clientName(node) {
+			return `${this.name(node.operationId)}${variant}`;
+		}
+	};
+}
+/**
+* Builds the shared mutation namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`optionsName`,
+* `typeName`, `argTypeName`) next to it.
+*
+* @example
+* ```ts
+* createResolver<PluginSwr>({ mutation: { ...createMutationResolver(), argTypeName(node) {...} } })
+* ```
+*/
+function createMutationResolver() {
+	return {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}MutationKey`;
+		}
+	};
+}
+(0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const queryKeyTransformer = ({ node }) => {
+	if (!node.path) return [];
+	const hasPathParams = getOperationParameters(node).path.length > 0;
+	const hasQueryParams = getOperationParameters(node).query.length > 0;
+	const hasRequestBody = !!node.requestBody?.content?.[0]?.schema;
+	return [
+		hasPathParams ? `{ url: '${kubb_kit.Url.toPath(node.path)}', params: path }` : `{ url: '${kubb_kit.Url.toPath(node.path)}' }`,
+		hasQueryParams ? "...(query ? [query] : [])" : null,
+		hasRequestBody ? "...(body ? [body] : [])" : null
+	].filter(Boolean);
+};
+//#endregion
+//#region ../../internals/client/src/resolveClient.ts
+/**
+* Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
+* operation, shared so the selection rules and diagnostics stay in one place.
+*
+* Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
+* contract client plugin (plugin-fetch or plugin-axios) and never emits its own inline client:
+*
+* - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
+*   imports and calls them.
+* - `error` — no client plugin is registered, several are registered without a selector, or the
+*   requested one is missing.
+*
+* The `client` string selects explicitly (`'fetch'` / `'axios'`); when it is unset a lone registered
+* contract client plugin is picked up automatically.
+*/
+const pluginFetchName = "plugin-fetch";
+const pluginAxiosName = "plugin-axios";
+const selectorToPlugin = {
+	fetch: pluginFetchName,
+	axios: pluginAxiosName
+};
+const contractPlugins = [pluginFetchName, pluginAxiosName];
+/**
+* Applies the `client` resolution rules. See the module comment for the strategy shape.
+*
+* @example
+* ```ts
+* resolveClient({ client: 'fetch', pluginNames: ['plugin-ts', 'plugin-fetch'] })
+* // { kind: 'contract', pluginName: 'plugin-fetch' }
+* ```
+*
+* @example
+* ```ts
+* resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
+* // { kind: 'error', message: 'No client plugin is registered…' }
+* ```
+*/
+function resolveClient(options) {
+	const { client, pluginNames } = options;
+	const has = (name) => pluginNames.includes(name);
+	if (client === "fetch" || client === "axios") {
+		const pluginName = selectorToPlugin[client];
+		if (!has(pluginName)) return {
+			kind: "error",
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`. Add it, or drop \`client\` to use a different client plugin.`
+		};
+		return {
+			kind: "contract",
+			pluginName
+		};
+	}
+	const registered = contractPlugins.filter(has);
+	if (registered.length === 1) return {
+		kind: "contract",
+		pluginName: registered[0]
+	};
+	if (registered.length > 1) return {
+		kind: "error",
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios'\` to choose which client the hooks call, or register a single client plugin.`
+	};
+	return {
+		kind: "error",
+		message: "No client plugin is registered. Add `@kubb/plugin-axios` or `@kubb/plugin-fetch` to `plugins` so the generated code has an HTTP client to call."
+	};
+}
+/**
+* Resolves the contract client during a consumer plugin's setup hook. Extracts the plugin names
+* from the raw `plugins` config, applies {@link resolveClient}, and throws the diagnostic on a
+* misconfiguration so every consumer fails fast with the same message.
+*/
+function resolveContractClient(options) {
+	const { client, plugins = [] } = options;
+	const resolved = resolveClient({
+		client,
+		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
+	});
+	if (resolved.kind === "error") throw new Error(resolved.message);
+	return resolved;
+}
+//#endregion
+//#region ../../internals/client/src/resolveClientOperation.ts
+/**
+* Resolves the contract client `<op>` a consumer (query hook, MCP handler) imports, by looking up
+* the registered contract client plugin's resolver and output. Works for any contract client plugin
+* (plugin-fetch or plugin-axios). Returns `null` when no contract plugin is in play (the inline
+* path). The plugin injects `.kubb/client.ts` at the global output root, the same path consumers
+* read `RequestConfig` / `ResponseErrorConfig` from.
+*/
+function resolveClientOperation(options) {
+	const { clientPlugin, driver, node, root, output } = options;
+	if (!clientPlugin) return null;
+	const resolver = driver.getResolver(clientPlugin.pluginName);
+	const plugin = driver.getPlugin(clientPlugin.pluginName);
+	const file = resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output: plugin?.options?.output ?? output,
+		group: plugin?.options?.group ?? void 0
+	});
+	return {
+		name: resolver.name(node.operationId),
+		path: file.path,
+		clientPath: node_path.default.resolve(root, ".kubb/client.ts")
+	};
+}
+//#endregion
+//#region 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 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+function buildQueryKeyParamsNode(node, options) {
+	const groupedParam = buildGroupedRequestParam(node, {
+		resolver: options.resolver,
+		keys: [
+			"path",
+			"query",
+			"body"
+		],
+		memberTypeWrapper: maybeRefOrGetter
+	});
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedParam ? [groupedParam] : [] });
+}
+function QueryKey({ name, node, tsResolver, typeName, transformer }) {
+	const paramsNode = buildQueryKeyParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$4.print(paramsNode) ?? "";
+	const keys = (transformer ?? queryKeyTransformer)({
+		node,
+		casing: "camelcase"
+	});
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function.Arrow, {
+			name,
+			export: true,
+			params: paramsSignature,
+			singleLine: true,
+			children: `[${keys.join(", ")}] as const`
+		})
+	}), /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name: typeName,
+		isExportable: true,
+		isIndexable: true,
+		isTypeOnly: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Type, {
+			name: typeName,
+			export: true,
+			children: `ReturnType<typeof ${name}>`
+		})
+	})] });
+}
+//#endregion
+//#region src/components/QueryOptions.tsx
+const declarationPrinter$3 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter$3 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function getQueryOptionsParams(node, options) {
+	return buildQueryOptionsParams(node, {
+		resolver: options.resolver,
+		memberTypeWrapper: maybeRefOrGetter
+	});
+}
+function QueryOptions({ name, clientName, node, tsResolver, queryKeyName }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const queryKeyParamsNode = buildQueryKeyParamsNode(node, { resolver: tsResolver });
+	const queryKeyParamsCall = callPrinter$3.print(queryKeyParamsNode) ?? "";
+	const paramsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
+	const queryFnBody = `const { data } = await ${buildVueClientCall(node, {
+		clientName,
+		signal: true
+	})}
+          return data`;
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name,
+			export: true,
+			params: paramsSignature,
+			children: `
+      const queryKey = ${queryKeyName}(${queryKeyParamsCall})
+      return queryOptions<${TData}, ${TError}, ${TData}>({
+       queryKey,
+       queryFn: async ({ signal }) => {
+          ${queryFnBody}
+       },
+      })
+`
+		})
+	});
+}
+//#endregion
+//#region src/components/InfiniteQuery.tsx
+const declarationPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function buildInfiniteQueryParamsNode(node, options) {
+	const { resolver } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver);
+	const optionsParam = (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "options",
+		type: `{
+  query?: Partial<UseInfiniteQueryOptions<${[
+			TData,
+			TError,
+			"TQueryData",
+			"TQueryKey",
+			"TQueryData"
+		].join(", ")}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper: maybeRefOrGetter
+	}), optionsParam].filter((param) => param !== null) });
+}
+function InfiniteQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const returnType = `UseInfiniteQueryReturnType<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
+	const generics = [
+		`TData = InfiniteData<${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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: paramsSignature,
+			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__ */ (0, kubb_jsx_jsx_runtime.jsx)(InfiniteQueryOptions$1, {
+		...props,
+		queryKeyType: "QueryKey",
+		memberTypeWrapper: maybeRefOrGetter,
+		unwrapName: (name) => `toValue(${name})`
+	});
+}
+//#endregion
+//#region src/components/Mutation.tsx
+const declarationPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function resolveMutationRequestType(node, resolver) {
+	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
+}
+function buildMutationParamsNode(node, options) {
+	const { resolver } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver);
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "options",
+		type: `{
+  mutation?: MutationObserverOptions<${[
+			TData,
+			TError,
+			resolveMutationRequestType(node, resolver),
+			"TContext"
+		].join(", ")}> & { client?: QueryClient },
+  client?: ${buildRequestConfigType(node)},
+}`,
+		default: "{}"
+	})] });
+}
+function Mutation({ name, clientName, node, tsResolver, mutationKeyName }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver);
+	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
+	const hasMutationParams = groupedParam !== null;
+	const groupedParamsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedParam ? [groupedParam] : [] });
+	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "";
+	const mutationFnBody = `const { data } = await ${buildVueClientCall(node, {
+		clientName,
+		signal: false
+	})}
+            return data`;
+	const generics = [
+		TData,
+		TError,
+		resolveMutationRequestType(node, tsResolver),
+		"TContext"
+	].join(", ");
+	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter$1.print(paramsNode) ?? "";
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name,
+			export: true,
+			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 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
+const callPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
+function buildQueryParamsNode(node, options) {
+	const { resolver } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver);
+	const optionsParam = (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "options",
+		type: `{
+  query?: Partial<UseQueryOptions<${[
+			TData,
+			TError,
+			"TData",
+			"TQueryData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
+  client?: ${buildClientOptionType()}
+}`,
+		default: "{}"
+	});
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, {
+		resolver,
+		memberTypeWrapper: maybeRefOrGetter
+	}), 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 queryOptionsParamsNode = getQueryOptionsParams(node, { resolver: tsResolver });
+	const queryOptionsParamsCall = callPrinter.print(queryOptionsParamsNode) ?? "";
+	const paramsNode = buildQueryParamsNode(node, { resolver: tsResolver });
+	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.Function, {
+			name,
+			export: true,
+			generics: generics.join(", "),
+			params: paramsSignature,
+			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 = useQuery({
+        ...${queryOptionsName}(${queryOptionsParamsCall}),
+        ...resolvedOptions,
+        queryKey
+       } as unknown as UseQueryOptions<${TData}, ${TError}, TData, ${TData}, TQueryKey>, toValue(queryClient)) as ${returnType}
+
+       queryResult.queryKey = queryKey as TQueryKey
+
+       return queryResult
+       `
+		})
+	});
+}
+//#endregion
+//#region src/generators/infiniteQueryGenerator.tsx
+/**
+* Built-in generator for `useInfiniteQuery` composables. Enabled when
+* `pluginVueQuery({ infinite: { ... }, hooks: true })`. Emits one
+* `useFooInfiniteQuery` composable per query operation, wiring the
+* configured cursor path into TanStack Query's cursor-based pagination.
+*/
+const infiniteQueryGenerator = (0, kubb_kit.defineGenerator)({
+	name: "vue-query-infinite",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, infinite, client, group, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isQuery, isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
+		if (!isQuery || isMutation || !infiniteOptions || !hooks) return null;
+		const normalizeKey = (key) => key.replace(/\?$/, "");
+		const queryParamKeys = getOperationParameters(node).query.map((p) => p.name);
+		if (!(infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false)) return null;
+		const importPath = query ? query.importPath : "@tanstack/vue-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const queryName = resolver.infiniteQuery.name(node);
+		const queryOptionsName = resolver.infiniteQuery.optionsName(node);
+		const queryKeyName = resolver.infiniteQuery.keyName(node);
+		const queryKeyTypeName = resolver.infiniteQuery.keyTypeName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, queryName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const { queryParamsTypeName } = resolvePageParamType(node, {
+			resolver: tsResolver,
+			initialPageParam: infiniteOptions.initialPageParam,
+			queryParam: infiniteOptions.queryParam
+		});
+		const importedTypeNames = [
+			tsResolver.response.options(node),
+			queryParamsTypeName,
+			...resolveOperationTypeNames(node, tsResolver, {
+				exclude: [queryKeyTypeName],
+				order: "body-response-first",
+				includeParams: false
+			})
+		].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["toValue"],
+					path: "vue"
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["MaybeRefOrGetter"],
+					path: "vue",
+					isTypeOnly: true
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["InfiniteData"],
+					isTypeOnly: true,
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["infiniteQueryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(InfiniteQueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver,
+					cursorParam: infiniteOptions.cursorParam,
+					nextParam: infiniteOptions.nextParam,
+					previousParam: infiniteOptions.previousParam,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["useInfiniteQuery"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [
+						"QueryKey",
+						"QueryClient",
+						"UseInfiniteQueryOptions",
+						"UseInfiniteQueryReturnType"
+					],
+					path: importPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(InfiniteQuery, {
+					name: queryName,
+					queryOptionsName,
+					queryKeyName,
+					queryKeyTypeName,
+					node,
+					tsResolver,
+					initialPageParam: infiniteOptions.initialPageParam,
+					queryParam: infiniteOptions.queryParam
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/mutationGenerator.tsx
+/**
+* Built-in generator for `useMutation` composables. Emits one
+* `useFooMutation` composable per POST/PUT/DELETE operation (configurable
+* via `mutation.methods`) plus the matching `fooMutationKey` helper.
+*/
+const mutationGenerator = (0, kubb_kit.defineGenerator)({
+	name: "vue-query-mutation",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, client, group, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		if (!isMutation) return null;
+		const importPath = mutation ? mutation.importPath : "@tanstack/vue-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const mutationHookName = resolver.mutation.name(node);
+		const mutationTypeName = resolver.mutation.typeName(node);
+		const mutationKeyName = resolver.mutation.keyName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, mutationHookName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		const groups = getRequestGroups(node);
+		const hasRequestGroups = groups.path || groups.query || groups.body || groups.headers;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				hasRequestGroups && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["toValue"],
+					path: "vue"
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["MaybeRefOrGetter"],
+					path: "vue",
+					isTypeOnly: true
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(MutationKey, {
+					name: mutationKeyName,
+					node,
+					transformer: ctx.options.mutationKey
+				}),
+				mutation && hooks && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: ["useMutation"],
+						path: importPath
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: ["MutationObserverOptions", "QueryClient"],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Mutation, {
+						name: mutationHookName,
+						clientName: calledClientName,
+						typeName: mutationTypeName,
+						node,
+						tsResolver,
+						mutationKeyName
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
+//#region src/generators/queryGenerator.tsx
+/**
+* Built-in generator for `useQuery` composables. Emits one `useFooQuery`
+* composable per GET operation (configurable via `query.methods`) plus the
+* matching `fooQueryKey` / `fooQueryOptions` helpers.
+*/
+const queryGenerator = (0, kubb_kit.defineGenerator)({
+	name: "vue-query",
+	renderer: kubb_jsx.jsxRenderer,
+	operation(node, ctx) {
+		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, query, mutation, client, group, hooks } = ctx.options;
+		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		const { isQuery, isMutation } = classifyOperation(node, {
+			query,
+			mutation
+		});
+		if (!isQuery || isMutation) return null;
+		const importPath = query ? query.importPath : "@tanstack/vue-query";
+		const contractOp = resolveClientOperation({
+			clientPlugin: { pluginName: client.pluginName },
+			driver,
+			node,
+			root,
+			output
+		});
+		if (!contractOp) return null;
+		const queryName = resolver.query.name(node);
+		const queryOptionsName = resolver.query.optionsName(node);
+		const queryKeyName = resolver.query.keyName(node);
+		const queryKeyTypeName = resolver.query.keyTypeName(node);
+		const meta = {
+			file: resolver.file({
+				...operationFileEntry(node, queryName),
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.file({
+				...operationFileEntry(node, node.operationId),
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
+			exclude: [queryKeyTypeName],
+			order: "body-response-first",
+			includeParams: false
+		})].filter((name) => Boolean(name));
+		const calledClientName = contractOp.name;
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: [contractOp.name],
+					root: meta.file.path,
+					path: contractOp.path
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["RequestConfig", "ResponseErrorConfig"],
+					root: meta.file.path,
+					path: contractOp.clientPath,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["toValue"],
+					path: "vue"
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["MaybeRefOrGetter"],
+					path: "vue",
+					isTypeOnly: true
+				}),
+				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: Array.from(new Set(importedTypeNames)),
+					root: meta.file.path,
+					path: meta.fileTs.path,
+					isTypeOnly: true
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryKey, {
+					name: queryKeyName,
+					typeName: queryKeyTypeName,
+					node,
+					tsResolver,
+					transformer: ctx.options.queryKey
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+					name: ["queryOptions"],
+					path: importPath
+				}),
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(QueryOptions, {
+					name: queryOptionsName,
+					clientName: calledClientName,
+					queryKeyName,
+					node,
+					tsResolver
+				}),
+				query && hooks && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: ["useQuery"],
+						path: importPath
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: [
+							"QueryKey",
+							"QueryClient",
+							"UseQueryOptions",
+							"UseQueryReturnType"
+						],
+						path: importPath,
+						isTypeOnly: true
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Query, {
+						name: queryName,
+						queryOptionsName,
+						queryKeyName,
+						queryKeyTypeName,
+						node,
+						tsResolver
+					})
+				] })
+			]
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverVueQuery.ts
+/**
+* Default resolver used by `@kubb/plugin-vue-query`. Decides the names and
+* file paths for every generated TanStack Query composable (`useFoo`,
+* `useFooInfinite`) and its companion helpers.
+*
+* The `default` helpers are supplied by `createResolver`. Functions and files use camelCase;
+* composables get the `use` prefix. Operation-specific naming is grouped under the `query`,
+* `infiniteQuery`, and `mutation` namespaces.
+*
+* @example Resolve composable and helper names
+* ```ts
+* import { resolverVueQuery } from '@kubb/plugin-vue-query'
+*
+* resolverVueQuery.query.name(operationNode)        // 'useGetPetById'
+* resolverVueQuery.query.keyName(operationNode)     // 'getPetByIdQueryKey'
+* resolverVueQuery.query.optionsName(operationNode) // 'getPetByIdQueryOptions'
+* ```
+*/
+const resolverVueQuery = (0, kubb_kit.createResolver)({
 	pluginName: "plugin-vue-query",
-	default(name, type) {
-		return require_components.camelCase(name, { isFile: type === "file" });
-	},
-	resolveName(name) {
-		return this.default(name, "function");
-	},
-	resolvePathName(name, type) {
-		return this.default(name, type);
-	},
-	resolveQueryName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}`;
-	},
-	resolveInfiniteQueryName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}Infinite`;
-	},
-	resolveMutationName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}`;
-	},
-	resolveQueryOptionsName(node) {
-		return `${this.resolveName(node.operationId)}QueryOptions`;
-	},
-	resolveInfiniteQueryOptionsName(node) {
-		return `${this.resolveName(node.operationId)}InfiniteQueryOptions`;
-	},
-	resolveQueryKeyName(node) {
-		return `${this.resolveName(node.operationId)}QueryKey`;
-	},
-	resolveInfiniteQueryKeyName(node) {
-		return `${this.resolveName(node.operationId)}InfiniteQueryKey`;
-	},
-	resolveMutationKeyName(node) {
-		return `${this.resolveName(node.operationId)}MutationKey`;
-	},
-	resolveQueryKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}QueryKey`;
-	},
-	resolveInfiniteQueryKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}InfiniteQueryKey`;
-	},
-	resolveMutationTypeName(node) {
-		return capitalize(this.resolveName(node.operationId));
-	},
-	resolveClientName(node) {
-		return this.resolveName(node.operationId);
-	},
-	resolveInfiniteClientName(node) {
-		return `${this.resolveName(node.operationId)}Infinite`;
+	query: createQueryResolver(),
+	infiniteQuery: createQueryResolver("Infinite"),
+	mutation: {
+		...createMutationResolver(),
+		typeName(node) {
+			return capitalize(this.name(node.operationId));
+		}
 	}
-}));
+});
 //#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-vue-query`. Used for driver lookups
+* and cross-plugin dependency references.
+*/
 const pluginVueQueryName = "plugin-vue-query";
-const pluginVueQuery = (0, _kubb_core.definePlugin)((options) => {
+/**
+* Generates one TanStack Query composable per OpenAPI operation for Vue's
+* Composition API. Queries become `useFoo` (and optionally
+* `useFooInfinite`). Mutations become `useFoo` as well. Each composable
+* is fully typed end to end.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginVueQuery } from '@kubb/plugin-vue-query'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginVueQuery({
+*       output: { path: './hooks' },
+*     }),
+*   ],
+* })
+* ```
+*/
+const pluginVueQuery = (0, kubb_kit.definePlugin)((options) => {
 	const { output = {
 		path: "hooks",
-		barrelType: "named"
-	}, group, exclude = [], include, override = [], parser = "client", infinite = false, paramsType = "inline", pathParamsType = paramsType === "object" ? "object" : options.pathParamsType || "inline", mutation = {}, query = {}, mutationKey = require_components.mutationKeyTransformer, queryKey = require_components.queryKeyTransformer, paramsCasing, client, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const clientName = client?.client ?? "axios";
-	const clientImportPath = client?.importPath ?? (!client?.bundle ? `@kubb/plugin-client/clients/${clientName}` : void 0);
-	const selectedGenerators = options.generators ?? [
-		require_generators.queryGenerator,
-		require_generators.infiniteQueryGenerator,
-		require_generators.mutationGenerator
-	].filter((generator) => Boolean(generator));
-	const groupConfig = group ? {
-		...group,
-		name: group.name ? group.name : (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${require_components.camelCase(ctx.group)}Controller`;
-		}
-	} : void 0;
+		barrel: { type: "named" }
+	}, group, exclude = [], include, override = [], infinite = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, hooks = false, client, resolver: userResolver, macros: userMacros } = options;
+	const selectedGenerators = [
+		queryGenerator,
+		infiniteQueryGenerator,
+		mutationGenerator
+	];
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginVueQueryName,
 		options,
-		dependencies: [_kubb_plugin_ts.pluginTsName, parser === "zod" ? _kubb_plugin_zod.pluginZodName : void 0].filter((dependency) => Boolean(dependency)),
+		dependencies: [_kubb_plugin_ts.pluginTsName],
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverVueQuery,
-				...userResolver
-			} : resolverVueQuery;
+			const resolver = userResolver ? kubb_kit.Resolver.merge(resolverVueQuery, userResolver) : resolverVueQuery;
 			ctx.setOptions({
 				output,
-				client: {
-					bundle: client?.bundle,
-					baseURL: client?.baseURL,
-					client: clientName,
-					clientType: client?.clientType ?? "function",
-					importPath: clientImportPath,
-					dataReturnType: client?.dataReturnType ?? "data",
-					paramsCasing
-				},
+				client: resolveContractClient({
+					client,
+					plugins: ctx.config.plugins
+				}),
 				queryKey,
-				query: query === false ? false : {
-					importPath: "@tanstack/vue-query",
-					methods: ["get"],
-					...query
-				},
+				query: resolveQueryConfig(query, { importPath: "@tanstack/vue-query" }),
 				mutationKey,
-				mutation: mutation === false ? false : {
-					importPath: "@tanstack/vue-query",
-					methods: [
-						"post",
-						"put",
-						"patch",
-						"delete"
-					],
-					...mutation
-				},
-				infinite: infinite ? {
-					queryParam: "id",
-					initialPageParam: 0,
-					cursorParam: void 0,
-					nextParam: void 0,
-					previousParam: void 0,
-					...infinite
-				} : false,
-				parser,
-				paramsType,
-				pathParamsType,
-				paramsCasing,
+				mutation: resolveMutationConfig(mutation, { importPath: "@tanstack/vue-query" }),
+				infinite: resolveInfiniteConfig(infinite),
+				hooks,
 				group: groupConfig,
 				exclude,
 				include,
@@ -152,31 +1676,8 @@ const pluginVueQuery = (0, _kubb_core.definePlugin)((options) => {
 				resolver
 			});
 			ctx.setResolver(resolver);
-			if (userTransformer) ctx.setTransformer(userTransformer);
-			for (const gen of selectedGenerators) ctx.addGenerator(gen);
-			for (const gen of userGenerators) ctx.addGenerator(gen);
-			const root = node_path.default.resolve(ctx.config.root, ctx.config.output.path);
-			const hasClientPlugin = !!ctx.config.plugins?.some((p) => p.name === _kubb_plugin_client.pluginClientName);
-			if (client?.bundle && !hasClientPlugin && !clientImportPath) ctx.injectFile({
-				baseName: "fetch.ts",
-				path: node_path.default.resolve(root, ".kubb/fetch.ts"),
-				sources: [_kubb_core.ast.createSource({
-					name: "fetch",
-					nodes: [_kubb_core.ast.createText(clientName === "fetch" ? _kubb_plugin_client_templates_clients_fetch_source.source : _kubb_plugin_client_templates_clients_axios_source.source)],
-					isExportable: true,
-					isIndexable: true
-				})]
-			});
-			if (!hasClientPlugin) ctx.injectFile({
-				baseName: "config.ts",
-				path: node_path.default.resolve(root, ".kubb/config.ts"),
-				sources: [_kubb_core.ast.createSource({
-					name: "config",
-					nodes: [_kubb_core.ast.createText(_kubb_plugin_client_templates_config_source.source)],
-					isExportable: false,
-					isIndexable: false
-				})]
-			});
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(...selectedGenerators);
 		} }
 	};
 });
@@ -184,5 +1685,6 @@ const pluginVueQuery = (0, _kubb_core.definePlugin)((options) => {
 exports.default = pluginVueQuery;
 exports.pluginVueQuery = pluginVueQuery;
 exports.pluginVueQueryName = pluginVueQueryName;
+exports.resolverVueQuery = resolverVueQuery;
 
 //# sourceMappingURL=index.cjs.map