@kubb/plugin-react-query 5.11.0-canary.20261111T120000 → 5.11.0-canary.20261111T193820

package/dist/index.cjs

@@ -23,14 +23,192 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-let _kubb_kit = require("@kubb/kit");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
+let _kubb_kit = require("@kubb/kit");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
 let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs, 1);
+// ../../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"
+]);
+/**
+* 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
+/**
+* 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\\@");
+}
+/**
+* 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("']?.['")}']`}`;
+}
 // ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -126,16 +304,19 @@ function getContentTypeInfo(node) {
 function getResponseContentTypeInfo(node) {
 	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
 }
+/**
+* The media type without its parameters, in lower case: `Text/Plain; charset=utf-8` gives `text/plain`.
+*/
 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`.
+* `application/x-ndjson` or `application/json-seq`.
 */
 function isJsonLines(entry) {
 	const baseType = baseContentType(entry.contentType);
-	return Boolean(entry.stream) && baseType !== "text/event-stream" && !baseType.startsWith("multipart/");
+	return Boolean(entry.stream) && baseType !== "text/event-stream" && isStreamContentType(baseType);
 }
 /**
 * How an operation streams its primary success response item by item, when that response declares one content type:
@@ -160,6 +341,25 @@ function getEventStream(node) {
 function isEventStream(node) {
 	return getEventStream(node) !== null;
 }
+const streamContentTypes = /* @__PURE__ */ new Set([
+	"text/event-stream",
+	"application/jsonl",
+	"application/x-ndjson",
+	"application/json-seq"
+]);
+function isStreamContentType(baseType) {
+	return streamContentTypes.has(baseType) || baseType.startsWith("application/") && baseType.endsWith("+json-seq");
+}
+/**
+* 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 getSuccessResponses(node.responses).some((response) => {
+		const variants = (response.content ?? []).filter((entry) => entry.schema);
+		return variants.length > 1 && variants.some((entry) => isStreamContentType(baseContentType(entry.contentType)));
+	});
+}
 /**
 * Builds the `client?:` option type shared by the generated query hooks (`useQuery`,
 * `useInfiniteQuery`, `useSWR`, ...): `RequestConfig` minus what the
@@ -235,7 +435,8 @@ function buildOperationComments(node, options = {}) {
 		getOperationRequestLine(node),
 		node.description && `@description ${node.description}`,
 		node.summary && `@summary ${node.summary}`,
-		node.deprecated && "@deprecated"
+		node.deprecated && "@deprecated",
+		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));
@@ -243,19 +444,25 @@ function buildOperationComments(node, options = {}) {
 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.
+* per property, typed and serialized like any other, with the `style` and `explode` its `encoding` entry declares.
 * 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";
+	const formEncoded = !param.contentType || baseContentType(param.contentType) === "application/x-www-form-urlencoded";
 	if (schema?.type !== "object" || !formEncoded) return [param];
-	return schema.properties.map((property) => _kubb_kit.ast.factory.createParameter({
-		name: property.name,
-		in: "query",
-		schema: property.schema,
-		required: param.required && property.required
-	}));
+	return schema.properties.map((property) => {
+		const { style, explode, allowReserved } = param.encoding?.[property.name] ?? {};
+		return _kubb_kit.ast.factory.createParameter({
+			name: property.name,
+			in: "query",
+			schema: property.schema,
+			required: param.required && property.required,
+			...style !== void 0 && { style },
+			...explode !== void 0 && { explode },
+			...allowReserved !== void 0 && { allowReserved }
+		});
+	});
 }
 /**
 * Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
@@ -294,13 +501,28 @@ function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
 	return Number.isNaN(code) ? null : code;
 }
-function isSuccessStatusCode(statusCode) {
+const statusClassByRange = /* @__PURE__ */ new Map([
+	["1xx", 1],
+	["2xx", 2],
+	["3xx", 3],
+	["4xx", 4],
+	["5xx", 5]
+]);
+/**
+* The class digit of a status code or range, such as `2` for `201` and `2xx`, or `null` for `default`.
+*/
+function getStatusClass(statusCode) {
+	const rangeClass = statusClassByRange.get(String(statusCode));
+	if (rangeClass) return rangeClass;
 	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 200 && code < 300;
+	return code === null ? null : Math.floor(code / 100);
+}
+function isSuccessStatusCode(statusCode) {
+	return getStatusClass(statusCode) === 2;
 }
 function isErrorStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 400;
+	const statusClass = getStatusClass(statusCode);
+	return statusClass !== null && statusClass >= 4;
 }
 function getSuccessResponses(responses) {
 	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
@@ -309,7 +531,10 @@ function getOperationSuccessResponses(node) {
 	return getSuccessResponses(node.responses);
 }
 function getPrimarySuccessResponse(node) {
-	return getOperationSuccessResponses(node)[0] ?? null;
+	const responses = getOperationSuccessResponses(node);
+	const withBody = responses.filter((response) => response.content?.length);
+	const candidates = withBody.length ? withBody : responses;
+	return candidates.find((response) => getStatusCodeNumber(response.statusCode) !== null) ?? candidates[0] ?? null;
 }
 function resolveErrorNames(node, resolver) {
 	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
@@ -348,172 +573,6 @@ 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"
-]);
-/**
-* 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("']?.['")}']`}`;
-}
 // ../../internals/shared/src/resolver.ts
 /**
 * The shared top-level `name` of the operation plugins, computed once per operation name and build.
@@ -526,6 +585,9 @@ function resolveOperationName(name) {
 * 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.
 *
+* 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
 * resolver.resolveName({ key: operationKey(node, 'response', 'status', 404), name })
@@ -534,8 +596,7 @@ function resolveOperationName(name) {
 function operationKey(node, ...scope) {
 	return [
 		"operation",
-		node.method,
-		node.path,
+		...node.pointer ? [node.pointer] : [node.method, node.path],
 		...scope.map(String)
 	];
 }
@@ -545,7 +606,8 @@ function operationKey(node, ...scope) {
 * 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`).
