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

package/dist/serializers-Ds8zZwOO.d.ts

@@ -0,0 +1,190 @@
+type HeaderValue = string | number | boolean | null | undefined | object;
+type HeadersInit = Array<[string, HeaderValue]> | Record<string, HeaderValue>;
+/**
+ * The request body type `fetch` accepts, derived from `RequestInit` instead of the global `BodyInit`
+ * name, which a Node-only project (`@types/node` without the `dom` lib) does not declare.
+ */
+type RequestBody = NonNullable<RequestInit['body']>;
+type HttpMethod = 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'QUERY';
+/**
+ * The OpenAPI query-parameter serialization style. `form` is the default; `spaceDelimited` and
+ * `pipeDelimited` join arrays with a space or pipe, and `deepObject` renders objects as
+ * `key[prop]=value`.
+ */
+type QueryStyle = 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+/**
+ * The serialization metadata shared by the styled parameter locations: the OpenAPI `style` (typed per
+ * location through `TStyle`), `explode`, and `allowReserved` (keeps RFC 3986 reserved characters
+ * unencoded, used by query and request bodies).
+ */
+type SerializationStyle<TStyle = string> = {
+  style?: TStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+};
+/** The media type of a parameter described with `content`; JSON sends one JSON-encoded value. */
+type ParamContentType = {
+  contentType?: string;
+};
+/**
+ * The per-parameter query serialization metadata carried by the generated request. `querystring` marks an OpenAPI 3.2
+ * `in: querystring` parameter, whose JSON value is the whole query string, sent without its name.
+ */
+type QueryParamStyle = SerializationStyle<QueryStyle> & ParamContentType & {
+  querystring?: boolean;
+};
+/**
+ * Serializes the query object into a search string. The optional second argument carries the
+ * per-parameter OpenAPI `style` / `explode` / `allowReserved` metadata; without it arrays explode
+ * into repeated keys and nested objects use the `deepObject` style.
+ */
+type QuerySerializer = (params: Record<string, unknown>, options?: Record<string, QueryParamStyle>) => string;
+/**
+ * The per-parameter cookie serialization metadata carried by the generated request. Cookies use the
+ * OpenAPI `form` style, so only `explode` is configurable.
+ */
+type CookieParamStyle = ParamContentType & {
+  explode?: boolean;
+};
+/**
+ * The per-parameter header serialization metadata carried by the generated request. Headers use the
+ * OpenAPI `simple` style, so only `explode` is configurable.
+ *
+ * @example
+ * ```ts
+ * // styles.header: { 'X-Ids': { explode: false } }, header [3, 4] -> 'X-Ids: 3,4'
+ * // styles.header: { 'X-Filter': { explode: true } }, header { role: 'admin' } -> 'X-Filter: role=admin'
+ * ```
+ */
+type HeaderParamStyle = ParamContentType & {
+  explode?: boolean;
+};
+/**
+ * The per-property `encoding` metadata for an `application/x-www-form-urlencoded` or
+ * `multipart/form-data` request body. `contentType` overrides the part's media type; `style` /
+ * `explode` / `allowReserved` follow the OpenAPI query rules for urlencoded bodies.
+ */
+type BodyEncoding = SerializationStyle<QueryStyle> & {
+  contentType?: string;
+};
+/**
+ * Serializes the request body. JSON by default; `FormData`, `URLSearchParams`, `Blob`,
+ * `ArrayBuffer`, and string bodies pass through untouched. The optional `encoding` argument carries
+ * the per-property OpenAPI `encoding` metadata for form bodies.
+ */
+type BodySerializer = (args: {
+  body: unknown;
+  contentType?: string;
+  encoding?: Record<string, BodyEncoding>;
+}) => RequestBody | undefined;
+/**
+ * The OpenAPI path-parameter serialization style. `simple` is the default and emits the bare value;
+ * `label` prefixes a `.` and `matrix` prefixes a `;name=` segment.
+ */
+type PathStyle = 'simple' | 'label' | 'matrix';
+/**
+ * The per-parameter serialization metadata carried by the generated request. `style` selects the
+ * OpenAPI style and `explode` controls how arrays and objects expand.
+ */
+type PathParamStyle = SerializationStyle<PathStyle>;
+/**
+ * Serializes a single path parameter for interpolation into the URL, honoring the OpenAPI `style` /
+ * `explode` passed as `options`. Defaults to `simple` style with `explode: false`: primitives are
+ * URL-encoded, arrays join their members with commas, and objects flatten to `key,value` pairs.
+ */
+type PathSerializer = (args: {
+  name: string;
+  value: unknown;
+  options?: PathParamStyle;
+}) => string;
+/**
+ * The per-concern serializers, grouped so they can be set in one place and overridden per client or
+ * per call. Each field falls back to the matching `default*Serializer` when omitted.
+ */
+type Serializers = {
+  query?: QuerySerializer;
+  body?: BodySerializer;
+  path?: PathSerializer;
+};
+/**
+ * The per-parameter OpenAPI `style` / `explode` metadata a generated request carries, grouped by
+ * location and keyed by parameter name. Mirrors the `serializer` grouping and feeds the default
+ * serializers; `body` carries the form `encoding` for a urlencoded or multipart body.
+ */
+type Styles = {
+  path?: Record<string, PathParamStyle>;
+  query?: Record<string, QueryParamStyle>;
+  header?: Record<string, HeaderParamStyle>;
+  cookie?: Record<string, CookieParamStyle>;
+  body?: Record<string, BodyEncoding>;
+};
+declare function isDefaultJsonBody(body: unknown): boolean;
+/**
+ * Default body serializer: passes binary/form bodies through and JSON-serializes everything else.
+ * For `multipart/form-data` plain objects become `FormData` and for
+ * `application/x-www-form-urlencoded` they become `URLSearchParams`. When `encoding` is supplied each
+ * urlencoded property follows its OpenAPI `style` / `explode` / `allowReserved`.
+ *
+ * @example
+ * ```ts
+ * defaultBodySerializer({ body: { name: 'odie' } }) // '{"name":"odie"}'
+ * defaultBodySerializer({ body: { field: 'x' }, contentType: 'multipart/form-data' }) // FormData
+ * defaultBodySerializer({ body: { tags: ['a', 'b'] }, contentType: 'application/x-www-form-urlencoded', encoding: { tags: { explode: false } } }) // 'tags=a,b'
+ * defaultBodySerializer({ body: { meta: { a: 1 } }, contentType: 'multipart/form-data', encoding: { meta: { contentType: 'application/json' } } }) // FormData with a typed Blob part
+ * ```
+ */
+declare const defaultBodySerializer: BodySerializer;
+/**
+ * The media type of a `Content-Type` value without its parameters, in lower case: `application/json; charset=utf-8` gives `application/json`.
+ */
+declare function baseContentType(value: string | null | undefined): string | undefined;
+/** Whether a content type carries JSON: `application/json`, `text/json`, or a `+json` suffix. */
+declare function isJsonMediaType(contentType: string | null | undefined): boolean;
+/**
+ * Serializes cookie parameters into a `Cookie` header value using the OpenAPI `form` style, joined
+ * with `; `. Values are URL-encoded and `explode` is honored per parameter.
+ *
+ * @example
+ * ```ts
+ * serializeCookies({ session: 'abc', ids: [1, 2] }) // 'session=abc; ids=1,2'
+ * serializeCookies({ ids: [1, 2] }, { ids: { explode: true } }) // 'ids=1; ids=2'
+ * ```
+ */
+declare function serializeCookies(cookies: Record<string, unknown>, styles?: Record<string, CookieParamStyle>): string;
+/**
+ * Default query serializer. Members with `options` metadata follow their OpenAPI `style` / `explode`
+ * / `allowReserved`. Members without it keep the defaults: arrays explode into repeated keys and
+ * nested objects use the `deepObject` style (`key[prop]=value`).
+ *
+ * @example
+ * ```ts
+ * defaultQuerySerializer({ id: [3, 4, 5] }) // 'id=3&id=4&id=5'
+ * defaultQuerySerializer({ id: [3, 4, 5] }, { id: { style: 'form', explode: false } }) // 'id=3,4,5'
+ * defaultQuerySerializer({ id: [3, 4, 5] }, { id: { style: 'spaceDelimited', explode: false } }) // 'id=3%204%205'
+ * defaultQuerySerializer({ id: [3, 4, 5] }, { id: { style: 'pipeDelimited', explode: false } }) // 'id=3|4|5'
+ * defaultQuerySerializer({ a: { b: 1 } }, { a: { style: 'deepObject' } }) // 'a%5Bb%5D=1'
+ * defaultQuerySerializer({ a: { b: { c: 1 } } }, { a: { style: 'deepObject' } }) // 'a%5Bb%5D%5Bc%5D=1'
+ * ```
+ */
+declare const defaultQuerySerializer: QuerySerializer;
+/**
+ * Default path serializer honoring the OpenAPI `style` / `explode` metadata. Without metadata it
+ * falls back to `simple` style with `explode: false`. Replaces the previous `String(value)`
+ * interpolation, which emitted `[object Object]` for object path params.
+ *
+ * @example
+ * ```ts
+ * defaultPathSerializer({ name: 'id', value: [3, 4, 5] }) // '3,4,5'
+ * defaultPathSerializer({ name: 'id', value: [3, 4, 5], options: { style: 'label', explode: true } }) // '.3.4.5'
+ * defaultPathSerializer({ name: 'id', value: [3, 4, 5], options: { style: 'matrix', explode: true } }) // ';id=3;id=4;id=5'
+ * defaultPathSerializer({ name: 'pt', value: { x: 1, y: 2 } }) // 'x,1,y,2'
+ * ```
+ */
+declare const defaultPathSerializer: PathSerializer;
+/**
+ * Serializes array and object header parameters with the OpenAPI `simple` style before they are
+ * merged. Header values are not URL-encoded. Primitive values and headers without metadata pass
+ * through untouched.
+ */
+declare function applyHeaderStyles(headers: HeadersInit | undefined, styles: Record<string, HeaderParamStyle> | undefined): HeadersInit | undefined;
+export { defaultQuerySerializer as C, serializeCookies as E, defaultPathSerializer as S, isJsonMediaType as T, Serializers as _, HeaderValue as a, baseContentType as b, ParamContentType as c, PathStyle as d, QueryParamStyle as f, SerializationStyle as g, RequestBody as h, HeaderParamStyle as i, PathParamStyle as l, QueryStyle as m, BodySerializer as n, HeadersInit as o, QuerySerializer as p, CookieParamStyle as r, HttpMethod as s, BodyEncoding as t, PathSerializer as u, Styles as v, isDefaultJsonBody as w, defaultBodySerializer as x, applyHeaderStyles as y };

