@kubb/plugin-react-query 5.10.0-canary.20261109T191216 → 5.10.0

package/dist/index.js

@@ -1,10 +1,293 @@
-import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "@kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, casing, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "@kubb/kit";
 import path from "node:path";
-import { pluginZodName } from "@kubb/plugin-zod";
-import { File, Function, Type, jsxRenderer } from "@kubb/renderer-jsx";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { File, Function, Type, jsxRenderer } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 import fs from "node:fs";
+// kubb-extension.json
+var compatibility = {
+	"kubb": ">=5.18.4",
+	"node": ">=22.22"
+};
+// package.json
+var version = "5.10.0";
+// ../../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, plugin-axios, or plugin-client) 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, the
+*   requested one is missing, or `client` is not a known selector.
+*
+* The `client` string selects explicitly (`'fetch'` / `'axios'` / `'client'`); when it is unset a
+* lone registered contract client plugin is picked up automatically.
+*/
+const pluginFetchName = "plugin-fetch";
+const pluginAxiosName = "plugin-axios";
+const pluginClientName = "plugin-client";
+const selectorToPlugin = {
+	fetch: pluginFetchName,
+	axios: pluginAxiosName,
+	client: pluginClientName
+};
+const contractPlugins = [
+	pluginFetchName,
+	pluginAxiosName,
+	pluginClientName
+];
+/**
+* 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', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
+* ```
+*/
+function resolveClient(options) {
+	const { client, pluginNames } = options;
+	const has = (name) => pluginNames.includes(name);
+	if (client === "fetch" || client === "axios" || client === "client") {
+		const pluginName = selectorToPlugin[client];
+		if (!has(pluginName)) return {
+			kind: "error",
+			code: Diagnostics.code.missingDependency,
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
+			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
+		};
+		return {
+			kind: "contract",
+			pluginName
+		};
+	}
+	if (client !== void 0) return {
+		kind: "error",
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
+		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
+	};
+	const registered = contractPlugins.filter(has);
+	if (registered.length === 1) return {
+		kind: "contract",
+		pluginName: registered[0]
+	};
+	if (registered.length > 1) return {
+		kind: "error",
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
+		help: "Set `client: 'fetch' | 'axios' | 'client'` to choose which client the hooks call, or register a single client plugin."
+	};
+	return {
+		kind: "error",
+		code: Diagnostics.code.missingDependency,
+		message: "No client plugin is registered.",
+		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
+	};
+}
+/**
+* Resolves the contract client during a consumer plugin's setup hook.
+* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
+* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
+* fails fast with the same message.
+*/
+function resolveContractClient(options) {
+	const { plugin, client, plugins = [] } = options;
+	const resolved = resolveClient({
+		client,
+		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
+	});
+	if (resolved.kind === "error") {
+		const { code, message, help } = resolved;
+		throw new Diagnostics.Error({
+			code,
+			severity: "error",
+			message,
+			help,
+			location: { kind: "config" },
+			plugin
+		});
+	}
+	return resolved;
+}
+// ../../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.
+*
+* @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("']?.['")}']`}`;
+}
+/**
+* Escapes an `@` at the start of a line, so a multi-line description can't start a new JSDoc tag.
+* Editors render `\@` as `@` in hovers.
+*
+* @example
+* ```ts
+* jsDocEscape('intro\n@example value') // 'intro\n\\@example value'
+* ```
+*/
+function jsDocEscape(input) {
+	return `${input}`.replace(/^(\s*)@/gm, "$1\\@");
+}
 // ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -26,29 +309,55 @@ function operationFileEntry(node, name, extname = ".ts") {
 	};
 }
 /**
-* Resolves a dependency plugin's generated file for `node.operationId`, cached in `memo` (the
-* build's `ctx.memo`) under the resolver's own plugin name and the operation. Several dependents reading the
-* same dependency for the same operation in one pass (a query plugin's several hook generators, the
-* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
+* Resolves the file a schema-emitting plugin (`plugin-ts`, `plugin-zod`, `plugin-faker`) writes
+* `node` to, cached in `ctx.memo` under the resolver's plugin name and the
+* operation. The plugin itself and every plugin that imports from it call this, so they all get
+* the same path.
+*
+* When that path matches the file of a component schema in `ctx.driver.inputNode`, ignoring case, the file name
+* gets an `Operation` suffix: operation `point` goes to `PointOperation.ts` next to schema `Point.ts`.
+* Otherwise the two merge into one file, or overwrite each other on a case-insensitive file system.
+* Only the file name changes. The declarations keep their names.
 *
-* @example Cache `plugin-ts`'s file for the current operation
+* @example Resolve `plugin-ts`'s file for the current operation
 * ```ts
-* const fileTs = resolveDependencyOperationFile({ memo: ctx.memo, node, resolver: tsResolver, root, output })
+* const fileTs = resolveOperationFile({ ctx, node, resolver: tsResolver, root, output })
 * ```
 */
-function resolveDependencyOperationFile(options) {
-	const { memo, node, resolver, root, output, group } = options;
-	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => resolver.file({
-		...operationFileEntry(node, node.operationId),
+function resolveOperationFile(options) {
+	const { ctx, node, resolver, root, output } = options;
+	const { memo } = ctx;
+	const location = {
 		root,
 		output,
-		group: group ?? void 0
-	}));
+		group: options.group ?? void 0
+	};
+	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => {
+		const schemaPaths = memo(`${resolver.pluginName}:schemaFilePaths`, () => new Set((ctx.driver.inputNode?.schemas ?? []).flatMap((schema) => schema.name ? [resolver.file({
+			name: schema.name,
+			extname: ".ts",
+			...location
+		}).path.toLowerCase()] : [])));
+		let file = resolver.file({
+			...operationFileEntry(node, node.operationId),
+			...location
+		});
+		for (let name = `${node.operationId}Operation`; schemaPaths.has(file.path.toLowerCase()); name += "Operation") {
+			const next = resolver.file({
+				...operationFileEntry(node, name),
+				...location
+			});
+			if (next.path === file.path) break;
+			file = next;
+		}
+		return file;
+	});
 }
