@kubb/plugin-faker 5.0.0-beta.4 → 5.0.0-beta.56

package/dist/{fakerGenerator-VJEVzLjc.cjs → fakerGenerator-DrwGWYwv.cjs}

@@ -1,40 +1,102 @@
-const require_Faker = require("./Faker-BgleOzVN.cjs");
+const require_Faker = require("./Faker-CcGjn5ZM.cjs");
+let _kubb_ast_utils = require("@kubb/ast/utils");
 let _kubb_core = require("@kubb/core");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
 let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
-//#region ../../internals/utils/src/object.ts
+//#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
 /**
-* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
-*
-* @example
-* stringify('hello')   // '"hello"'
-* stringify('"hello"') // '"hello"'
+* 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 stringify(value) {
-	if (value === void 0 || value === null) return "\"\"";
-	return JSON.stringify(require_Faker.trimQuotes(value.toString()));
+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("");
 }
-//#endregion
-//#region ../../internals/utils/src/regexp.ts
 /**
-* Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.
-* Inline flags expressed as `^(?im)` prefixes are extracted and applied to the resulting expression.
-* Pass `null` as the second argument to emit a `/pattern/flags` literal instead.
-*
-* @example
-* toRegExpString('^(?im)foo')       // → 'new RegExp("foo", "im")'
-* toRegExpString('^(?im)foo', null) // → '/foo/im'
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
 */
-function toRegExpString(text, func = "RegExp") {
-	const raw = require_Faker.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)}` : ""})`;
+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
@@ -99,7 +161,7 @@ const fakerKeywordMapper = {
 		return `{...${items.join(", ...")}}`;
 	},
 	matches: (value = "", regexGenerator = "faker") => {
-		if (regexGenerator === "randexp") return `${toRegExpString(value, "RandExp")}.gen()`;
+		if (regexGenerator === "randexp") return `${(0, _kubb_ast_utils.toRegExpString)(value, "RandExp")}.gen()`;
 		return `faker.helpers.fromRegExp("${value}")`;
 	},
 	email: () => "faker.internet.email()",
@@ -110,9 +172,25 @@ function getEnumValues(node) {
 	return node.enumValues ?? [];
 }
 function parseEnumValue(value) {
-	if (typeof value === "string") return stringify(value);
+	if (typeof value === "string") return (0, _kubb_ast_utils.stringify)(value);
 	return value;
 }
+/** Reads the discriminator literal off a variant, or `undefined` when it can't be determined. */
+function getDiscriminatorValue(member, discriminatorPropertyName) {
+	const prop = _kubb_core.ast.narrowSchema(member, "object")?.properties?.find((p) => p.name === discriminatorPropertyName);
+	const enumNode = prop ? _kubb_core.ast.narrowSchema(prop.schema, "enum") : null;
+	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.
@@ -157,7 +235,7 @@ const printerFaker = _kubb_core.ast.definePrinter((options) => {
 				return fakerKeywordMapper.time(node.representation ?? "string", this.options.dateParser);
 			},
 			ref(node) {
-				const refName = node.ref ? _kubb_core.ast.extractRefName(node.ref) ?? node.name ?? node.schema?.name : node.name ?? node.schema?.name;
+				const refName = node.ref ? (0, _kubb_ast_utils.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;
@@ -168,7 +246,20 @@ const printerFaker = _kubb_core.ast.definePrinter((options) => {
 				return fakerKeywordMapper.enum(getEnumValues(node).map(parseEnumValue), this.options.typeName);
 			},
 			union(node) {
-				const items = (node.members ?? []).map((member) => printNested(member, { nestedInObject: true })).filter((item) => Boolean(item));
+				const { discriminatorPropertyName } = node;
+				const baseTypeName = this.options.typeName;
+				const items = (node.members ?? []).map((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
+					});
+				}).filter((item) => Boolean(item));
 				return fakerKeywordMapper.union(items);
 			},
 			intersection(node) {
@@ -191,18 +282,18 @@ const printerFaker = _kubb_core.ast.definePrinter((options) => {
 			},
 			object(node) {
 				const cyclicSchemas = this.options.cyclicSchemas;
-				return `{${(node.properties ?? []).map((property) => {
-					if (this.options.mapper && Object.hasOwn(this.options.mapper, property.name)) return `"${property.name}": ${this.options.mapper[property.name]}`;
+				return (0, _kubb_ast_utils.buildObject)((node.properties ?? []).map((property) => {
+					if (this.options.mapper && Object.hasOwn(this.options.mapper, property.name)) return `${(0, _kubb_ast_utils.objectKey)(property.name)}: ${this.options.mapper[property.name]}`;
 					const value = printNested(property.schema, {
-						typeName: this.options.typeName ? `NonNullable<${this.options.typeName}>[${JSON.stringify(property.name)}]` : void 0,
+						typeName: this.options.typeName ? indexedTypeName(this.options.typeName, property.name, this.options.nestedInUnion) : void 0,
 						nestedInObject: true
 					}) ?? "undefined";
 					if (cyclicSchemas && _kubb_core.ast.containsCircularRef(property.schema, {
 						circularSchemas: cyclicSchemas,
 						excludeName: this.options.schemaName
-					})) return `get ${property.name}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`;
-					return `"${property.name}": ${value}`;
-				}).join(",")}}`;
+					})) return `get ${(0, _kubb_ast_utils.objectKey)(property.name)}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`;
+					return `${(0, _kubb_ast_utils.objectKey)(property.name)}: ${value}`;
+				}));
 			},
 			...options.nodes
 		},
