@kubb/plugin-faker 5.0.0-beta.81 → 5.0.0-beta.85

package/dist/index.cjs

@@ -2,36 +2,382 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+//#endregion
+let node_path = require("node:path");
+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");
+//#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);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ new Set([
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[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}`;
+}
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/strings.ts
+/**
+* Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping
+* any backslash or single quote in the content.
+*
+* @example
+* ```ts
+* singleQuote('foo')      // "'foo'"
+* singleQuote("o'clock")  // "'o\\'clock'"
+* ```
+*/
+function singleQuote(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+/**
+* Strips a single matching pair of `"..."`, `'...'`, or `` `...` `` from both ends of `text`.
+* Returns the string unchanged when no balanced quote pair is found.
+*
+* @example
+* ```ts
+* trimQuotes('"hello"') // 'hello'
+* trimQuotes('hello')   // 'hello'
+* ```
+*/
+function trimQuotes(text) {
+	if (text.length >= 2) {
+		const first = text[0];
+		const last = text[text.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'" || first === "`" && last === "`") return text.slice(1, -1);
 	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+	return text;
+}
+/**
+* Serializes a primitive to a single-quoted string literal, stripping any surrounding quotes first.
+*
+* Escaping runs through `JSON.stringify`, then the result switches to single quotes so the generated
+* code matches the repo style without a formatter.
+*
+* @example
+* ```ts
+* stringify('hello')   // "'hello'"
+* stringify('"hello"') // "'hello'"
+* ```
+*/
+function stringify(value) {
+	if (value === void 0 || value === null) return "''";
+	return `'${JSON.stringify(trimQuotes(value.toString())).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+}
+/**
+* Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,
+* and the Unicode line terminators U+2028 and U+2029.
+*
+* @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+*
+* @example
+* ```ts
+* jsStringEscape('say "hi"\nbye') // 'say \\"hi\\"\\nbye'
+* ```
+*/
+function jsStringEscape(input) {
+	return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
+		switch (character) {
+			case "\"":
+			case "'":
+			case "\\": return `\\${character}`;
+			case "\n": return "\\n";
+			case "\r": return "\\r";
+			case "\u2028": return "\\u2028";
+			case "\u2029": return "\\u2029";
+			default: return "";
+		}
+	});
+}
+/**
+* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
+* Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.
+* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
+*
+* @example
+* ```ts
+* toRegExpString('^(?im)foo')       // 'new RegExp("^foo", "im")'
+* toRegExpString('^(?im)foo', null) // '/^foo/im'
+* ```
+*/
+function toRegExpString(text, func = "RegExp") {
+	const raw = trimQuotes(text);
+	const match = raw.match(/^\^(\(\?([igmsuy]+)\))/i);
+	const replacementTarget = match?.[1] ?? "";
+	const matchedFlags = match?.[2];
+	const cleaned = raw.replace(/^\\?\//, "").replace(/\\?\/$/, "").replace(replacementTarget, "");
+	const { source, flags } = new RegExp(cleaned, matchedFlags);
+	if (func === null) return `/${source}/${flags}`;
+	return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ""})`;
+}
+//#endregion
+//#region ../../internals/utils/src/codegen.ts
+const INDENT = "  ";
+/**
+* Indents every non-empty line of `text` by one indent level, leaving blank lines empty.
+*/
+function indentLines(text) {
+	if (!text) return "";
+	return text.split("\n").map((line) => line.trim() ? `${INDENT}${line}` : "").join("\n");
+}
+/**
+* Renders an object key, quoting it with single quotes only when it is not a valid identifier.
+* Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.
+*
+* @example
+* ```ts
+* objectKey('name')    // 'name'
+* objectKey('x-total') // "'x-total'"
+* ```
+*/
+function objectKey(name) {
+	return isIdentifier(name) ? name : singleQuote(name);
+}
+/**
+* Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one
+* level and closing the brace at column zero. Entries that are themselves multi-line objects indent
+* cumulatively. Each entry ends with a trailing comma to match the formatter's multi-line style.
+*
+* @example
+* ```ts
+* buildObject(['id: z.number()', 'name: z.string()'])
+* // '{\n  id: z.number(),\n  name: z.string(),\n}'
+* ```
+*/
+function buildObject(entries) {
+	if (entries.length === 0) return "{}";
+	return `{\n${entries.map((entry) => `${indentLines(entry)},`).join("\n")}\n}`;
+}
+//#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/imports.ts
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getImportNames(entry) {
+	return (Array.isArray(entry.name) ? entry.name : [entry.name]).map((name) => {
+		if (typeof name === "string") return name;
+		return name.name ?? name.propertyName;
+	}).filter((name) => Boolean(name));
+}
+function filterUsedImports(imports, text, skipImportNames = []) {
+	const skip = new Set(skipImportNames);
+	return imports.filter((entry) => {
+		return getImportNames(entry).some((name) => {
+			if (skip.has(name)) return false;
+			return new RegExp(`\\b${escapeRegExp(name)}\\b(?=\\s*\\()`).test(text);
+		});
+	});
+}
+function aliasConflictingImports(imports, reservedNames) {
+	const reservedNameSet = new Set(reservedNames);
+	const aliases = /* @__PURE__ */ new Map();
+	return {
+		imports: imports.map((entry) => {
+			const aliasedNames = (Array.isArray(entry.name) ? entry.name : [entry.name]).map((item) => {
+				if (typeof item !== "string" || !reservedNameSet.has(item)) return item;
+				const alias = `${item}Schema`;
+				aliases.set(item, alias);
+				return {
+					propertyName: item,
+					name: alias
+				};
+			});
+			return aliasedNames.some((item) => typeof item === "object" && item.name) ? {
+				...entry,
+				name: aliasedNames
+			} : entry;
+		}),
+		aliases
+	};
+}
+function rewriteAliasedImports(text, aliases) {
+	return Array.from(aliases).reduce((acc, [name, alias]) => acc.replace(new RegExp(`\\b${escapeRegExp(name)}\\b`, "g"), alias), text);
+}
 //#endregion
-let _kubb_ast_utils = require("@kubb/ast/utils");
-let _kubb_plugin_ts = require("@kubb/plugin-ts");
-let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
-let node_path = require("node:path");
-node_path = __toESM(node_path, 1);
-let _kubb_core = require("@kubb/core");
-let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
-let node_crypto = require("node:crypto");
 //#region src/utils.ts
 /**
 * Returns the `@faker-js/faker` named export for a locale code.
@@ -80,17 +426,6 @@ function canOverrideSchema(node) {
 		"blob"
 	])).has(node.type);
 }
-/**
-* Resolves a parameter name based on its location (path, query, header, etc.) using the provided resolver.
-*/
-function resolveParamNameByLocation(resolver, node, param) {
-	switch (param.in) {
-		case "path": return resolver.resolvePathParamsName(node, param);
-		case "query": return resolver.resolveQueryParamsName(node, param);
-		case "header": return resolver.resolveHeaderParamsName(node, param);
-		default: return resolver.resolveParamName(node, param);
-	}
-}
 function shouldInlineSingleResponseSchema(schema) {
 	return (/* @__PURE__ */ new Set([
 		"any",
@@ -125,16 +460,16 @@ function buildResponseUnionSchema(node, resolver) {
 	if (responses.length === 1) {
 		const schema = responses[0].content?.[0]?.schema;
 		if (schema && shouldInlineSingleResponseSchema(schema)) return schema;
-		return _kubb_core.ast.factory.createSchema({
+		return kubb_kit.ast.factory.createSchema({
 			type: "ref",
-			name: resolver.resolveResponseStatusName(node, responses[0].statusCode)
+			name: resolver.response.status(node, responses[0].statusCode)
 		});
 	}
-	return _kubb_core.ast.factory.createSchema({
+	return kubb_kit.ast.factory.createSchema({
 		type: "union",
-		members: responses.map((response) => _kubb_core.ast.factory.createSchema({
+		members: responses.map((response) => kubb_kit.ast.factory.createSchema({
 			type: "ref",
-			name: resolver.resolveResponseStatusName(node, response.statusCode)
+			name: resolver.response.status(node, response.statusCode)
 		}))
 	});
 }
@@ -255,24 +590,24 @@ function Faker({ node, description, name, typeName, printer, seed, canOverride }
 		const paramsSignature = declarationPrinter.print(params) ?? "";
 		const returnType = resolvedReturnType;
 		const returnExpression = node.type === "ref" && canOverride && returnType ? `${fakerTextWithOverride} as ${returnType}` : fakerTextWithOverride;
-		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
+		return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 			name,
 			isExportable: true,
 			isIndexable: true,
-			children: /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.Function, {
+			children: /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.Function, {
 				export: true,
 				name,
-				JSDoc: { comments: description ? [`@description ${(0, _kubb_ast_utils.jsStringEscape)(description)}`] : [] },
+				JSDoc: { comments: description ? [`@description ${jsStringEscape(description)}`] : [] },
 				params: canOverride ? paramsSignature : void 0,
 				returnType: returnType ?? void 0,
-				children: [seed ? /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [`faker.seed(${JSON.stringify(seed)})`, /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)("br", {})] }) : void 0, `return ${returnExpression}`]
+				children: [seed ? /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [`faker.seed(${JSON.stringify(seed)})`, /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)("br", {})] }) : void 0, `return ${returnExpression}`]
 			})
 		});
 	}
-	const functionSignature = `${description ? `/**\n   * @description ${(0, _kubb_ast_utils.jsStringEscape)(description)}\n   */\n  ` : ""}export function ${name}<TData extends Partial<${typeName}> = object>(data?: TData)`;
+	const functionSignature = `${description ? `/**\n   * @description ${jsStringEscape(description)}\n   */\n  ` : ""}export function ${name}<TData extends Partial<${typeName}> = object>(data?: TData)`;
 	const seedCode = seed ? `faker.seed(${JSON.stringify(seed)})\n  ` : "";
 	const { cyclicSchemas, schemaName } = printer.options;
-	const functionBody = node.type === "object" && !!cyclicSchemas && (node.properties ?? []).some((p) => (0, _kubb_ast_utils.containsCircularRef)(p.schema, {
+	const functionBody = node.type === "object" && !!cyclicSchemas && (node.properties ?? []).some((p) => kubb_kit.ast.containsCircularRef(p.schema, {
 		circularSchemas: cyclicSchemas,
 		excludeName: schemaName
 	})) ? `{
@@ -290,7 +625,7 @@ function Faker({ node, description, name, typeName, printer, seed, canOverride }
     ...(data || {}),
   } as Omit<typeof defaultFakeData, keyof TData> & TData
 }`;
-	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File.Source, {
+	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx.File.Source, {
 		name,
 		isExportable: true,
 		isIndexable: true,
@@ -298,226 +633,6 @@ function Faker({ node, description, name, typeName, printer, seed, canOverride }
 	});
 }
 //#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);
-}
-//#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/imports.ts
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function getImportNames(entry) {
-	return (Array.isArray(entry.name) ? entry.name : [entry.name]).map((name) => {
-		if (typeof name === "string") return name;
-		return name.name ?? name.propertyName;
-	}).filter((name) => Boolean(name));
-}
-function filterUsedImports(imports, text, skipImportNames = []) {
-	const skip = new Set(skipImportNames);
-	return imports.filter((entry) => {
-		return getImportNames(entry).some((name) => {
-			if (skip.has(name)) return false;
-			return new RegExp(`\\b${escapeRegExp(name)}\\b(?=\\s*\\()`).test(text);
-		});
-	});
-}
-function aliasConflictingImports(imports, reservedNames) {
-	const reservedNameSet = new Set(reservedNames);
-	const aliases = /* @__PURE__ */ new Map();
-	return {
-		imports: imports.map((entry) => {
-			const aliasedNames = (Array.isArray(entry.name) ? entry.name : [entry.name]).map((item) => {
-				if (typeof item !== "string" || !reservedNameSet.has(item)) return item;
-				const alias = `${item}Schema`;
-				aliases.set(item, alias);
-				return {
-					propertyName: item,
-					name: alias
-				};
-			});
-			return aliasedNames.some((item) => typeof item === "object" && item.name) ? {
-				...entry,
-				name: aliasedNames
-			} : entry;
-		}),
-		aliases
-	};
-}
-function rewriteAliasedImports(text, aliases) {
-	return Array.from(aliases).reduce((acc, [name, alias]) => acc.replace(new RegExp(`\\b${escapeRegExp(name)}\\b`, "g"), alias), text);
-}
-//#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = /* @__PURE__ */ new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[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/shared/src/params.ts
 const caseParamsCache = /* @__PURE__ */ new WeakMap();
 /**
@@ -538,6 +653,23 @@ function caseParams(params, casing) {
 	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;
+	});
+}
 //#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
@@ -588,6 +720,15 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
+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"))
+	};
+}
 //#endregion
 //#region ../../internals/shared/src/group.ts
 /**
@@ -682,7 +823,7 @@ const fakerKeywordMapper = {
 		return `{...${items.join(", ...")}}`;
 	},
 	matches: (value = "", regexGenerator = "faker") => {
-		if (regexGenerator === "randexp") return `${(0, _kubb_ast_utils.toRegExpString)(value, "RandExp")}.gen()`;
+		if (regexGenerator === "randexp") return `${toRegExpString(value, "RandExp")}.gen()`;
 		return `faker.helpers.fromRegExp("${value}")`;
 	},
 	email: () => "faker.internet.email()",
@@ -693,15 +834,15 @@ function getEnumValues(node) {
 	return node.enumValues ?? [];
 }
 function parseEnumValue(value) {
-	if (typeof value === "string") return (0, _kubb_ast_utils.stringify)(value);
+	if (typeof value === "string") return stringify(value);
 	return value;
 }
 /**
 * Reads the discriminator literal off a variant, or `undefined` when it can't be determined.
 */
 function getDiscriminatorValue(member, discriminatorPropertyName) {
-	const prop = _kubb_core.ast.narrowSchema(member, "object")?.properties?.find((p) => p.name === discriminatorPropertyName);
-	const enumNode = prop ? _kubb_core.ast.narrowSchema(prop.schema, "enum") : null;
+	const prop = kubb_kit.ast.narrowSchema(member, "object")?.properties?.find((p) => p.name === discriminatorPropertyName);
+	const enumNode = prop ? kubb_kit.ast.narrowSchema(prop.schema, "enum") : null;
 	return enumNode ? getEnumValues(enumNode)[0] : void 0;
 }
 /**
@@ -718,7 +859,7 @@ function indexedTypeName(typeName, propertyName, nestedInUnion) {
 * Creates a Faker printer that generates mock data generation code from schema nodes.
 * Handles circular references gracefully by emitting memoizing getters for cyclic properties.
 */
-const printerFaker = _kubb_core.ast.createPrinter((options) => {
+const printerFaker = kubb_kit.ast.createPrinter((options) => {
 	const printNested = (node, overrideOptions = {}) => {
 		return printerFaker({
 			...options,
@@ -758,10 +899,10 @@ const printerFaker = _kubb_core.ast.createPrinter((options) => {
 				return fakerKeywordMapper.time(node.representation ?? "string", this.options.dateParser);
 			},
 			ref(node) {
-				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? (0, _kubb_ast_utils.extractRefName)(node.ref) ?? node.name ?? node.schema?.name : node.name ?? node.schema?.name;
+				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? kubb_kit.ast.extractRefName(node.ref) ?? node.name ?? node.schema?.name : node.name ?? node.schema?.name;
 				if (!refName) throw new Error("Name not defined for ref node");
 				if (this.options.schemaName && refName === this.options.schemaName) return this.options.typeName ? `undefined as unknown as ${this.options.typeName}` : "undefined as unknown";
-				const resolvedName = node.ref ? this.options.resolver.resolveName(refName) : refName;
+				const resolvedName = node.ref ? this.options.resolver.name(refName) : refName;
 				if (!this.options.nestedInObject) return `${resolvedName}(data)`;
 				return `${resolvedName}()`;
 			},
@@ -771,7 +912,7 @@ const printerFaker = _kubb_core.ast.createPrinter((options) => {
 			union(node) {
 				const { discriminatorPropertyName } = node;
 				const baseTypeName = this.options.typeName;
-				const items = (0, _kubb_ast_utils.mapSchemaMembers)(node, (member) => {
+				const items = kubb_kit.ast.mapSchemaMembers(node, (member) => {
 					const value = discriminatorPropertyName ? getDiscriminatorValue(member, discriminatorPropertyName) : void 0;
 					if (baseTypeName && value !== void 0) return printNested(member, {
 						typeName: `Extract<NonNullable<${baseTypeName}>, { ${JSON.stringify(discriminatorPropertyName)}: ${parseEnumValue(value)} }>`,
@@ -786,11 +927,11 @@ const printerFaker = _kubb_core.ast.createPrinter((options) => {
 				return fakerKeywordMapper.union(items);
 			},
 			intersection(node) {
-				const items = (0, _kubb_ast_utils.mapSchemaMembers)(node, (member) => printNested(member, { nestedInObject: true })).map(({ output }) => output).filter((item) => Boolean(item) && item !== "undefined");
+				const items = kubb_kit.ast.mapSchemaMembers(node, (member) => printNested(member, { nestedInObject: true })).map(({ output }) => output).filter((item) => Boolean(item) && item !== "undefined");
 				return fakerKeywordMapper.and(items);
 			},
 			array(node) {
-				const items = (0, _kubb_ast_utils.mapSchemaItems)(node, (member) => printNested(member, {
+				const items = kubb_kit.ast.mapSchemaItems(node, (member) => printNested(member, {
 					typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[number]` : void 0,
 					nestedInObject: true
 				})).map(({ output }) => output).filter((item) => Boolean(item));