-function getOperationLink(node, link) {
-	if (!link) return null;
-	if (typeof link === "function") return link(node) ?? null;
-	return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
+/**
+* The operation's method and path as plain text, such as `` `GET /pet/{petId}` ``. A path is not a valid `{@link}` target.
+*/
+function getOperationRequestLine(node) {
+	return ast.http.isOperation(node) && node.path ? `\`${node.method.toUpperCase()} ${node.path}\`` : null;
 }
 /**
 * Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
@@ -72,18 +381,7 @@ function getContentTypeInfo(node) {
 * 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 baseContentType(contentType) {
-	return contentType.split(";")[0].trim().toLowerCase();
-}
-/**
-* Whether a content entry is a sequence of JSON values the adapter marks as a stream, such as `application/jsonl`,
-* `application/x-ndjson`, `application/json-seq`, or any media type with an OpenAPI 3.2 `itemSchema`.
-*/
-function isJsonLines(entry) {
-	const baseType = baseContentType(entry.contentType);
-	return Boolean(entry.stream) && baseType !== "text/event-stream" && !baseType.startsWith("multipart/");
+	return buildContentTypeInfo(ast.http.responses.findPrimary(node)?.content?.map((e) => e.contentType) ?? []);
 }
 /**
 * How an operation streams its primary success response item by item, when that response declares one content type:
@@ -95,11 +393,19 @@ function isJsonLines(entry) {
 * call with its query hooks.
 */
 function getEventStream(node) {
-	const content = getPrimarySuccessResponse(node)?.content ?? [];
+	const content = ast.http.responses.findPrimary(node)?.content ?? [];
 	if (content.length !== 1) return null;
 	const entry = content[0];
-	if (baseContentType(entry.contentType) === "text/event-stream") return entry.stream?.shape ?? "data";
-	return isJsonLines(entry) ? "line" : null;
+	const framing = getStreamFraming(entry);
+	if (framing === "events") return entry.stream?.shape ?? "data";
+	return framing === "lines" ? "line" : null;
+}
+/**
+* How a content entry is framed as a stream: `'events'` for Server-Sent Events, `'lines'` for JSON Lines.
+*/
+function getStreamFraming(entry) {
+	if (ast.mediaType.getBase(entry) === "text/event-stream") return "events";
+	return entry.stream && ast.mediaType.isStream(entry) ? "lines" : void 0;
 }
 /**
 * Whether an operation streams its primary success response, as Server-Sent Events or JSON Lines. The client generator uses
@@ -109,20 +415,42 @@ function isEventStream(node) {
 	return getEventStream(node) !== null;
 }
 /**
+* Whether a success response offers a stream media type next to other content types. The client returns that variant's
+* body as a `ReadableStream`, so the stream runtime is registered and a hook's data type includes the stream.
+*/
+function hasStreamVariant(node) {
+	return ast.http.responses.filterSuccess(node).some((response) => {
+		const variants = (response.content ?? []).filter((entry) => entry.schema);
+		return variants.length > 1 && variants.some((entry) => ast.mediaType.isStream(entry));
+	});
+}
+/**
 * 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. It drops the data-shape keys to stay assignable to `Options`, which omits them
-* from `RequestConfig`. `cookies` is a group only on an operation that declares one.
+* `useInfiniteQuery`, `useSWR`, ...): `RequestConfig` minus what the
+* hook fills in, which is every request group and `throwOnError`. Unlike {@link buildRequestConfigType},
+* it never narrows `contentType`: query hooks wrap GET operations, which carry no request body to select
+* a content type for.
 */
-function buildClientOptionType(node) {
-	return `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers'${getOperationParameters(node).cookie.length > 0 ? ` | 'cookies'` : ""} | 'url'>>`;
+function buildClientOptionType(options = {}) {
+	return `Partial<Omit<RequestConfig, ${[
+		...requestGroupOrder,
+		"url",
+		...options.omit ?? [],
+		"throwOnError"
+	].map((key) => `'${key}'`).join(" | ")}>>`;
 }
+/**
+* The `client?:` option type of a mutation hook. When the operation has a request content type choice,
+* the mutation variables carry `contentType`, so the config leaves it out. Otherwise the ambiguous side is
+* narrowed to the operation's media types; a single-type side has nothing to pick, so it stays baked in the
+* generated call.
+*/
 function buildRequestConfigType(node) {
+	if (hasRequestContentTypeChoice(node)) return buildClientOptionType({ omit: ["contentType"] });
 	const request = getContentTypeInfo(node);
 	const response = getResponseContentTypeInfo(node);
 	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
-	const base = buildClientOptionType(node);
+	const base = buildClientOptionType();
 	return members.length ? `${base} & { contentType?: { ${members.join("; ")} } }` : base;
 }
 /** The grouped request options, in the order generated signatures and calls list them. */
@@ -137,11 +465,11 @@ const requestGroupOrder = [
 * Which of the grouped request options an operation carries.
 */
 function getRequestGroups(node) {
-	const { path, query, header, cookie } = getOperationParameters(node);
+	const { path, query, header, cookie } = ast.http.groupParameters(node);
 	return {
 		path: path.length > 0,
 		query: query.length > 0,
-		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		body: Boolean(ast.http.requestBody.getSchema(node)),
 		headers: header.length > 0,
 		cookies: cookie.length > 0
 	};
@@ -153,7 +481,7 @@ function getRequestGroups(node) {
 */
 function getRequestGroupOptionality(node) {
 	const groups = getRequestGroups(node);
-	const { path, query, header } = getOperationParameters(node);
+	const { path, query, header } = ast.http.groupParameters(node);
 	const hasRequiredPath = path.some((param) => param.required);
 	const hasRequiredQuery = query.some((param) => param.required);
 	const hasRequiredHeader = header.some((param) => param.required);
@@ -166,104 +494,28 @@ function getRequestGroupOptionality(node) {
 	};
 }
 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"
-	] : [
+	const { splitLines = false } = options;
+	const filteredComments = [
+		getOperationRequestLine(node),
 		node.description && `@description ${node.description}`,
 		node.summary && `@summary ${node.summary}`,
 		node.deprecated && "@deprecated",
-		linkComment
-	]).filter((comment) => Boolean(comment));
+		node.externalDocs && `@see ${jsDocEscape([node.externalDocs.url, node.externalDocs.description].filter(Boolean).join(" "))}`
+	].filter((comment) => Boolean(comment));
 	if (!splitLines) return filteredComments;
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
-const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
-/**
-* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
-* per property, typed and serialized like any other.
-* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
-*/
-function spreadQuerystring(param) {
-	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
-	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
-	if (schema?.type !== "object" || !formEncoded) return [param];
-	return schema.properties.map((property) => ast.factory.createParameter({
-		name: property.name,
-		in: "query",
-		schema: property.schema,
-		required: param.required && property.required
-	}));
-}
-/**
-* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
-* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
-* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
-* same parameters once per plugin.
-*/
-function getOperationParameters(node) {
-	const cached = operationParameterGroupsByNode.get(node);
-	if (cached) return cached;
-	const dedupe = (params) => {
-		const seen = /* @__PURE__ */ new Set();
-		return params.filter((param) => {
-			if (seen.has(param.name)) return false;
-			seen.add(param.name);
-			return true;
-		});
-	};
-	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
-	const groups = {
-		path: group("path"),
-		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
-		header: group("header"),
-		cookie: group("cookie")
-	};
-	operationParameterGroupsByNode.set(node, groups);
-	return groups;
-}
 /**
 * Whether the operation declares more than one request media type with a schema, so a caller must pick one on `contentType`.
 */
 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;
-}
-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));
+	return ast.http.responses.filterError(node).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));
+	return ast.http.responses.filterSuccess(node).map((response) => resolver.response.status(node, response.statusCode));
 }
 function resolveStatusCodeNames(node, resolver) {
 	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
@@ -275,7 +527,7 @@ function resolveStatusCodeNames(node, resolver) {
 function resolveOperationTypeNames(node, resolver, options = {}) {
 	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, cookie } = getOperationParameters(node);
+		const { path, query, header, cookie } = ast.http.groupParameters(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 ? [] : [
@@ -284,7 +536,7 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 			...header.map((param) => resolver.param.headers(node, param)),
 			...cookie.map((param) => resolver.param.cookies(node, param))
 		];
-		const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)];
+		const bodyAndResponseNames = [ast.http.requestBody.getSchema(node) ? resolver.response.body(node) : null, resolver.response.response(node)];
 		return (options.order === "body-response-first" ? [
 			...bodyAndResponseNames,
 			...paramNames,
@@ -296,235 +548,139 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 		]).filter((name) => Boolean(name) && !exclude.has(name));
 	});
 }
