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

package/dist/index.js

@@ -1,10 +1,379 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { ast, defineGenerator, definePlugin, defineResolver } from "kubb/kit";
-import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { posix } from "node:path";
+import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
+import { buildParams, createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, jsxRenderer } from "kubb/jsx";
-import path, { posix } from "node:path";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
-import { createHash } from "node:crypto";
+//#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 isIdentifier(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 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
 //#region src/utils.ts
 /**
 * Returns the `@faker-js/faker` named export for a locale code.
@@ -53,17 +422,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",
@@ -100,14 +458,14 @@ function buildResponseUnionSchema(node, resolver) {
 		if (schema && shouldInlineSingleResponseSchema(schema)) return schema;
 		return ast.factory.createSchema({
 			type: "ref",
-			name: resolver.resolveResponseStatusName(node, responses[0].statusCode)
+			name: resolver.response.status(node, responses[0].statusCode)
 		});
 	}
 	return ast.factory.createSchema({
 		type: "union",
 		members: responses.map((response) => ast.factory.createSchema({
 			type: "ref",
-			name: resolver.resolveResponseStatusName(node, response.statusCode)
+			name: resolver.response.status(node, response.statusCode)
 		}))
 	});
 }
@@ -126,7 +484,6 @@ const SCALAR_TYPES$1 = /* @__PURE__ */ new Set([
 	"blob",
 	"enum"
 ]);
