orval 8.18.0 → 8.20.0

package/dist/{config-CXPetEiJ.mjs → config-C8B9Lol2.mjs}

@@ -1,5 +1,6 @@
+import { createRequire } from "node:module";
 import path from "node:path";
-import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SupportedFormatter, asyncReduce, buildDynamicScope, collectReferencedComponents, conventionName, createSuccessMessage, dynamicImport, fixCrossDirectoryImports, fixRegularSchemaImports, generateComponentDefinition, generateDependencyImports, generateMutator, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getBaseUrlRuntimeImports, getFileInfo, getFullRoute, getImportExtension, getMockFileExtensionByTypeName, getRefInfo, getRoute, isBoolean, isComponentRef, isFunction, isNullish, isObject, isReference, isString, isUrl, jsDoc, log, logError, logVerbose, logWarning, pascal, removeFilesAndEmptyFolders, resolveInstalledVersions, resolveRef, resolveValue, splitSchemasByType, upath, writeGeneratedFile, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
+import { DefaultTag, FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SupportedFormatter, asyncReduce, buildDynamicScope, buildSchemaTagMap, collectReferencedComponents, conventionName, createSuccessMessage, dynamicImport, fixCrossDirectoryImports, fixRegularSchemaImports, generateComponentDefinition, generateDependencyImports, generateMutator, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getBaseUrlRuntimeImports, getFileInfo, getFullRoute, getImportExtension, getMockFileExtensionByTypeName, getRefInfo, getRoute, isBoolean, isComponentRef, isFunction, isNullish, isObject, isReference, isString, isUrl, jsDoc, kebab, log, logError, logVerbose, logWarning, pascal, removeFilesAndEmptyFolders, resolveInstalledVersions, resolveRef, resolveValue, splitSchemasByType, upath, writeGeneratedFile, writeSchemas, writeSchemasTagsSplit, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
 import { bundle } from "@scalar/json-magic/bundle";
 import { fetchUrls, parseJson, parseYaml, readFiles } from "@scalar/json-magic/bundle/plugins/node";
 import { upgrade, validate } from "@scalar/openapi-parser";
@@ -15,20 +16,20 @@ import mcp from "@orval/mcp";
 import query from "@orval/query";
 import solidStart from "@orval/solid-start";
 import swr from "@orval/swr";
-import zod, { dereference, generateFormDataZodSchema, generateZodValidationSchemaDefinition, isZodVersionV4, parseZodValidationSchemaDefinition } from "@orval/zod";
+import zod, { assertZodTarget, dereference, generateFormDataZodSchema, generateZodValidationSchemaDefinition, getZodImportSource, getZodTypeName, parseZodValidationSchemaDefinition, resolveIsZodV4 } from "@orval/zod";
 import { ExecaError, execa } from "execa";
 import fs from "fs-extra";
 import fs$1, { access } from "node:fs/promises";
 import { styleText } from "node:util";
 import { parseArgsStringToArgv } from "string-argv";
+import fs$2, { existsSync } from "node:fs";
 import { findUp, findUpMultiple } from "find-up";
 import yaml from "js-yaml";
 import { parseTsconfig } from "get-tsconfig";
-import fs$2 from "node:fs";
 import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
-var version = "8.18.0";
+var version = "8.20.0";
 var description = "A swagger client generator for typescript";
 //#endregion
 //#region src/client.ts
@@ -77,21 +78,24 @@ const generateClientImports = ({ client, implementation, imports, projectName, h
 };
 const generateClientHeader = ({ outputClient = DEFAULT_CLIENT, isRequestOptions, isGlobalMutator, isMutator, provideIn, hasAwaitedType, titles, output, verbOptions, tag, isDefaultTagBucket, clientImplementation }) => {
 	const { header } = getGeneratorClient(outputClient, output);
+	const rawHeader = header ? header({
+		title: titles.implementation,
+		isRequestOptions,
+		isGlobalMutator,
+		isMutator,
+		provideIn,
+		hasAwaitedType,
+		output,
+		verbOptions,
+		tag,
+		isDefaultTagBucket,
+		clientImplementation
+	}) : "";
+	const normalizedHeader = typeof rawHeader === "string" ? { implementation: rawHeader } : rawHeader;
 	return {
-		implementation: header ? header({
-			title: titles.implementation,
-			isRequestOptions,
-			isGlobalMutator,
-			isMutator,
-			provideIn,
-			hasAwaitedType,
-			output,
-			verbOptions,
-			tag,
-			isDefaultTagBucket,
-			clientImplementation
-		}) : "",
-		implementationMock: `export const ${titles.implementationMock} = () => [\n`
+		implementation: normalizedHeader.implementation,
+		implementationMock: `export const ${titles.implementationMock} = () => [\n`,
+		sharedTypes: normalizedHeader.sharedTypes
 	};
 };
 const generateClientFooter = ({ outputClient, operationNames, hasMutator, hasAwaitedType, titles, output }) => {
@@ -888,7 +892,8 @@ function normalizeSchemasOption(schemas, workspace) {
 	return {
 		path: normalizePath(schemas.path, workspace),
 		type: schemas.type ?? "typescript",
-		importPath: schemas.importPath
+		importPath: schemas.importPath,
+		splitByTags: schemas.splitByTags ?? false
 	};
 }
 /**
@@ -905,6 +910,29 @@ function validatePackageSpecifier(value, fieldName) {
 	if (value.startsWith(".")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not a relative path. Received: "${value}"`);
 	if (path.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\")) throw new Error(`\`${fieldName}\` must be a package specifier (e.g. '@acme/models'), not an absolute path. Received: "${value}"`);
 }
+function looksLikePackageSpecifier(value) {
+	return !!value && value.trim() === value && !value.startsWith(".") && !path.isAbsolute(value) && !/^[A-Za-z]:[\\/]/.test(value) && !value.startsWith("\\\\");
+}
+function resolvePackageSpecifier(workspace, value) {
+	try {
+		return createRequire(path.join(workspace, "package.json")).resolve(value);
+	} catch {
+		return;
+	}
+}
+function isPackageSpecifierCandidate(workspace, value) {
+	if (!looksLikePackageSpecifier(value)) return false;
+	if (existsSync(path.resolve(workspace, value))) return false;
+	if (value.startsWith("@")) return true;
+	const [packageName] = value.split("/");
+	if (!value.includes("/")) return true;
+	for (let dir = workspace;;) {
+		if (existsSync(path.join(dir, "node_modules", packageName))) return true;
+		const parent = path.dirname(dir);
+		if (parent === dir) return false;
+		dir = parent;
+	}
+}
 function normalizeEffectOptions(effect) {
 	return {
 		strict: {
@@ -1017,6 +1045,8 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 			baseUrl: outputOptions.baseUrl,
 			unionAddMissingProperties: outputOptions.unionAddMissingProperties ?? false,
 			factoryMethods,
+			tagsSplitDeduplication: outputOptions.tagsSplitDeduplication ?? false,
+			commonTypesFileName: outputOptions.commonTypesFileName ?? "common-types",
 			override: {
 				...outputOptions.override,
 				mock: {
@@ -1027,8 +1057,8 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 					fractionDigits: outputOptions.override?.mock?.fractionDigits ?? 2,
 					...outputOptions.override?.mock
 				},
-				operations: normalizeOperationsAndTags(outputOptions.override?.operations ?? {}, outputWorkspace, { query: globalQueryOptions }),
-				tags: normalizeOperationsAndTags(outputOptions.override?.tags ?? {}, outputWorkspace, { query: globalQueryOptions }),
+				operations: normalizeOperationsAndTags(outputOptions.override?.operations ?? {}, outputWorkspace, { query: globalQueryOptions }, "operations"),
+				tags: normalizeOperationsAndTags(outputOptions.override?.tags ?? {}, outputWorkspace, { query: globalQueryOptions }, "tags"),
 				mutator: normalizeMutator(outputWorkspace, outputOptions.override?.mutator),
 				formData: createFormData(outputWorkspace, outputOptions.override?.formData),
 				formUrlEncoded: (isBoolean(outputOptions.override?.formUrlEncoded) ? outputOptions.override.formUrlEncoded : normalizeMutator(outputWorkspace, outputOptions.override?.formUrlEncoded)) ?? true,
@@ -1090,6 +1120,8 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 						...outputOptions.override?.zod?.preprocess?.response ? { response: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.response) } : {}
 					},
 					...outputOptions.override?.zod?.params ? { params: normalizeMutator(outputWorkspace, outputOptions.override.zod.params) } : {},
+					variant: outputOptions.override?.zod?.variant ?? "classic",
+					version: outputOptions.override?.zod?.version ?? "auto",
 					generateEachHttpStatus: outputOptions.override?.zod?.generateEachHttpStatus ?? false,
 					useBrandedTypes: outputOptions.override?.zod?.useBrandedTypes ?? false,
 					generateReusableSchemas: outputOptions.override?.zod?.generateReusableSchemas ?? false,
@@ -1113,6 +1145,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 					forceSuccessResponse: outputOptions.override?.fetch?.forceSuccessResponse ?? false,
 					runtimeValidation: outputOptions.override?.fetch?.runtimeValidation ?? false,
 					useRuntimeFetcher: outputOptions.override?.fetch?.useRuntimeFetcher ?? false,
+					...outputOptions.override?.fetch?.arrayFormat ? { arrayFormat: outputOptions.override.fetch.arrayFormat } : {},
 					...outputOptions.override?.fetch,
 					...outputOptions.override?.fetch?.jsonReviver ? { jsonReviver: normalizeMutator(outputWorkspace, outputOptions.override.fetch.jsonReviver) } : {}
 				},
@@ -1153,8 +1186,10 @@ function normalizeMutator(workspace, mutator) {
 	if (isObject(mutator)) {
 		const m = mutator;
 		if (!m.path) throw new Error(styleText("red", `Mutator requires a path.`));
+		const resolvedPath = looksLikePackageSpecifier(m.path) ? resolvePackageSpecifier(workspace, m.path) : void 0;
 		return {
-			path: path.resolve(workspace, m.path),
+			path: !!resolvedPath || isPackageSpecifierCandidate(workspace, m.path) ? m.path : path.resolve(workspace, m.path),
+			...resolvedPath ? { resolvedPath } : {},
 			name: m.name,
 			default: m.default ?? !m.name,
 			alias: m.alias,
@@ -1162,10 +1197,14 @@ function normalizeMutator(workspace, mutator) {
 			extension: m.extension
 		};
 	}
-	if (isString(mutator)) return {
-		path: path.resolve(workspace, mutator),
-		default: true
-	};
+	if (isString(mutator)) {
+		const resolvedPath = looksLikePackageSpecifier(mutator) ? resolvePackageSpecifier(workspace, mutator) : void 0;
+		return {
+			path: !!resolvedPath || isPackageSpecifierCandidate(workspace, mutator) ? mutator : path.resolve(workspace, mutator),
+			...resolvedPath ? { resolvedPath } : {},
+			default: true
+		};
+	}
 }
 async function resolveFirstValidTarget(targets, workspace, parserOptions) {
 	for (const target of targets) {
@@ -1227,8 +1266,20 @@ function normalizePath(path$1, workspace) {
 	if (!isString(path$1)) return path$1;
 	return path.resolve(workspace, path$1);
 }
-function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
+function normalizeOperationsAndTags(operationsOrTags, workspace, global, source) {
+	const unsupportedZodKeys = [
+		"version",
+		"variant",
+		"dateTimeOptions",
+		"timeOptions",
+		"generateEachHttpStatus",
+		"generateReusableSchemas",
+		"generateMeta"
+	];
 	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, paramsFilter, query, angular, zod, effect, ...rest }]) => {
+		const unsupportedOperationZodKeys = zod && unsupportedZodKeys.filter((unsupportedKey) => zod[unsupportedKey] !== void 0);
+		if (unsupportedOperationZodKeys && unsupportedOperationZodKeys.length) logWarning(`⚠️  override.${source}.${key}.zod only supports strict, generate, coerce, preprocess, params, and useBrandedTypes. Ignoring unsupported ${unsupportedOperationZodKeys.length === 1 ? "field" : "fields"}: ${unsupportedOperationZodKeys.map((unsupportedKey) => `zod.${unsupportedKey}`).join(", ")}.`);
+		const hasSupportedOperationZodConfig = !!zod && (zod.strict !== void 0 || zod.generate !== void 0 || zod.coerce !== void 0 || zod.preprocess !== void 0 || zod.params !== void 0 || zod.useBrandedTypes !== void 0);
 		return [key, {
 			...rest,
 			...angular ? { angular: {
@@ -1238,7 +1289,7 @@ function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
 				...angular.httpResource ? { httpResource: angular.httpResource } : {}
 			} } : {},
 			...query ? { query: normalizeQueryOptions(query, workspace, global.query) } : {},
-			...zod ? { zod: {
+			...hasSupportedOperationZodConfig && zod ? { zod: {
 				strict: {
 					param: zod.strict?.param ?? false,
 					query: zod.strict?.query ?? false,
@@ -1268,12 +1319,7 @@ function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
 					...zod.preprocess?.response ? { response: normalizeMutator(workspace, zod.preprocess.response) } : {}
 				},
 				...zod.params ? { params: normalizeMutator(workspace, zod.params) } : {},
-				generateEachHttpStatus: zod.generateEachHttpStatus ?? false,
-				useBrandedTypes: zod.useBrandedTypes ?? false,
-				generateReusableSchemas: zod.generateReusableSchemas ?? false,
-				generateMeta: zod.generateMeta ?? false,
-				dateTimeOptions: zod.dateTimeOptions ?? { offset: true },
-				timeOptions: zod.timeOptions ?? {}
+				useBrandedTypes: zod.useBrandedTypes ?? false
 			} } : {},
 			...effect ? { effect: normalizeEffectOptions(effect) } : {},
 			...transformer ? { transformer: normalizePath(transformer, workspace) } : {},
@@ -1480,13 +1526,14 @@ const generateReusableSchemaSet = (refs, context, options) => {
 			operationId: "",
 			location: "schema",
 			schemaName: name
-		} : void 0);
+		} : void 0, options.variant);
 		entries.push({
 			ref,
 			name,
 			zod: parsed.zod,
 			consts: parsed.consts,
-			usedRefs: parsed.usedRefs
+			usedRefs: parsed.usedRefs,
+			variant: options.variant
 		});
 		for (const usedName of parsed.usedRefs) {
 			const usedRef = nameToRef.get(usedName);
@@ -1582,7 +1629,7 @@ const rewriteReusableSchemas = (entries) => {
 	else if (lazyEdges.has(edgeKey(scc[0], scc[0]))) recursiveNames.add(scc[0]);
 	const rewritten = new Map(entries.map((entry) => {
 		const newZod = entry.zod.replaceAll(SENTINEL_PATTERN, (_match, refName) => {
-			return lazyEdges.has(edgeKey(entry.name, refName)) ? `zod.lazy(() => ${refName})` : refName;
+			return lazyEdges.has(edgeKey(entry.name, refName)) ? `${entry.variant === "mini" ? "/*#__PURE__*/ " : ""}zod.lazy(() => ${refName})` : refName;
 		});
 		return [entry.name, {
 			...entry,
@@ -1599,6 +1646,7 @@ const rewriteReusableSchemas = (entries) => {
 };
 //#endregion
 //#region src/write-zod-specs.ts
+const getZodSchemaImportStatement = (variant) => variant === "mini" ? `import * as zod from '${getZodImportSource(variant)}';` : `import { z as zod } from '${getZodImportSource(variant)}';`;
 /**
 * Render the `import { ... } from '...'` line for a resolved
 * `GeneratorMutator`. Mirrors the format produced by
@@ -1608,6 +1656,23 @@ const rewriteReusableSchemas = (entries) => {
 function buildMutatorImportStatement(mutator) {
 	return `import ${mutator.default ? mutator.name : `{ ${mutator.name} }`} from '${mutator.path}';`;
 }
+const ROOT_DIR = ".";
+function getSchemaDir(schemaTagMap, name) {
+	return schemaTagMap?.get(name) ?? ROOT_DIR;
+}
+function computeCrossDirImportPath(schemasPath, fromDir, toDir, fileName, importExt) {
+	if (fromDir === toDir) return `./${fileName}${importExt}`;
+	const fromPath = fromDir === ROOT_DIR ? schemasPath : path.join(schemasPath, fromDir);
+	const toPath = toDir === ROOT_DIR ? schemasPath : path.join(schemasPath, toDir);
+	const relDir = upath.relativeSafe(fromPath, toPath);
+	return `${upath.joinSafe(relDir, fileName)}${importExt}`;
+}
+function adjustMutatorPathForDir(mutatorPath, tagDir) {
+	if (tagDir === ROOT_DIR) return mutatorPath;
+	if (mutatorPath.startsWith("./")) return `../${mutatorPath.slice(2)}`;
+	if (mutatorPath.startsWith("../")) return `../${mutatorPath}`;
+	return mutatorPath;
+}
 /**
 * Whole-word substring check for a resolved mutator alias inside generated
 * code. Plain `String.includes` would false-positive when the user names the
@@ -1616,9 +1681,9 @@ function buildMutatorImportStatement(mutator) {
 function bodyReferencesMutator(body, mutator) {
 	return new RegExp(String.raw`\b${mutator.name}\b`).test(body);
 }
-function generateZodSchemaFileContent(header, schemas, includeZodImport = true) {
+function generateZodSchemaFileContent(header, schemas, zodVariant, includeZodImport = true) {
 	const refImports = [...new Set(schemas.flatMap((s) => s.importStatements ?? []))].toSorted();
-	const importBlock = [...includeZodImport ? [`import { z as zod } from 'zod';`] : [], ...refImports].join("\n");
+	const importBlock = [...includeZodImport ? [getZodSchemaImportStatement(zodVariant)] : [], ...refImports].join("\n");
 	const schemaContent = schemas.map(({ schemaName, consts, zodExpression }) => {
 		return `${consts ? `${consts}\n` : ""}export const ${schemaName} = ${zodExpression}
 
@@ -1627,7 +1692,7 @@ export type ${schemaName}Output = zod.output<typeof ${schemaName}>;`;
 	}).join("\n\n");
 	return `${header}${importBlock ? `${importBlock}\n\n` : ""}${schemaContent}\n`;
 }
-function renderReusableSchemaEntry(entry, context) {
+function renderReusableSchemaEntry(entry, context, zodVariant) {
 	const consts = entry.consts ? `${entry.consts}\n\n` : "";
 	if (entry.isRecursive) {
 		const rawName = isComponentRef(entry.ref) ? getRefInfo(entry.ref, context).originalName : void 0;
@@ -1638,10 +1703,18 @@ function renderReusableSchemaEntry(entry, context) {
 			context
 		}) : void 0;
 		const typeBody = resolved ? resolved.value : "unknown";
+		const seenSubModels = /* @__PURE__ */ new Set();
+		const subModels = (resolved?.schemas ?? []).filter((s) => {
+			if (seenSubModels.has(s.name)) return false;
+			seenSubModels.add(s.name);
+			return true;
+		});
+		const subModelBlock = subModels.length ? `${subModels.map((s) => s.model.trimEnd()).join("\n")}\n\n` : "";
+		const localNames = new Set(subModels.map((s) => s.name));
 		const seen = /* @__PURE__ */ new Set();
 		const extraImports = [];
 		for (const imp of resolved?.imports ?? []) {
-			if (!imp.name || imp.name === entry.name) continue;
+			if (!imp.name || imp.name === entry.name || localNames.has(imp.name)) continue;
 			const bindingKey = imp.alias ?? imp.name;
 			if (seen.has(bindingKey)) continue;
 			seen.add(bindingKey);
@@ -1651,7 +1724,7 @@ function renderReusableSchemaEntry(entry, context) {
 			});
 		}
 		return {
-			content: `${consts}export type ${entry.name} = ${typeBody};\n\nexport const ${entry.name}: zod.ZodType<${entry.name}> = ${entry.zod};\n\nexport type ${entry.name}Output = zod.output<typeof ${entry.name}>;`,
+			content: `${consts}${subModelBlock}export type ${entry.name} = ${typeBody};\n\nexport const ${entry.name}: zod.${getZodTypeName(zodVariant)}<${entry.name}> = ${entry.zod};\n\nexport type ${entry.name}Output = zod.output<typeof ${entry.name}>;`,
 			extraImports
 		};
 	}
@@ -1677,7 +1750,7 @@ const isValidSchemaIdentifier = (name) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
 * `resolveValue` producer surfaces aliases here today, so the integration
 * tests can't exercise it.
 */
-function buildSiblingImports({ usedRefs, extraImports, entryName, componentNames, namingConvention, importExt }) {
+function buildSiblingImports({ usedRefs, extraImports, entryName, componentNames, namingConvention, importExt, schemaTagMap, currentDir, schemasPath }) {
 	const importsByName = /* @__PURE__ */ new Map();
 	for (const name of usedRefs) {
 		if (name === entryName) continue;
@@ -1689,7 +1762,7 @@ function buildSiblingImports({ usedRefs, extraImports, entryName, componentNames
 	}
 	return [...importsByName.values()].toSorted((a, b) => a.name.localeCompare(b.name)).map(({ name, alias }) => {
 		const importedFile = conventionName(name, namingConvention);
-		return `import { ${alias ? `${name} as ${alias}` : name} } from './${importedFile}${importExt}';`;
+		return `import { ${alias ? `${name} as ${alias}` : name} } from '${schemaTagMap && currentDir && schemasPath ? computeCrossDirImportPath(schemasPath, currentDir, getSchemaDir(schemaTagMap, name), importedFile, importExt) : `./${importedFile}${importExt}`}';`;
 	}).join("\n");
 }
 const isPrimitiveSchemaName = (name) => [
@@ -1732,11 +1805,38 @@ async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNam
 	const uniqueExports = [...new Set(allExports.split("\n"))].filter((line) => line.trim()).toSorted().join("\n");
 	await fs.outputFile(indexPath, `${header}\n${uniqueExports}\n`);
 }
+async function writeZodSchemaTagsSplitBarrel(schemasPath, fileExtension, header, componentDirs, verbDirs, namingConvention, tsconfig) {
+	const importExt = getImportExtension(fileExtension, tsconfig);
+	const indexImportExt = getImportExtension(".ts", tsconfig);
+	const allDirs = /* @__PURE__ */ new Map();
+	for (const [dir, names] of componentDirs) allDirs.set(dir, [...names]);
+	for (const [dir, names] of verbDirs) if (allDirs.has(dir)) allDirs.get(dir).push(...names);
+	else allDirs.set(dir, [...names]);
+	for (const [dir, schemaNames] of allDirs) {
+		if (dir === ROOT_DIR) continue;
+		await writeZodSchemaIndex(path.join(schemasPath, dir), fileExtension, header, schemaNames, namingConvention, false, tsconfig);
+	}
+	const rootSchemas = allDirs.get(ROOT_DIR) ?? [];
+	const rootExports = [...new Set(rootSchemas)].map((name) => {
+		return `export * from './${conventionName(name, namingConvention)}${importExt}';`;
+	}).toSorted();
+	const tagExports = [...allDirs.keys()].filter((dir) => dir !== ROOT_DIR).toSorted((a, b) => a.localeCompare(b, "en", { numeric: true })).map((dir) => {
+		return `export * from '${indexImportExt ? `./${dir}/index${indexImportExt}` : `./${dir}`}';`;
+	});
+	const allExports = [...rootExports, ...tagExports];
+	const rootIndexPath = path.join(schemasPath, "index.ts");
+	const content = `${header}\n${allExports.join("\n")}\n`;
+	await fs.outputFile(rootIndexPath, content);
+}
 function generateZodSchemasInline(builder, output, includeZodImport = true, paramsMutator, includeParamsImport = false) {
 	if (output.override.zod.generateReusableSchemas === true) return generateZodSchemasInlineReusable(builder, output, includeZodImport, paramsMutator, includeParamsImport);
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
 	if (schemasWithOpenApiDef.length === 0) return "";
-	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const schemas = [];
@@ -1751,7 +1851,7 @@ function generateZodSchemasInline(builder, output, includeZodImport = true, para
 		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, {
 			required: true,
 			emitMeta: output.override.zod.generateMeta
-		}), context, coerce, strict, isZodV4);
+		}), context, coerce, strict, isZodV4, void 0, void 0, output.override.zod.variant);
 		schemas.push({
 			schemaName: name,
 			consts: parsedZodDefinition.consts,
@@ -1759,10 +1859,14 @@ function generateZodSchemasInline(builder, output, includeZodImport = true, para
 		});
 	}
 	if (schemas.length === 0) return "";
-	return generateZodSchemaFileContent("", schemas, includeZodImport);
+	return generateZodSchemaFileContent("", schemas, output.override.zod.variant, includeZodImport);
 }
 function generateZodSchemasInlineReusable(builder, output, includeZodImport = true, paramsMutator, includeParamsImport = false) {
-	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const context = {
@@ -1779,28 +1883,32 @@ function generateZodSchemasInlineReusable(builder, output, includeZodImport = tr
 		strict,
 		isZodV4,
 		coerce,
+		variant: output.override.zod.variant,
 		generateMeta: output.override.zod.generateMeta,
 		paramsMutator
-	})).map((entry) => renderReusableSchemaEntry(entry, context).content).join("\n\n");
-	const zodImport = includeZodImport ? `import { z as zod } from 'zod';\n` : "";
+	})).map((entry) => renderReusableSchemaEntry(entry, context, output.override.zod.variant).content).join("\n\n");
+	const zodImport = includeZodImport ? `${getZodSchemaImportStatement(output.override.zod.variant)}\n` : "";
 	const paramsImport = paramsMutator && includeParamsImport && bodyReferencesMutator(body, paramsMutator) ? `${buildMutatorImportStatement(paramsMutator)}\n` : "";
 	return `${zodImport || paramsImport ? `${zodImport}${paramsImport}\n` : ""}${body}\n`;
 }
