@kubb/plugin-fetch 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/index.cjs

@@ -71,31 +71,6 @@ 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.
@@ -219,6 +194,23 @@ function ensureValidVarName(name) {
 	return `_${name}`;
 }
 //#endregion
+//#region ../../internals/utils/src/codegen.ts
+/**
+* Builds a JSDoc comment block from an array of lines. Returns `fallback` when there are no
+* comments.
+*
+* @example
+* ```ts
+* buildJSDoc(['@type string', '@example hello'])
+* // '/**\n   * @type string\n   * @example hello\n   *\/\n  '
+* ```
+*/
+function buildJSDoc(comments, options = {}) {
+	const { indent = "   * ", suffix = "\n  ", fallback = "  " } = options;
+	if (comments.length === 0) return fallback;
+	return `/**\n${comments.map((c) => `${indent}${c}`).join("\n")}\n   */${suffix}`;
+}
+//#endregion
 //#region ../../internals/utils/src/url.ts
 function transformParam(raw, casing) {
 	const param = isValidVarName(raw) ? raw : camelCase(raw);
@@ -367,17 +359,45 @@ function dedupeByCasedName(params) {
 		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.resolveFile`: a file named `name`, tagged by the operation's first
+* `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.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
 * ```
 */
 function operationFileEntry(node, name, extname = ".ts") {
@@ -600,7 +620,7 @@ function resolveResponseValidator(validator) {
 * `<operation>ResponseSchema` is used; error bodies are never zod-parsed.
 */
 function buildZodResponseParse(node, zodResolver) {
-	const name = zodResolver.resolveResponseName?.(node);
+	const name = zodResolver.response.response(node);
 	return name ? {
 		expression: name,
 		importNames: [name]
@@ -613,7 +633,7 @@ function buildZodResponseParse(node, zodResolver) {
 */
 function buildZodErrorParse(node, zodResolver) {
 	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
-	const name = zodResolver.resolveErrorName?.(node);
+	const name = zodResolver.response.error?.(node);
 	return name ? {
 		expression: name,
 		importNames: [name]
@@ -688,6 +708,38 @@ 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
@@ -698,7 +750,7 @@ function buildSecurityMetadata({ security }) {
 * `buildRequestResultGenerics({ node, tsResolver }) // 'AddPetResponses, ThrowOnError'`
 */
 function buildRequestResultGenerics({ node, tsResolver }) {
-	return `${tsResolver.resolveResponsesName(node)}, ThrowOnError`;
+	return `${tsResolver.response.responses(node)}, ThrowOnError`;
 }
 //#endregion
 //#region ../../internals/client/src/builders/returnStatement.ts
@@ -721,41 +773,42 @@ function buildReturnStatement({ node, tsResolver, callConfig }) {
 const declarationPrinter = (0, _kubb_plugin_ts.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
+* is the plugin-ts `<Name>Options` (carrying a literal `url`), and a `RequestResult` return type
 * keyed to the plugin-ts per-status responses record. There are no positional arguments.
 *
-* The generated file imports `<Name>RequestConfig` and `<Name>Responses` and uses them directly, so no
+* The generated file imports `<Name>Options` and `<Name>Responses` and uses them directly, so no
 * per-operation input type has to be emitted.
 */
 function buildGroupedOptionsSignature({ node, tsResolver }) {
-	const requestConfigName = tsResolver.resolveRequestConfigName(node);
-	const responsesName = tsResolver.resolveResponsesName(node);
+	const optionsName = tsResolver.response.options(node);
+	const responsesName = tsResolver.response.responses(node);
 	const resultGenerics = buildRequestResultGenerics({
 		node,
 		tsResolver
 	});
 	const { isOptional } = getRequestGroupOptionality(node);
 	return {
-		dataTypeName: requestConfigName,
+		dataTypeName: optionsName,
 		paramsSignature: declarationPrinter.print((0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
 			name: "options",
-			type: `Options<${requestConfigName}, ThrowOnError>`,
+			type: `Options<${optionsName}, ThrowOnError>`,
 			...isOptional ? { default: "{}" } : {}
 		})] })) ?? "",
 		returnType: `Promise<RequestResult<${resultGenerics}>>`,
 		generics: ["ThrowOnError extends boolean = true"],
-		importedTypeNames: [requestConfigName, responsesName]
+		importedTypeNames: [optionsName, responsesName]
 	};
 }
 //#endregion
 //#region ../../internals/client/src/builders/styles.ts
 /**
-* Renders a parameter name as an object-literal key, quoting it when the camelCased name is not a
-* bare identifier (for example a name that starts with a digit) so the emitted literal stays valid.
+* Renders a parameter name as an object-literal key, quoted when it is not a bare identifier.
+* Path keys are camelCased to match the URL template placeholders. Query, header, and cookie keys
+* keep the spec name, matching the remapped keys the runtime serializes.
 */
