@kubb/plugin-client 5.12.0 → 6.0.1

package/dist/templates/client.d.ts

@@ -1,2 +1,3 @@
-import { A as SuccessOf, S as RequestResult, n as NativeResponse, p as DataShape, t as NativeRequest, y as Options } from "../client-BxO6Dygu.js";
-export { type DataShape, NativeRequest, NativeResponse, type Options, type RequestResult, type SuccessOf };
+import { $ as createClientCore, A as ResultByStatus, B as SuccessVariant, C as RequestResult, D as ResponseErrorConfig, E as ResponseError, F as StreamResult, G as Unwrappable, H as Transport, I as StreamResultWithHeaders, J as UnwrappedResultWithHeaders, K as Unwrapped, L as SuccessOf, M as SecurityRequirement, N as ServerSentEvent, O as ResponseErrorOf, P as StreamOptions, Q as Validator, R as SuccessResultUnion, S as RequestCredentials, T as ResolvedRequest, U as TransportResult, V as ToStatusNumber, W as TypedEvent, X as UnwrappedStreamResultWithHeaders, Y as UnwrappedStreamResult, Z as UrlConfig, _ as InterceptorStack, a as AuthResolver, at as resolveThrowOnError, b as ParseAs, c as ClientInstance, ct as withUnwrap, d as DataShape, dt as MediaTypes, et as createInterceptorStack, f as DecodedResponse, ft as defaultMediaTypes, g as InterceptorFn, h as EventStreamOptions, ht as resolveMediaType, i as Auth, it as resolveAuth, j as ResultUnion, k as ResponseHeaders, l as ContentType, lt as MediaType, m as ErrorOf, mt as parseJson, n as NativeRequest, nt as getHeader, o as AuthToken, ot as toRequestInit, p as EmptyErrorBody, pt as isEncodedBody, q as UnwrappedResult, r as NativeResponse, rt as isResponseError, s as ClientConfig, st as unwrapResult, t as NativeOptions, tt as createLazyClient, u as DataOf, ut as MediaTypeContext, v as Interceptors, w as RequestResultWithHeaders, x as RequestConfig, y as Options, z as SuccessStatusCode } from "../client-C-0-puI2.js";
+import { ValidateOption, ValidationErrorContext, ValidationErrorHandler } from "./standardSchema.js";
+export { type Auth, type AuthResolver, type AuthToken, type ClientConfig, type ClientInstance, type ContentType, type DataOf, type DataShape, type DecodedResponse, type EmptyErrorBody, type ErrorOf, type EventStreamOptions, type InterceptorFn, type InterceptorStack, type Interceptors, type MediaType, type MediaTypeContext, type MediaTypes, NativeOptions, NativeRequest, NativeResponse, type Options, type ParseAs, type RequestConfig, type RequestCredentials, type RequestResult, type RequestResultWithHeaders, type ResolvedRequest, type ResponseError, type ResponseErrorConfig, type ResponseErrorOf, type ResponseHeaders, type ResultByStatus, type ResultUnion, type SecurityRequirement, type ServerSentEvent, type StreamOptions, type StreamResult, type StreamResultWithHeaders, type SuccessOf, type SuccessResultUnion, type SuccessStatusCode, type SuccessVariant, type ToStatusNumber, type Transport, type TransportResult, type TypedEvent, type Unwrappable, type Unwrapped, type UnwrappedResult, type UnwrappedResultWithHeaders, type UnwrappedStreamResult, type UnwrappedStreamResultWithHeaders, type UrlConfig, type ValidateOption, type ValidationErrorContext, type ValidationErrorHandler, type Validator, type createClientCore, type createInterceptorStack, type createLazyClient, type defaultMediaTypes, type getHeader, type isEncodedBody, type isResponseError, type parseJson, type resolveAuth, type resolveMediaType, type resolveThrowOnError, type toRequestInit, type unwrapResult, type withUnwrap };