-async function writeZodSchemas(builder, schemasPath, fileExtension, header, output, paramsMutator) {
-	if (output.override.zod.generateReusableSchemas) {
-		await writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator);
-		return;
-	}
+async function writeZodSchemas(builder, schemasPath, fileExtension, header, output, paramsMutator, schemaTagMap) {
+	if (output.override.zod.generateReusableSchemas) return writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator, schemaTagMap);
+	const isSplit = !!schemaTagMap;
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
 	const schemasToWrite = [];
-	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	for (const generatorSchema of schemasWithOpenApiDef) {
 		const { name, schema: schemaObject } = generatorSchema;
 		if (!schemaObject) continue;
 		const fileName = conventionName(name, output.namingConvention);
-		const filePath = path.join(schemasPath, `${fileName}${fileExtension}`);
+		const tagDir = getSchemaDir(schemaTagMap, name);
+		const filePath = isSplit ? path.join(schemasPath, tagDir, `${fileName}${fileExtension}`) : path.join(schemasPath, `${fileName}${fileExtension}`);
 		const context = {
 			spec: builder.spec,
 			target: builder.target,
@@ -1810,7 +1918,7 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, {
 			required: true,
 			emitMeta: output.override.zod.generateMeta
-		}), context, coerce, strict, isZodV4);
+		}), context, coerce, strict, isZodV4, void 0, void 0, output.override.zod.variant);
 		schemasToWrite.push({
 			schemaName: name,
 			filePath,
@@ -1820,13 +1928,29 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 	}
 	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
 	for (const schemaGroup of groupedSchemasToWrite) {
-		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
+		const fileContent = generateZodSchemaFileContent(header, schemaGroup, output.override.zod.variant);
 		await fs.outputFile(schemaGroup[0].filePath, fileContent);
 	}
-	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, false, output.tsconfig);
+	const writtenSchemaNames = groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName);
+	if (output.indexFiles && !isSplit) await writeZodSchemaIndex(schemasPath, fileExtension, header, writtenSchemaNames, output.namingConvention, false, output.tsconfig);
+	if (isSplit) {
+		const dirSchemas = /* @__PURE__ */ new Map();
+		for (const name of writtenSchemaNames) {
+			const dir = getSchemaDir(schemaTagMap, name);
+			if (!dirSchemas.has(dir)) dirSchemas.set(dir, []);
+			dirSchemas.get(dir).push(name);
+		}
+		return dirSchemas;
+	}
+	return new Map([[ROOT_DIR, writtenSchemaNames]]);
 }
