@kubb/plugin-client 5.12.0 → 6.0.0

package/README.md

@@ -10,7 +10,7 @@ pluginClient({ importPath: '../api/client' })
 
 `importPath` is written into each generated import as-is, so it must resolve from the generated operation file (for example `../../../client`, or a package or alias specifier). The module must export `client`, plus the `Options` and `RequestResult` types. Generated operations call `client` with a config containing `method`, `url`, and the operation options, and return its promise typed as `RequestResult`. There are no `withUnwrap` or `unwrapResult` helpers to write, and `returnType` is not an option.
 
-If your spec has server-sent event operations, also export `toEventStream` and the `EventStreamResult`, `SuccessOf`, and `TypedEvent` types. A generated function calls `toEventStream<TData>(promise)` with the promise your `client` returns and nothing else, and leaves the response validator on `config.validator.response`, so your module decides how to validate events.
+If your spec has server-sent event or JSON Lines operations, `client` also needs a `stream` method, and the module exports the `StreamResult`, `SuccessOf`, `TypedEvent`, and `ServerSentEvent` types. A generated function calls `client.stream<TResponses, ThrowOnError, TItem>(config)` and returns its `StreamResult`. `TItem` is `TypedEvent<…>` when the document names each event, and `ServerSentEvent<…>` when it types only the payload. The call keeps the response validator on `config.validator.response`, so your module decides how to validate items.
 
 Set the base URL, auth, retries, and any other behavior inside your `client`. `sdk`, `returnType`, and `baseURL` are not options of this plugin. `validator: 'zod'` needs `pluginZod()` in the plugins, and generation stops with an error if it is missing. Your `client` receives the schemas on `config.validator` (`{ request?, response?, error? }`), so add that field to your `RequestConfig` and run them yourself.
 

package/dist/client-Dq0z61hu.d.ts

