@kubb/plugin-fetch 5.0.0-beta.98 → 5.0.0

package/dist/index.cjs

@@ -19,19 +19,225 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
 //#endregion
+let kubb_kit = require("kubb/kit");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
-let kubb_kit = require("kubb/kit");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
 let kubb_jsx = require("kubb/jsx");
 let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
 let _kubb_plugin_zod = require("@kubb/plugin-zod");
 let node_url = require("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
+	};
+}
+/**
+* Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the
+* current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the
+* same dependency for the same operation in one pass (a query plugin's several hook generators, the
+* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
+*
+* @example Cache `plugin-ts`'s file for the current operation
+* ```ts
+* const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })
+* ```
+*/
+function resolveDependencyOperationFile(options) {
+	const { cache, node, resolver, root, output, group } = options;
+	return cache.ensureItem(`${resolver.pluginName}:operationFile`, () => resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output,
+		group: group ?? void 0
+	}));
+}
+function getOperationLink(node, link) {
+	if (!link) return null;
+	if (typeof link === "function") return link(node) ?? null;
+	return node.path ? `{@link ${kubb_kit.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));
+}
+const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
+/**
+* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
+* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
+* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
+* same parameters once per plugin.
+*/
+function getOperationParameters(node) {
+	const cached = operationParameterGroupsByNode.get(node);
+	if (cached) return cached;
+	const groups = {
+		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"))
+	};
+	operationParameterGroupsByNode.set(node, groups);
+	return groups;
+}
+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.
@@ -227,342 +433,6 @@ function buildJSDoc(comments, options = {}) {
 	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
 }
 //#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");
-	}
-	/**
-	* Rewrites OpenAPI placeholder names while keeping the `{...}` braces, so the generated `url`
-	* literal aligns with the grouped `path` request option that the runtime client interpolates by
-	* key.
-	*
-	* @example
-	* Url.toCasedTemplate('/projects/{project_id}', { casing: 'camelcase' }) // '/projects/{projectId}'
-	*/
-	static toCasedTemplate(path, { casing } = {}) {
-		return path.replace(/\{([^}]+)\}/g, (_, name) => `{${transformParam(name, casing)}}`);
-	}
-	/**
-	* 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;
-}
-/**
-* Drops parameters that collapse to the same property identity once camelCased, keeping the first.
-*
-* Some specs declare the same parameter twice under different casings (for example AWS S3 lists both
-* `max-uploads` and `MaxUploads`). Both resolve to one output property, so emitting both would yield
-* an object type with a duplicate member, which TypeScript rejects. De-duplicate by the camelCased
-* identity so the resulting group is collision-free regardless of the names each caller carries.
-*/
-function dedupeByCasedName(params) {
-	const seen = /* @__PURE__ */ new Set();
-	return params.filter((param) => {
-		const key = camelCase(param.name);
-		if (seen.has(key)) return false;
-		seen.add(key);
-		return true;
-	});
-}
-function buildParamsMapping(originalParams, mappedParams) {
-	const mapping = {};
-	let hasChanged = false;
-	originalParams.forEach((param, i) => {
-		const mappedName = mappedParams[i]?.name ?? param.name;
-		mapping[param.name] = mappedName;
-		if (param.name !== mappedName) hasChanged = true;
-	});
-	return hasChanged ? mapping : null;
-}
-function toAccess(object, name) {
-	return isValidVarName(name) ? `${object}.${name}` : `${object}[${JSON.stringify(name)}]`;
-}
-/**
-* Renders the object-literal expression that renames the camelCased keys of a grouped request
-* option back to the names the OpenAPI document declares, guarded so an omitted optional group
-* stays omitted. Shared by the client and cypress generators, which pass a `buildParamsMapping`
-* result and the source expression to read the keys from.
-*
-* @example
-* ```ts
-* buildParamsRemapExpression({ source: 'config.query', mapping: { include_deleted: 'includeDeleted' } })
-* // 'config.query ? { "include_deleted": config.query.includeDeleted } : config.query'
-* ```
-*/
-function buildParamsRemapExpression({ source, mapping }) {
-	return `${source} ? { ${Object.entries(mapping).map(([originalName, casedName]) => `${JSON.stringify(originalName)}: ${toAccess(source, casedName)}`).join(", ")} } : ${source}`;
-}
-//#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;
-	if (link === "urlPath") return node.path ? `{@link ${Url.toPath(node.path)}}` : null;
-	return node.path ? `{@link ${node.path.replaceAll("{", ":").replaceAll("}", "")}}` : 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, options = {}) {
-	const params = caseParams(node.parameters, options.paramsCasing === "original" ? void 0 : "camelcase");
-	return {
-		path: dedupeByCasedName(params.filter((param) => param.in === "path")),
-		query: dedupeByCasedName(params.filter((param) => param.in === "query")),
-		header: dedupeByCasedName(params.filter((param) => param.in === "header")),
-		cookie: dedupeByCasedName(params.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/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -594,38 +464,6 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
-//#region ../../internals/client/src/builders/paramsRemap.ts
-/**
-* Builds the call-config entries that rename the camelCased `query` and `headers` keys back to the
-* names the OpenAPI document declares, so the wire format follows the spec while the generated
-* types keep camelCase keys. Returns an empty array when no name changes. Path parameters need no
-* remap because the URL template placeholders are renamed in sync with the `path` keys. Emit the
-* entries after the `...config` spread so they override the camelCased groups the caller passes in.
-*
-* @example
-* ```ts
-* // a query param named include_deleted in the spec
-* buildParamsRemap({ node }) // ['query: config.query ? { "include_deleted": config.query.includeDeleted } : config.query']
-* ```
-*/
-function buildParamsRemap({ node }) {
-	if (!kubb_kit.ast.isHttpOperationNode(node)) return [];
-	const original = getOperationParameters(node, { paramsCasing: "original" });
-	const cased = getOperationParameters(node);
-	const queryMapping = buildParamsMapping(original.query, cased.query);
-	const headerMapping = buildParamsMapping(original.header, cased.header);
-	const entries = [];
-	if (queryMapping) entries.push(`query: ${buildParamsRemapExpression({
-		source: "config.query",
-		mapping: queryMapping
-	})}`);
-	if (headerMapping) entries.push(`headers: ${buildParamsRemapExpression({
-		source: "config.headers",
-		mapping: headerMapping
-	})}`);
-	return entries;
-}
-//#endregion
 //#region ../../internals/client/src/builders/generics.ts
 /**
 * Builds the `RequestResult` generic arguments for one operation: the plugin-ts per-status responses
@@ -857,11 +695,10 @@ function buildCallConfig({ node, validator, zodResolver, security }) {
 	const securityLiteral = buildSecurityMetadata({ security });
 	return `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
-		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
+		`url: '${node.path}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
 		validatorLiteral,
-		"...config",
-		...buildParamsRemap({ node })
+		"...config"
 	].filter(Boolean).join(", ")} }`;
 }
 /**
@@ -987,14 +824,13 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
 	const callConfig = `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
-		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
+		`url: '${node.path}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
 		stylesLiteral ? `styles: ${stylesLiteral}` : null,
 		validatorLiteral,
 		contentTypeLiteral,
 		responseTypeLiteral,
-		"...config",
-		...buildParamsRemap({ node })
+		"...config"
 	].filter(Boolean).join(", ")} }`;
 	const eventType = `SuccessOf<${tsResolver.response.responses(node)}>`;
 	const returnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
@@ -1058,6 +894,125 @@ function SdkClient({ name, isExportable = true, isIndexable = true, operations,
 	});
 }
 //#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 (0, kubb_kit.defineGenerator)({
+		name,
+		renderer: kubb_jsx.jsxRenderer,
+		operation(node, ctx) {
+			if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
+			const { config, driver, resolver, root } = ctx;
+			const { output, validator, group } = ctx.options;
+			const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
+			if (!pluginTs) return null;
+			const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+			const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(_kubb_plugin_zod.pluginZodName) : null;
+			const zodResolver = pluginZod ? driver.getResolver(_kubb_plugin_zod.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: resolveDependencyOperationFile({
+					cache: ctx.cache,
+					node,
+					resolver: tsResolver,
+					root,
+					output: pluginTs.options?.output ?? output,
+					group: pluginTs.options?.group
+				}),
+				fileZod: zodResolver && pluginZod?.options ? zodResolver.file({
+					...operationFileEntry(node, node.operationId),
+					root,
+					output: pluginZod.options.output ?? output,
+					group: pluginZod.options?.group ?? void 0
+				}) : null
+			};
+			const security = getOperationSecurity({
+				document: ctx.adapter.document,
+				method: node.method,
+				path: node.path
+			});
+			const clientPath = node_path.default.resolve(root, ".kubb/client.ts");
+			const eventStream = isEventStream(node);
+			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: eventStream ? ["client", "toEventStream"] : ["client"],
+						root: meta.file.path,
+						path: clientPath
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: eventStream ? [
+							"Options",
+							"EventStreamResult",
+							"SuccessOf"
+						] : ["Options", "RequestResult"],
+						root: meta.file.path,
+						path: clientPath,
+						isTypeOnly: true
+					}),
+					meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: importedZodNames,
+						root: meta.file.path,
+						path: meta.fileZod.path
+					}),
+					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.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
@@ -1087,7 +1042,7 @@ function resolveTypeImportNames(node, tsResolver) {
 	return [tsResolver.response.options(node), tsResolver.response.responses(node)];
 }
 function resolveZodImportNames(node, zodResolver, validator) {
-	const { query: queryParams } = getOperationParameters(node, { paramsCasing: "original" });
+	const { query: queryParams } = getOperationParameters(node);
 	return [
 		resolveResponseValidator(validator) === "zod" ? zodResolver.response.response(node) : null,
 		resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
@@ -1327,7 +1282,7 @@ function createSdkGenerator() {
 * 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 = [kubb_kit.ast.macroSimplifyUnion];
+const defaultMacros = [kubb_kit.macroSimplifyUnion];
 //#endregion
 //#region ../../internals/client/src/resolver.ts
 /**
@@ -1356,115 +1311,10 @@ const resolverClient = (0, kubb_kit.createResolver)({
 //#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`.
+* 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 = (0, kubb_kit.defineGenerator)({
-	name: "fetch",
-	renderer: kubb_jsx.jsxRenderer,
-	operation(node, ctx) {
-		if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
-		const { config, driver, resolver, root } = ctx;
-		const { output, validator, group } = ctx.options;
-		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
-		if (!pluginTs) return null;
-		const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
-		const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(_kubb_plugin_zod.pluginZodName) : null;
-		const zodResolver = pluginZod ? driver.getResolver(_kubb_plugin_zod.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 = node_path.default.resolve(root, ".kubb/client.ts");
-		const eventStream = isEventStream(node);
-		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-					name: eventStream ? ["client", "toEventStream"] : ["client"],
-					root: meta.file.path,
-					path: clientPath
-				}),
-				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-					name: eventStream ? [
-						"Options",
-						"EventStreamResult",
-						"SuccessOf"
-					] : ["Options", "RequestResult"],
-					root: meta.file.path,
-					path: clientPath,
-					isTypeOnly: true
-				}),
-				meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
-					name: importedZodNames,
-					root: meta.file.path,
-					path: meta.fileZod.path
-				}),
-				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Operation, {
-					name: meta.name,
-					node,
-					tsResolver,
-					zodResolver,
-					validator,
-					security
-				})
-			]
-		});
-	}
-});
+const clientGenerator = createClientGenerator("fetch");
 //#endregion
 //#region src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */