@kubb/plugin-fetch 5.14.0-canary.20261109T134631 → 6.0.1

package/docs/options.md

@@ -23,7 +23,7 @@ Pass these options to `pluginFetch()`. Shared options link to [Shared plugin opt
 
 ### baseURL
 
-Base URL prepended to every request. When omitted, each request uses the operation's relative path from the spec. A value with a `${...}` interpolation is emitted as a template literal in the generated client config, so `baseURL: '${process.env.API_URL}'` reads the environment variable at runtime.
+Base URL prepended to every request. When omitted, each request uses the operation's relative path from the spec. A path or operation that declares its own `servers` uses that URL instead. See [Set the base URL](https://kubb.dev/extensions/kubb-labs/plugin-fetch/guides/base-url). A value with a `${...}` interpolation is emitted as a template literal in the generated client config, so `baseURL: '${process.env.API_URL}'` reads the environment variable at runtime.
 
 |          |          |
 | -------- | -------- |
@@ -32,7 +32,7 @@ Base URL prepended to every request. When omitted, each request uses the operati
 
 ### throwOnErrorDefault
 
-Set `throwOnErrorDefault: false` to return documented error responses as values by default. It sets the fallback on each generated request and the default `ThrowOnError` type parameter on functions and SDK methods. It applies to the whole plugin, so `override` cannot set it. A call that passes `throwOnError` still wins. With `throwOnError: true`, a non-2xx response throws and the return type narrows to successful responses. Query hooks always pass `throwOnError: true`.
+Set `throwOnErrorDefault: false` to return documented error responses as values by default. The option sets the fallback on each generated request and the default `ThrowOnError` type parameter on functions and SDK methods. The option applies to the whole plugin, so `override` cannot set it. A call that passes `throwOnError` still wins. With `throwOnError: true`, a non-2xx response throws and the return type narrows to successful responses. Query hooks always pass `throwOnError: true`.
 
 |          |           |
 | -------- | --------- |
@@ -46,9 +46,11 @@ const result = await getPetById({ path: { petId: 1 } })
 if (result.status !== 200) console.error(result.status, result.error)
 ```
 
+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`.
+
 ### validator
 
-Validates request bodies, path, query, and header params, and response bodies with schemas from `@kubb/plugin-zod`, so add `pluginZod()` too. An invalid value makes the generated function throw a `ParseError`.
+Validates request bodies, the path, query, header, and cookie params, and response bodies with schemas from `@kubb/plugin-zod`, so add `pluginZod()` too. An invalid value makes the generated function throw a `ParseError`.
 
 |          |                                                                           |
 | -------- | ------------------------------------------------------------------------- |
@@ -63,11 +65,11 @@ Default value. Does no validation and returns the response cast to the generated
 :::
 
 :::field{name="'zod'"}
-Validates the success response body, and the error body when a non-2xx call does not throw.
+Validates the success response body, and the error body against the schema of its status.
 :::
 
 :::field{name="{ request?: 'zod', params?: 'zod', response?: 'zod' }"}
-Opts in per direction. `request` validates the request body and `params` validates the path, query, and header params before the call. `response` validates the response body after it.
+Opts in per direction. `request` validates the request body and `params` validates the path, query, header, and cookie params before the call. `response` validates the response body after it.
 :::
 
 ::
@@ -89,9 +91,9 @@ export default defineConfig({
 })
 ```
 
-`params` runs each group through its generated `<operation>PathSchema`, `QuerySchema`, or `HeadersSchema`, and sends what the schema returns. A codec param such as a `Date` goes out in its wire form, and an invalid param fails before the request. Values added by `auth` are not validated.
+`params` runs each group through its generated `<operation>PathSchema`, `QuerySchema`, `HeadersSchema`, or `CookiesSchema`, and sends what the schema returns. A codec param such as a `Date` goes out in its wire form, and an invalid param fails before the request. Values added by `auth` are not validated.
 
-Only the params your OpenAPI spec declares are sent. Path and query keys the spec does not declare are stripped, so a key such as an undocumented filter or a cache-buster never reaches the URL. Declare it in the spec, or leave `params` off. Headers are the exception: client-level `headers` (such as `Authorization` or tracing headers) are merged with the call's headers before validation, so headers the spec does not declare pass through unchanged, and declared header params match in any casing.
+Only the params your OpenAPI spec declares are sent. Path and query keys the spec does not declare are stripped, so a key such as an undocumented filter or a cache-buster never reaches the URL. Declare it in the spec, or leave `params` off. Headers are the exception. Client-level `headers`, such as `Authorization` or tracing headers, are merged with the call's headers before validation. Headers the spec does not declare pass through unchanged, and declared header params match in any casing.
 
 Pair `request` and `params` with `pluginZod({ inferred: 'codec' })` when the schemas use codecs, so the request types accept the domain values (such as a `Date`) that the validators encode. See [`inferred`](https://kubb.dev/extensions/kubb-labs/plugin-zod/options#inferred).
 
@@ -107,7 +109,7 @@ Generates a class-based SDK. Each instance takes its own client config, so envir
 ::field-group
 
 :::field{name="'tag'"}
-Default value for `sdk.mode`. Generates one class per tag, such as `PetClient`. Set `sdk.name` to also get a root class that shares one config, used as `new PetStore(config).pet.getPetById(...)`.
+Default value for `sdk.mode`. Generates one class per tag, such as `PetClient`. Set `sdk.name` to also get a root class that shares one client with every tag, used as `new PetStore(config).pet.getPetById(...)`.
 :::
 
 :::field{name="'flat'"}
@@ -125,6 +127,16 @@ const pet = new PetClient({ baseURL: 'https://petstore.swagger.io/v2' })
 const { data } = await pet.getPetById({ path: { petId: 1 } })
 ```
 
+Each SDK class exposes its client as the read-only `client` field. Interceptors on the root class's `client` apply to every tag:
+
+```typescript
+const api = new PetStore({ baseURL: 'https://petstore.swagger.io/v2' })
+api.client.interceptors.request.use((request) => request)
+await api.pet.getPetById({ path: { petId: 1 } })
+```
+
+A tag class also accepts an existing client, as in `new PetClient(api.client)`.
+
 ### returnType
 
 Shape of the value a generated call resolves to.
@@ -138,7 +150,7 @@ Shape of the value a generated call resolves to.
 ::field-group
 
 :::field{name="'full'"}
-Default value. Returns `{ status, data, error, contentType, request, response }`.
+Default value. Returns `{ status, data, error, contentType, headers, request, response }`. `headers` is the response's `Headers`. For an operation whose responses declare `headers`, its `get` suggests those names once `status` is narrowed, and the values stay strings.
 :::
 
 :::field{name="'data'"}
@@ -153,7 +165,7 @@ pluginFetch({ returnType: 'data' })
 const pet = await getPetById({ path: { petId: 1 } }) // Pet, not { status, data, ... }
 ```
 
-It applies to the functions and the SDK. The query plugins and `@kubb/plugin-mcp` read it too, including a per-operation value set through [`override`](https://kubb.dev/docs/5.x/reference/plugin-options#override). To read headers such as `ETag` under `'data'`, pass `throwOnError: false` and call `result.response.headers.get('etag')`.
+`returnType` applies to the functions and the SDK. The query plugins and `@kubb/plugin-mcp` read it too, including a per-operation value set through [`override`](https://kubb.dev/docs/5.x/reference/plugin-options#override). To read headers such as `ETag` under `'data'`, pass `throwOnError: false` and call `result.response.headers.get('etag')`.
 
 ### resolver
 

package/docs/overview.md

@@ -2,17 +2,17 @@
 
 The Fetch plugin turns each operation in your OpenAPI spec into a typed async function that sends the request with the native Fetch API. Each function takes grouped `path`, `query`, `headers`, and `body` parameters and returns a result keyed by status code.
 
-The query plugins (`@kubb/plugin-react-query`, `@kubb/plugin-vue-query`, and `@kubb/plugin-swr`) and `@kubb/plugin-mcp` call these functions. The plugin also copies its runtime files (`client.ts`, `serializers.ts`, and `standardSchema.ts`) to `.kubb/` in the root output folder.
+The query plugins (`@kubb/plugin-react-query`, `@kubb/plugin-vue-query`, and `@kubb/plugin-swr`) and `@kubb/plugin-mcp` call these functions. The plugin also copies its runtime files to `.kubb/` in the root output folder. Import the client from `.kubb/client.ts`.
 
 ## Setup
 
 - Add `@kubb/plugin-ts` for the operation types, or `@kubb/plugin-zod` with `inferred: true`.
-- Add `@kubb/plugin-zod` when you set `validator`, and install `zod` v4. Without the plugin, `validator` does nothing.
+- Add `@kubb/plugin-zod` when you set `validator`, and install `zod` v4. Generation fails without the plugin.
 - No HTTP client package is needed. The generated code calls the global `fetch`.
 
 ## Options worth knowing
 
-- `baseURL` is prepended to every request. The spec's `servers` URL is not used, so without `baseURL` you set one at runtime with `client.setConfig({ baseURL })`.
+- `baseURL` is prepended to every request. The spec's top-level `servers` URL is not used, so without `baseURL` you set one at runtime with `client.setConfig({ baseURL })`. Operations with their own `servers`, on the path or the operation, call that URL instead.
 - `validator: 'zod'` validates response bodies with the schemas from `@kubb/plugin-zod`. Use `{ request: 'zod', response: 'zod' }` to also validate request bodies.
 - `throwOnErrorDefault: false` returns non-2xx responses as values instead of throwing. A single call can still pass `throwOnError`.
 - `returnType: 'data'` makes a call resolve to the success body instead of the full result. With `throwOnError: false`, the call still returns the full result.
@@ -26,12 +26,14 @@ The config below generates a Fetch client that sends every request to the Petsto
 
 ```typescript [kubb.config.ts]
 import { defineConfig } from 'kubb/config'
+import { adapterOas } from '@kubb/adapter-oas'
 import { pluginTs } from '@kubb/plugin-ts'
 import { pluginFetch } from '@kubb/plugin-fetch'
 
 export default defineConfig({
   input: './petStore.yaml',
   output: { path: './src/gen' },
+  adapter: adapterOas({ integerType: 'number' }),
   plugins: [
     pluginTs(),
     pluginFetch({ baseURL: 'https://petstore.swagger.io/v2' }),

package/kubb-extension.json

@@ -17,10 +17,9 @@
       "github": "stijnvanhulle"
     }
   ],
-  "dependencies": ["plugin-ts"],
-  "optionalDependencies": ["plugin-zod"],
+  "optionalDependencies": ["plugin-ts", "plugin-zod"],
   "compatibility": {
-    "kubb": ">=5.16.0",
+    "kubb": ">=5.18.4",
     "node": ">=22.22"
   },
   "role": "client",
@@ -199,7 +198,7 @@
       "key": "returnType",
       "path": ["returnType"],
       "label": "Return Type",
-      "description": "What a generated function resolves to. full is the whole result with status and error, data is only the success body when it throws, and plain is the client's own promise",
+      "description": "What a generated function resolves to. full is the whole result with status and error, and data is only the success body when it throws",
       "type": "select",
       "default": "full",
       "choices": [
@@ -208,9 +207,6 @@
         },
         {
           "value": "data"
-        },
-        {
-          "value": "plain"
         }
       ]
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.14.0-canary.20261109T134631",
+  "version": "6.0.1",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -39,6 +39,10 @@
     "src",
     "dist",
     "templates",
+    "!templates/config.ts",
+    "!templates/core.ts",
+    "!templates/serializers.ts",
+    "!templates/standardSchema.ts",
     "kubb-extension.json",
     "docs",
     "!/**/**.test.**",
@@ -67,8 +71,7 @@
     "./package.json": "./package.json",
     "./kubb-extension.json": "./kubb-extension.json",
     "./templates/*.ts": {
-      "types": "./dist/templates/*.d.ts",
-      "default": "./templates/*.ts"
+      "types": "./dist/templates/*.d.ts"
     },
     "./templates/*.js": {
       "types": "./dist/templates/*.d.ts"
@@ -80,15 +83,10 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/kit": "^5.16.0",
-    "@kubb/plugin-client": "^5.12.0-canary.20261109T134631",
-    "@kubb/plugin-ts": "^5.5.0-canary.20261109T134631",
-    "@kubb/plugin-zod": "^5.9.0-canary.20261109T134631",
-    "@kubb/renderer-jsx": "^5.16.0"
+    "@kubb/kit": "^5.18.8",
+    "@kubb/plugin-client": "^6.0.1"
   },
   "devDependencies": {
-    "@internals/client": "0.1.0-canary.20261109T134631",
-    "@internals/shared": "0.1.0-canary.20261109T134631",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {},

package/src/index.ts

@@ -1,3 +1,2 @@
-export { clientGenerator } from './generators/clientGenerator.tsx'
 export { default, pluginFetch, pluginFetchName } from './plugin.ts'
 export type { Options, PluginFetch, ResolvedOptions, ResolverClient } from './types.ts'

package/src/plugin.ts

@@ -1,14 +1,9 @@
-import path from 'node:path'
-import { createSdkGenerator, defaultMacros, isValidatorEnabled, resolverClient } from '@internals/client'
-import { createGroupConfig } from '@internals/shared'
-import { addGenerator, defineExtension, injectFile, Resolver, setMacros, setResolver, useConfig } from '@kubb/kit'
+import { fileURLToPath } from 'node:url'
+import { defineExtension } from '@kubb/kit'
+import { clientDependencies, resolveClientOptions, setupClient } from '@kubb/plugin-client'
 import { compatibility } from '../kubb-extension.json'
 import { version } from '../package.json'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { pluginZodName } from '@kubb/plugin-zod'
-import { clientGenerator } from './generators/clientGenerator.tsx'
-import { fetchClientTemplatePath, coreTemplatePath, serializersTemplatePath, sseTemplatePath, standardSchemaTemplatePath } from './templates.ts'
-import type { PluginFetch, ResolvedOptions, ResolverClient } from './types.ts'
+import type { PluginFetch } from './types.ts'
 
 /**
  * Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin
@@ -41,72 +36,10 @@ export const pluginFetchName = 'plugin-fetch' satisfies PluginFetch['name']
 export const pluginFetch = defineExtension<PluginFetch>({
   kind: 'plugin',
   meta: { name: pluginFetchName, version, compatibility },
-  // `plugin-ts` supplies the operation types unless it is absent, in which case `pluginZod({ inferred: true })`
-  // does. `plugin-zod` is required once `validator` enables a direction, so a missing one fails setup instead of codegen.
-  dependencies: (options) => ({ [pluginTsName]: { optional: true }, [pluginZodName]: { optional: !isValidatorEnabled(options.validator) } }),
+  dependencies: clientDependencies,
   setup(options) {
-    const config = useConfig()
-    const {
-      output = { path: 'clients', barrel: { type: 'named' } },
-      exclude = [],
-      include,
-      override = [],
-      baseURL,
-      throwOnErrorDefault = true,
-      validator = false,
-      returnType = 'full',
-      group,
-      sdk,
-      resolver: userResolver,
-    } = options
-
-    const resolved: ResolvedOptions = {
-      output,
-      exclude,
-      include,
-      override,
-      group: createGroupConfig(group),
-      baseURL,
-      throwOnErrorDefault,
-      validator,
-      returnType,
-      sdk: sdk ? { mode: sdk.mode ?? 'tag', name: sdk.name } : undefined,
-      resolver: userResolver ? Resolver.merge<ResolverClient>(resolverClient, userResolver) : resolverClient,
-    }
-
-    setResolver(resolved.resolver)
-    setMacros([...defaultMacros, ...(options.macros ?? [])])
-
-    // `sdk` swaps the per-operation functions for the class-based SDK; left unset, the standalone
-    // functions (which query plugins consume) stay.
-    addGenerator(resolved.sdk ? createSdkGenerator<PluginFetch>({ sse: sseTemplatePath }) : clientGenerator)
-
-    const root = path.resolve(config.root, config.output.path)
-
-    injectFile({
-      baseName: 'serializers.ts',
-      path: path.resolve(root, '.kubb/serializers.ts'),
-      copy: serializersTemplatePath,
-    })
-
-    injectFile({
-      baseName: 'core.ts',
-      path: path.resolve(root, '.kubb/core.ts'),
-      copy: coreTemplatePath,
-    })
-
-    injectFile({
-      baseName: 'client.ts',
-      path: path.resolve(root, '.kubb/client.ts'),
-      copy: fetchClientTemplatePath,
-    })
-
-    injectFile({
-      baseName: 'standardSchema.ts',
-      path: path.resolve(root, '.kubb/standardSchema.ts'),
-      copy: standardSchemaTemplatePath,
-    })
-
+    const resolved = resolveClientOptions(options)
+    setupClient({ name: 'fetch', resolved, macros: options.macros, client: fileURLToPath(new URL('../templates/client.ts', import.meta.url)) })
     return resolved
   },
 })

package/src/types.ts

@@ -1,7 +1,10 @@
 import type { PluginType } from '@kubb/kit'
-import type { Options, ResolvedOptions, ResolverClient } from '@internals/client'
+import type { ClientOptions, ClientResolvedOptions as ResolvedOptions, ResolverClient } from '@kubb/plugin-client'
 
-export type { Options, ResolvedOptions, ResolverClient } from '@internals/client'
+export type { ClientResolvedOptions as ResolvedOptions, ResolverClient } from '@kubb/plugin-client'
+
+/** The shared client options, without `returnType: 'plain'`, which only fits a client module `@kubb/plugin-client` calls. */
+export type Options = ClientOptions & { returnType?: 'full' | 'data' }
 
 /**
  * The plugin factory type for `@kubb/plugin-fetch`. Shares the options surface, resolver, and

package/templates/client.ts

@@ -1,39 +1,21 @@
-import {
-  createClientCore,
-  getResponseContentType,
-  resolveResponseType,
-  type ResponseType,
-  type ResponseTypeMap,
-  type Transport,
-  type TransportResult,
-} from './core.ts'
-import { isJsonMediaType } from './serializers.ts'
+import { createClientCore, createLazyClient, toRequestInit } from './core.ts'
+import { defaultConfig } from './config.ts'
 import * as core from './core.ts'
 
 export * from './core.ts'
 
-/** The request and response objects of this transport, carried on every result and error. */
+/**
+ * The native request and response that every result and error carries.
+ */
 export type NativeRequest = Request
 export type NativeResponse = Response
 
 /**
- * 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`.
+ * Extra `fetch` init for a call or client, such as `cache`, `redirect`, or Next.js's `next`.
  */
-export type FetchOptions = RequestInit & { next?: Record<string, unknown> }
+export type NativeOptions = RequestInit & { next?: Record<string, unknown> }
 
-export type RequestConfig<TBody = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core.RequestConfig<TBody, TRequest, TResponse> & {
-  options?: FetchOptions
-}
-export type Options<TData extends core.DataShape, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse> = core.Options<
-  TData,
-  ThrowOnError,
-  TRequest,
-  TResponse
-> & { options?: FetchOptions }
-export type ClientConfig<TRequest = NativeRequest, TResponse = NativeResponse> = core.ClientConfig<TRequest, TResponse> & { options?: FetchOptions }
-export type ResolvedRequest = core.ResolvedRequest & { options?: FetchOptions }
 export type ResponseError<TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core.ResponseError<TError, TRequest, TResponse>
-/** The core's `ResponseError` class, typed with this transport's request and response. `instanceof` and `ResponseError.is` both match what the client throws. */
 export const ResponseError = core.ResponseError as {
   new <TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse>(
     config: ConstructorParameters<typeof core.ResponseError<TError, TRequest, TResponse>>[0],
@@ -43,69 +25,68 @@ export const ResponseError = core.ResponseError as {
   prototype: core.ResponseError<unknown, NativeRequest, NativeResponse>
 }
 
-async function parseResponse(response: Response, responseType?: ResponseType | ResponseTypeMap): Promise<unknown> {
-  if (response.status === 204 || response.status === 205 || response.status === 304 || !response.body) {
-    return undefined
-  }
+export type RequestConfig<TBody = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core.RequestConfig<TBody, TRequest, TResponse> & {
+  options?: NativeOptions
+}
+export type Options<TData extends core.DataShape, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse> = core.Options<
+  TData,
+  ThrowOnError,
+  TRequest,
+  TResponse
+> & { options?: NativeOptions }
+export type ClientConfig<TRequest = NativeRequest, TResponse = NativeResponse> = core.ClientConfig<TRequest, TResponse> & { options?: NativeOptions }
+export type ResolvedRequest = core.ResolvedRequest & { options?: NativeOptions }
+export type RequestResult<
+  TResponses,
+  ThrowOnError extends boolean = true,
+  TRequest = NativeRequest,
+  TResponse = NativeResponse,
+  THeaders = unknown,
+> = core.RequestResult<TResponses, ThrowOnError, TRequest, TResponse, THeaders>
+export type UnwrappedResult<
+  TResponses,
+  ThrowOnError extends boolean = true,
+  TRequest = NativeRequest,
+  TResponse = NativeResponse,
+  THeaders = unknown,
+> = core.UnwrappedResult<TResponses, ThrowOnError, TRequest, TResponse, THeaders>
+export type ResponseErrorConfig<TError = unknown> = core.ResponseError<TError, NativeRequest, NativeResponse>
+export type TransportResult<TRequest = NativeRequest, TResponse = NativeResponse> = core.TransportResult<TRequest, TResponse>
+export type DecodedResponse<TData = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core.DecodedResponse<TData, TRequest, TResponse>
+export type Transport<TRequest = NativeRequest, TResponse = NativeResponse> = core.Transport<TRequest, TResponse>
+export type Interceptors<TRequest = NativeRequest, TResponse = NativeResponse> = core.Interceptors<TRequest, TResponse>
+export type ClientInstance<TRequest = NativeRequest, TResponse = NativeResponse> = core.ClientInstance<TRequest, TResponse>
+export type StreamResult<
+  TResponses,
+  ThrowOnError extends boolean = true,
+  TEvent = core.ServerSentEvent<core.SuccessOf<TResponses>>,
+  TRequest = NativeRequest,
+  TResponse = NativeResponse,
+  THeaders = unknown,
+> = core.StreamResult<TResponses, ThrowOnError, TEvent, TRequest, TResponse, THeaders>
+export type ResponseErrorOf<TResponses, TRequest = NativeRequest, TResponse = NativeResponse, THeaders = unknown> = core.ResponseErrorOf<
+  TResponses,
+  TRequest,
+  TResponse,
+  THeaders
+>
+export const isResponseError = core.isResponseError as <TResponses = unknown, TRequest = NativeRequest, TResponse = NativeResponse, THeaders = unknown>(
+  error: unknown,
+) => error is ResponseErrorOf<TResponses, TRequest, TResponse, THeaders>
 
-  const contentType = response.headers.get('Content-Type')
-  // A server may answer a streamed operation with JSON, or with an error body: both are decoded by their content type. Any other streamed success body stays a stream.
-  const resolved = resolveResponseType(responseType, contentType)
-  const detected = resolved === 'stream' && (!response.ok || isJsonMediaType(contentType)) ? resolveResponseType(undefined, contentType) : resolved
-  switch (detected) {
-    case 'text':
-    case 'document':
-      return response.text()
-    case 'blob':
-      return response.blob()
-    case 'arraybuffer':
-      return response.arrayBuffer()
-    case 'stream':
-      return response.body ?? undefined
-    case 'json': {
-      // An empty body with a JSON content-type would make response.json() throw, so treat it as no data.
-      const body = await response.text()
-      return body ? JSON.parse(body) : undefined
-    }
-  }
+export const defaultTransport = async (request: core.ResolvedRequest): Promise<TransportResult> => {
+  const nativeRequest = new Request(request.url, toRequestInit(request))
+  // `Request` drops the non-standard `next` field, so Next.js reads it from the init.
+  const nextInit: NativeOptions | undefined = request.options?.next ? { next: request.options.next } : undefined
+  const response = await globalThis.fetch(nativeRequest, nextInit)
 
-  const text = await response.text()
-  if (!text) return undefined
-  try {
-    return JSON.parse(text)
-  } catch {
-    return text
-  }
+  return { webResponse: response, request: nativeRequest, response }
 }
 
 /**
- * The default transport that sends the resolved request through `globalThis.fetch` and returns the parsed body with the native request and response.
+ * The client every generated operation uses unless a call passes its own. It is created on first use.
  */
-export const defaultTransport: Transport = async (request: ResolvedRequest): Promise<TransportResult> => {
-  const init: RequestInit = {
-    ...request.options,
-    method: request.method,
-    headers: request.headers,
-    body: request.body,
-    signal: request.signal,
-  }
-  if (request.credentials) init.credentials = request.credentials
-
-  const nativeRequest = new Request(request.url, init)
-  const response = await globalThis.fetch(nativeRequest)
-  const data = await parseResponse(response, request.responseType)
-
-  return {
-    data,
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers,
-    contentType: getResponseContentType(response.headers),
-    request: nativeRequest,
-    response,
-  }
-}
-
-export const client = createClientCore({ defaultTransport })
+export const client: ClientInstance = createLazyClient((config) => createClientCore({ defaultTransport, ...config }))
+client.setConfig(defaultConfig)
 
-export const createClient = (config?: Parameters<typeof client.createClient>[0]) => client.createClient(config)
+export const createClient: ClientInstance['createClient'] = client.createClient

package/dist/client-Dn80AjdR.d.ts

@@ -1,39 +0,0 @@
-import { n as __exportAll, r as __reExport, t as core_d_exports } from "./core-D6FAGTsL.js";
-declare namespace client_d_exports {
-  export { ClientConfig, FetchOptions, NativeRequest, NativeResponse, Options, RequestConfig, ResolvedRequest, ResponseError, client, createClient, defaultTransport };
-}
-/** The request and response objects of this transport, carried on every result and error. */
-type NativeRequest = Request;
-type NativeResponse = Response;
-/**
- * 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`.
- */
-type FetchOptions = RequestInit & {
-  next?: Record<string, unknown>;
-};
-type RequestConfig<TBody = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core_d_exports.RequestConfig<TBody, TRequest, TResponse> & {
-  options?: FetchOptions;
-};
-type Options<TData extends core_d_exports.DataShape, ThrowOnError extends boolean = true, TRequest = NativeRequest, TResponse = NativeResponse> = core_d_exports.Options<TData, ThrowOnError, TRequest, TResponse> & {
-  options?: FetchOptions;
-};
-type ClientConfig<TRequest = NativeRequest, TResponse = NativeResponse> = core_d_exports.ClientConfig<TRequest, TResponse> & {
-  options?: FetchOptions;
-};
-type ResolvedRequest = core_d_exports.ResolvedRequest & {
-  options?: FetchOptions;
-};
-type ResponseError<TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse> = core_d_exports.ResponseError<TError, TRequest, TResponse>;
-/** The core's `ResponseError` class, typed with this transport's request and response. `instanceof` and `ResponseError.is` both match what the client throws. */
-declare const ResponseError: {
-  new <TError = unknown, TRequest = NativeRequest, TResponse = NativeResponse>(config: ConstructorParameters<typeof core_d_exports.ResponseError<TError, TRequest, TResponse>>[0]): core_d_exports.ResponseError<TError, TRequest, TResponse>;
-  is: typeof core_d_exports.ResponseError.is;
-  prototype: core_d_exports.ResponseError<unknown, NativeRequest, NativeResponse>;
-};
-/**
- * The default transport that sends the resolved request through `globalThis.fetch` and returns the parsed body with the native request and response.
- */
-declare const defaultTransport: core_d_exports.Transport;
-declare const client: core_d_exports.ClientInstance<unknown, unknown>;
-declare const createClient: (config?: Parameters<typeof client.createClient>[0]) => core_d_exports.ClientInstance<unknown, unknown>;
-export { Options as a, ResponseError as c, createClient as d, defaultTransport as f, NativeResponse as i, client as l, FetchOptions as n, RequestConfig as o, NativeRequest as r, ResolvedRequest as s, ClientConfig as t, client_d_exports as u };

package/dist/core-D6FAGTsL.d.ts

@@ -1,2 +0,0 @@
-import * as import__kubb_plugin_client_templates_core_ts from "@kubb/plugin-client/templates/core.ts";
-export { __exportAll as n, __reExport as r, core_d_exports as t };

package/dist/templates/core.d.ts

@@ -1,2 +0,0 @@
-import "../core-D6FAGTsL.js";
-export * from "@kubb/plugin-client/templates/core.ts";

package/dist/templates/fetch.d.ts

@@ -1,6 +0,0 @@
-import { a as Options, c as ResponseError, d as createClient, f as defaultTransport, i as NativeResponse, l as client, n as FetchOptions, o as RequestConfig, r as NativeRequest, s as ResolvedRequest, t as ClientConfig, u as client_d_exports } from "../client-Dn80AjdR.js";
-export * from "@kubb/plugin-client/templates/core.ts";
-declare namespace fetch_d_exports {
-  export { ClientConfig, FetchOptions, NativeRequest, NativeResponse, Options, RequestConfig, ResolvedRequest, ResponseError, client, createClient, defaultTransport };
-}
-export { ClientConfig, FetchOptions, NativeRequest, NativeResponse, Options, RequestConfig, ResolvedRequest, ResponseError, client, createClient, defaultTransport };

package/dist/templates/serializers.d.ts

@@ -1 +0,0 @@
-export * from "@kubb/plugin-client/templates/serializers.ts";

package/dist/templates/standardSchema.d.ts

@@ -1 +0,0 @@
-export * from "@kubb/plugin-client/templates/standardSchema.ts";

package/src/generators/clientGenerator.tsx

@@ -1,10 +0,0 @@
-import { createClientGenerator } from '@internals/client'
-import { sseTemplatePath } from '../templates.ts'
-import type { PluginFetch } from '../types.ts'
-
-/**
- * Built-in operation generator for `@kubb/plugin-fetch`. Emits one async function per OpenAPI
- * operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
- * that forwards a single `options` object to the bundled `client` and returns the `RequestResult`.
- */
-export const clientGenerator = createClientGenerator<PluginFetch>('fetch', { sse: sseTemplatePath })

package/src/templates.ts

@@ -1,16 +0,0 @@
-import { createRequire } from 'node:module'
-import { fileURLToPath } from 'node:url'
-
-const require = createRequire(import.meta.url)
-
-/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
-export const fetchClientTemplatePath = fileURLToPath(new URL('../templates/client.ts', import.meta.url))
-
-/**
- * Absolute paths to the runtime templates `@kubb/plugin-client` ships for every client plugin, copied into `.kubb/core.ts`,
- * `.kubb/serializers.ts`, `.kubb/standardSchema.ts`, and `.kubb/sse.ts`.
- */
-export const coreTemplatePath = require.resolve('@kubb/plugin-client/templates/core.ts')
-export const serializersTemplatePath = require.resolve('@kubb/plugin-client/templates/serializers.ts')
-export const standardSchemaTemplatePath = require.resolve('@kubb/plugin-client/templates/standardSchema.ts')
-export const sseTemplatePath = require.resolve('@kubb/plugin-client/templates/sse.ts')

package/templates/core.ts

@@ -1,2 +0,0 @@
-// Resolves `./core.ts` for the client template next to it. The generator copies the file from `@kubb/plugin-client` into `.kubb/core.ts`.
-export * from '@kubb/plugin-client/templates/core.ts'

package/templates/fetch.ts

@@ -1,2 +0,0 @@
-// The client template was `templates/fetch.ts` before it became `templates/client.ts`; this keeps the old subpath working.
-export * from './client.ts'

package/templates/serializers.ts

@@ -1,2 +0,0 @@
-// Resolves `./serializers.ts` for the client template next to it. The generator copies the file from `@kubb/plugin-client` into `.kubb/serializers.ts`.
-export * from '@kubb/plugin-client/templates/serializers.ts'

package/templates/standardSchema.ts

@@ -1,2 +0,0 @@
-// Resolves `./standardSchema.ts` for the client template next to it. The generator copies the file from `@kubb/plugin-client` into `.kubb/standardSchema.ts`.
-export * from '@kubb/plugin-client/templates/standardSchema.ts'