package/dist/standardSchema-BShJWz2i.d.ts

@@ -0,0 +1,104 @@
+/**
+ * A Standard Schema-compatible validator: a minimal duck-type covering Zod v3/v4, valibot, and
+ * arktype schemas. Only the `~standard.validate` method is required at runtime.
+ */
+type StandardSchemaValidator<TOutput = unknown> = {
+  readonly '~standard': {
+    validate(value: unknown): StandardSchemaResult<TOutput> | Promise<StandardSchemaResult<TOutput>>;
+  };
+};
+/**
+ * The two possible outcomes of a Standard Schema `validate` call. A successful result carries
+ * `value`; a failed result carries `issues`.
+ */
+type StandardSchemaResult<TOutput> = {
+  readonly value: TOutput;
+  readonly issues?: undefined;
+} | {
+  readonly issues: ReadonlyArray<StandardSchemaIssue>;
+};
+/**
+ * One validation issue from a Standard Schema `validate` call.
+ */
+type StandardSchemaIssue = {
+  readonly message?: string;
+  readonly path?: ReadonlyArray<PropertyKey | {
+    readonly key: PropertyKey;
+  }>;
+};
+/**
+ * Thrown by `validateStandardSchema` when validation fails. Carries the raw `issues` array from
+ * the schema's `validate` result so callers receive a uniform error shape regardless of which
+ * schema library is in use.
+ */
+declare class ParseError extends Error {
+  readonly issues: ReadonlyArray<StandardSchemaIssue>;
+  constructor({ issues, message }: {
+    issues: ReadonlyArray<StandardSchemaIssue>;
+    message?: string;
+  });
+}
+/**
+ * Validates `value` against a Standard Schema-compatible `schema`. Returns the parsed output on
+ * success; throws `ParseError` with the schema's `issues` on failure. Handles both sync and async
+ * `validate` implementations transparently.
+ *
+ * @example
+ * const pet = await validateStandardSchema(PetSchema, rawData)
+ */
+declare function validateStandardSchema<TOutput>(schema: StandardSchemaValidator<TOutput>, value: unknown): Promise<TOutput>;
+/**
+ * Wraps an object schema so its keys match case-insensitively.
+ * Keys the schema does not declare pass through untouched.
+ * The declared keys are validated with `schema` under their declared names.
+ * Every key, and every issue path, keeps the casing the caller used.
+ *
+ * @param schema Standard Schema-compatible object schema.
+ * @param entries The record of keys the passed object schema validates.
+ * @example
+ * ```ts
+ * validator: { headers: toHeadersStandardSchema(putEventHeadersSchema, putEventHeadersSchema.shape) }
+ * ```
+ */
+declare function toHeadersStandardSchema(schema: StandardSchemaValidator, entries: Record<string, unknown>): StandardSchemaValidator;
+/**
+ * Identifies the value and request that failed validation in `onValidationError`.
+ */
+type ValidationErrorContext = {
+  value: unknown;
+  direction: 'request' | 'response' | 'error';
+  source: 'body' | 'path' | 'query' | 'headers';
+  method?: string;
+  url?: string;
+  status?: number;
+};
+/**
+ * Return `{ value }` to substitute a failed value, including `undefined`. Returning nothing rethrows the `ParseError`.
+ */
+type ValidationErrorHandler = (error: ParseError, context: ValidationErrorContext) => {
+  value: unknown;
+} | void | Promise<{
+  value: unknown;
+} | void>;
+/**
+ * Turns generated validation on or off. `false` skips every validator, an object skips only the directions set to `false`:
+ * `request` is the body, `params` are path, query, and header params, `response` and `error` are the response bodies.
+ * @default true
+ */
+type ValidateOption = boolean | {
+  request?: boolean;
+  params?: boolean;
+  response?: boolean;
+  error?: boolean;
+};
+declare function isValidationEnabled(validate: ValidateOption | undefined, direction: 'request' | 'params' | 'response' | 'error'): boolean;
+/**
+ * Runs a validator when there is one, handing a `ParseError` to `onValidationError` first, which may substitute the value.
+ */
+declare function runValidator<T>({ validator, value, context, onValidationError }: {
+  validator: StandardSchemaValidator<T> | undefined;
+  value: T;
+  context: Omit<ValidationErrorContext, 'value'>;
+  onValidationError: ValidationErrorHandler | undefined;
+}): Promise<T>;
+export { ValidateOption as a, isValidationEnabled as c, validateStandardSchema as d, StandardSchemaValidator as i, runValidator as l, StandardSchemaIssue as n, ValidationErrorContext as o, StandardSchemaResult as r, ValidationErrorHandler as s, ParseError as t, toHeadersStandardSchema as u };

