@kubb/plugin-fetch 5.6.0-canary.20261014T114046 → 5.6.1

package/dist/index.cjs

@@ -1487,7 +1487,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.6.0-canary.20261014T114046";
+var version = "5.6.1";
 //#endregion
 //#region src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */

package/dist/index.js

@@ -1461,7 +1461,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.6.0-canary.20261014T114046";
+var version = "5.6.1";
 //#endregion
 //#region src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */

package/dist/templates/fetch.d.ts

@@ -0,0 +1,414 @@
+import { HeadersInit, RequestBody, Serializers, Styles } from "./serializers.js";
+import { ParseError, StandardSchemaValidator } from "./standardSchema.js";
+//#region templates/fetch.d.ts
+/**
+ * HTTP status codes treated as a success, everything else is an error.
+ */
+export type SuccessStatusCode = '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226';
+/**
+ * The success members of a per-status responses record.
+ */
+export type SuccessOf<TResponses> = TResponses[Extract<keyof TResponses, SuccessStatusCode>];
+/**
+ * The error members of a per-status responses record, every documented status that is not a 2xx.
+ */
+export 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`.
+ */
+export type ToStatusNumber<TStatus> = TStatus extends `${infer TNumber extends number}` ? TNumber : number;
+/**
+ * The plain body of a per-status response, unwrapping the `{ contentType; data }` union so an error result keeps the bare body union on `error`.
+ */
+export type DataOf<T> = T extends {
+  contentType: string;
+  data: infer TData;
+} ? TData : T;
+/**
+ * The success variant for a single status, flattened so the negotiated `contentType` sits next to `data` and `switch (result.contentType)` narrows it.
+ */
+export 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;
+};
+/**
+ * One result variant for a single documented status, keyed by the numeric `status` so a `switch (result.status)` narrows `data` or `error`.
+ */
+export 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;
+};
+/**
+ * The union of every documented status' result variant.
+ */
+export type ResultUnion<TResponses, TRequest, TResponse> = { [TStatus in keyof TResponses]: ResultByStatus<TResponses, TStatus, TRequest, TResponse>; }[keyof TResponses];
+/**
+ * The union of just the success (2xx) status variants, selected by status code so an untyped error payload can never widen `data`.
+ */
+export type SuccessResultUnion<TResponses, TRequest, TResponse> = { [TStatus in Extract<keyof TResponses, SuccessStatusCode>]: ResultByStatus<TResponses, TStatus, TRequest, TResponse>; }[Extract<keyof TResponses, SuccessStatusCode>];
+/**
+ * The shape every generated function returns, discriminated by the top-level `status`, narrowing to the 2xx variants under `throwOnError` and to every documented status without it.
+ */
+export type RequestResult<TResponses, ThrowOnError extends boolean = true, TRequest = Request, TResponse = Response> = 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.
+ */
+export 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 Full result
+ * `const { data, error } = await getPetById({ path: { petId: 1 } })`
+ *
+ * @example Success body only
+ * `const pet = await getPetById({ path: { petId: 1 } }).unwrap()`
+ */
+export 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.
+ */
+export type UnwrappedResult<TResponses, ThrowOnError extends boolean = true, TRequest = Request, TResponse = Response> = 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.
+ * Backs generated operations with `returnType: 'data'`.
+ */
+export declare function unwrapResult<T extends {
+  data: unknown;
+  error: unknown;
+}>(promise: Promise<T>, throwOnError: boolean | undefined): Promise<T | T['data']>;
+/**
+ * The data-shaped keys of the grouped options object, which `Options` re-adds typed per operation.
+ */
+export type DataShape = {
+  body?: unknown;
+  cookies?: unknown;
+  headers?: unknown;
+  path?: unknown;
+  query?: unknown;
+};
+export type RequestCredentials = 'omit' | 'same-origin' | 'include';
+export type ResponseType = 'arraybuffer' | 'blob' | 'document' | 'json' | 'text' | 'stream';
+/**
+ * Turns a raw response body into a parsed value, registered per media type as a codec's `deserialize` to handle formats the runtime does not decode itself.
+ */
+export type Deserializer<T = unknown> = (raw: unknown, contentType: string) => T | Promise<T>;
+/**
+ * Serializes a request body for a single media type, registered per content type as a codec's `serialize` to encode formats the default serializer does not handle.
+ */
+export type ContentBodySerializer = (body: unknown, contentType?: string) => RequestBody | undefined;
+/**
+ * A per-content-type codec registered on `codecs`, keyed by content type. `serialize` encodes the
+ * request body for that media type and `deserialize` decodes the response body. Either half is
+ * optional, so a codec can handle one direction.
+ */
+export type Codec = {
+  serialize?: ContentBodySerializer;
+  deserialize?: Deserializer;
+};
+/**
+ * The per-call content type selection, where a bare string sets the request content type and the object form also sets the response format sent as `Accept`.
+ */
+export type ContentType = string | {
+  request?: string;
+  response?: string;
+};
+/**
+ * A Standard Schema validator (zod, valibot, arktype) that parses a value before it is sent or after
+ * it is received. `runValidator` runs it through `validateStandardSchema`. Wired through the per-call
+ * `validator.request` / `validator.response` / `validator.error` hooks (`error` runs on the error body when a
+ * non-2xx call does not throw).
+ */
+export type Validator<T = unknown> = StandardSchemaValidator<T>;
+/**
+ * The failing body and the call it came from, handed to `onValidationError` alongside the `ParseError`.
+ * `direction` says which slot rejected it: the request body, the success body, or the error body.
+ */
+export type ValidationErrorContext = {
+  value: unknown;
+  direction: 'request' | 'response' | 'error';
+  method?: string;
+  url?: string;
+  status?: number;
+};
+/**
+ * Decides what a failed validation does. Returning nothing rethrows the `ParseError`; returning
+ * `{ value }` resolves the call with that value instead, so a drifted body can be reported and still
+ * delivered. The box keeps an explicit `{ value: undefined }` substitution distinct from declining.
+ */
+export type ValidationErrorHandler = (error: ParseError, context: ValidationErrorContext) => {
+  value: unknown;
+} | void | Promise<{
+  value: unknown;
+} | void>;
+/**
+ * A resolved security scheme carried on each generated call's `security` array and passed to the `auth` resolver.
+ */
+export type Auth = {
+  type: 'http' | 'apiKey' | 'oauth2' | 'openIdConnect';
+  scheme?: 'bearer' | 'basic';
+  name?: string;
+  in?: 'header' | 'query' | 'cookie';
+};
+/**
+ * The raw token a consumer returns for a scheme (or `user:password` for basic), or `undefined` to skip it.
+ */
+export 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.
+ */
+export type AuthResolver = AuthToken | ((auth: Auth) => AuthToken | Promise<AuthToken>);
+/**
+ * Extra `fetch` init the transport spreads onto every `Request`, an escape hatch for fields the runtime does not set itself such as `cache`, `redirect`, and Next.js's `next`.
+ */
+export type FetchOptions = RequestInit & {
+  next?: Record<string, unknown>;
+};
+/**
+ * The request a generated function hands to the runtime, with `body` / `headers` / `path` / `query` from the grouped options.
+ */
+export type RequestConfig<TBody = unknown, TRequest = Request, TResponse = Response> = {
+  baseURL?: string;
+  url?: string;
+  method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'QUERY';
+  path?: unknown;
+  query?: unknown;
+  params?: unknown;
+  cookies?: unknown;
+  body?: TBody;
+  headers?: unknown;
+  styles?: Styles;
+  signal?: AbortSignal;
+  credentials?: RequestCredentials;
+  options?: FetchOptions;
+  contentType?: ContentType;
+  responseType?: ResponseType;
+  throwOnError?: boolean;
+  client?: ClientInstance<TRequest, TResponse>;
+  transport?: Transport<TRequest, TResponse>;
+  serializer?: Serializers;
+  codecs?: Record<string, Codec>;
+  validator?: {
+    request?: Validator;
+    response?: Validator;
+    error?: Validator;
+  };
+  onValidationError?: ValidationErrorHandler;
+  security?: Array<Auth>;
+  auth?: AuthResolver;
+};
+/**
+ * The grouped options object passed to every generated function: the request config minus the
+ * data-shaped keys and the literal `url`, plus the per-operation `<Name>Request`.
+ */
+export type Options<TData extends DataShape, ThrowOnError extends boolean = true, TRequest = Request, TResponse = Response> = 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`.
+ */
+export type ClientConfig<TRequest = Request, TResponse = Response> = {
+  baseURL?: string;
+  headers?: HeadersInit;
+  credentials?: RequestCredentials;
+  options?: FetchOptions;
+  throwOnError?: boolean;
+  transport?: Transport<TRequest, TResponse>;
+  serializer?: Serializers;
+  codecs?: Record<string, Codec>;
+  onValidationError?: ValidationErrorHandler;
+  auth?: AuthResolver;
+};
+/**
+ * The normalized request the transport receives, with all serialization, auth, and header work already done.
+ */
+export type ResolvedRequest = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body?: RequestBody;
+  signal?: AbortSignal;
+  credentials?: RequestCredentials;
+  options?: FetchOptions;
+  responseType?: ResponseType;
+};
+/**
+ * What a transport returns: the parsed body plus the native request and response objects.
+ */
+export type TransportResult<TData = unknown, TRequest = Request, TResponse = Response> = {
+  data: TData;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  contentType?: string;
+  request: TRequest;
+  response: TResponse;
+};
+/**
+ * The per-plugin send, supplied to `createClientCore` as `defaultTransport`.
+ */
+export type Transport<TRequest = Request, TResponse = Response> = (request: ResolvedRequest) => Promise<TransportResult<unknown, TRequest, TResponse>>;
+/**
+ * The result a resolved call produces before it is cast to `RequestResult` by the generated wrapper.
+ */
+export type CallResult<TRequest = Request, TResponse = Response> = {
+  status: number;
+  data: unknown;
+  error: unknown;
+  contentType: string | undefined;
+  request: TRequest;
+  response: TResponse;
+};
+export type InterceptorFn<T, TContext = never> = (value: T, context?: TContext) => T | Promise<T>;
+/**
+ * A single interceptor channel with a transport-agnostic `use` / `eject` / `update` API.
+ */
+export 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>;
+};
+/**
+ * The three interceptor channels every client instance exposes.
+ */
+export type Interceptors<TRequest = Request, TResponse = Response> = {
+  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>>;
+};
+/**
+ * A client instance: the callable send plus configuration, interceptors, and an isolated
+ * `createClient` factory bound to the same transport.
+ */
+export type ClientInstance<TRequest = Request, TResponse = Response> = {
+  <TBody = unknown>(config: RequestConfig<TBody, TRequest, TResponse>): Promise<CallResult<TRequest, TResponse>>;
+  getConfig: () => ClientConfig<TRequest, TResponse>;
+  setConfig: (config: ClientConfig<TRequest, TResponse>) => ClientConfig<TRequest, TResponse>;
+  getUrl: <TBody = unknown>(config: RequestConfig<TBody, TRequest, TResponse>) => 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.
+ */
+export declare class ResponseError<TError = unknown, TRequest = Request, TResponse = Response> 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>;
+}
+export type ResponseErrorConfig<TError = unknown> = ResponseError<TError>;
+/**
+ * Creates a transport-agnostic interceptor channel that runs interceptors in registration order.
+ */
+export 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.
+ */
+export declare function resolveAuth(params: {
+  security: Array<Auth> | undefined;
+  auth: AuthResolver | undefined;
+  headers: Record<string, string>;
+  query: Record<string, unknown>;
+}): Promise<void>;
+/**
+ * Builds the shared client core bound to a transport, exported by each plugin as `client` plus a `createClient` factory.
+ */
+export declare function createClientCore<TRequest = Request, TResponse = Response>(options: {
+  defaultTransport: Transport<TRequest, TResponse>;
+} & ClientConfig<TRequest, TResponse>): ClientInstance<TRequest, TResponse>;
+/**
+ * One decoded Server-Sent Event, with `data` parsed as JSON when valid and kept as the raw string otherwise.
+ */
+export type ServerSentEvent<TData = unknown> = {
+  data: TData;
+  event?: string;
+  id?: string;
+  retry?: number;
+};
+/**
+ * Parses a `text/event-stream` body into typed Server-Sent Events, consumed with `for await` and stopped early by breaking the loop.
+ */
+export declare function parseEventStream<TData = unknown>(stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>): AsyncGenerator<ServerSentEvent<TData>>;
+/**
+ * The resolved shape returned by a generated `text/event-stream` operation: the typed event
+ * `stream` plus the native `response`.
+ */
+export type EventStreamResult<TData = unknown, TResponse = Response> = {
+  stream: AsyncGenerator<ServerSentEvent<TData>>;
+  response: TResponse;
+};
+/**
+ * Wraps a transport result whose `data` is a streaming body into an `EventStreamResult`, exposing
+ * the parsed events as a typed async iterator. Generated SSE operations call this.
+ */
+export declare function toEventStream<TData = unknown>(result: Promise<{
+  data: unknown;
+  response: Response;
+}>): Promise<EventStreamResult<TData>>;
+export declare const client: ClientInstance<Request, Response>;
+export declare const createClient: (config?: Parameters<typeof client.createClient>[0]) => ClientInstance<Request, Response>;
+//#endregion

package/dist/templates/serializers.d.ts

@@ -0,0 +1,177 @@
+//#region templates/serializers.d.ts
+export type HeaderValue = string | number | boolean | null | undefined | object;
+export 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.
+ */
+export type RequestBody = NonNullable<RequestInit['body']>;
+/**
+ * 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`.
+ */
+export 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).
+ */
+export type SerializationStyle<TStyle = string> = {
+  style?: TStyle;
+  explode?: boolean;
+  allowReserved?: boolean;
+};
+/**
+ * The per-parameter query serialization metadata carried by the generated request.
+ */
+export type QueryParamStyle = SerializationStyle<QueryStyle>;
+/**
+ * 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.
+ */
+export 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.
+ */
+export type CookieParamStyle = {
+  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'
+ * ```
+ */
+export type HeaderParamStyle = {
+  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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export type Styles = {
+  path?: Record<string, PathParamStyle>;
+  query?: Record<string, QueryParamStyle>;
+  header?: Record<string, HeaderParamStyle>;
+  cookie?: Record<string, CookieParamStyle>;
+  body?: Record<string, BodyEncoding>;
+};
+export 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
+ * ```
+ */
+export declare const defaultBodySerializer: BodySerializer;
+/**
+ * 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'
+ * ```
+ */
+export 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'
+ * ```
+ */
+export 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'
+ * ```
+ */
+export 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.
+ */
+export declare function applyHeaderStyles(headers: HeadersInit | undefined, styles: Record<string, HeaderParamStyle> | undefined): HeadersInit | undefined;
+//#endregion

package/dist/templates/standardSchema.d.ts

@@ -0,0 +1,51 @@
+//#region templates/standardSchema.d.ts
+/**
+ * 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.
+ */
+export 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`.
+ */
+export type StandardSchemaResult<TOutput> = {
+  readonly value: TOutput;
+  readonly issues?: undefined;
+} | {
+  readonly issues: ReadonlyArray<StandardSchemaIssue>;
+};
+/**
+ * One validation issue from a Standard Schema `validate` call.
+ */
+export 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.
+ */
+export 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)
+ */
+export declare function validateStandardSchema<TOutput>(schema: StandardSchemaValidator<TOutput>, value: unknown): Promise<TOutput>;
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.6.0-canary.20261014T114046",
+  "version": "5.6.1",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -61,6 +61,13 @@
     },
     "./package.json": "./package.json",
     "./kubb-extension.json": "./kubb-extension.json",
+    "./templates/*.ts": {
+      "types": "./dist/templates/*.d.ts",
+      "default": "./templates/*.ts"
+    },
+    "./templates/*.js": {
+      "types": "./dist/templates/*.d.ts"
+    },
     "./templates/*": "./templates/*"
   },
   "publishConfig": {
@@ -68,12 +75,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/plugin-ts": "^5.1.0-canary.20261014T114045",
-    "@kubb/plugin-zod": "^5.5.0-canary.20261014T114045"
+    "@kubb/plugin-ts": "^5.0.11",
+    "@kubb/plugin-zod": "^5.4.9"
   },
   "devDependencies": {
-    "@internals/client": "0.1.0-canary.20261014T114046",
-    "@internals/shared": "0.1.0-canary.20261014T114045",
+    "@internals/client": "0.0.0",
+    "@internals/shared": "0.0.0",
     "kubb": "^5.9.2",
     "typescript": "^6.0.3"
   },

package/templates/fetch.ts

@@ -215,7 +215,7 @@ export type FetchOptions = RequestInit & { next?: Record<string, unknown> }
 export type RequestConfig<TBody = unknown, TRequest = Request, TResponse = Response> = {
   baseURL?: string
   url?: string
-  method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD'
+  method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'QUERY'
   path?: unknown
   query?: unknown
   params?: unknown