@kubb/plugin-fetch 5.0.0-beta.95 → 5.0.0-beta.99

package/dist/index.cjs

@@ -27,8 +27,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let kubb_kit = require("kubb/kit");
-let kubb_jsx = require("kubb/jsx");
 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");
@@ -228,33 +228,17 @@ function buildJSDoc(comments, options = {}) {
 }
 //#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;
+/**
+* Keeps the OpenAPI parameter name as-is when it is already a valid JS identifier, and
+* camelCases it only enough to become one otherwise (for example a hyphenated path segment).
+*/
+function transformParam(raw) {
+	return isValidVarName(raw) ? raw : camelCase(raw);
 }
 /**
-* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
+* Helpers for OpenAPI/Swagger paths.
 */
 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.
 	*
@@ -270,15 +254,14 @@ var Url = class Url {
 	* key.
 	*
 	* @example
-	* Url.toCasedTemplate('/projects/{project_id}', { casing: 'camelcase' }) // '/projects/{projectId}'
+	* Url.toSafeTemplate('/user/{monetary-account-id}') // '/user/{monetaryAccountId}'
 	*/
-	static toCasedTemplate(path, { casing } = {}) {
-		return path.replace(/\{([^}]+)\}/g, (_, name) => `{${transformParam(name, casing)}}`);
+	static toSafeTemplate(path) {
+		return path.replace(/\{([^}]+)\}/g, (_, name) => `{${transformParam(name)}}`);
 	}
 	/**
 	* 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.
+	* `prefix` is prepended inside the literal, and `replacer` transforms each parameter name.
 	*
 	* @example
 	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
@@ -286,10 +269,10 @@ var Url = class Url {
 	* @example
 	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
 	*/
-	static toTemplateString(path, { prefix, replacer, casing } = {}) {
+	static toTemplateString(path, { prefix, replacer } = {}) {
 		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
 			if (i % 2 === 0) return part;
-			const param = transformParam(part, casing);
+			const param = transformParam(part);
 			return `\${${replacer ? replacer(param) : param}}`;
 		}).join("");
 		return `\`${prefix ?? ""}${result}\``;
@@ -297,8 +280,8 @@ var Url = class Url {
 	/**
 	* 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.
+	* names 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}`'
@@ -306,103 +289,28 @@ var Url = class Url {
 	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.
+* Drops parameters that share the same name, 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.
+* 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 dedupeByCasedName(params) {
+function dedupeParams(params) {
 	const seen = /* @__PURE__ */ new Set();
 	return params.filter((param) => {
-		const key = camelCase(param.name);
-		if (seen.has(key)) return false;
-		seen.add(key);
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
 		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
 /**
@@ -536,13 +444,15 @@ function buildOperationComments(node, options = {}) {
 	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");
+function getOperationParameters(node) {
 	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"))
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path").map((param) => isValidVarName(param.name) ? param : {
+			...param,
+			name: camelCase(param.name)
+		})),
+		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) {
@@ -594,64 +504,33 @@ function createGroupConfig(group) {
 	};
 }
 //#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;
-}
+//#region ../../internals/client/src/builders/generics.ts
 /**
-* 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.
+* 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 buildZodResponseParse(node, zodResolver) {
-	const name = zodResolver.response.response(node);
-	return name ? {
-		expression: name,
-		importNames: [name]
-	} : null;
+function buildRequestResultGenerics({ node, tsResolver }) {
+	return `${tsResolver.response.responses(node)}, ThrowOnError`;
 }
+//#endregion
+//#region ../../internals/client/src/builders/returnStatement.ts
 /**
-* 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.
+* 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 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;
+function buildReturnStatement({ node, tsResolver, callConfig }) {
+	return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		tsResolver
+	})}>>`;
 }
 //#endregion
 //#region ../../internals/client/src/builders/security.ts
@@ -722,67 +601,6 @@ function buildSecurityMetadata({ security }) {
 	return `[${security.map(serializeAuth).join(", ")}]`;
 }
 //#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
-* 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/signature.ts
 const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 /**
@@ -814,6 +632,151 @@ function buildGroupedOptionsSignature({ node, tsResolver }) {
 	};
 }
 //#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: '${Url.toSafeTemplate(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 (!kubb_kit.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.
@@ -867,32 +830,6 @@ function buildStyles({ node }) {
 	return `{ ${locations.map((location) => `${location}: { ${groups[location].join(", ")} }`).join(", ")} }`;
 }
 //#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/components/Operation.tsx
 /**
 * Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
@@ -927,14 +864,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: '${Url.toSafeTemplate(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;
@@ -967,66 +903,6 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 	});
 }
 //#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: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
-		securityLiteral ? `security: ${securityLiteral}` : null,
-		validatorLiteral,
-		"...config",
-		...buildParamsRemap({ node })
-	].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 (!kubb_kit.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/components/SdkClient.tsx
 /**
 * Renders one instance class per tag with one method per operation. The constructor takes a client
@@ -1087,7 +963,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,