@orval/core 8.16.0 → 8.18.0

package/dist/index.mjs

@@ -955,17 +955,18 @@ const sortByPriority = (arr) => arr.toSorted((a, b) => {
 function stringify(data) {
 	if (data === void 0) return;
 	if (data === null) return "null";
-	if (isString(data)) return `'${data.replaceAll("'", String.raw`\'`)}'`;
+	if (isString(data)) return `'${jsStringLiteralEscape(data)}'`;
 	if (isNumber(data) || isBoolean(data) || isFunction(data)) return String(data);
 	if (Array.isArray(data)) return `[${data.map((item) => stringify(item)).join(", ")}]`;
 	const entries = Object.entries(data);
 	let result = "";
 	for (const [index, [key, value]] of entries.entries()) {
 		const strValue = stringify(value);
-		if (entries.length === 1) result = `{ ${key}: ${strValue}, }`;
-		else if (!index) result = `{ ${key}: ${strValue}, `;
-		else if (entries.length - 1 === index) result += `${key}: ${strValue}, }`;
-		else result += `${key}: ${strValue}, `;
+		const safeKey = key === "__proto__" ? `['${jsStringLiteralEscape(key)}']` : keyword.isIdentifierNameES5(key) ? key : `'${jsStringLiteralEscape(key)}'`;
+		if (entries.length === 1) result = `{ ${safeKey}: ${strValue}, }`;
+		else if (!index) result = `{ ${safeKey}: ${strValue}, `;
+		else if (entries.length - 1 === index) result += `${safeKey}: ${strValue}, }`;
+		else result += `${safeKey}: ${strValue}, `;
 	}
 	return result;
 }
@@ -1320,7 +1321,7 @@ const getUnion = (value, enumName) => {
 };
 function getEnumUnionFromSchema(schema) {
 	if (!schema?.enum) return "";
-	return schema.enum.filter((val) => val !== null).map((val) => isString(val) ? `'${escape(val)}'` : String(val)).join(" | ");
+	return schema.enum.filter((val) => val !== null).map((val) => isString(val) ? `'${jsStringLiteralEscape(val)}'` : String(val)).join(" | ");
 }
 const stripNullUnion = (value) => value.replaceAll(/\s*\|\s*null/g, "").trim();
 const isSpreadableEnumRef = (schema, refName) => {
@@ -1707,13 +1708,13 @@ function getPropertyNamesEnumKeyType(item) {
 	if (Array.isArray(propertyNames.enum)) {
 		const enumValues = propertyNames.enum.filter((val) => isString(val));
 		if (enumValues.length > 0) return {
-			value: enumValues.map((val) => `'${escape(val)}'`).join(" | "),
+			value: enumValues.map((val) => `'${jsStringLiteralEscape(val)}'`).join(" | "),
 			imports: [],
 			dependencies: []
 		};
 	}
 	if (isString(propertyNames.const)) return {
-		value: `'${escape(propertyNames.const)}'`,
+		value: `'${jsStringLiteralEscape(propertyNames.const)}'`,
 		imports: [],
 		dependencies: []
 	};
@@ -1878,7 +1879,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			const hasConst = constValue !== void 0;
 			let constLiteral;
 			if (!hasConst) constLiteral = void 0;
-			else if (isString(constValue)) constLiteral = `'${escape(constValue)}'`;
+			else if (isString(constValue)) constLiteral = `'${jsStringLiteralEscape(constValue)}'`;
 			else constLiteral = JSON.stringify(constValue);
 			const needsValueImport = hasConst && (resolvedValue.isEnum || resolvedValue.type === "enum");
 			const usedResolvedValue = !hasConst || needsValueImport;
@@ -2011,7 +2012,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 		else if (typeof constValue === "boolean") type = "boolean";
 		else type = "object";
 		return {
-			value: typeof constValue === "string" ? `'${escape(constValue)}'` : JSON.stringify(constValue),
+			value: typeof constValue === "string" ? `'${jsStringLiteralEscape(constValue)}'` : JSON.stringify(constValue),
 			imports: [],
 			schemas: [],
 			isEnum: false,
@@ -2152,7 +2153,7 @@ function getScalar({ item, name, context, formDataContext }) {
 			let value = "string";
 			let isEnum = false;
 			if (enumItems) {
-				value = enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : `${enumItem}`).filter(Boolean).join(` | `);
+				value = enumItems.map((enumItem) => isString(enumItem) ? `'${jsStringLiteralEscape(enumItem)}'` : `${enumItem}`).filter(Boolean).join(` | `);
 				isEnum = true;
 			}
 			if (!formDataContext?.urlEncoded) {
@@ -2164,7 +2165,7 @@ function getScalar({ item, name, context, formDataContext }) {
 			}
 			if (context.output.override.useDates && (schemaFormat === "date" || schemaFormat === "date-time")) value = "Date";
 			value += nullable;
-			if (schemaConst) value = `'${schemaConst}'`;
+			if (schemaConst) value = `'${jsStringLiteralEscape(schemaConst)}'`;
 			return {
 				value,
 				isEnum,
@@ -2214,7 +2215,7 @@ function getScalar({ item, name, context, formDataContext }) {
 				nullable
 			});
 			if (enumItems) return {
-				value: enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : String(enumItem)).filter(Boolean).join(` | `) + nullable,
+				value: enumItems.map((enumItem) => isString(enumItem) ? `'${jsStringLiteralEscape(enumItem)}'` : String(enumItem)).filter(Boolean).join(` | `) + nullable,
 				isEnum: true,
 				type: "string",
 				imports: [],
@@ -4457,8 +4458,9 @@ function findRefs(value) {
 	if (!value || typeof value !== "object") return [];
 	if (Array.isArray(value)) return value.flatMap((item) => findRefs(item));
 	const obj = value;
-	if (typeof obj.$ref === "string") return [obj.$ref];
-	return Object.values(obj).flatMap((val) => findRefs(val));
+	const refs = [];
+	if (typeof obj.$ref === "string") refs.push(obj.$ref);
+	return refs.concat(Object.values(obj).flatMap((val) => findRefs(val)));
 }
 function parseComponentRef(ref) {
 	const parts = ref.split("/");
@@ -4617,9 +4619,10 @@ function parseFunction(ast, funcName) {
 //#endregion
 //#region src/generators/mutator.ts
 const BODY_TYPE_NAME = "BodyType";
-const getImport = (output, mutator) => {
+const getImport = (output, mutator, tsconfig) => {
 	const outputFile = getFileInfo(output).path;
-	return `${getRelativeImportPath(outputFile, mutator.path)}${mutator.extension ?? ""}`;
+	const ext = mutator.extension ?? getImportExtension(nodePath.extname(mutator.path), tsconfig);
+	return `${getRelativeImportPath(outputFile, mutator.path)}${ext}`;
 };
 async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 	if (!mutator || !output) return;
@@ -4642,7 +4645,7 @@ async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 		tsconfig
 	});
 	if (!mutatorInfo) throw new Error(styleText("red", `Your mutator file doesn't have the ${mutatorInfoName} exported function`));
-	const importStatementPath = getImport(output, mutator);
+	const importStatementPath = getImport(output, mutator, tsconfig);
 	const isHook = mutator.name ? mutator.name.startsWith("use") && !mutatorInfo.numberOfParams : !mutatorInfo.numberOfParams;
 	return {
 		name: mutator.name || !isHook ? importName : `use${pascal(importName)}`,
@@ -4684,11 +4687,19 @@ const getAngularFilteredParamsExpression = (paramsExpression, requiredNullablePa
       continue;
     }
 ` : "";
-	const preserveNullableBranch = preserveRequiredNullables ? `    } else if (value === null && requiredNullableParamKeys.has(key)) {
+	let preserveNullableBranch;
+	let requiredNullableParamKeysBranch;
+	if (preserveRequiredNullables) {
+		preserveNullableBranch = `    } else if (value === null && requiredNullableParamKeys.has(key)) {
       filteredParams[key] = null;
-` : "";
+`;
+		requiredNullableParamKeysBranch = `const requiredNullableParamKeys = new Set<string>(${JSON.stringify(requiredNullableParamKeys)});`;
+	} else {
+		preserveNullableBranch = "";
+		requiredNullableParamKeysBranch = "";
+	}
 	return `(() => {
-${hasPassthrough ? `  const passthroughKeys = new Set<string>(${JSON.stringify(nonPrimitiveKeys)});\n` : ""}  const requiredNullableParamKeys = new Set<string>(${JSON.stringify(requiredNullableParamKeys)});
+${hasPassthrough ? `  const passthroughKeys = new Set<string>(${JSON.stringify(nonPrimitiveKeys)});\n` : ""}  ${requiredNullableParamKeysBranch}
   const filteredParams: Record<string, ${filteredParamValueType}> = {};
   for (const [key, value] of Object.entries(${paramsExpression})) {
 ${passthroughBranch}    if (Array.isArray(value)) {
@@ -5746,12 +5757,25 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 //#endregion
 //#region src/writers/finalize-mock-implementation.ts
 function getFinalizeMockImplementationOptions(output, mockOutputs) {
-	const strictSchemaTypeNames = [...new Set((Array.isArray(mockOutputs) ? mockOutputs : [mockOutputs]).flatMap((mockOutput) => mockOutput.strictMockSchemaTypeNames ?? []))];
+	const outputs = Array.isArray(mockOutputs) ? mockOutputs : [mockOutputs];
+	const strictSchemaTypeNames = [...new Set(outputs.flatMap((mockOutput) => mockOutput.strictMockSchemaTypeNames ?? []))];
+	const strictMockSchemaKinds = outputs.reduce((acc, mockOutput) => {
+		if (!mockOutput.strictMockSchemaKinds) return acc;
+		for (const [name, kind] of Object.entries(mockOutput.strictMockSchemaKinds)) acc[name] ??= kind;
+		return acc;
+	}, {});
 	return {
 		mockOptions: output.override.mock,
-		strictSchemaTypeNames: strictSchemaTypeNames.length > 0 ? strictSchemaTypeNames : void 0
+		strictSchemaTypeNames: strictSchemaTypeNames.length > 0 ? strictSchemaTypeNames : void 0,
+		strictMockSchemaKinds: Object.keys(strictMockSchemaKinds).length > 0 ? strictMockSchemaKinds : void 0
 	};
 }
+/** Drop schema-factory `{Schema}Mock` type imports that are declared locally. */
+function filterLocalStrictMockTypeImports(imports, strictSchemaTypeNames) {
+	if (!strictSchemaTypeNames?.length) return [...imports];
+	const localMockTypeNames = new Set(strictSchemaTypeNames.map((name) => `${name}Mock`));
+	return imports.filter((imp) => !(imp.schemaFactory && !imp.values && localMockTypeNames.has(imp.name)));
+}
 //#endregion
 //#region src/writers/generate-imports-for-builder.ts
 function generateImportsForBuilder(output, imports, relativeSchemasPath) {
@@ -5759,9 +5783,10 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 	const isZodSchemaOutput = isObject(output.schemas) && output.schemas.type === "zod";
 	const schemaFactoryImports = imports.filter((i) => i.schemaFactory);
 	const schemaFactoryImportExtension = isPackageImport ? "" : getImportExtension(output.fileExtension, output.tsconfig);
+	const schemaFactoryDependency = getFakerSchemasImportPath(output.mock) ?? joinSafe(relativeSchemasPath, `index.faker${schemaFactoryImportExtension}`);
 	const schemaFactoryDeps = schemaFactoryImports.length > 0 ? [{
 		exports: uniqueBy(schemaFactoryImports, (entry) => `${entry.name}|${entry.alias ?? ""}`),
-		dependency: joinSafe(relativeSchemasPath, `index.faker${schemaFactoryImportExtension}`)
+		dependency: schemaFactoryDependency
 	}] : [];
 	imports = imports.filter((i) => !i.schemaFactory);
 	let schemaImports;
@@ -5796,6 +5821,16 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 		...otherImports
 	];
 }
+/**
+* Extracts the faker generator's `schemasImportPath` from the normalized mock
+* config, if one is configured. Returns `undefined` when there is no faker
+* generator with schema factories enabled, or when `schemasImportPath` is not
+* set.
+*/
+function getFakerSchemasImportPath(mock) {
+	if (!mock) return;
+	return mock.generators.find((g) => !isFunction(g) && g.type === OutputMockType.FAKER && g.schemas === true)?.schemasImportPath;
+}
 //#endregion
 //#region src/writers/mock-outputs.ts
 /**
@@ -5811,6 +5846,21 @@ function collapseInlineMockOutputs(mockOutputs) {
 	return mockOutputs.filter((m) => m.type !== OutputMockType.FAKER);
 }
 //#endregion
+//#region src/writers/mock-utils.ts
+function getMockDir(entry, mockConfig) {
+	if (!isFunction(entry) && entry.path) return entry.path;
+	return mockConfig.path;
+}
+function hasAnyMockPath(mockConfig) {
+	if (mockConfig.path) return true;
+	return mockConfig.generators.some((g) => !isFunction(g) && !!g.path);
+}
+function resolveMockSchemasPath(mockFilePath, schemasTarget) {
+	const ext = nodePath.extname(mockFilePath);
+	const targetExt = nodePath.extname(schemasTarget);
+	return getRelativeImportPath(mockFilePath, targetExt === ".schemas" ? schemasTarget + ext : targetExt ? schemasTarget : schemasTarget + ext);
+}
+//#endregion
 //#region src/writers/target.ts
 function emptyMockOutputFull$1(type) {
 	return {
@@ -5828,7 +5878,8 @@ function flattenMockOutput$1(full) {
 		type: full.type,
 		implementation: full.implementation.function + full.implementation.handler,
 		imports: full.imports,
-		strictMockSchemaTypeNames: full.strictMockSchemaTypeNames
+		strictMockSchemaTypeNames: full.strictMockSchemaTypeNames,
+		strictMockSchemaKinds: full.strictMockSchemaKinds
 	};
 }
 function generateTarget(builder, options) {
@@ -5864,6 +5915,10 @@ function generateTarget(builder, options) {
 			}
 			acc.imports.push(...opMock.imports);
 			if (opMock.strictMockSchemaTypeNames?.length) acc.strictMockSchemaTypeNames = [...new Set([...acc.strictMockSchemaTypeNames ?? [], ...opMock.strictMockSchemaTypeNames])];
+			if (opMock.strictMockSchemaKinds) acc.strictMockSchemaKinds = {
+				...acc.strictMockSchemaKinds,
+				...opMock.strictMockSchemaKinds
+			};
 			acc.implementation.function += opMock.implementation.function;
 			acc.implementation.handler += opMock.implementation.handler;
 			if (opMock.implementation.handlerName) {
@@ -5961,30 +6016,33 @@ interface TypedResponse<T> extends Response {
 //#region src/writers/single-mode.ts
 async function writeSingleMode({ builder, output, projectName, header, needSchema, generateSchemasInline }) {
 	try {
-		const { path } = getFileInfo(output.target, {
+		const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
 			backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
 			extension: output.fileExtension
 		});
 		const { imports, mockOutputs: rawMockOutputs, implementation, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, paramsFilter, fetchReviver } = generateTarget(builder, output);
-		const mockOutputs = collapseInlineMockOutputs(rawMockOutputs);
-		const implementationMock = mockOutputs.map((m) => m.implementation).join("\n\n");
-		const finalizedImplementationMock = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(implementationMock, getFinalizeMockImplementationOptions(output, mockOutputs)) : implementationMock;
-		const importsMock = mockOutputs.flatMap((m) => m.imports);
-		let data = header;
-		const schemaCustomImportPath = getSchemasImportPath(output.schemas);
-		const schemasPath = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(path, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
+		const shouldDeinlineMocks = hasAnyMockPath(output.mock);
+		const schemaCustomImportPath = getSchemasImportPath(output.schemas);
+		const schemasPath = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
+		const relativeSchemasPath = schemasPath ?? "./" + filename + ".schemas" + extension.replace(/\.ts$/, "");
+		const schemasTarget = output.schemas ? getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname : targetPath;
 		const normalizedImports = imports.filter((imp) => {
 			const searchWords = [imp.alias, imp.name].filter((part) => Boolean(part?.length)).map((part) => escapeRegExp(part)).join("|");
 			if (!searchWords) return false;
 			return new RegExp(String.raw`\b(${searchWords})\b`, "g").test(implementation);
 		}).map((imp) => ({ ...imp }));
-		for (const mockImport of importsMock) {
-			const matchingImport = normalizedImports.find((imp) => imp.name === mockImport.name && (imp.alias ?? "") === (mockImport.alias ?? ""));
-			if (!matchingImport) continue;
-			if (!!mockImport.values || !!mockImport.isConstant || !!mockImport.default || !!mockImport.namespaceImport || !!mockImport.syntheticDefaultImport) matchingImport.values = true;
+		const collapsedMockOutputs = shouldDeinlineMocks ? [] : collapseInlineMockOutputs(rawMockOutputs);
+		if (!shouldDeinlineMocks) {
+			const importsMock = collapsedMockOutputs.flatMap((m) => m.imports);
+			for (const mockImport of importsMock) {
+				const matchingImport = normalizedImports.find((imp) => imp.name === mockImport.name && (imp.alias ?? "") === (mockImport.alias ?? ""));
+				if (!matchingImport) continue;
+				if (!!mockImport.values || !!mockImport.isConstant || !!mockImport.default || !!mockImport.namespaceImport || !!mockImport.syntheticDefaultImport) matchingImport.values = true;
+			}
 		}
-		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, normalizedImports, schemasPath) : generateImportsForBuilder(output, normalizedImports.filter((imp) => !!imp.importPath), ".");
+		let data = header;
+		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, normalizedImports, relativeSchemasPath) : generateImportsForBuilder(output, normalizedImports.filter((imp) => !!imp.importPath), ".");
 		data += builder.imports({
 			client: output.client,
 			implementation,
@@ -5998,10 +6056,11 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 			packageJson: output.packageJson,
 			output
 		});
-		for (const mockOutput of mockOutputs) {
+		if (!shouldDeinlineMocks) for (const mockOutput of collapsedMockOutputs) {
 			const entry = output.mock.generators.find((g) => !isFunction(g) && g.type === mockOutput.type);
-			const filteredMockImports = mockOutput.imports.filter((impMock) => !normalizedImports.some((imp) => imp.name === impMock.name && (imp.alias ?? "") === (impMock.alias ?? "")));
-			const importsMockForBuilder = schemasPath ? generateImportsForBuilder(output, filteredMockImports, schemasPath) : generateImportsForBuilder(output, filteredMockImports.filter((imp) => !!imp.importPath), ".");
+			const finalizeMockOptions = getFinalizeMockImplementationOptions(output, mockOutput);
+			const filteredMockImports = filterLocalStrictMockTypeImports(mockOutput.imports.filter((impMock) => !normalizedImports.some((imp) => imp.name === impMock.name && (imp.alias ?? "") === (impMock.alias ?? ""))), finalizeMockOptions.strictSchemaTypeNames);
+			const importsMockForBuilder = schemasPath ? generateImportsForBuilder(output, filteredMockImports, relativeSchemasPath) : generateImportsForBuilder(output, filteredMockImports.filter((imp) => !!imp.importPath), ".");
 			data += builder.importsMock({
 				implementation: mockOutput.implementation,
 				imports: importsMockForBuilder,
@@ -6031,18 +6090,140 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 		}
 		if (!output.schemas && needSchema) data += generateSchemasInline ? generateSchemasInline() : generateModelsInline(builder.schemas);
 		data += `${implementation.trim()}\n`;
-		if (mockOutputs.length > 0) {
-			data += "\n\n";
-			data += finalizedImplementationMock;
+		if (!shouldDeinlineMocks) {
+			const implementationMock = collapsedMockOutputs.map((m) => m.implementation).join("\n\n");
+			const finalizedImplementationMock = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(implementationMock, getFinalizeMockImplementationOptions(output, collapsedMockOutputs)) : implementationMock;
+			if (collapsedMockOutputs.length > 0) {
+				data += "\n\n";
+				data += finalizedImplementationMock;
+			}
 		}
-		await writeGeneratedFile(path, data);
-		return [path];
+		await writeGeneratedFile(targetPath, data);
+		const extraPaths = [];
+		if (shouldDeinlineMocks) {
+			const seenMockIndexKeys = /* @__PURE__ */ new Set();
+			const writtenMockEntries = [];
+			for (const mockOutput of rawMockOutputs) {
+				const rawEntry = output.mock.generators.find((g) => {
+					if (isFunction(g)) return mockOutput.type === OutputMockType.MSW;
+					return g.type === mockOutput.type;
+				});
+				if (!rawEntry) continue;
+				const mockExtension = isFunction(rawEntry) ? OutputMockType.MSW : getMockFileExtensionByTypeName(rawEntry);
+				const mockDir = getMockDir(rawEntry, output.mock) ?? dirname;
+				const mockFilePath = nodePath.join(mockDir, filename + "." + mockExtension + extension);
+				const mockRelativeSchemasPath = schemaCustomImportPath ?? resolveMockSchemasPath(mockFilePath, schemasTarget);
+				const importsMockForBuilder = schemasPath || mockDir !== dirname ? generateImportsForBuilder(output, mockOutput.imports, mockRelativeSchemasPath) : generateImportsForBuilder(output, mockOutput.imports.filter((imp) => !!imp.importPath), ".");
+				let mockData = header;
+				const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, getFinalizeMockImplementationOptions(output, mockOutput)) : mockOutput.implementation;
+				mockData += builder.importsMock({
+					implementation: finalizedMockImplementation,
+					imports: importsMockForBuilder,
+					projectName,
+					hasSchemaDir: !!output.schemas,
+					isAllowSyntheticDefaultImports,
+					options: isFunction(rawEntry) ? void 0 : rawEntry
+				});
+				mockData += `\n${finalizedMockImplementation}`;
+				await writeGeneratedFile(mockFilePath, mockData);
+				extraPaths.push(mockFilePath);
+				const indexKey = `${mockExtension}::${mockDir}`;
+				if (!seenMockIndexKeys.has(indexKey)) {
+					seenMockIndexKeys.add(indexKey);
+					writtenMockEntries.push({
+						extension: mockExtension,
+						mockDir
+					});
+				}
+			}
+			if (output.mock.indexMockFiles) {
+				const importExtension = getImportExtension(output.fileExtension, output.tsconfig);
+				for (const { extension: mockExt, mockDir } of writtenMockEntries) {
+					const indexMockPath = nodePath.join(mockDir, `index.${mockExt}${extension}`);
+					await writeGeneratedFile(indexMockPath, `export * from './${filename}.${mockExt}${importExtension}'\n`);
+					extraPaths.push(indexMockPath);
+				}
+			}
+		}
+		return [targetPath, ...extraPaths];
 	} catch (error) {
 		const errorMsg = error instanceof Error ? error.message : "unknown error";
 		throw new Error(`Oups... 🍻. An Error occurred while writing file => ${errorMsg}`, { cause: error });
 	}
 }
 //#endregion
+//#region src/writers/mock-imports.ts
+/** Maps `components/schemas` names to consolidated index.faker import symbols. */
+function buildKnownSchemaFactoryImportSets(schemaNames) {
+	const factoryNames = /* @__PURE__ */ new Set();
+	const typeNames = /* @__PURE__ */ new Set();
+	for (const name of schemaNames) {
+		const typeName = pascal(name);
+		factoryNames.add(`get${typeName}Mock`);
+		typeNames.add(`${typeName}Mock`);
+	}
+	return {
+		factoryNames,
+		typeNames
+	};
+}
+/**
+* Recover schema-factory imports referenced in generated mock bodies but
+* missing from the collected import list (e.g. after shared-array import
+* aggregation on large specs). Scans for `get<Schema>Mock()` calls and
+* `as <Schema>Mock` casts emitted by strict schema delegation (#3590).
+*
+* When `knownSets` is provided, only symbols that exist in the consolidated
+* schemas faker file are recovered — this avoids importing one-off split
+* response helper factories that live in the tag file itself.
+*/
+function collectSchemaFactoryImportsFromImplementation(implementation, knownSets) {
+	const imports = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const match of implementation.matchAll(/\b(get[A-Za-z0-9]+Mock)\(\)/g)) {
+		const factoryName = match[1];
+		if (knownSets && !knownSets.factoryNames.has(factoryName)) continue;
+		const key = `value::${factoryName}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		imports.push({
+			name: factoryName,
+			values: true,
+			schemaFactory: true
+		});
+	}
+	for (const match of implementation.matchAll(/\bas ([A-Za-z0-9]+Mock)\b/g)) {
+		const typeName = match[1];
+		if (knownSets && !knownSets.typeNames.has(typeName)) continue;
+		const key = `type::${typeName}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		imports.push({
+			name: typeName,
+			values: false,
+			schemaFactory: true
+		});
+	}
+	return imports;
+}
+function mergeGeneratorImports(...groups) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const imp of group) {
+		const key = `${imp.name}::${imp.alias ?? ""}`;
+		const existing = merged.get(key);
+		if (!existing) {
+			merged.set(key, imp);
+			continue;
+		}
+		if (!existing.values && imp.values) merged.set(key, imp);
+	}
+	return [...merged.values()];
+}
+/** Recover missing index.faker imports when `schemas: true` is enabled. */
+function collectRecoveredSchemaFactoryImports(implementation, componentSchemaNames) {
+	return collectSchemaFactoryImportsFromImplementation(implementation, buildKnownSchemaFactoryImportSets(componentSchemaNames));
+}
+//#endregion
 //#region src/writers/split-mode.ts
 async function writeSplitMode({ builder, output, projectName, header, needSchema, generateSchemasInline }) {
 	try {
@@ -6053,7 +6234,8 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		const { imports, implementation, mockOutputs, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, paramsFilter, fetchReviver } = generateTarget(builder, output);
 		let implementationData = header;
 		const schemaCustomImportPath = getSchemasImportPath(output.schemas);
-		const relativeSchemasPath = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas" + extension.replace(/\.ts$/, "");
+		const relativeSchemasPath = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas" + getImportExtension(extension, output.tsconfig);
+		const schemasTarget = output.schemas ? getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname : nodePath.join(dirname, filename + ".schemas" + getImportExtension(extension, output.tsconfig));
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 		const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 		implementationData += builder.imports({
@@ -6094,34 +6276,49 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		const implementationPath = nodePath.join(dirname, implementationFilename);
 		await writeGeneratedFile(implementationPath, implementationData);
 		const mockPaths = [];
-		const writtenMockExtensions = /* @__PURE__ */ new Set();
+		const seenMockIndexKeys = /* @__PURE__ */ new Set();
+		const writtenMockEntries = [];
 		for (const mockOutput of mockOutputs) {
-			const entry = output.mock.generators.find((g) => !isFunction(g) && g.type === mockOutput.type);
-			if (!entry) continue;
-			const importsMockForBuilder = generateImportsForBuilder(output, mockOutput.imports, relativeSchemasPath);
+			const rawEntry = output.mock.generators.find((g) => {
+				if (isFunction(g)) return mockOutput.type === OutputMockType.MSW;
+				return g.type === mockOutput.type;
+			});
+			if (!rawEntry) continue;
+			const mockExtension = isFunction(rawEntry) ? OutputMockType.MSW : getMockFileExtensionByTypeName(rawEntry);
+			const mockDir = getMockDir(rawEntry, output.mock) ?? dirname;
+			const mockFilePath = nodePath.join(mockDir, filename + "." + mockExtension + extension);
+			const mockRelativeSchemasPath = schemaCustomImportPath ?? resolveMockSchemasPath(mockFilePath, schemasTarget);
+			const finalizeMockOptions = getFinalizeMockImplementationOptions(output, mockOutput);
+			const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, finalizeMockOptions) : mockOutput.implementation;
+			const recoveredSchemaFactoryImports = !isFunction(rawEntry) && rawEntry.type === OutputMockType.FAKER && rawEntry.schemas === true && output.schemas ? collectRecoveredSchemaFactoryImports(finalizedMockImplementation, builder.schemas.filter((s) => s.schema).map((s) => s.name)) : [];
+			const importsMockForBuilder = generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames), mockRelativeSchemasPath);
 			let mockData = header;
-			const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, getFinalizeMockImplementationOptions(output, mockOutput)) : mockOutput.implementation;
 			mockData += builder.importsMock({
 				implementation: finalizedMockImplementation,
 				imports: importsMockForBuilder,
 				projectName,
 				hasSchemaDir: !!output.schemas,
 				isAllowSyntheticDefaultImports,
-				options: entry
+				options: isFunction(rawEntry) ? void 0 : rawEntry
 			});
 			mockData += `\n${finalizedMockImplementation}`;
-			const mockExtension = getMockFileExtensionByTypeName(entry);
-			const mockPath = nodePath.join(dirname, filename + "." + mockExtension + extension);
-			await writeGeneratedFile(mockPath, mockData);
-			mockPaths.push(mockPath);
-			writtenMockExtensions.add(mockExtension);
+			await writeGeneratedFile(mockFilePath, mockData);
+			mockPaths.push(mockFilePath);
+			const indexKey = `${mockExtension}::${mockDir}`;
+			if (!seenMockIndexKeys.has(indexKey)) {
+				seenMockIndexKeys.add(indexKey);
+				writtenMockEntries.push({
+					extension: mockExtension,
+					mockDir
+				});
+			}
 		}
 		const indexMockPaths = [];
 		if (output.mock.indexMockFiles) {
 			const importExtension = getImportExtension(output.fileExtension, output.tsconfig);
-			for (const mockExtension of writtenMockExtensions) {
-				const indexMockPath = nodePath.join(dirname, `index.${mockExtension}${extension}`);
-				await writeGeneratedFile(indexMockPath, `export * from './${filename}.${mockExtension}${importExtension}'\n`);
+			for (const { extension: mockExt, mockDir } of writtenMockEntries) {
+				const indexMockPath = nodePath.join(mockDir, `index.${mockExt}${extension}`);
+				await writeGeneratedFile(indexMockPath, `export * from './${filename}.${mockExt}${importExtension}'\n`);
 				indexMockPaths.push(indexMockPath);
 			}
 		}
@@ -6165,14 +6362,17 @@ function flattenMockOutput(full) {
 		type: full.type,
 		implementation: full.implementation.function + full.implementation.handler,
 		imports: full.imports,
-		strictMockSchemaTypeNames: full.strictMockSchemaTypeNames
+		strictMockSchemaTypeNames: full.strictMockSchemaTypeNames,
+		strictMockSchemaKinds: full.strictMockSchemaKinds
 	};
 }
 function mergeOperationMockOutputs(accMockOutputs, opMockOutputs) {
 	const result = accMockOutputs.map((m) => ({
 		type: m.type,
 		implementation: { ...m.implementation },
-		imports: [...m.imports]
+		imports: [...m.imports],
+		strictMockSchemaTypeNames: m.strictMockSchemaTypeNames ? [...m.strictMockSchemaTypeNames] : void 0,
+		strictMockSchemaKinds: m.strictMockSchemaKinds ? { ...m.strictMockSchemaKinds } : void 0
 	}));
 	for (const op of opMockOutputs) {
 		let acc = result.find((m) => m.type === op.type);
@@ -6182,6 +6382,10 @@ function mergeOperationMockOutputs(accMockOutputs, opMockOutputs) {
 		}
 		acc.imports.push(...op.imports);
 		if (op.strictMockSchemaTypeNames?.length) acc.strictMockSchemaTypeNames = [...new Set([...acc.strictMockSchemaTypeNames ?? [], ...op.strictMockSchemaTypeNames])];
+		if (op.strictMockSchemaKinds) acc.strictMockSchemaKinds = {
+			...acc.strictMockSchemaKinds,
+			...op.strictMockSchemaKinds
+		};
 		acc.implementation.function += op.implementation.function;
 		acc.implementation.handler += op.implementation.handler;
 		if (op.implementation.handlerName) {
@@ -6199,7 +6403,9 @@ function initialMockOutputsForOperation(op) {
 			handler: m.implementation.handler,
 			handlerName: m.implementation.handlerName ? "  " + m.implementation.handlerName + "()" : ""
 		},
-		imports: [...m.imports]
+		imports: [...m.imports],
+		strictMockSchemaTypeNames: m.strictMockSchemaTypeNames ? [...m.strictMockSchemaTypeNames] : void 0,
+		strictMockSchemaKinds: m.strictMockSchemaKinds ? { ...m.strictMockSchemaKinds } : void 0
 	}));
 }
 function generateTargetTags(currentAcc, operation) {
@@ -6281,7 +6487,9 @@ function generateTargetForTags(builder, options) {
 						handler: m.implementation.handlerName ? m.implementation.handler + header.implementationMock + m.implementation.handlerName + footer.implementationMock : m.implementation.handler,
 						handlerName: m.implementation.handlerName
 					},
-					imports: m.imports
+					imports: m.imports,
+					strictMockSchemaTypeNames: m.strictMockSchemaTypeNames,
+					strictMockSchemaKinds: m.strictMockSchemaKinds
 				}));
 				transformed[tag] = {
 					implementation: header.implementation + target.implementation + footer.implementation,
@@ -6315,23 +6523,17 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 	});
 	const target = generateTargetForTags(builder, output);
 	const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