package/dist/templates/client.d.ts

@@ -0,0 +1,2 @@
+import { S as RequestResult, k as SuccessOf, n as NativeResponse, p as DataShape, t as NativeRequest, y as Options } from "../client-CiHb_Cfg.js";
+export { type DataShape, NativeRequest, NativeResponse, type Options, type RequestResult, type SuccessOf };

package/dist/templates/core.d.ts

@@ -0,0 +1,3 @@
+import { a as ValidateOption, o as ValidationErrorContext, s as ValidationErrorHandler } from "../standardSchema-BShJWz2i.js";
+import { A as SuccessResultUnion, B as createClientCore, C as ResolvedRequest, D as ResultByStatus, E as ResponseType, F as TransportResult, G as unwrapResult, H as getResponseContentType, I as Unwrappable, K as withUnwrap, L as UnwrappedResult, M as SuccessVariant, N as ToStatusNumber, O as ResultUnion, P as Transport, R as UrlConfig, S as RequestResult, T as ResponseErrorConfig, U as isStreamed, V as createInterceptorStack, W as resolveAuth, _ as InterceptorStack, a as AuthToken, b as RequestConfig, c as ClientInstance, d as ContentType, f as DataOf, g as InterceptorFn, h as ErrorOf, i as AuthResolver, j as SuccessStatusCode, k as SuccessOf, l as Codec, m as Deserializer, o as CallResult, p as DataShape, r as Auth, s as ClientConfig, u as ContentBodySerializer, v as Interceptors, w as ResponseError, x as RequestCredentials, y as Options, z as Validator } from "../client-CiHb_Cfg.js";
+export { Auth, AuthResolver, AuthToken, CallResult, ClientConfig, ClientInstance, Codec, ContentBodySerializer, ContentType, DataOf, DataShape, Deserializer, ErrorOf, InterceptorFn, InterceptorStack, Interceptors, Options, RequestConfig, RequestCredentials, RequestResult, ResolvedRequest, ResponseError, ResponseErrorConfig, ResponseType, ResultByStatus, ResultUnion, SuccessOf, SuccessResultUnion, SuccessStatusCode, SuccessVariant, ToStatusNumber, Transport, TransportResult, Unwrappable, UnwrappedResult, UrlConfig, type ValidateOption, type ValidationErrorContext, type ValidationErrorHandler, Validator, createClientCore, createInterceptorStack, getResponseContentType, isStreamed, resolveAuth, unwrapResult, withUnwrap };