package/dist/templates/core.d.ts

@@ -1,3 +1,3 @@
-import { a as ValidateOption, o as ValidationErrorContext, s as ValidationErrorHandler } from "../standardSchema-BShJWz2i.js";
-import { A as SuccessOf, B as Validator, C as ResolvedRequest, D as ResponseTypeMap, E as ResponseType, F as Transport, G as resolveAuth, H as createInterceptorStack, I as TransportResult, J as withUnwrap, K as resolveResponseType, L as Unwrappable, M as SuccessStatusCode, N as SuccessVariant, O as ResultByStatus, P as ToStatusNumber, R as UnwrappedResult, S as RequestResult, T as ResponseErrorConfig, U as getResponseContentType, V as createClientCore, W as isStreamed, _ 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 SuccessResultUnion, k as ResultUnion, l as Codec, m as Deserializer, o as CallResult, p as DataShape, q as unwrapResult, r as Auth, s as ClientConfig, u as ContentBodySerializer, v as Interceptors, w as ResponseError, x as RequestCredentials, y as Options, z as UrlConfig } from "../client-BxO6Dygu.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, ResponseTypeMap, ResultByStatus, ResultUnion, SuccessOf, SuccessResultUnion, SuccessStatusCode, SuccessVariant, ToStatusNumber, Transport, TransportResult, Unwrappable, UnwrappedResult, UrlConfig, type ValidateOption, type ValidationErrorContext, type ValidationErrorHandler, Validator, createClientCore, createInterceptorStack, getResponseContentType, isStreamed, resolveAuth, resolveResponseType, unwrapResult, withUnwrap };
+import { $ as createClientCore, A as ResultByStatus, B as SuccessVariant, C as RequestResult, D as ResponseErrorConfig, E as ResponseError, F as StreamResult, G as Unwrappable, H as Transport, I as StreamResultWithHeaders, J as UnwrappedResultWithHeaders, K as Unwrapped, L as SuccessOf, M as SecurityRequirement, N as ServerSentEvent, O as ResponseErrorOf, P as StreamOptions, Q as Validator, R as SuccessResultUnion, S as RequestCredentials, T as ResolvedRequest, U as TransportResult, V as ToStatusNumber, W as TypedEvent, X as UnwrappedStreamResultWithHeaders, Y as UnwrappedStreamResult, Z as UrlConfig, _ as InterceptorStack, a as AuthResolver, at as resolveThrowOnError, b as ParseAs, c as ClientInstance, ct as withUnwrap, d as DataShape, dt as MediaTypes, et as createInterceptorStack, f as DecodedResponse, ft as defaultMediaTypes, g as InterceptorFn, h as EventStreamOptions, ht as resolveMediaType, i as Auth, it as resolveAuth, j as ResultUnion, k as ResponseHeaders, l as ContentType, lt as MediaType, m as ErrorOf, mt as parseJson, nt as getHeader, o as AuthToken, ot as toRequestInit, p as EmptyErrorBody, pt as isEncodedBody, q as UnwrappedResult, rt as isResponseError, s as ClientConfig, st as unwrapResult, tt as createLazyClient, u as DataOf, ut as MediaTypeContext, v as Interceptors, w as RequestResultWithHeaders, x as RequestConfig, y as Options, z as SuccessStatusCode } from "../client-C-0-puI2.js";
+import { ValidateOption, ValidationErrorContext, ValidationErrorHandler } from "./standardSchema.js";
+export { Auth, AuthResolver, AuthToken, ClientConfig, ClientInstance, ContentType, DataOf, DataShape, DecodedResponse, EmptyErrorBody, ErrorOf, EventStreamOptions, InterceptorFn, InterceptorStack, Interceptors, MediaType, MediaTypeContext, MediaTypes, Options, ParseAs, RequestConfig, RequestCredentials, RequestResult, RequestResultWithHeaders, ResolvedRequest, ResponseError, ResponseErrorConfig, ResponseErrorOf, ResponseHeaders, ResultByStatus, ResultUnion, SecurityRequirement, ServerSentEvent, StreamOptions, StreamResult, StreamResultWithHeaders, SuccessOf, SuccessResultUnion, SuccessStatusCode, SuccessVariant, ToStatusNumber, Transport, TransportResult, TypedEvent, Unwrappable, Unwrapped, UnwrappedResult, UnwrappedResultWithHeaders, UnwrappedStreamResult, UnwrappedStreamResultWithHeaders, UrlConfig, type ValidateOption, type ValidationErrorContext, type ValidationErrorHandler, Validator, createClientCore, createInterceptorStack, createLazyClient, defaultMediaTypes, getHeader, isEncodedBody, isResponseError, parseJson, resolveAuth, resolveMediaType, resolveThrowOnError, toRequestInit, unwrapResult, withUnwrap };

package/dist/templates/mediaTypes/formData.d.ts

@@ -0,0 +1,5 @@
+import { lt as MediaType } from "../../client-C-0-puI2.js";
+/**
+ * The `multipart/form-data` handler, which follows `config.styles.body`.
+ */
+export declare const multipartFormData: MediaType;

package/dist/templates/mediaTypes/urlencoded.d.ts

@@ -0,0 +1,5 @@
+import { lt as MediaType } from "../../client-C-0-puI2.js";
+/**
+ * The `application/x-www-form-urlencoded` handler, which follows `config.styles.body`.
+ */
+export declare const urlencoded: MediaType;

package/dist/templates/mediaTypes.d.ts

@@ -0,0 +1,2 @@
+import { dt as MediaTypes, ft as defaultMediaTypes, ht as resolveMediaType, lt as MediaType, mt as parseJson, pt as isEncodedBody, ut as MediaTypeContext } from "../client-C-0-puI2.js";
+export { MediaType, MediaTypeContext, MediaTypes, defaultMediaTypes, isEncodedBody, parseJson, resolveMediaType };

package/dist/templates/serializers/cookies.d.ts

@@ -0,0 +1,5 @@
+import { CookieSerializer } from "../serializers.js";
+/**
+ * Joins cookie parameters into a `Cookie` header value with the OpenAPI `form` style, or the `cookie` style when a parameter sets it.
+ */
+export declare const serializeCookies: CookieSerializer;

package/dist/templates/serializers/headers.d.ts

@@ -0,0 +1,5 @@
+import { HeaderSerializer } from "../serializers.js";
+/**
+ * Serializes array and object headers with the OpenAPI `simple` style.
+ */
+export declare const serializeHeaders: HeaderSerializer;

package/dist/templates/serializers/path.d.ts

@@ -0,0 +1,5 @@
+import { PathSerializer } from "../serializers.js";
+/**
+ * The path serializer for the `simple` style, which `serializeStyledPath` also uses.
+ */
+export declare const serializePath: PathSerializer;

package/dist/templates/serializers/pathStyles.d.ts

@@ -0,0 +1,5 @@
+import { PathSerializer } from "../serializers.js";
+/**
+ * The path serializer for the OpenAPI `label` and `matrix` styles. A `simple` parameter uses `serializePath`.
+ */
+export declare const serializeStyledPath: PathSerializer;

package/dist/templates/serializers/query.d.ts

@@ -0,0 +1,5 @@
+import { QuerySerializer } from "../serializers.js";
+/**
+ * The query serializer for a spec without styled query parameters: arrays repeat their key, objects use `form` with explode.
+ */
+export declare const serializeQuery: QuerySerializer;

package/dist/templates/serializers/queryStyles.d.ts