-	if (output.mock.generators.some((g) => isFunction(g))) throw new Error("Function mock generators (ClientMockBuilder) are not supported in tags-split mode. Use typed generators ({ type: \"msw\" } or { type: \"faker\" }).");
-	const generatorEntries = output.mock.generators.filter((g) => !isFunction(g));
-	const indexFilePathsByType = /* @__PURE__ */ new Map();
-	if (output.mock.indexMockFiles) for (const entry of generatorEntries) {
-		const ext = getMockFileExtensionByTypeName(entry);
-		const indexPath = nodePath.join(dirname, `index.${ext}${extension}`);
-		indexFilePathsByType.set(ext, indexPath);
-		await fs$1.outputFile(indexPath, "");
-	}
-	const tagEntries = Object.entries(target);
+	const mockIndexEntries = [];
+	const seenMockIndexKeys = /* @__PURE__ */ new Set();
+	const schemasTarget = output.schemas ? getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname : nodePath.join(dirname, filename + ".schemas" + getImportExtension(extension, output.tsconfig));
+	const tagEntries = Object.entries(target).toSorted(([a], [b]) => a.localeCompare(b));
 	const generatedFilePathsArray = await Promise.all(tagEntries.map(async ([tag, target]) => {
 		try {
 			const { imports, implementation, mockOutputs, mutators, clientMutators, formData, fetchReviver, formUrlEncoded, paramsSerializer, paramsFilter } = target;
 			let implementationData = header;
 			const importerPath = nodePath.join(dirname, tag, tag + extension);
 			const schemaCustomImportPath = getSchemasImportPath(output.schemas);
-			const relativeSchemasPath = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(importerPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas" + extension.replace(/\.ts$/, "");
+			const relativeSchemasPath = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(importerPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas" + getImportExtension(extension, output.tsconfig);
 			const tagNames = new Set(tagEntries.map(([t]) => t));
 			const serviceSuffix = OutputClient.ANGULAR === output.client ? ".service" : "";
 			const importsForBuilder = generateImportsForBuilder(output, imports.map((imp) => {
@@ -6408,10 +6610,19 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			await writeGeneratedFile(implementationPath, implementationData);
 			const mockPaths = [];
 			for (const mockOutput of mockOutputs) {
-				const entry = output.mock.generators.find((g) => !isFunction(g) && g.type === mockOutput.type);
-				if (!entry) continue;
-				const importsMockForBuilder = generateImportsForBuilder(output, mockOutput.imports, relativeSchemasPath);
-				const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, getFinalizeMockImplementationOptions(output, mockOutput)) : mockOutput.implementation;
+				const rawEntry = output.mock.generators.find((g) => {
+					if (isFunction(g)) return mockOutput.type === OutputMockType.MSW;
+					return g.type === mockOutput.type;
+				});
+				if (!rawEntry) continue;
+				const mockExtension = isFunction(rawEntry) ? OutputMockType.MSW : getMockFileExtensionByTypeName(rawEntry);
+				const mockDir = getMockDir(rawEntry, output.mock) ?? dirname;
+				const mockFilePath = nodePath.join(mockDir, tag, tag + "." + mockExtension + extension);
+				const mockRelativeSchemasPath = schemaCustomImportPath ?? resolveMockSchemasPath(mockFilePath, schemasTarget);
+				const finalizeMockOptions = getFinalizeMockImplementationOptions(output, mockOutput);
+				const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, finalizeMockOptions) : mockOutput.implementation;
+				const recoveredSchemaFactoryImports = !isFunction(rawEntry) && rawEntry.type === OutputMockType.FAKER && rawEntry.schemas === true && output.schemas ? collectRecoveredSchemaFactoryImports(finalizedMockImplementation, builder.schemas.filter((s) => s.schema).map((s) => s.name)) : [];
+				const importsMockForBuilder = generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames), mockRelativeSchemasPath);
 				let mockData = header;
 				mockData += builder.importsMock({
 					implementation: finalizedMockImplementation,
@@ -6419,12 +6630,23 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 					projectName,
 					hasSchemaDir: !!output.schemas,
 					isAllowSyntheticDefaultImports,
-					options: entry
+					options: isFunction(rawEntry) ? void 0 : rawEntry
 				});
 				mockData += `\n${finalizedMockImplementation}`;
-				const mockPath = nodePath.join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(entry) + extension);
-				await writeGeneratedFile(mockPath, mockData);
-				mockPaths.push(mockPath);
+				await writeGeneratedFile(mockFilePath, mockData);
+				mockPaths.push(mockFilePath);
+				const indexKey = `${mockExtension}::${mockDir}`;
+				let indexEntry = mockIndexEntries.find((e) => e.ext === mockExtension && e.mockDir === mockDir);
+				if (!indexEntry) {
+					indexEntry = {
+						ext: mockExtension,
+						mockDir,
+						tags: []
+					};
+					mockIndexEntries.push(indexEntry);
+					seenMockIndexKeys.add(indexKey);
+				}
+				if (!indexEntry.tags.includes(tag)) indexEntry.tags.push(tag);
 			}
 			return [
 				implementationPath,
@@ -6435,17 +6657,14 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			throw new Error(`Oups... 🍻. An Error occurred while splitting tag ${tag} => ${String(error)}`, { cause: error });
 		}
 	}));
-	if (output.mock.indexMockFiles) for (const entry of generatorEntries) {
-		const ext = getMockFileExtensionByTypeName(entry);
-		const indexFilePath = indexFilePathsByType.get(ext);
-		if (!indexFilePath) continue;
-		const indexContent = tagEntries.map(([tag]) => {
-			const localMockPath = joinSafe("./", tag, tag + "." + ext);
+	if (output.mock.indexMockFiles) {
+		const mockImportExtension = getImportExtension(extension, output.tsconfig);
+		for (const { ext, mockDir, tags } of mockIndexEntries) await writeGeneratedFile(nodePath.join(mockDir, `index.${ext}${extension}`), tags.toSorted((a, b) => a.localeCompare(b)).map((tag) => {
+			const localMockPath = joinSafe("./", tag, tag + "." + ext + mockImportExtension);
 			return ext === OutputMockType.MSW ? `export { get${pascal(tag)}Mock } from '${localMockPath}'\n` : `export * from '${localMockPath}'\n`;
-		}).join("");
-		await fs$1.appendFile(indexFilePath, indexContent);
+		}).join(""));
 	}
-	return [...new Set([...indexFilePathsByType.values(), ...generatedFilePathsArray.flat()])];
+	return [...new Set([...output.mock.indexMockFiles ? mockIndexEntries.map(({ mockDir, ext }) => nodePath.join(mockDir, `index.${ext}${extension}`)) : [], ...generatedFilePathsArray.flat()])];
 }
 //#endregion
 //#region src/writers/tags-mode.ts
@@ -6456,25 +6675,30 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 	});
 	const target = generateTargetForTags(builder, output);
 	const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
