@kubb/plugin-client 6.0.0 → 6.0.2

package/dist/templates/client.d.ts

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

package/dist/templates/core.d.ts

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

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

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

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

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

package/dist/templates/mediaTypes.d.ts

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

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

@@ -1,4 +1,4 @@
-import { r as CookieSerializer } from "../../serializers-BRgfPGr1.js";
+import { CookieSerializer } from "../serializers.js";
 /**
  * Joins cookie parameters into a `Cookie` header value with the OpenAPI `form` style, or the `cookie` style when a parameter sets it.
  */

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

@@ -1,4 +1,4 @@
-import { a as HeaderSerializer } from "../../serializers-BRgfPGr1.js";
+import { HeaderSerializer } from "../serializers.js";
 /**
  * Serializes array and object headers with the OpenAPI `simple` style.
  */

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

@@ -1,4 +1,4 @@
-import { d as PathSerializer } from "../../serializers-BRgfPGr1.js";
+import { PathSerializer } from "../serializers.js";
 /**
  * The path serializer for the `simple` style, which `serializeStyledPath` also uses.
  */

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

@@ -1,4 +1,4 @@
-import { d as PathSerializer } from "../../serializers-BRgfPGr1.js";
+import { PathSerializer } from "../serializers.js";
 /**
  * The path serializer for the OpenAPI `label` and `matrix` styles. A `simple` parameter uses `serializePath`.
  */

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

@@ -1,4 +1,4 @@
-import { m as QuerySerializer } from "../../serializers-BRgfPGr1.js";
+import { QuerySerializer } from "../serializers.js";
 /**
  * The query serializer for a spec without styled query parameters: arrays repeat their key, objects use `form` with explode.
  */

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

@@ -1,4 +1,4 @@
-import { m as QuerySerializer, p as QueryParamStyle } from "../../serializers-BRgfPGr1.js";
+import { QueryParamStyle, QuerySerializer } from "../serializers.js";
 /**
  * One query parameter or form field with its OpenAPI style, as encoded pairs.
  */

package/dist/templates/serializers.d.ts

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

package/dist/templates/sse.d.ts

@@ -1,4 +1,4 @@
-import { N as ServerSentEvent, dt as MediaTypes, h as EventStreamOptions, lt as MediaType } from "../client-Dq0z61hu.js";
+import { N as ServerSentEvent, dt as MediaTypes, h as EventStreamOptions, lt as MediaType } from "../client-C-0-puI2.js";
 type Cursor = {
   lastEventId: string;
 };

package/dist/templates/standardSchema.d.ts

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

package/docs/guides/authentication.md

@@ -62,7 +62,7 @@ setAuth(async () => readTokenFromSecretsStore())
 
 ## Sign requests or use several auth methods
 
-Read `config.security` and pick per operation, or pass a different `client` on a call. This works for request signing, such as AWS SigV4, and for services that use different credentials:
+Read `config.security` and pick per operation, or pass a different `client` on a call. Both ways work for request signing, such as AWS SigV4, and for services that use different credentials:
 
 ```typescript
 import { createSignedClient } from './clients/iam'
@@ -70,4 +70,6 @@ import { createSignedClient } from './clients/iam'
 await getPetById({ path: { petId: 1 }, client: createSignedClient() })
 ```
 