-const ARRAY_TYPES$1 = /* @__PURE__ */ new Set(["array"]);
 function toRelativeImportPath(from, to) {
 	const relativePath = posix.relative(posix.dirname(from), to);
 	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
@@ -171,7 +528,7 @@ function getScalarType(node, typeName) {
 * Determines the data type, return type, and whether it uses the type name.
 */
 function resolveFakerTypeUsage(node, typeName, canOverride) {
-	const isArray = ARRAY_TYPES$1.has(node.type);
+	const isArray = node.type === "array";
 	const isTuple = node.type === "tuple";
 	const isScalar = SCALAR_TYPES$1.has(node.type);
 	let dataType = `Partial<${typeName}>`;
@@ -188,7 +545,6 @@ function resolveFakerTypeUsage(node, typeName, canOverride) {
 //#endregion
 //#region src/components/Faker.tsx
 const OBJECT_TYPES = /* @__PURE__ */ new Set(["object", "intersection"]);
-const ARRAY_TYPES = /* @__PURE__ */ new Set(["array"]);
 const SCALAR_TYPES = /* @__PURE__ */ new Set([
 	"string",
 	"email",
@@ -207,7 +563,7 @@ const SCALAR_TYPES = /* @__PURE__ */ new Set([
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 function Faker({ node, description, name, typeName, printer, seed, canOverride }) {
 	const fakerText = printer.print(node) ?? "undefined";
-	const isArray = ARRAY_TYPES.has(node.type);
+	const isArray = node.type === "array";
 	const isObject = OBJECT_TYPES.has(node.type);
 	const isTuple = node.type === "tuple";
 	const isScalar = SCALAR_TYPES.has(node.type);
@@ -235,14 +591,14 @@ function Faker({ node, description, name, typeName, printer, seed, canOverride }
 			children: /* @__PURE__ */ jsxs(Function, {
 				export: true,
 				name,
-				JSDoc: { comments: description ? [`@description ${ast.jsStringEscape(description)}`] : [] },
+				JSDoc: { comments: description ? [`@description ${jsStringEscape(description)}`] : [] },
 				params: canOverride ? paramsSignature : void 0,
 				returnType: returnType ?? void 0,
 				children: [seed ? /* @__PURE__ */ jsxs(Fragment, { children: [`faker.seed(${JSON.stringify(seed)})`, /* @__PURE__ */ jsx("br", {})] }) : void 0, `return ${returnExpression}`]
 			})
 		});
 	}
-	const functionSignature = `${description ? `/**\n   * @description ${ast.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) => ast.containsCircularRef(p.schema, {
@@ -271,226 +627,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();
 /**
@@ -511,6 +647,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
 /**
@@ -561,6 +714,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
 /**
@@ -655,7 +817,7 @@ const fakerKeywordMapper = {
 		return `{...${items.join(", ...")}}`;
 	},
 	matches: (value = "", regexGenerator = "faker") => {
-		if (regexGenerator === "randexp") return `${ast.toRegExpString(value, "RandExp")}.gen()`;
+		if (regexGenerator === "randexp") return `${toRegExpString(value, "RandExp")}.gen()`;
 		return `faker.helpers.fromRegExp("${value}")`;
 	},
 	email: () => "faker.internet.email()",
@@ -666,7 +828,7 @@ function getEnumValues(node) {
 	return node.enumValues ?? [];
 }
 function parseEnumValue(value) {
-	if (typeof value === "string") return ast.stringify(value);
+	if (typeof value === "string") return stringify(value);
 	return value;
 }
 /**
@@ -734,7 +896,7 @@ const printerFaker = ast.createPrinter((options) => {
 				const refName = node.ref ? this.options.nameMapping?.get(node.ref) ?? 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}()`;
 			},
@@ -778,7 +940,7 @@ const printerFaker = ast.createPrinter((options) => {
 			},
 			object(node) {
 				const cyclicSchemas = this.options.cyclicSchemas;
-				const entries = (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
@@ -786,10 +948,9 @@ const printerFaker = ast.createPrinter((options) => {
 					if (cyclicSchemas && ast.containsCircularRef(property.schema, {
 						circularSchemas: cyclicSchemas,
 						excludeName: this.options.schemaName
-					})) return `get ${ast.objectKey(property.name)}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`;
-					return `${ast.objectKey(property.name)}: ${value}`;
-				});
-				return ast.buildObject(entries);
+					})) 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
 		},
@@ -819,22 +980,20 @@ const fakerGenerator = defineGenerator({
 		const isEnumSchema = !!ast.narrowSchema(node, 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
@@ -862,11 +1021,10 @@ const fakerGenerator = 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
@@ -876,7 +1034,7 @@ const fakerGenerator = 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: {
@@ -884,7 +1042,7 @@ const fakerGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -941,10 +1099,31 @@ const fakerGenerator = defineGenerator({
 		const pluginTs = ctx.driver.getPlugin(pluginTsName);
 		if (!pluginTs) return;
 		const tsResolver = ctx.driver.getResolver(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: 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);
@@ -981,36 +1160,34 @@ const fakerGenerator = 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
@@ -1018,11 +1195,10 @@ const fakerGenerator = 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
@@ -1087,7 +1263,7 @@ const fakerGenerator = 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: {
@@ -1095,7 +1271,7 @@ const fakerGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1119,11 +1295,7 @@ const fakerGenerator = defineGenerator({
 					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,
@@ -1141,7 +1313,7 @@ const fakerGenerator = defineGenerator({
 				renderEntry({
 					schema: buildResponseUnionSchema(node, resolver),
 					name: responseName,
-					typeName: tsResolver.resolveResponseName(node),
+					typeName: tsResolver.response.response(node),
 					skipImportNames: responseUnits.map((unit) => unit.name)
 				})
 			]
@@ -1159,69 +1331,45 @@ const fakerGenerator = defineGenerator({
 * ```ts
 * import { resolverFaker } from '@kubb/plugin-faker'
 *
-* resolverFaker.default('list pets', 'function') // 'createListPets'
+* resolverFaker.name('list pets') // 'createListPets'
 * ```
 */
-const resolverFaker = 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 = path.basename(filePath);
-			return {
-				kind: "File",
-				id: createHash("sha256").update(filePath).digest("hex"),
-				name: path.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 = 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
@@ -1277,10 +1425,7 @@ const pluginFaker = definePlugin((options) => {
 				regexGenerator,
 				printer
 			});
-			ctx.setResolver(userResolver ? {
-				...resolverFaker,
-				...userResolver
-			} : resolverFaker);
+			ctx.setResolver(userResolver ? Resolver.merge(resolverFaker, userResolver) : resolverFaker);
 			if (userMacros?.length) ctx.setMacros(userMacros);
 			ctx.addGenerator(fakerGenerator);
 		} }