@orval/core 8.18.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;
 			}
@@ -1159,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;
@@ -2486,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.
 */
@@ -2521,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 {
@@ -2713,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) => {
@@ -4621,7 +4722,7 @@ function parseFunction(ast, funcName) {
 const BODY_TYPE_NAME = "BodyType";
 const getImport = (output, mutator, tsconfig) => {
 	const outputFile = getFileInfo(output).path;
-	const ext = mutator.extension ?? getImportExtension(nodePath.extname(mutator.path), tsconfig);
+	const ext = mutator.extension ?? getImportExtension(path.extname(mutator.path), tsconfig);
 	return `${getRelativeImportPath(outputFile, mutator.path)}${ext}`;
 };
 async function generateMutator({ output, mutator, name, workspace, tsconfig }) {
@@ -4821,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";
@@ -4858,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}",
@@ -4888,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,
@@ -4902,7 +5002,6 @@ function generateOptions({ route, body, angularObserve, angularParamsRef, header
 		isExactOptionalPropertyTypes,
 		hasSignal,
 		hasSignalParam,
-		isVue: isVue ?? false,
 		isAngular: isAngular ?? false,
 		paramsSerializer,
 		paramsSerializerOptions,
@@ -4925,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,
@@ -4942,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";
@@ -5479,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).
@@ -5631,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`;
@@ -5725,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) {
@@ -5755,6 +5897,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 : 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 outputs = Array.isArray(mockOutputs) ? mockOutputs : [mockOutputs];
@@ -5778,7 +5975,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 +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);
 		}
@@ -5832,6 +6033,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
@@ -5856,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
@@ -5901,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()) {
@@ -5948,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,
@@ -6014,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),
@@ -6042,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,
@@ -6059,10 +6333,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,
@@ -6111,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,
@@ -6139,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);
 				}
@@ -6152,80 +6430,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 +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" + 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 : 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,
@@ -6251,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,
@@ -6273,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();
@@ -6286,12 +6492,12 @@ 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 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,
@@ -6317,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);
 			}
@@ -6409,7 +6615,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,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,
@@ -6480,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: {
@@ -6492,7 +6701,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 +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;
@@ -6516,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
@@ -6525,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" + 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 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" + 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) => {
 				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,
@@ -6565,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,
@@ -6606,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) {
@@ -6617,12 +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 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,
@@ -6659,16 +6887,38 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 	}));
 	if (output.mock.indexMockFiles) {
 		const mockImportExtension = getImportExtension(extension, output.tsconfig);
-		for (const { ext, mockDir, tags } of mockIndexEntries) await writeGeneratedFile(nodePath.join(mockDir, `index.${ext}${extension}`), tags.toSorted((a, b) => a.localeCompare(b)).map((tag) => {
+		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(""));
 	}
-	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 = 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
@@ -6680,7 +6930,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 	const seenMockIndexKeys = /* @__PURE__ */ new Set();
 	const schemaCustomImportPath = getSchemasImportPath(output.schemas);
 	const schemasPathRelative = output.schemas ? schemaCustomImportPath ?? getRelativeImportPath(targetPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas" + getImportExtension(extension, output.tsconfig);
-	const schemasTarget = output.schemas ? getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname : nodePath.join(dirname, filename + ".schemas" + getImportExtension(extension, output.tsconfig));
+	const 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 {
@@ -6700,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,
@@ -6716,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,
@@ -6726,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,
@@ -6757,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) {
@@ -6768,12 +7018,12 @@ 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 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,
@@ -6811,7 +7061,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 	if (shouldDeinlineMocks && output.mock.indexMockFiles) {
 		const mockImportExtension = getImportExtension(extension, output.tsconfig);
 		for (const { ext, mockDir, tags } of mockIndexEntries) {
-			const indexPath = nodePath.join(mockDir, `index.${ext}${extension}`);
+			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`;
@@ -6822,6 +7072,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, 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