package/dist/templates/serializers.d.ts

@@ -0,0 +1,2 @@
+import { C as defaultQuerySerializer, E as serializeCookies, S as defaultPathSerializer, T as isJsonMediaType, _ as Serializers, a as HeaderValue, b as baseContentType, c as ParamContentType, d as PathStyle, f as QueryParamStyle, g as SerializationStyle, h as RequestBody, i as HeaderParamStyle, l as PathParamStyle, m as QueryStyle, n as BodySerializer, o as HeadersInit, p as QuerySerializer, r as CookieParamStyle, s as HttpMethod, t as BodyEncoding, u as PathSerializer, v as Styles, w as isDefaultJsonBody, x as defaultBodySerializer, y as applyHeaderStyles } from "../serializers-Ds8zZwOO.js";
+export { BodyEncoding, BodySerializer, CookieParamStyle, HeaderParamStyle, HeaderValue, HeadersInit, HttpMethod, ParamContentType, PathParamStyle, PathSerializer, PathStyle, QueryParamStyle, QuerySerializer, QueryStyle, RequestBody, SerializationStyle, Serializers, Styles, applyHeaderStyles, baseContentType, defaultBodySerializer, defaultPathSerializer, defaultQuerySerializer, isDefaultJsonBody, isJsonMediaType, serializeCookies };