@@ -805,16 +946,16 @@ const printerFaker = _kubb_core.ast.createPrinter((options) => {
 			},
 			object(node) {
 				const cyclicSchemas = this.options.cyclicSchemas;
-				return (0, _kubb_ast_utils.buildObject)((node.properties ?? []).map((property) => {
+				return buildObject((node.properties ?? []).map((property) => {
 					const value = printNested(property.schema, {
 						typeName: this.options.typeName ? indexedTypeName(this.options.typeName, property.name, this.options.nestedInUnion) : void 0,
 						nestedInObject: true
 					}) ?? "undefined";
-					if (cyclicSchemas && (0, _kubb_ast_utils.containsCircularRef)(property.schema, {
+					if (cyclicSchemas && kubb_kit.ast.containsCircularRef(property.schema, {
 						circularSchemas: cyclicSchemas,
 						excludeName: this.options.schemaName
-					})) return `get ${(0, _kubb_ast_utils.objectKey)(property.name)}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`;
-					return `${(0, _kubb_ast_utils.objectKey)(property.name)}: ${value}`;
+					})) return `get ${objectKey(property.name)}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`;
+					return `${objectKey(property.name)}: ${value}`;
 				}));
 			},
 			...options.nodes
@@ -832,9 +973,9 @@ const printerFaker = _kubb_core.ast.createPrinter((options) => {
 * factory returns a value matching the corresponding TypeScript type from
 * `@kubb/plugin-ts`.
 */
-const fakerGenerator = (0, _kubb_core.defineGenerator)({
+const fakerGenerator = (0, kubb_kit.defineGenerator)({
 	name: "faker",
-	renderer: _kubb_renderer_jsx.jsxRenderer,
+	renderer: kubb_jsx.jsxRenderer,
 	schema(node, ctx) {
 		const { adapter, config, resolver, root } = ctx;
 		const { output, group, dateParser, regexGenerator, seed, locale, printer } = ctx.options;
@@ -842,25 +983,23 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 		if (!node.name || !pluginTs) return;
 		const tsResolver = ctx.driver.getResolver(_kubb_plugin_ts.pluginTsName);
 		const schemaName = node.name;
-		const isEnumSchema = !!_kubb_core.ast.narrowSchema(node, _kubb_core.ast.schemaTypes.enum);
+		const isEnumSchema = !!kubb_kit.ast.narrowSchema(node, kubb_kit.ast.schemaTypes.enum);
 		const tsEnumType = pluginTs.options?.enum?.type;
 		const tsEnumTypeSuffix = pluginTs.options?.enum?.typeSuffix ?? "Key";
-		const schemaTypeName = isEnumSchema && tsEnumType === "asConst" ? tsResolver.resolveEnumKeyName({ name: schemaName }, tsEnumTypeSuffix) : tsResolver.resolveTypeName(schemaName);
+		const schemaTypeName = isEnumSchema && tsEnumType === "asConst" ? tsResolver.enum.keyName({ name: schemaName }, tsEnumTypeSuffix) : tsResolver.name(schemaName);
 		const meta = {
-			name: resolver.resolveName(schemaName),
-			file: resolver.resolveFile({
+			name: resolver.name(schemaName),
+			file: resolver.file({
 				name: schemaName,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
 			}),
 			typeName: schemaTypeName,
-			typeFile: tsResolver.resolveFile({
+			typeFile: tsResolver.file({
 				name: schemaName,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output: pluginTs.options?.output ?? output,
 				group: pluginTs.options?.group ?? void 0
@@ -888,21 +1027,20 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			typeFilePath: meta.typeFile.path
 		});
 		const usedImports = filterUsedImports(adapter.getImports(node, (schemaName) => ({
-			name: resolver.resolveName(schemaName),
-			path: resolver.resolveFile({
+			name: resolver.name(schemaName),
+			path: resolver.file({
 				name: schemaName,
-				extname: ".ts"
-			}, {
+				extname: ".ts",
 				root,
 				output,
 				group: group ?? void 0
 			}).path
 		})), fakerText);
-		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
+		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.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -910,7 +1048,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -919,28 +1057,28 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				}
 			}),
 			children: [
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: locale ? [{
 						propertyName: localeToFakerImport(locale),
 						name: "faker"
 					}] : ["faker"],
 					path: "@faker-js/faker"
 				}),
-				regexGenerator === "randexp" && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				regexGenerator === "randexp" && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: "RandExp",
 					path: "randexp"
 				}),
-				dateParser !== "faker" && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				dateParser !== "faker" && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					path: dateParser,
 					name: dateParser
 				}),
-				typeReference.importPath && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				typeReference.importPath && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					isTypeOnly: true,
 					root: meta.file.path,
 					path: typeReference.importPath,
 					name: [meta.typeName]
 				}),
-				usedImports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				usedImports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
@@ -949,7 +1087,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 					imp.path,
 					imp.name
 				].join("-"))),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Faker, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Faker, {
 					name: meta.name,
 					typeName: typeReference.typeName,
 					description: node.description,
@@ -967,10 +1105,31 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 		const pluginTs = ctx.driver.getPlugin(_kubb_plugin_ts.pluginTsName);
 		if (!pluginTs) return;
 		const tsResolver = ctx.driver.getResolver(_kubb_plugin_ts.pluginTsName);
-		const paramEntries = caseParams(node.parameters, "camelcase").map((param) => ({
-			param,
-			name: resolveParamNameByLocation(resolver, node, param),
-			typeName: resolveParamNameByLocation(tsResolver, node, param)
+		const params = caseParams(node.parameters, "camelcase");
+		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters({
+			...node,
+			parameters: params
+		}, { paramsCasing: "original" });
+		const paramGroups = [
+			{
+				params: pathParams,
+				name: resolver.param.path,
+				typeName: tsResolver.param.path
+			},
+			{
+				params: queryParams,
+				name: resolver.param.query,
+				typeName: tsResolver.param.query
+			},
+			{
+				params: headerParams,
+				name: resolver.param.headers,
+				typeName: tsResolver.param.headers
+			}
+		].filter((group) => group.params.length > 0).map((group) => ({
+			schema: (0, _kubb_plugin_ts.buildParams)({ params: group.params }),
+			name: group.name(node, group.params[0]),
+			typeName: group.typeName(node, group.params[0])
 		}));
 		function expandContentUnits(entries, baseName, tsBaseName, description, decorate) {
 			const withSchema = entries.filter((entry) => entry.schema);
@@ -986,9 +1145,9 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				}];
 			}
 			const variants = resolveContentTypeVariants(entries, baseName);
-			const unionSchema = _kubb_core.ast.factory.createSchema({
+			const unionSchema = kubb_kit.ast.factory.createSchema({
 				type: "union",
-				members: variants.map((variant) => _kubb_core.ast.factory.createSchema({
+				members: variants.map((variant) => kubb_kit.ast.factory.createSchema({
 					type: "ref",
 					name: variant.name
 				}))
@@ -1007,36 +1166,34 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				skipImportNames: variants.map((variant) => variant.name)
 			}];
 		}
-		const responseUnits = node.responses.flatMap((response) => expandContentUnits(response.content ?? [], resolver.resolveResponseStatusName(node, response.statusCode), tsResolver.resolveResponseStatusName(node, response.statusCode), response.description));
-		const dataUnits = expandContentUnits(node.requestBody?.content ?? [], resolver.resolveDataName(node), tsResolver.resolveDataName(node), node.requestBody?.description, (schema) => ({
+		const responseUnits = node.responses.flatMap((response) => expandContentUnits(response.content ?? [], resolver.response.status(node, response.statusCode), tsResolver.response.status(node, response.statusCode), response.description));
+		const dataUnits = expandContentUnits(node.requestBody?.content ?? [], resolver.response.body(node), tsResolver.response.body(node), node.requestBody?.description, (schema) => ({
 			...schema,
 			description: node.requestBody?.description ?? schema.description
 		}));
-		const responseName = resolver.resolveResponseName(node);
+		const responseName = resolver.response.response(node);
 		const localHelperNames = /* @__PURE__ */ new Set([
-			...paramEntries.map((entry) => entry.name),
+			...paramGroups.map((group) => group.name),
 			...responseUnits.map((unit) => unit.name),
 			...dataUnits.map((unit) => unit.name),
 			responseName
 		]);
 		const cyclicSchemas = new Set(ctx.meta.circularNames);
 		const meta = {
-			file: resolver.resolveFile({
+			file: resolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output,
 				group: group ?? void 0
 			}),
-			typeFile: tsResolver.resolveFile({
+			typeFile: tsResolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output: pluginTs.options?.output ?? output,
 				group: pluginTs.options?.group ?? void 0
@@ -1044,11 +1201,10 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 		};
 		function resolveMockImports(schema) {
 			return adapter.getImports(schema, (schemaName) => ({
-				name: resolver.resolveName(schemaName),
-				path: resolver.resolveFile({
+				name: resolver.name(schemaName),
+				path: resolver.file({
 					name: schemaName,
-					extname: ".ts"
-				}, {
+					extname: ".ts",
 					root,
 					output,
 					group: group ?? void 0
@@ -1079,14 +1235,14 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				filePath: meta.file.path,
 				typeFilePath: meta.typeFile.path
 			});
-			return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
-				typeReference.importPath && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+			return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsxs)(kubb_jsx_jsx_runtime.Fragment, { children: [
+				typeReference.importPath && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					isTypeOnly: true,
 					root: meta.file.path,
 					path: typeReference.importPath,
 					name: [typeName]
 				}),
-				imports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				imports.map((imp) => /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
@@ -1095,7 +1251,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 					imp.path,
 					imp.name
 				].join("-"))),
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(Faker, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Faker, {
 					name,
 					typeName: typeReference.typeName,
 					description,
@@ -1109,11 +1265,11 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				})
 			] });
 		}
-		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
+		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.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1121,7 +1277,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1130,26 +1286,22 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				}
 			}),
 			children: [
-				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: locale ? [{
 						propertyName: localeToFakerImport(locale),
 						name: "faker"
 					}] : ["faker"],
 					path: "@faker-js/faker"
 				}),
-				regexGenerator === "randexp" && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				regexGenerator === "randexp" && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					name: "RandExp",
 					path: "randexp"
 				}),
-				dateParser !== "faker" && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				dateParser !== "faker" && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
 					path: dateParser,
 					name: dateParser
 				}),
-				paramEntries.map(({ param, name, typeName }) => renderEntry({
-					schema: param.schema,
-					name,
-					typeName
-				})),
+				paramGroups.map((group) => renderEntry(group)),
 				responseUnits.map((unit) => renderEntry({
 					schema: unit.schema,
 					name: unit.name,
@@ -1167,7 +1319,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				renderEntry({
 					schema: buildResponseUnionSchema(node, resolver),
 					name: responseName,
-					typeName: tsResolver.resolveResponseName(node),
+					typeName: tsResolver.response.response(node),
 					skipImportNames: responseUnits.map((unit) => unit.name)
 				})
 			]
@@ -1185,69 +1337,45 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 * ```ts
 * import { resolverFaker } from '@kubb/plugin-faker'
 *
-* resolverFaker.default('list pets', 'function') // 'createListPets'
+* resolverFaker.name('list pets') // 'createListPets'
 * ```
 */
-const resolverFaker = (0, _kubb_core.defineResolver)(() => {
-	return {
-		name: "default",
-		pluginName: "plugin-faker",
-		default(name, type) {
-			if (type === "file") return toFilePath(name, (part) => camelCase(part, { prefix: "create" }));
-			return ensureValidVarName(camelCase(name, { prefix: "create" }));
-		},
-		resolveName(name, type) {
-			return this.default(name, type);
-		},
-		resolvePathName(name, type) {
-			return this.default(name, type);
-		},
-		resolveFile({ name, extname, tag, path: groupPath }, context) {
-			const inputBaseName = `${context.output.mode === "file" ? "" : this.resolveName(name, "file")}${extname}`;
-			const filePath = this.resolvePath({
-				baseName: inputBaseName,
-				tag,
-				path: groupPath
-			}, context);
-			const baseName = node_path.default.basename(filePath);
-			return {
-				kind: "File",
-				id: (0, node_crypto.createHash)("sha256").update(filePath).digest("hex"),
-				name: node_path.default.basename(filePath, extname),
-				path: filePath,
-				baseName,
-				extname,
-				meta: { pluginName: this.pluginName },
-				sources: [],
-				imports: [],
-				exports: []
-			};
-		},
-		resolveParamName(node, param) {
-			return this.resolveName(`${node.operationId} ${param.in} ${param.name}`);
-		},
-		resolveDataName(node) {
-			return this.resolveName(`${node.operationId} Data`);
+const resolverFaker = (0, kubb_kit.createResolver)({
+	pluginName: "plugin-faker",
+	name(name) {
+		return ensureValidVarName(camelCase(name, { prefix: "create" }));
+	},
+	file: { baseName({ name, extname }) {
+		return `${toFilePath(name, (part) => camelCase(part, { prefix: "create" }))}${extname}`;
+	} },
+	param: {
+		name(node, param) {
+			return this.name(`${node.operationId} ${param.in} ${param.name}`);
 		},
-		resolveResponseStatusName(node, statusCode) {
-			return this.resolveName(`${node.operationId} Status ${statusCode}`);
+		path(node) {
+			return this.name(`${node.operationId} Path`);
 		},
-		resolveResponseName(node) {
-			return this.resolveName(`${node.operationId} Response`);
+		query(node) {
+			return this.name(`${node.operationId} Query`);
 		},
-		resolveResponsesName(node) {
-			return this.resolveName(`${node.operationId} Responses`);
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	},
+	response: {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
 		},
-		resolvePathParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		body(node) {
+			return this.name(`${node.operationId} Body`);
 		},
-		resolveQueryParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		response(node) {
+			return this.name(`${node.operationId} Response`);
 		},
-		resolveHeaderParamsName(node, param) {
-			return this.resolveParamName(node, param);
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
 		}
-	};
+	}
 });
 //#endregion
 //#region src/plugin.ts
@@ -1263,7 +1391,7 @@ const pluginFakerName = "plugin-faker";
 *
 * @example
 * ```ts
-* import { defineConfig } from 'kubb'
+* import { defineConfig } from 'kubb/config'
 * import { pluginTs } from '@kubb/plugin-ts'
 * import { pluginFaker } from '@kubb/plugin-faker'
 *
@@ -1280,7 +1408,7 @@ const pluginFakerName = "plugin-faker";
 * })
 * ```
 */
-const pluginFaker = (0, _kubb_core.definePlugin)((options) => {
+const pluginFaker = (0, kubb_kit.definePlugin)((options) => {
 	const { output = {
 		path: "mocks",
 		barrel: { type: "named" }
@@ -1303,10 +1431,7 @@ const pluginFaker = (0, _kubb_core.definePlugin)((options) => {
 				regexGenerator,
 				printer
 			});
-			ctx.setResolver(userResolver ? {
-				...resolverFaker,
-				...userResolver
-			} : resolverFaker);
+			ctx.setResolver(userResolver ? kubb_kit.Resolver.merge(resolverFaker, userResolver) : resolverFaker);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(fakerGenerator);
 		} }