@kubb/plugin-client 5.12.0-canary.20261109T134631 → 6.0.0

package/dist/serializers-BRgfPGr1.d.ts

@@ -0,0 +1,119 @@
+type HeaderValue = string | number | boolean | null | undefined | object;
+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.
+ */
+type RequestBody = NonNullable<RequestInit['body']>;
+type HttpMethod = 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'QUERY' | 'TRACE' | (string & {});
+/**
+ * The OpenAPI query style. `form` is the default.
+ */
+type QueryStyle = 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+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;
+};
+/**
+ * `querystring` marks an OpenAPI 3.2 `in: querystring` parameter, sent as the whole query string.
+ */
+type QueryParamStyle = SerializationStyle<QueryStyle> & ParamContentType & {
+  querystring?: boolean;
+};
+/**
+ * Turns the query object into a search string, following each parameter's OpenAPI style when given.
+ */
+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.
+ */
+type CookieParamStyle = ParamContentType & {
+  style?: 'form' | 'cookie';
+  explode?: boolean;
+};
+type HeaderParamStyle = ParamContentType & {
+  explode?: boolean;
+};
+/**
+ * The OpenAPI `encoding` of one form body property. `contentType` sets a multipart part's media type.
+ */
+type BodyEncoding = SerializationStyle<QueryStyle> & {
+  contentType?: string;
+};
+/**
+ * The OpenAPI path style. `simple` is the default.
+ */
+type PathStyle = 'simple' | 'label' | 'matrix';
+type PathParamStyle = SerializationStyle<PathStyle>;
+/**
+ * Joins the cookie parameters of a call into a `Cookie` header value.
+ */
+type CookieSerializer = (cookies: Record<string, unknown>, styles?: Record<string, CookieParamStyle>) => string;
+/**
+ * Serializes the header parameters of a call that are arrays or objects.
+ */
+type HeaderSerializer = (headers: HeadersInit | undefined, styles?: Record<string, HeaderParamStyle>) => HeadersInit | undefined;
+/**
+ * Turns one path parameter into its URL segment.
+ */
+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`.
+ */
+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`.
+ */
+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.
+ */
+declare function jsonReplacer(_key: string, value: unknown): unknown;
+/**
+ * A `Content-Type` without its parameters, in lower case.
+ */
+declare function baseContentType(value: string | null | undefined): string | undefined;
+/**
+ * Whether a media type is JSON, such as `application/json` or `application/problem+json`.
+ */
+declare function isJsonMediaType(contentType: string | null | undefined): boolean;
+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.
+ */
+declare function toValue(value: unknown): string;
+declare function encodeComponent(value: unknown): string;
+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]`.
+ */
+declare function serializeDefaultQueryParam(key: string, value: unknown): Array<string>;
+export { isRecord as C, toValue as D, serializeDefaultQueryParam as E, isJsonMediaType as S, notNullish as T, SerializationStyle as _, HeaderSerializer as a, baseContentType as b, HttpMethod as c, PathSerializer as d, PathStyle as f, RequestBody as g, QueryStyle as h, HeaderParamStyle as i, ParamContentType as l, QuerySerializer as m, CookieParamStyle as n, HeaderValue as o, QueryParamStyle as p, CookieSerializer as r, HeadersInit as s, BodyEncoding as t, PathParamStyle as u, Serializers as v, jsonReplacer as w, encodeComponent as x, Styles as y };

package/dist/{standardSchema-BShJWz2i.d.ts → standardSchema-CGuiSK7F.d.ts}

@@ -1,60 +1,42 @@
 /**
- * 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.
+ * A Standard Schema validator, such as a Zod, Valibot, or ArkType schema.
  */
 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;
-  }>;
+  }> | undefined;
 };
 /**
- * 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.
+ * Thrown when validation fails, with the schema's `issues`.
  */
 declare class ParseError extends Error {
   readonly issues: ReadonlyArray<StandardSchemaIssue>;
-  constructor({ issues, message }: {
+  readonly cause?: unknown;
+  constructor({ issues, message, cause }: {
     issues: ReadonlyArray<StandardSchemaIssue>;
     message?: string;
+    cause?: unknown;
   });
 }
 /**
- * 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)
+ * Returns the parsed value, or throws a `ParseError` with the schema's `issues`.
  */
 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.
+ * Wraps an object schema so its keys match in any letter case. `entries` are the keys the schema declares.
  *
- * @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) }
@@ -62,18 +44,18 @@ declare function validateStandardSchema<TOutput>(schema: StandardSchemaValidator
  */
 declare function toHeadersStandardSchema(schema: StandardSchemaValidator, entries: Record<string, unknown>): StandardSchemaValidator;
 /**
- * Identifies the value and request that failed validation in `onValidationError`.
+ * Which value and request failed validation.
  */
 type ValidationErrorContext = {
   value: unknown;
   direction: 'request' | 'response' | 'error';
-  source: 'body' | 'path' | 'query' | 'headers';
-  method?: string;
-  url?: string;
-  status?: number;
+  source: 'body' | 'path' | 'query' | 'headers' | 'cookies';
+  method?: string | undefined;
+  url?: string | undefined;
+  status?: number | undefined;
 };
 /**
- * Return `{ value }` to substitute a failed value, including `undefined`. Returning nothing rethrows the `ParseError`.
+ * Return `{ value }` to use instead of a failed value. Return nothing to rethrow the `ParseError`.
  */
 type ValidationErrorHandler = (error: ParseError, context: ValidationErrorContext) => {
   value: unknown;
@@ -81,8 +63,7 @@ type ValidationErrorHandler = (error: ParseError, context: ValidationErrorContex
   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.
+ * Turns generated validation on or off, for every direction or per direction.
  * @default true
  */
 type ValidateOption = boolean | {
@@ -92,9 +73,6 @@ type ValidateOption = 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;

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-Dq0z61hu.js";
+import { a as ValidateOption, o as ValidationErrorContext, s as ValidationErrorHandler } from "../standardSchema-CGuiSK7F.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-Dq0z61hu.js";
+import { a as ValidateOption, o as ValidationErrorContext, s as ValidationErrorHandler } from "../standardSchema-CGuiSK7F.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-Dq0z61hu.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-Dq0z61hu.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-Dq0z61hu.js";
+export { MediaType, MediaTypeContext, MediaTypes, defaultMediaTypes, isEncodedBody, parseJson, resolveMediaType };

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

@@ -0,0 +1,5 @@
+import { r as CookieSerializer } from "../../serializers-BRgfPGr1.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 { a as HeaderSerializer } from "../../serializers-BRgfPGr1.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 { d as PathSerializer } from "../../serializers-BRgfPGr1.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 { d as PathSerializer } from "../../serializers-BRgfPGr1.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 { m as QuerySerializer } from "../../serializers-BRgfPGr1.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 { m as QuerySerializer, p as QueryParamStyle } from "../../serializers-BRgfPGr1.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,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 };
+import { C as isRecord, D as toValue, E as serializeDefaultQueryParam, S as isJsonMediaType, T as notNullish, _ as SerializationStyle, a as HeaderSerializer, b as baseContentType, c as HttpMethod, d as PathSerializer, f as PathStyle, g as RequestBody, h as QueryStyle, i as HeaderParamStyle, l as ParamContentType, m as QuerySerializer, n as CookieParamStyle, o as HeaderValue, p as QueryParamStyle, r as CookieSerializer, s as HeadersInit, t as BodyEncoding, u as PathParamStyle, v as Serializers, w as jsonReplacer, x as encodeComponent, y as Styles } from "../serializers-BRgfPGr1.js";
+export { BodyEncoding, CookieParamStyle, CookieSerializer, HeaderParamStyle, HeaderSerializer, HeaderValue, HeadersInit, HttpMethod, ParamContentType, PathParamStyle, PathSerializer, PathStyle, QueryParamStyle, QuerySerializer, QueryStyle, RequestBody, SerializationStyle, Serializers, Styles, baseContentType, encodeComponent, isJsonMediaType, isRecord, jsonReplacer, notNullish, serializeDefaultQueryParam, toValue };

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-Dq0z61hu.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,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";
+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-CGuiSK7F.js";
 export { ParseError, StandardSchemaIssue, StandardSchemaResult, StandardSchemaValidator, ValidateOption, ValidationErrorContext, ValidationErrorHandler, isValidationEnabled, runValidator, toHeadersStandardSchema, validateStandardSchema };

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: