@kubb/plugin-vue-query 5.7.0-canary.20261025T201031 → 5.7.1

package/dist/index.js

@@ -1,11 +1,10 @@
-import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, 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 { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
-//#endregion
-//#region ../../internals/shared/src/operation.ts
+// ../../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
@@ -74,6 +73,24 @@ function getContentTypeInfo(node) {
 function getResponseContentTypeInfo(node) {
 	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
 }
+/**
+* Reads the single base content type of an operation's primary success response, lowercased and
+* stripped of any `; charset=...` suffix. Returns `undefined` when the response declares zero or
+* more than one content type, since neither case has a single type to act on.
+*/
+function getPrimarySuccessContentType(node) {
+	const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? [];
+	if (contentTypes.length !== 1) return void 0;
+	return contentTypes[0].split(";")[0].trim().toLowerCase();
+}
+/**
+* Whether an operation streams its primary success response as Server-Sent Events
+* (`text/event-stream`). The client generator uses this to return a typed event stream instead of a
+* one-shot `RequestResult`.
+*/
+function isEventStream(node) {
+	return getPrimarySuccessContentType(node) === "text/event-stream";
+}
 const requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 function buildRequestConfigType(node) {
 	const request = getContentTypeInfo(node);
@@ -165,6 +182,22 @@ function getOperationParameters(node) {
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
 }
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
+* printer to emit `z.object(…)` rather than a record.
+*/
+function hasRequestContentTypeChoice(node) {
+	return (node.requestBody?.content ?? []).filter((entry) => entry.schema).length > 1;
+}
+/**
+* Casts a call argument to the client's parameter type; a `'plain'` client is non-generic.
+*/
+function castToClientOptions(callArg, clientName, returnType = "full") {
+	return `${callArg} as Parameters<typeof ${clientName}${returnType === "plain" ? "" : "<true>"}>[0]`;
+}
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
 	return Number.isNaN(code) ? null : code;
@@ -195,88 +228,184 @@ function resolveSuccessNames(node, resolver) {
 function resolveStatusCodeNames(node, resolver) {
 	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
 }
-const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
+/**
+* Lists the type names an operation's types file declares, computed once per resolver and `options` so every
+* dependent reads the same list.
+*/
 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;
+	const key = `${node.operationId}\0${options.order ?? ""}\0${options.responseStatusNames ?? ""}\0${options.includeParams === false ? "noparams" : ""}\0${(options.exclude ?? []).join(",")}`;
+	return resolver.memo(`operationTypeNames:${key}`, () => {
+		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)];
+		return (options.order === "body-response-first" ? [
+			...bodyAndResponseNames,
+			...paramNames,
+			...responseStatusNames
+		] : [
+			...paramNames,
+			...bodyAndResponseNames,
+			...responseStatusNames
+		]).filter((name) => Boolean(name) && !exclude.has(name));
+	});
 }
-//#endregion
-//#region ../../internals/utils/src/casing.ts
+// ../../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`.
+* Uppercases only the first character of `text`, leaving the rest untouched.
+* Unlike `pascalCase` it never re-splits word boundaries or strips characters.
 *
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+* @example
+* `capitalize('getPetById') // 'GetPetById'`
 */
-function convert(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, "");
-}
-const cache = /* @__PURE__ */ new Map();
-const cacheLimit = 1e4;
-function toCamelOrPascal(text, pascal) {
-	const key = `${pascal ? "P" : "c"}${text}`;
-	const cached = cache.get(key);
-	if (cached !== void 0) return cached;
-	const result = convert(text, pascal);
-	if (cache.size >= cacheLimit) cache.clear();
-	cache.set(key, result);
-	return result;
+function capitalize(text) {
+	return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+// ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ new Set([
+	"abstract",
+	"arguments",
+	"await",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
 }
 /**
-* Converts `text` to camelCase.
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
 *
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
+* Useful for sanitizing OpenAPI schema names or operation IDs that start with
+* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
+* variable, type, or function names.
 *
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+* @example
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
 */
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
 }
 /**
-* Uppercases only the first character of `text`, leaving the rest untouched.
-* Unlike {@link pascalCase} it never re-splits word boundaries or strips characters.
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
 *
 * @example
-* `capitalize('getPetById') // 'GetPetById'`
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
 */