package/dist/templates/sse.d.ts

@@ -0,0 +1,124 @@
+import { a as ValidateOption, i as StandardSchemaValidator, s as ValidationErrorHandler } from "../standardSchema-BShJWz2i.js";
+import { S as RequestResult, k as SuccessOf, n as NativeResponse, p as DataShape, t as NativeRequest, y as Options } from "../client-CiHb_Cfg.js";
+/**
+ * One decoded Server-Sent Event. `data` is parsed as JSON when valid and kept as the raw string otherwise,
+ * `event` is `message` when the server sent no `event` field, and `id` is the last event ID the stream has set.
+ */
+export type ServerSentEvent<TData = unknown> = {
+  data: TData;
+  event: string;
+  id?: string;
+  retry?: number;
+};
+/** An event the document types by name: the member's own `event` and `data`, plus the `id` and `retry` any event may carry. */
+export type TypedEvent<TEvent> = TEvent & Pick<ServerSentEvent, 'id' | 'retry'>;
+/** Per-call options of a streamed operation, passed next to its request params. */
+export type EventStreamOptions = {
+  /**
+   * The largest number of characters, line breaks included, one event may hold before the blank line that ends it.
+   * A larger event throws a `RangeError` and cancels the stream. Set `Infinity` to turn the limit off.
+   * @default 16777216
+   */
+  maxEventSize?: number;
+  /**
+   * Ends the stream when an event's raw `data` equals this value, such as `[DONE]`.
+   */
+  terminator?: string;
+  /**
+   * Maps each event before validation.
+   */
+  transform?: (event: ServerSentEvent) => ServerSentEvent;
+};
+/** The options of a streamed operation: the call's `Options` with the per-call stream options, as `Options` is for a regular call. */
+export type StreamOptions<TData extends DataShape, ThrowOnError extends boolean = true> = Options<TData, ThrowOnError> & EventStreamOptions;
+/**
+ * The validation settings a call or its client may set.
+ */
+type ValidationSettings = {
+  validate?: ValidateOption;
+  onValidationError?: ValidationErrorHandler;
+};
+/**
+ * What the client resolves a streamed call to: the body as a stream or a decoded value, its content type, and the native response.
+ */
+export type EventStreamCall<TResponse> = {
+  data: unknown;
+  error?: unknown;
+  status?: number;
+  contentType?: string;
+  request?: NativeRequest;
+  response: TResponse;
+};
+/** The payload wrapped in `ServerSentEvent`, or the item itself when the document types it as a whole event. */
+type StreamEvent<TData> = TData extends {
+  event: string;
+} ? TData : ServerSentEvent<TData>;
+/** Parsed events with the fields a `RequestResult` carries. `TData` is the payload, or the typed event. Iterating the result reads `stream`. */
+export type EventStreamResult<TData = unknown, TResponse = NativeResponse> = AsyncIterable<StreamEvent<TData>> & {
+  stream: AsyncGenerator<StreamEvent<TData>>;
+  /** The same events as `stream` on a 2xx response, so `.unwrap()` and `returnType: 'data'` return them. */
+  data: AsyncGenerator<StreamEvent<TData>> | undefined;
+  status: number | undefined;
+  /** The error body of a failed call with `throwOnError: false`, whose `stream` then yields nothing. */
+  error: unknown;
+  contentType: string | undefined;
+  request: NativeRequest | undefined;
+  response: TResponse;
+  /**
+   * The last event ID the server sent, to resume from with a `Last-Event-ID` header on a new call. Empty until the server sends `id`.
+   */
+  readonly lastEventId: string;
+};
+type StreamParts<TData> = AsyncIterable<StreamEvent<TData>> & {
+  stream: AsyncGenerator<StreamEvent<TData>>;
+  readonly lastEventId: string;
+};
+type WithEvents<TResult, TData> = TResult extends {
+  error: undefined;
+} ? Omit<TResult, 'data'> & {
+  data: AsyncGenerator<StreamEvent<TData>>;
+} : TResult;
+/** A stream call's result, as `RequestResult` is a regular call's: `status` narrows `error`, and the events are its `data`. Branching on `ThrowOnError` lets a generated call cast to it. */
+export type StreamResult<TResponses, ThrowOnError extends boolean = true, TData = SuccessOf<TResponses>> = ThrowOnError extends true ? WithEvents<RequestResult<TResponses, true>, TData> & StreamParts<TData> : WithEvents<RequestResult<TResponses, false>, TData> & StreamParts<TData>;
+/** What a stream operation returns with `returnType: 'data'`, as `UnwrappedResult` is for a regular call. */
+export type UnwrappedStreamResult<TResponses, ThrowOnError extends boolean = true, TData = SuccessOf<TResponses>> = ThrowOnError extends true ? AsyncGenerator<StreamEvent<TData>> : StreamResult<TResponses, false, TData>;
+/** The last event ID, shared with the result so it can be read after the loop. */
+type Cursor = {
+  lastEventId: string;
+};
+/**
+ * Parses a `text/event-stream` body as the WHATWG event stream specification does: an event is dispatched at its blank line
+ * when it holds `data`, `event` defaults to `message`, `id` carries across events until an empty `id` resets it, `retry` needs
+ * all digits, and an unfinished event at the end is dropped. `data` is parsed as JSON when it is valid and kept as text
+ * otherwise. Consume with `for await`, and break the loop to cancel the stream.
+ */
+type EventStreamInput = ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+export declare function parseEventStream<TData = unknown>(input: EventStreamInput | (Pick<EventStreamOptions, 'maxEventSize' | 'terminator'> & {
+  stream: EventStreamInput;
+  cursor?: Cursor;
+})): AsyncGenerator<ServerSentEvent<TData>>;
+/**
+ * Reads a call as typed Server-Sent Events, transformed and validated one by one, until the terminator or the end of the
+ * stream. A successful call whose body is not a stream, such as a decoded JSON answer, throws a `TypeError` with the body
+ * as its `cause`. A dropped connection ends the loop with the transport's error; `lastEventId` on the result is the ID
+ * to resume from.
+ */
+export declare function toEventStream<TData = unknown, TResponse = NativeResponse>(call: Promise<EventStreamCall<TResponse>>, { client, config: options, ...meta }?: {
+  /**
+   * The client the call went through, for the validation settings a call does not set itself.
+   */
+  client?: {
+    getConfig: () => ValidationSettings;
+  };
+  config?: EventStreamOptions & ValidationSettings;
+  /**
+   * `event` when the document types each event with its own `event` and `data`, or `data` when it types only the payload.
+   * @default 'data'
+   */
+  shape?: 'event' | 'data';
+  /**
+   * Validates each event (`shape: 'event'`) or its `data` (`shape: 'data'`), after `transform`.
+   */
+  validator?: StandardSchemaValidator;
+}): Promise<EventStreamResult<TData, TResponse>>;
+export {};