@@ -213,6 +304,12 @@ const printerFaker = _kubb_core.ast.definePrinter((options) => {
 });
 //#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 = (0, _kubb_core.defineGenerator)({
 	name: "faker",
 	renderer: _kubb_renderer_jsx.jsxRenderer,
@@ -220,11 +317,13 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 		const { adapter, config, resolver, root } = ctx;
 		const { output, group, dateParser, regexGenerator, mapper, seed, locale, printer } = ctx.options;
 		const pluginTs = ctx.driver.getPlugin(_kubb_plugin_ts.pluginTsName);
-		if (!node.name || !pluginTs || !adapter.inputNode) return;
+		if (!node.name || !pluginTs) return;
 		const tsResolver = ctx.driver.getResolver(_kubb_plugin_ts.pluginTsName);
-		const schemaNode = require_Faker.resolveSchemaRef(node, adapter.inputNode.schemas);
-		const schemaName = schemaNode.name ?? node.name;
-		const mode = ctx.getMode(output);
+		const schemaName = node.name;
+		const isEnumSchema = !!_kubb_core.ast.narrowSchema(node, _kubb_core.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({
@@ -233,20 +332,20 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}),
-			typeName: tsResolver.resolveTypeName(schemaName),
+			typeName: schemaTypeName,
 			typeFile: tsResolver.resolveFile({
 				name: schemaName,
 				extname: ".ts"
 			}, {
 				root,
 				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
+				group: pluginTs.options?.group ?? void 0
 			})
 		};
-		const canOverride = require_Faker.canOverrideSchema(schemaNode);
-		const cyclicSchemas = adapter.inputNode ? _kubb_core.ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
+		const canOverride = require_Faker.canOverrideSchema(node);
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
 		const printerInstance = printerFaker({
 			resolver,
 			schemaName,
@@ -257,16 +356,16 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			nodes: printer?.nodes,
 			cyclicSchemas
 		});
-		const fakerText = printerInstance.print(schemaNode) ?? "undefined";
+		const fakerText = printerInstance.print(node) ?? "undefined";
 		const typeReference = require_Faker.resolveTypeReference({
-			node: schemaNode,
+			node,
 			canOverride,
 			name: meta.name,
 			typeName: meta.typeName,
 			filePath: meta.file.path,
 			typeFilePath: meta.typeFile.path
 		});
-		const usedImports = require_Faker.filterUsedImports(adapter.getImports(schemaNode, (schemaName) => ({
+		const usedImports = filterUsedImports(adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveName(schemaName),
 			path: resolver.resolveFile({
 				name: schemaName,
@@ -274,20 +373,28 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}).path
-		})).filter((entry) => entry.path !== meta.file.path), fakerText);
+		})), fakerText);
 		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx.File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -311,7 +418,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 					path: typeReference.importPath,
 					name: [meta.typeName]
 				}),
-				mode === "split" && usedImports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
+				usedImports.map((imp) => /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
@@ -323,8 +430,8 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(require_Faker.Faker, {
 					name: meta.name,
 					typeName: typeReference.typeName,
-					description: schemaNode.description,
-					node: schemaNode,
+					description: node.description,
+					node,
 					printer: printerInstance,
 					seed,
 					canOverride
@@ -343,27 +450,54 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			name: require_Faker.resolveParamNameByLocation(resolver, node, param),
 			typeName: require_Faker.resolveParamNameByLocation(tsResolver, node, param)
 		}));
