@kubb/plugin-react-query 5.7.0-canary.20261025T193222 → 5.7.0

package/dist/index.js

@@ -5,8 +5,7 @@ import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 import fs from "node:fs";
-//#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
@@ -75,6 +74,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);
@@ -166,6 +183,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;
@@ -228,8 +261,7 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 	byResolver.set(cacheKey, result);
 	return result;
 }
-//#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)
@@ -276,8 +308,146 @@ function camelCase(text, { prefix = "", suffix = "" } = {}) {
 function capitalize(text) {
 	return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
 }
-//#endregion
-//#region ../../internals/utils/src/strings.ts
+// ../../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);
+}
+/**
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
+*
+* 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
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
+*/
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
+}
+/**
+* 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
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+// ../../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.
@@ -293,8 +463,29 @@ 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
+function resolveOperationName(name) {
+	return 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:
@@ -324,17 +515,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.20261025T193222";
-//#endregion
-//#region ../../internals/client/src/resolveOperationTypes.ts
+// package.json
+var version = "5.7.0";
+// ../../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.
@@ -400,8 +588,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.
@@ -511,8 +698,7 @@ function resolveContractClient(options) {
 	}
 	return resolved;
 }
-//#endregion
-//#region ../../internals/client/src/resolveClientOperation.ts
+// ../../internals/client/src/resolveClientOperation.ts
 function isRelativeImport(importPath) {
 	return importPath.startsWith(".");
 }
@@ -559,8 +745,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,
@@ -571,8 +761,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.
@@ -661,8 +850,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.
@@ -688,7 +876,7 @@ function maybeValueOrGetter(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;
@@ -700,6 +888,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) {
@@ -757,14 +950,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
@@ -860,9 +1056,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 {
@@ -1015,8 +1216,7 @@ function buildResolvedRequestParams(node) {
 	if (names.length === 0) return null;
 	return `{ ${names.map((name) => `${name}: typeof ${name} === 'function' ? ${name}() : ${name}`).join(", ")} }`;
 }
-//#endregion
-//#region ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
+// ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
 const callPrinter$3 = functionPrinter({ mode: "call" });
 function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, returnType = "full" }) {
@@ -1092,8 +1292,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$5 = functionPrinter({ mode: "declaration" });
 /**
 * Default `mutationKey` builder. Call it from a custom builder to extend the default key.
@@ -1140,8 +1339,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.
@@ -1157,19 +1355,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
+			});
 		}
 	};
 }
@@ -1186,15 +1404,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$4 = functionPrinter({ mode: "declaration" });
 /**
 * Default `queryKey` builder. Call it from a custom builder to extend the default key.
@@ -1252,8 +1477,7 @@ function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "qu
 		})
 	})] });
 }
-//#endregion
-//#region src/generators/customHookOptionsFileGenerator.tsx
+// src/generators/customHookOptionsFileGenerator.tsx
 /**
 * Scaffolds the user-editable `useCustomHookOptions` file when
 * `pluginReactQuery({ customOptions: { ... }, hooks: true })` is configured. The file is
@@ -1350,8 +1574,7 @@ const customHookOptionsFileGenerator = defineGenerator({
 		});
 	}
 });
-//#endregion
-//#region src/generators/hookOptionsGenerator.tsx
+// src/generators/hookOptionsGenerator.tsx
 /**
 * Emits the `HookOptions` type used by `customOptions`. Enabled when
 * `pluginReactQuery({ customOptions: { ... } })`. The generated type lists
@@ -1510,8 +1733,7 @@ const hookOptionsGenerator = defineGenerator({
 		});
 	}
 });
-//#endregion
-//#region src/components/Query.tsx
+// src/components/Query.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
 const OBSERVER_OPTIONS_NAMES = {
 	infinite: {
@@ -1621,8 +1843,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 		})
 	});
 }
-//#endregion
-//#region src/components/QueryOptions.tsx
+// src/components/QueryOptions.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$2 = functionPrinter({ mode: "call" });
 function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, returnType = "full" }) {
@@ -1655,8 +1876,7 @@ function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, return
 		})
 	});
 }
-//#endregion
-//#region src/generators/createQueryGenerator.tsx
+// src/generators/createQueryGenerator.tsx
 const OBSERVER_IMPORTS = {
 	query: ["QueryObserverOptions", "UseQueryResult"],
 	suspenseQuery: ["UseSuspenseQueryOptions", "UseSuspenseQueryResult"],
@@ -1815,8 +2035,7 @@ function createQueryGenerator({ name, variant }) {
 		}
 	});
 }
-//#endregion
-//#region src/generators/infiniteQueryGenerator.tsx
+// src/generators/infiniteQueryGenerator.tsx
 /**
 * Built-in generator for `useInfiniteQuery` hooks. Enabled when
 * `pluginReactQuery({ infinite: { ... }, hooks: true })`. Emits one
@@ -1828,8 +2047,7 @@ const infiniteQueryGenerator = createQueryGenerator({
 	name: "react-infinite-query",
 	variant: "infiniteQuery"
 });
-//#endregion
-//#region src/components/MutationOptions.tsx
+// src/components/MutationOptions.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 const callPrinter$1 = functionPrinter({ mode: "call" });
 function buildMutationConfigParamsNode(node) {
@@ -1843,14 +2061,19 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 	const { TData, TError } = buildResponseTypes(node, tsResolver);
 	const configParamsNode = buildMutationConfigParamsNode(node);
 	const paramsSignature = declarationPrinter$1.print(configParamsNode) ?? "";
-	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 TRequest = hasMutationParams ? tsResolver.response.options(node) : "undefined";
 	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "_";
 	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
-		signal: false
+		signal: false,
+		withContentType: true,
+		returnType
 	}), { returnType });
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
@@ -1873,8 +2096,7 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 		})
 	});
 }
-//#endregion
-//#region src/components/Mutation.tsx
+// src/components/Mutation.tsx
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 const callPrinter = functionPrinter({ mode: "call" });
 function buildMutationParamsNode(node, options) {
@@ -1933,8 +2155,7 @@ function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName
 		})
 	});
 }
-//#endregion
-//#region src/generators/mutationGenerator.tsx
+// src/generators/mutationGenerator.tsx
 /**
 * Built-in generator for `useMutation` hooks. Emits one `useFooMutation` hook
 * per POST/PUT/DELETE operation (configurable via `mutation.methods`) plus
@@ -2027,8 +2248,7 @@ const mutationGenerator = defineGenerator({
 		});
 	}
 });
-//#endregion
-//#region src/generators/queryGenerator.tsx
+// src/generators/queryGenerator.tsx
 /**
 * Built-in generator for `useQuery` hooks. Emits one `useFooQuery` hook per
 * GET and QUERY operation (configurable via `query.methods`) plus the matching
@@ -2038,8 +2258,7 @@ const queryGenerator = createQueryGenerator({
 	name: "react-query",
 	variant: "query"
 });
-//#endregion
-//#region src/generators/suspenseInfiniteQueryGenerator.tsx
+// src/generators/suspenseInfiniteQueryGenerator.tsx
 /**
 * Built-in generator for `useSuspenseInfiniteQuery` hooks. Enabled when
 * `suspense`, `infinite`, and `hooks` are all configured. Combines suspense
@@ -2050,8 +2269,7 @@ const suspenseInfiniteQueryGenerator = createQueryGenerator({
 	name: "react-suspense-infinite-query",
 	variant: "suspenseInfiniteQuery"
 });
-//#endregion
-//#region src/generators/suspenseQueryGenerator.tsx
+// src/generators/suspenseQueryGenerator.tsx
 /**
 * Built-in generator for `useSuspenseQuery` hooks. Enabled when
 * `pluginReactQuery({ suspense: {}, hooks: true })`. Emits one
@@ -2063,15 +2281,14 @@ const suspenseQueryGenerator = createQueryGenerator({
 	name: "react-suspense-query",
 	variant: "suspenseQuery"
 });
-//#endregion
-//#region src/resolvers/resolverReactQuery.ts
+// src/resolvers/resolverReactQuery.ts
 /**
 * Default resolver used by `@kubb/plugin-react-query`. Decides the names and
 * file paths for every generated TanStack Query hook (`useFoo`,
 * `useFooSuspense`, `useFooInfinite`, ...) and its companion helpers
 * (`fooQueryKey`, `fooQueryOptions`).
 *
-* Functions and files use the built-in camelCase casing; hooks get the `use`
+* Functions use safe camelCase identifiers; hooks get the `use`
 * prefix; suspense and infinite variants are suffixed with `Suspense`/`Infinite`.
 *
 * @example Resolve hook and helper names
@@ -2086,6 +2303,7 @@ const suspenseQueryGenerator = createQueryGenerator({
 */
 const resolverReactQuery = createResolver({
 	pluginName: "plugin-react-query",
+	name: resolveOperationName,
 	query: createQueryResolver(),
 	suspenseQuery: createQueryResolver("Suspense"),
 	infiniteQuery: createQueryResolver("Infinite"),
@@ -2093,23 +2311,36 @@ const resolverReactQuery = createResolver({
 	mutation: {
 		...createMutationResolver(),
 		optionsName(node) {
-			return `${this.name(node.operationId)}MutationOptions`;
+			const name = `${this.name(node.operationId)}MutationOptions`;
+			return this.resolveName({
+				key: operationKey(node, "mutation", "optionsName"),
+				name
+			});
 		},
 		typeName(node) {
-			return capitalize(this.name(node.operationId));
+			const name = capitalize(this.name(node.operationId));
+			return this.resolveName({
+				key: operationKey(node, "mutation", "typeName"),
+				name
+			});
 		}
 	},
 	hook: {
 		optionsName() {
-			return "HookOptions";
+			return this.resolveName({
+				key: ["hook", "options"],
+				name: "HookOptions"
+			});
 		},
 		customOptionsName() {
-			return "getCustomHookOptions";
+			return this.resolveName({
+				key: ["hook", "custom-options"],
+				name: "getCustomHookOptions"
+			});
 		}
 	}
 });
-//#endregion
-//#region src/plugin.ts
+// src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-react-query`. Used for driver lookups
 * and cross-plugin dependency references.
@@ -2183,7 +2414,6 @@ const pluginReactQuery = defineExtension({
 		};
 	}
 });
-//#endregion
 export { pluginReactQuery as default, pluginReactQuery, definePageParam, mutationKeyTransformer, pluginReactQueryName, queryKeyTransformer, resolverReactQuery };
 
 //# sourceMappingURL=index.js.map