@@ -0,0 +1,14 @@
+import { QueryParamStyle, QuerySerializer } from "../serializers.js";
+/**
+ * One query parameter or form field with its OpenAPI style, as encoded pairs.
+ */
+export declare function serializeStyledQueryParam({ key, value, options }: {
+  key: string;
+  value: unknown;
+  options: QueryParamStyle;
+}): Array<string>;
+/**
+ * The query serializer for a spec with styled query parameters: an OpenAPI style, `allowReserved` or a JSON content
+ * type. Without a style entry, arrays repeat their key and objects use `form` with explode.
+ */
+export declare const serializeStyledQuery: QuerySerializer;

package/dist/templates/serializers.d.ts

@@ -1,2 +1,118 @@
-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 };
+export type HeaderValue = string | number | boolean | null | undefined | object;
+export type HeadersInit = Array<[string, HeaderValue]> | Record<string, HeaderValue>;
+/**
+ * A body `fetch` accepts, read from `RequestInit` so a project without the `dom` lib still has it.
+ */
+export type RequestBody = NonNullable<RequestInit['body']>;
+export type HttpMethod = 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'QUERY' | 'TRACE' | (string & {});
+/**
+ * The OpenAPI query style. `form` is the default.
+ */
+export type QueryStyle = 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+export 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.
+ */
+export type ParamContentType = {
+  contentType?: string;
+};
+/**
+ * `querystring` marks an OpenAPI 3.2 `in: querystring` parameter, sent as the whole query string.
+ */
+export type QueryParamStyle = SerializationStyle<QueryStyle> & ParamContentType & {
+  querystring?: boolean;
+};
+/**
+ * Turns the query object into a search string, following each parameter's OpenAPI style when given.
+ */
+export type QuerySerializer = (params: Record<string, unknown>, options?: Record<string, QueryParamStyle>) => string;
+/**
+ * `cookie` is the OpenAPI 3.2 style that sends values as they are, without percent-encoding (RFC 6265). `form` is the default.
+ */
+export type CookieParamStyle = ParamContentType & {
+  style?: 'form' | 'cookie';
+  explode?: boolean;
+};
+export type HeaderParamStyle = ParamContentType & {
+  explode?: boolean;
+};
+/**
+ * The OpenAPI `encoding` of one form body property. `contentType` sets a multipart part's media type.
+ */
+export type BodyEncoding = SerializationStyle<QueryStyle> & {
+  contentType?: string;
+};
+/**
+ * The OpenAPI path style. `simple` is the default.
+ */
+export type PathStyle = 'simple' | 'label' | 'matrix';
+export type PathParamStyle = SerializationStyle<PathStyle>;
+/**
+ * Joins the cookie parameters of a call into a `Cookie` header value.
+ */
+export type CookieSerializer = (cookies: Record<string, unknown>, styles?: Record<string, CookieParamStyle>) => string;
+/**
+ * Serializes the header parameters of a call that are arrays or objects.
+ */
+export type HeaderSerializer = (headers: HeadersInit | undefined, styles?: Record<string, HeaderParamStyle>) => HeadersInit | undefined;
+/**
+ * Turns one path parameter into its URL segment.
+ */
+export type PathSerializer = (args: {
+  name: string;
+  value: unknown;
+  options?: PathParamStyle | undefined;
+}) => string;
+/**
+ * Parameter serializers, set per client or per call. `.kubb/client.ts` registers the ones the spec needs. Bodies are
+ * encoded by `mediaTypes`.
+ */
+export type Serializers = {
+  query?: QuerySerializer;
+  path?: PathSerializer;
+  /**
+   * Turns array and object header values into strings. Without one, such a value is sent as JSON.
+   */
+  header?: HeaderSerializer;
+  /**
+   * Sends the `cookies` of a call. Kubb registers `serializeCookies` when the spec has a cookie parameter.
+   */
+  cookie?: CookieSerializer;
+};
+/**
+ * The OpenAPI styles of a generated call's parameters, by location and name. `body` holds the form `encoding`.
+ */
+export type Styles = {
+  path?: Record<string, PathParamStyle>;
+  query?: Record<string, QueryParamStyle>;
+  header?: Record<string, HeaderParamStyle>;
+  cookie?: Record<string, CookieParamStyle>;
+  body?: Record<string, BodyEncoding>;
+};
+/**
+ * Sends a `bigint` as a JSON number, and throws past the safe-integer range instead of losing precision.
+ */
+export declare function jsonReplacer(_key: string, value: unknown): unknown;
+/**
+ * A `Content-Type` without its parameters, in lower case.
+ */
+export declare function baseContentType(value: string | null | undefined): string | undefined;
+/**
+ * Whether a media type is JSON, such as `application/json` or `application/problem+json`.
+ */
+export declare function isJsonMediaType(contentType: string | null | undefined): boolean;
+export declare function notNullish(value: unknown): boolean;
+/**
+ * Renders a parameter value as a string. A `Date` becomes ISO-8601, so it does not depend on the locale.
+ */
+export declare function toValue(value: unknown): string;
+export declare function encodeComponent(value: unknown): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * One parameter as form pairs, with an array repeating its key and an object as `key[prop]`.
+ */
+export declare function serializeDefaultQueryParam(key: string, value: unknown): Array<string>;