-function toKey(name) {
-	const cased = camelCase(name);
-	return isValidVarName(cased) ? cased : JSON.stringify(cased);
+function toKey(name, location) {
+	const key = location === "path" ? camelCase(name) : name;
+	return isValidVarName(key) ? key : JSON.stringify(key);
 }
 /**
 * Serializes one parameter's metadata into a `{ style, explode }` literal, or `null` when the
@@ -769,8 +822,9 @@ function serializeParameter(parameter) {
 	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
 }
 /**
-* Builds the per-operation `styles` literal from the operation's parameters, grouped by location and
-* keyed by the camelCased parameter name to match the generated `path` / `query` / `headers` keys.
+* Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
+* Path entries are keyed by the camelCased name to match the URL template placeholders; query,
+* header, and cookie entries keep the spec name to match the keys the runtime serializes.
 * Only parameters whose source defines `style` or `explode` are emitted, so calls without
 * serialization metadata keep the runtime defaults and existing output is unchanged. Returns `null`
 * when no parameter carries metadata.
@@ -792,7 +846,7 @@ function buildStyles({ node }) {
 	for (const parameter of node.parameters) {
 		const literal = serializeParameter(parameter);
 		if (!literal) continue;
-		groups[parameter.in].push(`${toKey(parameter.name)}: ${literal}`);
+		groups[parameter.in].push(`${toKey(parameter.name, parameter.in)}: ${literal}`);
 	}
 	const locations = Object.keys(groups).filter((location) => groups[location].length > 0);
 	if (locations.length === 0) return null;
@@ -808,7 +862,7 @@ function buildStyles({ node }) {
 function buildValidatorHooks({ node, validator, zodResolver }) {
 	const importedZodNames = [];
 	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null;
+	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;
@@ -865,9 +919,10 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 		validatorLiteral,
 		contentTypeLiteral,
 		responseTypeLiteral,
-		"...config"
+		"...config",
+		...buildParamsRemap({ node })
 	].filter(Boolean).join(", ")} }`;
-	const eventType = `SuccessOf<${tsResolver.resolveResponsesName(node)}>`;
+	const eventType = `SuccessOf<${tsResolver.response.responses(node)}>`;
 	const returnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
 	const returnStatement = eventStream ? `return toEventStream<${eventType}>(request(${callConfig}))` : buildReturnStatement({
 		node,
@@ -918,7 +973,8 @@ function buildCallConfig({ node, validator, zodResolver, security }) {
 		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
 		validatorLiteral,
-		"...config"
+		"...config",
+		...buildParamsRemap({ node })
 	].filter(Boolean).join(", ")} }`;
 }
 /**
@@ -944,7 +1000,7 @@ function buildSdkMethod({ node, name, tsResolver, zodResolver, validator, securi
 		})
 	});
 	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
-	const jsdoc = kubb_kit.ast.buildJSDoc(buildOperationComments(node, {
+	const jsdoc = buildJSDoc(buildOperationComments(node, {
 		link: "urlPath",
 		linkPosition: "beforeDeprecated",
 		splitLines: true
@@ -1014,15 +1070,15 @@ function SdkFacade({ name, isExportable = true, isIndexable = true, members, chi
 //#endregion
 //#region ../../internals/client/src/generators/sdkGenerator.tsx
 function resolveTypeImportNames(node, tsResolver) {
-	return [tsResolver.resolveRequestConfigName(node), tsResolver.resolveResponsesName(node)];
+	return [tsResolver.response.options(node), tsResolver.response.responses(node)];
 }
 function resolveZodImportNames(node, zodResolver, validator) {
 	const { query: queryParams } = getOperationParameters(node, { paramsCasing: "original" });
 	return [
-		resolveResponseValidator(validator) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+		resolveResponseValidator(validator) === "zod" ? zodResolver.response.response(node) : null,
 		resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
-		resolveRequestValidator(validator) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-		resolveQueryParamsValidator(validator) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
+		resolveRequestValidator(validator) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null,
+		resolveQueryParamsValidator(validator) === "zod" && queryParams.length > 0 ? zodResolver.param.query(node, queryParams[0]) : null
 	].filter((n) => Boolean(n));
 }
 /**
@@ -1039,12 +1095,14 @@ function buildControllers(nodes, ctx) {
 	const zodResolver = pluginZod ? driver.getResolver(_kubb_plugin_zod.pluginZodName) : null;
 	const document = ctx.adapter.document;
 	function buildOperationData(node) {
-		const typeFile = tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+		const typeFile = tsResolver.file({
+			...operationFileEntry(node, node.operationId),
 			root,
 			output: tsPluginOptions?.output ?? output,
 			group: tsPluginOptions?.group
 		});
-		const zodFile = zodResolver && pluginZod?.options ? zodResolver.resolveFile(operationFileEntry(node, node.operationId), {
+		const zodFile = zodResolver && pluginZod?.options ? zodResolver.file({
+			...operationFileEntry(node, node.operationId),
 			root,
 			output: pluginZod.options?.output ?? output,
 			group: pluginZod.options?.group ?? void 0
@@ -1056,7 +1114,7 @@ function buildControllers(nodes, ctx) {
 		}) : void 0;
 		return {
 			node,
-			name: resolver.resolveName(node.operationId),
+			name: resolver.name(node.operationId),
 			tsResolver,
 			zodResolver,
 			typeFile,
@@ -1067,12 +1125,11 @@ function buildControllers(nodes, ctx) {
 	return nodes.reduce((acc, operationNode) => {
 		if (!kubb_kit.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({
+		const name = tag ? group?.name?.({ group: camelCase(tag) }) ?? resolver.groupName(tag) : resolver.className("ApiClient");
+		const file = resolver.file({
 			name,
 			extname: ".ts",
-			tag
-		}, {
+			tag,
 			root,
 			output,
 			group: group ?? void 0
@@ -1126,7 +1183,7 @@ function createSdkGenerator() {
 			if (!ctx.driver.getPlugin(_kubb_plugin_ts.pluginTsName) || !sdk) return null;
 			const controllers = buildControllers(nodes, ctx);
 			const clientPath = node_path.default.resolve(root, ".kubb/client.ts");
-			const banner = (file) => resolver.resolveBanner(ctx.meta, {
+			const banner = (file) => resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1134,7 +1191,7 @@ function createSdkGenerator() {
 					baseName: file.baseName
 				}
 			});
-			const footer = (file) => resolver.resolveFooter(ctx.meta, {
+			const footer = (file) => resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1201,28 +1258,26 @@ function createSdkGenerator() {
 					]
 				}, file.path);
 			};
-			if (sdk.mode === "flat") return renderClassFile(resolver.resolveClassName(sdk.name ?? "sdk"), resolver.resolveFile({
+			if (sdk.mode === "flat") return renderClassFile(resolver.className(sdk.name ?? "sdk"), resolver.file({
 				name: sdk.name ?? "sdk",
-				extname: ".ts"
-			}, {
+				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__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx_jsx_runtime.Fragment, { children: classFiles });
-			const sdkFile = resolver.resolveFile({
+			const sdkFile = resolver.file({
 				name: sdk.name,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
 			});
-			const facadeName = resolver.resolveClassName(sdk.name);
+			const facadeName = resolver.className(sdk.name);
 			const members = controllers.map(({ name, tag }) => ({
 				className: name,
-				propName: resolver.resolveClientPropertyName(tag ?? name)
+				propName: resolver.propertyName(tag ?? name)
 			}));
 			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [classFiles, /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File, {
 				baseName: sdkFile.baseName,
@@ -1262,38 +1317,27 @@ const defaultMacros = [kubb_kit.ast.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.
+* Default resolver shared by the client plugins. Functions and files inherit the built-in camelCase
+* `name` and `file`; classes and tag groups use PascalCase.
 *
 * @example
 * ```ts
-* resolverClient.resolveName('show pet by id') // 'showPetById'
-* resolverClient.resolveGroupName('pet')       // 'PetClient'
+* resolverClient.name('show pet by id')  // 'showPetById'
+* resolverClient.groupName('pet')        // 'PetClient'
 * ```
 */
-const resolverClient = (0, kubb_kit.defineResolver)(() => ({
-	name: "default",
+const resolverClient = (0, kubb_kit.createResolver)({
 	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) {
+	className(name) {
 		return ensureValidVarName(pascalCase(name));
 	},
-	resolveGroupName(name) {
+	groupName(name) {
 		return ensureValidVarName(pascalCase(`${name} Client`));
 	},
-	resolveClientPropertyName(name) {
+	propertyName(name) {
 		return ensureValidVarName(camelCase(name));
 	}
-}));
+});
 //#endregion
 //#region src/generators/clientGenerator.tsx
 /**
@@ -1314,25 +1358,28 @@ const clientGenerator = (0, kubb_kit.defineGenerator)({
 		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.resolveRequestConfigName(node), tsResolver.resolveResponsesName(node)];
+		const importedTypeNames = [tsResolver.response.options(node), tsResolver.response.responses(node)];
 		const importedZodNames = zodResolver ? [
-			resolveResponseValidator(validator) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
+			resolveResponseValidator(validator) === "zod" ? zodResolver.response.response?.(node) : null,
 			resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
-			resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.resolveDataName?.(node) : null
+			resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body?.(node) : null
 		].filter((name) => Boolean(name)) : [];
 		const meta = {
-			name: resolver.resolveName(node.operationId),
-			file: resolver.resolveFile(operationFileEntry(node, node.operationId), {
+			name: resolver.name(node.operationId),
+			file: resolver.file({
+				...operationFileEntry(node, node.operationId),
 				root,
 				output,
 				group: group ?? void 0
 			}),
-			fileTs: tsResolver.resolveFile(operationFileEntry(node, node.operationId), {
+			fileTs: tsResolver.file({
+				...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), {
+			fileZod: zodResolver && pluginZod?.options ? zodResolver.file({
+				...operationFileEntry(node, node.operationId),
 				root,
 				output: pluginZod.options.output ?? output,
 				group: pluginZod.options?.group ?? void 0
@@ -1349,7 +1396,7 @@ const clientGenerator = (0, kubb_kit.defineGenerator)({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1357,7 +1404,7 @@ const clientGenerator = (0, kubb_kit.defineGenerator)({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1461,10 +1508,7 @@ const pluginFetch = (0, kubb_kit.definePlugin)((options) => {
 			mode: sdk.mode ?? "tag",
 			name: sdk.name
 		} : void 0,
-		resolver: userResolver ? {
-			...resolverClient,
-			...userResolver
-		} : resolverClient
+		resolver: userResolver ? kubb_kit.Resolver.merge(resolverClient, userResolver) : resolverClient
 	};
 	const selectedGenerators = resolved.sdk ? [createSdkGenerator()] : [clientGenerator];
 	return {