@kubb/plugin-faker 5.0.0-beta.64 → 5.0.0-beta.74

package/dist/fakerGenerator-D5Bcy5WY.js

@@ -1,659 +0,0 @@
-import "./chunk-C0LytTxp.js";
-import { a as resolveParamNameByLocation, i as localeToFakerImport, n as buildResponseUnionSchema, o as resolveTypeReference, r as canOverrideSchema, t as Faker } from "./Faker-DUx7jvCo.js";
-import { buildObject, caseParams, containsCircularRef, extractRefName, mapSchemaItems, mapSchemaMembers, objectKey, stringify, toRegExpString } from "@kubb/ast/utils";
-import { ast, defineGenerator } from "@kubb/core";
-import { pluginTsName } from "@kubb/plugin-ts";
-import { File, jsxRenderer } from "@kubb/renderer-jsx";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-//#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/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
-		};
-	});
-}
-//#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 = "any") => `faker.helpers.arrayElement<${type}>([${items.join(", ")}])`,
-	union: (items = []) => `faker.helpers.arrayElement<any>([${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.definePrinter((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 = node.ref ? 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 "undefined as any";
-				const resolvedName = node.ref ? this.options.resolver.resolveName(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) return printNested(member, {
-						typeName: `Extract<NonNullable<${baseTypeName}>, { ${JSON.stringify(discriminatorPropertyName)}: ${parseEnumValue(value)} }>`,
-						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));
-				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) => {
-					if (this.options.mapper && Object.hasOwn(this.options.mapper, property.name)) return `${objectKey(property.name)}: ${this.options.mapper[property.name]}`;
-					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 { adapter, config, resolver, root } = ctx;
-		const { output, group, dateParser, regexGenerator, mapper, 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.resolveEnumKeyName({ name: schemaName }, tsEnumTypeSuffix) : tsResolver.resolveTypeName(schemaName);
-		const meta = {
-			name: resolver.resolveName(schemaName),
-			file: resolver.resolveFile({
-				name: schemaName,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group: group ?? void 0
-			}),
-			typeName: schemaTypeName,
-			typeFile: tsResolver.resolveFile({
-				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,
-			mapper,
-			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(adapter.getImports(node, (schemaName) => ({
-			name: resolver.resolveName(schemaName),
-			path: resolver.resolveFile({
-				name: schemaName,
-				extname: ".ts"
-			}, {
-				root,
-				output,
-				group: group ?? void 0
-			}).path
-		})), fakerText);
-		return /* @__PURE__ */ jsxs(File, {
-			baseName: meta.file.baseName,
-			path: meta.file.path,
-			meta: meta.file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
-			footer: resolver.resolveFooter(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 { adapter, config, resolver, root } = ctx;
-		const { output, group, paramsCasing, dateParser, regexGenerator, mapper, seed, locale, printer } = ctx.options;
-		const pluginTs = ctx.driver.getPlugin(pluginTsName);
-		if (!pluginTs) return;
-		const tsResolver = ctx.driver.getResolver(pluginTsName);
-		const paramEntries = caseParams(node.parameters, paramsCasing).map((param) => ({
-			param,
-			name: resolveParamNameByLocation(resolver, node, param),
-			typeName: resolveParamNameByLocation(tsResolver, node, param)
-		}));
-		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.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) => ({
-			...schema,
-			description: node.requestBody?.description ?? schema.description
-		}));
-		const responseName = resolver.resolveResponseName(node);
-		const localHelperNames = new Set([
-			...paramEntries.map((entry) => entry.name),
-			...responseUnits.map((unit) => unit.name),
-			...dataUnits.map((unit) => unit.name),
-			responseName
-		]);
-		const cyclicSchemas = new Set(ctx.meta.circularNames);
-		const meta = {
-			file: resolver.resolveFile({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
-				root,
-				output,
-				group: group ?? void 0
-			}),
-			typeFile: tsResolver.resolveFile({
-				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 adapter.getImports(schema, (schemaName) => ({
-				name: resolver.resolveName(schemaName),
-				path: resolver.resolveFile({
-					name: schemaName,
-					extname: ".ts"
-				}, {
-					root,
-					output,
-					group: group ?? void 0
-				}).path
-			})).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,
-				mapper,
-				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.resolveBanner(ctx.meta, {
-				output,
-				config,
-				file: {
-					path: meta.file.path,
-					baseName: meta.file.baseName
-				}
-			}),
-			footer: resolver.resolveFooter(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
-				}),
-				paramEntries.map(({ param, name, typeName }) => renderEntry({
-					schema: param.schema,
-					name,
-					typeName
-				})),
-				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.resolveResponseName(node),
-					skipImportNames: responseUnits.map((unit) => unit.name)
-				})
-			]
-		});
-	}
-});
-//#endregion
-export { printerFaker as n, fakerGenerator as t };
-
-//# sourceMappingURL=fakerGenerator-D5Bcy5WY.js.map