+* - `tag` groups get no name here, so Kubb names them itself: the camelCased tag (`pet store` → `petStore`), nested in
+*   the folders of its OpenAPI 3.2 `parent` tags (`payment` with parent `store` → `store/payment`).
 *
 * 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
@@ -560,22 +622,19 @@ function operationKey(node, ...scope) {
 */
 function createGroupConfig(group) {
 	if (!group) return null;
-	const defaultName = (ctx) => {
-		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return (0, _kubb_kit.camelCase)(ctx.group);
-	};
+	if (group.name || group.type !== "path") return group;
 	return {
 		...group,
-		name: group.name ? group.name : defaultName
+		name: (ctx) => `${ctx.group.split("/")[1]}`
 	};
 }
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.16.0",
+	"kubb": ">=5.18.4",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.11.0-canary.20261111T120000";
+var version = "5.11.0-canary.20261111T193820";
 // ../../internals/client/src/resolveClient.ts
 /**
 * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
@@ -745,12 +804,53 @@ function resolveClientOperation(options) {
 				operationFile: file.path
 			}),
 			clientPathIsFile: importPath === void 0 || isRelativeImport(importPath),
-			returnType: operationOptions.returnType ?? "full"
+			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)]);
+}
+/**
+* The headers type argument of `RequestResult`, such as `{ '200': LoginUserStatus200Headers }`, or `null` when no response declares headers.
+*/
+function buildResponseHeadersType({ node, types }) {
+	const entries = getResponseHeadersEntries({
+		node,
+		types
+	}).map(([statusCode, name]) => `'${statusCode}': ${name}`);
+	return entries.length ? `{ ${entries.join("; ")} }` : null;
+}
+/**
+* A runtime result type, such as `RequestResult`, in its `WithHeaders` form when `headers` is set.
+*/
+function resultTypeName(name, headers) {
+	return headers ? `${name}WithHeaders` : name;
+}
+/**
+* A runtime result type with its arguments, such as `RequestResultWithHeaders<Responses, Headers, ThrowOnError>`.
+*/
+function buildResultTypeRef(name, responses, headers, rest = []) {
+	return `${resultTypeName(name, headers !== null)}<${[
+		responses,
+		headers,
+		...rest
+	].filter(Boolean).join(", ")}>`;
+}
+/**
+* The names of the headers types `buildResponseHeadersType` references, for the file's imports.
+*/
+function getResponseHeadersTypeNames({ node, types }) {
+	return getResponseHeadersEntries({
+		node,
+		types
+	}).map(([, name]) => name);
+}
 /**
 * 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.
@@ -773,6 +873,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)
 		}
 	};
@@ -838,6 +939,10 @@ 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,
@@ -855,6 +960,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)),
@@ -872,6 +978,7 @@ function resolveHookFile(node, ctx, options) {
 		tsResolver,
 		contractOp,
 		importedTypeNames,
+		resultTypeName: headerTypeNames.length ? "RequestResultWithHeaders" : "RequestResult",
 		returnType,
 		banner: resolver.default.banner(ctx.meta, {
 			output,
@@ -889,7 +996,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__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
 		baseName: file.baseName,
 		path: file.path,
@@ -906,7 +1013,7 @@ function HookFile({ hook, imports, children }) {
 				name: [
 					"RequestConfig",
 					"ResponseErrorConfig",
-					"RequestResult"
+					resultTypeName
 				],
 				root: contractOp.clientPathIsFile ? file.path : void 0,
 				path: contractOp.clientPath,
@@ -1051,19 +1158,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"}>`
 		};
 	});
@@ -1299,8 +1415,11 @@ function buildResolvedRequestParams(node) {
 // ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$6 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$3 = (0, _kubb_plugin_ts.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,
@@ -1801,8 +1920,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"];
@@ -1862,8 +1984,11 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 // src/components/QueryOptions.tsx
 const declarationPrinter$2 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$2 = (0, _kubb_plugin_ts.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 });
@@ -2009,7 +2134,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__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 						name: ["queryOptions"],
@@ -2021,7 +2147,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__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
 						/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -2046,6 +2173,7 @@ function createQueryGenerator({ name, variant }) {
 							tsResolver: hook.tsResolver,
 							customOptions,
 							returnType: hook.returnType,
+							typedHeaders: hook.contractOp.typedHeaders,
 							suspense,
 							infinite: infiniteOptions ? {
 								initialPageParam: infiniteOptions.initialPageParam,
@@ -2080,8 +2208,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, {
@@ -2125,8 +2256,11 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter = (0, _kubb_plugin_ts.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,
@@ -2141,8 +2275,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,
@@ -2154,7 +2291,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__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
@@ -2249,7 +2387,8 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 					node,
 					tsResolver,
 					clientReturnType: contractOp.returnType,
-					returnType: hook.returnType
+					returnType: hook.returnType,
+					typedHeaders: hook.contractOp.typedHeaders
 				}),
 				mutation && hooks && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
 					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -2272,7 +2411,8 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 						node,
 						tsResolver,
 						customOptions,
-						returnType: hook.returnType
+						returnType: hook.returnType,
+						typedHeaders: hook.contractOp.typedHeaders
 					})
 				] })
 			]