-function capitalize(text) {
-	return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
-//#endregion
-//#region ../../internals/utils/src/strings.ts
+// ../../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.
@@ -292,8 +421,32 @@ function getNestedAccessor(param, accessor) {
 	if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
 	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
 }
-//#endregion
-//#region ../../internals/shared/src/group.ts
+// ../../internals/shared/src/resolver.ts
+/**
+* The shared top-level `name` of the operation plugins, computed once per operation name and build.
+*/
+function resolveOperationName(name) {
+	return this.memo(`operation:${name}`, () => ensureValidVarName(camelCase(name)));
+}
+/**
+* Builds the allocation key for a declaration an operation owns. `scope` names which declaration
+* it is, so two of them never share an allocation even when a custom resolver gives both the same
+* name. Leave `scope` empty for the operation's own declaration.
+*
+* @example
+* ```ts
+* resolver.resolveName({ key: operationKey(node, 'response', 'status', 404), name })
+* ```
+*/
+function operationKey(node, ...scope) {
+	return [
+		"operation",
+		node.method,
+		node.path,
+		...scope.map(String)
+	];
+}
+// ../../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:
@@ -323,17 +476,14 @@ function createGroupConfig(group) {
 		name: group.name ? group.name : defaultName
 	};
 }
-//#endregion
-//#region kubb-extension.json
+// kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.8.3",
+	"kubb": ">=5.14.6",
 	"node": ">=22.22"
 };
-//#endregion
-//#region package.json
-var version = "5.7.0-canary.20261025T201031";
-//#endregion
-//#region ../../internals/client/src/resolveOperationTypes.ts
+// package.json
+var version = "5.7.1";
+// ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
 * exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
@@ -343,6 +493,7 @@ function toZodTypeResolver(resolver) {
 	return {
 		...resolver,
 		file: resolver.file.bind(resolver),
+		memo: (key, compute) => resolver.memo(`zodTypes:${key}`, compute),
 		param: {
 			name: (node, p) => type(resolver.param.name(node, p)),
 			path: (node, p) => type(resolver.param.path(node, p)),
@@ -399,8 +550,7 @@ function resolveOperationTypes(driver, pluginName) {
 		group: pluginZod.options.group ?? void 0
 	};
 }
-//#endregion
-//#region ../../internals/client/src/resolveClient.ts
+// ../../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.
@@ -510,8 +660,7 @@ function resolveContractClient(options) {
 	}
 	return resolved;
 }
-//#endregion
-//#region ../../internals/client/src/resolveClientOperation.ts
+// ../../internals/client/src/resolveClientOperation.ts
 function isRelativeImport(importPath) {
 	return importPath.startsWith(".");
 }
@@ -558,8 +707,12 @@ function resolveClientOperation(options) {
 			group: operationOptions.group ?? void 0
 		});
 		const { importPath } = operationOptions;
+		const name = resolver.name(node.operationId);
 		return {
-			name: resolver.name(node.operationId),
+			name: resolver.resolveName({
+				key: operationKey(node),
+				name
+			}),
 			path: file.path,
 			clientPath: importPath === void 0 ? path.resolve(root, ".kubb/client.ts") : resolveImportPath({
 				importPath,
@@ -570,8 +723,7 @@ function resolveClientOperation(options) {
 		};
 	});
 }