-	return (await Promise.all(Object.entries(target).map(async ([tag, target]) => {
+	const shouldDeinlineMocks = hasAnyMockPath(output.mock);
+	const mockIndexEntries = [];
+	const seenMockIndexKeys = /* @__PURE__ */ new Set();
+	const schemaCustomImportPath = getSchemasImportPath(output.schemas);
+	const schemasPathRelative = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas" + getImportExtension(extension, output.tsconfig);
+	const schemasTarget = output.schemas ? getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname : nodePath.join(dirname, filename + ".schemas" + getImportExtension(extension, output.tsconfig));
+	const tagEntries = Object.entries(target).toSorted(([a], [b]) => a.localeCompare(b));
+	const generatedFilePathsArray = await Promise.all(tagEntries.map(async ([tag, target]) => {
 		try {
 			const { imports, implementation, mockOutputs: rawMockOutputs, mutators, clientMutators, formData, formUrlEncoded, fetchReviver, paramsSerializer, paramsFilter } = target;
-			const mockOutputs = collapseInlineMockOutputs(rawMockOutputs);
-			const importsMock = mockOutputs.flatMap((m) => m.imports);
-			const implementationMock = mockOutputs.map((m) => m.implementation).join("\n\n");
-			const finalizedImplementationMock = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(implementationMock, getFinalizeMockImplementationOptions(output, mockOutputs)) : implementationMock;
-			let data = header;
-			const schemaCustomImportPath = getSchemasImportPath(output.schemas);
-			const schemasPathRelative = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas" + extension.replace(/\.ts$/, "");
 			const normalizedImports = imports.filter((imp) => {
 				const searchWords = [imp.alias, imp.name].filter((part) => Boolean(part?.length)).map((part) => escapeRegExp(part)).join("|");
 				if (!searchWords) return false;
 				return new RegExp(String.raw`\b(${searchWords})\b`, "g").test(implementation);
 			}).map((imp) => ({ ...imp }));
-			for (const mockImport of importsMock) {
-				const matchingImport = normalizedImports.find((imp) => imp.name === mockImport.name && (imp.alias ?? "") === (mockImport.alias ?? ""));
-				if (!matchingImport) continue;
-				if (!!mockImport.values || !!mockImport.isConstant || !!mockImport.default || !!mockImport.namespaceImport || !!mockImport.syntheticDefaultImport) matchingImport.values = true;
+			const collapsedMockOutputs = shouldDeinlineMocks ? [] : collapseInlineMockOutputs(rawMockOutputs);
+			let data = header;
+			if (!shouldDeinlineMocks) {
+				const importsMock = collapsedMockOutputs.flatMap((m) => m.imports);
+				for (const mockImport of importsMock) {
+					const matchingImport = normalizedImports.find((imp) => imp.name === mockImport.name && (imp.alias ?? "") === (mockImport.alias ?? ""));
+					if (!matchingImport) continue;
+					if (!!mockImport.values || !!mockImport.isConstant || !!mockImport.default || !!mockImport.namespaceImport || !!mockImport.syntheticDefaultImport) matchingImport.values = true;
+				}
 			}
 			const importsForBuilder = generateImportsForBuilder(output, normalizedImports, schemasPathRelative);
 			data += builder.imports({
@@ -6490,7 +6714,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 				packageJson: output.packageJson,
 				output
 			});
-			for (const mockOutput of mockOutputs) {
+			if (!shouldDeinlineMocks) for (const mockOutput of collapsedMockOutputs) {
 				const entry = output.mock.generators.find((g) => !isFunction(g) && g.type === mockOutput.type);
 				const importsMockForBuilder = generateImportsForBuilder(output, mockOutput.imports.filter((impMock) => !normalizedImports.some((imp) => imp.name === impMock.name && (imp.alias ?? "") === (impMock.alias ?? ""))), schemasPathRelative);
 				data += builder.importsMock({
@@ -6524,17 +6748,78 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 				data += "\n";
 			}
 			data += implementation;
-			if (mockOutputs.length > 0) {
-				data += "\n\n";
-				data += finalizedImplementationMock;
+			if (!shouldDeinlineMocks) {
+				const implementationMock = collapsedMockOutputs.map((m) => m.implementation).join("\n\n");
+				const finalizedImplementationMock = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(implementationMock, getFinalizeMockImplementationOptions(output, collapsedMockOutputs)) : implementationMock;
+				if (collapsedMockOutputs.length > 0) {
+					data += "\n\n";
+					data += finalizedImplementationMock;
+				}
 			}
-			const implementationPath = nodePath.join(dirname, `${kebab(tag)}${extension}`);
+			const kebabTag = kebab(tag);
+			const implementationPath = nodePath.join(dirname, `${kebabTag}${extension}`);
 			await writeGeneratedFile(implementationPath, data);
-			return [implementationPath, ...schemasPath ? [schemasPath] : []];
+			const extraPaths = [];
+			if (shouldDeinlineMocks) for (const mockOutput of rawMockOutputs) {
+				const rawEntry = output.mock.generators.find((g) => {
+					if (isFunction(g)) return mockOutput.type === OutputMockType.MSW;
+					return g.type === mockOutput.type;
+				});
+				if (!rawEntry) continue;
+				const mockExtension = isFunction(rawEntry) ? OutputMockType.MSW : getMockFileExtensionByTypeName(rawEntry);
+				const mockDir = getMockDir(rawEntry, output.mock) ?? dirname;
+				const mockFilePath = nodePath.join(mockDir, kebabTag, kebabTag + "." + mockExtension + extension);
+				const mockRelativeSchemasPath = schemaCustomImportPath ?? resolveMockSchemasPath(mockFilePath, schemasTarget);
+				const finalizeMockOptions = getFinalizeMockImplementationOptions(output, mockOutput);
+				const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, finalizeMockOptions) : mockOutput.implementation;
+				const recoveredSchemaFactoryImports = !isFunction(rawEntry) && rawEntry.type === OutputMockType.FAKER && rawEntry.schemas === true && output.schemas ? collectRecoveredSchemaFactoryImports(finalizedMockImplementation, builder.schemas.filter((s) => s.schema).map((s) => s.name)) : [];
+				const importsMockForBuilder = generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames), mockRelativeSchemasPath);
+				let mockData = header;
+				mockData += builder.importsMock({
+					implementation: finalizedMockImplementation,
+					imports: importsMockForBuilder,
+					projectName,
+					hasSchemaDir: !!output.schemas,
+					isAllowSyntheticDefaultImports,
+					options: isFunction(rawEntry) ? void 0 : rawEntry
+				});
+				mockData += `\n${finalizedMockImplementation}`;
+				await writeGeneratedFile(mockFilePath, mockData);
+				extraPaths.push(mockFilePath);
+				const indexKey = `${mockExtension}::${mockDir}`;
+				let indexEntry = mockIndexEntries.find((e) => e.ext === mockExtension && e.mockDir === mockDir);
+				if (!indexEntry) {
+					indexEntry = {
+						ext: mockExtension,
+						mockDir,
+						tags: []
+					};
+					mockIndexEntries.push(indexEntry);
+					seenMockIndexKeys.add(indexKey);
+				}
+				if (!indexEntry.tags.includes(kebabTag)) indexEntry.tags.push(kebabTag);
+			}
+			return [
+				implementationPath,
+				...schemasPath ? [schemasPath] : [],
+				...extraPaths
+			];
 		} catch (error) {
 			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${String(error)}`, { cause: error });
 		}
-	}))).flat();
+	}));
+	if (shouldDeinlineMocks && output.mock.indexMockFiles) {
+		const mockImportExtension = getImportExtension(extension, output.tsconfig);
+		for (const { ext, mockDir, tags } of mockIndexEntries) {
+			const indexPath = nodePath.join(mockDir, `index.${ext}${extension}`);
+			await writeGeneratedFile(indexPath, tags.toSorted((a, b) => a.localeCompare(b)).map((kebabTag) => {
+				const localMockPath = joinSafe("./", kebabTag, kebabTag + "." + ext + mockImportExtension);
+				return ext === OutputMockType.MSW ? `export { get${pascal(kebabTag)}Mock } from '${localMockPath}'\n` : `export * from '${localMockPath}'\n`;
+			}).join(""));
+			generatedFilePathsArray.push([indexPath]);
+		}
+	}
+	return generatedFilePathsArray.flat();
 }
 //#endregion
 export { BODY_TYPE_NAME, DefaultTag, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NAMED_COMPONENT_SECTIONS, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, SupportedFormatter, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, addDependency, asyncReduce, buildAngularParamsFilterExpression, buildDynamicScope, camel, collectReferencedComponents, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicAnchorToParamName, dynamicAnchorsToUniqueParamNames, dynamicImport, escape, escapeRegExp, extractBoundAliasInfo, filterByContentType, filteredVerbs, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFactory, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getAngularFilteredParamsCallExpression, getAngularFilteredParamsExpression, getAngularFilteredParamsHelperBody, getArray, getBaseUrlRuntimeImports, getBodiesByContentType, getBody, getCombinedEnumValue, getDefaultContentType, getDynamicAnchorName, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getImportExtension, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSchemasImportPath, getSuccessResponseType, getTypedResponse, getWarningCount, isBinaryContentType, isBinaryScalarSchema, isBoolean, isComponentRef, isDirectory, isDynamicReference, isFakerMock, isFunction, isModule, isMswMock, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, isVerbose, jsDoc, jsStringEscape, jsStringLiteralEscape, kebab, keyValuePairsToJsDoc, log, logError, logVerbose, logWarning, makeRouteSafe, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resetWarnings, resolveDiscriminators, resolveDynamicRef, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, setVerbose, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, wrapRouteParameters, writeGeneratedFile, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };