@orval/core 8.18.0 → 8.20.0

package/dist/index.mjs

@@ -74,12 +74,13 @@ const FormDataArrayHandling = {
 	SERIALIZE_WITH_BRACKETS: "serialize-with-brackets"
 };
 const Verbs = {
-	POST: "post",
-	PUT: "put",
 	GET: "get",
-	PATCH: "patch",
+	PUT: "put",
+	POST: "post",
 	DELETE: "delete",
-	HEAD: "head"
+	OPTIONS: "options",
+	HEAD: "head",
+	PATCH: "patch"
 };
 /**
 * Canonical tag name used for the generated bucket that collects untagged operations.
@@ -369,10 +370,17 @@ function conventionName(name, convention) {
 }
 //#endregion
 //#region src/utils/compare-version.ts
+const getComparableVersion = (version) => {
+	const npmAliasVersion = version.match(/^npm:(?:@[^/]+\/)?[^@]+@(.+)$/)?.[1];
+	if (npmAliasVersion) return npmAliasVersion;
+	if (version.startsWith("npm:")) return "latest";
+	return version;
+};
 function compareVersions(firstVersion, secondVersions, operator = ">=") {
-	if (firstVersion === "latest" || firstVersion === "*") return true;
-	if (firstVersion.startsWith("catalog:")) return true;
-	return compare(firstVersion.replace(/(\s(.*))/, ""), secondVersions, operator);
+	const comparableVersion = getComparableVersion(firstVersion);
+	if (comparableVersion === "latest" || comparableVersion === "*") return true;
+	if (comparableVersion.startsWith("catalog:")) return true;
+	return compare(comparableVersion.replace(/(\s(.*))/, ""), secondVersions, operator);
 }
 //#endregion
 //#region src/utils/content-type.ts
@@ -1159,6 +1167,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;
@@ -1586,7 +1643,7 @@ function combineSchemas({ name, schema, separator, context, nullable, formDataCo
 		hasReadonlyProps: false,
 		example: schema.example,
 		examples: resolveExampleRefs(schema.examples, context),
-		requiredProperties: separator === "allOf" ? schema.required ?? [] : []
+		requiredProperties: separator === "allOf" ? [...normalizedSchema.required ?? []] : []
 	};
 	for (const subSchema of items) {
 		let propName;
@@ -1594,7 +1651,6 @@ function combineSchemas({ name, schema, separator, context, nullable, formDataCo
 			propName = name ? name + pascal(separator) : void 0;
 			if (propName && resolvedData.schemas.length > 0) propName = propName + pascal(getNumberWord(resolvedData.schemas.length + 1));
 		}
-		if (separator === "allOf" && isSchema(subSchema) && subSchema.required) resolvedData.requiredProperties.push(...subSchema.required);
 		const resolvedValue = resolveObject({
 			schema: subSchema,
 			propName,
@@ -1602,6 +1658,10 @@ function combineSchemas({ name, schema, separator, context, nullable, formDataCo
 			context,
 			formDataContext
 		});
+		if (separator === "allOf") {
+			const memberRequired = resolvedValue.originalSchema?.required;
+			if (Array.isArray(memberRequired)) resolvedData.requiredProperties.push(...memberRequired);
+		}
 		const aliasedImports = getAliasedImports({
 			context,
 			name,
@@ -2486,27 +2546,105 @@ 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;
+}
+/**
+* Lazily build and memoize the `$dynamicAnchor` index on the context.
+*
+* Scans `components.schemas` once per spec and stores, per anchor name, the
+* compact match info required by the {@link resolveDynamicRef} fallback (see
+* {@link DynamicAnchorIndexEntry}). Subsequent fallback lookups are O(1)
+* instead of re-scanning every schema per `$dynamicRef`.
+*
+* Recording of non-exact matches stops once `count >= 2` — the fallback only
+* distinguishes "exactly one non-exact" from "ambiguous", so further non-exact
+* names are irrelevant. Iteration continues regardless because a later schema
+* whose key equals the anchor name is still the definitive (`exactName`)
+* winner. This is the safe form of "bail early when ambiguous": a literal
+* early-return at `count === 2` would regress the exact-name rule when the
+* exact schema appears later in iteration order.
+*/
+function getDynamicAnchorIndex(context) {
+	const cached = context.dynamicAnchorIndex;
+	if (cached) return cached;
+	const index = /* @__PURE__ */ new Map();
+	const schemas = context.spec.components?.schemas;
+	if (schemas && typeof schemas === "object") for (const [schemaName, schemaObj] of Object.entries(schemas)) {
+		if (!schemaObj || typeof schemaObj !== "object") continue;
+		const anchor = schemaObj.$dynamicAnchor;
+		if (typeof anchor !== "string") continue;
+		let entry = index.get(anchor);
+		if (!entry) {
+			entry = { count: 0 };
+			index.set(anchor, entry);
+		}
+		if (schemaName === anchor) entry.exactName = schemaName;
+		else if (entry.count < 2) {
+			entry.count += 1;
+			if (!entry.firstName) entry.firstName = schemaName;
+		}
+	}
+	context.dynamicAnchorIndex = index;
+	return index;
+}
+/**
 * Resolve a `$dynamicRef` anchor to its concrete type using the current dynamic scope.
 * Returns `{ schema: {}, resolvedTypeName: 'unknown' }` when no scope override exists.
 */
 function resolveDynamicRef(anchorName, context, imports = []) {
 	let scopeEntry = (context.dynamicScope ?? {})[anchorName];
 	if (!scopeEntry) {
-		const schemas = context.spec.components?.schemas;
-		if (schemas && typeof schemas === "object") {
-			const matches = [];
-			for (const [schemaName, schemaObj] of Object.entries(schemas)) {
-				if (!schemaObj || typeof schemaObj !== "object") continue;
-				if (schemaObj.$dynamicAnchor === anchorName) matches.push(schemaName);
-			}
-			const match = matches.length === 1 ? matches[0] : matches.find((m) => m === anchorName);
-			if (match) {
-				const refInfo = getRefInfo(`#/components/schemas/${encodeJsonPointerSegment(match)}`, context);
-				scopeEntry = {
-					name: refInfo.name,
-					schemaName: refInfo.originalName
-				};
-			}
+		const entry = getDynamicAnchorIndex(context).get(anchorName);
+		const match = entry?.exactName ?? (entry?.count === 1 ? entry?.firstName : void 0);
+		if (match) {
+			const refInfo = getRefInfo(`#/components/schemas/${encodeJsonPointerSegment(match)}`, context);
+			scopeEntry = {
+				name: refInfo.name,
+				schemaName: refInfo.originalName
+			};
 		}
 	}
 	if (!scopeEntry) return {
@@ -2521,6 +2659,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 {
@@ -2713,7 +2857,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) => {
@@ -4620,6 +4764,7 @@ function parseFunction(ast, funcName) {
 //#region src/generators/mutator.ts
 const BODY_TYPE_NAME = "BodyType";
 const getImport = (output, mutator, tsconfig) => {
+	if (mutator.resolvedPath || !nodePath.isAbsolute(mutator.path)) return mutator.path;
 	const outputFile = getFileInfo(output).path;
 	const ext = mutator.extension ?? getImportExtension(nodePath.extname(mutator.path), tsconfig);
 	return `${getRelativeImportPath(outputFile, mutator.path)}${ext}`;
@@ -4629,15 +4774,16 @@ async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
 	const isDefault = mutator.default;
 	const importName = mutator.name ?? `${name}Mutator`;
 	const importPath = mutator.path;
+	const inspectionPath = mutator.resolvedPath ?? mutator.path;
 	const mutatorInfoName = isDefault ? "default" : mutator.name;
 	if (mutatorInfoName === void 0) throw new Error(styleText("red", `Mutator ${importPath} must have a named or default export.`));
-	let rawFile = await fs$1.readFile(importPath, "utf8");
+	let rawFile = nodePath.isAbsolute(inspectionPath) ? await fs$1.readFile(inspectionPath, "utf8") : "";
 	rawFile = removeComments(rawFile);
-	const hasErrorType = rawFile.includes("export type ErrorType") || rawFile.includes("export interface ErrorType");
-	const hasBodyType = rawFile.includes(`export type BodyType`) || rawFile.includes(`export interface BodyType`);
+	const hasErrorType = !!rawFile && (rawFile.includes("export type ErrorType") || rawFile.includes("export interface ErrorType"));
+	const hasBodyType = !!rawFile && (rawFile.includes(`export type BodyType`) || rawFile.includes(`export interface BodyType`));
 	const errorTypeName = mutator.default ? `${pascal(name)}ErrorType` : "ErrorType";
 	const bodyTypeName = mutator.default ? `${pascal(name)}${BODY_TYPE_NAME}` : BODY_TYPE_NAME;
-	const mutatorInfo = await getMutatorInfo(importPath, {
+	const mutatorInfo = await getMutatorInfo(inspectionPath, {
 		root: workspace,
 		namedExport: mutatorInfoName,
 		alias: mutator.alias,
@@ -4821,7 +4967,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";
@@ -4858,8 +5004,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}",
@@ -4888,7 +5033,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,
@@ -4902,7 +5047,6 @@ function generateOptions({ route, body, angularObserve, angularParamsRef, header
 		isExactOptionalPropertyTypes,
 		hasSignal,
 		hasSignalParam,
-		isVue: isVue ?? false,
 		isAngular: isAngular ?? false,
 		paramsSerializer,
 		paramsSerializerOptions,
@@ -4925,11 +5069,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,
@@ -4942,9 +5085,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";
@@ -5479,6 +5622,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).
@@ -5755,6 +5942,61 @@ 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 : nodePath.join(schemaPath, groupDir);
+		fixCrossTagImports(groupSchemas, schemaTagMap, schemaPath, groupDir, namingConvention, importExtension);
+		const groupFactoryDir = factoryOutputDirectory ? isRoot ? factoryOutputDirectory : nodePath.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 = nodePath.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 : nodePath.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 : nodePath.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 outputs = Array.isArray(mockOutputs) ? mockOutputs : [mockOutputs];
@@ -5778,7 +6020,7 @@ function filterLocalStrictMockTypeImports(imports, strictSchemaTypeNames) {
 }
 //#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);
@@ -5800,7 +6042,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);
 		}
@@ -5832,6 +6078,78 @@ function getFakerSchemasImportPath(mock) {
 	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
 /**
 * Collapses the per-generator mock outputs for "inline" writer modes
@@ -5861,6 +6179,12 @@ function resolveMockSchemasPath(mockFilePath, schemasTarget) {
 	return getRelativeImportPath(mockFilePath, targetExt === ".schemas" ? schemasTarget + ext : targetExt ? schemasTarget : schemasTarget + ext);
 }
 //#endregion
+//#region src/writers/typescript-version.ts
+const getTypeScriptVersion = (packageJson) => {
+	return packageJson?.resolvedVersions?.typescript ?? packageJson?.dependencies?.typescript ?? packageJson?.devDependencies?.typescript ?? packageJson?.peerDependencies?.typescript ?? "4.4.0";
+};
+const hasTypeScriptAwaitedType = (packageJson) => compareVersions(getTypeScriptVersion(packageJson), "4.5.0");
+//#endregion
 //#region src/writers/target.ts
 function emptyMockOutputFull$1(type) {
 	return {
@@ -5901,7 +6225,8 @@ function generateTarget(builder, options) {
 		formUrlEncoded: [],
 		paramsSerializer: [],
 		paramsFilter: [],
-		fetchReviver: []
+		fetchReviver: [],
+		sharedTypes: []
 	};
 	const operations = Object.values(builder.operations);
 	for (const [index, operation] of operations.entries()) {
@@ -5935,7 +6260,7 @@ function generateTarget(builder, options) {
 		if (operation.fetchReviver) target.fetchReviver.push(operation.fetchReviver);
 		if (index === operations.length - 1) {
 			const isMutator = target.mutators.some((mutator) => isAngularClient ? mutator.hasThirdArg : mutator.hasSecondArg);
-			const hasAwaitedType = compareVersions(options.packageJson?.dependencies?.typescript ?? options.packageJson?.devDependencies?.typescript ?? "4.4.0", "4.5.0");
+			const hasAwaitedType = hasTypeScriptAwaitedType(options.packageJson);
 			const header = builder.header({
 				outputClient: options.client,
 				isRequestOptions: options.override.requestOptions !== false,
@@ -5948,7 +6273,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,
@@ -6014,7 +6339,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),
@@ -6042,7 +6367,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,
@@ -6059,10 +6384,12 @@ 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 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), ".");
+			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,
@@ -6113,9 +6440,11 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 				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), ".");
+				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,
@@ -6152,80 +6481,8 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 	}
 }
 //#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 }) {
+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),
@@ -6234,10 +6491,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" + 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 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 : nodePath.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,
@@ -6291,7 +6548,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			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);
+			const importsMockForBuilder = generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames), mockRelativeSchemasPath, schemaTagMap);
 			let mockData = header;
 			mockData += builder.importsMock({
 				implementation: finalizedMockImplementation,
@@ -6409,7 +6666,7 @@ function initialMockOutputsForOperation(op) {
 	}));
 }
 function generateTargetTags(currentAcc, operation) {
-	const tag = kebab(operation.tags[0]);
+	const tag = getOperationTagKey(operation);
 	if (!(tag in currentAcc)) {
 		currentAcc[tag] = {
 			imports: operation.imports,
@@ -6450,8 +6707,8 @@ 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 hasAwaitedType = compareVersions(options.packageJson?.dependencies?.typescript ?? options.packageJson?.devDependencies?.typescript ?? "4.4.0", "4.5.0");
+				const operationNames = operations.filter((operation) => isOperationInTagBucket(operation, tag)).map(({ operationName }) => operationName);
+				const hasAwaitedType = hasTypeScriptAwaitedType(options.packageJson);
 				const titles = builder.title({
 					outputClient: options.client,
 					title: pascal(tag),
@@ -6480,6 +6737,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: {
@@ -6492,7 +6752,7 @@ function generateTargetForTags(builder, options) {
 					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,
@@ -6501,7 +6761,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;
@@ -6516,7 +6777,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
@@ -6525,15 +6786,33 @@ 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" + getImportExtension(extension, output.tsconfig));
+	const schemasTarget = output.schemas ? isString(output.schemas) ? output.schemas : output.schemas.path : nodePath.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 = nodePath.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;
+			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 = 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" + getImportExtension(extension, output.tsconfig);
+			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) => {
@@ -6551,7 +6830,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 					...imp,
 					importPath: adjustedPath
 				};
-			}), relativeSchemasPath);
+			}), relativeSchemasPath, schemaTagMap);
 			implementationData += builder.imports({
 				client: output.client,
 				implementation,
@@ -6622,7 +6901,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				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);
+				const importsMockForBuilder = generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames), mockRelativeSchemasPath, schemaTagMap);
 				let mockData = header;
 				mockData += builder.importsMock({
 					implementation: finalizedMockImplementation,
@@ -6664,11 +6943,33 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			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()])];
+	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 = nodePath.join(dirname, `index${extension}`);
+		await writeGeneratedFile(indexFilePath, indexContent);
+	}
+	return [...new Set([
+		...output.mock.indexMockFiles ? mockIndexEntries.map(({ mockDir, ext }) => nodePath.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
@@ -6700,7 +7001,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,
@@ -6716,7 +7017,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,
@@ -6773,7 +7074,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 				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);
+				const importsMockForBuilder = generateImportsForBuilder(output, filterLocalStrictMockTypeImports(mergeGeneratorImports(mockOutput.imports, recoveredSchemaFactoryImports), finalizeMockOptions.strictSchemaTypeNames), mockRelativeSchemasPath, schemaTagMap);
 				let mockData = header;
 				mockData += builder.importsMock({
 					implementation: finalizedMockImplementation,
@@ -6822,6 +7123,6 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 	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, getDynamicAnchorIndex, 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