@kubb/plugin-fetch 5.0.0-beta.77 → 5.0.0-beta.80

package/dist/index.js

@@ -77,7 +77,7 @@ function toFilePath(name, caseLast = camelCase) {
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
 */
-const reservedWords = new Set([
+const reservedWords = /* @__PURE__ */ new Set([
 	"abstract",
 	"arguments",
 	"boolean",
@@ -326,6 +326,23 @@ function caseParams(params, casing) {
 	caseParamsCache.set(params, result);
 	return result;
 }
+/**
+* Drops parameters that collapse to the same property identity once camelCased, keeping the first.
+*
+* Some specs declare the same parameter twice under different casings (for example AWS S3 lists both
+* `max-uploads` and `MaxUploads`). Both resolve to one output property, so emitting both would yield
+* an object type with a duplicate member, which TypeScript rejects. De-duplicate by the camelCased
+* identity so the resulting group is collision-free regardless of the names each caller carries.
+*/
+function dedupeByCasedName(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		const key = camelCase(param.name);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
 //#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
@@ -364,6 +381,86 @@ function getContentTypeInfo(node) {
 		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
 	};
 }
+/**
+* The request-body counterpart for the primary success response: the content types it documents and
+* whether several are present, so the client can let a caller pick which one to accept.
+*/
+function getResponseContentTypeInfo(node) {
+	const contentTypes = getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? [];
+	const isMultipleContentTypes = contentTypes.length > 1;
+	return {
+		contentTypes,
+		isMultipleContentTypes,
+		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
+		defaultContentType: contentTypes[0] ?? "application/json",
+		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
+	};
+}
+/**
+* Reads the single base content type of an operation's primary success response, lowercased and
+* stripped of any `; charset=...` suffix. Returns `undefined` when the response declares zero or
+* more than one content type, since neither case has a single type to act on.
+*/
+function getPrimarySuccessContentType(node) {
+	const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? [];
+	if (contentTypes.length !== 1) return void 0;
+	return contentTypes[0].split(";")[0].trim().toLowerCase();
+}
+/**
+* Whether an operation streams its primary success response as Server-Sent Events
+* (`text/event-stream`). The client generator uses this to return a typed event stream instead of a
+* one-shot `RequestResult`.
+*/
+function isEventStream(node) {
+	return getPrimarySuccessContentType(node) === "text/event-stream";
+}
+/**
+* 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.
+*/
+function getResponseType(node) {
+	const baseType = getPrimarySuccessContentType(node);
+	if (!baseType) return void 0;
+	if (baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json") return void 0;
+	if (baseType === "text/event-stream") return "stream";
+	if (baseType.startsWith("text/")) return "text";
+	if (baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType)) return "blob";
+}
+/**
+* Which of the grouped request options an operation carries.
+*/
+function getRequestGroups(node) {
+	const { path, query, header } = getOperationParameters(node);
+	return {
+		path: path.length > 0,
+		query: query.length > 0,
+		body: Boolean(node.requestBody?.content?.[0]?.schema),
+		headers: header.length > 0
+	};
+}
+/**
+* Resolves which grouped request options an operation carries together with whether each group
+* holds a required member. The grouped parameter stays optional only when nothing inside it is
+* required, matching the generated `RequestConfig` type.
+*/
+function getRequestGroupOptionality(node) {
+	const groups = getRequestGroups(node);
+	const { path, query, header } = getOperationParameters(node);
+	const hasRequiredPath = path.some((param) => param.required);
+	const hasRequiredQuery = query.some((param) => param.required);
+	const hasRequiredHeader = header.some((param) => param.required);
+	return {
+		groups,
+		hasRequiredPath,
+		hasRequiredQuery,
+		hasRequiredHeader,
+		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !groups.body
+	};
+}
 function buildOperationComments(node, options = {}) {
 	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
 	const linkComment = getOperationLink(node, link);
@@ -384,10 +481,10 @@ function buildOperationComments(node, options = {}) {
 function getOperationParameters(node, options = {}) {
 	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
 	return {
-		path: params.filter((param) => param.in === "path"),
-		query: params.filter((param) => param.in === "query"),
-		header: params.filter((param) => param.in === "header"),
-		cookie: params.filter((param) => param.in === "cookie")
+		path: dedupeByCasedName(params.filter((param) => param.in === "path")),
+		query: dedupeByCasedName(params.filter((param) => param.in === "query")),
+		header: dedupeByCasedName(params.filter((param) => param.in === "header")),
+		cookie: dedupeByCasedName(params.filter((param) => param.in === "cookie"))
 	};
 }
 function getStatusCodeNumber(statusCode) {
@@ -398,6 +495,15 @@ function isSuccessStatusCode(statusCode) {
 	const code = getStatusCodeNumber(statusCode);
 	return code !== null && code >= 200 && code < 300;
 }
+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;
+}
 //#endregion
 //#region ../../internals/shared/src/group.ts
 /**
@@ -430,39 +536,39 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
-//#region ../../internals/client/src/builders/parser.ts
+//#region ../../internals/client/src/builders/validatorOptions.ts
 /**
-* Returns `true` when any direction of the parser uses zod (used for dependency checks).
+* Returns `true` when any direction of the validator uses zod (used for dependency checks).
 */
-function isParserEnabled(parser) {
-	if (!parser) return false;
-	if (parser === "zod") return true;
-	return Boolean(parser.request || parser.response);
+function isValidatorEnabled(validator) {
+	if (!validator) return false;
+	if (validator === "zod") return true;
+	return Boolean(validator.request || validator.response);
 }
 /**
 * Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
 * `'zod'` validates the response only, so it does not enable request parsing.
 */
-function resolveRequestParser(parser) {
-	if (!parser || parser === "zod") return null;
-	return parser.request ?? null;
+function resolveRequestValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? null;
 }
 /**
 * Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise. Only the object form
 * `{ request: 'zod' }` enables it.
 */
-function resolveQueryParamsParser(parser) {
-	if (!parser || parser === "zod") return null;
-	return parser.request ?? null;
+function resolveQueryParamsValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? null;
 }
 /**
 * Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
 * maps to response parsing.
 */
-function resolveResponseParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.response ?? null;
+function resolveResponseValidator(validator) {
+	if (!validator) return null;
+	if (validator === "zod") return "zod";
+	return validator.response ?? null;
 }
 /**
 * Resolves the zod expression a generated client validates a success response with. Only success
@@ -604,11 +710,13 @@ function buildGroupedOptionsSignature({ node, tsResolver }) {
 		node,
 		tsResolver
 	});
+	const { isOptional } = getRequestGroupOptionality(node);
 	return {
 		dataTypeName: requestConfigName,
 		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
 			name: "options",
-			type: `Options<${requestConfigName}, ThrowOnError>`
+			type: `Options<${requestConfigName}, ThrowOnError>`,
+			...isOptional ? { default: "{}" } : {}
 		})] })) ?? "",
 		returnType: `Promise<RequestResult<${resultGenerics}>>`,
 		generics: ["ThrowOnError extends boolean = true"],
@@ -616,23 +724,74 @@ function buildGroupedOptionsSignature({ node, tsResolver }) {
 	};
 }
 //#endregion
+//#region ../../internals/client/src/builders/styles.ts
+/**
+* Renders a parameter name as an object-literal key, quoting it when the camelCased name is not a
+* bare identifier (for example a name that starts with a digit) so the emitted literal stays valid.
+*/
+function toKey(name) {
+	const cased = camelCase(name);
+	return isValidVarName(cased) ? cased : JSON.stringify(cased);
+}
+/**
+* Serializes one parameter's metadata into a `{ style, explode }` literal, or `null` when the
+* parameter carries neither. Path and query carry the serialization `style`; header and cookie use a
+* fixed style (`simple` and `form`), so only `explode` is emitted for them.
+*/
+function serializeParameter(parameter) {
+	const parts = [];
+	if ((parameter.in === "path" || parameter.in === "query") && parameter.style) parts.push(`style: '${parameter.style}'`);
+	if (parameter.explode !== void 0) parts.push(`explode: ${parameter.explode}`);
+	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
+}
+/**
+* Builds the per-operation `styles` literal from the operation's parameters, grouped by location and
+* keyed by the camelCased parameter name to match the generated `path` / `query` / `headers` keys.
+* Only parameters whose source defines `style` or `explode` are emitted, so calls without
+* serialization metadata keep the runtime defaults and existing output is unchanged. Returns `null`
+* when no parameter carries metadata.
+*
+* @example
+* ```ts
+* // a path param with { style: 'matrix', explode: true } and a query param with { explode: false }
+* buildStyles({ node }) // "{ path: { id: { style: 'matrix', explode: true } }, query: { tags: { explode: false } } }"
+* ```
+*/
+function buildStyles({ node }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const groups = {
+		path: [],
+		query: [],
+		header: [],
+		cookie: []
+	};
+	for (const parameter of node.parameters) {
+		const literal = serializeParameter(parameter);
+		if (!literal) continue;
+		groups[parameter.in].push(`${toKey(parameter.name)}: ${literal}`);
+	}
+	const locations = Object.keys(groups).filter((location) => groups[location].length > 0);
+	if (locations.length === 0) return null;
+	return `{ ${locations.map((location) => `${location}: { ${groups[location].join(", ")} }`).join(", ")} }`;
+}
+//#endregion
 //#region ../../internals/client/src/builders/validator.ts
 /**
-* Builds the parser-hook expressions for one operation. Request parsing runs before the send;
-* response parsing runs on the success body only. Returns `null` expressions when the matching
-* parser direction is disabled or the schema is absent.
+* Builds the validator-hook references for one operation. Request validation runs before the send;
+* response validation runs on the success body only. Returns `null` references when the matching
+* direction is disabled or the schema is absent.
 */
-function buildParserHooks({ node, parser, zodResolver }) {
+function buildValidatorHooks({ node, validator, zodResolver }) {
 	const importedZodNames = [];
 	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const zodRequestName = zodResolver && resolveRequestParser(parser) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null;
-	const request = zodRequestName ? `(data: unknown) => ${zodRequestName}.parse(data)` : null;
+	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null;
+	const request = zodRequestName ?? null;
 	if (zodRequestName) importedZodNames.push(zodRequestName);
-	const responseParse = zodResolver && resolveResponseParser(parser) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
-	const response = responseParse ? `(data: unknown) => ${responseParse.expression}.parse(data)` : null;
+	const responseParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
+	const response = responseParse ? responseParse.expression : null;
 	if (responseParse) importedZodNames.push(...responseParse.importNames);
-	const errorParse = zodResolver && resolveResponseParser(parser) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
-	const error = errorParse ? `(data: unknown) => ${errorParse.expression}.parse(data)` : null;
+	const errorParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
+	const error = errorParse ? errorParse.expression : null;
 	if (errorParse) importedZodNames.push(...errorParse.importNames);
 	return {
 		request,
@@ -648,34 +807,49 @@ function buildParserHooks({ node, parser, zodResolver }) {
 * single `options` object to the resolved client and returns the `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, tsResolver, zodResolver, parser, security, isExportable = true, isIndexable = true }) {
+function Operation({ name, node, tsResolver, zodResolver, validator, security, isExportable = true, isIndexable = true }) {
 	if (!ast.isHttpOperationNode(node)) return null;
 	const signature = buildGroupedOptionsSignature({
 		node,
 		tsResolver
 	});
-	const parsers = buildParserHooks({
+	const validators = buildValidatorHooks({
 		node,
-		parser,
+		validator,
 		zodResolver
 	});
 	const securityLiteral = buildSecurityMetadata({ security });
+	const stylesLiteral = buildStyles({ node });
 	const { defaultContentType } = getContentTypeInfo(node);
-	const contentTypeLiteral = Boolean(node.requestBody?.content?.[0]?.schema) && defaultContentType !== "application/json" ? `contentType: '${defaultContentType}'` : null;
-	const parserEntries = [
-		parsers.request ? `request: ${parsers.request}` : null,
-		parsers.response ? `response: ${parsers.response}` : null,
-		parsers.error ? `error: ${parsers.error}` : null
+	const bakedRequestContentType = Boolean(node.requestBody?.content?.[0]?.schema) && defaultContentType !== "application/json" ? defaultContentType : null;
+	const mergeContentType = Boolean(bakedRequestContentType) && getResponseContentTypeInfo(node).isMultipleContentTypes;
+	const contentTypeLiteral = !bakedRequestContentType ? null : mergeContentType ? `contentType: { request: '${bakedRequestContentType}', ...(typeof contentType === 'string' ? { request: contentType } : contentType) }` : `contentType: { request: '${bakedRequestContentType}' }`;
+	const eventStream = isEventStream(node);
+	const responseType = getResponseType(node);
+	const responseTypeLiteral = responseType ? `responseType: '${responseType}'` : null;
+	const validatorEntries = [
+		validators.request ? `request: ${validators.request}` : null,
+		validators.response ? `response: ${validators.response}` : null,
+		validators.error ? `error: ${validators.error}` : null
 	].filter(Boolean);
-	const parserLiteral = parserEntries.length ? `parser: { ${parserEntries.join(", ")} }` : null;
+	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
 	const callConfig = `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
 		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
-		parserLiteral,
+		stylesLiteral ? `styles: ${stylesLiteral}` : null,
+		validatorLiteral,
 		contentTypeLiteral,
+		responseTypeLiteral,
 		"...config"
 	].filter(Boolean).join(", ")} }`;
+	const eventType = `SuccessOf<${tsResolver.resolveResponsesName(node)}>`;
+	const returnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
+	const returnStatement = eventStream ? `return toEventStream<${eventType}>(request(${callConfig}))` : buildReturnStatement({
+		node,
+		tsResolver,
+		callConfig
+	});
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
 		isExportable,
@@ -685,20 +859,16 @@ function Operation({ name, node, tsResolver, zodResolver, parser, security, isEx
 			export: isExportable,
 			generics: signature.generics,
 			params: signature.paramsSignature,
-			returnType: signature.returnType,
+			returnType,
 			JSDoc: { comments: buildOperationComments(node, {
 				link: "urlPath",
 				linkPosition: "beforeDeprecated",
 				splitLines: true
 			}) },
 			children: [
-				"const { client: request = client, ...config } = options",
+				mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
 				/* @__PURE__ */ jsx("br", {}),
-				buildReturnStatement({
-					node,
-					tsResolver,
-					callConfig
-				})
+				returnStatement
 			]
 		})
 	});
@@ -707,23 +877,23 @@ function Operation({ name, node, tsResolver, zodResolver, parser, security, isEx
 //#region ../../internals/client/src/builders/sdkMethod.ts
 /**
 * Builds the call config literal forwarded to the contract client, mirroring the shared `Operation`
-* component: `{ method, url, security?, parser?, ...config }`. The `...config` spread carries every
+* component: `{ method, url, security?, validator?, ...config }`. The `...config` spread carries every
 * per-call field (including `throwOnError`), so the method stays a thin wrapper over the contract.
 */
-function buildCallConfig({ node, parser, zodResolver, security }) {
-	const parsers = buildParserHooks({
+function buildCallConfig({ node, validator, zodResolver, security }) {
+	const validators = buildValidatorHooks({
 		node,
-		parser,
+		validator,
 		zodResolver
 	});
-	const parserEntries = [parsers.request ? `request: ${parsers.request}` : null, parsers.response ? `response: ${parsers.response}` : null].filter(Boolean);
-	const parserLiteral = parserEntries.length ? `parser: { ${parserEntries.join(", ")} }` : null;
+	const validatorEntries = [validators.request ? `request: ${validators.request}` : null, validators.response ? `response: ${validators.response}` : null].filter(Boolean);
+	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
 	const securityLiteral = buildSecurityMetadata({ security });
 	return `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
 		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
-		parserLiteral,
+		validatorLiteral,
 		"...config"
 	].filter(Boolean).join(", ")} }`;
 }
@@ -733,7 +903,7 @@ function buildCallConfig({ node, parser, zodResolver, security }) {
 * returns the `RequestResult`. A per-call `options.client` still overrides the instance client, so
 * one operation can be routed to a different environment without a new instance.
 */
-function buildSdkMethod({ node, name, tsResolver, zodResolver, parser, security }) {
+function buildSdkMethod({ node, name, tsResolver, zodResolver, validator, security }) {
 	if (!ast.isHttpOperationNode(node)) return "";
 	const signature = buildGroupedOptionsSignature({
 		node,
@@ -744,7 +914,7 @@ function buildSdkMethod({ node, name, tsResolver, zodResolver, parser, security
 		tsResolver,
 		callConfig: buildCallConfig({
 			node,
-			parser,
+			validator,
 			zodResolver,
 			security
 		})
@@ -770,13 +940,13 @@ function buildSdkMethod({ node, name, tsResolver, zodResolver, parser, security
 * instance: `const api = new PetClient({ baseURL }); api.getPetById(...)`. A per-call `client` option
 * still overrides the instance client for a one-off call.
 */
-function SdkClient({ name, isExportable = true, isIndexable = true, operations, parser, children }) {
+function SdkClient({ name, isExportable = true, isIndexable = true, operations, validator, children }) {
 	const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver, security }) => buildSdkMethod({
 		node,
 		name: methodName,
 		tsResolver,
 		zodResolver,
-		parser,
+		validator,
 		security
 	}));
 	const classCode = `export class ${name} {\n${[
@@ -822,13 +992,13 @@ function SdkFacade({ name, isExportable = true, isIndexable = true, members, chi
 function resolveTypeImportNames(node, tsResolver) {
 	return [tsResolver.resolveRequestConfigName(node), tsResolver.resolveResponsesName(node)];
 }
-function resolveZodImportNames(node, zodResolver, parser) {
+function resolveZodImportNames(node, zodResolver, validator) {
 	const { query: queryParams } = getOperationParameters(node, { paramsCasing: "original" });
 	return [
-		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
-		resolveResponseParser(parser) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
-		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
+		resolveResponseValidator(validator) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+		resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
+		resolveRequestValidator(validator) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+		resolveQueryParamsValidator(validator) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
 	].filter((n) => Boolean(n));
 }
 /**
@@ -837,11 +1007,11 @@ function resolveZodImportNames(node, zodResolver, parser) {
 */
 function buildControllers(nodes, ctx) {
 	const { driver, resolver, root } = ctx;
-	const { output, group, parser } = ctx.options;
+	const { output, group, validator } = ctx.options;
 	const pluginTs = driver.getPlugin(pluginTsName);
 	const tsResolver = driver.getResolver(pluginTsName);
 	const tsPluginOptions = pluginTs.options;
-	const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
+	const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName) : null;
 	const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 	const document = ctx.adapter.document;
 	function buildOperationData(node) {
@@ -928,7 +1098,7 @@ function createSdkGenerator() {
 		renderer: jsxRenderer,
 		operations(nodes, ctx) {
 			const { config, resolver, root } = ctx;
-			const { output, group, parser, sdk } = ctx.options;
+			const { output, group, validator, sdk } = ctx.options;
 			if (!ctx.driver.getPlugin(pluginTsName) || !sdk) return null;
 			const controllers = buildControllers(nodes, ctx);
 			const clientPath = path.resolve(root, ".kubb/client.ts");
@@ -953,9 +1123,9 @@ function createSdkGenerator() {
 					file: op.typeFile,
 					names: resolveTypeImportNames(op.node, op.tsResolver)
 				}));
-				const { namesByPath: zodNamesByPath, filesByPath: zodFilesByPath } = isParserEnabled(parser) ? collectImportsByFile(ops, (op) => ({
+				const { namesByPath: zodNamesByPath, filesByPath: zodFilesByPath } = isValidatorEnabled(validator) ? collectImportsByFile(ops, (op) => ({
 					file: op.zodFile,
-					names: op.zodResolver ? resolveZodImportNames(op.node, op.zodResolver, parser) : []
+					names: op.zodResolver ? resolveZodImportNames(op.node, op.zodResolver, validator) : []
 				})) : {
 					namesByPath: /* @__PURE__ */ new Map(),
 					filesByPath: /* @__PURE__ */ new Map()
@@ -983,7 +1153,7 @@ function createSdkGenerator() {
 							path: clientPath,
 							isTypeOnly: true
 						}),
-						parser === "zod" && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
+						validator === "zod" && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
 							name: ["z"],
 							path: "zod",
 							isTypeOnly: true
@@ -994,7 +1164,7 @@ function createSdkGenerator() {
 							path: typeFilesByPath.get(filePath).path,
 							isTypeOnly: true
 						}, filePath)),
-						isParserEnabled(parser) && Array.from(zodNamesByPath.entries()).map(([filePath, set]) => /* @__PURE__ */ jsx(File.Import, {
+						isValidatorEnabled(validator) && Array.from(zodNamesByPath.entries()).map(([filePath, set]) => /* @__PURE__ */ jsx(File.Import, {
 							name: Array.from(set),
 							root: file.path,
 							path: zodFilesByPath.get(filePath).path
@@ -1002,7 +1172,7 @@ function createSdkGenerator() {
 						/* @__PURE__ */ jsx(SdkClient, {
 							name: className,
 							operations: ops,
-							parser
+							validator
 						})
 					]
 				}, file.path);
@@ -1113,18 +1283,18 @@ const clientGenerator = defineGenerator({
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { config, driver, resolver, root } = ctx;
-		const { output, parser, group } = ctx.options;
+		const { output, validator, group } = ctx.options;
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
-		const pluginZod = resolveResponseParser(parser) === "zod" || resolveRequestParser(parser) === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(pluginZodName) : null;
 		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 		const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
 		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), tsResolver.resolveResponsesName(node)];
 		const importedZodNames = zodResolver ? [
-			resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
-			resolveResponseParser(parser) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
-			resolveRequestParser(parser) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null
+			resolveResponseValidator(validator) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+			resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
+			resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null
 		].filter((name) => Boolean(name)) : [];
 		const meta = {
 			name: resolver.resolveName(node.operationId),
@@ -1150,6 +1320,7 @@ const clientGenerator = defineGenerator({
 			path: node.path
 		});
 		const clientPath = path.resolve(root, ".kubb/client.ts");
+		const eventStream = isEventStream(node);
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
@@ -1172,12 +1343,16 @@ const clientGenerator = defineGenerator({
 			}),
 			children: [
 				/* @__PURE__ */ jsx(File.Import, {
-					name: ["client"],
+					name: eventStream ? ["client", "toEventStream"] : ["client"],
 					root: meta.file.path,
 					path: clientPath
 				}),
 				/* @__PURE__ */ jsx(File.Import, {
-					name: ["Options", "RequestResult"],
+					name: eventStream ? [
+						"Options",
+						"EventStreamResult",
+						"SuccessOf"
+					] : ["Options", "RequestResult"],
 					root: meta.file.path,
 					path: clientPath,
 					isTypeOnly: true
@@ -1198,7 +1373,7 @@ const clientGenerator = defineGenerator({
 					node,
 					tsResolver,
 					zodResolver,
-					parser,
+					validator,
 					security
 				})
 			]
@@ -1207,12 +1382,15 @@ const clientGenerator = defineGenerator({
 });
 //#endregion
 //#region src/templates.ts
+/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
+const fetchClientTemplatePath = fileURLToPath(new URL("../templates/fetch.ts", import.meta.url));
+/** Absolute path to the fetch serializers template, copied into `.kubb/serializers.ts`. */
+const fetchSerializersTemplatePath = fileURLToPath(new URL("../templates/serializers.ts", import.meta.url));
 /**
-* Absolute path to the fetch client runtime template, resolved relative to this package's own
-* location so it stays correct no matter which package imports it. Pass it to a file node's `copy`
-* field to emit the runtime into the generated `.kubb/client.ts` verbatim.
+* Absolute path to the Standard Schema runtime template. Pass it to a file node's `copy` field to
+* emit the helper into the generated `.kubb/standardSchema.ts` verbatim.
 */
-const fetchClientTemplatePath = fileURLToPath(new URL("../templates/fetch.ts", import.meta.url));
+const standardSchemaTemplatePath = fileURLToPath(new URL("../templates/standardSchema.ts", import.meta.url));
 //#endregion
 //#region src/plugin.ts
 /**
@@ -1246,7 +1424,7 @@ const pluginFetch = definePlugin((options) => {
 	const { output = {
 		path: "clients",
 		barrel: { type: "named" }
-	}, exclude = [], include, override = [], baseURL, parser = false, group, sdk, resolver: userResolver } = options;
+	}, exclude = [], include, override = [], baseURL, validator = false, group, sdk, resolver: userResolver } = options;
 	const resolved = {
 		output,
 		exclude,
@@ -1254,7 +1432,7 @@ const pluginFetch = definePlugin((options) => {
 		override,
 		group: createGroupConfig(group),
 		baseURL,
-		parser,
+		validator,
 		sdk: sdk ? {
 			mode: sdk.mode ?? "tag",
 			name: sdk.name
@@ -1268,19 +1446,29 @@ const pluginFetch = definePlugin((options) => {
 	return {
 		name: pluginFetchName,
 		options,
-		dependencies: [pluginTsName, isParserEnabled(resolved.parser) ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
+		dependencies: [pluginTsName, isValidatorEnabled(resolved.validator) ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
 		hooks: { "kubb:plugin:setup"(ctx) {
 			ctx.setOptions(resolved);
 			ctx.setResolver(resolved.resolver);
 			ctx.setMacros([...defaultMacros, ...options.macros ?? []]);
 			ctx.addGenerator(...selectedGenerators);
 			const root = path.resolve(ctx.config.root, ctx.config.output.path);
+			ctx.injectFile({
+				baseName: "serializers.ts",
+				path: path.resolve(root, ".kubb/serializers.ts"),
+				copy: fetchSerializersTemplatePath
+			});
 			ctx.injectFile({
 				baseName: "client.ts",
 				path: path.resolve(root, ".kubb/client.ts"),
 				copy: fetchClientTemplatePath,
 				footer: baseURL ? `client.setConfig({ baseURL: ${JSON.stringify(baseURL)} })` : void 0
 			});
+			ctx.injectFile({
+				baseName: "standardSchema.ts",
+				path: path.resolve(root, ".kubb/standardSchema.ts"),
+				copy: standardSchemaTemplatePath
+			});
 		} }
 	};
 });