-async function writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator) {
-	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+async function writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator, schemaTagMap) {
+	const isSplit = !!schemaTagMap;
+	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const context = {
@@ -1842,35 +1966,60 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 		strict,
 		isZodV4,
 		coerce,
+		variant: output.override.zod.variant,
 		generateMeta: output.override.zod.generateMeta,
 		paramsMutator
 	}));
 	const componentNames = new Set(Object.keys(builder.spec.components?.schemas ?? {}).map((schemaName) => resolveSchemaName(`#/components/schemas/${schemaName}`, context)));
-	const paramsMutatorImport = paramsMutator ? buildMutatorImportStatement(paramsMutator) : void 0;
 	for (const entry of rewritten) {
 		const fileName = conventionName(entry.name, output.namingConvention);
-		const filePath = path.join(schemasPath, `${fileName}${fileExtension}`);
+		const tagDir = getSchemaDir(schemaTagMap, entry.name);
+		const filePath = isSplit ? path.join(schemasPath, tagDir, `${fileName}${fileExtension}`) : path.join(schemasPath, `${fileName}${fileExtension}`);
 		const importExt = getImportExtension(fileExtension, output.tsconfig);
-		const rendered = renderReusableSchemaEntry(entry, context);
+		const rendered = renderReusableSchemaEntry(entry, context, output.override.zod.variant);
 		const refImports = buildSiblingImports({
 			usedRefs: entry.usedRefs,
 			extraImports: rendered.extraImports,
 			entryName: entry.name,
 			componentNames,
 			namingConvention: output.namingConvention,
-			importExt
+			importExt,
+			...isSplit ? {
+				schemaTagMap,
+				currentDir: tagDir,
+				schemasPath
+			} : {}
 		});
-		const imports = [...!!paramsMutator && bodyReferencesMutator(entry.zod, paramsMutator) && paramsMutatorImport ? [paramsMutatorImport] : [], ...refImports ? [refImports] : []].join("\n");
-		const fileContent = `${header}import { z as zod } from 'zod';\n` + (imports ? `${imports}\n\n` : "\n") + `${rendered.content}\n`;
+		const mutatorImportStr = !!paramsMutator && bodyReferencesMutator(entry.zod, paramsMutator) ? buildMutatorImportStatement({
+			...paramsMutator,
+			path: isSplit ? adjustMutatorPathForDir(paramsMutator.path, tagDir) : paramsMutator.path
+		}) : void 0;
+		const imports = [...mutatorImportStr ? [mutatorImportStr] : [], ...refImports ? [refImports] : []].join("\n");
+		const fileContent = `${header}${getZodSchemaImportStatement(output.override.zod.variant)}\n` + (imports ? `${imports}\n\n` : "\n") + `${rendered.content}\n`;
 		await fs.outputFile(filePath, fileContent);
 	}
