@orval/core 8.17.0 → 8.19.0

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./chunk-8H4AJuhK.mjs";
 import { createRequire } from "node:module";
 import { entries, groupBy, isArray, isBoolean, isBoolean as isBoolean$1, isEmptyish, isFunction, isFunction as isFunction$1, isNullish, isNullish as isNullish$1, isNumber, isString, isString as isString$1, prop, unique, uniqueBy, uniqueWith } from "remeda";
 import { keyword } from "esutils";
-import nodePath from "node:path";
+import path from "node:path";
 import { compare } from "compare-versions";
 import debug from "debug";
 import { pathToFileURL } from "node:url";
@@ -168,7 +168,7 @@ function isDynamicReference(obj) {
 * @param pathValue - Path string to inspect.
 */
 function isDirectory(pathValue) {
-	return !nodePath.extname(pathValue);
+	return !path.extname(pathValue);
 }
 /**
 * Type guard for plain objects created with `{}` or `new Object()`.
@@ -560,8 +560,8 @@ async function dynamicImport(toImport, from = process.cwd(), takeDefault = true)
 	if (!toImport) return toImport;
 	try {
 		if (isString(toImport)) {
-			const filePath = nodePath.resolve(from, toImport);
-			const extension = nodePath.extname(filePath);
+			const filePath = path.resolve(from, toImport);
+			const extension = path.extname(filePath);
 			if (TS_MODULE_EXTENSIONS.has(extension)) {
 				const data = await createJiti(from, { interopDefault: true }).import(filePath);
 				if (takeDefault && (isObject(data) || isModule(data)) && data.default) return data.default;
@@ -586,14 +586,14 @@ function getExtension(path) {
 //#region src/utils/file.ts
 function getFileInfo(target = "", { backupFilename = "filename", extension = ".ts" } = {}) {
 	const isDir = isDirectory(target);
-	const filePath = isDir ? nodePath.join(target, backupFilename + extension) : target;
+	const filePath = isDir ? path.join(target, backupFilename + extension) : target;
 	return {
 		path: filePath,
 		pathWithoutExtension: filePath.replace(/\.[^/.]+$/, ""),
 		extension,
 		isDirectory: isDir,
-		dirname: nodePath.dirname(filePath),
-		filename: nodePath.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
+		dirname: path.dirname(filePath),
+		filename: path.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
 	};
 }
 async function removeFilesAndEmptyFolders(patterns, dir) {
@@ -804,10 +804,10 @@ var path_exports = /* @__PURE__ */ __exportAll({
 	toUnix: () => toUnix
 });
 function isAbsolute(value) {
-	return nodePath.isAbsolute(value);
+	return path.isAbsolute(value);
 }
 function resolve(...args) {
-	return toUnix(nodePath.resolve(...args));
+	return toUnix(path.resolve(...args));
 }
 function toUnix(value) {
 	value = value.replaceAll("\\", "/");
@@ -815,13 +815,13 @@ function toUnix(value) {
 	return value;
 }
 function join(...args) {
-	return toUnix(nodePath.join(...args.map((a) => toUnix(a))));
+	return toUnix(path.join(...args.map((a) => toUnix(a))));
 }
 /**
 * Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
 */
 function relativeSafe(from, to) {
-	return normalizeSafe(`./${toUnix(nodePath.relative(toUnix(from), toUnix(to)))}`);
+	return normalizeSafe(`./${toUnix(path.relative(toUnix(from), toUnix(to)))}`);
 }
 function getSchemaFileName(path) {
 	return path.replace(`.${getExtension(path)}`, "").slice(path.lastIndexOf("/") + 1);
@@ -829,13 +829,13 @@ function getSchemaFileName(path) {
 function normalizeSafe(value) {
 	let result;
 	value = toUnix(value);
-	result = toUnix(nodePath.normalize(value));
+	result = toUnix(path.normalize(value));
 	if (value.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
 	else if (value.startsWith("//") && !result.startsWith("//")) result = value.startsWith("//./") ? "//." + result : "/" + result;
 	return result;
 }
 function joinSafe(...values) {
-	let result = toUnix(nodePath.join(...values.map((v) => toUnix(v))));
+	let result = toUnix(path.join(...values.map((v) => toUnix(v))));
 	if (values.length > 0) {
 		const firstValue = toUnix(values[0]);
 		if (firstValue.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
@@ -866,14 +866,14 @@ function joinSafe(...values) {
 * @returns The relative import path string.
 */
 function getRelativeImportPath(importerFilePath, exporterFilePath, includeFileExtension = false) {
-	if (!nodePath.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
-	if (!nodePath.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
-	const importerDir = nodePath.dirname(importerFilePath);
-	const relativePath = nodePath.relative(importerDir, exporterFilePath);
-	let posixPath = nodePath.posix.join(...relativePath.split(nodePath.sep));
+	if (!path.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
+	if (!path.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
+	const importerDir = path.dirname(importerFilePath);
+	const relativePath = path.relative(importerDir, exporterFilePath);
+	let posixPath = path.posix.join(...relativePath.split(path.sep));
 	if (!posixPath.startsWith("./") && !posixPath.startsWith("../")) posixPath = `./${posixPath}`;
 	if (!includeFileExtension) {
-		const ext = nodePath.extname(posixPath);
+		const ext = path.extname(posixPath);
 		if (ext && posixPath.endsWith(ext)) posixPath = posixPath.slice(0, -ext.length);
 	}
 	return posixPath;
@@ -882,20 +882,20 @@ function getRelativeImportPath(importerFilePath, exporterFilePath, includeFileEx
 //#region src/utils/resolve-version.ts
 function resolveInstalledVersion(packageName, fromDir) {
 	try {
-		const require = createRequire(nodePath.join(fromDir, "noop.js"));
+		const require = createRequire(path.join(fromDir, "noop.js"));
 		try {
 			return require(`${packageName}/package.json`).version;
 		} catch (directError) {
 			if (directError instanceof Error && "code" in directError && directError.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
 				const entryPath = require.resolve(packageName);
-				let dir = nodePath.dirname(entryPath);
-				while (dir !== nodePath.parse(dir).root) {
-					const pkgPath = nodePath.join(dir, "package.json");
+				let dir = path.dirname(entryPath);
+				while (dir !== path.parse(dir).root) {
+					const pkgPath = path.join(dir, "package.json");
 					if (existsSync(pkgPath)) {
 						const pkgData = JSON.parse(readFileSync(pkgPath, "utf8"));
 						if (pkgData.name === packageName) return pkgData.version;
 					}
-					dir = nodePath.dirname(dir);
+					dir = path.dirname(dir);
 				}
 				return;
 			}
@@ -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;
 }
@@ -1158,6 +1159,55 @@ function dedupeUnionType(unionType) {
 	return [...new Set(parts)].join(" | ");
 }
 //#endregion
+//#region src/utils/tags.ts
+/**
+* Canonical bucket key for a single OpenAPI tag.
+*
+* In `tags` / `tags-split` mode operations are routed into files by their first
+* tag. This function is the **single source of truth** for turning a tag (or a
+* missing tag) into the key that identifies that file bucket. Every place that
+* groups operations by tag, derives a per-tag file/directory name, or checks
+* whether an operation belongs to a tag MUST go through here so that the
+* "build the key" side and the "look the key up" side can never disagree.
+*
+* The result is `kebab`-cased. `kebab` is idempotent
+* (`kebab(kebab(x)) === kebab(x)`), so it is always safe to call this on a value
+* that is already a canonical key. Other case functions (`camel`, `pascal`) are
+* NOT safe here: they do not round-trip through the bucket key for tags
+* containing acronyms or spaces (e.g. `"AB Widget"`), which is exactly the class
+* of bug this module exists to prevent.
+*
+* Missing or empty tags map to the implicit {@link DefaultTag} bucket.
+*/
+function getTagKey(tag) {
+	const normalizedTag = tag?.trim();
+	return kebab(normalizedTag ? normalizedTag : DefaultTag);
+}
+/**
+* Canonical bucket key for an operation, derived from its primary (first) tag.
+*
+* Untagged operations resolve to the {@link DefaultTag} bucket.
+*/
+function getOperationTagKey(operation) {
+	return getTagKey(operation.tags[0]);
+}
+/**
+* Whether an operation belongs to the given tag bucket.
+*
+* Both sides are normalised through {@link getTagKey}, so the comparison is
+* correct regardless of how `tagKey` was spelled or cased by the caller. An
+* absent (`undefined`) `tagKey` matches every operation (the "no tag filter"
+* case); an empty/whitespace `tagKey` is normalised to the {@link DefaultTag}
+* bucket like any other tag.
+*
+* Prefer this over hand-rolling `operation.tags[0] === tagKey`: a raw tag
+* compared against a canonical key silently fails for multi-word/acronym tags.
+*/
+function isOperationInTagBucket(operation, tagKey) {
+	if (tagKey == null) return true;
+	return getOperationTagKey(operation) === getTagKey(tagKey);
+}
+//#endregion
 //#region src/utils/tsconfig.ts
 function isSyntheticDefaultImportsAllow(config) {
 	if (!config) return true;
@@ -2485,6 +2535,52 @@ function buildDynamicScope(schemaName, schema, context) {
 	return scope;
 }
 /**
+* Build dynamic scope entries for an **anonymous inline** subschema that declares
+* `$dynamicAnchor` without a `$ref` (e.g. inside `allOf`, `items`, nested props).
+*
+* Unlike {@link buildDynamicScope}, entries carry the concrete `inlineSchema` so
+* that a descendant `$dynamicRef` resolves to the inline override rather than the
+* outer/global component. Used when `dereference` enters a subschema without a
+* named component `$ref`.
+*
+* Scope of handling (deliberate, see #3492):
+*   - Direct `$dynamicAnchor` on the subschema → inline entry.
+*   - `$defs` `$dynamicAnchor` *without* a `$ref` → inline entry. Note this
+*     differs from `buildDynamicScope`, which treats unbound `$defs` anchors as
+*     generic parameters (`isParameter`); inline subschemas are concrete
+*     instances, so the anchor resolves to the inline schema object itself.
+*   - `$defs` `$dynamicAnchor` *with* a `$ref` → intentionally NOT collected
+*     here. Such anchors rely on `resolveDynamicRef`'s global fallback (which
+*     finds them when the `$ref` target declares the same anchor). Fully
+*     resolving them would duplicate `buildDynamicScope`'s `$defs` logic.
+*/
+function buildInlineDynamicScope(schema) {
+	const scope = {};
+	const schemaRecord = schema;
+	if (typeof schemaRecord.$dynamicAnchor === "string") {
+		const anchor = schemaRecord.$dynamicAnchor;
+		scope[anchor] = {
+			name: anchor,
+			schemaName: anchor,
+			inlineSchema: schema
+		};
+	}
+	const defs = schemaRecord.$defs;
+	if (defs && typeof defs === "object") for (const defSchema of Object.values(defs)) {
+		if (!defSchema || typeof defSchema !== "object") continue;
+		const defRecord = defSchema;
+		if (typeof defRecord.$dynamicAnchor === "string" && !defSchema.$ref) {
+			const anchor = defRecord.$dynamicAnchor;
+			scope[anchor] = {
+				name: anchor,
+				schemaName: anchor,
+				inlineSchema: defSchema
+			};
+		}
+	}
+	return scope;
+}
+/**
 * Resolve a `$dynamicRef` anchor to its concrete type using the current dynamic scope.
 * Returns `{ schema: {}, resolvedTypeName: 'unknown' }` when no scope override exists.
 */
@@ -2520,6 +2616,12 @@ function resolveDynamicRef(anchorName, context, imports = []) {
 		resolvedTypeName: scopeEntry.name,
 		schemaName: void 0
 	};
+	if (scopeEntry.inlineSchema) return {
+		schema: scopeEntry.inlineSchema,
+		imports,
+		resolvedTypeName: scopeEntry.name,
+		schemaName: void 0
+	};
 	const resolvedTypeName = scopeEntry.name;
 	const schemaRef = `#/components/schemas/${encodeJsonPointerSegment(scopeEntry.schemaName)}`;
 	try {
@@ -2712,7 +2814,7 @@ function resolveValue({ schema, name, context, formDataContext }) {
 		const refName = resolvedImport.name;
 		let effectiveContext = context;
 		const refAnchor = schemaObject.$dynamicAnchor;
-		if (typeof refAnchor === "string" && context.dynamicScope?.[refAnchor] && context.dynamicScope[refAnchor].name !== refName && !context.dynamicScope[refAnchor].isParameter) {
+		if (typeof refAnchor === "string" && context.dynamicScope?.[refAnchor] && context.dynamicScope[refAnchor].name !== refName && !context.dynamicScope[refAnchor].isParameter && !context.dynamicScope[refAnchor].inlineSchema) {
 			const scopeEntry = context.dynamicScope[refAnchor];
 			const allOf = ((context.spec.components?.schemas)?.[scopeEntry.schemaName])?.allOf;
 			if (!(Array.isArray(allOf) && allOf.some((el) => {
@@ -4618,9 +4720,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(path.extname(mutator.path), tsconfig);
+	return `${getRelativeImportPath(outputFile, mutator.path)}${ext}`;
 };
 async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 	if (!mutator || !output) return;
@@ -4643,7 +4746,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)}`,
@@ -4685,11 +4788,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)) {
@@ -4811,7 +4922,7 @@ function generateBodyOptions(body, isFormData, isFormUrlEncoded) {
 	if (isFormUrlEncoded && body.formUrlEncoded) return "formUrlEncoded";
 	if (body.implementation) return body.implementation;
 }
-function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularObserve, angularParamsRef, requiredNullableQueryParamKeys, nonPrimitiveQueryParamKeys, queryParams, headers, requestOptions, hasSignal, hasSignalParam = false, isVue, isAngular, paramsSerializer, paramsSerializerOptions, paramsFilter }) {
+function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularObserve, angularParamsRef, requiredNullableQueryParamKeys, nonPrimitiveQueryParamKeys, queryParams, headers, requestOptions, hasSignal, hasSignalParam = false, isAngular, paramsSerializer, paramsSerializerOptions, paramsFilter }) {
 	const isRequestOptions = requestOptions !== false;
 	const angularPassthroughQueryParamKeys = paramsSerializer ? nonPrimitiveQueryParamKeys : [];
 	const signalVar = hasSignalParam ? "querySignal" : "signal";
@@ -4848,8 +4959,7 @@ function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularO
 	if (isRequestOptions) {
 		value += isAngular ? "\n    ...(options as Omit<NonNullable<typeof options>, 'observe'>)," : "\n    ...options,";
 		if (isAngular && angularObserve) value += `\n        observe: '${angularObserve}',`;
-		if (queryParams) if (isVue) value += "\n        params: {...unref(params), ...options?.params},";
-		else if (isAngular && angularParamsRef) value += `\n        params: ${angularParamsRef},`;
+		if (queryParams) if (isAngular && angularParamsRef) value += `\n        params: ${angularParamsRef},`;
 		else if (isAngular && paramsSerializer) {
 			const callExpr = buildAngularParamsFilterExpression({
 				paramsExpression: "{...params, ...options?.params}",
@@ -4878,7 +4988,7 @@ function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularO
 	}
 	return value;
 }
-function generateOptions({ route, body, angularObserve, angularParamsRef, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, hasSignalParam, isVue, paramsSerializer, paramsSerializerOptions, paramsFilter }) {
+function generateOptions({ route, body, angularObserve, angularParamsRef, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, hasSignalParam, paramsSerializer, paramsSerializerOptions, paramsFilter }) {
 	const bodyIdentifier = getIsBodyVerb(verb) ? generateBodyOptions(body, isFormData, isFormUrlEncoded) : void 0;
 	const axiosOptions = generateAxiosOptions({
 		response,
@@ -4892,7 +5002,6 @@ function generateOptions({ route, body, angularObserve, angularParamsRef, header
 		isExactOptionalPropertyTypes,
 		hasSignal,
 		hasSignalParam,
-		isVue: isVue ?? false,
 		isAngular: isAngular ?? false,
 		paramsSerializer,
 		paramsSerializerOptions,
@@ -4915,11 +5024,10 @@ function generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) {
 	if (body.implementation) return `,\n      data: ${body.implementation}`;
 	return "";
 }
-function generateQueryParamsAxiosConfig(response, isVue, isAngular, requiredNullableQueryParamKeys, queryParams, paramsFilter) {
+function generateQueryParamsAxiosConfig(response, isAngular, requiredNullableQueryParamKeys, queryParams, paramsFilter) {
 	if (!queryParams && !response.isBlob) return "";
 	let value = "";
-	if (queryParams) if (isVue) value += ",\n        params: unref(params)";
-	else if (isAngular) {
+	if (queryParams) if (isAngular) {
 		const paramsExpr = buildAngularParamsFilterExpression({
 			paramsExpression: "params ?? {}",
 			requiredNullableParamKeys: requiredNullableQueryParamKeys,
@@ -4932,9 +5040,9 @@ function generateQueryParamsAxiosConfig(response, isVue, isAngular, requiredNull
 	if (response.isBlob) value += `,\n        responseType: 'blob'`;
 	return value;
 }
-function generateMutatorConfig({ route, body, headers, queryParams, response, verb, isFormData, isFormUrlEncoded, hasSignal, hasSignalParam = false, isExactOptionalPropertyTypes, isVue, isAngular, paramsFilter }) {
+function generateMutatorConfig({ route, body, headers, queryParams, response, verb, isFormData, isFormUrlEncoded, hasSignal, hasSignalParam = false, isExactOptionalPropertyTypes, isAngular, paramsFilter }) {
 	const bodyOptions = getIsBodyVerb(verb) ? generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) : "";
-	const queryParamsOptions = generateQueryParamsAxiosConfig(response, isVue ?? false, isAngular ?? false, queryParams?.requiredNullableKeys, queryParams, paramsFilter);
+	const queryParamsOptions = generateQueryParamsAxiosConfig(response, isAngular ?? false, queryParams?.requiredNullableKeys, queryParams, paramsFilter);
 	const ignoreContentTypes = isAngular ? ["multipart/form-data"] : [];
 	const headerOptions = body.contentType && !ignoreContentTypes.includes(body.contentType) ? `,\n      headers: {'Content-Type': '${body.contentType}', ${headers ? "...headers" : ""}}` : headers ? ",\n      headers" : "";
 	const signalVar = hasSignalParam ? "querySignal" : "signal";
@@ -5469,6 +5577,50 @@ async function writeGeneratedFile(filePath, content) {
 	await fs$1.outputFile(filePath, content.replaceAll(TRAILING_WHITESPACE_RE, ""));
 }
 //#endregion
+//#region src/writers/schema-tag-mapper.ts
+const SHARED_DIR = ".";
+function buildSchemaTagMap(operations, schemas) {
+	const schemaNames = new Set(schemas.map((s) => s.name));
+	const schemaToTags = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (!schemaToTags.has(schema.name)) schemaToTags.set(schema.name, /* @__PURE__ */ new Set());
+	for (const operation of operations) {
+		const tag = kebab(operation.tags[0] ?? "default");
+		for (const imp of operation.imports) if (!imp.importPath && schemaNames.has(imp.name)) addTag(schemaToTags, imp.name, tag);
+	}
+	propagateTransitiveTags(schemaToTags, new Map(schemas.map((s) => [s.name, s])));
+	const result = /* @__PURE__ */ new Map();
+	for (const [name, tags] of schemaToTags) if (tags.size === 0 || tags.size > 1) result.set(name, ".");
+	else result.set(name, [...tags][0]);
+	return result;
+}
+function addTag(schemaToTags, schemaName, tag) {
+	if (!schemaToTags.has(schemaName)) schemaToTags.set(schemaName, /* @__PURE__ */ new Set());
+	schemaToTags.get(schemaName).add(tag);
+}
+function propagateTransitiveTags(schemaToTags, schemaByName) {
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const [name, tags] of schemaToTags) {
+			const schema = schemaByName.get(name);
+			if (!schema) continue;
+			for (const imp of schema.imports) {
+				if (!isSchemaImport(imp)) continue;
+				if (!schemaByName.has(imp.name)) continue;
+				const targetTags = schemaToTags.get(imp.name);
+				if (!targetTags) continue;
+				for (const tag of tags) if (!targetTags.has(tag)) {
+					targetTags.add(tag);
+					changed = true;
+				}
+			}
+		}
+	}
+}
+function isSchemaImport(imp) {
+	return !imp.importPath;
+}
+//#endregion
 //#region src/writers/schemas.ts
 /**
 * Patterns to detect operation-derived types (params, bodies, responses).
@@ -5621,8 +5773,8 @@ function getSchema({ schema: { imports, model }, header, namingConvention = Nami
 	file += model;
 	return file;
 }
-function getPath(path, name, fileExtension) {
-	return nodePath.join(path, `${name}${fileExtension}`);
+function getPath(path$1, name, fileExtension) {
+	return path.join(path$1, `${name}${fileExtension}`);
 }
 function writeModelInline(acc, model) {
 	return acc + `${model}\n`;
@@ -5715,14 +5867,14 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		await writeGeneratedFile(getPath(factoryDir, factoryFileName, fileExtension), factoryFile);
 	}
 	if (indexFiles) {
-		const schemaFilePath = nodePath.join(schemaPath, `index.ts`);
+		const schemaFilePath = path.join(schemaPath, `index.ts`);
 		await fs$1.ensureFile(schemaFilePath);
 		const ext = getImportExtension(fileExtension, tsconfig);
 		const conventionNamesSet = new Set(Object.values(schemaGroups).map((group) => conventionName(group[0].name, namingConvention)));
 		try {
 			const currentExports = [...conventionNamesSet].map((schemaName) => `export * from './${schemaName}${ext}';`);
 			if (factoryOutputDirectory && normalizeSafe(factoryOutputDirectory) !== normalizeSafe(schemaPath) && (isCombined.value || separateFactoryNames.length > 0)) {
-				const factoryIndexFilePath = nodePath.join(factoryOutputDirectory, `index.ts`);
+				const factoryIndexFilePath = path.join(factoryOutputDirectory, `index.ts`);
 				await fs$1.ensureFile(factoryIndexFilePath);
 				const factoryExports = [];
 				if (isCombined.value) {
@@ -5745,24 +5897,93 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 	}
 }
 //#endregion
+//#region src/writers/schemas-tags-split.ts
+async function writeSchemasTagsSplit({ schemaPath, schemas, target, namingConvention, fileExtension, header, indexFiles, tsconfig, factoryOutputDirectory, operations }) {
+	const schemaTagMap = buildSchemaTagMap(operations, schemas);
+	const importExtension = getImportExtension(fileExtension, tsconfig);
+	const groups = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		const group = schemaTagMap.get(schema.name) ?? ".";
+		if (!groups.has(group)) groups.set(group, []);
+		groups.get(group).push(schema);
+	}
+	for (const [groupDir, groupSchemas] of groups) {
+		const isRoot = groupDir === ".";
+		const groupPath = isRoot ? schemaPath : path.join(schemaPath, groupDir);
+		fixCrossTagImports(groupSchemas, schemaTagMap, schemaPath, groupDir, namingConvention, importExtension);
+		const groupFactoryDir = factoryOutputDirectory ? isRoot ? factoryOutputDirectory : path.join(factoryOutputDirectory, groupDir) : void 0;
+		await writeSchemas({
+			schemaPath: groupPath,
+			schemas: groupSchemas,
+			target,
+			namingConvention,
+			fileExtension,
+			header,
+			indexFiles: !isRoot && indexFiles,
+			tsconfig,
+			factoryOutputDirectory: groupFactoryDir
+		});
+	}
+	if (indexFiles && groups.size > 0) {
+		const rootIndexPath = path.join(schemaPath, "index.ts");
+		const rootExports = (groups.get(".") ?? []).map((s) => {
+			return `export * from './${conventionName(s.name, namingConvention)}${importExtension}';`;
+		});
+		const tagExports = [...groups.keys()].filter((dir) => dir !== ".").toSorted((a, b) => a.localeCompare(b, "en", { numeric: true })).map((dir) => {
+			return `export * from '${importExtension ? `./${dir}/index${importExtension}` : `./${dir}`}';`;
+		});
+		await writeGeneratedFile(rootIndexPath, `${header}\n${[...rootExports, ...tagExports].join("\n")}\n`);
+	}
+}
+function fixCrossTagImports(schemas, schemaTagMap, schemaPath, currentGroupDir, namingConvention, importExtension) {
+	const fromPath = currentGroupDir === "." ? schemaPath : path.join(schemaPath, currentGroupDir);
+	for (const schema of schemas) {
+		const fixImports = (imports) => imports.map((imp) => {
+			const targetGroup = schemaTagMap.get(imp.name);
+			if (targetGroup === void 0 || targetGroup === currentGroupDir) return imp;
+			const importPath = joinSafe(relativeSafe(fromPath, targetGroup === "." ? schemaPath : path.join(schemaPath, targetGroup)), conventionName(imp.name, namingConvention)) + importExtension;
+			return {
+				...imp,
+				importPath
+			};
+		});
+		schema.imports = fixImports(schema.imports);
+		if (schema.factoryImports) schema.factoryImports = fixImports(schema.factoryImports);
+	}
+}
+//#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) {
+function generateImportsForBuilder(output, imports, relativeSchemasPath, schemaTagMap) {
 	const isPackageImport = isObject(output.schemas) && !!output.schemas.importPath;
 	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;
@@ -5776,7 +5997,11 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 	else {
 		const importsByDependency = /* @__PURE__ */ new Map();
 		for (const schemaImport of imports.filter((i) => !i.importPath)) {
-			const dependency = joinSafe(relativeSchemasPath, `${conventionName(isZodSchemaOutput ? schemaImport.name : schemaImport.schemaName ?? schemaImport.name, output.namingConvention)}${isZodSchemaOutput ? ".zod" : ""}${isPackageImport ? "" : getImportExtension(output.fileExtension, output.tsconfig)}`);
+			const normalizedName = conventionName(isZodSchemaOutput ? schemaImport.name : schemaImport.schemaName ?? schemaImport.name, output.namingConvention);
+			const suffix = isZodSchemaOutput ? ".zod" : "";
+			const importExtension = isPackageImport ? "" : getImportExtension(output.fileExtension, output.tsconfig);
+			const tagDir = schemaTagMap?.get(schemaImport.name);
+			const dependency = joinSafe(relativeSchemasPath, `${tagDir && tagDir !== "." ? `${tagDir}/` : ""}${normalizedName}${suffix}${importExtension}`);
 			if (!importsByDependency.has(dependency)) importsByDependency.set(dependency, []);
 			importsByDependency.get(dependency)?.push(schemaImport);
 		}
@@ -5797,6 +6022,88 @@ 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-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/mock-outputs.ts
 /**
@@ -5822,8 +6129,8 @@ function hasAnyMockPath(mockConfig) {
 	return mockConfig.generators.some((g) => !isFunction(g) && !!g.path);
 }
 function resolveMockSchemasPath(mockFilePath, schemasTarget) {
-	const ext = nodePath.extname(mockFilePath);
-	const targetExt = nodePath.extname(schemasTarget);
+	const ext = path.extname(mockFilePath);
+	const targetExt = path.extname(schemasTarget);
 	return getRelativeImportPath(mockFilePath, targetExt === ".schemas" ? schemasTarget + ext : targetExt ? schemasTarget : schemasTarget + ext);
 }
 //#endregion
@@ -5844,7 +6151,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) {
@@ -5866,7 +6174,8 @@ function generateTarget(builder, options) {
 		formUrlEncoded: [],
 		paramsSerializer: [],
 		paramsFilter: [],
-		fetchReviver: []
+		fetchReviver: [],
+		sharedTypes: []
 	};
 	const operations = Object.values(builder.operations);
 	for (const [index, operation] of operations.entries()) {
@@ -5880,6 +6189,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) {
@@ -5909,7 +6222,7 @@ function generateTarget(builder, options) {
 				verbOptions: builder.verbOptions,
 				clientImplementation: target.implementation
 			});
-			target.implementation = header.implementation + target.implementation;
+			target.implementation = (header.sharedTypes && header.sharedTypes.length > 0 ? header.sharedTypes.map((t) => `${t.exported ? "export " : ""}${t.code}`).join("\n") + "\n\n" : "") + header.implementation + target.implementation;
 			const footer = builder.footer({
 				outputClient: options.client,
 				operationNames,
@@ -5975,7 +6288,7 @@ interface TypedResponse<T> extends Response {
 }
 //#endregion
 //#region src/writers/single-mode.ts
-async function writeSingleMode({ builder, output, projectName, header, needSchema, generateSchemasInline }) {
+async function writeSingleMode({ builder, output, projectName, header, needSchema, generateSchemasInline, schemaTagMap }) {
 	try {
 		const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
 			backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
@@ -6003,7 +6316,7 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 			}
 		}
 		let data = header;
-		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, normalizedImports, relativeSchemasPath) : generateImportsForBuilder(output, normalizedImports.filter((imp) => !!imp.importPath), ".");
+		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, normalizedImports, relativeSchemasPath, schemaTagMap) : generateImportsForBuilder(output, normalizedImports.filter((imp) => !!imp.importPath), ".");
 		data += builder.imports({
 			client: output.client,
 			implementation,
@@ -6019,10 +6332,13 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 		});
 		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, relativeSchemasPath) : generateImportsForBuilder(output, filteredMockImports.filter((imp) => !!imp.importPath), ".");
+			const finalizeMockOptions = getFinalizeMockImplementationOptions(output, mockOutput);
+			const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, finalizeMockOptions) : mockOutput.implementation;
+			const recoveredSchemaFactoryImports = !!entry && !isFunction(entry) && entry.type === OutputMockType.FAKER && entry.schemas === true && output.schemas ? collectRecoveredSchemaFactoryImports(finalizedMockImplementation, builder.schemas.filter((s) => s.schema).map((s) => s.name)) : [];
+			const filteredMockImports = filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports).filter((impMock) => !normalizedImports.some((imp) => imp.name === impMock.name && (imp.alias ?? "") === (impMock.alias ?? ""))), finalizeMockOptions.strictSchemaTypeNames);
+			const importsMockForBuilder = schemasPath ? generateImportsForBuilder(output, filteredMockImports, relativeSchemasPath, schemaTagMap) : generateImportsForBuilder(output, filteredMockImports.filter((imp) => !!imp.importPath), ".");
 			data += builder.importsMock({
-				implementation: mockOutput.implementation,
+				implementation: finalizedMockImplementation,
 				imports: importsMockForBuilder,
 				projectName,
 				hasSchemaDir: !!output.schemas,
@@ -6071,11 +6387,13 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 				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 mockFilePath = path.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), ".");
+				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 = schemasPath || mockDir !== dirname ? generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames), mockRelativeSchemasPath, schemaTagMap) : generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames).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,
@@ -6099,7 +6417,7 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 			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}`);
+					const indexMockPath = path.join(mockDir, `index.${mockExt}${extension}`);
 					await writeGeneratedFile(indexMockPath, `export * from './${filename}.${mockExt}${importExtension}'\n`);
 					extraPaths.push(indexMockPath);
 				}
@@ -6113,7 +6431,7 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 }
 //#endregion
 //#region src/writers/split-mode.ts
-async function writeSplitMode({ builder, output, projectName, header, needSchema, generateSchemasInline }) {
+async function writeSplitMode({ builder, output, projectName, header, needSchema, generateSchemasInline, schemaTagMap }) {
 	try {
 		const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
 			backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
@@ -6122,10 +6440,10 @@ 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 schemasTarget = output.schemas ? getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname : nodePath.join(dirname, filename + ".schemas" + extension.replace(/\.ts$/, ""));
+		const relativeSchemasPath = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(targetPath, isString(output.schemas) ? output.schemas : output.schemas.path, true) : "./" + filename + ".schemas" + getImportExtension(extension, output.tsconfig);
+		const schemasTarget = output.schemas ? isString(output.schemas) ? output.schemas : output.schemas.path : path.join(dirname, filename + ".schemas" + getImportExtension(extension, output.tsconfig));
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
-		const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
+		const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath, schemaTagMap);
 		implementationData += builder.imports({
 			client: output.client,
 			implementation,
@@ -6139,7 +6457,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			packageJson: output.packageJson,
 			output
 		});
-		const schemasPath = !output.schemas && needSchema ? nodePath.join(dirname, filename + ".schemas" + extension) : void 0;
+		const schemasPath = !output.schemas && needSchema ? path.join(dirname, filename + ".schemas" + extension) : void 0;
 		if (schemasPath) await writeGeneratedFile(schemasPath, generateSchemasInline ? header + generateSchemasInline() : header + generateModelsInline(builder.schemas));
 		if (mutators) implementationData += generateMutatorImports({
 			mutators,
@@ -6161,7 +6479,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		}
 		implementationData += `\n${implementation}`;
 		const implementationFilename = filename + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-		const implementationPath = nodePath.join(dirname, implementationFilename);
+		const implementationPath = path.join(dirname, implementationFilename);
 		await writeGeneratedFile(implementationPath, implementationData);
 		const mockPaths = [];
 		const seenMockIndexKeys = /* @__PURE__ */ new Set();
@@ -6174,11 +6492,13 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			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 mockFilePath = path.join(mockDir, filename + "." + mockExtension + extension);
 			const mockRelativeSchemasPath = schemaCustomImportPath ?? resolveMockSchemasPath(mockFilePath, schemasTarget);
-			const importsMockForBuilder = generateImportsForBuilder(output, mockOutput.imports, mockRelativeSchemasPath);
+			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, schemaTagMap);
 			let mockData = header;
-			const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, getFinalizeMockImplementationOptions(output, mockOutput)) : mockOutput.implementation;
 			mockData += builder.importsMock({
 				implementation: finalizedMockImplementation,
 				imports: importsMockForBuilder,
@@ -6203,7 +6523,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		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}`);
+				const indexMockPath = path.join(mockDir, `index.${mockExt}${extension}`);
 				await writeGeneratedFile(indexMockPath, `export * from './${filename}.${mockExt}${importExtension}'\n`);
 				indexMockPaths.push(indexMockPath);
 			}
@@ -6248,7 +6568,8 @@ 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) {
@@ -6256,7 +6577,8 @@ function mergeOperationMockOutputs(accMockOutputs, opMockOutputs) {
 		type: m.type,
 		implementation: { ...m.implementation },
 		imports: [...m.imports],
-		strictMockSchemaTypeNames: m.strictMockSchemaTypeNames ? [...m.strictMockSchemaTypeNames] : void 0
+		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);
@@ -6266,6 +6588,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) {
@@ -6284,11 +6610,12 @@ function initialMockOutputsForOperation(op) {
 			handlerName: m.implementation.handlerName ? "  " + m.implementation.handlerName + "()" : ""
 		},
 		imports: [...m.imports],
-		strictMockSchemaTypeNames: m.strictMockSchemaTypeNames ? [...m.strictMockSchemaTypeNames] : void 0
+		strictMockSchemaTypeNames: m.strictMockSchemaTypeNames ? [...m.strictMockSchemaTypeNames] : void 0,
+		strictMockSchemaKinds: m.strictMockSchemaKinds ? { ...m.strictMockSchemaKinds } : void 0
 	}));
 }
 function generateTargetTags(currentAcc, operation) {
-	const tag = kebab(operation.tags[0]);
+	const tag = getOperationTagKey(operation);
 	if (!(tag in currentAcc)) {
 		currentAcc[tag] = {
 			imports: operation.imports,
@@ -6329,7 +6656,7 @@ function generateTargetForTags(builder, options) {
 			const transformed = {};
 			for (const [tag, target] of Object.entries(allTargetTags)) {
 				const isMutator = !!target.mutators?.some((mutator) => isAngularClient ? mutator.hasThirdArg : mutator.hasSecondArg);
-				const operationNames = Object.values(builder.operations).filter(({ tags }) => tags.map((tag) => kebab(tag)).indexOf(kebab(tag)) === 0).map(({ operationName }) => operationName);
+				const operationNames = operations.filter((operation) => isOperationInTagBucket(operation, tag)).map(({ operationName }) => operationName);
 				const hasAwaitedType = compareVersions(options.packageJson?.dependencies?.typescript ?? options.packageJson?.devDependencies?.typescript ?? "4.4.0", "4.5.0");
 				const titles = builder.title({
 					outputClient: options.client,
@@ -6359,6 +6686,9 @@ function generateTargetForTags(builder, options) {
 					isDefaultTagBucket: tag === "default" && Object.values(builder.operations).some((operation) => operation.tags.length === 0),
 					clientImplementation: target.implementation
 				});
+				const sharedTypes = header.sharedTypes;
+				const deduplicationActive = options.tagsSplitDeduplication && !options.workspace;
+				const inlinedSharedTypes = !deduplicationActive && sharedTypes && sharedTypes.length > 0 ? sharedTypes.map((t) => `${t.exported ? "export " : ""}${t.code}`).join("\n") + "\n\n" : "";
 				const wrappedMockOutputs = target.mockOutputs.map((m) => ({
 					type: m.type,
 					implementation: {
@@ -6367,10 +6697,11 @@ function generateTargetForTags(builder, options) {
 						handlerName: m.implementation.handlerName
 					},
 					imports: m.imports,
-					strictMockSchemaTypeNames: m.strictMockSchemaTypeNames
+					strictMockSchemaTypeNames: m.strictMockSchemaTypeNames,
+					strictMockSchemaKinds: m.strictMockSchemaKinds
 				}));
 				transformed[tag] = {
-					implementation: header.implementation + target.implementation + footer.implementation,
+					implementation: inlinedSharedTypes + header.implementation + target.implementation + footer.implementation,
 					mockOutputs: wrappedMockOutputs,
 					imports: target.imports,
 					mutators: target.mutators,
@@ -6379,7 +6710,8 @@ function generateTargetForTags(builder, options) {
 					formUrlEncoded: target.formUrlEncoded,
 					paramsSerializer: target.paramsSerializer,
 					paramsFilter: target.paramsFilter,
-					fetchReviver: target.fetchReviver
+					fetchReviver: target.fetchReviver,
+					sharedTypes: deduplicationActive ? sharedTypes : void 0
 				};
 			}
 			allTargetTags = transformed;
@@ -6394,7 +6726,7 @@ function generateTargetForTags(builder, options) {
 }
 //#endregion
 //#region src/writers/split-tags-mode.ts
-async function writeSplitTagsMode({ builder, output, projectName, header, needSchema, generateSchemasInline }) {
+async function writeSplitTagsMode({ builder, output, projectName, header, needSchema, generateSchemasInline, schemaTagMap }) {
 	const { filename, dirname, extension } = getFileInfo(output.target, {
 		backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
 		extension: output.fileExtension
@@ -6403,33 +6735,51 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 	const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 	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" + extension.replace(/\.ts$/, ""));
+	const schemasTarget = output.schemas ? isString(output.schemas) ? output.schemas : output.schemas.path : path.join(dirname, filename + ".schemas" + getImportExtension(extension, output.tsconfig));
 	const tagEntries = Object.entries(target).toSorted(([a], [b]) => a.localeCompare(b));
+	const deduplicationEnabled = output.tagsSplitDeduplication && !output.workspace;
+	const collectedSharedTypes = [];
+	const seenSharedTypeNames = /* @__PURE__ */ new Set();
+	for (const [, target] of tagEntries) {
+		if (!target.sharedTypes) continue;
+		for (const t of target.sharedTypes) if (!seenSharedTypeNames.has(t.name)) {
+			seenSharedTypeNames.add(t.name);
+			collectedSharedTypes.push(t);
+		}
+	}
+	const commonTypesImportExtension = getImportExtension(extension, output.tsconfig);
+	const commonTypesBasename = output.commonTypesFileName;
+	const commonTypesPath = path.join(dirname, commonTypesBasename + extension);
+	const commonTypesRelativeImport = "../" + commonTypesBasename + (deduplicationEnabled ? commonTypesImportExtension : "");
 	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);
+			if (deduplicationEnabled && target.sharedTypes && target.sharedTypes.length > 0) {
+				const typeNames = target.sharedTypes.map((t) => t.name).join(", ");
+				implementationData += `import type { ${typeNames} } from '${commonTypesRelativeImport}';\n`;
+			}
+			const importerPath = path.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, isString(output.schemas) ? output.schemas : output.schemas.path, true) : "../" + 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) => {
 				if (!imp.importPath) return imp;
 				if (!imp.importPath.startsWith(".")) return imp;
-				const resolvedPath = nodePath.resolve(dirname, imp.importPath);
-				const targetBasename = nodePath.basename(resolvedPath);
+				const resolvedPath = path.resolve(dirname, imp.importPath);
+				const targetBasename = path.basename(resolvedPath);
 				let targetFile;
 				if (tagNames.has(targetBasename)) {
 					const tagFilename = targetBasename + serviceSuffix + extension;
-					targetFile = nodePath.join(resolvedPath, tagFilename);
+					targetFile = path.join(resolvedPath, tagFilename);
 				} else targetFile = resolvedPath + extension;
 				const adjustedPath = getRelativeImportPath(importerPath, targetFile);
 				return {
 					...imp,
 					importPath: adjustedPath
 				};
-			}), relativeSchemasPath);
+			}), relativeSchemasPath, schemaTagMap);
 			implementationData += builder.imports({
 				client: output.client,
 				implementation,
@@ -6443,7 +6793,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				packageJson: output.packageJson,
 				output
 			});
-			const schemasPath = !output.schemas && needSchema ? nodePath.join(dirname, filename + ".schemas" + extension) : void 0;
+			const schemasPath = !output.schemas && needSchema ? path.join(dirname, filename + ".schemas" + extension) : void 0;
 			if (schemasPath) await writeGeneratedFile(schemasPath, generateSchemasInline ? header + generateSchemasInline() : header + generateModelsInline(builder.schemas));
 			if (mutators) implementationData += generateMutatorImports({
 				mutators,
@@ -6484,7 +6834,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			}
 			implementationData += `\n${implementation}`;
 			const implementationFilename = tag + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-			const implementationPath = nodePath.join(dirname, tag, implementationFilename);
+			const implementationPath = path.join(dirname, tag, implementationFilename);
 			await writeGeneratedFile(implementationPath, implementationData);
 			const mockPaths = [];
 			for (const mockOutput of mockOutputs) {
@@ -6495,10 +6845,12 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				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 mockFilePath = path.join(mockDir, tag, tag + "." + mockExtension + extension);
 				const mockRelativeSchemasPath = schemaCustomImportPath ?? resolveMockSchemasPath(mockFilePath, schemasTarget);
-				const importsMockForBuilder = generateImportsForBuilder(output, mockOutput.imports, mockRelativeSchemasPath);
-				const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, getFinalizeMockImplementationOptions(output, mockOutput)) : mockOutput.implementation;
+				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, schemaTagMap);
 				let mockData = header;
 				mockData += builder.importsMock({
 					implementation: finalizedMockImplementation,
@@ -6533,15 +6885,40 @@ 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 { 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);
-		return ext === OutputMockType.MSW ? `export { get${pascal(tag)}Mock } from '${localMockPath}'\n` : `export * from '${localMockPath}'\n`;
-	}).join(""));
-	return [...new Set([...output.mock.indexMockFiles ? mockIndexEntries.map(({ mockDir, ext }) => nodePath.join(mockDir, `index.${ext}${extension}`)) : [], ...generatedFilePathsArray.flat()])];
+	if (output.mock.indexMockFiles) {
+		const mockImportExtension = getImportExtension(extension, output.tsconfig);
+		for (const { ext, mockDir, tags } of mockIndexEntries) await writeGeneratedFile(path.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(""));
+	}
+	let commonTypesFilePath;
+	if (deduplicationEnabled && collectedSharedTypes.length > 0) {
+		const commonTypesContent = collectedSharedTypes.map((t) => `export ${t.code}`).join("\n") + "\n";
+		commonTypesFilePath = commonTypesPath;
+		await writeGeneratedFile(commonTypesPath, commonTypesContent);
+	}
+	let indexFilePath;
+	if (output.indexFiles && deduplicationEnabled && tagEntries.length > 0) {
+		const importExtension = getImportExtension(output.fileExtension, output.tsconfig);
+		const serviceSuffix = OutputClient.ANGULAR === output.client ? ".service" : "";
+		const publicSharedTypeNames = collectedSharedTypes.filter((t) => t.exported).map((t) => t.name);
+		const indexContent = (publicSharedTypeNames.length > 0 ? `export type { ${publicSharedTypeNames.join(", ")} } from './${commonTypesBasename}${importExtension}';\n` : "") + tagEntries.map(([tag]) => {
+			return `export * from '${joinSafe("./", tag, tag + serviceSuffix + importExtension)}';\n`;
+		}).join("");
+		indexFilePath = path.join(dirname, `index${extension}`);
+		await writeGeneratedFile(indexFilePath, indexContent);
+	}
+	return [...new Set([
+		...output.mock.indexMockFiles ? mockIndexEntries.map(({ mockDir, ext }) => path.join(mockDir, `index.${ext}${extension}`)) : [],
+		...commonTypesFilePath ? [commonTypesFilePath] : [],
+		...indexFilePath ? [indexFilePath] : [],
+		...generatedFilePathsArray.flat()
+	])];
 }
 //#endregion
 //#region src/writers/tags-mode.ts
-async function writeTagsMode({ builder, output, projectName, header, needSchema, generateSchemasInline }) {
+async function writeTagsMode({ builder, output, projectName, header, needSchema, generateSchemasInline, schemaTagMap }) {
 	const { path: targetPath, filename, dirname, extension } = getFileInfo(output.target, {
 		backupFilename: conventionName(builder.info.title ?? "filename", output.namingConvention),
 		extension: output.fileExtension
@@ -6552,8 +6929,8 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 	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" + extension.replace(/\.ts$/, "");
-	const schemasTarget = output.schemas ? getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname : nodePath.join(dirname, filename + ".schemas" + extension.replace(/\.ts$/, ""));
+	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 : path.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 {
@@ -6573,7 +6950,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 					if (!!mockImport.values || !!mockImport.isConstant || !!mockImport.default || !!mockImport.namespaceImport || !!mockImport.syntheticDefaultImport) matchingImport.values = true;
 				}
 			}
-			const importsForBuilder = generateImportsForBuilder(output, normalizedImports, schemasPathRelative);
+			const importsForBuilder = generateImportsForBuilder(output, normalizedImports, schemasPathRelative, schemaTagMap);
 			data += builder.imports({
 				client: output.client,
 				implementation,
@@ -6589,7 +6966,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 			});
 			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);
+				const importsMockForBuilder = generateImportsForBuilder(output, mockOutput.imports.filter((impMock) => !normalizedImports.some((imp) => imp.name === impMock.name && (imp.alias ?? "") === (impMock.alias ?? ""))), schemasPathRelative, schemaTagMap);
 				data += builder.importsMock({
 					implementation: mockOutput.implementation,
 					imports: importsMockForBuilder,
@@ -6599,7 +6976,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 					options: entry && !isFunction(entry) ? entry : void 0
 				});
 			}
-			const schemasPath = !output.schemas && needSchema ? nodePath.join(dirname, filename + ".schemas" + extension) : void 0;
+			const schemasPath = !output.schemas && needSchema ? path.join(dirname, filename + ".schemas" + extension) : void 0;
 			if (schemasPath) await writeGeneratedFile(schemasPath, generateSchemasInline ? header + generateSchemasInline() : header + generateModelsInline(builder.schemas));
 			if (mutators) data += generateMutatorImports({
 				mutators,
@@ -6630,7 +7007,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 				}
 			}
 			const kebabTag = kebab(tag);
-			const implementationPath = nodePath.join(dirname, `${kebabTag}${extension}`);
+			const implementationPath = path.join(dirname, `${kebabTag}${extension}`);
 			await writeGeneratedFile(implementationPath, data);
 			const extraPaths = [];
 			if (shouldDeinlineMocks) for (const mockOutput of rawMockOutputs) {
@@ -6641,11 +7018,13 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 				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 mockFilePath = path.join(mockDir, kebabTag, kebabTag + "." + mockExtension + extension);
 				const mockRelativeSchemasPath = schemaCustomImportPath ?? resolveMockSchemasPath(mockFilePath, schemasTarget);
-				const importsMockForBuilder = generateImportsForBuilder(output, mockOutput.imports, mockRelativeSchemasPath);
+				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, schemaTagMap);
 				let mockData = header;
-				const finalizedMockImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(mockOutput.implementation, getFinalizeMockImplementationOptions(output, mockOutput)) : mockOutput.implementation;
 				mockData += builder.importsMock({
 					implementation: finalizedMockImplementation,
 					imports: importsMockForBuilder,
@@ -6679,17 +7058,20 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${String(error)}`, { cause: error });
 		}
 	}));
-	if (shouldDeinlineMocks && output.mock.indexMockFiles) 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);
-			return ext === OutputMockType.MSW ? `export { get${pascal(kebabTag)}Mock } from '${localMockPath}'\n` : `export * from '${localMockPath}'\n`;
-		}).join(""));
-		generatedFilePathsArray.push([indexPath]);
+	if (shouldDeinlineMocks && output.mock.indexMockFiles) {
+		const mockImportExtension = getImportExtension(extension, output.tsconfig);
+		for (const { ext, mockDir, tags } of mockIndexEntries) {
+			const indexPath = path.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 };
+export { BODY_TYPE_NAME, DefaultTag, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NAMED_COMPONENT_SECTIONS, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SHARED_DIR, SchemaType, SupportedFormatter, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, addDependency, asyncReduce, buildAngularParamsFilterExpression, buildDynamicScope, buildInlineDynamicScope, buildSchemaTagMap, 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, getOperationTagKey, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSchemasImportPath, getSuccessResponseType, getTagKey, getTypedResponse, getWarningCount, isBinaryContentType, isBinaryScalarSchema, isBoolean, isComponentRef, isDirectory, isDynamicReference, isFakerMock, isFunction, isModule, isMswMock, isNullish, isNumber, isNumeric, isObject, isOperationInTagBucket, 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, writeSchemasTagsSplit, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
 
 //# sourceMappingURL=index.mjs.map