@kubb/plugin-faker 5.0.0-alpha.9 → 5.0.0-beta.100

package/dist/index.js

@@ -1,9 +1,9 @@
-import "./chunk--u3MIqq1.js";
-import { t as fakerGenerator } from "./fakerGenerator-M5oCrPmy.js";
-import path from "node:path";
-import { createPlugin, getBarrelFiles, getMode } from "@kubb/core";
-import { OperationGenerator, SchemaGenerator, pluginOasName } from "@kubb/plugin-oas";
-import { pluginTsName } from "@kubb/plugin-ts";
+import "./rolldown-runtime-C0LytTxp.js";
+import { posix } from "node:path";
+import { Resolver, ast, containsCircularRef, createResolver, defineGenerator, definePlugin } from "kubb/kit";
+import { buildParams, createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { File, Function, jsxRenderer } from "kubb/jsx";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -15,127 +15,1460 @@ import { pluginTsName } from "@kubb/plugin-ts";
 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;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
 /**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+* 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
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+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.
+*
+* Without a locale, returns `'faker'` for the default English instance.
+* With a locale, the language code is converted to upper case and joined with any region suffix.
+*
+* @example Default
+* `localeToFakerImport() // 'faker'`
+*
+* @example Simple locale
+* `localeToFakerImport('de') // 'fakerDE'`
+*
+* @example Compound locale
+* `localeToFakerImport('de_AT') // 'fakerDE_AT'`
+*/
+function localeToFakerImport(locale) {
+	if (!locale) return "faker";
+	const parts = locale.split("_");
+	parts[0] = parts[0].toUpperCase();
+	return `faker${parts.join("_")}`;
+}
+/**
+* Determines if a schema node can be overridden during faker generation.
+*/
+function canOverrideSchema(node) {
+	return (/* @__PURE__ */ new Set([
+		"array",
+		"tuple",
+		"object",
+		"intersection",
+		"union",
+		"enum",
+		"ref",
+		"string",
+		"email",
+		"url",
+		"uuid",
+		"number",
+		"integer",
+		"bigint",
+		"boolean",
+		"date",
+		"time",
+		"datetime",
+		"blob"
+	])).has(node.type);
+}
+function shouldInlineSingleResponseSchema(schema) {
+	return (/* @__PURE__ */ new Set([
+		"any",
+		"unknown",
+		"void",
+		"null",
+		"array",
+		"tuple",
+		"string",
+		"email",
+		"url",
+		"uuid",
+		"number",
+		"integer",
+		"bigint",
+		"boolean",
+		"date",
+		"time",
+		"datetime",
+		"blob",
+		"enum",
+		"union"
+	])).has(schema.type);
+}
+/**
+* Builds a response schema as a union of all response statuses.
+* Returns null if no responses are provided, or embeds single simple responses inline.
+*/
+function buildResponseUnionSchema(node, resolver) {
+	const responses = node.responses.filter((response) => response.content?.[0]?.schema);
+	if (!responses.length) return null;
+	if (responses.length === 1) {
+		const schema = responses[0].content?.[0]?.schema;
+		if (schema && shouldInlineSingleResponseSchema(schema)) return schema;
+		return ast.factory.createSchema({
+			type: "ref",
+			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.response.status(node, response.statusCode)
+		}))
+	});
+}
+const SCALAR_TYPES$1 = /* @__PURE__ */ new Set([
+	"string",
+	"email",
+	"url",
+	"uuid",
+	"number",
+	"integer",
+	"bigint",
+	"boolean",
+	"date",
+	"time",
+	"datetime",
+	"blob",
+	"enum"
+]);
+function toRelativeImportPath(from, to) {
+	const relativePath = posix.relative(posix.dirname(from), to);
+	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
+}
+/**
+* Resolves a type reference, determining if it needs an import statement or inline type reference.
+* Takes into account whether the type can be overridden and the file paths.
+*/
+function resolveTypeReference({ node, canOverride, name, typeName, filePath, typeFilePath }) {
+	const { usesTypeName } = resolveFakerTypeUsage(node, typeName, canOverride);
+	if (!usesTypeName) return { typeName };
+	if (name === typeName) return { typeName: `import('${toRelativeImportPath(filePath, typeFilePath)}').${typeName}` };
+	return {
+		importPath: typeFilePath,
+		typeName
+	};
+}
+/**
+* Maps a schema node type to its corresponding scalar type representation.
+* Returns the type name for enums or the base type (string, number, etc.) for primitives.
+*/
+function getScalarType(node, typeName) {
+	switch (node.type) {
+		case "string":
+		case "email":
+		case "url":
+		case "uuid": return "string";
+		case "number":
+		case "integer": return "number";
+		case "bigint": return "bigint";
+		case "boolean": return "boolean";
+		case "date":
+		case "time": return node.representation === "date" ? "Date" : "string";
+		case "datetime": return "string";
+		case "blob": return "Blob";
+		case "enum": return typeName;
+		default: return typeName;
+	}
+}
+/**
+* Resolves faker type usage information for a schema.
+* Determines the data type, return type, and whether it uses the type name.
+*/
+function resolveFakerTypeUsage(node, typeName, canOverride) {
+	const isArray = node.type === "array";
+	const isTuple = node.type === "tuple";
+	const isScalar = SCALAR_TYPES$1.has(node.type);
+	let dataType = `Partial<${typeName}>`;
+	if (isArray || isTuple || node.type === "union" || node.type === "enum") dataType = typeName;
+	if (isScalar) dataType = getScalarType(node, typeName);
+	let returnType = canOverride ? typeName : null;
+	if (isScalar) returnType = getScalarType(node, typeName);
+	return {
+		dataType,
+		returnType,
+		usesTypeName: dataType.includes(typeName) || Boolean(returnType?.includes(typeName))
+	};
+}
+//#endregion
+//#region src/components/Faker.tsx
+const OBJECT_TYPES = /* @__PURE__ */ new Set(["object", "intersection"]);
+const SCALAR_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"email",
+	"url",
+	"uuid",
+	"number",
+	"integer",
+	"bigint",
+	"boolean",
+	"date",
+	"time",
+	"datetime",
+	"blob",
+	"enum"
+]);
+const declarationPrinter = functionPrinter({ mode: "declaration" });
+function Faker({ node, description, name, typeName, printer, seed, canOverride }) {
+	const fakerText = printer.print(node) ?? "undefined";
+	const isArray = node.type === "array";
+	const isObject = OBJECT_TYPES.has(node.type);
+	const isTuple = node.type === "tuple";
+	const isScalar = SCALAR_TYPES.has(node.type);
+	const useGenericOverride = canOverride && isObject;
+	const fakerTextWithOverride = (() => {
+		if (canOverride && isTuple) return `data || ${fakerText}`;
+		if (canOverride && isArray) return `[\n  ...${fakerText},\n  ...(data || [])\n]`;
+		if (canOverride && isScalar) return `data ?? ${fakerText}`;
+		return fakerText;
+	})();
+	const { dataType, returnType: resolvedReturnType } = resolveFakerTypeUsage(node, typeName, canOverride);
+	if (!useGenericOverride) {
+		const params = createFunctionParameters({ params: [createFunctionParameter({
+			name: /\bdata\b/.test(fakerTextWithOverride) ? "data" : "_data",
+			type: dataType,
+			optional: true
+		})] });
+		const paramsSignature = declarationPrinter.print(params) ?? "";
+		const returnType = resolvedReturnType;
+		const returnExpression = node.type === "ref" && canOverride && returnType ? `${fakerTextWithOverride} as ${returnType}` : fakerTextWithOverride;
+		return /* @__PURE__ */ jsx(File.Source, {
+			name,
+			isExportable: true,
+			isIndexable: true,
+			children: /* @__PURE__ */ jsxs(Function, {
+				export: true,
+				name,
+				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 ${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) => containsCircularRef(p.schema, {
+		circularSchemas: cyclicSchemas,
+		excludeName: schemaName
+	})) ? `{
+  ${seedCode}const defaultFakeData = ${fakerText}
+  if (data) {
+    for (const [key, value] of Object.entries(data)) {
+      Object.defineProperty(defaultFakeData, key, { value, configurable: true, writable: true, enumerable: true })
+    }
+  }
+  return defaultFakeData as Omit<typeof defaultFakeData, keyof TData> & TData
+}` : `{
+  ${seedCode}const defaultFakeData = ${fakerText}
+  return {
+    ...defaultFakeData,
+    ...(data || {}),
+  } as Omit<typeof defaultFakeData, keyof TData> & TData
+}`;
+	return /* @__PURE__ */ jsxs(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: [functionSignature, functionBody]
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/params.ts
+/**
+* Drops parameters that share the same name, keeping the first.
+*
+* A malformed spec can declare the same parameter name twice within one `in` location. Both would
+* resolve to the same output property, so emitting both would yield an object type with a duplicate
+* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
+* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
+*/
+function dedupeParams(params) {
+	const seen = /* @__PURE__ */ new Set();
+	return params.filter((param) => {
+		if (seen.has(param.name)) return false;
+		seen.add(param.name);
+		return true;
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Maps a content type to the PascalCase suffix used to name per-content-type variants
+* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
+*/
+function getContentTypeSuffix(contentType) {
+	const baseType = contentType.split(";")[0].trim();
+	if (baseType === "application/json") return "Json";
+	if (baseType === "multipart/form-data") return "FormData";
+	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
+	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return "Unknown";
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+*/
+function getPerContentTypeName(baseName, suffix) {
+	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
+	return baseName + suffix;
+}
+/**
+* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
+* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
+* the final (possibly counter-augmented) value, so callers can derive parallel names in another
+* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
+*/
+function resolveContentTypeVariants(entries, baseName) {
+	const usedNames = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => entry.schema).map((entry) => {
+		const baseSuffix = getContentTypeSuffix(entry.contentType);
+		let suffix = baseSuffix;
+		let name = getPerContentTypeName(baseName, suffix);
+		let counter = 2;
+		while (usedNames.has(name)) {
+			suffix = `${baseSuffix}${counter++}`;
+			name = getPerContentTypeName(baseName, suffix);
+		}
+		usedNames.add(name);
+		return {
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
+		};
+	});
+}
+function getOperationParameters(node) {
+	return {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
+		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
+		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
+		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
+	};
+}
+//#endregion
+//#region ../../internals/shared/src/resolver.ts
+/**
+* Resolves a single operation parameter name with the
+* `<operationId> <in> <name>` template.
+*
+* @example
+* `operationParamName.call(resolver, node, param) // → 'DeletePetPathPetId'`
+*/
+function operationParamName(node, param) {
+	return this.name(`${node.operationId} ${param.in} ${param.name}`);
+}
+/**
+* Builds the shared `param` namespace. Spread the result into `createResolver`
+* and override individual methods next to it when a plugin deviates.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ param: createOperationParamResolver(), ... })
+* ```
+*/
+function createOperationParamResolver() {
+	return {
+		name: operationParamName,
+		path(node) {
+			return this.name(`${node.operationId} Path`);
+		},
+		query(node) {
+			return this.name(`${node.operationId} Query`);
+		},
+		headers(node) {
+			return this.name(`${node.operationId} Headers`);
+		}
+	};
+}
+/**
+* Builds the shared `response` namespace. Spread the result into
+* `createResolver` and add plugin-specific methods (`options`, `error`) next
+* to it.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ response: { ...createOperationResponseResolver(), options(node) {...} }, ... })
+* ```
+*/
+function createOperationResponseResolver() {
+	return {
+		status(node, statusCode) {
+			return this.name(`${node.operationId} Status ${statusCode}`);
+		},
+		body(node) {
+			return this.name(`${node.operationId} Body`);
+		},
+		responses(node) {
+			return this.name(`${node.operationId} Responses`);
+		},
+		response(node) {
+			return this.name(`${node.operationId} Response`);
+		}
+	};
+}
+/**
+* Builds a resolver `file` override whose base name runs every path segment
+* through `toFilePath`, casing the final segment with `caseLast`.
+*
+* @example
+* ```ts
+* createResolver<PluginTs>({ file: createCasedFile(pascalCase), ... })
+* ```
+*/
+function createCasedFile(caseLast) {
+	return { baseName({ name, extname }) {
+		return `${toFilePath(name, caseLast)}${extname}`;
+	} };
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use the camelCased group (`pet store` → `petStore`).
+*
+* A user-provided `group.name` always wins over the default namer, so callers stay in
+* control of their output folders. Returns `null` when grouping is disabled, matching the
+* per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+*
+* @example
+* ```ts
+* createGroupConfig(group) // shared across every plugin
+* ```
+*/
+function createGroupConfig(group) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return camelCase(ctx.group);
+	};
+	return {
+		...group,
+		name: group.name ? group.name : defaultName
+	};
+}
+//#endregion
+//#region ../../internals/shared/src/schemaTraversal.ts
+/**
+* Maps each member of a union or intersection schema to its transformed output, pairing every
+* result with the original member.
+*/
+function mapSchemaMembers(node, transform) {
+	return (node.members ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+/**
+* Maps each item of an array or tuple schema to its transformed output, pairing every result with
+* the original item.
+*/
+function mapSchemaItems(node, transform) {
+	return (node.items ?? []).map((schema) => ({
+		schema,
+		output: transform(schema)
+	}));
+}
+//#endregion
+//#region src/printers/printerFaker.ts
+const fakerKeywordMapper = {
+	any: () => "undefined",
+	unknown: () => "undefined",
+	void: () => "undefined",
+	number: (min, max) => {
+		if (max !== void 0 && min !== void 0) return `faker.number.float({ min: ${min}, max: ${max} })`;
+		if (max !== void 0) return `faker.number.float({ max: ${max} })`;
+		if (min !== void 0) return `faker.number.float({ min: ${min} })`;
+		return "faker.number.float()";
+	},
+	integer: (min, max) => {
+		if (max !== void 0 && min !== void 0) return `faker.number.int({ min: ${min}, max: ${max} })`;
+		if (max !== void 0) return `faker.number.int({ max: ${max} })`;
+		if (min !== void 0) return `faker.number.int({ min: ${min} })`;
+		return "faker.number.int()";
+	},
+	bigint: () => "faker.number.bigInt()",
+	string: (min, max) => {
+		if (max !== void 0 && min !== void 0) return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`;
+		if (max !== void 0) return `faker.string.alpha({ length: ${max} })`;
+		if (min !== void 0) return `faker.string.alpha({ length: ${min} })`;
+		return "faker.string.alpha()";
+	},
+	boolean: () => "faker.datatype.boolean()",
+	null: () => "null",
+	array: (items = [], min, max) => {
+		if (items.length > 1) return `faker.helpers.arrayElements([${items.join(", ")}])`;
+		const item = items.at(0);
+		if (min !== void 0 && max !== void 0) return `faker.helpers.multiple(() => (${item}), { count: { min: ${min}, max: ${max} }})`;
+		if (min !== void 0) return `faker.helpers.multiple(() => (${item}), { count: ${min} })`;
+		if (max !== void 0) return `faker.helpers.multiple(() => (${item}), { count: { min: 0, max: ${max} }})`;
+		return `faker.helpers.multiple(() => (${item}))`;
+	},
+	tuple: (items = []) => `[${items.join(", ")}]`,
+	enum: (items = [], type) => `faker.helpers.arrayElement${type ? `<${type}>` : ""}([${items.join(", ")}])`,
+	union: (items = []) => `faker.helpers.arrayElement([${items.join(", ")}])`,
+	datetime: () => "faker.date.anytime().toISOString()",
+	date: (representation = "string", parser = "faker") => {
+		if (representation === "string") {
+			if (parser !== "faker") return `${parser}(faker.date.anytime()).format("YYYY-MM-DD")`;
+			return "faker.date.anytime().toISOString().substring(0, 10)";
+		}
+		if (parser !== "faker") throw new Error(`type '${representation}' and parser '${parser}' can not work together`);
+		return "faker.date.anytime()";
+	},
+	time: (representation = "string", parser = "faker") => {
+		if (representation === "string") {
+			if (parser !== "faker") return `${parser}(faker.date.anytime()).format("HH:mm:ss")`;
+			return "faker.date.anytime().toISOString().substring(11, 19)";
+		}
+		if (parser !== "faker") throw new Error(`type '${representation}' and parser '${parser}' can not work together`);
+		return "faker.date.anytime()";
+	},
+	uuid: () => "faker.string.uuid()",
+	url: () => "faker.internet.url()",
+	and: (items = []) => {
+		if (items.length === 0) return "{}";
+		if (items.length === 1) return items[0] ?? "{}";
+		return `{...${items.join(", ...")}}`;
+	},
+	matches: (value = "", regexGenerator = "faker") => {
+		if (regexGenerator === "randexp") return `${toRegExpString(value, "RandExp")}.gen()`;
+		return `faker.helpers.fromRegExp("${value}")`;
+	},
+	email: () => "faker.internet.email()",
+	blob: () => "faker.image.url() as unknown as Blob"
+};
+function getEnumValues(node) {
+	if (node.namedEnumValues?.length) return node.namedEnumValues.map((item) => item.value);
+	return node.enumValues ?? [];
+}
+function parseEnumValue(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 = ast.narrowSchema(member, "object")?.properties?.find((p) => p.name === discriminatorPropertyName);
+	const enumNode = prop ? ast.narrowSchema(prop.schema, "enum") : null;
+	return enumNode ? getEnumValues(enumNode)[0] : void 0;
+}
+/**
+* Type expression for an object property's value, indexed off the parent `typeName`.
+*
+* In a union (`oneOf`), a key that only some branches declare turns a plain `NonNullable<T>[K]`
+* into a TS2339 error, so union members guard the access. The breakdown is below.
+*/
+function indexedTypeName(typeName, propertyName, nestedInUnion) {
+	const key = JSON.stringify(propertyName);
+	return nestedInUnion ? `(NonNullable<${typeName}> & Record<${key}, unknown>)[${key}]` : `NonNullable<${typeName}>[${key}]`;
+}
+/**
+* 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 = ast.createPrinter((options) => {
+	const printNested = (node, overrideOptions = {}) => {
+		return printerFaker({
+			...options,
+			...overrideOptions,
+			nodes: options.nodes
+		}).print(node) ?? "undefined";
+	};
+	return {
+		name: "faker",
+		options,
+		nodes: {
+			any: () => fakerKeywordMapper.any(),
+			unknown: () => fakerKeywordMapper.unknown(),
+			void: () => fakerKeywordMapper.void(),
+			boolean: () => fakerKeywordMapper.boolean(),
+			null: () => fakerKeywordMapper.null(),
+			string(node) {
+				if (node.pattern) return fakerKeywordMapper.matches(node.pattern, this.options.regexGenerator);
+				return fakerKeywordMapper.string(node.min, node.max);
+			},
+			email: () => fakerKeywordMapper.email(),
+			url: () => fakerKeywordMapper.url(),
+			uuid: () => fakerKeywordMapper.uuid(),
+			number(node) {
+				return fakerKeywordMapper.number(node.min, node.max);
+			},
+			integer(node) {
+				return fakerKeywordMapper.integer(node.min, node.max);
+			},
+			bigint: () => fakerKeywordMapper.bigint(),
+			blob: () => fakerKeywordMapper.blob(),
+			datetime: () => fakerKeywordMapper.datetime(),
+			date(node) {
+				return fakerKeywordMapper.date(node.representation ?? "string", this.options.dateParser);
+			},
+			time(node) {
+				return fakerKeywordMapper.time(node.representation ?? "string", this.options.dateParser);
+			},
+			ref(node) {
+				const refName = ast.resolveRefName(node);
+				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.name(refName) : refName;
+				if (!this.options.nestedInObject) return `${resolvedName}(data)`;
+				return `${resolvedName}()`;
+			},
+			enum(node) {
+				return fakerKeywordMapper.enum(getEnumValues(node).map(parseEnumValue), this.options.typeName);
+			},
+			union(node) {
+				const { discriminatorPropertyName } = node;
+				const baseTypeName = this.options.typeName;
+				const items = mapSchemaMembers(node, (member) => {
+					const value = discriminatorPropertyName ? getDiscriminatorValue(member, discriminatorPropertyName) : void 0;
+					if (baseTypeName && value !== void 0) {
+						const typeName = `Extract<NonNullable<${baseTypeName}>, { ${JSON.stringify(discriminatorPropertyName)}: ${parseEnumValue(value)} }>`;
+						return printNested(member, {
+							typeName,
+							nestedInObject: true
+						});
+					}
+					return printNested(member, {
+						typeName: baseTypeName,
+						nestedInObject: true,
+						nestedInUnion: true
+					});
+				}).map(({ output }) => output).filter((item) => Boolean(item));
+				return fakerKeywordMapper.union(items);
+			},
+			intersection(node) {
+				const items = mapSchemaMembers(node, (member) => printNested(member, { nestedInObject: true })).map(({ output }) => output).filter((item) => Boolean(item) && item !== "undefined");
+				return fakerKeywordMapper.and(items);
+			},
+			array(node) {
+				const items = 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));
+				return fakerKeywordMapper.array(items, node.min, node.max);
+			},
+			tuple(node) {
+				const items = (node.items ?? []).map((member, index) => printNested(member, {
+					typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${index}]` : void 0,
+					nestedInObject: true
+				})).filter((item) => Boolean(item));
+				return fakerKeywordMapper.tuple(items);
+			},
+			object(node) {
+				const cyclicSchemas = this.options.cyclicSchemas;
+				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 && containsCircularRef(property.schema, {
+						circularSchemas: cyclicSchemas,
+						excludeName: this.options.schemaName
+					})) 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
+		},
+		print(node) {
+			return this.transform(node) ?? null;
+		}
+	};
+});
+//#endregion
+//#region src/generators/fakerGenerator.tsx
+/**
+* Built-in generator for `@kubb/plugin-faker`. Emits one `createX` factory
+* per schema in the spec plus per-operation request/response factories. Each
+* factory returns a value matching the corresponding TypeScript type from
+* `@kubb/plugin-ts`.
+*/
+const fakerGenerator = defineGenerator({
+	name: "faker",
+	renderer: jsxRenderer,
+	schema(node, ctx) {
+		const { config, resolver, root } = ctx;
+		const { output, group, dateParser, regexGenerator, seed, locale, printer } = ctx.options;
+		const pluginTs = ctx.driver.getPlugin(pluginTsName);
+		if (!node.name || !pluginTs) return;
+		const tsResolver = ctx.driver.getResolver(pluginTsName);
+		const schemaName = node.name;
+		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.enum.keyName({ name: schemaName }, tsEnumTypeSuffix) : tsResolver.name(schemaName);
+		const meta = {
+			name: resolver.name(schemaName),
+			file: resolver.file({
+				name: schemaName,
+				extname: ".ts",
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			typeName: schemaTypeName,
+			typeFile: tsResolver.file({
+				name: schemaName,
+				extname: ".ts",
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		const canOverride = canOverrideSchema(node);
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		const printerInstance = printerFaker({
+			resolver,
+			schemaName,
+			typeName: meta.typeName,
+			dateParser,
+			regexGenerator,
+			nodes: printer?.nodes,
+			cyclicSchemas
+		});
+		const fakerText = printerInstance.print(node) ?? "undefined";
+		const typeReference = resolveTypeReference({
+			node,
+			canOverride,
+			name: meta.name,
+			typeName: meta.typeName,
+			filePath: meta.file.path,
+			typeFilePath: meta.typeFile.path
+		});
+		const usedImports = filterUsedImports(resolver.imports({
+			node,
+			root,
+			output,
+			group: group ?? void 0
+		}), fakerText);
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: locale ? [{
+						propertyName: localeToFakerImport(locale),
+						name: "faker"
+					}] : ["faker"],
+					path: "@faker-js/faker"
+				}),
+				regexGenerator === "randexp" && /* @__PURE__ */ jsx(File.Import, {
+					name: "RandExp",
+					path: "randexp"
+				}),
+				dateParser !== "faker" && /* @__PURE__ */ jsx(File.Import, {
+					path: dateParser,
+					name: dateParser
+				}),
+				typeReference.importPath && /* @__PURE__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					root: meta.file.path,
+					path: typeReference.importPath,
+					name: [meta.typeName]
+				}),
+				usedImports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: meta.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [
+					schemaName,
+					imp.path,
+					imp.name
+				].join("-"))),
+				/* @__PURE__ */ jsx(Faker, {
+					name: meta.name,
+					typeName: typeReference.typeName,
+					description: node.description,
+					node,
+					printer: printerInstance,
+					seed,
+					canOverride
+				})
+			]
+		});
+	},
+	operation(node, ctx) {
+		const { config, resolver, root } = ctx;
+		const { output, group, dateParser, regexGenerator, seed, locale, printer } = ctx.options;
+		const pluginTs = ctx.driver.getPlugin(pluginTsName);
+		if (!pluginTs) return;
+		const tsResolver = ctx.driver.getResolver(pluginTsName);
+		const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+		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);
+			if (withSchema.length <= 1) {
+				const primary = withSchema[0] ?? entries[0];
+				if (!primary?.schema) return [];
+				return [{
+					schema: decorate ? decorate(primary.schema) : primary.schema,
+					name: baseName,
+					typeName: tsBaseName,
+					description,
+					skipImportNames: []
+				}];
+			}
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = ast.factory.createSchema({
+				type: "union",
+				members: variants.map((variant) => ast.factory.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return [...variants.map((variant) => ({
+				schema: decorate ? decorate(variant.schema) : variant.schema,
+				name: variant.name,
+				typeName: getPerContentTypeName(tsBaseName, variant.suffix),
+				description,
+				skipImportNames: []
+			})), {
+				schema: unionSchema,
+				name: baseName,
+				typeName: tsBaseName,
+				description,
+				skipImportNames: variants.map((variant) => variant.name)
+			}];
+		}
+		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.response.response(node);
+		const localHelperNames = /* @__PURE__ */ new Set([
+			...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.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output,
+				group: group ?? void 0
+			}),
+			typeFile: tsResolver.file({
+				name: node.operationId,
+				extname: ".ts",
+				tag: node.tags[0] ?? "default",
+				path: node.path,
+				root,
+				output: pluginTs.options?.output ?? output,
+				group: pluginTs.options?.group ?? void 0
+			})
+		};
+		function resolveMockImports(schema) {
+			return resolver.imports({
+				node: schema,
+				root,
+				output,
+				group: group ?? void 0
+			}).filter((entry) => entry.path !== meta.file.path);
+		}
+		function renderEntry({ schema, name, typeName, description, skipImportNames = [] }) {
+			if (!schema) return null;
+			const canOverride = canOverrideSchema(schema);
+			const printerInstance = printerFaker({
+				resolver,
+				schemaName: name,
+				typeName,
+				dateParser,
+				regexGenerator,
+				nodes: printer?.nodes,
+				cyclicSchemas
+			});
+			const fakerText = printerInstance.print(schema) ?? "undefined";
+			const { imports, aliases } = aliasConflictingImports(filterUsedImports(resolveMockImports(schema), fakerText, skipImportNames), localHelperNames);
+			const rewrittenFakerText = rewriteAliasedImports(fakerText, aliases);
+			const typeReference = resolveTypeReference({
+				node: schema,
+				canOverride,
+				name,
+				typeName,
+				filePath: meta.file.path,
+				typeFilePath: meta.typeFile.path
+			});
+			return /* @__PURE__ */ jsxs(Fragment, { children: [
+				typeReference.importPath && /* @__PURE__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					root: meta.file.path,
+					path: typeReference.importPath,
+					name: [typeName]
+				}),
+				imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: meta.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [
+					name,
+					imp.path,
+					imp.name
+				].join("-"))),
+				/* @__PURE__ */ jsx(Faker, {
+					name,
+					typeName: typeReference.typeName,
+					description,
+					node: schema,
+					printer: {
+						...printerInstance,
+						print: () => rewrittenFakerText
+					},
+					seed,
+					canOverride
+				})
+			] });
+		}
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: meta.file.baseName,
+			path: meta.file.path,
+			meta: meta.file.meta,
+			banner: resolver.default.banner(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			footer: resolver.default.footer(ctx.meta, {
+				output,
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: locale ? [{
+						propertyName: localeToFakerImport(locale),
+						name: "faker"
+					}] : ["faker"],
+					path: "@faker-js/faker"
+				}),
+				regexGenerator === "randexp" && /* @__PURE__ */ jsx(File.Import, {
+					name: "RandExp",
+					path: "randexp"
+				}),
+				dateParser !== "faker" && /* @__PURE__ */ jsx(File.Import, {
+					path: dateParser,
+					name: dateParser
+				}),
+				paramGroups.map((group) => renderEntry(group)),
+				responseUnits.map((unit) => renderEntry({
+					schema: unit.schema,
+					name: unit.name,
+					typeName: unit.typeName,
+					description: unit.description,
+					skipImportNames: unit.skipImportNames
+				})),
+				dataUnits.map((unit) => renderEntry({
+					schema: unit.schema,
+					name: unit.name,
+					typeName: unit.typeName,
+					description: unit.description,
+					skipImportNames: unit.skipImportNames
+				})),
+				renderEntry({
+					schema: buildResponseUnionSchema(node, resolver),
+					name: responseName,
+					typeName: tsResolver.response.response(node),
+					skipImportNames: responseUnits.map((unit) => unit.name)
+				})
+			]
+		});
+	}
+});
+//#endregion
+//#region src/resolvers/resolverFaker.ts
+/**
+* Default resolver used by `@kubb/plugin-faker`. Decides the names and file
+* paths for every generated mock factory. Functions and files are prefixed
+* with `create` so `Pet` becomes `createPet`.
+*
+* @example Resolve a factory name
+* ```ts
+* import { resolverFaker } from '@kubb/plugin-faker'
+*
+* resolverFaker.name('list pets') // 'createListPets'
+* ```
+*/
+const resolverFaker = createResolver({
+	pluginName: "plugin-faker",
+	name(name) {
+		return ensureValidVarName(camelCase(name, { prefix: "create" }));
+	},
+	file: createCasedFile((part) => camelCase(part, { prefix: "create" })),
+	param: createOperationParamResolver(),
+	response: createOperationResponseResolver()
+});
+//#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-faker`. Used for driver lookups and
+* cross-plugin dependency references.
+*/
 const pluginFakerName = "plugin-faker";
-const pluginFaker = createPlugin((options) => {
+/**
+* Generates one mock-data factory per OpenAPI schema using Faker.js. Call
+* `createPet()` to get a realistic `Pet` object. Useful for tests, Storybook,
+* and local development without a running backend.
+*
+* @example
+* ```ts
+* import { defineConfig } from 'kubb/config'
+* import { pluginTs } from '@kubb/plugin-ts'
+* import { pluginFaker } from '@kubb/plugin-faker'
+*
+* export default defineConfig({
+*   input: './petStore.yaml',
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginFaker({
+*       output: { path: './mocks' },
+*       seed: [100],
+*     }),
+*   ],
+* })
+* ```
+*/
+const pluginFaker = definePlugin((options) => {
 	const { output = {
 		path: "mocks",
-		barrelType: "named"
-	}, seed, group, exclude = [], include, override = [], transformers = {}, mapper = {}, unknownType = "any", emptySchemaType = unknownType, dateType = "string", integerType = "number", dateParser = "faker", generators = [fakerGenerator].filter(Boolean), regexGenerator = "faker", paramsCasing, contentType } = options;
+		barrel: { type: "named" }
+	}, seed, locale = "en", group, exclude = [], include, override = [], dateParser = "faker", regexGenerator = "faker", printer, resolver: userResolver, macros: userMacros } = options;
+	const groupConfig = createGroupConfig(group);
 	return {
 		name: pluginFakerName,
-		options: {
-			output,
-			transformers,
-			seed,
-			dateType,
-			integerType,
-			unknownType,
-			emptySchemaType,
-			dateParser,
-			mapper,
-			override,
-			regexGenerator,
-			paramsCasing,
-			group,
-			usedEnumNames: {}
-		},
-		pre: [pluginOasName, pluginTsName],
-		resolvePath(baseName, pathMode, options) {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
- /**
-			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
-			*/
-			return path.resolve(root, output.path);
-			if (group && (options?.group?.path || options?.group?.tag)) {
-				const groupName = group?.name ? group.name : (ctx) => {
-					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
-					return `${camelCase(ctx.group)}Controller`;
-				};
-				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
-			}
-			return path.resolve(root, output.path, baseName);
-		},
-		resolveName(name, type) {
-			const resolvedName = camelCase(name, {
-				prefix: type ? "create" : void 0,
-				isFile: type === "file"
-			});
-			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
-			return resolvedName;
-		},
-		async install() {
-			const root = path.resolve(this.config.root, this.config.output.path);
-			const mode = getMode(path.resolve(root, output.path));
-			const oas = await this.getOas();
-			const schemaFiles = await new SchemaGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
-				include: void 0,
-				override,
-				mode,
-				output: output.path
-			}).build(...generators);
-			await this.upsertFile(...schemaFiles);
-			const operationFiles = await new OperationGenerator(this.plugin.options, {
-				fabric: this.fabric,
-				oas,
-				driver: this.driver,
-				events: this.events,
-				plugin: this.plugin,
-				contentType,
+		options,
+		dependencies: [pluginTsName],
+		hooks: { "kubb:plugin:setup"(ctx) {
+			ctx.setOptions({
+				output,
+				seed,
+				locale,
 				exclude,
 				include,
 				override,
-				mode
-			}).build(...generators);
-			await this.upsertFile(...operationFiles);
-			const barrelFiles = await getBarrelFiles(this.fabric.files, {
-				type: output.barrelType ?? "named",
-				root,
-				output,
-				meta: { pluginName: this.plugin.name }
+				group: groupConfig,
+				dateParser,
+				regexGenerator,
+				printer
 			});
-			await this.upsertFile(...barrelFiles);
-		}
+			ctx.setResolver(userResolver ? Resolver.merge(resolverFaker, userResolver) : resolverFaker);
+			if (userMacros?.length) ctx.setMacros(userMacros);
+			ctx.addGenerator(fakerGenerator);
+		} }
 	};
 });
 //#endregion
-export { pluginFaker, pluginFakerName };
+export { Faker, pluginFaker as default, pluginFaker, fakerGenerator, pluginFakerName, printerFaker, resolverFaker };
 
 //# sourceMappingURL=index.js.map