@kubb/plugin-client 5.10.0-canary.20261105T164114 → 5.10.0

package/dist/index.js

@@ -1,9 +1,9 @@
-import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, macroSimplifyUnion, pascalCase, setMacros, setResolver } from "@kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, macroDedupeUnion, pascalCase, setMacros, setResolver } from "@kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
-import { jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 // ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -84,20 +84,33 @@ function getPrimarySuccessContentType(node) {
 	return contentTypes[0].split(";")[0].trim().toLowerCase();
 }
 /**
-* Whether an operation streams its primary success response as Server-Sent Events
-* (`text/event-stream`). The client generator uses this to return a typed event stream instead of a
-* one-shot `RequestResult`.
+* The `text/event-stream` content of the primary success response, when it is the only content type. A response that also
+* declares another type stays a normal call with its query hooks.
+*/
+function getEventStreamContent(node) {
+	return getPrimarySuccessContentType(node) === "text/event-stream" ? getPrimarySuccessResponse(node)?.content?.[0] : void 0;
+}
+/**
+* Whether an operation streams its primary success response as Server-Sent Events (`text/event-stream`). The client
+* generator uses this to return a typed event stream instead of a one-shot `RequestResult`.
 */
 function isEventStream(node) {
-	return getPrimarySuccessContentType(node) === "text/event-stream";
+	return getEventStreamContent(node) !== void 0;
+}
+/**
+* How the document types a `text/event-stream` response, as the adapter read it from `itemSchema`: `event` when each item is
+* the parsed event with its own `event` and `data`, `data` when it is only the payload. Returns `null` without an event stream.
+*/
+function getEventStream(node) {
+	const content = getEventStreamContent(node);
+	return content ? content.stream?.shape ?? "data" : null;
 }
 /**
 * Derives the default `responseType` for an operation from its primary success response.
 *
-* Returns a value only when that response declares a single non-JSON content type. `text/event-stream`
-* and other binary types (`application/octet-stream`, `application/pdf`, `image/*`, `audio/*`,
-* `video/*`) map to a stream or `'blob'`, and other `text/*` maps to `'text'`. Otherwise `undefined`,
-* leaving the runtime client's `Content-Type` auto-detection in charge.
+* Returns a value only when that response declares a single non-JSON content type. `text/event-stream` maps to
+* `'stream'`, `application/octet-stream`, `application/pdf`, `image/*`, `audio/*` and `video/*` map to `'blob'`, and
+* other `text/*` to `'text'`. Otherwise `undefined`, leaving the runtime client's `Content-Type` auto-detection in charge.
 */
 function getResponseType(node) {
 	const baseType = getPrimarySuccessContentType(node);
@@ -157,6 +170,22 @@ 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.
+* 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
@@ -165,17 +194,18 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
-	const group = (location) => {
+	const dedupe = (params) => {
 		const seen = /* @__PURE__ */ new Set();
-		return node.parameters.filter((param) => {
-			if (param.in !== location || seen.has(param.name)) return false;
+		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: group("query"),
+		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
 		header: group("header"),
 		cookie: group("cookie")
 	};
@@ -405,11 +435,11 @@ function createGroupConfig(group) {
 }
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.14.6",
+	"kubb": ">=5.16.0",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.10.0-canary.20261105T164114";
+var version = "5.10.0";
 // ../../internals/client/src/builders/validatorOptions.ts
 /**
 * Returns `true` when any direction of the validator uses zod (used for dependency checks).
@@ -453,6 +483,114 @@ function buildZodErrorParse(node, zodResolver) {
 	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
 	return zodResolver.response.error?.(node) || null;
 }
+// ../../internals/client/src/builders/generics.ts
+/**
+* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
+* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
+* runtime, so this only names the record and threads `ThrowOnError`.
+*
+* @example
+* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
+*/
+function buildRequestResultGenerics({ node, types }) {
+	return `${types.response.responses(node)}, ThrowOnError`;
+}
+/**
+* Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
+* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, a plain
+* `Promise<RequestResult>` for the internal `'plain'` shape, or a
+* `Promise` of the runtime's `UnwrappedResult` when `returnType: 'data'` narrows a resolved call
+* down to the bare success body.
+*
+* @example
+* `buildResultType({ node, types, returnType: 'data' }) // 'Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>'`
+*/
+function buildResultType({ node, types, returnType }) {
+	const generics = buildRequestResultGenerics({
+		node,
+		types
+	});
+	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
+	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
+	return `Unwrappable<RequestResult<${generics}>>`;
+}
+// ../../internals/client/src/builders/returnStatement.ts
+/**
+* Builds the return statement of a generated operation function. With the default
+* `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
+* The generated code casts that result to the operation's `RequestResult`, then wraps it with
+* `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
+* body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
+* which narrows the resolved value down to the bare success body the same way `RequestResult`
+* already does, using the plugin default when the call leaves `throwOnError` unset.
+* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
+*
+* Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
+* as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
+* straight to `Unwrappable<B>` does not work: the `.then` overload stays pinned to `A`, and `as`
+* rejects that two-generic swap even where `A` and `B` on their own would satisfy it.
+*
+* @example
+* `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
+* @example
+* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
+* @example
+* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
+*/
+function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
+	const request = returnType !== "plain" && hasRequestContentTypeChoice(node) ? `request<${types.response.options(node)}['body']>` : "request";
+	if (returnType === "data") return `return unwrapResult(${request}(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
+		node,
+		types,
+		returnType
+	})}`;
+	if (returnType === "plain") return `return ${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		types
+	})}>>`;
+	return `return withUnwrap(${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		types
+	})}>>)`;
+}
+/**
+* Builds the return type and statement of a `text/event-stream` operation. The item type is `TypedEvent<...>` when each item
+* declares its own `event` and `data`, and otherwise the payload type, which `EventStreamResult` wraps in `ServerSentEvent`. The call's
+* promise goes through `toEventStream` with the `client` for its defaults, the call's `config`, the shape and the per-event
+* validator. A `returnType: 'plain'` client receives only the promise,
+* `toEventStream(request(config))`, and keeps its response validator in the call config.
+*/
+function buildEventStreamReturn({ node, types, callConfig, returnType, validatorHooks, throwOnErrorDefault }) {
+	const shape = getEventStream(node) ?? "data";
+	const responses = types.response.responses(node);
+	const success = `SuccessOf<${responses}>`;
+	const eventType = shape === "event" ? `TypedEvent<${success}>` : success;
+	if (returnType === "plain") return {
+		returnType: `Promise<EventStreamResult<${eventType}>>`,
+		statement: `return toEventStream<${eventType}>(request(${callConfig}))`
+	};
+	const generics = `${responses}, ThrowOnError${shape === "event" ? `, ${eventType}` : ""}`;
+	const call = `toEventStream<${eventType}>(request(${callConfig}), { client: request, config, ${[`shape: '${shape}'`, validatorHooks?.response ? `validator: ${validatorHooks.response}` : null].filter(Boolean).join(", ")} })`;
+	if (returnType === "data") {
+		const result = `Promise<UnwrappedStreamResult<${generics}>>`;
+		return {
+			returnType: result,
+			statement: `return unwrapResult(${call}, config.throwOnError ?? ${throwOnErrorDefault}) as ${result}`
+		};
+	}
+	return {
+		returnType: `Unwrappable<StreamResult<${generics}>>`,
+		statement: `return withUnwrap(${call} as Promise<StreamResult<${generics}>>)`
+	};
+}
+/** The stream types an operation file imports: `StreamResult` and `StreamOptions`, `EventStreamResult` for a plain client, and `TypedEvent` for named events. */
+function buildEventStreamImports({ returnType, typed }) {
+	return [...{
+		plain: ["EventStreamResult"],
+		full: ["StreamResult", "StreamOptions"],
+		data: ["UnwrappedStreamResult", "StreamOptions"]
+	}[returnType], ...typed ? ["TypedEvent"] : []];
+}
 // ../../internals/client/src/builders/security.ts
 function serializeAuth(auth) {
 	const parts = [`type: '${auth.type}'`];
@@ -608,6 +746,7 @@ function serializeParameter(parameter) {
 	if (parameter.explode !== void 0) parts.push(`explode: ${parameter.explode}`);
 	if (parameter.in === "query" && parameter.allowReserved !== void 0) parts.push(`allowReserved: ${parameter.allowReserved}`);
 	if (parameter.in !== "path" && parameter.contentType) parts.push(`contentType: '${parameter.contentType}'`);
+	if (parameter.in === "querystring") parts.push("querystring: true");
 	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
 }
 /**
@@ -650,10 +789,9 @@ function buildStyles({ node }) {
 		header: [],
 		cookie: []
 	};
-	for (const parameter of node.parameters) {
+	for (const [location, parameters] of Object.entries(getOperationParameters(node))) for (const parameter of parameters) {
 		const literal = serializeParameter(parameter);
-		if (!literal) continue;
-		groups[parameter.in].push(`${toKey(parameter.name)}: ${literal}`);
+		if (literal) groups[location].push(`${toKey(parameter.name)}: ${literal}`);
 	}
 	const entries = [...Object.keys(groups).filter((location) => groups[location].length > 0).map((location) => `${location}: { ${groups[location].join(", ")} }`), serializeBodyEncoding(node)].filter(Boolean);
 	return entries.length > 0 ? `{ ${entries.join(", ")} }` : null;
@@ -664,12 +802,20 @@ function buildStyles({ node }) {
 * functions and the SDK methods. The `throwOnError` fallback is applied after the `...config` spread.
 *
 * `mergeContentType` is `true` when the caller must destructure `contentType` from `options`, and
-* `eventStream` is `true` when the operation returns `text/event-stream`.
+* `eventStream` is `true` when the operation returns `text/event-stream`. Unless `returnType` is `'plain'`, a
+* stream's literal leaves the `response` validator to `toEventStream`, which runs it per event.
 */
-function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault }) {
+function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault, returnType }) {
+	const eventStream = isEventStream(node);
 	const securityLiteral = buildSecurityMetadata({ security });
 	const stylesLiteral = buildStyles({ node });
-	const validatorLiteral = buildValidatorLiteral(validatorHooks, [
+	const validatorLiteral = buildValidatorLiteral(validatorHooks, eventStream && returnType !== "plain" ? [
+		"request",
+		"path",
+		"query",
+		"headers",
+		"error"
+	] : [
 		"request",
 		"path",
 		"query",
@@ -692,90 +838,7 @@ function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault }
 			`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
 		].filter(Boolean).join(", ")} }`,
 		mergeContentType,
-		eventStream: isEventStream(node)
-	};
-}
-// ../../internals/client/src/builders/generics.ts
-/**
-* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
-* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
-* runtime, so this only names the record and threads `ThrowOnError`.
-*
-* @example
-* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
-*/
-function buildRequestResultGenerics({ node, types }) {
-	return `${types.response.responses(node)}, ThrowOnError`;
-}
-/**
-* Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
-* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, a plain
-* `Promise<RequestResult>` for the internal `'plain'` shape, or a
-* `Promise` of the runtime's `UnwrappedResult` when `returnType: 'data'` narrows a resolved call
-* down to the bare success body.
-*
-* @example
-* `buildResultType({ node, types, returnType: 'data' }) // 'Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>'`
-*/
-function buildResultType({ node, types, returnType }) {
-	const generics = buildRequestResultGenerics({
-		node,
-		types
-	});
-	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
-	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
-	return `Unwrappable<RequestResult<${generics}>>`;
-}
-// ../../internals/client/src/builders/returnStatement.ts
-/**
-* Builds the return statement of a generated operation function. With the default
-* `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
-* The generated code casts that result to the operation's `RequestResult`, then wraps it with
-* `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
-* body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
-* which narrows the resolved value down to the bare success body the same way `RequestResult`
-* already does, using the plugin default when the call leaves `throwOnError` unset.
-* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
-*
-* Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
-* as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
-* straight to `Unwrappable<B>` does not work: the `.then` overload stays pinned to `A`, and `as`
-* rejects that two-generic swap even where `A` and `B` on their own would satisfy it.
-*
-* @example
-* `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
-* @example
-* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
-* @example
-* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
-*/
-function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
-	const request = returnType !== "plain" && hasRequestContentTypeChoice(node) ? `request<${types.response.options(node)}['body']>` : "request";
-	if (returnType === "data") return `return unwrapResult(${request}(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
-		node,
-		types,
-		returnType
-	})}`;
-	if (returnType === "plain") return `return ${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		types
-	})}>>`;
-	return `return withUnwrap(${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		types
-	})}>>)`;
-}
-/**
-* Builds the return type and statement of an operation that returns `text/event-stream`: the call
-* is wrapped in `toEventStream`, so the caller iterates the typed success events. Except with
-* `returnType: 'plain'`, `toEventStream` also receives `config`, so a per-call `maxEventSize` reaches the parser.
-*/
-function buildEventStreamReturn({ node, types, callConfig, returnType }) {
-	const eventType = `SuccessOf<${types.response.responses(node)}>`;
-	const args = returnType === "plain" ? `request(${callConfig})` : `request(${callConfig}), config`;
-	return {
-		returnType: `Promise<EventStreamResult<${eventType}>>`,
-		statement: `return toEventStream<${eventType}>(${args})`
+		eventStream
 	};
 }
 // ../../internals/client/src/builders/signature.ts
@@ -789,13 +852,14 @@ const declarationPrinter = functionPrinter({ mode: "declaration" });
 * per-operation input type has to be emitted. Both names come from `types`, which is `plugin-ts` or
 * `plugin-zod`'s inferred types (see `resolveOperationTypes`).
 */
-function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDefault }) {
+function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDefault, eventStream = false }) {
 	const optionsName = types.response.options(node);
+	const optionsType = `${eventStream && returnType !== "plain" ? "StreamOptions" : "Options"}<${optionsName}, ThrowOnError>`;
 	const { isOptional } = getRequestGroupOptionality(node);
 	return {
 		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
 			name: "options",
-			type: `Options<${optionsName}, ThrowOnError>`,
+			type: optionsType,
 			...isOptional ? { default: "{}" } : {}
 		})] })) ?? "",
 		returnType: buildResultType({
@@ -806,38 +870,63 @@ function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDef
 		generics: [`ThrowOnError extends boolean = ${throwOnErrorDefault}`]
 	};
 }