-	if (output.indexFiles && rewritten.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, rewritten.map((e) => e.name), output.namingConvention, true, output.tsconfig);
+	if (output.indexFiles && !isSplit && rewritten.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, rewritten.map((e) => e.name), output.namingConvention, true, output.tsconfig);
+	if (isSplit) {
+		const dirSchemas = /* @__PURE__ */ new Map();
+		for (const entry of rewritten) {
+			const dir = getSchemaDir(schemaTagMap, entry.name);
+			if (!dirSchemas.has(dir)) dirSchemas.set(dir, []);
+			dirSchemas.get(dir).push(entry.name);
+		}
+		return dirSchemas;
+	}
+	return new Map([[ROOT_DIR, rewritten.map((e) => e.name)]]);
 }
-async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension, header, output, context) {
+async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension, header, output, context, schemaTagMap) {
+	const isSplit = !!schemaTagMap;
 	const zodContext = context;
 	const verbOptionsArray = Object.values(verbOptions);
-	if (verbOptionsArray.length === 0) return;
-	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	if (verbOptionsArray.length === 0) return /* @__PURE__ */ new Map();
+	const isZodV4 = resolveIsZodV4(output.override.zod.version, output.packageJson);
+	assertZodTarget({
+		variant: output.override.zod.variant,
+		isZodV4
+	});
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const useReusableSchemas = output.override.zod.generateReusableSchemas === true;
@@ -1932,25 +2081,30 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 			...queryParamsSchemas,
 			...headerParamsSchemas,
 			...responseSchemas
-		]);
+		]).map((s) => ({
+			...s,
+			verbTagDir: isSplit ? kebab(verbOption.tags?.[0] ?? DefaultTag) : ROOT_DIR
+		}));
 	}));
 	const schemasToWrite = [];
 	for (const entry of uniqueVerbsSchemas) {
 		if (useReusableSchemas && entry.schema && typeof entry.schema.$ref === "string" && Object.keys(entry.schema).length === 1) continue;
 		const { name, schema } = entry;
 		const fileName = conventionName(name, output.namingConvention);
-		const filePath = path.join(schemasPath, `${fileName}${fileExtension}`);
+		const tagDir = entry.verbTagDir ?? ROOT_DIR;
+		const filePath = isSplit ? path.join(schemasPath, tagDir, `${fileName}${fileExtension}`) : path.join(schemasPath, `${fileName}${fileExtension}`);
 		const parsedZodDefinition = parseZodValidationSchemaDefinition("bodyContentType" in entry && entry.bodyContentType === "multipart/form-data" ? generateFormDataZodSchema(schema, zodContext, name, strict, isZodV4, "encoding" in entry ? entry.encoding : void 0, useReusableSchemas) : generateZodValidationSchemaDefinition(schema, zodContext, name, strict, isZodV4, {
 			required: true,
 			useReusableSchemas
-		}), zodContext, coerce, strict, isZodV4);
+		}), zodContext, coerce, strict, isZodV4, void 0, void 0, output.override.zod.variant);
 		let zodExpression = parsedZodDefinition.zod;
 		let importStatements;
 		if (useReusableSchemas && parsedZodDefinition.usedRefs.size > 0) {
 			zodExpression = rewriteSentinelsToDirect(zodExpression);
 			const importExt = getImportExtension(fileExtension, output.tsconfig);
 			importStatements = [...parsedZodDefinition.usedRefs].filter((refName) => refName !== name).toSorted().map((refName) => {
-				return `import { ${refName} } from './${conventionName(refName, output.namingConvention)}${importExt}';`;
+				const importedFile = conventionName(refName, output.namingConvention);
+				return `import { ${refName} } from '${isSplit ? computeCrossDirImportPath(schemasPath, tagDir, getSchemaDir(schemaTagMap, refName), importedFile, importExt) : `./${importedFile}${importExt}`}';`;
 			});
 		}
 		schemasToWrite.push({
@@ -1963,10 +2117,22 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 	}
 	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
 	for (const schemaGroup of groupedSchemasToWrite) {
-		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
+		const fileContent = generateZodSchemaFileContent(header, schemaGroup, output.override.zod.variant);
 		await fs.outputFile(schemaGroup[0].filePath, fileContent);
 	}
-	if (output.indexFiles && uniqueVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, true, output.tsconfig);
+	const writtenSchemaNames = groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName);
+	if (output.indexFiles && !isSplit && uniqueVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, writtenSchemaNames, output.namingConvention, true, output.tsconfig);
+	if (isSplit) {
+		const dirSchemas = /* @__PURE__ */ new Map();
+		for (const entry of uniqueVerbsSchemas) {
+			if (useReusableSchemas && entry.schema && typeof entry.schema.$ref === "string" && Object.keys(entry.schema).length === 1) continue;
+			const dir = entry.verbTagDir ?? ROOT_DIR;
+			if (!dirSchemas.has(dir)) dirSchemas.set(dir, []);
+			dirSchemas.get(dir).push(entry.name);
+		}
+		return dirSchemas;
+	}
+	return new Map([[ROOT_DIR, writtenSchemaNames]]);
 }
 //#endregion
 //#region src/write-specs.ts