-		const responseEntries = node.responses.map((response) => ({
-			response,
-			name: resolver.resolveResponseStatusName(node, response.statusCode),
-			typeName: tsResolver.resolveResponseStatusName(node, response.statusCode)
+		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 = _kubb_core.ast.createSchema({
+				type: "union",
+				members: variants.map((variant) => _kubb_core.ast.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 dataEntry = node.requestBody?.content?.[0]?.schema ? {
-			schema: {
-				...node.requestBody.content[0].schema,
-				description: node.requestBody.description ?? node.requestBody.content[0].schema.description
-			},
-			name: resolver.resolveDataName(node),
-			typeName: tsResolver.resolveDataName(node),
-			description: node.requestBody.description ?? node.requestBody.content[0].schema.description
-		} : null;
 		const responseName = resolver.resolveResponseName(node);
 		const localHelperNames = new Set([
 			...paramEntries.map((entry) => entry.name),
-			...responseEntries.map((entry) => entry.name),
-			...dataEntry ? [dataEntry.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,
@@ -373,7 +507,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output,
-				group
+				group: group ?? void 0
 			}),
 			typeFile: tsResolver.resolveFile({
 				name: node.operationId,
@@ -383,7 +517,7 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			}, {
 				root,
 				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group
+				group: pluginTs.options?.group ?? void 0
 			})
 		};
 		function resolveMockImports(schema) {
@@ -395,14 +529,13 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				}, {
 					root,
 					output,
-					group
+					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 = require_Faker.canOverrideSchema(schema);
-			const cyclicSchemas = adapter.inputNode ? _kubb_core.ast.findCircularSchemas(adapter.inputNode.schemas) : void 0;
 			const printerInstance = printerFaker({
 				resolver,
 				schemaName: name,
@@ -414,8 +547,8 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 				cyclicSchemas
 			});
 			const fakerText = printerInstance.print(schema) ?? "undefined";
-			const { imports, aliases } = require_Faker.aliasConflictingImports(require_Faker.filterUsedImports(resolveMockImports(schema), fakerText, skipImportNames), localHelperNames);
-			const rewrittenFakerText = require_Faker.rewriteAliasedImports(fakerText, aliases);
+			const { imports, aliases } = aliasConflictingImports(filterUsedImports(resolveMockImports(schema), fakerText, skipImportNames), localHelperNames);
+			const rewrittenFakerText = rewriteAliasedImports(fakerText, aliases);
 			const typeReference = require_Faker.resolveTypeReference({
 				node: schema,
 				canOverride,
@@ -458,13 +591,21 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(adapter.inputNode, {
+			banner: resolver.resolveBanner(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
-			footer: resolver.resolveFooter(adapter.inputNode, {
+			footer: resolver.resolveFooter(ctx.meta, {
 				output,
-				config
+				config,
+				file: {
+					path: meta.file.path,
+					baseName: meta.file.baseName
+				}
 			}),
 			children: [
 				/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -487,23 +628,25 @@ const fakerGenerator = (0, _kubb_core.defineGenerator)({
 					name,
 					typeName
 				})),
-				responseEntries.map(({ response, name, typeName }) => renderEntry({
-					schema: response.schema,
-					name,
-					typeName,
-					description: response.description
+				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
 				})),
-				dataEntry ? renderEntry({
-					schema: dataEntry.schema,
-					name: dataEntry.name,
-					typeName: dataEntry.typeName,
-					description: dataEntry.description
-				}) : null,
 				renderEntry({
 					schema: require_Faker.buildResponseUnionSchema(node, resolver),
 					name: responseName,
 					typeName: tsResolver.resolveResponseName(node),
-					skipImportNames: responseEntries.map(({ name }) => name)
+					skipImportNames: responseUnits.map((unit) => unit.name)
 				})
 			]
 		});
@@ -523,4 +666,4 @@ Object.defineProperty(exports, "printerFaker", {
 	}
 });
 
-//# sourceMappingURL=fakerGenerator-VJEVzLjc.cjs.map
+//# sourceMappingURL=fakerGenerator-DrwGWYwv.cjs.map