@kubb/plugin-client 5.12.0 → 6.0.1

package/dist/client-BxO6Dygu.d.ts

@@ -1,355 +0,0 @@
-import { _ as Serializers, h as RequestBody, o as HeadersInit, s as HttpMethod, v as Styles } from "./serializers-Ds8zZwOO.js";
-import { a as ValidateOption, i as StandardSchemaValidator, s as ValidationErrorHandler } from "./standardSchema-BShJWz2i.js";
-/**
- * HTTP status codes treated as a success, everything else is an error.
- */
-type SuccessStatusCode = '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226';
-type SuccessOf<TResponses> = TResponses[Extract<keyof TResponses, SuccessStatusCode>];
-type ErrorOf<TResponses> = TResponses[Exclude<keyof TResponses, SuccessStatusCode>];
-/**
- * Converts a response record's string status key to its numeric literal, leaving non-numeric keys like `default` as `number`.
- */
-type ToStatusNumber<TStatus> = TStatus extends `${infer TNumber extends number}` ? TNumber : number;
-/**
- * Unwraps content-type variants to keep the bare body on `error`.
- */
-type DataOf<T> = T extends {
-  contentType: string;
-  data: infer TData;
-} ? TData : T;
-/**
- * Keeps `contentType` beside `data` so switching on it narrows the body.
- */
-type SuccessVariant<TStatus, TEntry, TRequest, TResponse> = TEntry extends {
-  contentType: string;
-  data: unknown;
-} ? TEntry extends {
-  contentType: infer TContentType;
-  data: infer TData;
-} ? {
-  status: ToStatusNumber<TStatus>;
-  data: TData;
-  error: undefined;
-  contentType: TContentType;
-  request: TRequest;
-  response: TResponse;
-} : never : {
-  status: ToStatusNumber<TStatus>;
-  data: TEntry;
-  error: undefined;
-  contentType: string | undefined;
-  request: TRequest;
-  response: TResponse;
-};
-/**
- * Narrows `data` or `error` when switching on the numeric status.
- */
-type ResultByStatus<TResponses, TStatus extends keyof TResponses, TRequest, TResponse> = TStatus extends SuccessStatusCode ? SuccessVariant<TStatus, TResponses[TStatus], TRequest, TResponse> : {
-  status: ToStatusNumber<TStatus>;
-  data: undefined;
-  error: DataOf<TResponses[TStatus]>;
-  contentType: string | undefined;
-  request: TRequest;
-  response: TResponse;
-};
-type ResultUnion<TResponses, TRequest, TResponse> = { [TStatus in keyof TResponses]: ResultByStatus<TResponses, TStatus, TRequest, TResponse>; }[keyof TResponses];
-/**
- * Selects success statuses without letting untyped error payloads widen `data`.
- */
-type SuccessResultUnion<TResponses, TRequest, TResponse> = { [TStatus in Extract<keyof TResponses, SuccessStatusCode>]: ResultByStatus<TResponses, TStatus, TRequest, TResponse>; }[Extract<keyof TResponses, SuccessStatusCode>];
-/**
- * Narrows `data` and `error` by status. With `throwOnError`, includes only success variants.
- */
-type RequestResult<TResponses, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse> = ThrowOnError extends true ? [SuccessResultUnion<TResponses, TRequest, TResponse>] extends [never] ? {
-  status: number;
-  data: SuccessOf<TResponses>;
-  error: undefined;
-  contentType: string | undefined;
-  request: TRequest;
-  response: TResponse;
-} : SuccessResultUnion<TResponses, TRequest, TResponse> : [ResultUnion<TResponses, TRequest, TResponse>] extends [never] ? {
-  status: number;
-  data: undefined;
-  error: undefined;
-  contentType: string | undefined;
-  request: TRequest;
-  response: TResponse;
-} : ResultUnion<TResponses, TRequest, TResponse>;
-/**
- * A `RequestResult` promise with an extra `unwrap()` method that resolves to the success body.
- */
-type Unwrappable<T extends {
-  data: unknown;
-  error: unknown;
-}> = Promise<T> & {
-  unwrap: () => Promise<Extract<T, {
-    error: undefined;
-  }>['data']>;
-};
-/**
- * Attaches `unwrap()` to a result promise, which rejects with `error` when the result carried one.
- *
- * @example
- * ```ts
- * const { data, error } = await getPetById({ path: { petId: 1 } })
- * ```
- *
- * @example
- * ```ts
- * const pet = await getPetById({ path: { petId: 1 } }).unwrap()
- * ```
- */
-declare function withUnwrap<T extends {
-  data: unknown;
-  error: unknown;
-}>(promise: Promise<T>): Unwrappable<T>;
-/**
- * The shape a generated operation returns with `returnType: 'data'`: the success body when
- * `throwOnError` is true, or the full `RequestResult` when it is false.
- */
-type UnwrappedResult<TResponses, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse> = ThrowOnError extends true ? RequestResult<TResponses, true, TRequest, TResponse>['data'] : RequestResult<TResponses, ThrowOnError, TRequest, TResponse>;
-/**
- * Returns the success body when `throwOnError` is true, or the full result when it is false.
- */
-declare function unwrapResult<T extends {
-  data: unknown;
-  error: unknown;
-}>(promise: Promise<T>, throwOnError: boolean | undefined): Promise<T | T['data']>;
-type DataShape = {
-  body?: unknown;
-  cookies?: unknown;
-  headers?: unknown;
-  path?: unknown;
-  query?: unknown;
-};
-type RequestCredentials = 'omit' | 'same-origin' | 'include';
-type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream' | 'formdata';
-/**
- * Parser per response content type. Generated when one success response declares several content
- * types that do not share a single parser. Keys are base media types, such as `audio/mpeg` or `audio/*`.
- */
-type ResponseTypeMap = Record<string, ResponseType>;
-/**
- * Decodes a response body for a codec's media type.
- */
-type Deserializer<T = unknown> = (raw: unknown, contentType: string) => T | Promise<T>;
-/**
- * Encodes a request body for a codec's media type.
- */
-type ContentBodySerializer = (body: unknown, contentType?: string) => RequestBody | undefined;
-/**
- * Encodes requests or decodes responses for a media type. Either direction can be omitted.
- */
-type Codec = {
-  serialize?: ContentBodySerializer;
-  deserialize?: Deserializer;
-};
-/**
- * A string sets the request content type. The object form can also set `Accept`.
- */
-type ContentType = string | {
-  request?: string;
-  response?: string;
-};
-/**
- * Validates request bodies and params, success bodies, or non-throwing error bodies with Standard Schema.
- */
-type Validator<T = unknown> = StandardSchemaValidator<T>;
-/**
- * A resolved security scheme carried on each generated call's `security` array and passed to the `auth` resolver.
- */
-type Auth = {
-  type: 'http' | 'apiKey' | 'oauth2' | 'openIdConnect';
-  scheme?: 'bearer' | 'basic';
-  name?: string;
-  in?: 'header' | 'query' | 'cookie';
-  scopes?: Array<string>;
-};
-/**
- * Return `user:password` for basic auth, or `undefined` to skip a scheme.
- */
-type AuthToken = string | undefined;
-/**
- * Resolves the token for a security scheme, either a static token or a callback called per scheme until one returns a token.
- */
-type AuthResolver = AuthToken | ((auth: Auth) => AuthToken | Promise<AuthToken>);
-type RequestConfig<TBody = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = {
-  baseURL?: string;
-  url?: string;
-  method?: HttpMethod;
-  path?: unknown;
-  query?: unknown;
-  /** Alias of `query`, kept for callers that pass the query under this name. */
-  params?: unknown;
-  cookies?: unknown;
-  body?: TBody;
-  headers?: unknown;
-  styles?: Styles;
-  signal?: AbortSignal;
-  credentials?: RequestCredentials;
-  options?: Record<string, unknown>;
-  contentType?: ContentType;
-  responseType?: ResponseType | ResponseTypeMap;
-  throwOnError?: boolean;
-  client?: ClientInstance<TRequest, TResponse>;
-  transport?: Transport<TRequest, TResponse>;
-  serializer?: Serializers;
-  codecs?: Record<string, Codec>;
-  validator?: {
-    request?: Validator;
-    path?: Validator;
-    query?: Validator;
-    headers?: Validator;
-    response?: Validator;
-    error?: Validator;
-  };
-  onValidationError?: ValidationErrorHandler;
-  validate?: ValidateOption;
-  security?: Array<Auth>;
-  auth?: AuthResolver;
-};
-/**
- * Combines client options with the operation's typed request params and body.
- */
-type Options<TData extends DataShape, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse> = Omit<RequestConfig<unknown, TRequest, TResponse>, keyof DataShape | 'url'> & TData & {
-  client?: ClientInstance<TRequest, TResponse>;
-  throwOnError?: ThrowOnError;
-};
-/**
- * Client-level configuration shared by every call an instance makes, overridden by the per-call `RequestConfig`.
- */
-type ClientConfig<TRequest = NativeRequest, TResponse = NativeResponse> = {
-  baseURL?: string;
-  headers?: HeadersInit;
-  credentials?: RequestCredentials;
-  options?: Record<string, unknown>;
-  throwOnError?: boolean;
-  transport?: Transport<TRequest, TResponse>;
-  serializer?: Serializers;
-  codecs?: Record<string, Codec>;
-  onValidationError?: ValidationErrorHandler;
-  validate?: ValidateOption;
-  auth?: AuthResolver;
-};
-/**
- * The normalized request the transport receives, with all serialization, auth, and header work already done.
- */
-type ResolvedRequest = {
-  url: string;
-  method: string;
-  headers: Record<string, string>;
-  body?: RequestBody;
-  signal?: AbortSignal;
-  credentials?: RequestCredentials;
-  options?: Record<string, unknown>;
-  responseType?: ResponseType | ResponseTypeMap;
-};
-/**
- * What a transport returns: the parsed body plus the native request and response objects.
- */
-type TransportResult<TData = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = {
-  data: TData;
-  status: number;
-  statusText: string;
-  headers: Headers;
-  contentType?: string;
-  request: TRequest;
-  response: TResponse;
-};
-/**
- * The per-plugin send, supplied to `createClientCore` as `defaultTransport`.
- */
-type Transport<TRequest = NativeRequest, TResponse = NativeResponse> = (request: ResolvedRequest) => Promise<TransportResult<unknown, TRequest, TResponse>>;
-type CallResult<TRequest = NativeRequest, TResponse = NativeResponse> = {
-  status: number;
-  data: unknown;
-  error: unknown;
-  contentType: string | undefined;
-  request: TRequest;
-  response: TResponse;
-};
-type InterceptorFn<T, TContext = never> = (value: T, context?: TContext) => T | Promise<T>;
-/**
- * A single interceptor channel with a transport-agnostic `use` / `eject` / `update` API.
- */
-type InterceptorStack<T, TContext = never> = {
-  use: (fn: InterceptorFn<T, TContext>) => number;
-  eject: (id: number) => void;
-  update: (id: number, fn: InterceptorFn<T, TContext>) => void;
-  run: (value: T, context?: TContext) => Promise<T>;
-};
-type Interceptors<TRequest = NativeRequest, TResponse = NativeResponse> = {
-  request: InterceptorStack<ResolvedRequest, RequestConfig<unknown, TRequest, TResponse>>;
-  response: InterceptorStack<TransportResult<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>;
-  error: InterceptorStack<ResponseError<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>;
-};
-type UrlConfig = Pick<RequestConfig, 'baseURL' | 'url' | 'path' | 'query' | 'params' | 'serializer' | 'styles'>;
-/**
- * A client instance: the callable send plus configuration, interceptors, and an isolated
- * `createClient` factory bound to the same transport.
- */
-type ClientInstance<TRequest = NativeRequest, TResponse = NativeResponse> = {
-  <TBody = unknown>(config: RequestConfig<TBody, TRequest, TResponse>): Promise<CallResult<TRequest, TResponse>>;
-  getConfig: () => ClientConfig<TRequest, TResponse>;
-  setConfig: (config: ClientConfig<TRequest, TResponse>) => ClientConfig<TRequest, TResponse>;
-  getUrl: (config: UrlConfig) => string;
-  interceptors: Interceptors<TRequest, TResponse>;
-  createClient: (config?: ClientConfig<TRequest, TResponse>) => ClientInstance<TRequest, TResponse>;
-};
-/**
- * Thrown for a non-2xx response, so a resolved call always means success.
- */
-declare class ResponseError<TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse> extends Error {
-  data: TError;
-  status: number;
-  statusText: string;
-  contentType: string | undefined;
-  request: TRequest;
-  response: TResponse;
-  constructor(config: {
-    data: TError;
-    status: number;
-    statusText: string;
-    contentType?: string;
-    request: TRequest;
-    response: TResponse;
-    method?: string;
-    url?: string;
-  });
-  /**
-   * Matches on `name`, not `instanceof`: every generated client bundles its own `ResponseError` class.
-   */
-  static is(error: unknown): error is ResponseError<unknown, unknown, unknown>;
-}
-type ResponseErrorConfig<TError = unknown> = ResponseError<TError>;
-/**
- * Creates a transport-agnostic interceptor channel that runs interceptors in registration order.
- */
-declare function createInterceptorStack<T, TContext = never>(): InterceptorStack<T, TContext>;
-/**
- * Walks the per-operation security in order and places the first resolved token on the request, mutating `headers` / `query` in place.
- */
-declare function resolveAuth(params: {
-  security: Array<Auth> | undefined;
-  auth: AuthResolver | undefined;
-  headers: Record<string, string>;
-  query: Record<string, unknown>;
-}): Promise<void>;
-/** A body a transport left as a stream: a web `ReadableStream` or an async iterable such as a Node readable. */
-declare function isStreamed(data: unknown): data is ReadableStream<Uint8Array> | AsyncIterable<Uint8Array | string>;
-/**
- * Picks the parser for a response. A string `responseType` wins. A map is matched against the media type: the exact
- * type, then a wildcard such as `audio/*`, then a catch-all entry. Otherwise the parser is guessed from the media type.
- */
-declare function resolveResponseType(responseType: ResponseType | ResponseTypeMap | undefined, contentType: string | null | undefined): ResponseType | undefined;
-/** The media type of the `Content-Type` response header, without its parameters. */
-declare function getResponseContentType(headers: Headers | Record<string, string> | undefined): string | undefined;
-/**
- * Creates an isolated client using the supplied default transport.
- */
-declare function createClientCore<TRequest = NativeRequest, TResponse = NativeResponse>(options: {
-  defaultTransport: Transport<TRequest, TResponse>;
-} & ClientConfig<TRequest, TResponse>): ClientInstance<TRequest, TResponse>;
-type NativeRequest = unknown;
-type NativeResponse = unknown;
-export { SuccessOf as A, Validator as B, ResolvedRequest as C, ResponseTypeMap as D, ResponseType as E, Transport as F, resolveAuth as G, createInterceptorStack as H, TransportResult as I, withUnwrap as J, resolveResponseType as K, Unwrappable as L, SuccessStatusCode as M, SuccessVariant as N, ResultByStatus as O, ToStatusNumber as P, UnwrappedResult as R, RequestResult as S, ResponseErrorConfig as T, getResponseContentType as U, createClientCore as V, isStreamed as W, InterceptorStack as _, AuthToken as a, RequestConfig as b, ClientInstance as c, ContentType as d, DataOf as f, InterceptorFn as g, ErrorOf as h, AuthResolver as i, SuccessResultUnion as j, ResultUnion as k, Codec as l, Deserializer as m, NativeResponse as n, CallResult as o, DataShape as p, unwrapResult as q, Auth as r, ClientConfig as s, NativeRequest as t, ContentBodySerializer as u, Interceptors as v, ResponseError as w, RequestCredentials as x, Options as y, UrlConfig as z };

package/dist/serializers-Ds8zZwOO.d.ts

@@ -1,190 +0,0 @@
-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

@@ -1,104 +0,0 @@
-/**
- * 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 };