@@ -0,0 +1,554 @@
+import { c as HttpMethod, g as RequestBody, s as HeadersInit, v as Serializers, y as Styles } from "./serializers-BRgfPGr1.js";
+import { a as ValidateOption, i as StandardSchemaValidator, s as ValidationErrorHandler } from "./standardSchema-CGuiSK7F.js";
+/**
+ * What a media type handler gets next to the body.
+ */
+type MediaTypeContext = {
+  contentType: string;
+  /**
+   * The response status, or `undefined` while a request body is encoded.
+   */
+  status?: number | undefined;
+  signal?: AbortSignal | undefined;
+  config: Omit<RequestConfig, 'client' | 'transport'> & EventStreamOptions;
+  /**
+   * Where a stream records the last event ID it read, for `StreamResult.lastEventId`.
+   */
+  cursor?: {
+    lastEventId: string;
+  } | undefined;
+};
+/**
+ * Encodes and decodes bodies of one media type. Every method is optional.
+ */
+type MediaType = {
+  encode?: (body: unknown, context: MediaTypeContext) => RequestBody | undefined;
+  decode?: (response: Response, context: MediaTypeContext) => unknown;
+  /**
+   * Reads a 2xx body item by item. Each item is validated with `validator.response`.
+   */
+  stream?: (body: ReadableStream<Uint8Array>, context: MediaTypeContext) => AsyncIterable<unknown>;
+};
+/**
+ * Handlers keyed by media type. A key may be a pattern such as `application/*+json` or `text/*`.
+ */
+type MediaTypes = Record<string, MediaType>;
+/**
+ * Picks the handler for a `Content-Type`: the exact type, then its `+suffix`, then `type/*`, then the catch-all. With `use`, a
+ * handler without that method is skipped.
+ */
+declare function resolveMediaType({ mediaTypes, contentType, use }: {
+  mediaTypes: MediaTypes;
+  contentType: string | null | undefined;
+  use?: keyof MediaType;
+}): MediaType | undefined;
+/**
+ * Whether a body is already encoded, so every built-in media type sends it as is.
+ */
+declare function isEncodedBody(body: unknown): body is RequestBody;
+/**
+ * Parses JSON text, throwing a `ParseError` that names the content type when it is not valid JSON.
+ */
+declare function parseJson(text: string, contentType: string | undefined): unknown;
+/**
+ * The media types every client knows: JSON, text, binary, and a catch-all that sends JSON and reads JSON or text.
+ */
+declare const defaultMediaTypes: MediaTypes;
+/**
+ * The status keys that count as success. `2xx` covers every 2xx status.
+ */
+type SuccessStatusCode = '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '2xx';
+type SuccessOf<TResponses> = TResponses[Extract<keyof TResponses, SuccessStatusCode>];
+type ErrorOf<TResponses> = TResponses[Exclude<keyof TResponses, SuccessStatusCode>];
+type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type ToNumber<T> = T extends `${infer TNumber extends number}` ? TNumber : never;
+/**
+ * Maps a status key such as `404` or `4xx` to its numeric statuses. `default` becomes `number`.
+ */
+type ToStatusNumber<TStatus, TKeys = never> = TStatus extends `${infer TNumber extends number}` ? TNumber : TStatus extends `${infer TFirst extends '1' | '2' | '3' | '4' | '5'}xx` ? Exclude<ToNumber<`${TFirst}${Digit}${Digit}`>, ToNumber<TKeys>> : number;
+/**
+ * The `error` of a failed call without a body, so `if (error)` still sees the failure.
+ */
+type EmptyErrorBody = {
+  status: number;
+  statusText: string;
+};
+type DataOf<T> = T extends {
+  contentType: string;
+  data: infer TData;
+} ? TData : T;
+/**
+ * A response's `Headers`, whose `get` suggests the header names the spec declares. Values stay strings, as sent.
+ */
+type ResponseHeaders<THeaders = unknown> = Omit<Headers, 'get'> & {
+  get: (name: Extract<keyof THeaders, string> | (string & {})) => string | null;
+};
+type StreamContentType = `text/event-stream${string}` | `application/jsonl${string}` | `application/x-ndjson${string}` | `application/json-seq${string}` | `application/${string}+json-seq${string}`;
+type HeadersFor<THeaders, TStatus> = ResponseHeaders<TStatus extends keyof THeaders ? THeaders[TStatus] : unknown>;
+type SuccessVariant<TStatus, TEntry, TRequest, TResponse, TKeys = never, THeaders = unknown> = TEntry extends {
+  contentType: string;
+  data: unknown;
+} ? TEntry extends {
+  contentType: infer TContentType;
+  data: infer TData;
+} ? {
+  status: ToStatusNumber<TStatus, TKeys>;
+  data: TContentType extends StreamContentType ? ReadableStream<Uint8Array> : TData;
+  error: undefined;
+  contentType: TContentType;
+  headers: HeadersFor<THeaders, TStatus>;
+  request: TRequest;
+  response: TResponse;
+} : never : {
+  status: ToStatusNumber<TStatus, TKeys>;
+  data: TEntry;
+  error: undefined;
+  contentType: string | undefined;
+  headers: HeadersFor<THeaders, TStatus>;
+  request: TRequest;
+  response: TResponse;
+};
+type ResultByStatus<TResponses, TStatus extends keyof TResponses, TRequest, TResponse, THeaders = unknown> = TStatus extends SuccessStatusCode ? SuccessVariant<TStatus, TResponses[TStatus], TRequest, TResponse, keyof TResponses, THeaders> : {
+  status: ToStatusNumber<TStatus, keyof TResponses>;
+  data: undefined;
+  error: DataOf<TResponses[TStatus]> | EmptyErrorBody;
+  contentType: string | undefined;
+  headers: HeadersFor<THeaders, TStatus>;
+  request: TRequest;
+  response: TResponse;
+};
+type ResultUnion<TResponses, TRequest, TResponse, THeaders = unknown> = { [TStatus in keyof TResponses]: ResultByStatus<TResponses, TStatus, TRequest, TResponse, THeaders>; }[keyof TResponses];
+type SuccessResultUnion<TResponses, TRequest, TResponse, THeaders = unknown> = { [TStatus in Extract<keyof TResponses, SuccessStatusCode>]: ResultByStatus<TResponses, TStatus, TRequest, TResponse, THeaders>; }[Extract<keyof TResponses, SuccessStatusCode>];
+/**
+ * The result of a call, narrowed by `status`. With `throwOnError`, it holds only the success variants. `THeaders` keys the
+ * declared response headers by status like the responses record, so `headers.get` suggests them for the narrowed status.
+ */
+type RequestResult<TResponses, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse, THeaders = unknown> = ThrowOnError extends true ? [SuccessResultUnion<TResponses, TRequest, TResponse, THeaders>] extends [never] ? {
+  status: number;
+  data: SuccessOf<TResponses>;
+  error: undefined;
+  contentType: string | undefined;
+  headers: ResponseHeaders;
+  request: TRequest;
+  response: TResponse;
+} : SuccessResultUnion<TResponses, TRequest, TResponse, THeaders> : [ResultUnion<TResponses, TRequest, TResponse, THeaders>] extends [never] ? {
+  status: number;
+  data: undefined;
+  error: undefined;
+  contentType: string | undefined;
+  headers: ResponseHeaders;
+  request: TRequest;
+  response: TResponse;
+} : ResultUnion<TResponses, TRequest, TResponse, THeaders>;
+/**
+ * `RequestResult` with the declared response headers by status: `RequestResultWithHeaders<ListPetsResponses, { '200': ListPetsStatus200Headers }>`.
+ */
+type RequestResultWithHeaders<TResponses, THeaders, ThrowOnError extends boolean = true> = RequestResult<TResponses, ThrowOnError, NativeRequest, NativeResponse, THeaders>;
+/**
+ * A result promise whose `unwrap()` resolves to the success body.
+ */
+type Unwrappable<T extends {
+  data: unknown;
+  error: unknown;
+}> = Promise<T> & {
+  unwrap: () => Promise<Extract<T, {
+    error: undefined;
+  }>['data']>;
+};
+/**
+ * Adds `unwrap()` to a result promise. It rejects with `error` when the result has one.
+ */
+declare function withUnwrap<T extends {
+  data: unknown;
+  error: unknown;
+}>(promise: Promise<T>): Unwrappable<T>;
+type Unwrapped<T, ThrowOnError extends boolean> = ThrowOnError extends true ? (T extends {
+  data: infer TData;
+} ? TData : never) : T;
+/**
+ * What an operation returns with `returnType: 'data'`: the success body, or the full result when `throwOnError` is false.
+ */
+type UnwrappedResult<TResponses, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse, THeaders = unknown> = Unwrapped<RequestResult<TResponses, ThrowOnError, TRequest, TResponse, THeaders>, ThrowOnError>;
+/**
+ * `UnwrappedResult` with the declared response headers by status, for the full result a `throwOnError: false` call resolves to.
+ */
+type UnwrappedResultWithHeaders<TResponses, THeaders, ThrowOnError extends boolean = true> = UnwrappedResult<TResponses, ThrowOnError, NativeRequest, NativeResponse, THeaders>;
+/**
+ * Resolves to the success body when `throwOnError` is true, or to the full result when it is false.
+ */
+declare function unwrapResult<T extends {
+  data: unknown;
+  error: unknown;
+}, ThrowOnError extends boolean>(promise: Promise<T>, throwOnError: ThrowOnError): Promise<Unwrapped<T, ThrowOnError>>;
+/**
+ * The call's `throwOnError`, or the operation's generated default when the call leaves it unset.
+ */
+declare function resolveThrowOnError<ThrowOnError extends boolean>(throwOnError: ThrowOnError | undefined, fallback: boolean): ThrowOnError;
+type DataShape = {
+  body?: unknown;
+  cookies?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+};
+type RequestCredentials = 'omit' | 'same-origin' | 'include';
+/**
+ * Reads a 2xx body as this format instead of by its media type. An error body still uses its media type.
+ */
+type ParseAs = 'json' | 'text' | 'blob' | 'arrayBuffer' | 'stream';
+/**
+ * The request content type, or `{ request, response }` to also set `Accept`.
+ */
+type ContentType = string | {
+  request?: string;
+  response?: string;
+};
+type Validator<T = unknown> = StandardSchemaValidator<T>;
+/**
+ * A security scheme of a generated call, passed to the `auth` resolver. OAuth2 `flows` and `metadataUrl` (RFC 8414) and
+ * the OpenID Connect `url` tell the resolver where to get a token.
+ */
+type Auth = {
+  type: 'http' | 'apiKey' | 'oauth2' | 'openIdConnect';
+  scheme?: 'bearer' | 'basic';
+  name?: string;
+  in?: 'header' | 'query' | 'cookie';
+  scopes?: Array<string>;
+  flows?: Record<string, {
+    authorizationUrl?: string;
+    deviceAuthorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+  }>;
+  metadataUrl?: string;
+  url?: string;
+};
+/**
+ * One scheme, or the schemes one requirement sends together.
+ */
+type SecurityRequirement = Auth | Array<Auth>;
+/**
+ * `user:password` for basic auth, or `undefined` to skip the scheme.
+ */
+type AuthToken = string | undefined;
+/**
+ * A static token, or a callback per scheme. The first requirement whose schemes all get a token is sent.
+ */
+type AuthResolver = AuthToken | ((auth: Auth) => AuthToken | Promise<AuthToken>);
+/**
+ * One Server-Sent Event. `data` is parsed JSON when it parses, otherwise the raw string.
+ */
+type ServerSentEvent<TData = unknown> = {
+  data: TData;
+  event: string;
+  id?: string;
+  retry?: number;
+};
+/**
+ * An event the document types by name, plus the `id` and `retry` any event may carry.
+ */
+type TypedEvent<TEvent> = TEvent & Pick<ServerSentEvent, 'id' | 'retry'>;
+/**
+ * Per-call options of a stream operation.
+ */
+type EventStreamOptions = {
+  /**
+   * The most characters one event or JSON line may hold. A larger one throws a `RangeError`, and `Infinity` turns the limit off.
+   * @default 16777216
+   */
+  maxEventSize?: number | undefined;
+  /**
+   * Ends the stream when an event's raw `data` or a JSON line equals this value, such as `[DONE]`.
+   */
+  terminator?: string | undefined;
+  /**
+   * Maps each Server-Sent Event before validation.
+   */
+  transform?: (event: ServerSentEvent) => ServerSentEvent;
+  /**
+   * What `validator.response` checks on each event: the payload (`data`) or the whole event (`event`).
+   */
+  eventShape?: 'event' | 'data';
+  /**
+   * Keeps each Server-Sent Event's `data` as the raw text instead of JSON-parsing it. The generated client sets it when the
+   * document types `data` as a string. A list of event names keeps it for those events only.
+   */
+  rawData?: boolean | Array<string> | undefined;
+};
+type RequestConfig<TBody = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = {
+  baseURL?: string;
+  url?: string;
+  method?: HttpMethod;
+  path?: unknown;
+  query?: unknown;
+  /**
+   * Alias of `query`.
+   */
+  params?: unknown;
+  cookies?: unknown;
+  body?: TBody;
+  headers?: unknown;
+  styles?: Styles | undefined;
+  signal?: AbortSignal | undefined;
+  credentials?: RequestCredentials | undefined;
+  options?: NativeOptions | undefined;
+  contentType?: ContentType;
+  parseAs?: ParseAs;
+  throwOnError?: boolean;
+  client?: ClientInstance<TRequest, TResponse>;
+  transport?: Transport<TRequest, TResponse>;
+  serializer?: Serializers;
+  /**
+   * Merged per key over the client's media types.
+   */
+  mediaTypes?: MediaTypes;
+  /**
+   * `error` takes one validator, or a map by status such as `{ 404: schema, '5xx': schema, default: schema }`.
+   */
+  validator?: {
+    request?: Validator;
+    path?: Validator;
+    query?: Validator;
+    headers?: Validator;
+    cookies?: Validator;
+    response?: Validator;
+    error?: Validator | Record<string, Validator>;
+  };
+  onValidationError?: ValidationErrorHandler;
+  validate?: ValidateOption;
+  security?: Array<SecurityRequirement>;
+  auth?: AuthResolver;
+};
+/**
+ * The options of a generated operation: its typed request groups plus the call config.
+ */
+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;
+};
+type StreamOptions<TData extends DataShape, ThrowOnError extends boolean = true> = Options<TData, ThrowOnError> & EventStreamOptions;
+/**
+ * Config shared by every call of a client. A call's own config overrides it.
+ */
+type ClientConfig<TRequest = NativeRequest, TResponse = NativeResponse> = {
+  baseURL?: string;
+  headers?: HeadersInit;
+  credentials?: RequestCredentials;
+  options?: NativeOptions;
+  throwOnError?: boolean;
+  transport?: Transport<TRequest, TResponse>;
+  serializer?: Serializers;
+  /**
+   * Merged per key over `defaultMediaTypes`.
+   */
+  mediaTypes?: MediaTypes;
+  onValidationError?: ValidationErrorHandler;
+  validate?: ValidateOption;
+  auth?: AuthResolver;
+};
+/**
+ * The request a transport sends, with its URL, headers, body, and auth already resolved.
+ */
+type ResolvedRequest = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body?: RequestBody | undefined;
+  signal?: AbortSignal | undefined;
+  credentials?: RequestCredentials | undefined;
+  options?: NativeOptions | undefined;
+  /**
+   * Read the response as a stream. A transport that buffers bodies, such as axios, must stream it.
+   */
+  stream?: boolean;
+};
+/**
+ * A transport's `Response` with the native request and response that results and errors carry.
+ */
+type TransportResult<TRequest = NativeRequest, TResponse = NativeResponse> = {
+  webResponse: Response;
+  request: TRequest;
+  response: TResponse;
+};
+/**
+ * Sends a resolved request and returns its `Response` with the body unread. The client decodes it.
+ */
+type Transport<TRequest = NativeRequest, TResponse = NativeResponse> = (request: ResolvedRequest) => Promise<Response | TransportResult<TRequest, TResponse>>;
+/**
+ * What a response interceptor gets: the decoded body with the status, headers, and native objects.
+ */
+type DecodedResponse<TData = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = {
+  data: TData;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  contentType?: string | undefined;
+  request: TRequest;
+  response: TResponse;
+};
+type InterceptorFn<T, TContext = never, TResult = T> = (value: T, context?: TContext) => TResult | Promise<TResult>;
+type InterceptorStack<T, TContext = never, TResult = T> = {
+  use: (fn: InterceptorFn<T, TContext, TResult>) => number;
+  eject: (id: number) => void;
+  update: (id: number, fn: InterceptorFn<T, TContext, TResult>) => void;
+  run: (value: T, context?: TContext) => Promise<T>;
+};
+type Interceptors<TRequest = NativeRequest, TResponse = NativeResponse> = {
+  request: InterceptorStack<ResolvedRequest, RequestConfig<unknown, TRequest, TResponse>>;
+  response: InterceptorStack<DecodedResponse<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>;
+  /**
+   * Sees every failure: a `ResponseError`, a network error, an abort, or a validation error. Return another error to throw it instead.
+   */
+  error: InterceptorStack<ResponseError<unknown, TRequest, TResponse> | Error, RequestConfig<unknown, TRequest, TResponse>, Error | void>;
+};
+type UrlConfig = Pick<RequestConfig, 'baseURL' | 'url' | 'path' | 'query' | 'params' | 'serializer' | 'styles'>;
+type StreamParts<TEvent> = AsyncIterable<TEvent> & {
+  stream: AsyncGenerator<TEvent>;
+  /**
+   * The last event ID the server sent, for a `Last-Event-ID` header on a new call.
+   */
+  readonly lastEventId: string;
+};
+type WithEvents<TResult, TEvent> = TResult extends {
+  error: undefined;
+} ? Omit<TResult, 'data'> & {
+  data: AsyncGenerator<TEvent>;
+} : TResult;
+/**
+ * The result of a stream call. Iterate it, or its `data`, for the items. A failed call yields none.
+ */
+type StreamResult<TResponses, ThrowOnError extends boolean = true, TEvent = ServerSentEvent<SuccessOf<TResponses>>, TRequest = NativeRequest, TResponse = NativeResponse, THeaders = unknown> = WithEvents<RequestResult<TResponses, ThrowOnError, TRequest, TResponse, THeaders>, TEvent> & StreamParts<TEvent>;
+/**
+ * `StreamResult` with the declared response headers by status: `StreamResultWithHeaders<StreamEventsResponses, { '200': StreamEventsStatus200Headers }>`.
+ */
+type StreamResultWithHeaders<TResponses, THeaders, ThrowOnError extends boolean = true, TEvent = ServerSentEvent<SuccessOf<TResponses>>> = StreamResult<TResponses, ThrowOnError, TEvent, NativeRequest, NativeResponse, THeaders>;
+/**
+ * What a stream operation returns with `returnType: 'data'`.
+ */
+type UnwrappedStreamResult<TResponses, ThrowOnError extends boolean = true, TEvent = ServerSentEvent<SuccessOf<TResponses>>, THeaders = unknown> = Unwrapped<StreamResult<TResponses, ThrowOnError, TEvent, NativeRequest, NativeResponse, THeaders>, ThrowOnError>;
+/**
+ * `UnwrappedStreamResult` with the declared response headers by status, for the full result a `throwOnError: false` call resolves to.
+ */
+type UnwrappedStreamResultWithHeaders<TResponses, THeaders, ThrowOnError extends boolean = true, TEvent = ServerSentEvent<SuccessOf<TResponses>>> = UnwrappedStreamResult<TResponses, ThrowOnError, TEvent, THeaders>;
+/**
+ * A client. Call it to send a request.
+ */
+type ClientInstance<TRequest = NativeRequest, TResponse = NativeResponse> = {
+  <TResponses = unknown, ThrowOnError extends boolean = true, THeaders = unknown>(config: RequestConfig<unknown, TRequest, TResponse> & {
+    throwOnError?: ThrowOnError;
+  }): Promise<RequestResult<TResponses, ThrowOnError, TRequest, TResponse, THeaders>>;
+  /**
+   * Sends the request and reads a 2xx body item by item. A body whose media type cannot stream throws a `TypeError`.
+   */
+  stream: <TResponses = unknown, ThrowOnError extends boolean = true, TItem = ServerSentEvent<SuccessOf<TResponses>>, THeaders = unknown>(config: RequestConfig<unknown, TRequest, TResponse> & EventStreamOptions & {
+    throwOnError?: ThrowOnError;
+  }) => Promise<StreamResult<TResponses, ThrowOnError, TItem, TRequest, TResponse, THeaders>>;
+  getConfig: () => ClientConfig<TRequest, TResponse>;
+  setConfig: (config: ClientConfig<TRequest, TResponse>) => ClientConfig<TRequest, TResponse>;
+  getUrl: (config: UrlConfig) => string;
+  interceptors: Interceptors<TRequest, TResponse>;
+  /**
+   * A client with this config and no interceptors.
+   */
+  createClient: (config?: ClientConfig<TRequest, TResponse>) => ClientInstance<TRequest, TResponse>;
+  /**
+   * A client with this config that runs this client's interceptors before its own.
+   */
+  extend: (config?: ClientConfig<TRequest, TResponse>) => ClientInstance<TRequest, TResponse>;
+};
+/**
+ * Thrown for a non-2xx response when `throwOnError` is true.
+ */
+declare class ResponseError<TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse> extends Error {
+  data: TError;
+  status: number;
+  statusText: string;
+  contentType: string | undefined;
+  /**
+   * The response's `Headers`, the same on every transport.
+   */
+  headers: ResponseHeaders;
+  request: TRequest;
+  response: TResponse;
+  constructor(config: {
+    data: TError;
+    status: number;
+    statusText: string;
+    contentType?: string | undefined;
+    headers?: Headers | undefined;
+    request: TRequest;
+    response: TResponse;
+    method?: string | undefined;
+    url?: string | undefined;
+  });
+  /**
+   * Matches on `name`, since every generated client has its own `ResponseError` class.
+   */
+  static is(error: unknown): error is ResponseError<unknown, unknown, unknown>;
+}
+type ResponseErrorConfig<TError = unknown> = ResponseError<TError>;
+type ErrorStatus<TResponses> = Exclude<keyof TResponses, SuccessStatusCode>;
+/**
+ * The `ResponseError` an operation throws. Checking `status` narrows `data` to that status's body, and `headers.get` to
+ * the header names in `THeaders`, the same record `RequestResult` takes.
+ */
+type ResponseErrorOf<TResponses, TRequest = NativeRequest, TResponse = NativeResponse, THeaders = unknown> = [ErrorStatus<TResponses>] extends [never] ? ResponseError<unknown, TRequest, TResponse> : { [TStatus in ErrorStatus<TResponses>]: ResponseError<DataOf<TResponses[TStatus]>, TRequest, TResponse> & {
+  status: ToStatusNumber<TStatus, keyof TResponses>;
+  headers: HeadersFor<THeaders, TStatus>;
+}; }[ErrorStatus<TResponses>];
+/**
+ * Narrows a caught error to the `ResponseError` of the operation whose responses record you pass.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await getPetById({ path: { petId: 7 } })
+ * } catch (error) {
+ *   if (isResponseError<GetPetByIdResponses>(error) && error.status === 404) error.data // GetPetById404
+ * }
+ * ```
+ */
+declare function isResponseError<TResponses = unknown, TRequest = NativeRequest, TResponse = NativeResponse, THeaders = unknown>(error: unknown): error is ResponseErrorOf<TResponses, TRequest, TResponse, THeaders>;
+/**
+ * The value of a header, matched by name in any letter case.
+ */
+declare function getHeader(headers: Record<string, string>, name: string): string | undefined;
+declare function createInterceptorStack<T, TContext = never, TResult = T>(): InterceptorStack<T, TContext, TResult>;
+/**
+ * Adds the tokens of the first security requirement whose schemes all get one to `headers` and `query`.
+ */
+declare function resolveAuth(params: {
+  security: Array<SecurityRequirement> | undefined;
+  auth: AuthResolver | undefined;
+  headers: Record<string, string>;
+  query: Record<string, unknown>;
+}): Promise<void>;
+/**
+ * The `RequestInit` of a resolved request, for `fetch` or a library that takes the same init, such as ky.
+ *
+ * @example
+ * ```ts
+ * client.setConfig({ transport: (request) => ky(request.url, { ...toRequestInit(request), throwHttpErrors: false, retry: 0, timeout: false }) })
+ * ```
+ */
+declare function toRequestInit(request: ResolvedRequest): RequestInit;
+type InterceptorRuns<TRequest, TResponse> = {
+  request: (value: ResolvedRequest, context?: RequestConfig<unknown, TRequest, TResponse>) => Promise<ResolvedRequest>;
+  response: (value: DecodedResponse<unknown, TRequest, TResponse>, context?: RequestConfig<unknown, TRequest, TResponse>) => Promise<DecodedResponse<unknown, TRequest, TResponse>>;
+  error: (value: Error, context?: RequestConfig<unknown, TRequest, TResponse>) => Promise<Error>;
+};
+/**
+ * Creates a client that sends through `defaultTransport`.
+ */
+declare function createClientCore<TRequest = NativeRequest, TResponse = NativeResponse>(options: {
+  defaultTransport: Transport<TRequest, TResponse>;
+  parent?: InterceptorRuns<TRequest, TResponse>;
+} & ClientConfig<TRequest, TResponse>): ClientInstance<TRequest, TResponse>;
+/**
+ * A client created on first use, so importing an operation runs no setup. Config set before that is passed to `create`.
+ */
+declare function createLazyClient<TRequest = NativeRequest, TResponse = NativeResponse>(create: (config: ClientConfig<TRequest, TResponse>) => ClientInstance<TRequest, TResponse>): ClientInstance<TRequest, TResponse>;
+type NativeOptions = Record<string, unknown>;
+type NativeRequest = unknown;
+type NativeResponse = unknown;
+export { createClientCore as $, ResultByStatus as A, SuccessVariant as B, RequestResult as C, ResponseErrorConfig as D, ResponseError as E, StreamResult as F, Unwrappable as G, Transport as H, StreamResultWithHeaders as I, UnwrappedResultWithHeaders as J, Unwrapped as K, SuccessOf as L, SecurityRequirement as M, ServerSentEvent as N, ResponseErrorOf as O, StreamOptions as P, Validator as Q, SuccessResultUnion as R, RequestCredentials as S, ResolvedRequest as T, TransportResult as U, ToStatusNumber as V, TypedEvent as W, UnwrappedStreamResultWithHeaders as X, UnwrappedStreamResult as Y, UrlConfig as Z, InterceptorStack as _, AuthResolver as a, resolveThrowOnError as at, ParseAs as b, ClientInstance as c, withUnwrap as ct, DataShape as d, MediaTypes as dt, createInterceptorStack as et, DecodedResponse as f, defaultMediaTypes as ft, InterceptorFn as g, EventStreamOptions as h, resolveMediaType as ht, Auth as i, resolveAuth as it, ResultUnion as j, ResponseHeaders as k, ContentType as l, MediaType as lt, ErrorOf as m, parseJson as mt, NativeRequest as n, getHeader as nt, AuthToken as o, toRequestInit as ot, EmptyErrorBody as p, isEncodedBody as pt, UnwrappedResult as q, NativeResponse as r, isResponseError as rt, ClientConfig as s, unwrapResult as st, NativeOptions as t, createLazyClient as tt, DataOf as u, MediaTypeContext as ut, Interceptors as v, RequestResultWithHeaders as w, RequestConfig as x, Options as y, SuccessStatusCode as z };