-//#endregion
-//#region ../../internals/tanstack-query/src/components/HookFile.tsx
+// ../../internals/tanstack-query/src/components/HookFile.tsx
 /**
 * Resolves what every TanStack hook file shares: its file, the operation types file and names (`@kubb/plugin-ts`, or
 * `pluginZod({ inferred: 'codec' })`), banner and footer.
@@ -660,8 +812,7 @@ function HookFile({ hook, imports, children }) {
 		]
 	});
 }
-//#endregion
-//#region ../../internals/tanstack-query/src/utils.ts
+// ../../internals/tanstack-query/src/utils.ts
 /**
 * The grouped request options, ordered for both the destructured signature and the
 * call passed to the underlying client.
@@ -697,7 +848,7 @@ function maybeRefOrGetter(type) {
 * `MaybeRefOrGetter` per group.
 */
 function buildGroupedRequestParam(node, options) {
-	const { resolver, keys = requestGroupOrder, memberTypeWrapper } = options;
+	const { resolver, keys = requestGroupOrder, memberTypeWrapper, withContentType = false } = options;
 	const { groups, hasRequiredPath, hasRequiredQuery, hasRequiredHeader } = getRequestGroupOptionality(node);
 	const names = keys.filter((key) => groups[key]);
 	if (names.length === 0) return null;
@@ -709,6 +860,11 @@ function buildGroupedRequestParam(node, options) {
 	};
 	const isOptional = names.every((name) => !requiredByGroup[name]);
 	const optionsName = resolver.response.options(node);
+	if (withContentType && hasRequestContentTypeChoice(node)) return createFunctionParameter({
+		name: "variables",
+		type: optionsName,
+		optional: false
+	});
 	const omittedKeys = requestGroupOrder.filter((key) => !keys.includes(key));
 	const optionsType = omittedKeys.length > 0 ? `Omit<${optionsName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : optionsName;
 	if (memberTypeWrapper) {
@@ -766,14 +922,17 @@ function buildQueryOptionsParams(node, options) {
 * ```
 */
 function buildClientCall(node, options) {
-	const { clientName, signal = false, unwrapName } = options;
+	const { clientName, signal = false, unwrapName, withContentType = false, returnType = "full" } = options;
 	const { groups } = getRequestGroupOptionality(node);
-	return `${clientName}({ ${[
+	const names = requestGroupOrder.filter((key) => groups[key]);
+	const args = [
 		"...config",
-		...requestGroupOrder.filter((key) => groups[key]).map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		...withContentType && hasRequestContentTypeChoice(node) ? ["...variables"] : names.map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
 		signal ? "signal: config.signal ?? signal" : null,
 		"throwOnError: true"
-	].filter((part) => part !== null).join(", ")} })`;
+	].filter((part) => part !== null);
+	if (withContentType && hasRequestContentTypeChoice(node)) return `${clientName}(${castToClientOptions(`{ ${args.join(", ")} }`, clientName, returnType)})`;
+	return `${clientName}({ ${args.join(", ")} })`;
 }
 /**
 * Builds the query/mutation body that resolves a `buildClientCall` expression down to the bare
@@ -869,9 +1028,14 @@ function resolveMutationConfig(mutation, options) {
 /**
 * Classifies an operation as a query or a mutation from the resolved `query` / `mutation` method lists.
 * Disabled query and mutation configs do not claim operations, and a method already claimed by an
-* enabled query config never counts as a mutation.
+* enabled query config never counts as a mutation. Event streams are consumed through the client
+* directly, so they do not generate query or mutation hooks.
 */
 function classifyOperation(node, { query, mutation }) {
+	if (isEventStream(node)) return {
+		isQuery: false,
+		isMutation: false
+	};
 	const isQuery = !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
 	const queryMethods = new Set(query ? query.methods : []);
 	return {
@@ -980,8 +1144,7 @@ function buildHookParams(node, options) {
 function resolveMutationRequestType(node, resolver) {
 	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
 }
-//#endregion
-//#region ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
+// ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 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" }) {
@@ -1057,8 +1220,7 @@ return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${que
 		})
 	});
 }