package/dist/templates/sse.d.ts

@@ -1,124 +1,31 @@
-import { a as ValidateOption, i as StandardSchemaValidator, s as ValidationErrorHandler } from "../standardSchema-BShJWz2i.js";
-import { A as SuccessOf, S as RequestResult, n as NativeResponse, p as DataShape, t as NativeRequest, y as Options } from "../client-BxO6Dygu.js";
+import { N as ServerSentEvent, dt as MediaTypes, h as EventStreamOptions, lt as MediaType } from "../client-C-0-puI2.js";
+type Cursor = {
+  lastEventId: string;
+};
+type EventStreamInput = ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
 /**
- * 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.
+ * Parses a `text/event-stream` body into events, as the WHATWG spec does. Break the loop to cancel the stream.
  */
-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;
+export declare function parseEventStream<TData = unknown>(input: EventStreamInput | (Pick<EventStreamOptions, 'maxEventSize' | 'terminator' | 'rawData'> & {
+  stream: EventStreamInput;
+  cursor?: Cursor | undefined;
+})): AsyncGenerator<ServerSentEvent<TData>>;
 /**
- * The validation settings a call or its client may set.
+ * Parses a JSON Lines body into one value per line. Break the loop to cancel the stream.
  */
-type ValidationSettings = {
-  validate?: ValidateOption;
-  onValidationError?: ValidationErrorHandler;
-};
+export declare function parseJsonLines<TData = unknown>({ stream, maxEventSize, terminator }: Pick<EventStreamOptions, 'maxEventSize' | 'terminator'> & {
+  stream: EventStreamInput;
+}): AsyncGenerator<TData>;
 /**
- * What the client resolves a streamed call to: the body as a stream or a decoded value, its content type, and the native response.
+ * The `text/event-stream` handler. A whole body, such as an error, is read as text.
  */
-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;
-};
+export declare const eventStream: MediaType;
 /**
- * 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.
+ * The JSON Lines handler. A whole body, such as an error, is read as text.
  */
-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>>;
+export declare const jsonLines: MediaType;
 /**
- * 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.
+ * The Server-Sent Events and JSON Lines handlers, registered when the document streams.
  */
-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 declare const streamMediaTypes: MediaTypes;
 export {};

package/dist/templates/standardSchema.d.ts