-// ../../internals/client/src/components/Operation.tsx
+// ../../internals/client/src/builders/operationBody.ts
 /**
-* Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
-* single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
-* type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
-* the source.
+* The pieces of a generated operation: its generics, `options` parameter, return type, return statement, and whether the
+* body destructures `contentType` from `options`. Shared by the standalone functions and the SDK methods, so a
+* `text/event-stream` operation is wired to `toEventStream` in one place.
 */
-function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security }) {
-	if (!ast.isHttpOperationNode(node)) return null;
-	const signature = buildGroupedOptionsSignature({
-		node,
-		types,
-		returnType,
-		throwOnErrorDefault
-	});
+function buildOperationBody({ node, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
 	const { callConfig, mergeContentType, eventStream } = buildCallConfig({
 		node,
 		validatorHooks,
 		security,
-		throwOnErrorDefault
+		throwOnErrorDefault,
+		returnType
 	});
-	const eventStreamReturn = eventStream ? buildEventStreamReturn({
+	const signature = buildGroupedOptionsSignature({
+		node,
+		types,
+		returnType,
+		throwOnErrorDefault,
+		eventStream
+	});
+	const stream = eventStream ? buildEventStreamReturn({
 		node,
 		types,
 		callConfig,
-		returnType
+		returnType,
+		validatorHooks,
+		throwOnErrorDefault
 	}) : null;
-	const functionReturnType = eventStreamReturn?.returnType ?? signature.returnType;
-	const returnStatement = eventStreamReturn?.statement ?? buildReturnStatement({
+	return {
+		generics: signature.generics,
+		paramsSignature: signature.paramsSignature,
+		returnType: stream?.returnType ?? signature.returnType,
+		statement: stream?.statement ?? buildReturnStatement({
+			node,
+			types,
+			callConfig,
+			returnType,
+			throwOnErrorDefault
+		}),
+		mergeContentType
+	};
+}
+// ../../internals/client/src/components/Operation.tsx
+/**
+* Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
+* single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
+* type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
+* the source.
+*/
+function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const body = buildOperationBody({
 		node,
 		types,
-		callConfig,
+		validatorHooks,
+		security,
 		returnType,
 		throwOnErrorDefault
 	});
@@ -848,22 +937,53 @@ function Operation({ name, node, types, validatorHooks, returnType, throwOnError
 		children: /* @__PURE__ */ jsxs(Function, {
 			name,
 			export: true,
-			generics: signature.generics,
-			params: signature.paramsSignature,
-			returnType: functionReturnType,
+			generics: body.generics,
+			params: body.paramsSignature,
+			returnType: body.returnType,
 			JSDoc: { comments: buildOperationComments(node, {
 				link: "urlPath",
 				linkPosition: "beforeDeprecated",
 				splitLines: true
 			}) },
 			children: [
-				mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
+				body.mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
 				/* @__PURE__ */ jsx("br", {}),
-				returnStatement
+				body.statement
 			]
 		})
 	});
 }
+// ../../internals/client/src/components/StreamRuntime.tsx
+/**
+* The `footer` of `.kubb/client.ts`: the `baseURL` set at generation time, and the `sse.ts` re-export when the document
+* streams events, so `ServerSentEvent` and `toEventStream` stay importable from the client as in earlier releases.
+*/
+function buildClientFooter({ baseURL, sse }) {
+	const baseURLExpression = baseURL ? baseURL.includes("${") ? `\`${baseURL.replaceAll("`", "\\`")}\`` : JSON.stringify(baseURL) : void 0;
+	return [baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : null, sse ? `export * from './sse.ts'` : null].filter(Boolean).join("\n") || void 0;
+}
+/**
+* Writes the footer of the `.kubb/client.ts` the plugin injected, the one place it is built, and copies `sse.ts` into
+* `.kubb/` only for a document with a `text/event-stream` operation, so a document without streams ships no stream runtime.
+* `sse` is set by the plugins that ship the runtime, so a custom client from `@kubb/plugin-client` gets neither file.
+*/
+function StreamRuntime({ nodes, root, sse, baseURL }) {
+	if (!sse) return null;
+	const streams = nodes.some(isEventStream);
+	const footer = buildClientFooter({
+		baseURL,
+		sse: streams
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [streams && /* @__PURE__ */ jsx(File, {
+		baseName: "sse.ts",
+		path: path.resolve(root, ".kubb/sse.ts"),
+		copy: sse
+	}), footer && /* @__PURE__ */ jsx(File, {
+		baseName: "client.ts",
+		path: path.resolve(root, ".kubb/client.ts"),
+		footer
+	})] });
+}
 // ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
@@ -939,13 +1059,24 @@ function resolveOperationTypes(driver, pluginName) {
 * `@kubb/plugin-axios`). Emits one async function per OpenAPI operation using the shared
 * `Operation` component: a grouped `<Name>Request` type and a function that forwards a single
 * `options` object to the bundled `client` and returns the `Unwrappable<RequestResult>`. Only the
-* generator `name` differs between plugins. Every other resolution, import, and rendering step is
-* identical.
+* generator `name` and the runtime templates differ between plugins. Every other resolution, import,
+* and rendering step is identical.
+*
+* `sse` is the Server-Sent Events runtime template, copied into `.kubb/sse.ts` only for a document with a
+* `text/event-stream` operation.
 */
-function createClientGenerator(name) {
+function createClientGenerator(name, { sse } = {}) {
 	return defineGenerator({
 		name,
 		renderer: jsxRenderer,
+		operations(nodes, ctx) {
+			return /* @__PURE__ */ jsx(StreamRuntime, {
+				nodes,
+				root: ctx.root,
+				sse,
+				baseURL: ctx.options.baseURL
+			});
+		},
 		operation(node, ctx) {
 			if (!ast.isHttpOperationNode(node)) return null;
 			const { config, driver, resolver, root } = ctx;
@@ -995,19 +1126,19 @@ function createClientGenerator(name) {
 			const clientPath = importPath ?? path.resolve(root, ".kubb/client.ts");
 			const clientRoot = importPath === void 0 ? meta.file.path : void 0;
 			const standardSchemaPath = importPath ?? path.resolve(root, ".kubb/standardSchema.ts");
-			const eventStream = isEventStream(node);
+			const ssePath = importPath ?? path.resolve(root, ".kubb/sse.ts");
+			const stream = getEventStream(node);
 			const clientValueImports = (() => {
-				if (eventStream) return ["client", "toEventStream"];
 				if (returnType === "plain") return ["client"];
 				if (returnType === "data") return ["client", "unwrapResult"];
 				return ["client", "withUnwrap"];
 			})();
 			const clientTypeImports = (() => {
-				if (eventStream) return [
-					"Options",
-					"EventStreamResult",
-					"SuccessOf"
-				];
+				if (stream) return {
+					plain: ["Options", "SuccessOf"],
+					data: ["SuccessOf"],
+					full: ["SuccessOf", "Unwrappable"]
+				}[returnType];
 				if (returnType === "plain") return ["Options", "RequestResult"];
 				if (returnType === "data") return ["Options", "UnwrappedResult"];
 				return [
@@ -1048,6 +1179,20 @@ function createClientGenerator(name) {
 						path: clientPath,
 						isTypeOnly: true
 					}),
+					stream && /* @__PURE__ */ jsx(File.Import, {
+						name: ["toEventStream"],
+						root: clientRoot,
+						path: ssePath
+					}),
+					stream && /* @__PURE__ */ jsx(File.Import, {
+						name: buildEventStreamImports({
+							returnType,
+							typed: stream === "event"
+						}),
+						root: clientRoot,
+						path: ssePath,
+						isTypeOnly: true
+					}),
 					meta.fileTypes && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
 						name: Array.from(new Set(importedTypeNames)),
 						root: meta.file.path,
@@ -1080,11 +1225,11 @@ function createClientGenerator(name) {
 }
 // ../../internals/client/src/macros.ts
 /**
-* Macros the client plugins apply by default, ahead of any user macros. `macroSimplifyUnion`
-* drops union members a broader scalar already covers, keeping the generated response and error
+* Macros the client plugins apply by default, ahead of any user macros. `macroDedupeUnion`
+* drops repeated union members, keeping the generated response and error
 * unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
 */
-const defaultMacros = [macroSimplifyUnion];
+const defaultMacros = [macroDedupeUnion];
 // ../../internals/client/src/resolver.ts
 /**
 * Default resolver shared by the client plugins. Functions use safe camelCase identifiers and