@@ -1998,6 +2164,23 @@ async function runFormatter(formatter, paths, projectTitle) {
 			break;
 	}
 }
+function getComparableFilePath(filePath) {
+	const resolvedPath = path.resolve(filePath);
+	let comparablePath = resolvedPath;
+	try {
+		comparablePath = fs.realpathSync(resolvedPath);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	return process.platform === "win32" || process.platform === "darwin" ? comparablePath.toLowerCase() : comparablePath;
+}
+function excludeFilePath(filePaths, filePathToExclude) {
+	const comparablePathToExclude = getComparableFilePath(filePathToExclude);
+	return filePaths.map((filePath) => ({
+		filePath,
+		comparablePath: getComparableFilePath(filePath)
+	})).filter(({ comparablePath }) => comparablePath !== comparablePathToExclude).map(({ filePath }) => filePath);
+}
 function getHeader(option, info) {
 	if (!option) return "";
 	const header = option(info);
@@ -2031,7 +2214,7 @@ async function addOperationSchemasReExport(schemaPath, operationSchemasPath, hea
 * file path so callers can include it in formatter / hook runs, or
 * `undefined` if no file was written.
 */
-async function writeFakerSchemaMocks(builder, options, header) {
+async function writeFakerSchemaMocks(builder, options, header, schemaTagMap) {
 	const { output } = options;
 	const fakerEntry = output.mock.generators.find((g) => !isFunction(g) && g.type === OutputMockType.FAKER && g.schemas === true);
 	if (!fakerEntry) return;
@@ -2062,9 +2245,32 @@ async function writeFakerSchemaMocks(builder, options, header) {
 		filePath = path.join(dir, `schemas.faker${fileExtension}`);
 		schemaImportPath = targetInfo ? `./${targetInfo.filename}${getImportExtension(fileExtension, output.tsconfig)}` : void 0;
 	}
-	const reroutedImports = imports.map((imp) => imp.importPath ? imp : {
-		...imp,
-		importPath: schemaImportPath
+	const isZodSchemaOutput = isObject(output.schemas) && output.schemas.type === "zod";
+	const importExtension = getImportExtension(fileExtension, output.tsconfig);
+	const schemaSuffix = isZodSchemaOutput ? ".zod" : "";
+	const perSchemaImportPath = /* @__PURE__ */ new Map();
+	if (schemaImportPath === "." && !output.indexFiles && isObject(output.schemas)) for (const schema of builder.schemas) {
+		const tsName = pascal(schema.name);
+		const fileName = conventionName(schema.name, output.namingConvention);
+		const tagDir = schemaTagMap?.get(schema.name);
+		const tagSegment = tagDir && tagDir !== "." ? `${tagDir}/` : "";
+		perSchemaImportPath.set(tsName, `./${tagSegment}${fileName}${schemaSuffix}${importExtension}`);
+	}
+	const reroutedImports = imports.map((imp) => {
+		if (imp.importPath) return imp;
+		if (imp.schemaFactory) return {
+			...imp,
+			importPath: "."
+		};
+		const resolved = perSchemaImportPath.get(imp.name);
+		if (resolved) return {
+			...imp,
+			importPath: resolved
+		};
+		return {
+			...imp,
+			importPath: schemaImportPath
+		};
 	});
 	const grouped = /* @__PURE__ */ new Map();
 	for (const imp of reroutedImports) {
@@ -2098,31 +2304,72 @@ function shouldGenerateZodSchemasInline(output, hasOperations) {
 function shouldGenerateSchemas(output, hasOperations) {
 	return !output.schemas && !isSchemaValidatorClient(output.client) || shouldGenerateZodSchemasInline(output, hasOperations);
 }
+function getImplementationPathsForIndex(output, implementationPaths, indexFile) {
+	const shouldExcludeSelf = output.indexFiles;
+	const paths = shouldExcludeSelf ? excludeFilePath(implementationPaths, indexFile) : implementationPaths;
+	if (!(shouldExcludeSelf && output.mode === OutputMode.SPLIT && getComparableFilePath(output.target) === getComparableFilePath(indexFile))) return paths;
+	const targetInfo = getFileInfo(output.target, { extension: output.fileExtension });
+	return excludeFilePath(paths, path.join(targetInfo.dirname, `${targetInfo.filename}.schemas${output.fileExtension}`));
+}
 async function writeSpecs(builder, workspace, options, projectName) {
 	const { info, schemas, target } = builder;
 	const { output } = options;
+	const shouldSplitSchemasByTags = isObject(output.schemas) && output.schemas.splitByTags;
+	const schemaTagMap = shouldSplitSchemasByTags ? buildSchemaTagMap(Object.values(builder.operations).map((op) => ({
+		imports: op.imports,
+		tags: op.tags
+	})), schemas) : void 0;
 	const projectTitle = projectName ?? info.title;
 	const header = getHeader(output.override.header, info);
 	if (output.schemas) {
 		const schemasPath = isString(output.schemas) ? output.schemas : output.schemas.path;
-		if (!isString(output.schemas) && output.schemas.type === "zod" || isString(output.schemas) && output.client === "zod" && output.override.zod.generateReusableSchemas) {
+		const isZodSchemas = !isString(output.schemas) && output.schemas.type === "zod" || isString(output.schemas) && output.client === "zod" && output.override.zod.generateReusableSchemas;
+		if (shouldSplitSchemasByTags && output.operationSchemas) throw new Error("schemas.splitByTags cannot be used with output.operationSchemas. The tags-split schema mode handles operation type placement within tag directories.");
+		if (isZodSchemas) {
 			const fileExtension = output.schemaFileExtension;
-			await writeZodSchemas(builder, schemasPath, fileExtension, header, output, output.override.zod.params ? await generateMutator({
+			const schemasParamsMutator = output.override.zod.params ? await generateMutator({
 				output: path.join(schemasPath, `__params__${fileExtension}`),
 				mutator: output.override.zod.params,
 				name: "zodParams",
 				workspace,
 				tsconfig: output.tsconfig
-			}) : void 0);
-			await writeZodSchemasFromVerbs(builder.verbOptions, schemasPath, fileExtension, header, output, {
-				spec: builder.spec,
-				target: builder.target,
-				workspace,
-				output
-			});
+			}) : void 0;
+			if (shouldSplitSchemasByTags) {
+				const componentDirs = await writeZodSchemas(builder, schemasPath, fileExtension, header, output, schemasParamsMutator, schemaTagMap);
+				const verbDirs = await writeZodSchemasFromVerbs(builder.verbOptions, schemasPath, fileExtension, header, output, {
+					spec: builder.spec,
+					target: builder.target,
+					workspace,
+					output
+				}, schemaTagMap);
+				if (output.indexFiles) await writeZodSchemaTagsSplitBarrel(schemasPath, fileExtension, header, componentDirs, verbDirs, output.namingConvention, output.tsconfig);
+			} else {
+				await writeZodSchemas(builder, schemasPath, fileExtension, header, output, schemasParamsMutator);
+				await writeZodSchemasFromVerbs(builder.verbOptions, schemasPath, fileExtension, header, output, {
+					spec: builder.spec,
+					target: builder.target,
+					workspace,
+					output
+				});
+			}
 		} else {
 			const fileExtension = output.fileExtension || ".ts";
-			if (output.operationSchemas) {
+			if (shouldSplitSchemasByTags) await writeSchemasTagsSplit({
+				schemaPath: schemasPath,
+				schemas,
+				target,
+				namingConvention: output.namingConvention,
+				fileExtension,
+				header,
+				indexFiles: output.indexFiles,
+				tsconfig: output.tsconfig,
+				factoryOutputDirectory: output.factoryMethods?.outputDirectory,
+				operations: Object.values(builder.operations).map((op) => ({
+					imports: op.imports,
+					tags: op.tags
+				}))
+			});
+			else if (output.operationSchemas) {
 				const { regularSchemas, operationSchemas: opSchemas } = splitSchemasByType(schemas);
 				const regularSchemaNames = new Set(regularSchemas.map((s) => s.name));
 				const operationSchemaNames = new Set(opSchemas.map((s) => s.name));
@@ -2166,7 +2413,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 			});
 		}
 	}
-	const fakerSchemaPath = await writeFakerSchemaMocks(builder, options, header);
+	const fakerSchemaPath = await writeFakerSchemaMocks(builder, options, header, schemaTagMap);
 	let implementationPaths = [];
 	if (output.target) {
 		const writeMode = getWriteMode(output.mode);
@@ -2189,6 +2436,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 			projectName,
 			header,
 			needSchema: shouldGenerateSchemas(output, hasOperations),
+			schemaTagMap,
 			generateSchemasInline: needZodSchemasInline ? () => generateZodSchemasInline(builder, output, includeZodImport, inlineSchemasParamsMutator, includeParamsImport) : void 0
 		});
 	}
@@ -2197,7 +2445,8 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		const indexFile = path.join(workspacePath, "index.ts");
 		const mockExtensions = output.mock.generators.map((g) => getMockFileExtensionByTypeName(g));
 		const importExtension = getImportExtension(output.fileExtension, output.tsconfig);
-		const imports = implementationPaths.filter((p) => mockExtensions.length === 0 || !mockExtensions.some((ext) => p.endsWith(`.${ext}.ts`))).map((p) => {
+		const implementationPathsForIndex = getImplementationPathsForIndex(output, implementationPaths, indexFile);
+		const imports = implementationPathsForIndex.filter((p) => mockExtensions.length === 0 || !mockExtensions.some((ext) => p.endsWith(`.${ext}.ts`))).map((p) => {
 			const relative = upath.getRelativeImportPath(indexFile, p, true);
 			return (relative.endsWith(output.fileExtension) ? relative.slice(0, -output.fileExtension.length) : relative.replace(/\.[^/.]+$/, "")) + importExtension;
 		});
@@ -2209,10 +2458,10 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		if (output.indexFiles) {
 			if (await fs.pathExists(indexFile)) {
 				const data = await fs.readFile(indexFile, "utf8");
-				const importsNotDeclared = imports.filter((imp) => !data.includes(imp));
+				const importsNotDeclared = imports.filter((imp) => !data.includes(`export * from '${imp}'`));
 				await fs.appendFile(indexFile, unique(importsNotDeclared).map((imp) => `export * from '${imp}';\n`).join(""));
 			} else await fs.outputFile(indexFile, unique(imports).map((imp) => `export * from '${imp}';`).join("\n") + "\n");
-			implementationPaths = [indexFile, ...implementationPaths];
+			implementationPaths = [indexFile, ...implementationPathsForIndex];
 		}
 	}
 	if (builder.extraFiles.length > 0) {
@@ -2352,4 +2601,4 @@ async function loadConfigFile(configFilePath) {
 //#endregion
 export { defineConfig as a, description as c, startWatcher as i, name as l, loadConfigFile as n, defineTransformer as o, generateSpec as r, normalizeOptions as s, findConfigFile as t, version as u };
 
-//# sourceMappingURL=config-CXPetEiJ.mjs.map
+//# sourceMappingURL=config-C8B9Lol2.mjs.map