@@ -1,2 +1,81 @@
-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 };
+/**
+ * A Standard Schema validator, such as a Zod, Valibot, or ArkType schema.
+ */
+export type StandardSchemaValidator<TOutput = unknown> = {
+  readonly '~standard': {
+    validate(value: unknown): StandardSchemaResult<TOutput> | Promise<StandardSchemaResult<TOutput>>;
+  };
+};
+export type StandardSchemaResult<TOutput> = {
+  readonly value: TOutput;
+  readonly issues?: undefined;
+} | {
+  readonly issues: ReadonlyArray<StandardSchemaIssue>;
+};
+export type StandardSchemaIssue = {
+  readonly message?: string;
+  readonly path?: ReadonlyArray<PropertyKey | {
+    readonly key: PropertyKey;
+  }> | undefined;
+};
+/**
+ * Thrown when validation fails, with the schema's `issues`.
+ */
+export declare class ParseError extends Error {
+  readonly issues: ReadonlyArray<StandardSchemaIssue>;
+  readonly cause?: unknown;
+  constructor({ issues, message, cause }: {
+    issues: ReadonlyArray<StandardSchemaIssue>;
+    message?: string;
+    cause?: unknown;
+  });
+}
+/**
+ * Returns the parsed value, or throws a `ParseError` with the schema's `issues`.
+ */
+export declare function validateStandardSchema<TOutput>(schema: StandardSchemaValidator<TOutput>, value: unknown): Promise<TOutput>;
+/**
+ * Wraps an object schema so its keys match in any letter case. `entries` are the keys the schema declares.
+ *
+ * @example
+ * ```ts
+ * validator: { headers: toHeadersStandardSchema(putEventHeadersSchema, putEventHeadersSchema.shape) }
+ * ```
+ */
+export declare function toHeadersStandardSchema(schema: StandardSchemaValidator, entries: Record<string, unknown>): StandardSchemaValidator;
+/**
+ * Which value and request failed validation.
+ */
+export type ValidationErrorContext = {
+  value: unknown;
+  direction: 'request' | 'response' | 'error';
+  source: 'body' | 'path' | 'query' | 'headers' | 'cookies';
+  method?: string | undefined;
+  url?: string | undefined;
+  status?: number | undefined;
+};
+/**
+ * Return `{ value }` to use instead of a failed value. Return nothing to rethrow the `ParseError`.
+ */
+export type ValidationErrorHandler = (error: ParseError, context: ValidationErrorContext) => {
+  value: unknown;
+} | void | Promise<{
+  value: unknown;
+} | void>;
+/**
+ * Turns generated validation on or off, for every direction or per direction.
+ * @default true
+ */
+export type ValidateOption = boolean | {
+  request?: boolean;
+  params?: boolean;
+  response?: boolean;
+  error?: boolean;
+};
+export declare function isValidationEnabled(validate: ValidateOption | undefined, direction: 'request' | 'params' | 'response' | 'error'): boolean;
+export declare function runValidator<T>({ validator, value, context, onValidationError }: {
+  validator: StandardSchemaValidator<T> | undefined;
+  value: T;
+  context: Omit<ValidationErrorContext, 'value'>;
+  onValidationError: ValidationErrorHandler | undefined;
+}): Promise<T>;

package/docs/guides/authentication.md

@@ -7,7 +7,7 @@ Auth lives in your `client`. The plugin does not send credentials itself. It tel
 Each generated function passes the operation's security schemes from the spec as `security`:
 
 ```typescript
-request({
+apiClient<GetPetByIdResponses, ThrowOnError>({
   method: 'GET',
   url: '/pet/{petId}',
   security: [{ type: 'apiKey', name: 'api_key', in: 'header' }, { type: 'oauth2' }],
@@ -15,8 +15,16 @@ request({
 })
 ```
 
+Each entry is one security requirement, and meeting one is enough. A requirement that needs several schemes together, such as an API key and a session cookie, is an array, and your client sends all of them: `security: [[{ type: 'apiKey', name: 'api_key', in: 'header' }, { type: 'apiKey', name: 'sid', in: 'cookie' }]]`.
+
 An operation without security requirements passes no `security` field. Use that to skip auth on public endpoints.
 