-//#endregion
-//#region ../../internals/tanstack-query/src/components/MutationKey.tsx
+// ../../internals/tanstack-query/src/components/MutationKey.tsx
 const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
 /**
 * Default `mutationKey` builder. Call it from a custom builder to extend the default key.
@@ -1105,8 +1267,7 @@ function MutationKey({ name, node, transformer, typeName }) {
 		})
 	})] });
 }
-//#endregion
-//#region ../../internals/tanstack-query/src/resolver.ts
+// ../../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.
@@ -1122,19 +1283,39 @@ function MutationKey({ name, node, transformer, typeName }) {
 function createQueryResolver(variant = "") {
 	return {
 		name(node) {
-			return `use${capitalize(this.name(node.operationId))}${variant}`;
+			const name = `use${capitalize(this.name(node.operationId))}${variant}`;
+			return this.resolveName({
+				key: operationKey(node, "query", variant, "name"),
+				name
+			});
 		},
 		optionsName(node) {
-			return `${this.name(node.operationId)}${variant}QueryOptions`;
+			const name = `${this.name(node.operationId)}${variant}QueryOptions`;
+			return this.resolveName({
+				key: operationKey(node, "query", variant, "optionsName"),
+				name
+			});
 		},
 		keyName(node) {
-			return `${this.name(node.operationId)}${variant}QueryKey`;
+			const name = `${this.name(node.operationId)}${variant}QueryKey`;
+			return this.resolveName({
+				key: operationKey(node, "query", variant, "keyName"),
+				name
+			});
 		},
 		keyTypeName(node) {
-			return `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
+			const name = `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
+			return this.resolveName({
+				key: operationKey(node, "query", variant, "keyTypeName"),
+				name
+			});
 		},
 		clientName(node) {
-			return `${this.name(node.operationId)}${variant}`;
+			const name = `${this.name(node.operationId)}${variant}`;
+			return this.resolveName({
+				key: operationKey(node, "query", variant, "clientName"),
+				name
+			});
 		}
 	};
 }
@@ -1151,15 +1332,22 @@ function createQueryResolver(variant = "") {
 function createMutationResolver() {
 	return {
 		name(node) {
-			return `use${capitalize(this.name(node.operationId))}`;
+			const name = `use${capitalize(this.name(node.operationId))}`;
+			return this.resolveName({
+				key: operationKey(node, "mutation", "name"),
+				name
+			});
 		},
 		keyName(node) {
-			return `${this.name(node.operationId)}MutationKey`;
+			const name = `${this.name(node.operationId)}MutationKey`;
+			return this.resolveName({
+				key: operationKey(node, "mutation", "keyName"),
+				name
+			});
 		}
 	};
 }
-//#endregion
-//#region ../../internals/tanstack-query/src/components/QueryKey.tsx
+// ../../internals/tanstack-query/src/components/QueryKey.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 /**
 * Default `queryKey` builder. Call it from a custom builder to extend the default key.
@@ -1217,8 +1405,7 @@ function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "qu
 		})
 	})] });
 }
-//#endregion
-//#region src/components/QueryOptions.tsx
+// src/components/QueryOptions.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$2 = functionPrinter({ mode: "call" });
 function getQueryOptionsParams(node, options) {
@@ -1261,8 +1448,7 @@ function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, return
 		})
 	});
 }
-//#endregion
-//#region src/components/Query.tsx
+// 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 }) {
@@ -1345,8 +1531,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 		})
 	});
 }
-//#endregion
-//#region src/generators/infiniteQueryGenerator.tsx
+// src/generators/infiniteQueryGenerator.tsx
 /**
 * Built-in generator for `useInfiniteQuery` composables. Enabled when
 * `pluginVueQuery({ infinite: { ... }, hooks: true })`. Emits one
@@ -1479,8 +1664,7 @@ const infiniteQueryGenerator = defineGenerator({
 		});
 	}
 });
-//#endregion
-//#region src/components/Mutation.tsx
+// src/components/Mutation.tsx
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 const callPrinter = functionPrinter({ mode: "call" });
 function buildMutationParamsNode(node, options) {
@@ -1502,7 +1686,10 @@ function buildMutationParamsNode(node, options) {
 }
 function Mutation({ name, clientName, node, tsResolver, mutationKeyName, returnType = "full" }) {
 	const { TData, TError } = buildResponseTypes(node, tsResolver);
-	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
+	const groupedParam = buildGroupedRequestParam(node, {
+		resolver: tsResolver,
+		withContentType: true
+	});
 	const hasMutationParams = groupedParam !== null;
 	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
 	const argBindingStr = hasMutationParams ? callPrinter.print(groupedParamsNode) ?? "" : "";
@@ -1510,6 +1697,8 @@ function Mutation({ name, clientName, node, tsResolver, mutationKeyName, returnT
 	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: false,
+		withContentType: true,
+		returnType,
 		unwrapName: (name) => `toValue<${TRequest}['${name}']>(${name})`
 	}), { returnType });
 	const generics = [
@@ -1546,8 +1735,7 @@ function Mutation({ name, clientName, node, tsResolver, mutationKeyName, returnT
 		})
 	});
 }
-//#endregion
-//#region src/generators/mutationGenerator.tsx
+// src/generators/mutationGenerator.tsx
 /**
 * Built-in generator for `useMutation` composables. Emits one
 * `useFooMutation` composable per POST/PUT/DELETE operation (configurable
@@ -1621,8 +1809,7 @@ const mutationGenerator = defineGenerator({
 		});
 	}
 });
-//#endregion
-//#region src/generators/queryGenerator.tsx
+// src/generators/queryGenerator.tsx
 /**
 * Built-in generator for `useQuery` composables. Emits one `useFooQuery`
 * composable per GET and QUERY operation (configurable via `query.methods`) plus the
@@ -1723,14 +1910,13 @@ const queryGenerator = defineGenerator({
 		});
 	}
 });
-//#endregion
-//#region src/resolvers/resolverVueQuery.ts
+// 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;
+* The `default` helpers are supplied by `createResolver`. Functions use safe camelCase identifiers;
 * composables get the `use` prefix. Operation-specific naming is grouped under the `query`,
 * `infiniteQuery`, and `mutation` namespaces.
 *
@@ -1745,17 +1931,21 @@ const queryGenerator = defineGenerator({
 */
 const resolverVueQuery = createResolver({
 	pluginName: "plugin-vue-query",
+	name: resolveOperationName,
 	query: createQueryResolver(),
 	infiniteQuery: createQueryResolver("Infinite"),
 	mutation: {
 		...createMutationResolver(),
 		typeName(node) {
-			return capitalize(this.name(node.operationId));
+			const name = capitalize(this.name(node.operationId));
+			return this.resolveName({
+				key: operationKey(node, "mutation", "typeName"),
+				name
+			});
 		}
 	}
 });
-//#endregion
-//#region src/plugin.ts
+// src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-vue-query`. Used for driver lookups
 * and cross-plugin dependency references.
@@ -1823,7 +2013,6 @@ const pluginVueQuery = defineExtension({
 		};
 	}
 });
-//#endregion
 export { pluginVueQuery as default, pluginVueQuery, definePageParam, mutationKeyTransformer, pluginVueQueryName, queryKeyTransformer, resolverVueQuery };
 
 //# sourceMappingURL=index.js.map