@kubb/plugin-faker 5.1.5 → 5.1.7

package/dist/index.js

@@ -1,9 +1,9 @@
 import "./rolldown-runtime-C0LytTxp.js";
 import { posix } from "node:path";
-import { Resolver, addGenerator, ast, containsCircularRef, createResolver, defineExtension, defineGenerator, setMacros, setResolver } from "kubb/kit";
-import { buildParams, createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { Diagnostics, Resolver, addGenerator, assertPluginOption, ast, containsCircularRef, createResolver, defineExtension, defineGenerator, setMacros, setResolver } from "kubb/kit";
 import { File, Function, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+import { buildParams, enumTypeName, pluginTsName } from "@kubb/plugin-ts";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -305,6 +305,24 @@ function buildObject(entries) {
 }
 //#endregion
 //#region ../../internals/utils/src/fs.ts
+function toSlash(p) {
+	if (p.startsWith("\\\\?\\")) return p;
+	return p.replaceAll("\\", "/");
+}
+/**
+* Returns the relative path from `rootDir` to `filePath`, always using forward slashes
+* and prefixed with `./` when not already traversing upward.
+*
+* @example
+* ```ts
+* getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'
+* getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'
+* ```
+*/
+function getRelativePath(rootDir, filePath) {
+	const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath));
+	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
+}
 /**
 * 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
@@ -329,51 +347,6 @@ function toFilePath(name, caseLast = camelCase) {
 	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.
@@ -397,54 +370,36 @@ function localeToFakerImport(locale) {
 	return `faker${parts.join("_")}`;
 }
 /**
+* Schema types a factory cannot override with `data`: they print a constant or have no faker value.
+*/
+const NON_OVERRIDABLE_TYPES = /* @__PURE__ */ new Set([
+	"any",
+	"unknown",
+	"void",
+	"null",
+	"never",
+	"ipv4",
+	"ipv6"
+]);
+/**
+* Schema types a single response cannot inline: they reference or compose other schemas.
+*/
+const NON_INLINABLE_RESPONSE_TYPES = /* @__PURE__ */ new Set([
+	"object",
+	"intersection",
+	"ref",
+	"never",
+	"ipv4",
+	"ipv6"
+]);
+/**
 * 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);
+	return !NON_OVERRIDABLE_TYPES.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);
+	return !NON_INLINABLE_RESPONSE_TYPES.has(schema.type);
 }
 /**
 * Builds a response schema as a union of all response statuses.
@@ -473,7 +428,7 @@ function buildResponseUnionSchema(node, resolver) {
 		})
 	});
 }
-const SCALAR_TYPES$1 = /* @__PURE__ */ new Set([
+const SCALAR_TYPES = /* @__PURE__ */ new Set([
 	"string",
 	"email",
 	"url",
@@ -488,10 +443,6 @@ const SCALAR_TYPES$1 = /* @__PURE__ */ new Set([
 	"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.
@@ -499,7 +450,7 @@ function toRelativeImportPath(from, to) {
 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}` };
+	if (name === typeName) return { typeName: `import('${getRelativePath(posix.dirname(filePath), typeFilePath)}').${typeName}` };
 	return {
 		importPath: typeFilePath,
 		typeName
@@ -523,28 +474,17 @@ function getScalarType(node, typeName) {
 		case "time": return node.representation === "date" ? "Date" : "string";
 		case "datetime": return "string";
 		case "blob": return "Blob";
-		case "enum": return typeName;
 		default: return typeName;
 	}
 }
 /**
-* A nullable scalar inlines its primitive instead of naming the generated type, so the
-* nullability the type plugin emitted has to be reapplied here. Non-scalars keep `typeName`,
-* which already carries it.
-*/
-function withNullability(type, node) {
-	return node.nullable ? `${type} | null` : type;
-}
-/**
 * 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 isScalar = SCALAR_TYPES$1.has(node.type);
-	let dataType = `Partial<${typeName}>`;
-	if (isScalar) dataType = withNullability(getScalarType(node, typeName), node);
-	let returnType = canOverride ? typeName : null;
-	if (isScalar) returnType = withNullability(getScalarType(node, typeName), node);
+	const scalarType = SCALAR_TYPES.has(node.type) ? `${getScalarType(node, typeName)}${node.nullable ? " | null" : ""}` : void 0;
+	const dataType = scalarType ?? `Partial<${typeName}>`;
+	const returnType = scalarType ?? (canOverride ? typeName : null);
 	return {
 		dataType,
 		returnType,
@@ -554,22 +494,6 @@ function resolveFakerTypeUsage(node, typeName, canOverride) {
 //#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, canOverride, typeMode = "inferred" }) {
 	const fakerText = printer.print(node) ?? "undefined";
 	const isArray = node.type === "array";
@@ -586,13 +510,7 @@ function Faker({ node, description, name, typeName, printer, canOverride, typeMo
 	})();
 	const { dataType, returnType: resolvedReturnType } = resolveFakerTypeUsage(node, typeName, canOverride);
 	if (!useObjectOverride) {
-		const dataParamName = /\bdata\b/.test(fakerTextWithOverride) ? "data" : "_data";
-		const params = createFunctionParameters({ params: [createFunctionParameter({
-			name: dataParamName,
-			type: dataType,
-			optional: true
-		})] });
-		const paramsSignature = declarationPrinter.print(params) ?? "";
+		const paramsSignature = `${/\bdata\b/.test(fakerTextWithOverride) ? "data" : "_data"}?: ${dataType}`;
 		const returnType = resolvedReturnType;
 		const returnExpression = canOverride && !!returnType && (node.type === "ref" || isArray || isTuple || isUnion) ? `${isTuple || isUnion ? `(${fakerTextWithOverride})` : fakerTextWithOverride} as ${returnType}` : fakerTextWithOverride;
 		return /* @__PURE__ */ jsx(File.Source, {
@@ -641,24 +559,6 @@ return {
 	});
 }
 //#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
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -757,11 +657,19 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
+	const group = (location) => {
+		const seen = /* @__PURE__ */ new Set();
+		return node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		});
+	};
 	const groups = {
-		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"))
+		path: group("path"),
+		query: group("query"),
+		header: group("header"),
+		cookie: group("cookie")
 	};
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
@@ -842,20 +750,6 @@ function createCasedFile(caseLast) {
 	} };
 }
 //#endregion
-//#region ../../internals/shared/src/refs.ts
-/**
-* Collects the resolved target name of every pointer-carrying ref in a schema tree, in
-* first-occurrence order. Use this for name-only checks (e.g. redeclaration detection) where
-* `resolver.imports` would resolve file paths that are then discarded.
-*/
-function collectRefNames(schema) {
-	return ast.collectSync(schema, { schema: (node) => {
-		const refNode = ast.narrowSchema(node, "ref");
-		if (!refNode?.ref) return null;
-		return ast.resolveRefName(refNode);
-	} });
-}
-//#endregion
 //#region ../../internals/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -909,6 +803,51 @@ function mapSchemaItems(node, transform) {
 	}));
 }
 //#endregion
+//#region src/utils/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/printers/printerFaker.ts
 /**
 * Formats that put a whole number inside a `type: 'string'` schema, the way ProtoJSON encodes
@@ -922,77 +861,32 @@ const integerFormats = /* @__PURE__ */ new Set([
 	"uint64"
 ]);
 const maxInt32 = 2147483647;
-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()",
-	integerString: (format) => {
-		if (format === "int32") return `faker.number.int({ max: ${maxInt32} }).toString()`;
-		return "faker.number.bigInt().toString()";
-	},
-	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"
-};
+/**
+* `faker.number.float()` or `faker.number.int()`, with `min` and `max` passed only when set.
+*/
+function numberCall(kind, min, max) {
+	const args = [min !== void 0 && `min: ${min}`, max !== void 0 && `max: ${max}`].filter(Boolean).join(", ");
+	return `faker.number.${kind}(${args ? `{ ${args} }` : ""})`;
+}
+/**
+* A `date` or `time` value: an ISO substring, a `dateParser` call, or a `Date` when `representation` is `'date'`.
+*/
+function dateTimeCall(representation, { format, substring }, parser = "faker", schemaName) {
+	if (representation === "string") return parser !== "faker" ? `${parser}(faker.date.anytime()).format("${format}")` : `faker.date.anytime().toISOString().substring(${substring})`;
+	if (parser !== "faker") throw new Diagnostics.Error({
+		code: Diagnostics.code.invalidPluginOptions,
+		severity: "error",
+		message: `Option \`dateParser: '${parser}'\` cannot format the adapter's \`dateType: 'date'\` values${schemaName ? ` in schema "${schemaName}"` : ""}.`,
+		help: "Set adapterOas({ dateType: 'string' }) or remove `dateParser`.",
+		location: { kind: "config" },
+		plugin: "plugin-faker"
+	});
+	return "faker.date.anytime()";
+}
+function matches(value, regexGenerator = "faker") {
+	if (regexGenerator === "randexp") return `${toRegExpString(value, "RandExp")}.gen()`;
+	return `faker.helpers.fromRegExp(${toRegExpString(value, null)})`;
+}
 function parseEnumValue(value) {
 	if (typeof value === "string") return stringify(value);
 	return value;
@@ -1038,49 +932,60 @@ const printerFaker = ast.createPrinter((options) => {
 		name: "faker",
 		options,
 		nodes: {
-			any: () => fakerKeywordMapper.any(),
-			unknown: () => fakerKeywordMapper.unknown(),
-			void: () => fakerKeywordMapper.void(),
-			boolean: () => fakerKeywordMapper.boolean(),
-			null: () => fakerKeywordMapper.null(),
+			any: () => "undefined",
+			unknown: () => "undefined",
+			void: () => "undefined",
+			boolean: () => "faker.datatype.boolean()",
+			null: () => "null",
 			string(node) {
-				if (node.pattern) return fakerKeywordMapper.matches(node.pattern, this.options.regexGenerator);
-				if (node.format && integerFormats.has(node.format)) return fakerKeywordMapper.integerString(node.format);
-				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);
+				if (node.pattern) return matches(node.pattern, this.options.regexGenerator);
+				if (node.format && integerFormats.has(node.format)) return node.format === "int32" ? `faker.number.int({ max: ${maxInt32} }).toString()` : "faker.number.bigInt().toString()";
+				const { min, max } = node;
+				if (min !== void 0 && max !== void 0) return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`;
+				if (max !== void 0 || min !== void 0) return `faker.string.alpha({ length: ${max ?? min} })`;
+				return "faker.string.alpha()";
 			},
-			integer(node) {
-				return fakerKeywordMapper.integer(node.min, node.max);
-			},
-			bigint: () => fakerKeywordMapper.bigint(),
-			blob: () => fakerKeywordMapper.blob(),
-			datetime: () => fakerKeywordMapper.datetime(),
+			email: () => "faker.internet.email()",
+			url: () => "faker.internet.url()",
+			uuid: () => "faker.string.uuid()",
+			number: (node) => numberCall("float", node.min, node.max),
+			integer: (node) => numberCall("int", node.min, node.max),
+			bigint: () => "faker.number.bigInt()",
+			blob: () => "faker.image.url() as unknown as Blob",
+			datetime: () => "faker.date.anytime().toISOString()",
 			date(node) {
-				return fakerKeywordMapper.date(node.representation ?? "string", this.options.dateParser);
+				return dateTimeCall(node.representation ?? "string", {
+					format: "YYYY-MM-DD",
+					substring: "0, 10"
+				}, this.options.dateParser, this.options.schemaName);
 			},
 			time(node) {
-				return fakerKeywordMapper.time(node.representation ?? "string", this.options.dateParser);
+				return dateTimeCall(node.representation ?? "string", {
+					format: "HH:mm:ss",
+					substring: "11, 19"
+				}, this.options.dateParser, this.options.schemaName);
 			},
 			ref(node) {
 				const refName = ast.resolveRefName(node);
-				if (!refName) throw new Error("Name not defined for ref node");
+				if (!refName) throw new Diagnostics.Error({
+					code: Diagnostics.code.pluginFailed,
+					severity: "error",
+					message: `Ref node "${node.ref ?? node.name ?? "unknown"}"${this.options.schemaName ? ` in schema "${this.options.schemaName}"` : ""} has no name.`,
+					plugin: "plugin-faker"
+				});
 				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(ast.getSchemaLiteralValues(node).map(parseEnumValue), this.options.typeName);
+				const { typeName } = this.options;
+				return `faker.helpers.arrayElement${typeName ? `<${typeName}>` : ""}([${ast.getSchemaLiteralValues(node).map(parseEnumValue).join(", ")}])`;
 			},
 			union(node) {
 				const { discriminatorPropertyName } = node;
 				const baseTypeName = this.options.typeName;
-				const items = mapSchemaMembers(node, (member) => {
+				return `faker.helpers.arrayElement([${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)} }>`;
@@ -1095,26 +1000,31 @@ const printerFaker = ast.createPrinter((options) => {
 						nestedInObject: true,
 						nestedInUnion: true
 					});
-				}).map(({ output }) => output).filter((item) => Boolean(item));
-				return fakerKeywordMapper.union(items);
+				}).map(({ output }) => output).filter((item) => Boolean(item)).join(", ")}])`;
 			},
 			intersection(node) {
 				const items = mapSchemaMembers(node, (member) => printNested(member, { nestedInObject: true })).map(({ output }) => output).filter((item) => Boolean(item) && item !== "undefined");
-				return fakerKeywordMapper.and(items);
+				if (items.length === 0) return "{}";
+				return items.length === 1 ? items[0] : `{...${items.join(", ...")}}`;
 			},
 			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);
+				if (items.length > 1) return `faker.helpers.arrayElements([${items.join(", ")}])`;
+				const { min, max } = node;
+				const item = items[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(node) {
-				const items = (node.items ?? []).map((member, index) => printNested(member, {
+				return `[${(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);
+				})).filter((item) => Boolean(item)).join(", ")}]`;
 			},
 			object(node) {
 				const cyclicSchemas = this.options.cyclicSchemas;
@@ -1131,10 +1041,7 @@ const printerFaker = ast.createPrinter((options) => {
 				}));
 			}
 		},
-		overrides: options.nodes,
-		print(node) {
-			return this.transform(node) ?? null;
-		}
+		overrides: options.nodes
 	};
 });
 //#endregion
@@ -1156,9 +1063,12 @@ const fakerGenerator = defineGenerator({
 		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 schemaTypeName = enumTypeName({
+			resolver: tsResolver,
+			name: schemaName,
+			enumOptions: pluginTs.options?.enum,
+			isEnum: isEnumSchema
+		});
 		const meta = {
 			name: resolver.name(schemaName),
 			file: resolver.file({
@@ -1339,7 +1249,7 @@ const fakerGenerator = defineGenerator({
 			description: node.requestBody?.description ?? schema.description
 		}));
 		const responseName = resolver.response.response(node);
-		const hasResponseNameCollision = new Set(node.responses.flatMap((response) => (response.content ?? []).flatMap((entry) => entry.schema ? collectRefNames(entry.schema).map((name) => resolver.name(name)) : []))).has(responseName);
+		const hasResponseNameCollision = new Set(node.responses.flatMap((response) => (response.content ?? []).flatMap((entry) => entry.schema ? ast.collectImportedRefNames(entry.schema).map((name) => resolver.name(name)) : []))).has(responseName);
 		const localHelperNames = /* @__PURE__ */ new Set([
 			...paramGroups.map((group) => group.name),
 			...responseUnits.map((unit) => unit.name),
@@ -1468,20 +1378,8 @@ const fakerGenerator = defineGenerator({
 					children: `faker.seed(${JSON.stringify(seed)})`
 				}) : void 0,
 				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
-				})),
+				responseUnits.map((unit) => renderEntry(unit)),
+				dataUnits.map((unit) => renderEntry(unit)),
 				!hasResponseNameCollision && renderEntry({
 					schema: buildResponseUnionSchema(node, resolver),
 					name: responseName,
@@ -1500,7 +1398,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.1.5";
+var version = "5.1.7";
 //#endregion
 //#region src/resolvers/resolverFaker.ts
 /**
@@ -1568,6 +1466,18 @@ const pluginFaker = defineExtension({
 			path: "mocks",
 			barrel: { type: "named" }
 		}, seed, locale = "en", group, exclude = [], include, override = [], typeMode = "inferred", dateParser = "faker", regexGenerator = "faker", printer, resolver: userResolver, macros: userMacros } = options;
+		assertPluginOption({
+			plugin: pluginFakerName,
+			option: "typeMode",
+			value: typeMode,
+			allowed: ["inferred", "schema"]
+		});
+		assertPluginOption({
+			plugin: pluginFakerName,
+			option: "regexGenerator",
+			value: regexGenerator,
+			allowed: ["faker", "randexp"]
+		});
 		setResolver(userResolver ? Resolver.merge(resolverFaker, userResolver) : resolverFaker);
 		if (userMacros?.length) setMacros(userMacros);
 		addGenerator(fakerGenerator);