@kubb/plugin-fetch 5.0.0-beta.100

package/dist/index.js

@@ -0,0 +1,1352 @@
+import "./rolldown-runtime-C0LytTxp.js";
+import { Resolver, Url, ast, createResolver, defineGenerator, definePlugin, macroSimplifyUnion } from "kubb/kit";
+import path from "node:path";
+import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { File, Function, jsxRenderer } from "kubb/jsx";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+import { pluginZodName } from "@kubb/plugin-zod";
+import { fileURLToPath } from "node:url";
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../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
+	};
+}
+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();
+}
+/**
+* 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 getPrimarySuccessContentType(node) === "text/event-stream";
+}
+/**
+* Derives the default `responseType` for an operation from its primary success response.
+*
+* Returns a value only when that response declares a single non-JSON content type. `text/event-stream`
+* and other binary types (`application/octet-stream`, `application/pdf`, `image/*`, `audio/*`,
+* `video/*`) map to a stream or `'blob'`, and other `text/*` maps to `'text'`. Otherwise `undefined`,
+* leaving the runtime client's `Content-Type` auto-detection in charge.
+*/
+function getResponseType(node) {
+	const baseType = getPrimarySuccessContentType(node);
+	if (!baseType) return void 0;
+	if (baseType === "application/json" || baseType.endsWith("+json") || baseType === "text/json") return void 0;
+	if (baseType === "text/event-stream") return "stream";
+	if (baseType.startsWith("text/")) return "text";
+	if (baseType === "application/octet-stream" || baseType === "application/pdf" || /^(image|audio|video)\//.test(baseType)) return "blob";
+}
+/**
+* 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
+	};
+}
+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));
+}
+function getOperationParameters(node) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+}
+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;
+}
+//#endregion
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+*
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
+*/
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region ../../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",
+	"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);
+}
+//#endregion
+//#region ../../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}`;
+}
+//#endregion
+//#region ../../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
+	};
+}
+//#endregion
+//#region ../../internals/client/src/builders/generics.ts
+/**
+* Builds the `RequestResult` generic arguments for one operation: the plugin-ts 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, tsResolver }) // 'AddPetResponses, ThrowOnError'`
+*/
+function buildRequestResultGenerics({ node, tsResolver }) {
+	return `${tsResolver.response.responses(node)}, ThrowOnError`;
+}
+//#endregion
+//#region ../../internals/client/src/builders/returnStatement.ts
+/**
+* Builds the return statement of a generated operation function. The runtime call already resolves
+* to `{ data, error, request, response }`; the generated code forwards that result and casts it to
+* the operation's `RequestResult`, which carries the `throwOnError` discrimination.
+*
+* @example
+* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
+*/
+function buildReturnStatement({ node, tsResolver, callConfig }) {
+	return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		tsResolver
+	})}>>`;
+}
+//#endregion
+//#region ../../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}'`);
+	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 of Object.keys(requirement)) {
+		if (seen.has(schemeName)) continue;
+		seen.add(schemeName);
+		const auth = resolveSecurityScheme(definitions[schemeName]);
+		if (auth) security.push(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(", ")}]`;
+}
+//#endregion
+//#region ../../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 plugin-ts `<Name>Options` (carrying a literal `url`), and a `RequestResult` return type
+* keyed to the plugin-ts 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.
+*/
+function buildGroupedOptionsSignature({ node, tsResolver }) {
+	const optionsName = tsResolver.response.options(node);
+	const responsesName = tsResolver.response.responses(node);
+	const resultGenerics = buildRequestResultGenerics({
+		node,
+		tsResolver
+	});
+	const { isOptional } = getRequestGroupOptionality(node);
+	return {
+		dataTypeName: optionsName,
+		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
+			name: "options",
+			type: `Options<${optionsName}, ThrowOnError>`,
+			...isOptional ? { default: "{}" } : {}
+		})] })) ?? "",
+		returnType: `Promise<RequestResult<${resultGenerics}>>`,
+		generics: ["ThrowOnError extends boolean = true"],
+		importedTypeNames: [optionsName, responsesName]
+	};
+}
+//#endregion
+//#region ../../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.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 query-parameters parsing is enabled, `null` otherwise. Only the object form
+* `{ request: 'zod' }` enables it.
+*/
+function resolveQueryParamsValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? 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 expression a generated client validates a success response with. Only success
+* (2xx) bodies reach the parse under the throw-on-error contract, so the success-only
+* `<operation>ResponseSchema` is used; error bodies are never zod-parsed.
+*/
+function buildZodResponseParse(node, zodResolver) {
+	const name = zodResolver.response.response(node);
+	return name ? {
+		expression: name,
+		importNames: [name]
+	} : null;
+}
+/**
+* Resolves the zod expression 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;
+	const name = zodResolver.response.error?.(node);
+	return name ? {
+		expression: name,
+		importNames: [name]
+	} : null;
+}
+//#endregion
+//#region ../../internals/client/src/builders/validator.ts
+/**
+* Builds the validator-hook references for one operation. Request validation runs 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 importedZodNames = [];
+	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) : null;
+	const request = zodRequestName ?? null;
+	if (zodRequestName) importedZodNames.push(zodRequestName);
+	const responseParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
+	const response = responseParse ? responseParse.expression : null;
+	if (responseParse) importedZodNames.push(...responseParse.importNames);
+	const errorParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
+	const error = errorParse ? errorParse.expression : null;
+	if (errorParse) importedZodNames.push(...errorParse.importNames);
+	return {
+		request,
+		response,
+		error,
+		importedZodNames
+	};
+}
+//#endregion
+//#region ../../internals/client/src/builders/sdkMethod.ts
+/**
+* Builds the call config literal forwarded to the contract client, mirroring the shared `Operation`
+* component: `{ method, url, security?, validator?, ...config }`. The `...config` spread carries every
+* per-call field (including `throwOnError`), so the method stays a thin wrapper over the contract.
+*/
+function buildCallConfig({ node, validator, zodResolver, security }) {
+	const validators = buildValidatorHooks({
+		node,
+		validator,
+		zodResolver
+	});
+	const validatorEntries = [validators.request ? `request: ${validators.request}` : null, validators.response ? `response: ${validators.response}` : null].filter(Boolean);
+	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
+	const securityLiteral = buildSecurityMetadata({ security });
+	return `{ ${[
+		`method: '${node.method.toUpperCase()}'`,
+		`url: '${node.path}'`,
+		securityLiteral ? `security: ${securityLiteral}` : null,
+		validatorLiteral,
+		"...config"
+	].filter(Boolean).join(", ")} }`;
+}
+/**
+* Builds a single instance method for a generated SDK class. The body forwards the single grouped
+* `options` object to the instance's own client (`this.client`, built once in the constructor) and
+* returns the `RequestResult`. A per-call `options.client` still overrides the instance client, so
+* one operation can be routed to a different environment without a new instance.
+*/
+function buildSdkMethod({ node, name, tsResolver, zodResolver, validator, security }) {
+	if (!ast.isHttpOperationNode(node)) return "";
+	const signature = buildGroupedOptionsSignature({
+		node,
+		tsResolver
+	});
+	const returnStatement = buildReturnStatement({
+		node,
+		tsResolver,
+		callConfig: buildCallConfig({
+			node,
+			validator,
+			zodResolver,
+			security
+		})
+	});
+	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
+	const jsdoc = buildJSDoc(buildOperationComments(node, {
+		link: "urlPath",
+		linkPosition: "beforeDeprecated",
+		splitLines: true
+	}));
+	const methodBody = [
+		"const { client: request = this.client, ...config } = options",
+		"",
+		returnStatement
+	].map((line) => line ? `    ${line}` : "").join("\n");
+	return `${jsdoc}  public ${name}${generics}(${signature.paramsSignature}): ${signature.returnType} {\n${methodBody}\n  }`;
+}
+//#endregion
+//#region ../../internals/client/src/builders/styles.ts
+/**
+* Renders a parameter name as an object-literal key, quoted when it is not a bare identifier.
+* Path keys are camelCased to match the URL template placeholders. Query, header, and cookie keys
+* keep the spec name, matching the remapped keys the runtime serializes.
+*/
+function toKey(name, location) {
+	const key = location === "path" ? camelCase(name) : name;
+	return isValidVarName(key) ? key : JSON.stringify(key);
+}
+/**
+* Serializes one parameter's metadata into a `{ style, explode }` literal, or `null` when the
+* parameter carries neither. Path and query carry the serialization `style`; header and cookie use a
+* fixed style (`simple` and `form`), so only `explode` is emitted for them.
+*/
+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}`);
+	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
+}
+/**
+* Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
+* Path entries are keyed by the camelCased name to match the URL template placeholders; query,
+* header, and cookie entries keep the spec name to match the keys the runtime serializes.
+* Only parameters whose source defines `style` or `explode` are emitted, so calls without
+* serialization metadata keep the runtime defaults and existing output is unchanged. Returns `null`
+* when no parameter 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 parameter of node.parameters) {
+		const literal = serializeParameter(parameter);
+		if (!literal) continue;
+		groups[parameter.in].push(`${toKey(parameter.name, parameter.in)}: ${literal}`);
+	}
+	const locations = Object.keys(groups).filter((location) => groups[location].length > 0);
+	if (locations.length === 0) return null;
+	return `{ ${locations.map((location) => `${location}: { ${groups[location].join(", ")} }`).join(", ")} }`;
+}
+//#endregion
+//#region ../../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 `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, tsResolver, zodResolver, validator, security, isExportable = true, isIndexable = true }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const signature = buildGroupedOptionsSignature({
+		node,
+		tsResolver
+	});
+	const validators = buildValidatorHooks({
+		node,
+		validator,
+		zodResolver
+	});
+	const securityLiteral = buildSecurityMetadata({ security });
+	const stylesLiteral = buildStyles({ node });
+	const { defaultContentType } = getContentTypeInfo(node);
+	const bakedRequestContentType = Boolean(node.requestBody?.content?.[0]?.schema) && defaultContentType !== "application/json" ? defaultContentType : null;
+	const mergeContentType = Boolean(bakedRequestContentType) && getResponseContentTypeInfo(node).isMultipleContentTypes;
+	const contentTypeLiteral = !bakedRequestContentType ? null : mergeContentType ? `contentType: { request: '${bakedRequestContentType}', ...(typeof contentType === 'string' ? { request: contentType } : contentType) }` : `contentType: { request: '${bakedRequestContentType}' }`;
+	const eventStream = isEventStream(node);
+	const responseType = getResponseType(node);
+	const responseTypeLiteral = responseType ? `responseType: '${responseType}'` : null;
+	const validatorEntries = [
+		validators.request ? `request: ${validators.request}` : null,
+		validators.response ? `response: ${validators.response}` : null,
+		validators.error ? `error: ${validators.error}` : null
+	].filter(Boolean);
+	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
+	const callConfig = `{ ${[
+		`method: '${node.method.toUpperCase()}'`,
+		`url: '${node.path}'`,
+		securityLiteral ? `security: ${securityLiteral}` : null,
+		stylesLiteral ? `styles: ${stylesLiteral}` : null,
+		validatorLiteral,
+		contentTypeLiteral,
+		responseTypeLiteral,
+		"...config"
+	].filter(Boolean).join(", ")} }`;
+	const eventType = `SuccessOf<${tsResolver.response.responses(node)}>`;
+	const returnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
+	const returnStatement = eventStream ? `return toEventStream<${eventType}>(request(${callConfig}))` : buildReturnStatement({
+		node,
+		tsResolver,
+		callConfig
+	});
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: /* @__PURE__ */ jsxs(Function, {
+			name,
+			export: isExportable,
+			generics: signature.generics,
+			params: signature.paramsSignature,
+			returnType,
+			JSDoc: { comments: buildOperationComments(node, {
+				link: "urlPath",
+				linkPosition: "beforeDeprecated",
+				splitLines: true
+			}) },
+			children: [
+				mergeContentType ? "const { client: request = client, contentType, ...config } = options" : "const { client: request = client, ...config } = options",
+				/* @__PURE__ */ jsx("br", {}),
+				returnStatement
+			]
+		})
+	});
+}
+//#endregion
+//#region ../../internals/client/src/components/SdkClient.tsx
+/**
+* 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, isExportable = true, isIndexable = true, operations, validator, children }) {
+	const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver, security }) => buildSdkMethod({
+		node,
+		name: methodName,
+		tsResolver,
+		zodResolver,
+		validator,
+		security
+	}));
+	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__ */ jsxs(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: [classCode, children]
+	});
+}
+//#endregion
+//#region ../../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 `RequestResult`. Only the generator
+* `name` differs between plugins; every other resolution, import, and rendering step is identical.
+*/
+function createClientGenerator(name) {
+	return defineGenerator({
+		name,
+		renderer: jsxRenderer,
+		operation(node, ctx) {
+			if (!ast.isHttpOperationNode(node)) return null;
+			const { config, driver, resolver, root } = ctx;
+			const { output, validator, group } = ctx.options;
+			const pluginTs = driver.getPlugin(pluginTsName);
+			if (!pluginTs) return null;
+			const tsResolver = driver.getResolver(pluginTsName);
+			const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(pluginZodName) : null;
+			const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+			const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+			const importedTypeNames = [tsResolver.response.options(node), tsResolver.response.responses(node)];
+			const importedZodNames = zodResolver ? [
+				resolveResponseValidator(validator) === "zod" ? zodResolver.response.response?.(node) : null,
+				resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
+				resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body?.(node) : null
+			].filter((name) => Boolean(name)) : [];
+			const meta = {
+				name: resolver.name(node.operationId),
+				file: resolver.file({
+					...operationFileEntry(node, node.operationId),
+					root,
+					output,
+					group: group ?? void 0
+				}),
+				fileTs: tsResolver.file({
+					...operationFileEntry(node, node.operationId),
+					root,
+					output: pluginTs.options?.output ?? output,
+					group: pluginTs.options?.group ?? void 0
+				}),
+				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 = path.resolve(root, ".kubb/client.ts");
+			const eventStream = isEventStream(node);
+			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: eventStream ? ["client", "toEventStream"] : ["client"],
+						root: meta.file.path,
+						path: clientPath
+					}),
+					/* @__PURE__ */ jsx(File.Import, {
+						name: eventStream ? [
+							"Options",
+							"EventStreamResult",
+							"SuccessOf"
+						] : ["Options", "RequestResult"],
+						root: meta.file.path,
+						path: clientPath,
+						isTypeOnly: true
+					}),
+					meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+						name: Array.from(new Set(importedTypeNames)),
+						root: meta.file.path,
+						path: meta.fileTs.path,
+						isTypeOnly: true
+					}),
+					meta.fileZod && importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+						name: importedZodNames,
+						root: meta.file.path,
+						path: meta.fileZod.path
+					}),
+					/* @__PURE__ */ jsx(Operation, {
+						name: meta.name,
+						node,
+						tsResolver,
+						zodResolver,
+						validator,
+						security
+					})
+				]
+			});
+		}
+	});
+}
+//#endregion
+//#region ../../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, isExportable = true, isIndexable = true, members, children }) {
+	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__ */ jsxs(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: [classCode, children]
+	});
+}
+//#endregion
+//#region ../../internals/client/src/generators/sdkGenerator.tsx
+function resolveTypeImportNames(node, tsResolver) {
+	return [tsResolver.response.options(node), tsResolver.response.responses(node)];
+}
+function resolveZodImportNames(node, zodResolver, validator) {
+	const { query: queryParams } = getOperationParameters(node);
+	return [
+		resolveResponseValidator(validator) === "zod" ? zodResolver.response.response(node) : null,
+		resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
+		resolveRequestValidator(validator) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null,
+		resolveQueryParamsValidator(validator) === "zod" && queryParams.length > 0 ? zodResolver.param.query(node, queryParams[0]) : null
+	].filter((n) => Boolean(n));
+}
+/**
+* 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) {
+	const { driver, resolver, root } = ctx;
+	const { output, group, validator } = ctx.options;
+	const pluginTs = driver.getPlugin(pluginTsName);
+	const tsResolver = driver.getResolver(pluginTsName);
+	const tsPluginOptions = pluginTs.options;
+	const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName) : null;
+	const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+	const document = ctx.adapter.document;
+	function buildOperationData(node) {
+		const typeFile = tsResolver.file({
+			...operationFileEntry(node, node.operationId),
+			root,
+			output: tsPluginOptions?.output ?? output,
+			group: tsPluginOptions?.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;
+		return {
+			node,
+			name: resolver.name(node.operationId),
+			tsResolver,
+			zodResolver,
+			typeFile,
+			zodFile,
+			security
+		};
+	}
+	return nodes.reduce((acc, operationNode) => {
+		if (!ast.isHttpOperationNode(operationNode)) return acc;
+		const tag = operationNode.tags[0];
+		const name = tag ? 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.
+*/
+function createSdkGenerator() {
+	return defineGenerator({
+		name: "sdk",
+		renderer: jsxRenderer,
+		operations(nodes, ctx) {
+			const { config, resolver, root } = ctx;
+			const { output, group, validator, sdk } = ctx.options;
+			if (!ctx.driver.getPlugin(pluginTsName) || !sdk) return null;
+			const controllers = buildControllers(nodes, ctx);
+			const clientPath = path.resolve(root, ".kubb/client.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.tsResolver)
+				}));
+				const { namesByPath: zodNamesByPath, filesByPath: zodFilesByPath } = isValidatorEnabled(validator) ? collectImportsByFile(ops, (op) => ({
+					file: op.zodFile,
+					names: op.zodResolver ? resolveZodImportNames(op.node, op.zodResolver, validator) : []
+				})) : {
+					namesByPath: /* @__PURE__ */ new Map(),
+					filesByPath: /* @__PURE__ */ new Map()
+				};
+				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"],
+							root: file.path,
+							path: clientPath
+						}),
+						/* @__PURE__ */ jsx(File.Import, {
+							name: [
+								"ClientConfig",
+								"ClientInstance",
+								"Options",
+								"RequestResult"
+							],
+							root: file.path,
+							path: clientPath,
+							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)),
+						isValidatorEnabled(validator) && Array.from(zodNamesByPath.entries()).map(([filePath, set]) => /* @__PURE__ */ jsx(File.Import, {
+							name: Array.from(set),
+							root: file.path,
+							path: zodFilesByPath.get(filePath).path
+						}, filePath)),
+						/* @__PURE__ */ jsx(SdkClient, {
+							name: className,
+							operations: ops,
+							validator
+						})
+					]
+				}, file.path);
+			};
+			if (sdk.mode === "flat") return 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));
+			const classFiles = controllers.map(({ name, file, operations: ops }) => renderClassFile(name, file, ops));
+			if (!sdk.name) return /* @__PURE__ */ jsx(Fragment, { children: classFiles });
+			const sdkFile = resolver.file({
+				name: sdk.name,
+				extname: ".ts",
+				root,
+				output,
+				group: group ?? void 0
+			});
+			const facadeName = resolver.className(sdk.name);
+			const members = controllers.map(({ name, tag }) => ({
+				className: name,
+				propName: resolver.propertyName(tag ?? name)
+			}));
+			return /* @__PURE__ */ jsxs(Fragment, { children: [classFiles, /* @__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: facadeName,
+						members
+					})
+				]
+			}, sdkFile.path)] });
+		}
+	});
+}
+//#endregion
+//#region ../../internals/client/src/macros.ts
+/**
+* Macros the client plugins apply by default, ahead of any user macros. `macroSimplifyUnion`
+* drops union members a broader scalar already covers, keeping the generated response and error
+* unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
+*/
+const defaultMacros = [macroSimplifyUnion];
+//#endregion
+//#region ../../internals/client/src/resolver.ts
+/**
+* Default resolver shared by the client plugins. Functions and files inherit the built-in camelCase
+* `name` and `file`; 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",
+	className(name) {
+		return ensureValidVarName(pascalCase(name));
+	},
+	groupName(name) {
+		return ensureValidVarName(pascalCase(`${name} Client`));
+	},
+	propertyName(name) {
+		return ensureValidVarName(camelCase(name));
+	}
+});
+//#endregion
+//#region 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");
+//#endregion
+//#region src/templates.ts
+/** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
+const fetchClientTemplatePath = fileURLToPath(new URL("../templates/fetch.ts", import.meta.url));
+/** Absolute path to the fetch serializers template, copied into `.kubb/serializers.ts`. */
+const fetchSerializersTemplatePath = fileURLToPath(new URL("../templates/serializers.ts", import.meta.url));
+/**
+* Absolute path to the Standard Schema runtime template. Pass it to a file node's `copy` field to
+* emit the helper into the generated `.kubb/standardSchema.ts` verbatim.
+*/
+const standardSchemaTemplatePath = fileURLToPath(new URL("../templates/standardSchema.ts", import.meta.url));
+//#endregion
+//#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin
+* dependency references.
+*/
+const pluginFetchName = "plugin-fetch";
+/**
+* Generates a type-safe HTTP client pinned to the Fetch API. Each operation becomes one async
+* function that takes a single grouped `options` object and returns the shared `RequestResult`
+* contract. The runtime is always bundled into `.kubb/client.ts`, so generated code never imports
+* from `@kubb/plugin-fetch` and the only runtime dependency is the global `fetch`.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginFetch } from '@kubb/plugin-fetch'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginFetch({ output: { path: './clients' } }),
+*   ],
+* })
+* ```
+*/
+const pluginFetch = definePlugin((options) => {
+	const { output = {
+		path: "clients",
+		barrel: { type: "named" }
+	}, exclude = [], include, override = [], baseURL, validator = false, group, sdk, resolver: userResolver } = options;
+	const resolved = {
+		output,
+		exclude,
+		include,
+		override,
+		group: createGroupConfig(group),
+		baseURL,
+		validator,
+		sdk: sdk ? {
+			mode: sdk.mode ?? "tag",
+			name: sdk.name
+		} : void 0,
+		resolver: userResolver ? Resolver.merge(resolverClient, userResolver) : resolverClient
+	};
+	const selectedGenerators = resolved.sdk ? [createSdkGenerator()] : [clientGenerator];
+	return {
+		name: pluginFetchName,
+		options,
+		dependencies: [pluginTsName, isValidatorEnabled(resolved.validator) ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
+		hooks: { "kubb:plugin:setup"(ctx) {
+			ctx.setOptions(resolved);
+			ctx.setResolver(resolved.resolver);
+			ctx.setMacros([...defaultMacros, ...options.macros ?? []]);
+			ctx.addGenerator(...selectedGenerators);
+			const root = path.resolve(ctx.config.root, ctx.config.output.path);
+			const baseURLExpression = baseURL ? baseURL.includes("${") ? `\`${baseURL.replaceAll("`", "\\`")}\`` : JSON.stringify(baseURL) : void 0;
+			ctx.injectFile({
+				baseName: "serializers.ts",
+				path: path.resolve(root, ".kubb/serializers.ts"),
+				copy: fetchSerializersTemplatePath
+			});
+			ctx.injectFile({
+				baseName: "client.ts",
+				path: path.resolve(root, ".kubb/client.ts"),
+				copy: fetchClientTemplatePath,
+				footer: baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : void 0
+			});
+			ctx.injectFile({
+				baseName: "standardSchema.ts",
+				path: path.resolve(root, ".kubb/standardSchema.ts"),
+				copy: standardSchemaTemplatePath
+			});
+		} }
+	};
+});
+//#endregion
+export { clientGenerator, pluginFetch as default, pluginFetch, pluginFetchName };
+
+//# sourceMappingURL=index.js.map