@kubb/plugin-fetch 5.0.0-beta.73

package/dist/index.js

@@ -0,0 +1,1231 @@
+import "./rolldown-runtime-C0LytTxp.js";
+import path from "node:path";
+import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+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 { pluginZodName } from "@kubb/plugin-zod";
+import { buildJSDoc } from "@kubb/ast/utils";
+import { macroSimplifyUnion } from "@kubb/ast/macros";
+import { fileURLToPath } from "node:url";
+//#region ../../internals/client/src/builders/parser.ts
+/**
+* Returns `true` when any direction of the parser uses zod (used for dependency checks).
+*/
+function isParserEnabled(parser) {
+	if (!parser) return false;
+	if (parser === "zod") return true;
+	return Boolean(parser.request || parser.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 resolveRequestParser(parser) {
+	if (!parser || parser === "zod") return null;
+	return parser.request ?? null;
+}
+/**
+* Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise. Only the object form
+* `{ request: 'zod' }` enables it.
+*/
+function resolveQueryParamsParser(parser) {
+	if (!parser || parser === "zod") return null;
+	return parser.request ?? null;
+}
+/**
+* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
+* maps to response parsing.
+*/
+function resolveResponseParser(parser) {
+	if (!parser) return null;
+	if (parser === "zod") return "zod";
+	return parser.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.resolveResponseName?.(node);
+	return name ? {
+		expression: name,
+		importNames: [name]
+	} : null;
+}
+//#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/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/fs.ts
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = 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 /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(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}`;
+}
+//#endregion
+//#region ../../internals/utils/src/url.ts
+function transformParam(raw, casing) {
+	const param = isValidVarName(raw) ? raw : camelCase(raw);
+	return casing === "camelcase" ? camelCase(param) : param;
+}
+function toParamsObject(path, { replacer, casing } = {}) {
+	const params = {};
+	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
+		const param = transformParam(match[1], casing);
+		const key = replacer ? replacer(param) : param;
+		params[key] = key;
+	}
+	return Object.keys(params).length > 0 ? params : null;
+}
+/**
+* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
+*/
+var Url = class Url {
+	/**
+	* Reports whether `url` is a parseable absolute URL. Delegates to the native `URL.canParse`.
+	*
+	* @example
+	* Url.canParse('https://petstore.swagger.io/v2') // true
+	* Url.canParse('/pet/{petId}')                   // false
+	*/
+	static canParse(url, base) {
+		return URL.canParse(url, base);
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
+	*
+	* @example
+	* Url.toPath('/pet/{petId}') // '/pet/:petId'
+	*/
+	static toPath(path) {
+		return path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
+	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
+	* and `casing` controls parameter identifier casing.
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
+	*
+	* @example
+	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
+	*/
+	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = transformParam(part, casing);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("");
+		return `\`${prefix ?? ""}${result}\``;
+	}
+	/**
+	* Converts an OpenAPI/Swagger path to a template literal that reads each parameter off the
+	* grouped `path` request option, e.g. `/pet/{petId}` becomes `` `/pet/${path.petId}` ``. Parameter
+	* names are camelCased to match the generated `path` type, and `prefix` is prepended inside the
+	* literal. Shared by the client and cypress generators that pass a grouped `path` object.
+	*
+	* @example
+	* Url.toGroupedTemplateString('/pet/{petId}') // '`/pet/${path.petId}`'
+	*/
+	static toGroupedTemplateString(path, { prefix } = {}) {
+		return Url.toTemplateString(path, {
+			prefix,
+			casing: "camelcase",
+			replacer: (name) => `path.${name}`
+		});
+	}
+	/**
+	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
+	* expression when `stringify` is set.
+	*
+	* @example
+	* Url.toObject('/pet/{petId}')
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	*/
+	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
+		const object = {
+			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
+				replacer,
+				casing
+			}),
+			params: toParamsObject(path, {
+				replacer,
+				casing
+			})
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+};
+//#endregion
+//#region ../../internals/shared/src/params.ts
+const caseParamsCache = /* @__PURE__ */ new WeakMap();
+/**
+* Applies camelCase to parameter names and returns a new array without mutating the input.
+*
+* Run it before handing parameters to schema builders so output property keys get the right casing
+* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
+* original array is returned unchanged. Results are cached per input array.
+*/
+function caseParams(params, casing) {
+	if (!casing) return params;
+	const cached = caseParamsCache.get(params);
+	if (cached) return cached;
+	const result = params.map((param) => ({
+		...param,
+		name: camelCase(param.name)
+	}));
+	caseParamsCache.set(params, result);
+	return result;
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.resolveFile`: 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.resolveFile(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;
+	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
+	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : null;
+}
+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, options = {}) {
+	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
+	return {
+		path: params.filter((param) => param.in === "path"),
+		query: params.filter((param) => param.in === "query"),
+		header: params.filter((param) => param.in === "header"),
+		cookie: params.filter((param) => param.in === "cookie")
+	};
+}
+//#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.resolveResponsesName(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/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>RequestConfig` (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>RequestConfig` and `<Name>Responses` and uses them directly, so no
+* per-operation input type has to be emitted.
+*/
+function buildGroupedOptionsSignature({ node, tsResolver }) {
+	const requestConfigName = tsResolver.resolveRequestConfigName(node);
+	const responsesName = tsResolver.resolveResponsesName(node);
+	const resultGenerics = buildRequestResultGenerics({
+		node,
+		tsResolver
+	});
+	return {
+		dataTypeName: requestConfigName,
+		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
+			name: "options",
+			type: `Options<${requestConfigName}, ThrowOnError>`
+		})] })) ?? "",
+		returnType: `Promise<RequestResult<${resultGenerics}>>`,
+		generics: ["ThrowOnError extends boolean = true"],
+		importedTypeNames: [requestConfigName, responsesName]
+	};
+}
+//#endregion
+//#region ../../internals/client/src/builders/validator.ts
+/**
+* Builds the parser-hook expressions for one operation. Request parsing runs before the send;
+* response parsing runs on the success body only. Returns `null` expressions when the matching
+* parser direction is disabled or the schema is absent.
+*/
+function buildParserHooks({ node, parser, zodResolver }) {
+	const importedZodNames = [];
+	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const zodRequestName = zodResolver && resolveRequestParser(parser) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null;
+	const request = zodRequestName ? `(data: unknown) => ${zodRequestName}.parse(data)` : null;
+	if (zodRequestName) importedZodNames.push(zodRequestName);
+	const responseParse = zodResolver && resolveResponseParser(parser) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
+	const response = responseParse ? `(data: unknown) => ${responseParse.expression}.parse(data)` : null;
+	if (responseParse) importedZodNames.push(...responseParse.importNames);
+	return {
+		request,
+		response,
+		importedZodNames
+	};
+}
+//#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, parser, security, isExportable = true, isIndexable = true }) {
+	if (!ast.isHttpOperationNode(node)) return null;
+	const signature = buildGroupedOptionsSignature({
+		node,
+		tsResolver
+	});
+	const parsers = buildParserHooks({
+		node,
+		parser,
+		zodResolver
+	});
+	const securityLiteral = buildSecurityMetadata({ security });
+	const parserEntries = [parsers.request ? `request: ${parsers.request}` : null, parsers.response ? `response: ${parsers.response}` : null].filter(Boolean);
+	const parserLiteral = parserEntries.length ? `parser: { ${parserEntries.join(", ")} }` : null;
+	const callConfig = `{ ${[
+		`method: '${node.method.toUpperCase()}'`,
+		`url: '${node.path}'`,
+		securityLiteral ? `security: ${securityLiteral}` : null,
+		parserLiteral,
+		"...config"
+	].filter(Boolean).join(", ")} }`;
+	return /* @__PURE__ */ jsx(File.Source, {
+		name,
+		isExportable,
+		isIndexable,
+		children: /* @__PURE__ */ jsxs(Function, {
+			name,
+			export: isExportable,
+			generics: signature.generics,
+			params: signature.paramsSignature,
+			returnType: signature.returnType,
+			JSDoc: { comments: buildOperationComments(node, {
+				link: "urlPath",
+				linkPosition: "beforeDeprecated",
+				splitLines: true
+			}) },
+			children: [
+				"const { client: request = client, ...config } = options",
+				/* @__PURE__ */ jsx("br", {}),
+				buildReturnStatement({
+					node,
+					tsResolver,
+					callConfig
+				})
+			]
+		})
+	});
+}
+//#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?, parser?, ...config }`. The `...config` spread carries every
+* per-call field (including `throwOnError`), so the method stays a thin wrapper over the contract.
+*/
+function buildCallConfig({ node, parser, zodResolver, security }) {
+	const parsers = buildParserHooks({
+		node,
+		parser,
+		zodResolver
+	});
+	const parserEntries = [parsers.request ? `request: ${parsers.request}` : null, parsers.response ? `response: ${parsers.response}` : null].filter(Boolean);
+	const parserLiteral = parserEntries.length ? `parser: { ${parserEntries.join(", ")} }` : null;
+	const securityLiteral = buildSecurityMetadata({ security });
+	return `{ ${[
+		`method: '${node.method.toUpperCase()}'`,
+		`url: '${node.path}'`,
+		securityLiteral ? `security: ${securityLiteral}` : null,
+		parserLiteral,
+		"...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, parser, security }) {
+	if (!ast.isHttpOperationNode(node)) return "";
+	const signature = buildGroupedOptionsSignature({
+		node,
+		tsResolver
+	});
+	const returnStatement = buildReturnStatement({
+		node,
+		tsResolver,
+		callConfig: buildCallConfig({
+			node,
+			parser,
+			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/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, parser, children }) {
+	const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver, security }) => buildSdkMethod({
+		node,
+		name: methodName,
+		tsResolver,
+		zodResolver,
+		parser,
+		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/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.resolveRequestConfigName(node), tsResolver.resolveResponsesName(node)];
+}
+function resolveZodImportNames(node, zodResolver, parser) {
+	const { query: queryParams } = getOperationParameters(node, { paramsCasing: "original" });
+	return [
+		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
+		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(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, parser } = ctx.options;
+	const pluginTs = driver.getPlugin(pluginTsName);
+	const tsResolver = driver.getResolver(pluginTsName);
+	const tsPluginOptions = pluginTs.options;
+	const pluginZod = isParserEnabled(parser) ? driver.getPlugin(pluginZodName) : null;
+	const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+	const document = ctx.adapter.document;
+	function buildOperationData(node) {
+		const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+			root,
+			output: tsPluginOptions?.output ?? output,
+			group: tsPluginOptions?.group
+		});
+		const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile(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.resolveName(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.resolveGroupName(tag) : resolver.resolveClassName("ApiClient");
+		const file = resolver.resolveFile({
+			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, parser, 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.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: file.path,
+					baseName: file.baseName
+				}
+			});
+			const footer = (file) => resolver.resolveFooter(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 } = isParserEnabled(parser) ? collectImportsByFile(ops, (op) => ({
+					file: op.zodFile,
+					names: op.zodResolver ? resolveZodImportNames(op.node, op.zodResolver, parser) : []
+				})) : {
+					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
+						}),
+						parser === "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)),
+						isParserEnabled(parser) && 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,
+							parser
+						})
+					]
+				}, file.path);
+			};
+			if (sdk.mode === "flat") return renderClassFile(resolver.resolveClassName(sdk.name ?? "sdk"), resolver.resolveFile({
+				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.resolveFile({
+				name: sdk.name,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group: group ?? void 0
+			});
+			const facadeName = resolver.resolveClassName(sdk.name);
+			const members = controllers.map(({ name, tag }) => ({
+				className: name,
+				propName: resolver.resolveClientPropertyName(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 use camelCase; classes and
+* tag groups use PascalCase.
+*
+* @example
+* ```ts
+* resolverClient.resolveName('show pet by id') // 'showPetById'
+* resolverClient.resolveGroupName('pet')       // 'PetClient'
+* ```
+*/
+const resolverClient = defineResolver(() => ({
+	name: "default",
+	pluginName: "plugin-contract-client",
+	default(name, type) {
+		if (type === "file") return toFilePath(name);
+		return ensureValidVarName(camelCase(name));
+	},
+	resolveName(name) {
+		return this.default(name, "function");
+	},
+	resolvePathName(name, type) {
+		return this.default(name, type);
+	},
+	resolveClassName(name) {
+		return ensureValidVarName(pascalCase(name));
+	},
+	resolveGroupName(name) {
+		return ensureValidVarName(pascalCase(`${name} Client`));
+	},
+	resolveClientPropertyName(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 = defineGenerator({
+	name: "fetch",
+	renderer: jsxRenderer,
+	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
+		const { config, driver, resolver, root } = ctx;
+		const { output, parser, group } = ctx.options;
+		const pluginTs = driver.getPlugin(pluginTsName);
+		if (!pluginTs) return null;
+		const tsResolver = driver.getResolver(pluginTsName);
+		const pluginZod = resolveResponseParser(parser) === "zod" || resolveRequestParser(parser) === "zod" ? driver.getPlugin(pluginZodName) : null;
+		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
+		const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), tsResolver.resolveResponsesName(node)];
+		const importedZodNames = zodResolver ? [resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null, resolveRequestParser(parser) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null].filter((name) => Boolean(name)) : [];
+		const meta = {
+			name: resolver.resolveName(node.operationId),
+			file: resolver.resolveFile(operationFileEntry(node, node.operationId), {
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			}),
+			fileZod: zodResolver && pluginZod?.options ? zodResolver.resolveFile(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");
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.resolveBanner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.resolveFooter(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["client"],
+					root: meta.file.path,
+					path: clientPath
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["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,
+					parser,
+					security
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/templates.ts
+/**
+* Absolute path to the fetch client runtime template, resolved relative to this package's own
+* location so it stays correct no matter which package imports it. Pass it to a file node's `copy`
+* field to emit the runtime into the generated `.kubb/client.ts` verbatim.
+*/
+const fetchClientTemplatePath = fileURLToPath(new URL("../templates/fetch.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'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginFetch } from '@kubb/plugin-fetch'
+*
+* export default defineConfig({
+*   input: { path: './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, parser = false, group, sdk, resolver: userResolver } = options;
+	const resolved = {
+		output,
+		exclude,
+		include,
+		override,
+		group: createGroupConfig(group),
+		baseURL,
+		parser,
+		sdk: sdk ? {
+			mode: sdk.mode ?? "tag",
+			name: sdk.name
+		} : void 0,
+		resolver: userResolver ? {
+			...resolverClient,
+			...userResolver
+		} : resolverClient
+	};
+	const selectedGenerators = resolved.sdk ? [createSdkGenerator()] : [clientGenerator];
+	return {
+		name: pluginFetchName,
+		options,
+		dependencies: [pluginTsName, isParserEnabled(resolved.parser) ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
+		hooks: { "kubb:plugin:setup"(ctx) {
+			ctx.setOptions(resolved);
+			ctx.setResolver(resolved.resolver);
+			ctx.setMacros([...defaultMacros, ...options.macros ?? []]);
+			for (const gen of selectedGenerators) ctx.addGenerator(gen);
+			const root = path.resolve(ctx.config.root, ctx.config.output.path);
+			ctx.injectFile({
+				baseName: "client.ts",
+				path: path.resolve(root, ".kubb/client.ts"),
+				copy: fetchClientTemplatePath,
+				footer: baseURL ? `client.setConfig({ baseURL: ${JSON.stringify(baseURL)} })` : void 0
+			});
+		} }
+	};
+});
+//#endregion
+export { clientGenerator, pluginFetch as default, pluginFetch, pluginFetchName };
+
+//# sourceMappingURL=index.js.map