package/dist/templates/standardSchema.d.ts

@@ -0,0 +1,2 @@
+import { a as ValidateOption, c as isValidationEnabled, d as validateStandardSchema, i as StandardSchemaValidator, l as runValidator, n as StandardSchemaIssue, o as ValidationErrorContext, r as StandardSchemaResult, s as ValidationErrorHandler, t as ParseError, u as toHeadersStandardSchema } from "../standardSchema-BShJWz2i.js";
+export { ParseError, StandardSchemaIssue, StandardSchemaResult, StandardSchemaValidator, ValidateOption, ValidationErrorContext, ValidationErrorHandler, isValidationEnabled, runValidator, toHeadersStandardSchema, validateStandardSchema };

package/docs/guides/write-your-client.md

@@ -10,7 +10,7 @@ The generated functions import your module through [`importPath`](https://kubb.d
 | `Options`       | type     | The grouped options object a generated function accepts.                                     |
 | `RequestResult` | type     | What a generated function resolves to.                                                       |
 
-If your spec has server-sent event operations, also export `toEventStream` and the `EventStreamResult` and `SuccessOf` types.
+If your spec has server-sent event operations, also export `toEventStream` and the `EventStreamResult`, `SuccessOf`, and `TypedEvent` types. A generated function calls `toEventStream<TData>(promise)` with the promise your `client` returns and nothing else, and leaves the response validator on `config.validator.response`, so your module decides how to validate events.
 
 The query plugins (`@kubb/plugin-react-query`, `@kubb/plugin-vue-query`, `@kubb/plugin-swr`) and `@kubb/plugin-mcp` call the generated functions with `throwOnError: true` and read `data` off the result. The query plugins also import two more types from your module:
 

package/docs/overview.md

@@ -6,7 +6,7 @@ Each function takes grouped `path`, `query`, `headers`, and `body` parameters an
 
 ## Setup
 
-- Set the required `importPath` option to your client module. The module must export `client` and the `Options` and `RequestResult` types. When the spec has server-sent event operations, it must also export `toEventStream` and the `EventStreamResult` and `SuccessOf` types.
+- Set the required `importPath` option to your client module. The module must export `client` and the `Options` and `RequestResult` types. When the spec has server-sent event operations, it must also export `toEventStream` and the `EventStreamResult`, `SuccessOf`, and `TypedEvent` types.
 - Add `@kubb/plugin-ts` for the operation types, or `@kubb/plugin-zod` with `inferred: true`.
 - Add `@kubb/plugin-zod` when you set `validator`, and install `zod` v4. Generation fails without the plugin.
 

package/kubb-extension.json

@@ -20,7 +20,7 @@
   "dependencies": ["plugin-ts"],
   "optionalDependencies": ["plugin-zod"],
   "compatibility": {
-    "kubb": ">=5.14.6",
+    "kubb": ">=5.16.0",
     "node": ">=22.22"
   },
   "options": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "5.10.0-canary.20261105T162357",
+  "version": "5.10.0",
   "description": "Generate typed API operations against your own client module.",
   "keywords": [
     "api-client",
@@ -22,6 +22,7 @@
   "files": [
     "src",
     "dist",
+    "templates",
     "kubb-extension.json",
     "docs",
     "!/**/**.test.**",
@@ -45,21 +46,29 @@
       }
     },
     "./package.json": "./package.json",
-    "./kubb-extension.json": "./kubb-extension.json"
+    "./kubb-extension.json": "./kubb-extension.json",
+    "./templates/*.ts": {
+      "types": "./dist/templates/*.d.ts",
+      "default": "./templates/*.ts"
+    },
+    "./templates/*.js": {
+      "types": "./dist/templates/*.d.ts"
+    },
+    "./templates/*": "./templates/*"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/kit": "^5.15.4",
-    "@kubb/plugin-ts": "^5.5.0-canary.20261105T162357",
-    "@kubb/plugin-zod": "^5.9.0-canary.20261105T162357",
-    "@kubb/renderer-jsx": "^5.15.4"
+    "@kubb/kit": "^5.16.0",
+    "@kubb/plugin-ts": "^5.4.1",
+    "@kubb/plugin-zod": "^5.8.2",
+    "@kubb/renderer-jsx": "^5.16.0"
   },
   "devDependencies": {
-    "@internals/client": "0.1.0-canary.20261105T162357",
-    "@internals/shared": "0.1.0-canary.20261105T162357",
+    "@internals/client": "0.0.0",
+    "@internals/shared": "0.0.0",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {},

package/templates/client.ts

@@ -0,0 +1,5 @@
+// Stands in for the transport's `client.ts` next to `sse.ts`, so the shared templates typecheck on their own. In the
+// generated `.kubb/` folder, `sse.ts` reads these from the real client; this file is never copied.
+export type { DataShape, Options, RequestResult, SuccessOf } from './core.ts'
+export type NativeRequest = unknown
+export type NativeResponse = unknown