+The examples set [`integerType: 'number'`](https://kubb.dev/extensions/kubb-labs/adapter-oas/options#integertype) on the adapter, so an `int64` id such as `petId` is a `number`. With the default it is a `bigint` and the call takes `1n`.
+
 A client passed on a call replaces the default for that call only.

package/docs/guides/calling-operations.md

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

package/docs/guides/validate-requests-and-responses.md

@@ -26,7 +26,7 @@ export default defineConfig({
 Each generated call now includes the schemas:
 
 ```typescript
-request({
+apiClient<AddPetResponses, ThrowOnError>({
   method: 'POST',
   url: '/pet',
   ...config,
@@ -61,10 +61,10 @@ Set `validator: { request: 'zod' }` or `{ response: 'zod' }` to pass one directi
 
 ## Validate params
 
-With `validator: { params: 'zod' }`, each call also passes the schemas for its path, query, and header params:
+With `validator: { params: 'zod' }`, each call also passes the schemas for its path, query, header, and cookie params:
 
 ```typescript
-request({
+apiClient<PutEventResponses, ThrowOnError>({
   method: 'PUT',
   url: '/events/{day}',
   ...config,
@@ -77,8 +77,8 @@ request({
 })
 ```
 
-Add `path`, `query`, and `headers` to the `validator` field of your `RequestConfig`. Run them on `config.path`, `config.query`, and `config.headers` before you build the URL and headers, and send the values they return.
+Add `path`, `query`, `headers`, and `cookies` to the `validator` field of your `RequestConfig`. Run them on `config.path`, `config.query`, `config.headers`, and `config.cookies` before you build the URL and headers, and send the values they return.
 
 The path and query schemas strip keys the spec does not declare, so only declared params are sent. Headers your client adds itself, such as `Authorization`, are not declared, so the headers schema passes undeclared keys through.
 
-The generated call imports `toHeadersStandardSchema` from your `importPath` module, so that module must export it, or the generated code does not compile. It takes a Standard Schema and the object's declared keys, and returns a Standard Schema that matches the declared headers in any casing and passes undeclared headers through. Copy it from the `.kubb/standardSchema.ts` file that `@kubb/plugin-fetch` generates. Returning the schema unchanged is not enough: the plain object schema strips undeclared headers such as `Authorization`.
+The generated call imports `toHeadersStandardSchema` from your `importPath` module, so that module must export it, or the generated code does not compile. `toHeadersStandardSchema` takes a Standard Schema and the object's declared keys, and returns a Standard Schema that matches the declared headers in any casing and passes undeclared headers through. Copy it from the `.kubb/standardSchema.ts` file that `@kubb/plugin-fetch` generates. Returning the schema unchanged is not enough: the plain object schema strips undeclared headers such as `Authorization`.

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

@@ -44,7 +44,7 @@ To reuse the runtime of the fetch and axios clients instead of writing your own
 
 ```typescript
 import type { Options, RequestResult } from '../../../client'
-import type { GetPetByIdOptions, GetPetByIdResponses } from '../../models/pet/GetPetById'
+import type { GetPetByIdOptions, GetPetByIdResponses } from '../../types/GetPetById'
 import { client } from '../../../client'
 
 export function getPetById<ThrowOnError extends boolean = true>(

package/docs/options.md

@@ -71,6 +71,8 @@ pluginClient({ importPath: '../../client', returnType: 'full' })
 // const pet = await getPetById({ path: { petId: 1 } }).unwrap()
 ```
 
+The examples set [`integerType: 'number'`](https://kubb.dev/extensions/kubb-labs/adapter-oas/options#integertype) on the adapter, so an `int64` id such as `petId` is a `number`. With the default it is a `bigint` and the call takes `1n`.
+
 The setting applies to the whole plugin, so you cannot set it in `override`.
 
 ### validator
@@ -94,7 +96,7 @@ Passes the response and error schemas.
 :::
 
 :::field{name="{ request?: 'zod', params?: 'zod', response?: 'zod' }"}
-Opts in per direction. `request` passes the request body schema, `params` the path, query, and header params schemas, and `response` the response and error schemas.
+Opts in per direction. `request` passes the request body schema, `params` the path, query, header, and cookie params schemas, and `response` the response and error schemas.
 :::
 
 ::

package/docs/overview.md

@@ -24,12 +24,14 @@ The config below groups the generated functions by tag and points them at the cl
 
 ```typescript [kubb.config.ts]
 import { defineConfig } from 'kubb/config'
+import { adapterOas } from '@kubb/adapter-oas'
 import { pluginTs } from '@kubb/plugin-ts'
 import { pluginClient } from '@kubb/plugin-client'
 
 export default defineConfig({
   input: './petStore.yaml',
   output: { path: './src/gen' },
+  adapter: adapterOas({ integerType: 'number' }),
   plugins: [
     pluginTs(),
     pluginClient({

package/kubb-extension.json

@@ -17,8 +17,7 @@
       "github": "stijnvanhulle"
     }
   ],
-  "dependencies": ["plugin-ts"],
-  "optionalDependencies": ["plugin-zod"],
+  "optionalDependencies": ["plugin-ts", "plugin-zod"],
   "compatibility": {
     "kubb": ">=5.18.4",
     "node": ">=22.22"
@@ -165,6 +164,25 @@
         "pattern": "$item"
       }
     },
+    {
+      "key": "returnType",
+      "path": ["returnType"],
+      "label": "Return Type",
+      "description": "What a generated function resolves to. plain is what your client returns, full is the whole result with status and error, and data is only the success body when it throws. full and data need the unwrap helpers exported from your client module",
+      "type": "select",
+      "default": "plain",
+      "choices": [
+        {
+          "value": "plain"
+        },
+        {
+          "value": "full"
+        },
+        {
+          "value": "data"
+        }
+      ]
+    },
     {
       "key": "throwOnErrorDefault",
       "path": ["throwOnErrorDefault"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-client",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "description": "Generate typed API operations against your own client module.",
   "keywords": [
     "api-client",
@@ -61,10 +61,10 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/kit": "^5.18.6",
-    "@kubb/plugin-ts": "^5.5.0",
-    "@kubb/plugin-zod": "^5.9.0",
-    "@kubb/renderer-jsx": "^5.18.6"
+    "@kubb/kit": "^5.19.0",
+    "@kubb/plugin-ts": "^5.5.2",
+    "@kubb/plugin-zod": "^5.9.2",
+    "@kubb/renderer-jsx": "^5.19.0"
   },
   "devDependencies": {
     "@internals/client": "0.0.0",

package/src/clientTypes.ts

@@ -84,9 +84,9 @@ export type ClientOptions = OutputOptions & {
   validator?: ValidatorOptions
   /**
    * Shape of the value a generated operation function resolves to. Applies to the standalone
-   * functions and the class-based SDK; not to the query-hook plugins (`@kubb/plugin-react-query`,
-   * `@kubb/plugin-vue-query`, `@kubb/plugin-swr`), which keep calling the client directly and
-   * expect the full result.
+   * functions and the class-based SDK. The query-hook plugins (`@kubb/plugin-react-query`,
+   * `@kubb/plugin-vue-query`, `@kubb/plugin-swr`) and `@kubb/plugin-mcp` read it to unwrap the
+   * call they make, and their own `returnType` sets what a hook resolves to.
    *
    * @default 'full'
    * @example

package/src/generators/sdkGenerator.tsx

@@ -2,7 +2,7 @@ import path from 'node:path'
 import { type OperationTypeSource, resolveOperationTypes, resultTypeName } from '@internals/client'
 import { isEventStream } from '@internals/shared'
 import { ensureValidVarName } from '@internals/utils'
-import { ast, defineGenerator, Diagnostics } from '@kubb/kit'
+import { ast, defineGenerator, Diagnostics, memo } from '@kubb/kit'
 import type { Generator } from '@kubb/kit'
 import { File, jsxRenderer } from '@kubb/renderer-jsx'
 import { type GeneratorContext, type OperationData, resolveOperationData } from '../builders/operationData.ts'
@@ -55,8 +55,7 @@ function collectImportsByFile(ops: Array<OperationData>, pick: (op: OperationDat
   ops.forEach((op) => {
     const { file, names } = pick(op)
     if (!file || names.length === 0) return
-    if (!namesByPath.has(file.path)) namesByPath.set(file.path, new Set())
-    const set = namesByPath.get(file.path)!
+    const set = memo(namesByPath, file.path, () => new Set<string>())
     names.forEach((n) => set.add(n))
     filesByPath.set(file.path, file)
   })