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

package/dist/index.js

@@ -1,1709 +1,13 @@
-import { createRequire } from "node:module";
-import { Diagnostics, Resolver, Url, addGenerator, ast, camelCase, createResolver, defineExtension, defineGenerator, injectFile, macroDedupeUnion, pascalCase, setMacros, setResolver, useConfig } from "@kubb/kit";
-import path from "node:path";
-import { pluginZodName } from "@kubb/plugin-zod";
-import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
-import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
 import { fileURLToPath } from "node:url";
-// ../../internals/shared/src/operation.ts
-/**
-* Builds the `ResolverFileParams` every operation generator passes to
-* `resolver.file`: a file named `name`, tagged by the operation's first
-* tag (or `'default'`), at the operation's path. Centralizes the entry object
-* that was repeated at dozens of call sites across the client and query plugins.
-*
-* @example
-* ```ts
-* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
-* ```
-*/
-function operationFileEntry(node, name, extname = ".ts") {
-	return {
-		name,
-		extname,
-		tag: node.tags[0] ?? "default",
-		path: node.path
-	};
-}
-/**
-* Resolves a dependency plugin's generated file for `node.operationId`, cached in `memo` (the
-* build's `ctx.memo`) under the resolver's own plugin name and the operation. Several dependents reading the
-* same dependency for the same operation in one pass (a query plugin's several hook generators, the
-* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
-*
-* @example Cache `plugin-ts`'s file for the current operation
-* ```ts
-* const fileTs = resolveDependencyOperationFile({ memo: ctx.memo, node, resolver: tsResolver, root, output })
-* ```
-*/
-function resolveDependencyOperationFile(options) {
-	const { memo, node, resolver, root, output, group } = options;
-	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => resolver.file({
-		...operationFileEntry(node, node.operationId),
-		root,
-		output,
-		group: group ?? void 0
-	}));
-}
-function getOperationLink(node, link) {
-	if (!link) return null;
-	if (typeof link === "function") return link(node) ?? null;
-	return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
-}
-/**
-* Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
-* are present and the union, default, and form-data flags the client uses to pick one.
-*/
-function buildContentTypeInfo(contentTypes) {
-	const isMultipleContentTypes = contentTypes.length > 1;
-	return {
-		contentTypes,
-		isMultipleContentTypes,
-		contentTypeUnion: isMultipleContentTypes ? contentTypes.map((ct) => JSON.stringify(ct)).join(" | ") : "",
-		defaultContentType: contentTypes[0] ?? "application/json",
-		hasFormData: contentTypes.some((ct) => ct === "multipart/form-data")
-	};
-}
-function getContentTypeInfo(node) {
-	return buildContentTypeInfo(node.requestBody?.content?.map((e) => e.contentType) ?? []);
-}
-/**
-* The request-body counterpart for the primary success response: the content types it documents and
-* whether several are present, so the client can let a caller pick which one to accept.
-*/
-function getResponseContentTypeInfo(node) {
-	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
-}
-/**
-* Reads the single base content type of an operation's primary success response, lowercased and
-* stripped of any `; charset=...` suffix. Returns `undefined` when the response declares zero or
-* more than one content type, since neither case has a single type to act on.
-*/
-function getPrimarySuccessContentType(node) {
-	const contentTypes = getPrimarySuccessResponse(node)?.content?.map((entry) => entry.contentType) ?? [];
-	if (contentTypes.length !== 1) return void 0;
-	return contentTypes[0].split(";")[0].trim().toLowerCase();
-}
-/**
-* The `text/event-stream` content of the primary success response, when it is the only content type. A response that also
-* declares another type stays a normal call with its query hooks.
-*/
-function getEventStreamContent(node) {
-	return getPrimarySuccessContentType(node) === "text/event-stream" ? getPrimarySuccessResponse(node)?.content?.[0] : void 0;
-}
-/**
-* Whether an operation streams its primary success response as Server-Sent Events (`text/event-stream`). The client
-* generator uses this to return a typed event stream instead of a one-shot `RequestResult`.
-*/
-function isEventStream(node) {
-	return getEventStreamContent(node) !== void 0;
-}
-/**
-* How the document types a `text/event-stream` response, as the adapter read it from `itemSchema`: `event` when each item is
-* the parsed event with its own `event` and `data`, `data` when it is only the payload. Returns `null` without an event stream.
-*/
-function getEventStream(node) {
-	const content = getEventStreamContent(node);
-	return content ? content.stream?.shape ?? "data" : null;
-}
-function baseContentType(contentType) {
-	return contentType.split(";")[0].trim().toLowerCase();
-}
-function isJsonContentType(baseType) {
-	return baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json";
-}
-/**
-* Parser for one response content entry.
-*
-* JSON stays unset so the runtime detects it. `text/event-stream` is a stream. A binary schema
-* (`format: binary` / `contentMediaType`) is a blob even when the media type is not a well-known
-* binary type. Other `text/*` is text, and `application/octet-stream`, `application/pdf`,
-* `image/*`, `audio/*`, and `video/*` are blobs.
-*/
-function responseTypeForContent(contentType, schema) {
-	const baseType = baseContentType(contentType);
-	if (!baseType) return void 0;
-	if (isJsonContentType(baseType)) return void 0;
-	if (baseType === "text/event-stream") return "stream";
-	if (schema?.type === "blob") return "blob";
-	if (baseType.startsWith("text/")) return "text";
-	if (baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType)) return "blob";
-}
-/**
-* Derives the default `responseType` string for an operation from its primary success response.
-*
-* One content type uses {@link responseTypeForContent}. Several content types that all use the same
-* parser collapse to that string, so a call can keep `responseType: 'blob'`. Mixed parsers return
-* `undefined`; {@link getResponseTypeMap} carries the per-type choice.
-*/
-function getResponseType(node) {
-	const entries = getPrimarySuccessResponse(node)?.content ?? [];
-	if (entries.length === 0) return void 0;
-	const responseTypes = entries.map((entry) => responseTypeForContent(entry.contentType, entry.schema));
-	const first = responseTypes[0];
-	if (!first) return void 0;
-	if (responseTypes.every((responseType) => responseType === first)) return first;
-}
-/**
-* Maps each base content type of a primary success response to its parser when those parsers differ.
-*
-* Keys are lowercased and stripped of parameters. JSON entries are kept as `'json'` so a catch-all
-* entry cannot claim a JSON response. Returns `undefined` when {@link getResponseType} already
-* covers the response with one string, or when no content type needs a parser other than JSON.
-* The runtime matches the response `Content-Type` against this map instead of guessing from the media type.
-*/
-function getResponseTypeMap(node) {
-	if (getResponseType(node)) return void 0;
-	const entries = getPrimarySuccessResponse(node)?.content ?? [];
-	if (entries.length <= 1) return void 0;
-	const map = {};
-	for (const entry of entries) {
-		const baseType = baseContentType(entry.contentType);
-		const responseType = responseTypeForContent(entry.contentType, entry.schema) ?? (isJsonContentType(baseType) ? "json" : void 0);
-		if (baseType && responseType) map[baseType] = responseType;
-	}
-	return Object.values(map).some((responseType) => responseType !== "json") ? map : void 0;
-}
-/**
-* Which of the grouped request options an operation carries.
-*/
-function getRequestGroups(node) {
-	const { path, query, header } = getOperationParameters(node);
-	return {
-		path: path.length > 0,
-		query: query.length > 0,
-		body: Boolean(node.requestBody?.content?.[0]?.schema),
-		headers: header.length > 0
-	};
-}
-/**
-* Resolves which grouped request options an operation carries together with whether each group
-* holds a required member. The grouped parameter stays optional only when nothing inside it is
-* required, matching the generated `RequestConfig` type.
-*/
-function getRequestGroupOptionality(node) {
-	const groups = getRequestGroups(node);
-	const { path, query, header } = getOperationParameters(node);
-	const hasRequiredPath = path.some((param) => param.required);
-	const hasRequiredQuery = query.some((param) => param.required);
-	const hasRequiredHeader = header.some((param) => param.required);
-	return {
-		groups,
-		hasRequiredPath,
-		hasRequiredQuery,
-		hasRequiredHeader,
-		isOptional: !hasRequiredPath && !hasRequiredQuery && !hasRequiredHeader && !(groups.body && node.requestBody?.required === true)
-	};
-}
-function buildOperationComments(node, options = {}) {
-	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
-	const linkComment = getOperationLink(node, link);
-	const filteredComments = (linkPosition === "beforeDeprecated" ? [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		linkComment,
-		node.deprecated && "@deprecated"
-	] : [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		node.deprecated && "@deprecated",
-		linkComment
-	]).filter((comment) => Boolean(comment));
-	if (!splitLines) return filteredComments;
-	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
-}
-const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
-/**
-* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
-* per property, typed and serialized like any other.
-* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
-*/
-function spreadQuerystring(param) {
-	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
-	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
-	if (schema?.type !== "object" || !formEncoded) return [param];
-	return schema.properties.map((property) => ast.factory.createParameter({
-		name: property.name,
-		in: "query",
-		schema: property.schema,
-		required: param.required && property.required
-	}));
-}
-/**
-* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
-* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
-* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
-* same parameters once per plugin.
-*/
-function getOperationParameters(node) {
-	const cached = operationParameterGroupsByNode.get(node);
-	if (cached) return cached;
-	const dedupe = (params) => {
-		const seen = /* @__PURE__ */ new Set();
-		return params.filter((param) => {
-			if (seen.has(param.name)) return false;
-			seen.add(param.name);
-			return true;
-		});
-	};
-	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
-	const groups = {
-		path: group("path"),
-		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
-		header: group("header"),
-		cookie: group("cookie")
-	};
-	operationParameterGroupsByNode.set(node, groups);
-	return groups;
-}
-/**
-* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
-* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
-* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
-* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
-* printer to emit `z.object(…)` rather than a record.
-*/
-function hasRequestContentTypeChoice(node) {
-	return (node.requestBody?.content ?? []).filter((entry) => entry.schema).length > 1;
-}
-function getStatusCodeNumber(statusCode) {
-	const code = Number(statusCode);
-	return Number.isNaN(code) ? null : code;
-}
-function isSuccessStatusCode(statusCode) {
-	const code = getStatusCodeNumber(statusCode);
-	return code !== null && code >= 200 && code < 300;
-}
-function getSuccessResponses(responses) {
-	return responses.filter((response) => isSuccessStatusCode(response.statusCode));
-}
-function getOperationSuccessResponses(node) {
-	return getSuccessResponses(node.responses);
-}
-function getPrimarySuccessResponse(node) {
-	return getOperationSuccessResponses(node)[0] ?? null;
-}
-// ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = /* @__PURE__ */ new Set([
-	"abstract",
-	"arguments",
-	"await",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return isIdentifier(name);
-}
-/**
-* Returns `name` when it's a syntactically valid JavaScript variable name,
-* otherwise prefixes it with `_` so the result is a valid identifier.
-*
-* Useful for sanitizing OpenAPI schema names or operation IDs that start with
-* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
-* variable, type, or function names.
-*
-* @example
-* ```ts
-* ensureValidVarName('409')             // '_409'
-* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
-* ensureValidVarName('Pet')              // 'Pet'
-* ensureValidVarName('class')            // '_class'
-* ```
-*/
-function ensureValidVarName(name) {
-	if (!name || isValidVarName(name)) return name;
-	return `_${name}`;
-}
-/**
-* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
-*
-* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
-* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
-* deciding whether an object key needs quoting.
-*
-* @example
-* ```ts
-* isIdentifier('name')   // true
-* isIdentifier('x-total')// false
-* ```
-*/
-function isIdentifier(name) {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-// ../../internals/utils/src/codegen.ts
-/**
-* Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no
-* comments.
-*
-* @example
-* ```ts
-* buildJSDoc(['@type string', '@example hello'])
-* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
-* ```
-*/
-function buildJSDoc(comments, options = {}) {
-	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
-	if (comments.length === 0) return fallback;
-	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
-}
-// ../../internals/shared/src/resolver.ts
-/**
-* The shared top-level `name` of the operation plugins, computed once per operation name and build.
-*/
-function resolveOperationName(name) {
-	return this.memo(`operation:${name}`, () => ensureValidVarName(camelCase(name)));
-}
-/**
-* Builds the allocation key for a declaration an operation owns. `scope` names which declaration
-* it is, so two of them never share an allocation even when a custom resolver gives both the same
-* name. Leave `scope` empty for the operation's own declaration.
-*
-* @example
-* ```ts
-* resolver.resolveName({ key: operationKey(node, 'response', 'status', 404), name })
-* ```
-*/
-function operationKey(node, ...scope) {
-	return [
-		"operation",
-		node.method,
-		node.path,
-		...scope.map(String)
-	];
-}
-// ../../internals/shared/src/group.ts
-/**
-* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
-* shared default naming so every plugin groups output consistently:
-*
-* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
-* - other groups use the camelCased group (`pet store` → `petStore`).
-*
-* A user-provided `group.name` always wins over the default namer, so callers stay in
-* control of their output folders. Returns `null` when grouping is disabled, matching the
-* per-plugin convention.
-*
-* @param group - The user-supplied group option, or `undefined` to disable grouping.
-*
-* @example
-* ```ts
-* createGroupConfig(group) // shared across every plugin
-* ```
-*/
-function createGroupConfig(group) {
-	if (!group) return null;
-	const defaultName = (ctx) => {
-		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-		return camelCase(ctx.group);
-	};
-	return {
-		...group,
-		name: group.name ? group.name : defaultName
-	};
-}
-// ../../internals/client/src/builders/validatorOptions.ts
-/**
-* Returns `true` when any direction of the validator uses zod (used for dependency checks).
-*/
-function isValidatorEnabled(validator) {
-	if (!validator) return false;
-	if (validator === "zod") return true;
-	return Boolean(validator.request || validator.params || validator.response);
-}
-/**
-* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
-* `'zod'` validates the response only, so it does not enable request parsing.
-*/
-function resolveRequestValidator(validator) {
-	if (!validator || validator === "zod") return null;
-	return validator.request ?? null;
-}
-/**
-* Returns `'zod'` when path, query, and header params parsing is enabled, `null` otherwise. Only the
-* object form `{ params: 'zod' }` enables it.
-*/
-function resolveParamsValidator(validator) {
-	if (!validator || validator === "zod") return null;
-	return validator.params ?? null;
-}
-/**
-* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
-* maps to response parsing.
-*/
-function resolveResponseValidator(validator) {
-	if (!validator) return null;
-	if (validator === "zod") return "zod";
-	return validator.response ?? null;
-}
-/**
-* Resolves the zod schema name a generated client validates an error body with on the non-throw path.
-* Uses the error-only `<operation>ErrorSchema` (the union of non-2xx statuses); returns `null` when the
-* operation documents no error responses with a schema.
-*/
-function buildZodErrorParse(node, zodResolver) {
-	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
-	return zodResolver.response.error?.(node) || null;
-}
-// ../../internals/client/src/builders/generics.ts
-/**
-* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
-* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
-* runtime, so this only names the record and threads `ThrowOnError`.
-*
-* @example
-* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
-*/
-function buildRequestResultGenerics({ node, types }) {
-	return `${types.response.responses(node)}, ThrowOnError`;
-}
-/**
-* Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
-* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, a plain
-* `Promise<RequestResult>` for the internal `'plain'` shape, or a
-* `Promise` of the runtime's `UnwrappedResult` when `returnType: 'data'` narrows a resolved call
-* down to the bare success body.
-*
-* @example
-* `buildResultType({ node, types, returnType: 'data' }) // 'Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>'`
-*/
-function buildResultType({ node, types, returnType }) {
-	const generics = buildRequestResultGenerics({
-		node,
-		types
-	});
-	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
-	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
-	return `Unwrappable<RequestResult<${generics}>>`;
-}
-// ../../internals/client/src/builders/returnStatement.ts
-/**
-* Builds the return statement of a generated operation function. With the default
-* `returnType: 'full'` the runtime call already resolves to `{ data, error, request, response }`.
-* The generated code casts that result to the operation's `RequestResult`, then wraps it with
-* `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
-* body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
-* which narrows the resolved value down to the bare success body the same way `RequestResult`
-* already does, using the plugin default when the call leaves `throwOnError` unset.
-* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
-*
-* Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
-* as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
-* straight to `Unwrappable<B>` does not work: the `.then` overload stays pinned to `A`, and `as`
-* rejects that two-generic swap even where `A` and `B` on their own would satisfy it.
-*
-* @example
-* `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
-* @example
-* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
-* @example
-* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
-*/
-function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
-	const request = returnType !== "plain" && hasRequestContentTypeChoice(node) ? `request<${types.response.options(node)}['body']>` : "request";
-	if (returnType === "data") return `return unwrapResult(${request}(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
-		node,
-		types,
-		returnType
-	})}`;
-	if (returnType === "plain") return `return ${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		types
-	})}>>`;
-	return `return withUnwrap(${request}(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		types
-	})}>>)`;
-}
-/**
-* Builds the return type and statement of a `text/event-stream` operation. The item type is `TypedEvent<...>` when each item
-* declares its own `event` and `data`, and otherwise the payload type, which `EventStreamResult` wraps in `ServerSentEvent`. The call's
-* promise goes through `toEventStream` with the `client` for its defaults, the call's `config`, the shape and the per-event
-* validator. A `returnType: 'plain'` client receives only the promise,
-* `toEventStream(request(config))`, and keeps its response validator in the call config.
-*/
-function buildEventStreamReturn({ node, types, callConfig, returnType, validatorHooks, throwOnErrorDefault }) {
-	const shape = getEventStream(node) ?? "data";
-	const responses = types.response.responses(node);
-	const success = `SuccessOf<${responses}>`;
-	const eventType = shape === "event" ? `TypedEvent<${success}>` : success;
-	if (returnType === "plain") return {
-		returnType: `Promise<EventStreamResult<${eventType}>>`,
-		statement: `return toEventStream<${eventType}>(request(${callConfig}))`
-	};
-	const generics = `${responses}, ThrowOnError${shape === "event" ? `, ${eventType}` : ""}`;
-	const call = `toEventStream<${eventType}>(request(${callConfig}), { client: request, config, ${[`shape: '${shape}'`, validatorHooks?.response ? `validator: ${validatorHooks.response}` : null].filter(Boolean).join(", ")} })`;
-	if (returnType === "data") {
-		const result = `Promise<UnwrappedStreamResult<${generics}>>`;
-		return {
-			returnType: result,
-			statement: `return unwrapResult(${call}, config.throwOnError ?? ${throwOnErrorDefault}) as ${result}`
-		};
-	}
-	return {
-		returnType: `Unwrappable<StreamResult<${generics}>>`,
-		statement: `return withUnwrap(${call} as Promise<StreamResult<${generics}>>)`
-	};
-}
-/** The stream types an operation file imports: `StreamResult` and `StreamOptions`, `EventStreamResult` for a plain client, and `TypedEvent` for named events. */
-function buildEventStreamImports({ returnType, typed }) {
-	return [...{
-		plain: ["EventStreamResult"],
-		full: ["StreamResult", "StreamOptions"],
-		data: ["UnwrappedStreamResult", "StreamOptions"]
-	}[returnType], ...typed ? ["TypedEvent"] : []];
-}
-// ../../internals/client/src/builders/security.ts
-function serializeAuth(auth) {
-	const parts = [`type: '${auth.type}'`];
-	if (auth.scheme) parts.push(`scheme: '${auth.scheme}'`);
-	if (auth.name) parts.push(`name: '${auth.name}'`);
-	if (auth.in) parts.push(`in: '${auth.in}'`);
-	if (auth.scopes?.length) parts.push(`scopes: [${auth.scopes.map((scope) => `'${scope}'`).join(", ")}]`);
-	return `{ ${parts.join(", ")} }`;
-}
-/**
-* Maps an OpenAPI security scheme to the inline `Auth` object, or `null` when the runtime cannot
-* place it (an unresolved `$ref`, or an `apiKey` without a name or outside `header` / `query` /
-* `cookie`). `http` schemes other than `basic` are treated as bearer.
-*/
-function resolveSecurityScheme(scheme) {
-	if (!scheme || "$ref" in scheme) return null;
-	if (scheme.type === "apiKey") {
-		if (!scheme.name || scheme.in !== "header" && scheme.in !== "query" && scheme.in !== "cookie") return null;
-		return {
-			type: "apiKey",
-			name: scheme.name,
-			in: scheme.in
-		};
-	}
-	if (scheme.type === "http") return {
-		type: "http",
-		scheme: scheme.scheme?.toLowerCase() === "basic" ? "basic" : "bearer"
-	};
-	if (scheme.type === "oauth2") return { type: "oauth2" };
-	if (scheme.type === "openIdConnect") return { type: "openIdConnect" };
-	return null;
-}
-/**
-* Derives the per-operation security metadata from the OpenAPI document. The operation's own
-* `security` overrides the global `security` (an explicit empty array disables auth), and every
-* referenced scheme is resolved from `components.securitySchemes` into a flat, de-duplicated list of
-* `Auth` objects the runtime walks in order.
-*
-* @example
-* `getOperationSecurity({ document, method: 'POST', path: '/pet' })`
-* `// [{ type: 'http', scheme: 'bearer' }]`
-*/
-function getOperationSecurity({ document, method, path }) {
-	if (!document) return void 0;
-	const requirements = (document.paths?.[path]?.[method.toLowerCase()])?.security ?? document.security;
-	if (!requirements?.length) return void 0;
-	const definitions = document.components?.securitySchemes ?? {};
-	const security = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const requirement of requirements) for (const [schemeName, scopes] of Object.entries(requirement)) {
-		if (seen.has(schemeName)) continue;
-		seen.add(schemeName);
-		const auth = resolveSecurityScheme(definitions[schemeName]);
-		if (auth) security.push(scopes.length ? {
-			...auth,
-			scopes
-		} : auth);
-	}
-	return security.length ? security : void 0;
-}
-/**
-* Serializes the per-operation security into the literal emitted on each generated call's `security`
-* field. The runtime `resolveAuth` helper walks it, calling the configured `auth` resolver per entry.
-*
-* @example
-* `buildSecurityMetadata({ security: [{ type: 'http', scheme: 'bearer' }] }) // "[{ type: 'http', scheme: 'bearer' }]"`
-*/
-function buildSecurityMetadata({ security }) {
-	if (!security?.length) return null;
-	return `[${security.map(serializeAuth).join(", ")}]`;
-}
-// ../../internals/client/src/builders/validator.ts
-/**
-* Builds the validator-hook references for one operation. Request body and params validation run before the send.
-* Response validation runs on the success body only. Returns `null` references when the matching
-* direction is disabled or the schema is absent.
-*/
-function buildValidatorHooks({ node, validator, zodResolver }) {
-	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const parsesResponse = zodResolver && resolveResponseValidator(validator) === "zod";
-	const response = parsesResponse ? zodResolver.response.response(node) || null : null;
-	const error = parsesResponse ? buildZodErrorParse(node, zodResolver) : null;
-	const request = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) || null : null;
-	const paramGroups = getOperationParameters(node);
-	const resolveParamsName = (kind, params) => zodResolver && resolveParamsValidator(validator) === "zod" && params.length > 0 ? zodResolver.param[kind](node, params[0]) : null;
-	const path = resolveParamsName("path", paramGroups.path);
-	const query = resolveParamsName("query", paramGroups.query);
-	const headers = resolveParamsName("headers", paramGroups.header);
-	const importedZodNames = [
-		response,
-		error,
-		request,
-		path,
-		query,
-		headers
-	].filter((name) => Boolean(name));
-	return {
-		request,
-		path,
-		query,
-		headers: headers ? `toHeadersStandardSchema(${headers}, ${headers}.shape)` : null,
-		response,
-		error,
-		importedZodNames
-	};
-}
-/**
-* Prints the `validator: { … }` entry of a call config from the hooks named in `keys`, or `null` when none is set.
-*/
-function buildValidatorLiteral(hooks, keys) {
-	const entries = keys.flatMap((key) => hooks?.[key] ? [`${key}: ${hooks[key]}`] : []);
-	return entries.length ? `validator: { ${entries.join(", ")} }` : null;
-}
-// ../../internals/client/src/builders/contentType.ts
-/**
-* Builds the `contentType` entry baked into the call config, or `null` without a request body.
-*
-* `merge` is `true` when the generated function must destructure `contentType` from `options` and
-* merge it over the baked request default, because the caller can also pick a response content type.
-*/
-function buildContentType({ node }) {
-	const { defaultContentType } = getContentTypeInfo(node);
-	const requestContentType = Boolean(node.requestBody?.content?.[0]?.schema) ? defaultContentType : null;
-	if (!requestContentType) return {
-		literal: null,
-		merge: false
-	};
-	const merge = getResponseContentTypeInfo(node).isMultipleContentTypes;
-	return {
-		merge,
-		literal: merge ? `contentType: { request: '${requestContentType}', ...(typeof contentType === 'string' ? { request: contentType } : contentType) }` : `contentType: { request: '${requestContentType}' }`
-	};
-}
-// ../../internals/client/src/builders/styles.ts
-/**
-* Renders a parameter name as an object-literal key, quoted when it is not a bare identifier. Every
-* location keeps the spec name: the runtime looks path styles up by the `{name}` placeholder in the
-* URL, and the other locations by the key it serializes.
-*/
-function toKey(name) {
-	return isValidVarName(name) ? name : JSON.stringify(name);
-}
-/**
-* Serializes one parameter's metadata into a `{ style, explode, allowReserved, contentType }`
-* literal, or `null` when the parameter carries none. Path and query carry the serialization
-* `style`; header and cookie use a fixed style (`simple` and `form`), so only `explode` is emitted
-* for them. `allowReserved` only applies to query parameters, and `contentType` to every location
-* except path.
-*/
-function serializeParameter(parameter) {
-	const parts = [];
-	if ((parameter.in === "path" || parameter.in === "query") && parameter.style) parts.push(`style: '${parameter.style}'`);
-	if (parameter.explode !== void 0) parts.push(`explode: ${parameter.explode}`);
-	if (parameter.in === "query" && parameter.allowReserved !== void 0) parts.push(`allowReserved: ${parameter.allowReserved}`);
-	if (parameter.in !== "path" && parameter.contentType) parts.push(`contentType: '${parameter.contentType}'`);
-	if (parameter.in === "querystring") parts.push("querystring: true");
-	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
-}
-/**
-* Serializes the `encoding` of the request body's default content type into a `{ property: { ... } }`
-* literal, or `null` when it carries none. Only an operation with a single request content type
-* emits it, because the runtime applies `styles.body` to whichever type the caller selects.
-*/
-function serializeBodyEncoding(node) {
-	const content = node.requestBody?.content;
-	const entries = Object.entries(content?.length === 1 ? content[0]?.encoding ?? {} : {}).map(([property, { contentType, style, explode, allowReserved }]) => {
-		const parts = [
-			style && `style: ${JSON.stringify(style)}`,
-			explode !== void 0 && `explode: ${explode}`,
-			allowReserved !== void 0 && `allowReserved: ${allowReserved}`,
-			contentType && `contentType: ${JSON.stringify(contentType)}`
-		].filter(Boolean);
-		return `${isValidVarName(property) ? property : JSON.stringify(property)}: { ${parts.join(", ")} }`;
-	});
-	return entries.length > 0 ? `body: { ${entries.join(", ")} }` : null;
-}
-/**
-* Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
-* Entries are keyed by the spec name of the parameter.
-* Only parameters whose source defines `style`, `explode`, `allowReserved`, or `contentType` are
-* emitted, so calls without serialization metadata keep the runtime defaults and existing output
-* is unchanged. A form request body adds a `body` group keyed by property name from its `encoding`.
-* Returns `null` when nothing carries metadata.
-*
-* @example
-* ```ts
-* // a path param with { style: 'matrix', explode: true } and a query param with { explode: false }
-* buildStyles({ node }) // "{ path: { id: { style: 'matrix', explode: true } }, query: { tags: { explode: false } } }"
-* ```
-*/
-function buildStyles({ node }) {
-	if (!ast.isHttpOperationNode(node)) return null;
-	const groups = {
-		path: [],
-		query: [],
-		header: [],
-		cookie: []
-	};
-	for (const [location, parameters] of Object.entries(getOperationParameters(node))) for (const parameter of parameters) {
-		const literal = serializeParameter(parameter);
-		if (literal) groups[location].push(`${toKey(parameter.name)}: ${literal}`);
-	}
-	const entries = [...Object.keys(groups).filter((location) => groups[location].length > 0).map((location) => `${location}: { ${groups[location].join(", ")} }`), serializeBodyEncoding(node)].filter(Boolean);
-	return entries.length > 0 ? `{ ${entries.join(", ")} }` : null;
-}
-// ../../internals/client/src/builders/callConfig.ts
-/**
-* `responseType` baked into a call. One parser is a string. Several parsers become a map from content
-* type to parser so the runtime can choose from the response `Content-Type`.
-*/
-function buildResponseTypeLiteral(node) {
-	const responseType = getResponseType(node);
-	if (responseType) return `responseType: '${responseType}'`;
-	const responseTypes = getResponseTypeMap(node);
-	if (!responseTypes) return null;
-	return `responseType: { ${Object.entries(responseTypes).map(([contentType, type]) => `${JSON.stringify(contentType)}: '${type}'`).join(", ")} }`;
-}
-/**
-* Builds the call config literal a generated operation forwards to the client, shared by the standalone
-* functions and the SDK methods. The `throwOnError` fallback is applied after the `...config` spread.
-*
-* `mergeContentType` is `true` when the caller must destructure `contentType` from `options`, and
-* `eventStream` is `true` when the operation returns `text/event-stream`. Unless `returnType` is `'plain'`, a
-* stream's literal leaves the `response` validator to `toEventStream`, which runs it per event.
-*/
-function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault, returnType }) {
-	const eventStream = isEventStream(node);
-	const securityLiteral = buildSecurityMetadata({ security });
-	const stylesLiteral = buildStyles({ node });
-	const validatorLiteral = buildValidatorLiteral(validatorHooks, eventStream && returnType !== "plain" ? [
-		"request",
-		"path",
-		"query",
-		"headers",
-		"error"
-	] : [
-		"request",
-		"path",
-		"query",
-		"headers",
-		"response",
-		"error"
-	]);
-	const { literal: contentTypeLiteral, merge: mergeContentType } = buildContentType({ node });
-	return {
-		callConfig: `{ ${[
-			`method: '${node.method.toUpperCase()}'`,
-			`url: '${node.path}'`,
-			securityLiteral ? `security: ${securityLiteral}` : null,
-			stylesLiteral ? `styles: ${stylesLiteral}` : null,
-			validatorLiteral,
-			contentTypeLiteral,
-			buildResponseTypeLiteral(node),
-			"...config",
-			`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
-		].filter(Boolean).join(", ")} }`,
-		mergeContentType,
-		eventStream
-	};
-}
-// ../../internals/client/src/builders/signature.ts
-const declarationPrinter = functionPrinter({ mode: "declaration" });
-/**
-* Builds the grouped-options signature for one operation: a single `options` object whose `TData`
-* is the `<Name>Options` type, and a `RequestResult` return type keyed to the per-status responses
-* record. There are no positional arguments.
-*
-* The generated file imports `<Name>Options` and `<Name>Responses` and uses them directly, so no
-* per-operation input type has to be emitted. Both names come from `types`, which is `plugin-ts` or
-* `plugin-zod`'s inferred types (see `resolveOperationTypes`).
-*/
-function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDefault, eventStream = false }) {
-	const optionsName = types.response.options(node);
-	const optionsType = `${eventStream && returnType !== "plain" ? "StreamOptions" : "Options"}<${optionsName}, ThrowOnError>`;
-	const { isOptional } = getRequestGroupOptionality(node);
-	return {
-		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
-			name: "options",
-			type: optionsType,
-			...isOptional ? { default: "{}" } : {}
-		})] })) ?? "",
-		returnType: buildResultType({
-			node,
-			types,
-			returnType
-		}),
-		generics: [`ThrowOnError extends boolean = ${throwOnErrorDefault}`]
-	};
-}
-// ../../internals/client/src/builders/operationBody.ts
-/**
-* The pieces of a generated operation: its generics, `options` parameter, return type, return statement, and whether the
-* body destructures `contentType` from `options`. Shared by the standalone functions and the SDK methods, so a
-* `text/event-stream` operation is wired to `toEventStream` in one place.
-*/
-function buildOperationBody({ node, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
-	const { callConfig, mergeContentType, eventStream } = buildCallConfig({
-		node,
-		validatorHooks,
-		security,
-		throwOnErrorDefault,
-		returnType
-	});
-	const signature = buildGroupedOptionsSignature({
-		node,
-		types,
-		returnType,
-		throwOnErrorDefault,
-		eventStream
-	});
-	const stream = eventStream ? buildEventStreamReturn({
-		node,
-		types,
-		callConfig,
-		returnType,
-		validatorHooks,
-		throwOnErrorDefault
-	}) : null;
-	return {
-		generics: signature.generics,
-		paramsSignature: signature.paramsSignature,
-		returnType: stream?.returnType ?? signature.returnType,
-		statement: stream?.statement ?? buildReturnStatement({
-			node,
-			types,
-			callConfig,
-			returnType,
-			throwOnErrorDefault
-		}),
-		mergeContentType
-	};
-}
-// ../../internals/client/src/components/Operation.tsx
-/**
-* Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
-* single `options` object to the resolved client and returns the `Unwrappable<RequestResult>`. The
-* type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
-* the source.
-*/
-function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security }) {
-	if (!ast.isHttpOperationNode(node)) return null;
-	const body = buildOperationBody({
-		node,
-		types,
-		validatorHooks,
-		security,
-		returnType,
-		throwOnErrorDefault
-	});
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: /* @__PURE__ */ jsxs(Function, {
-			name,
-			export: true,
-			generics: body.generics,
-			params: body.paramsSignature,
-			returnType: body.returnType,
-			JSDoc: { comments: buildOperationComments(node, {
-				link: "urlPath",
-				linkPosition: "beforeDeprecated",
-				splitLines: true
-			}) },
-			children: [
-				body.mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
-				/* @__PURE__ */ jsx("br", {}),
-				body.statement
-			]
-		})
-	});
-}
-// ../../internals/client/src/components/StreamRuntime.tsx
-/**
-* The `footer` of `.kubb/client.ts`: the `baseURL` set at generation time, and the `sse.ts` re-export when the document
-* streams events, so `ServerSentEvent` and `toEventStream` stay importable from the client as in earlier releases.
-*/
-function buildClientFooter({ baseURL, sse }) {
-	const baseURLExpression = baseURL ? baseURL.includes("${") ? `\`${baseURL.replaceAll("`", "\\`")}\`` : JSON.stringify(baseURL) : void 0;
-	return [baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : null, sse ? `export * from './sse.ts'` : null].filter(Boolean).join("\n") || void 0;
-}
-/**
-* Writes the footer of the `.kubb/client.ts` the plugin injected, the one place it is built, and copies `sse.ts` into
-* `.kubb/` only for a document with a `text/event-stream` operation, so a document without streams ships no stream runtime.
-* `sse` is set by the plugins that ship the runtime, so a custom client from `@kubb/plugin-client` gets neither file.
-*/
-function StreamRuntime({ nodes, root, sse, baseURL }) {
-	if (!sse) return null;
-	const streams = nodes.some(isEventStream);
-	const footer = buildClientFooter({
-		baseURL,
-		sse: streams
-	});
-	return /* @__PURE__ */ jsxs(Fragment, { children: [streams && /* @__PURE__ */ jsx(File, {
-		baseName: "sse.ts",
-		path: path.resolve(root, ".kubb/sse.ts"),
-		copy: sse
-	}), footer && /* @__PURE__ */ jsx(File, {
-		baseName: "client.ts",
-		path: path.resolve(root, ".kubb/client.ts"),
-		footer
-	})] });
-}
-// ../../internals/client/src/resolveOperationTypes.ts
-/**
-* A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
-* exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
-*/
-function toZodTypeResolver(resolver) {
-	const type = (name) => resolver.schema.type(name);
-	return {
-		...resolver,
-		file: resolver.file.bind(resolver),
-		memo: (key, compute) => resolver.memo(`zodTypes:${key}`, compute),
-		param: {
-			name: (node, p) => type(resolver.param.name(node, p)),
-			path: (node, p) => type(resolver.param.path(node, p)),
-			query: (node, p) => type(resolver.param.query(node, p)),
-			headers: (node, p) => type(resolver.param.headers(node, p))
-		},
-		response: {
-			body: (node) => type(resolver.response.body(node)),
-			status: (node, statusCode) => type(resolver.response.status(node, statusCode)),
-			response: (node) => type(resolver.response.response(node)),
-			responses: (node) => type(resolver.response.responses(node)),
-			options: (node) => resolver.response.options(node)
-		}
-	};
-}
-/**
-* Picks the plugin generated clients, query hooks, and MCP handlers take their operation types from.
-*
-* `pluginZod({ inferred: 'codec' })` wins, so a codec param takes its domain value. Otherwise `plugin-ts`
-* wins when it is in the pipeline, and without it any `pluginZod({ inferred })`. Throws
-* `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available.
-*
-* @example
-* ```ts
-* const types = resolveOperationTypes(ctx.driver, ctx.plugin.name)
-* types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
-* ```
-*/
-function resolveOperationTypes(driver, pluginName) {
-	return driver.memo(`operationTypes:${pluginName}`, () => {
-		const pluginTs = driver.getPlugin(pluginTsName);
-		const pluginZod = driver.getPlugin(pluginZodName);
-		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
-			const resolver = driver.getResolver(pluginTsName);
-			return {
-				response: resolver.response,
-				resolver,
-				output: pluginTs.options?.output,
-				group: pluginTs.options?.group ?? void 0
-			};
-		}
-		if (!pluginZod?.options?.inferred) throw new Diagnostics.Error({
-			code: Diagnostics.code.missingDependency,
-			severity: "error",
-			message: `Plugin "${pluginName}" has no source for operation types.`,
-			help: `Add \`pluginTs()\` before "${pluginName}", or add \`pluginZod({ inferred: true })\`.`,
-			location: { kind: "config" },
-			plugin: pluginName
-		});
-		const resolver = toZodTypeResolver(driver.getResolver(pluginZodName));
-		return {
-			response: resolver.response,
-			resolver,
-			output: pluginZod.options.output,
-			group: pluginZod.options.group ?? void 0
-		};
-	});
-}
-// ../../internals/client/src/generators/clientGenerator.tsx
-/**
-* Builds the built-in per-operation generator shared by the client plugins (`@kubb/plugin-fetch`,
-* `@kubb/plugin-axios`). 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 `Unwrappable<RequestResult>`. Only the
-* generator `name` and the runtime templates differ between plugins. Every other resolution, import,
-* and rendering step is identical.
-*
-* `sse` is the Server-Sent Events runtime template, copied into `.kubb/sse.ts` only for a document with a
-* `text/event-stream` operation.
-*/
-function createClientGenerator(name, { sse } = {}) {
-	return defineGenerator({
-		name,
-		renderer: jsxRenderer,
-		operations(nodes, ctx) {
-			return /* @__PURE__ */ jsx(StreamRuntime, {
-				nodes,
-				root: ctx.root,
-				sse,
-				baseURL: ctx.options.baseURL
-			});
-		},
-		operation(node, ctx) {
-			if (!ast.isHttpOperationNode(node)) return null;
-			const { config, driver, resolver, root } = ctx;
-			const { output, validator, returnType, throwOnErrorDefault, group, importPath } = ctx.options;
-			const types = resolveOperationTypes(driver, ctx.plugin.name);
-			const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName) : null;
-			const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-			const importedTypeNames = [types.response.options(node), types.response.responses(node)];
-			const validatorHooks = buildValidatorHooks({
-				node,
-				validator,
-				zodResolver
-			});
-			const importedZodNames = validatorHooks.importedZodNames;
-			const operationName = resolver.name(node.operationId);
-			const meta = {
-				name: resolver.resolveName({
-					key: operationKey(node),
-					name: operationName
-				}),
-				file: resolver.file({
-					...operationFileEntry(node, node.operationId),
-					root,
-					output,
-					group: group ?? void 0
-				}),
-				fileTypes: resolveDependencyOperationFile({
-					memo: ctx.memo,
-					node,
-					resolver: types.resolver,
-					root,
-					output: types.output ?? output,
-					group: types.group
-				}),
-				fileZod: zodResolver && pluginZod?.options ? zodResolver.file({
-					...operationFileEntry(node, node.operationId),
-					root,
-					output: pluginZod.options.output ?? output,
-					group: pluginZod.options?.group ?? void 0
-				}) : null
-			};
-			const security = getOperationSecurity({
-				document: ctx.adapter.document,
-				method: node.method,
-				path: node.path
-			});
-			const clientPath = importPath ?? path.resolve(root, ".kubb/client.ts");
-			const clientRoot = importPath === void 0 ? meta.file.path : void 0;
-			const standardSchemaPath = importPath ?? path.resolve(root, ".kubb/standardSchema.ts");
-			const ssePath = importPath ?? path.resolve(root, ".kubb/sse.ts");
-			const stream = getEventStream(node);
-			const clientValueImports = (() => {
-				if (returnType === "plain") return ["client"];
-				if (returnType === "data") return ["client", "unwrapResult"];
-				return ["client", "withUnwrap"];
-			})();
-			const clientTypeImports = (() => {
-				if (stream) return {
-					plain: ["Options", "SuccessOf"],
-					data: ["SuccessOf"],
-					full: ["SuccessOf", "Unwrappable"]
-				}[returnType];
-				if (returnType === "plain") return ["Options", "RequestResult"];
-				if (returnType === "data") return ["Options", "UnwrappedResult"];
-				return [
-					"Options",
-					"Unwrappable",
-					"RequestResult"
-				];
-			})();
-			return /* @__PURE__ */ jsxs(File, {
-				baseName: meta.file.baseName,
-				path: meta.file.path,
-				meta: meta.file.meta,
-				banner: resolver.default.banner(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: meta.file.path,
-						baseName: meta.file.baseName
-					}
-				}),
-				footer: resolver.default.footer(ctx.meta, {
-					output,
-					config,
-					file: {
-						path: meta.file.path,
-						baseName: meta.file.baseName
-					}
-				}),
-				children: [
-					/* @__PURE__ */ jsx(File.Import, {
-						name: clientValueImports,
-						root: clientRoot,
-						path: clientPath
-					}),
-					/* @__PURE__ */ jsx(File.Import, {
-						name: clientTypeImports,
-						root: clientRoot,
-						path: clientPath,
-						isTypeOnly: true
-					}),
-					stream && /* @__PURE__ */ jsx(File.Import, {
-						name: ["toEventStream"],
-						root: clientRoot,
-						path: ssePath
-					}),
-					stream && /* @__PURE__ */ jsx(File.Import, {
-						name: buildEventStreamImports({
-							returnType,
-							typed: stream === "event"
-						}),
-						root: clientRoot,
-						path: ssePath,
-						isTypeOnly: true
-					}),
-					meta.fileTypes && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-						name: Array.from(new Set(importedTypeNames)),
-						root: meta.file.path,
-						path: meta.fileTypes.path,
-						isTypeOnly: true
-					}),
-					meta.fileZod && importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-						name: importedZodNames,
-						root: meta.file.path,
-						path: meta.fileZod.path
-					}),
-					validatorHooks.headers && /* @__PURE__ */ jsx(File.Import, {
-						name: ["toHeadersStandardSchema"],
-						root: clientRoot,
-						path: standardSchemaPath
-					}),
-					/* @__PURE__ */ jsx(Operation, {
-						name: meta.name,
-						node,
-						types,
-						validatorHooks,
-						returnType,
-						throwOnErrorDefault,
-						security
-					})
-				]
-			});
-		}
-	});
-}
-// ../../internals/client/src/components/SdkClient.tsx
-/**
-* Builds one instance method of a generated SDK class; a per-call `options.client` overrides `this.client`.
-*/
-function buildSdkMethod({ node, name, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
-	if (!ast.isHttpOperationNode(node)) return "";
-	const body = buildOperationBody({
-		node,
-		types,
-		validatorHooks,
-		security,
-		returnType,
-		throwOnErrorDefault
-	});
-	const generics = body.generics.length ? `<${body.generics.join(", ")}>` : "";
-	const jsdoc = buildJSDoc(buildOperationComments(node, {
-		link: "urlPath",
-		linkPosition: "beforeDeprecated",
-		splitLines: true
-	}));
-	const methodBody = [
-		body.mergeContentType ? "const { client: request = this.client, contentType, ...config } = options" : "const { client: request = this.client, ...config } = options",
-		"",
-		body.statement
-	].map((line) => line ? `    ${line}` : "").join("\n");
-	return `${jsdoc}  public ${name}${generics}(${body.paramsSignature}): ${body.returnType} {\n${methodBody}\n  }`;
-}
-/**
-* Renders one instance class per tag with one method per operation. The constructor takes a client
-* config object and builds its own client through `createClient`, so each environment is a separate
-* instance: `const api = new PetClient({ baseURL }); api.getPetById(...)`. A per-call `client` option
-* still overrides the instance client for a one-off call.
-*/
-function SdkClient({ name, operations, returnType, throwOnErrorDefault }) {
-	const methods = operations.map(({ node, name: methodName, types, validatorHooks, security }) => buildSdkMethod({
-		node,
-		name: methodName,
-		types,
-		validatorHooks,
-		security,
-		returnType,
-		throwOnErrorDefault
-	}));
-	const classCode = `export class ${name} {\n${[
-		"  private readonly client: ClientInstance",
-		"",
-		"  constructor(config: ClientConfig = {}) {",
-		"    this.client = createClient(config)",
-		"  }"
-	].join("\n")}\n\n${methods.join("\n\n")}\n}`;
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: classCode
-	});
-}
-// ../../internals/client/src/components/SdkFacade.tsx
-/**
-* Renders a composed root SDK class that instantiates every tag client from one shared config, so
-* `new PetStore({ baseURL }).petClient.getPetById(...)` reaches an operation through a single entry
-* point bound to one environment. The per-tag clients are read-only fields built in the constructor.
-*/
-function SdkFacade({ name, members }) {
-	const fields = members.map((member) => `  readonly ${member.propName}: ${member.className}`);
-	const assignments = members.map((member) => `    this.${member.propName} = new ${member.className}(config)`);
-	const classCode = `export class ${name} {\n${[
-		...fields,
-		"",
-		"  constructor(config: ClientConfig = {}) {",
-		...assignments,
-		"  }"
-	].join("\n")}\n}`;
-	return /* @__PURE__ */ jsx(File.Source, {
-		name,
-		isExportable: true,
-		isIndexable: true,
-		children: classCode
-	});
-}
-// ../../internals/client/src/generators/sdkGenerator.tsx
-function resolveTypeImportNames(node, types) {
-	return [types.response.options(node), types.response.responses(node)];
-}
-/**
-* Groups operations into one controller per tag. Operations without a tag fall back to a single
-* `Client`/`ApiClient` controller, matching the resolver's default naming.
-*/
-function buildControllers(nodes, ctx, types, validatorEnabled) {
-	const { driver, resolver, root } = ctx;
-	const { output, group, validator } = ctx.options;
-	const pluginZod = validatorEnabled ? driver.getPlugin(pluginZodName) : null;
-	const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-	const document = ctx.adapter.document;
-	function buildOperationData(node) {
-		const typeFile = types.resolver.file({
-			...operationFileEntry(node, node.operationId),
-			root,
-			output: types.output ?? output,
-			group: types.group
-		});
-		const zodFile = zodResolver && pluginZod?.options ? zodResolver.file({
-			...operationFileEntry(node, node.operationId),
-			root,
-			output: pluginZod.options?.output ?? output,
-			group: pluginZod.options?.group ?? void 0
-		}) : null;
-		const security = ast.isHttpOperationNode(node) ? getOperationSecurity({
-			document,
-			method: node.method,
-			path: node.path
-		}) : void 0;
-		const validatorHooks = zodResolver ? buildValidatorHooks({
-			node,
-			validator,
-			zodResolver
-		}) : null;
-		const name = resolver.name(node.operationId);
-		return {
-			node,
-			name: resolver.resolveName({
-				key: operationKey(node),
-				name
-			}),
-			types,
-			typeFile,
-			zodFile,
-			validatorHooks,
-			security
-		};
-	}
-	return nodes.reduce((acc, operationNode) => {
-		if (!ast.isHttpOperationNode(operationNode)) return acc;
-		const tag = operationNode.tags[0];
-		const name = tag ? ensureValidVarName(group?.name?.({ group: camelCase(tag) }) ?? resolver.groupName(tag)) : resolver.className("ApiClient");
-		const file = resolver.file({
-			name,
-			extname: ".ts",
-			tag,
-			root,
-			output,
-			group: group ?? void 0
-		});
-		const operationData = buildOperationData(operationNode);
-		const previous = acc.find((item) => item.file.path === file.path);
-		if (previous) previous.operations.push(operationData);
-		else acc.push({
-			name,
-			tag,
-			file,
-			operations: [operationData]
-		});
-		return acc;
-	}, []);
-}
-function collectImportsByFile(ops, pick) {
-	const namesByPath = /* @__PURE__ */ new Map();
-	const filesByPath = /* @__PURE__ */ new Map();
-	ops.forEach((op) => {
-		const { file, names } = pick(op);
-		if (!file || names.length === 0) return;
-		if (!namesByPath.has(file.path)) namesByPath.set(file.path, /* @__PURE__ */ new Set());
-		const set = namesByPath.get(file.path);
-		names.forEach((n) => set.add(n));
-		filesByPath.set(file.path, file);
-	});
-	return {
-		namesByPath,
-		filesByPath
-	};
-}
-/**
-* Builds the class-based SDK generator for a client plugin (`@kubb/plugin-fetch`,
-* `@kubb/plugin-axios`). Only registered when `sdk` is set; otherwise the plugin keeps its
-* standalone per-operation functions.
-*
-* Every tag client is an instance class whose constructor takes a client config and builds its own
-* client, so each environment is a separate instance. With `sdk.mode: 'tag'` (the default) it
-* emits one class per tag and, when `sdk.name` is set, a composed root that instantiates every tag
-* client. With `sdk.mode: 'flat'` it emits one class named by `sdk.name`, with every operation as a
-* direct method.
-*
-* `sse` is the Server-Sent Events runtime template, copied into `.kubb/sse.ts` only for a document with a
-* `text/event-stream` operation.
-*/
-function createSdkGenerator({ sse } = {}) {
-	return defineGenerator({
-		name: "sdk",
-		renderer: jsxRenderer,
-		operations(nodes, ctx) {
-			const { config, resolver, root } = ctx;
-			const { output, group, validator, returnType, throwOnErrorDefault, sdk } = ctx.options;
-			if (!sdk) return null;
-			if (sdk.mode === "tag" && output.mode === "file") throw new Diagnostics.Error({
-				code: Diagnostics.code.invalidPluginOptions,
-				severity: "error",
-				message: `Plugin "${ctx.plugin.name}" resolves \`output.mode\` to 'file' but also configures \`sdk.mode: 'tag'\`.`,
-				help: "A single-file output has nothing to split tag classes into. Set `sdk.mode: 'flat'` to emit one class into that file, or give `output.path` an extensionless directory name (or set `output.mode: 'directory'` explicitly) so each tag gets its own file.",
-				location: { kind: "config" },
-				plugin: ctx.plugin.name
-			});
-			const types = resolveOperationTypes(ctx.driver, ctx.plugin.name);
-			const validatorEnabled = isValidatorEnabled(validator);
-			const controllers = buildControllers(nodes, ctx, types, validatorEnabled);
-			const clientPath = path.resolve(root, ".kubb/client.ts");
-			const standardSchemaPath = path.resolve(root, ".kubb/standardSchema.ts");
-			const ssePath = path.resolve(root, ".kubb/sse.ts");
-			const banner = (file) => resolver.default.banner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: file.path,
-					baseName: file.baseName
-				}
-			});
-			const footer = (file) => resolver.default.footer(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: file.path,
-					baseName: file.baseName
-				}
-			});
-			const renderClassFile = (className, file, ops) => {
-				const { namesByPath: typeNamesByPath, filesByPath: typeFilesByPath } = collectImportsByFile(ops, (op) => ({
-					file: op.typeFile,
-					names: resolveTypeImportNames(op.node, op.types)
-				}));
-				const { namesByPath: zodNamesByPath, filesByPath: zodFilesByPath } = validatorEnabled ? collectImportsByFile(ops, (op) => ({
-					file: op.zodFile,
-					names: op.validatorHooks?.importedZodNames ?? []
-				})) : {
-					namesByPath: /* @__PURE__ */ new Map(),
-					filesByPath: /* @__PURE__ */ new Map()
-				};
-				const shapes = new Set(ops.map((op) => getEventStream(op.node)).filter(Boolean));
-				const hasEventStream = shapes.size > 0;
-				const hasResult = ops.some((op) => !isEventStream(op.node));
-				return /* @__PURE__ */ jsxs(File, {
-					baseName: file.baseName,
-					path: file.path,
-					meta: file.meta,
-					banner: banner(file),
-					footer: footer(file),
-					children: [
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["createClient", returnType === "data" ? "unwrapResult" : "withUnwrap"],
-							root: file.path,
-							path: clientPath
-						}),
-						/* @__PURE__ */ jsx(File.Import, {
-							name: [
-								"ClientConfig",
-								"ClientInstance",
-								"Options",
-								...returnType === "data" ? [] : ["Unwrappable"],
-								...hasResult ? [returnType === "data" ? "UnwrappedResult" : "RequestResult"] : [],
-								...hasEventStream ? ["SuccessOf"] : []
-							],
-							root: file.path,
-							path: clientPath,
-							isTypeOnly: true
-						}),
-						hasEventStream && /* @__PURE__ */ jsx(File.Import, {
-							name: ["toEventStream"],
-							root: file.path,
-							path: ssePath
-						}),
-						hasEventStream && /* @__PURE__ */ jsx(File.Import, {
-							name: buildEventStreamImports({
-								returnType,
-								typed: shapes.has("event")
-							}),
-							root: file.path,
-							path: ssePath,
-							isTypeOnly: true
-						}),
-						validator === "zod" && ops.some((op) => op.node.requestBody?.content?.[0]?.schema != null) && /* @__PURE__ */ jsx(File.Import, {
-							name: ["z"],
-							path: "zod",
-							isTypeOnly: true
-						}),
-						Array.from(typeNamesByPath.entries()).map(([filePath, set]) => /* @__PURE__ */ jsx(File.Import, {
-							name: Array.from(set),
-							root: file.path,
-							path: typeFilesByPath.get(filePath).path,
-							isTypeOnly: true
-						}, filePath)),
-						validatorEnabled && Array.from(zodNamesByPath.entries()).map(([filePath, set]) => /* @__PURE__ */ jsx(File.Import, {
-							name: Array.from(set),
-							root: file.path,
-							path: zodFilesByPath.get(filePath).path
-						}, filePath)),
-						ops.some((op) => op.validatorHooks?.headers) && /* @__PURE__ */ jsx(File.Import, {
-							name: ["toHeadersStandardSchema"],
-							root: file.path,
-							path: standardSchemaPath
-						}),
-						/* @__PURE__ */ jsx(SdkClient, {
-							name: className,
-							operations: ops,
-							returnType,
-							throwOnErrorDefault
-						})
-					]
-				}, file.path);
-			};
-			const renderFacadeFile = (name) => {
-				const sdkFile = resolver.file({
-					name,
-					extname: ".ts",
-					root,
-					output,
-					group: group ?? void 0
-				});
-				const members = controllers.map(({ name, tag }) => ({
-					className: name,
-					propName: resolver.propertyName(tag ?? name)
-				}));
-				return /* @__PURE__ */ jsxs(File, {
-					baseName: sdkFile.baseName,
-					path: sdkFile.path,
-					meta: sdkFile.meta,
-					banner: banner(sdkFile),
-					footer: footer(sdkFile),
-					children: [
-						/* @__PURE__ */ jsx(File.Import, {
-							name: ["ClientConfig"],
-							root: sdkFile.path,
-							path: clientPath,
-							isTypeOnly: true
-						}),
-						controllers.map(({ name, file }) => /* @__PURE__ */ jsx(File.Import, {
-							name: [name],
-							root: sdkFile.path,
-							path: file.path
-						}, name)),
-						/* @__PURE__ */ jsx(SdkFacade, {
-							name: resolver.className(name),
-							members
-						})
-					]
-				}, sdkFile.path);
-			};
-			const files = sdk.mode === "flat" ? renderClassFile(resolver.className(sdk.name ?? "sdk"), resolver.file({
-				name: sdk.name ?? "sdk",
-				extname: ".ts",
-				root,
-				output,
-				group: group ?? void 0
-			}), controllers.flatMap((controller) => controller.operations)) : [...controllers.map(({ name, file, operations: ops }) => renderClassFile(name, file, ops)), sdk.name && renderFacadeFile(sdk.name)];
-			return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(StreamRuntime, {
-				nodes,
-				root,
-				sse,
-				baseURL: ctx.options.baseURL
-			}), files] });
-		}
-	});
-}
-// ../../internals/client/src/macros.ts
-/**
-* Macros the client plugins apply by default, ahead of any user macros. `macroDedupeUnion`
-* drops repeated union members, keeping the generated response and error
-* unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
-*/
-const defaultMacros = [macroDedupeUnion];
-// ../../internals/client/src/resolver.ts
-/**
-* Default resolver shared by the client plugins. Functions use safe camelCase identifiers and
-* files inherit the built-in casing; classes and tag groups use PascalCase.
-*
-* @example
-* ```ts
-* resolverClient.name('show pet by id')  // 'showPetById'
-* resolverClient.groupName('pet')        // 'PetClient'
-* ```
-*/
-const resolverClient = createResolver({
-	pluginName: "plugin-contract-client",
-	name: resolveOperationName,
-	className(name) {
-		return ensureValidVarName(pascalCase(name));
-	},
-	groupName(name) {
-		return ensureValidVarName(pascalCase(`${name} Client`));
-	},
-	propertyName(name) {
-		return ensureValidVarName(camelCase(name));
-	}
-});
-// src/templates.ts
-const require = createRequire(import.meta.url);
-/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
-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`.
-*/
-const coreTemplatePath = require.resolve("@kubb/plugin-client/templates/core.ts");
-const serializersTemplatePath = require.resolve("@kubb/plugin-client/templates/serializers.ts");
-const standardSchemaTemplatePath = require.resolve("@kubb/plugin-client/templates/standardSchema.ts");
-const sseTemplatePath = require.resolve("@kubb/plugin-client/templates/sse.ts");
-// src/generators/clientGenerator.tsx
-/**
-* 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`.
-*/
-const clientGenerator = createClientGenerator("fetch", { sse: sseTemplatePath });
+import { defineExtension } from "@kubb/kit";
+import { clientDependencies, resolveClientOptions, setupClient } from "@kubb/plugin-client";
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.16.0",
+	"kubb": ">=5.18.4",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.14.0-canary.20261109T134631";
+var version = "6.0.1";
 // src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin
@@ -1739,59 +43,18 @@ const pluginFetch = defineExtension({
 		version,
 		compatibility
 	},
-	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 = {
-			output,
-			exclude,
-			include,
-			override,
-			group: createGroupConfig(group),
-			baseURL,
-			throwOnErrorDefault,
-			validator,
-			returnType,
-			sdk: sdk ? {
-				mode: sdk.mode ?? "tag",
-				name: sdk.name
-			} : void 0,
-			resolver: userResolver ? Resolver.merge(resolverClient, userResolver) : resolverClient
-		};
-		setResolver(resolved.resolver);
-		setMacros([...defaultMacros, ...options.macros ?? []]);
-		addGenerator(resolved.sdk ? createSdkGenerator({ 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;
 	}
 });
-export { clientGenerator, pluginFetch as default, pluginFetch, pluginFetchName };
+export { pluginFetch as default, pluginFetch, pluginFetchName };
 
 //# sourceMappingURL=index.js.map