+An `oauth2` entry carries its `flows` with their URLs, and its `metadataUrl` when the spec sets `oauth2MetadataUrl`. An `openIdConnect` entry carries its discovery `url`. Your client can use them to run the flow, such as the OpenAPI 3.2 `deviceAuthorization` flow, and then send the token as a bearer token:
+
+```typescript
+security: [{ type: 'oauth2', flows: { deviceAuthorization: { deviceAuthorizationUrl: 'https://auth.example.com/device', tokenUrl: 'https://auth.example.com/token' } }, scopes: ['read'] }]
+```
+
 ## Add a bearer token from an async source
 
 The client can `await` anything before it sends the request. The client below awaits a token function you register with `setAuth`, so the token can come from a secrets store or a refresh call:
@@ -54,7 +62,7 @@ setAuth(async () => readTokenFromSecretsStore())
 
 ## Sign requests or use several auth methods
 
-Read `config.security` and pick per operation, or pass a different `client` on a call. This works for request signing, such as AWS SigV4, and for services that use different credentials:
+Read `config.security` and pick per operation, or pass a different `client` on a call. Both ways work for request signing, such as AWS SigV4, and for services that use different credentials:
 
 ```typescript
 import { createSignedClient } from './clients/iam'
@@ -62,4 +70,6 @@ import { createSignedClient } from './clients/iam'
 await getPetById({ path: { petId: 1 }, client: createSignedClient() })
 ```
 
+The examples set [`integerType: 'number'`](https://kubb.dev/extensions/kubb-labs/adapter-oas/options#integertype) on the adapter, so an `int64` id such as `petId` is a `number`. With the default it is a `bigint` and the call takes `1n`.
+
 A client passed on a call replaces the default for that call only.

package/docs/guides/calling-operations.md

@@ -8,20 +8,22 @@ import { addPet, getPetById } from './gen/clients'
 const created = await addPet({ body: { name: 'Odie', photoUrls: [] } })
 console.log(created.data, created.response.status)
 
-const pet = await getPetById({ path: { petId: 1n } })
+const pet = await getPetById({ path: { petId: 1 } })
 ```
 
-The keys are `path`, `query`, `headers`, and `body`. Kubb types each from the spec, so a wrong key or value fails at compile time.
+The examples set [`integerType: 'number'`](https://kubb.dev/extensions/kubb-labs/adapter-oas/options#integertype) on the adapter, so an `int64` id such as `petId` is a `number`. With the default it is a `bigint` and the call takes `1n`.
+
+The keys are `path`, `query`, `headers`, `cookies`, and `body`. Kubb types each from the spec, so a wrong key or value fails at compile time.
 
 ## Errors
 
-`throwOnError` defaults to `true` (see [`throwOnErrorDefault`](https://kubb.dev/extensions/kubb-labs/plugin-client/options#throwonerrordefault)). What that means is up to your client. With the example client, a non-2xx status throws, and `throwOnError: false` returns the error as a value:
+`throwOnError` defaults to `true` (see [`throwOnErrorDefault`](https://kubb.dev/extensions/kubb-labs/plugin-client/options#throwonerrordefault)). What that means is up to your client. With the [minimal client](https://kubb.dev/extensions/kubb-labs/plugin-client/guides/write-your-client#a-minimal-client), a non-2xx status throws, and `throwOnError: false` returns the error as a value:
 
 ```typescript
-const result = await getPetById({ path: { petId: 1n }, throwOnError: false })
+const result = await getPetById({ path: { petId: 1 }, throwOnError: false })
 
 if (result.error === undefined) {
-  console.log('pet', result.data.name)
+  console.log('pet', result.data)
 }
 if (result.error !== undefined) {
   console.log('failed', result.response.status)
@@ -33,5 +35,5 @@ if (result.error !== undefined) {
 Pass `client` to send one call through another function:
 
 ```typescript
-await getPetById({ path: { petId: 2n }, client: tenantClient })
+await getPetById({ path: { petId: 2 }, client: tenantClient })
 ```