-// ../../internals/utils/src/casing.ts
-/**
-* Uppercases only the first character of `text`, leaving the rest untouched.
-* Unlike `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)}`;
-}
-// ../../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"
-]);
+// ../../internals/shared/src/resolver.ts
 /**
-* 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)
-* ```
+* The shared top-level `name` of the operation plugins, computed once per operation name and build.
 */
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return isIdentifier(name);
+function resolveOperationName(name) {
+	return this.memo(`operation:${name}`, () => ensureValidVarName(casing.camel(name)));
 }
 /**
-* Returns `name` when it's a syntactically valid JavaScript variable name,
-* otherwise prefixes it with `_` so the result is a valid identifier.
+* 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.
 *
-* 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.
+* The key starts from the operation's input `pointer`, which macros keep, so a plugin whose macro
+* rewrites the method or path still resolves another plugin's names for the same operation.
 *
 * @example
 * ```ts
-* ensureValidVarName('409')             // '_409'
-* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
-* ensureValidVarName('Pet')              // 'Pet'
-* ensureValidVarName('class')            // '_class'
+* resolver.resolveName({ key: operationKey(node, 'response', 'status', 404), name })
 * ```
 */
-function ensureValidVarName(name) {
-	if (!name || isValidVarName(name)) return name;
-	return `_${name}`;
+function operationKey(node, ...scope) {
+	return [
+		"operation",
+		...node.pointer ? [node.pointer] : [node.method, node.path],
+		...scope.map(String)
+	];
+}
+// ../../internals/client/src/resolveClientOperation.ts
+function isRelativeImport(importPath) {
+	return importPath.startsWith(".");
+}
+function resolveImportPath(options) {
+	const { importPath, operationFile } = options;
+	return isRelativeImport(importPath) ? path.resolve(path.dirname(operationFile), importPath) : importPath;
 }
 /**
-* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+* 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, plugin-axios, or plugin-client). Returns `null` when no contract plugin is in play (the inline
+* path), or when the client plugin's `exclude` / `include` leaves this operation out, since it then
+* emits no `<op>` to import. plugin-fetch / plugin-axios inject `.kubb/client.ts` at the global
+* output root, the same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
+* With plugin-client they come from the user's `importPath` module instead.
 *
-* 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.
+* The result is cached in `memo` (the build's `ctx.memo`) under the client plugin's name and the operation,
+* so several dependents reading the same client plugin for one operation in a single pass
+* (react-query's query/mutation/infinite generators, vue-query, swr, the MCP handler, ...) share
+* one computed result instead of each re-deriving the name and path.
 *
-* @example
-* ```ts
-* isIdentifier('name')   // true
-* isIdentifier('x-total')// false
-* ```
+* `returnType`, `output`, and `group` are the client plugin's options for this operation, after its
+* `override` entries, the same resolution its own generator sees. A dependent's generated call body
+* and import path therefore match the `<op>` actually emitted, even when an `override` changes it.
 */
-function isIdentifier(name) {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+function resolveClientOperation(options) {
+	const { clientPlugin, driver, node, root, output, memo } = options;
+	if (!clientPlugin) return null;
+	return memo(`${clientPlugin.pluginName}:clientOperation:${node.operationId}`, () => {
+		const resolver = driver.getResolver(clientPlugin.pluginName);
+		const pluginOptions = driver.getPlugin(clientPlugin.pluginName)?.options ?? {};
+		const { exclude, include, override } = pluginOptions;
+		const operationOptions = Boolean(exclude?.length || include?.length || override?.length) && resolver.default ? resolver.default.options(node, {
+			options: pluginOptions,
+			exclude,
+			include,
+			override
+		}) : pluginOptions;
+		if (!operationOptions) return null;
+		const file = resolver.file({
+			...operationFileEntry(node, node.operationId),
+			root,
+			output: operationOptions.output ?? output,
+			group: operationOptions.group ?? void 0
+		});
+		const { importPath } = operationOptions;
+		const name = resolver.name(node.operationId);
+		return {
+			name: resolver.resolveName({
+				key: operationKey(node),
+				name
+			}),
+			path: file.path,
+			clientPath: importPath === void 0 ? path.resolve(root, ".kubb/client.ts") : resolveImportPath({
+				importPath,
+				operationFile: file.path
+			}),
+			clientPathIsFile: importPath === void 0 || isRelativeImport(importPath),
+			returnType: operationOptions.returnType ?? "full",
+			typedHeaders: importPath === void 0
+		};
+	});
+}
+// ../../internals/client/src/resolveOperationTypes.ts
+const pluginZodName = "plugin-zod";
+function getResponseHeadersEntries({ node, types }) {
+	const resolve = types.response.headers;
+	if (!resolve) return [];
+	return node.responses.filter((response) => response.headers?.length).map((response) => [response.statusCode, resolve.call(types.response, node, response.statusCode)]);
 }
-// ../../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']"
-* ```
+* The headers type argument of `RequestResult`, such as `{ '200': LoginUserStatus200Headers }`, or `null` when no response declares headers.
 */
-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("']?.['")}']`}`;
+function buildResponseHeadersType({ node, types }) {
+	const entries = getResponseHeadersEntries({
+		node,
+		types
+	}).map(([statusCode, name]) => `'${statusCode}': ${name}`);
+	return entries.length ? `{ ${entries.join("; ")} }` : null;
 }
-// ../../internals/shared/src/resolver.ts
 /**
-* The shared top-level `name` of the operation plugins, computed once per operation name and build.
+* A runtime result type, such as `RequestResult`, in its `WithHeaders` form when `headers` is set.
 */
-function resolveOperationName(name) {
-	return this.memo(`operation:${name}`, () => ensureValidVarName(camelCase(name)));
+function resultTypeName(name, headers) {
+	return headers ? `${name}WithHeaders` : 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 })
-* ```
+* A runtime result type with its arguments, such as `RequestResultWithHeaders<Responses, Headers, ThrowOnError>`.
 */
-function operationKey(node, ...scope) {
-	return [
-		"operation",
-		node.method,
-		node.path,
-		...scope.map(String)
-	];
+function buildResultTypeRef(name, responses, headers, rest = []) {
+	return `${resultTypeName(name, headers !== null)}<${[
+		responses,
+		headers,
+		...rest
+	].filter(Boolean).join(", ")}>`;
 }
-// ../../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
-* ```
+* The names of the headers types `buildResponseHeadersType` references, for the file's imports.
 */
-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
-	};
+function getResponseHeadersTypeNames({ node, types }) {
+	return getResponseHeadersEntries({
+		node,
+		types
+	}).map(([, name]) => name);
 }
-// kubb-extension.json
-var compatibility = {
-	"kubb": ">=5.16.0",
-	"node": ">=22.22"
-};
-// package.json
-var version = "5.10.0-canary.20261109T191216";
-// ../../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.
@@ -547,6 +703,7 @@ function toZodTypeResolver(resolver) {
 			status: (node, statusCode) => type(resolver.response.status(node, statusCode)),
 			response: (node) => type(resolver.response.response(node)),
 			responses: (node) => type(resolver.response.responses(node)),
+			headers: (node, statusCode) => type(resolver.response.headers(node, statusCode)),
 			options: (node) => resolver.response.options(node)
 		}
 	};
@@ -594,179 +751,6 @@ function resolveOperationTypes(driver, pluginName) {
 		};
 	});
 }
-// ../../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, plugin-axios, or plugin-client) 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, the
-*   requested one is missing, or `client` is not a known selector.
-*
-* The `client` string selects explicitly (`'fetch'` / `'axios'` / `'client'`); when it is unset a
-* lone registered contract client plugin is picked up automatically.
-*/
-const pluginFetchName = "plugin-fetch";
-const pluginAxiosName = "plugin-axios";
-const pluginClientName = "plugin-client";
-const selectorToPlugin = {
-	fetch: pluginFetchName,
-	axios: pluginAxiosName,
-	client: pluginClientName
-};
-const contractPlugins = [
-	pluginFetchName,
-	pluginAxiosName,
-	pluginClientName
-];
-/**
-* 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', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
-* ```
-*/
-function resolveClient(options) {
-	const { client, pluginNames } = options;
-	const has = (name) => pluginNames.includes(name);
-	if (client === "fetch" || client === "axios" || client === "client") {
-		const pluginName = selectorToPlugin[client];
-		if (!has(pluginName)) return {
-			kind: "error",
-			code: Diagnostics.code.missingDependency,
-			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
-			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
-		};
-		return {
-			kind: "contract",
-			pluginName
-		};
-	}
-	if (client !== void 0) return {
-		kind: "error",
-		code: Diagnostics.code.invalidPluginOptions,
-		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
-		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
-	};
-	const registered = contractPlugins.filter(has);
-	if (registered.length === 1) return {
-		kind: "contract",
-		pluginName: registered[0]
-	};
-	if (registered.length > 1) return {
-		kind: "error",
-		code: Diagnostics.code.invalidPluginOptions,
-		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
-		help: "Set `client: 'fetch' | 'axios' | 'client'` to choose which client the hooks call, or register a single client plugin."
-	};
-	return {
-		kind: "error",
-		code: Diagnostics.code.missingDependency,
-		message: "No client plugin is registered.",
-		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
-	};
-}
-/**
-* Resolves the contract client during a consumer plugin's setup hook.
-* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
-* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
-* fails fast with the same message.
-*/
-function resolveContractClient(options) {
-	const { plugin, client, plugins = [] } = options;
-	const resolved = resolveClient({
-		client,
-		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
-	});
-	if (resolved.kind === "error") {
-		const { code, message, help } = resolved;
-		throw new Diagnostics.Error({
-			code,
-			severity: "error",
-			message,
-			help,
-			location: { kind: "config" },
-			plugin
-		});
-	}
-	return resolved;
-}
-// ../../internals/client/src/resolveClientOperation.ts
-function isRelativeImport(importPath) {
-	return importPath.startsWith(".");
-}
-function resolveImportPath(options) {
-	const { importPath, operationFile } = options;
-	return isRelativeImport(importPath) ? path.resolve(path.dirname(operationFile), importPath) : importPath;
-}
-/**
-* 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, plugin-axios, or plugin-client). Returns `null` when no contract plugin is in play (the inline
-* path), or when the client plugin's `exclude` / `include` leaves this operation out, since it then
-* emits no `<op>` to import. plugin-fetch / plugin-axios inject `.kubb/client.ts` at the global
-* output root, the same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
-* With plugin-client they come from the user's `importPath` module instead.
-*
-* The result is cached in `memo` (the build's `ctx.memo`) under the client plugin's name and the operation,
-* so several dependents reading the same client plugin for one operation in a single pass
-* (react-query's query/mutation/infinite generators, vue-query, swr, the MCP handler, ...) share
-* one computed result instead of each re-deriving the name and path.
-*
-* `returnType`, `output`, and `group` are the client plugin's options for this operation, after its
-* `override` entries, the same resolution its own generator sees. A dependent's generated call body
-* and import path therefore match the `<op>` actually emitted, even when an `override` changes it.
-*/
-function resolveClientOperation(options) {
-	const { clientPlugin, driver, node, root, output, memo } = options;
-	if (!clientPlugin) return null;
-	return memo(`${clientPlugin.pluginName}:clientOperation:${node.operationId}`, () => {
-		const resolver = driver.getResolver(clientPlugin.pluginName);
-		const pluginOptions = driver.getPlugin(clientPlugin.pluginName)?.options ?? {};
-		const { exclude, include, override } = pluginOptions;
-		const operationOptions = Boolean(exclude?.length || include?.length || override?.length) && resolver.default ? resolver.default.options(node, {
-			options: pluginOptions,
-			exclude,
-			include,
-			override
-		}) : pluginOptions;
-		if (!operationOptions) return null;
-		const file = resolver.file({
-			...operationFileEntry(node, node.operationId),
-			root,
-			output: operationOptions.output ?? output,
-			group: operationOptions.group ?? void 0
-		});
-		const { importPath } = operationOptions;
-		const name = resolver.name(node.operationId);
-		return {
-			name: resolver.resolveName({
-				key: operationKey(node),
-				name
-			}),
-			path: file.path,
-			clientPath: importPath === void 0 ? path.resolve(root, ".kubb/client.ts") : resolveImportPath({
-				importPath,
-				operationFile: file.path
-			}),
-			clientPathIsFile: importPath === void 0 || isRelativeImport(importPath),
-			returnType: operationOptions.returnType ?? "full"
-		};
-	});
-}
 // ../../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
@@ -785,14 +769,18 @@ function resolveHookFile(node, ctx, options) {
 	});
 	const types = resolveOperationTypes(ctx.driver, resolver.pluginName);
 	const tsResolver = types.resolver;
+	const headerTypeNames = returnType === "data" || !contractOp.typedHeaders ? [] : getResponseHeadersTypeNames({
+		node,
+		types: tsResolver
+	});
 	const file = resolver.file({
 		...operationFileEntry(node, name),
 		root,
 		output,
 		group: group ?? void 0
 	});
-	const fileTs = resolveDependencyOperationFile({
-		memo: ctx.memo,
+	const fileTs = resolveOperationFile({
+		ctx,
 		node,
 		resolver: tsResolver,
 		root,
@@ -802,6 +790,7 @@ function resolveHookFile(node, ctx, options) {
 	const importedTypeNames = [
 		tsResolver.response.options(node),
 		tsResolver.response.responses(node),
+		...headerTypeNames,
 		...extraTypeNames,
 		...resolveOperationTypeNames(node, tsResolver, {
 			exclude: [keyTypeName, returnType !== "data" ? tsResolver.response.response(node) : null].filter((name) => Boolean(name)),
@@ -819,6 +808,7 @@ function resolveHookFile(node, ctx, options) {
 		tsResolver,
 		contractOp,
 		importedTypeNames,
+		resultTypeName: headerTypeNames.length ? "RequestResultWithHeaders" : "RequestResult",
 		returnType,
 		banner: resolver.default.banner(ctx.meta, {
 			output,
@@ -836,7 +826,7 @@ function resolveHookFile(node, ctx, options) {
 * The `<File>` shell shared by the TanStack hook generators; renders `children` after the imports.
 */
 function HookFile({ hook, imports, children }) {
-	const { file, fileTs, contractOp, importedTypeNames, banner, footer } = hook;
+	const { file, fileTs, contractOp, importedTypeNames, resultTypeName, banner, footer } = hook;
 	return /* @__PURE__ */ jsxs(File, {
 		baseName: file.baseName,
 		path: file.path,
@@ -853,7 +843,7 @@ function HookFile({ hook, imports, children }) {
 				name: [
 					"RequestConfig",
 					"ResponseErrorConfig",
-					"RequestResult"
+					resultTypeName
 				],
 				root: contractOp.clientPathIsFile ? file.path : void 0,
 				path: contractOp.clientPath,
@@ -929,8 +919,8 @@ function buildGroupedRequestParam(node, options) {
 /**
 * Builds the shared `({ path, query, body, headers, cookies }, 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`.
+* trailing `config` is the client's `Options` minus the request groups and `throwOnError`, which the
+* hook passes itself. Framework plugins wrap the result when needed, for example vue-query applies `MaybeRefOrGetter`.
 */
 function buildQueryOptionsParams(node, options) {
 	const { resolver, memberTypeWrapper } = options;
@@ -940,7 +930,7 @@ function buildQueryOptionsParams(node, options) {
 	});
 	const configParam = createFunctionParameter({
 		name: "config",
-		type: buildClientOptionType(node),
+		type: buildClientOptionType(),
 		default: "{}"
 	});
 	return createFunctionParameters({ params: [groupedParam, configParam].filter((param) => param !== null) });
@@ -952,26 +942,30 @@ function buildQueryOptionsParams(node, options) {
 * can't flip the query's error semantics. Queries thread the TanStack `signal`; mutations omit it.
 *
 * 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.
+* used by vue-query to resolve refs and getters with `toValue(...)` at call time. `pageParam` names the
+* query parameter an infinite query sets from TanStack's `pageParam`.
 *
 * @example
 * ```ts
 * buildClientCall(node, { clientName: 'getPetById', signal: true })
-* // getPetById({ path, ...config, signal: config.signal ?? signal, throwOnError: true })
+* // getPetById({ ...config, path, signal: config.signal ?? signal, throwOnError: true })
 * ```
 */
 function buildClientCall(node, options) {
-	const { clientName, signal = false, unwrapName, withContentType = false, returnType = "full" } = options;
+	const { clientName, signal = false, unwrapName, withContentType = false, pageParam } = options;
 	const { groups } = getRequestGroupOptionality(node);
 	const names = requestGroupOrder.filter((key) => groups[key]);
-	const args = [
+	const member = (name) => {
+		const value = unwrapName ? unwrapName(name) : name;
+		if (name === "query" && pageParam) return `query: { ...${value}, ${JSON.stringify(pageParam)}: pageParam }`;
+		return unwrapName ? `${name}: ${value}` : name;
+	};
+	return `${clientName}({ ${[
 		"...config",
-		...withContentType && hasRequestContentTypeChoice(node) ? ["...variables"] : names.map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		...withContentType && hasRequestContentTypeChoice(node) ? ["...variables"] : names.map(member),
 		signal ? "signal: config.signal ?? signal" : null,
 		"throwOnError: true"
-	].filter((part) => part !== null);
-	if (withContentType && hasRequestContentTypeChoice(node)) return `${clientName}(${castToClientOptions(`{ ${args.join(", ")} }`, clientName, returnType)})`;
-	return `${clientName}({ ${args.join(", ")} })`;
+	].filter((part) => part !== null).join(", ")} })`;
 }
 /**
 * Builds the query/mutation body that resolves a `buildClientCall` expression down to the bare
@@ -994,19 +988,28 @@ function buildCallResultBody(call, options = {}) {
 	if (clientReturnType === "plain") return `return (await ${call}).data`;
 	return `return ${call}.unwrap()`;
 }
+function buildResultType(node, resolver, typedHeaders) {
+	const headers = typedHeaders ? buildResponseHeadersType({
+		node,
+		types: resolver
+	}) : null;
+	return buildResultTypeRef("RequestResult", resolver.response.responses(node), headers, ["true"]);
+}
 /**
 * Builds the `TData` / `TError` type expressions shared by every generated hook, joining the resolved
 * success responses into `TData` and wrapping the error responses in `ResponseErrorConfig<...>`.
-* With `returnType` `'full'`, `TData` is the client's `RequestResult` over the operation's responses record.
+* With `returnType` `'full'`, `TData` is the client's `RequestResult` over the operation's responses record, with the
+* response headers the operation declares.
 */
 function buildResponseTypes(node, resolver, options = {}) {
-	const { returnType = "data" } = options;
-	return resolver.memo(`responseTypes:${returnType}:${node.method}\0${node.path}`, () => {
+	const { returnType = "data", typedHeaders = true } = options;
+	return resolver.memo(`responseTypes:${returnType}:${typedHeaders}:${node.method}\0${node.path}`, () => {
 		const successNames = resolveSuccessNames(node, resolver);
-		const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
+		const bodyName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
+		const responseName = hasStreamVariant(node) ? `${bodyName} | ReadableStream<Uint8Array>` : bodyName;
 		const errorNames = resolveErrorNames(node, resolver);
 		return {
-			TData: returnType !== "data" ? `RequestResult<${resolver.response.responses(node)}, true>` : responseName,
+			TData: returnType === "data" ? responseName : buildResultType(node, resolver, typedHeaders),
 			TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
 		};
 	});
@@ -1025,7 +1028,7 @@ function resolveFallbackPageParamType(initialPageParam) {
 * so callers can reuse it when rewriting the paginated request.
 */
 function resolvePageParamType(node, { resolver, initialPageParam, queryParam }) {
-	const firstQueryParam = getOperationParameters(node).query[0];
+	const firstQueryParam = ast.http.groupParameters(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;
@@ -1128,7 +1131,7 @@ function resolveInfiniteConfig(infinite) {
 */
 function matchesInfinite(node, infinite) {
 	if (!infinite.queryParam) return false;
-	return getOperationParameters(node).query.some((param) => param.name.replace(/\?$/, "") === infinite.queryParam);
+	return ast.http.groupParameters(node).query.some((param) => param.name.replace(/\?$/, "") === infinite.queryParam);
 }
 /**
 * Warning for an infinite hook that falls back to the built-in page params on a response that
@@ -1136,8 +1139,8 @@ function matchesInfinite(node, infinite) {
 */
 function getDefaultPageParamsWarning(node, infinite) {
 	if (!(infinite.getNextPageParam == null && infinite.getPreviousPageParam == null && infinite.nextParam == null && infinite.previousParam == null && !infinite.cursorParam)) return null;
-	const content = getPrimarySuccessResponse(node)?.content;
-	let resolved = (content?.find((item) => item.contentType?.includes("json")) ?? content?.[0])?.schema;
+	const content = ast.http.responses.findPrimary(node)?.content;
+	let resolved = (content?.find((item) => ast.mediaType.isJson(item)) ?? content?.[0])?.schema;
 	while (resolved?.type === "ref" || resolved?.type === "intersection" && resolved.members?.length === 1) resolved = resolved.type === "ref" ? resolved.schema : resolved.members?.[0];
 	if (!resolved || resolved.type === "array") return null;
 	return `${node.operationId}: the default infinite page params expect an array response and never end for this one. Set \`infinite.getNextPageParam\` (or \`nextParam\`) to read the next page from the response.`;
@@ -1220,9 +1223,15 @@ function buildHookParams(node, options) {
 }
 /**
 * The `TRequest` type argument of a mutation hook: the options type when the operation takes a request, else `undefined`.
+* When the variables carry the request media type and the response has several, `contentType` can pick the
+* response one too, as `{ request, response }`.
 */
 function resolveMutationRequestType(node, resolver) {
-	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
+	if (!buildGroupedRequestParam(node, { resolver })) return "undefined";
+	const optionsName = resolver.response.options(node);
+	const response = getResponseContentTypeInfo(node);
+	if (!hasRequestContentTypeChoice(node) || !response.isMultipleContentTypes) return optionsName;
+	return `${/^[\w$]+$/.test(optionsName) ? optionsName : `(${optionsName})`} & { contentType?: string | { response?: ${response.contentTypeUnion} } }`;
 }
 /**
 * Builds the object literal that unwraps each request group's getter before it reaches `queryKey`/`queryOptions`; `null` without a request group.
@@ -1236,8 +1245,11 @@ function buildResolvedRequestParams(node) {
 // ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$6 = functionPrinter({ mode: "declaration" });
 const callPrinter$3 = functionPrinter({ mode: "call" });
-function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, clientReturnType, returnType }) {
-	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver, { returnType });
+function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, clientReturnType, returnType, typedHeaders }) {
+	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver, {
+		returnType,
+		typedHeaders
+	});
 	const dataSuffix = returnType === "data" ? "" : ".data";
 	const { queryParamsTypeName, pageParamType } = resolvePageParamType(node, {
 		resolver: tsResolver,
@@ -1256,10 +1268,12 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitI
 		memberTypeWrapper
 	});
 	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
+	const pageParam = queryParam && queryParamsTypeName ? queryParam : void 0;
 	const queryFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: true,
-		unwrapName
+		unwrapName,
+		pageParam
 	}), {
 		clientReturnType,
 		returnType
@@ -1286,12 +1300,7 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitI
 		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;
+	const queryFnArgs = pageParam ? "{ signal, pageParam }" : "{ signal }";
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable: true,
@@ -1305,7 +1314,7 @@ const queryKey = ${queryKeyName}(${queryKeyParamsCall})
 return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, ${queryKeyType}, ${pageParamType}>({
   queryKey,
   queryFn: async (${queryFnArgs}) => {
-    ${queryFnStatements}
+    ${queryFnBody}
   },
   ${queryOptionsArr.join(",\n  ")}
 })
@@ -1376,7 +1385,7 @@ function MutationKey({ name, node, transformer, typeName }) {
 function createQueryResolver(variant = "") {
 	return {
 		name(node) {
-			const name = `use${capitalize(this.name(node.operationId))}${variant}`;
+			const name = `use${casing.capitalize(this.name(node.operationId))}${variant}`;
 			return this.resolveName({
 				key: operationKey(node, "query", variant, "name"),
 				name
@@ -1397,7 +1406,7 @@ function createQueryResolver(variant = "") {
 			});
 		},
 		keyTypeName(node) {
-			const name = `${capitalize(this.name(node.operationId))}${variant}QueryKey`;
+			const name = `${casing.capitalize(this.name(node.operationId))}${variant}QueryKey`;
 			return this.resolveName({
 				key: operationKey(node, "query", variant, "keyTypeName"),
 				name
@@ -1418,7 +1427,7 @@ function createQueryResolver(variant = "") {
 function createMutationResolver() {
 	return {
 		name(node) {
-			const name = `use${capitalize(this.name(node.operationId))}`;
+			const name = `use${casing.capitalize(this.name(node.operationId))}`;
 			return this.resolveName({
 				key: operationKey(node, "mutation", "name"),
 				name
@@ -1447,14 +1456,14 @@ const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
 */
 const queryKeyTransformer = ({ node, variant }) => {
 	if (!node.path) return [];
-	const { path, query } = getOperationParameters(node);
+	const { path, query } = ast.http.groupParameters(node);
 	const isInfinite = variant === "infiniteQuery" || variant === "suspenseInfiniteQuery";
 	const urlFields = [`url: '${Url.toPath(node.path)}'`];
 	if (path.length > 0) urlFields.push("params: path");
 	if (isInfinite) urlFields.push("infinite: true");
 	const result = [`{ ${urlFields.join(", ")} }`];
 	if (query.length > 0) result.push("...(query ? [query] : [])");
-	if (node.requestBody?.content?.[0]?.schema) result.push("...(body !== undefined ? [body] : [])");
+	if (ast.http.requestBody.getSchema(node)) result.push("...(body !== undefined ? [body] : [])");
 	return result;
 };
 function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "query", memberTypeWrapper, exportType }) {
@@ -1618,7 +1627,7 @@ const hookOptionsGenerator = defineGenerator({
 		const imports = [];
 		const hookOptions = {};
 		for (const node of nodes) {
-			if (!ast.isHttpOperationNode(node)) continue;
+			if (!ast.http.isOperation(node)) continue;
 			const opOverrides = resolveOperationOverrides(node, override);
 			const nodeQuery = "query" in opOverrides ? opOverrides.query : query;
 			const nodeMutation = "mutation" in opOverrides ? opOverrides.mutation : mutation;
@@ -1741,8 +1750,11 @@ function buildHookTypes({ node, tsResolver, infinite, suspense, TData, TError, q
 		resultType: `${resultTypeName}<TData, ${TError}> & { queryKey: TQueryKey }`
 	};
 }
-function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions, suspense, infinite, returnType }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, customOptions, suspense, infinite, returnType, typedHeaders }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, {
+		returnType,
+		typedHeaders
+	});
 	const prefix = suspense ? "UseSuspense" : "Use";
 	const hookName = `${suspense ? "useSuspense" : "use"}${infinite ? "InfiniteQuery" : "Query"}`;
 	const observerOptionsName = OBSERVER_OPTIONS_NAMES[infinite ? "infinite" : "plain"][suspense ? "suspense" : "standard"];
@@ -1766,7 +1778,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 		memberTypeWrapper: maybeValueOrGetter,
 		optionsType: `{
   query?: Partial<${observerOptionsType}> & { client?: QueryClient },
-  client?: ${buildClientOptionType(node)}
+  client?: ${buildClientOptionType()}
 }`
 	});
 	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
@@ -1802,8 +1814,11 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 // src/components/QueryOptions.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$2 = functionPrinter({ mode: "call" });
-function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, clientReturnType, returnType }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
+function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, clientReturnType, returnType, typedHeaders }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, {
+		returnType,
+		typedHeaders
+	});
 	const queryKeyParamsNode = buildQueryKeyParams(node, { resolver: tsResolver });
 	const queryKeyParamsCall = callPrinter$2.print(queryKeyParamsNode) ?? "";
 	const paramsNode = buildQueryOptionsParams(node, { resolver: tsResolver });
@@ -1856,7 +1871,7 @@ function createQueryGenerator({ name, variant }) {
 		renderer: jsxRenderer,
 		match(node, ctx) {
 			const operationNode = node;
-			if (!ast.isHttpOperationNode(operationNode)) return false;
+			if (!ast.http.isOperation(operationNode)) return false;
 			const { query, mutation, infinite: infiniteConfig, suspense: suspenseConfig, hooks } = ctx.options;
 			const { isQuery, isMutation } = classifyOperation(operationNode, {
 				query,
@@ -1871,7 +1886,7 @@ function createQueryGenerator({ name, variant }) {
 			return !!infiniteOptions && matchesInfinite(operationNode, infiniteOptions);
 		},
 		operation(node, ctx) {
-			if (!ast.isHttpOperationNode(node)) return null;
+			if (!ast.http.isOperation(node)) return null;
 			const { driver, resolver, root } = ctx;
 			const { output, query, infinite: infiniteConfig, client, group, customOptions, hooks } = ctx.options;
 			const infiniteOptions = infinite && infiniteConfig && typeof infiniteConfig === "object" ? infiniteConfig : null;
@@ -1949,7 +1964,8 @@ function createQueryGenerator({ name, variant }) {
 							hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
 							queryParam: infiniteOptions.queryParam,
 							clientReturnType: contractOp.returnType,
-							returnType: hook.returnType
+							returnType: hook.returnType,
+							typedHeaders: hook.contractOp.typedHeaders
 						})
 					] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(File.Import, {
 						name: ["queryOptions"],
@@ -1961,7 +1977,8 @@ function createQueryGenerator({ name, variant }) {
 						node,
 						tsResolver: hook.tsResolver,
 						clientReturnType: contractOp.returnType,
-						returnType: hook.returnType
+						returnType: hook.returnType,
+						typedHeaders: hook.contractOp.typedHeaders
 					})] }),
 					(variant !== "query" || query && hooks) && /* @__PURE__ */ jsxs(Fragment, { children: [
 						/* @__PURE__ */ jsx(File.Import, {
@@ -1986,6 +2003,7 @@ function createQueryGenerator({ name, variant }) {
 							tsResolver: hook.tsResolver,
 							customOptions,
 							returnType: hook.returnType,
+							typedHeaders: hook.contractOp.typedHeaders,
 							suspense,
 							infinite: infiniteOptions ? {
 								initialPageParam: infiniteOptions.initialPageParam,
@@ -2020,8 +2038,11 @@ function buildMutationConfigParamsNode(node) {
 		default: "{}"
 	})] });
 }
-function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName, clientReturnType, returnType }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
+function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName, clientReturnType, returnType, typedHeaders }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, {
+		returnType,
+		typedHeaders
+	});
 	const configParamsNode = buildMutationConfigParamsNode(node);
 	const paramsSignature = declarationPrinter$1.print(configParamsNode) ?? "";
 	const groupedParam = buildGroupedRequestParam(node, {
@@ -2030,13 +2051,12 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 	});
 	const hasMutationParams = groupedParam !== null;
 	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
-	const TRequest = hasMutationParams ? tsResolver.response.options(node) : "undefined";
+	const TRequest = resolveMutationRequestType(node, tsResolver);
 	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "_";
 	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: false,
-		withContentType: true,
-		returnType: clientReturnType
+		withContentType: true
 	}), {
 		clientReturnType,
 		returnType
@@ -2066,8 +2086,11 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 const callPrinter = functionPrinter({ mode: "call" });
 function buildMutationParamsNode(node, options) {
-	const { resolver, returnType } = options;
-	const { TData, TError } = buildResponseTypes(node, resolver, { returnType });
+	const { resolver, returnType, typedHeaders } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver, {
+		returnType,
+		typedHeaders
+	});
 	return buildHookParams(node, {
 		resolver,
 		withRequest: false,
@@ -2082,8 +2105,11 @@ function buildMutationParamsNode(node, options) {
 }`
 	});
 }
-function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName, customOptions, returnType }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
+function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName, customOptions, returnType, typedHeaders }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, {
+		returnType,
+		typedHeaders
+	});
 	const generics = [
 		TData,
 		TError,
@@ -2095,7 +2121,8 @@ function Mutation({ name, mutationOptionsName, node, tsResolver, mutationKeyName
 	const mutationOptionsParamsCall = callPrinter.print(mutationOptionsConfigNode) ?? "";
 	const paramsNode = buildMutationParamsNode(node, {
 		resolver: tsResolver,
-		returnType
+		returnType,
+		typedHeaders
 	});
 	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
 	return /* @__PURE__ */ jsx(File.Source, {
@@ -2135,7 +2162,7 @@ const mutationGenerator = defineGenerator({
 	renderer: jsxRenderer,
 	match(node, ctx) {
 		const operationNode = node;
-		if (!ast.isHttpOperationNode(operationNode)) return false;
+		if (!ast.http.isOperation(operationNode)) return false;
 		const { query, mutation } = ctx.options;
 		return classifyOperation(operationNode, {
 			query,
@@ -2143,7 +2170,7 @@ const mutationGenerator = defineGenerator({
 		}).isMutation;
 	},
 	operation(node, ctx) {
-		if (!ast.isHttpOperationNode(node)) return null;
+		if (!ast.http.isOperation(node)) return null;
 		const { driver, resolver, root } = ctx;
 		const { output, mutation, client, group, customOptions, hooks } = ctx.options;
 		const importPath = mutation ? mutation.importPath : "@tanstack/react-query";
@@ -2190,7 +2217,8 @@ const mutationGenerator = defineGenerator({
 					node,
 					tsResolver,
 					clientReturnType: contractOp.returnType,
-					returnType: hook.returnType
+					returnType: hook.returnType,
+					typedHeaders: hook.contractOp.typedHeaders
 				}),
 				mutation && hooks && /* @__PURE__ */ jsxs(Fragment, { children: [
 					/* @__PURE__ */ jsx(File.Import, {
@@ -2213,7 +2241,8 @@ const mutationGenerator = defineGenerator({
 						node,
 						tsResolver,
 						customOptions,
-						returnType: hook.returnType
+						returnType: hook.returnType,
+						typedHeaders: hook.contractOp.typedHeaders
 					})
 				] })
 			]
@@ -2372,7 +2401,7 @@ const pluginReactQuery = defineExtension({
 				...customOptions
 			} : null,
 			hooks,
-			group: createGroupConfig(group),
+			group: group ?? null,
 			exclude,
 			include,
 			override,