orval 8.17.0 → 8.19.0

package/dist/{config-DKT1smAv.mjs → config-D-TQRn-G.mjs}

@@ -1,5 +1,5 @@
 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,7 +15,7 @@ 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, { dereference, generateFormDataZodSchema, generateZodValidationSchemaDefinition, parseZodValidationSchemaDefinition, resolveIsZodV4 } from "@orval/zod";
 import { ExecaError, execa } from "execa";
 import fs from "fs-extra";
 import fs$1, { access } from "node:fs/promises";
@@ -28,7 +28,7 @@ import fs$2 from "node:fs";
 import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
-var version = "8.17.0";
+var version = "8.19.0";
 var description = "A swagger client generator for typescript";
 //#endregion
 //#region src/client.ts
@@ -77,21 +77,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 }) => {
@@ -173,7 +176,8 @@ const generateOperations = (outputClient = DEFAULT_CLIENT, verbsOptions, options
 				type: isFunction(entry) ? OutputMockType.MSW : entry.type,
 				implementation: generated.implementation,
 				imports: generated.imports,
-				strictMockSchemaTypeNames: generated.strictMockSchemaTypeNames
+				strictMockSchemaTypeNames: generated.strictMockSchemaTypeNames,
+				strictMockSchemaKinds: generated.strictMockSchemaKinds
 			};
 		});
 		const hasImplementation = client.implementation.trim().length > 0;
@@ -883,17 +887,28 @@ function createFormData(workspace, formData) {
 function normalizeSchemasOption(schemas, workspace) {
 	if (!schemas) return;
 	if (isString(schemas)) return normalizePath(schemas, workspace);
-	if (schemas.importPath !== void 0 && !schemas.importPath) throw new Error(`schemas.importPath must be a non-empty package specifier (e.g. '@acme/models'). Received an empty string.`);
-	if (schemas.importPath?.trim() === "") throw new Error(`schemas.importPath must be a non-empty package specifier (e.g. '@acme/models'). Received a whitespace-only string.`);
-	if (schemas.importPath && schemas.importPath.trim() !== schemas.importPath) throw new Error(`schemas.importPath must be a non-empty package specifier (e.g. '@acme/models'). Received a value with leading or trailing whitespace: "${schemas.importPath}"`);
-	if (schemas.importPath?.startsWith(".")) throw new Error(`schemas.importPath must be a package specifier (e.g. '@acme/models'), not a relative path. Received: "${schemas.importPath}"`);
-	if (schemas.importPath && (path.isAbsolute(schemas.importPath) || /^[A-Za-z]:[\\/]/.test(schemas.importPath) || schemas.importPath.startsWith("\\\\"))) throw new Error(`schemas.importPath must be a package specifier (e.g. '@acme/models'), not an absolute path. Received: "${schemas.importPath}"`);
+	validatePackageSpecifier(schemas.importPath, "schemas.importPath");
 	return {
 		path: normalizePath(schemas.path, workspace),
-		type: schemas.type,
-		importPath: schemas.importPath
+		type: schemas.type ?? "typescript",
+		importPath: schemas.importPath,
+		splitByTags: schemas.splitByTags ?? false
 	};
 }
+/**
+* Validates that a config value is a valid package specifier (bare specifier
+* or sub-path import like `@acme/models` / `@acme/models/fakers`). Rejects
+* empty, whitespace-only, relative (`./`, `../`), and absolute paths with a
+* clear, actionable error message. No-op when the value is `undefined`.
+*/
+function validatePackageSpecifier(value, fieldName) {
+	if (value === void 0) return;
+	if (!value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received an empty string.`);
+	if (value.trim() === "") throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a whitespace-only string.`);
+	if (value.trim() !== value) throw new Error(`\`${fieldName}\` must be a non-empty package specifier (e.g. '@acme/models'). Received a value with leading or trailing whitespace: "${value}"`);
+	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 normalizeEffectOptions(effect) {
 	return {
 		strict: {
@@ -955,6 +970,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 		if (isFunction(entry)) continue;
 		if (seenMockTypes.has(entry.type)) throw new Error(`Duplicate mock generator type "${entry.type}". Each type can only appear once in mock.generators.`);
 		seenMockTypes.add(entry.type);
+		if (entry.type === OutputMockType.FAKER) validatePackageSpecifier(entry.schemasImportPath, "mock.generators[faker].schemasImportPath");
 	}
 	const defaultFileExtension = ".ts";
 	const defaultSchemaFileExtension = !!outputOptions.schemas && (!isString(outputOptions.schemas) && outputOptions.schemas.type === "zod" || isString(outputOptions.schemas) && (outputOptions.client ?? client) === "zod" && outputOptions.override?.zod?.generateReusableSchemas === true) ? ".zod.ts" : defaultFileExtension;
@@ -973,7 +989,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 		shouldExportQueryKey: true,
 		shouldFilterQueryKey: false,
 		shouldSplitQueryKey: false,
-		...normalizeQueryOptions(outputOptions.override?.query, workspace)
+		...normalizeQueryOptions(outputOptions.override?.query, outputWorkspace)
 	};
 	const normalizedOptions = {
 		input: {
@@ -1005,6 +1021,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: {
@@ -1015,8 +1033,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,
@@ -1071,13 +1089,14 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 						response: outputOptions.override?.zod?.coerce?.response ?? false
 					},
 					preprocess: {
-						...outputOptions.override?.zod?.preprocess?.param ? { param: normalizeMutator(workspace, outputOptions.override.zod.preprocess.param) } : {},
-						...outputOptions.override?.zod?.preprocess?.query ? { query: normalizeMutator(workspace, outputOptions.override.zod.preprocess.query) } : {},
-						...outputOptions.override?.zod?.preprocess?.header ? { header: normalizeMutator(workspace, outputOptions.override.zod.preprocess.header) } : {},
-						...outputOptions.override?.zod?.preprocess?.body ? { body: normalizeMutator(workspace, outputOptions.override.zod.preprocess.body) } : {},
-						...outputOptions.override?.zod?.preprocess?.response ? { response: normalizeMutator(workspace, outputOptions.override.zod.preprocess.response) } : {}
+						...outputOptions.override?.zod?.preprocess?.param ? { param: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.param) } : {},
+						...outputOptions.override?.zod?.preprocess?.query ? { query: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.query) } : {},
+						...outputOptions.override?.zod?.preprocess?.header ? { header: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.header) } : {},
+						...outputOptions.override?.zod?.preprocess?.body ? { body: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.body) } : {},
+						...outputOptions.override?.zod?.preprocess?.response ? { response: normalizeMutator(outputWorkspace, outputOptions.override.zod.preprocess.response) } : {}
 					},
-					...outputOptions.override?.zod?.params ? { params: normalizeMutator(workspace, outputOptions.override.zod.params) } : {},
+					...outputOptions.override?.zod?.params ? { params: normalizeMutator(outputWorkspace, outputOptions.override.zod.params) } : {},
+					version: outputOptions.override?.zod?.version ?? "auto",
 					generateEachHttpStatus: outputOptions.override?.zod?.generateEachHttpStatus ?? false,
 					useBrandedTypes: outputOptions.override?.zod?.useBrandedTypes ?? false,
 					generateReusableSchemas: outputOptions.override?.zod?.generateReusableSchemas ?? false,
@@ -1101,6 +1120,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) } : {}
 				},
@@ -1121,6 +1141,11 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 	};
 	if (!normalizedOptions.input.target) throw new Error(styleText("red", `Config requires an input target.`));
 	if (!normalizedOptions.output.target && !normalizedOptions.output.schemas) throw new Error(styleText("red", `Config requires an output target or schemas.`));
+	const fakerWithSchemasImportPath = normalizedOptions.output.mock.generators.find((g) => !isFunction(g) && g.type === OutputMockType.FAKER && !!g.schemasImportPath);
+	if (fakerWithSchemasImportPath) {
+		if (fakerWithSchemasImportPath.schemas !== true) throw new Error(styleText("red", `\`mock.generators[faker].schemasImportPath\` requires \`schemas: true\` on the same generator. Schema-level faker factories are only emitted when \`schemas: true\`.`));
+		if (!(isObject(normalizedOptions.output.schemas) && normalizedOptions.output.schemas.importPath)) throw new Error(styleText("red", `\`mock.generators[faker].schemasImportPath\` requires \`schemas.importPath\` to also be set. It overrides the package specifier used for importing schema-level faker factories.`));
+	}
 	const usesAngularGenerator = normalizedOptions.output.client === OutputClient.ANGULAR || normalizedOptions.output.client === OutputClient.ANGULAR_QUERY && normalizedOptions.output.httpClient === OutputHttpClient.ANGULAR;
 	if (normalizedOptions.output.override.paramsFilter && !usesAngularGenerator) throw new Error(styleText("red", `\`override.paramsFilter\` is only supported by the Angular generator (the \`angular\` client, or \`angular-query\` with \`httpClient: 'angular'\`). It has no effect for other clients — use \`override.paramsSerializer\` instead.`));
 	if (!usesAngularGenerator) {
@@ -1210,8 +1235,19 @@ 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",
+		"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: {
@@ -1221,7 +1257,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,
@@ -1251,12 +1287,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) } : {},
@@ -1591,6 +1622,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
@@ -1660,7 +1708,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;
@@ -1672,7 +1720,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) => [
@@ -1698,8 +1746,8 @@ const groupSchemasByFilePath = (schemas) => {
 	}
 	return [...grouped.values()].map((group) => [...group].toSorted((a, b) => a.filePath.localeCompare(b.filePath, "en", { numeric: true }))).toSorted((a, b) => a[0].filePath.localeCompare(b[0].filePath, "en", { numeric: true }));
 };
-async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNames, namingConvention, shouldMergeExisting = false) {
-	const importFileExtension = fileExtension.replace(/\.ts$/, "");
+async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNames, namingConvention, shouldMergeExisting = false, tsconfig) {
+	const importFileExtension = getImportExtension(fileExtension, tsconfig);
 	const indexPath = path.join(schemasPath, `index.ts`);
 	let existingExports = "";
 	if (shouldMergeExisting && await fs.pathExists(indexPath)) {
@@ -1715,11 +1763,34 @@ 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);
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const schemas = [];
@@ -1745,7 +1816,7 @@ function generateZodSchemasInline(builder, output, includeZodImport = true, para
 	return generateZodSchemaFileContent("", schemas, 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);
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const context = {
@@ -1769,21 +1840,20 @@ function generateZodSchemasInlineReusable(builder, output, includeZodImport = tr
 	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);
 	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,
@@ -1806,10 +1876,22 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
 		await fs.outputFile(schemaGroup[0].filePath, fileContent);
 	}
-	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, false);
+	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);
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const context = {
@@ -1829,11 +1911,11 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 		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 importExt = fileExtension.replace(/\.ts$/, "");
+		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 refImports = buildSiblingImports({
 			usedRefs: entry.usedRefs,
@@ -1841,19 +1923,39 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 			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 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}import { z as zod } from 'zod';\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);
+	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);
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
 	const useReusableSchemas = output.override.zod.generateReusableSchemas === true;
@@ -1915,14 +2017,18 @@ 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
@@ -1931,9 +2037,10 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 		let importStatements;
 		if (useReusableSchemas && parsedZodDefinition.usedRefs.size > 0) {
 			zodExpression = rewriteSentinelsToDirect(zodExpression);
-			const importExt = fileExtension.replace(/\.ts$/, "");
+			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({
@@ -1949,7 +2056,19 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
 		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);
+	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
@@ -1989,6 +2108,10 @@ function getHeader(option, info) {
 /**
 * Add re-export of operation schemas from the main schemas index file.
 * Handles the case where the index file doesn't exist (no regular schemas).
+*
+* NOTE: `operationSchemasPath` is a directory, so under NodeNext the re-export
+* would need an `/index.js` suffix rather than a bare `.js`. That directory-
+* import case is tracked separately and intentionally left as-is here.
 */
 async function addOperationSchemasReExport(schemaPath, operationSchemasPath, header) {
 	const schemaIndexPath = path.join(schemaPath, `index.ts`);
@@ -2010,13 +2133,13 @@ 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;
 	const schemasWithDef = builder.schemas.filter((s) => !!s.schema);
 	if (schemasWithDef.length === 0) return;
-	const { implementation, imports, strictMockSchemaTypeNames } = generateFakerForSchemas(schemasWithDef, {
+	const { implementation, imports, strictMockSchemaTypeNames, strictMockSchemaKinds } = generateFakerForSchemas(schemasWithDef, {
 		spec: builder.spec,
 		target: builder.target,
 		workspace: "",
@@ -2025,7 +2148,8 @@ async function writeFakerSchemaMocks(builder, options, header) {
 	if (!implementation.trim()) return;
 	const finalizedImplementation = builder.finalizeMockImplementation ? builder.finalizeMockImplementation(implementation, {
 		mockOptions: output.override.mock,
-		strictSchemaTypeNames: strictMockSchemaTypeNames
+		strictSchemaTypeNames: strictMockSchemaTypeNames,
+		strictMockSchemaKinds
 	}) : implementation;
 	let filePath;
 	let schemaImportPath;
@@ -2040,9 +2164,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) {
@@ -2079,28 +2226,62 @@ function shouldGenerateSchemas(output, hasOperations) {
 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));
@@ -2144,7 +2325,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);
@@ -2167,6 +2348,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
 		});
 	}
@@ -2174,7 +2356,11 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		const workspacePath = output.workspace;
 		const indexFile = path.join(workspacePath, "index.ts");
 		const mockExtensions = output.mock.generators.map((g) => getMockFileExtensionByTypeName(g));
-		const imports = implementationPaths.filter((p) => mockExtensions.length === 0 || !mockExtensions.some((ext) => p.endsWith(`.${ext}.ts`))).map((p) => upath.getRelativeImportPath(indexFile, getFileInfo(p).pathWithoutExtension, true));
+		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 relative = upath.getRelativeImportPath(indexFile, p, true);
+			return (relative.endsWith(output.fileExtension) ? relative.slice(0, -output.fileExtension.length) : relative.replace(/\.[^/.]+$/, "")) + importExtension;
+		});
 		if (output.schemas) {
 			const schemasPath = isString(output.schemas) ? output.schemas : output.schemas.path;
 			imports.push(upath.getRelativeImportPath(indexFile, getFileInfo(schemasPath).dirname));
@@ -2326,4 +2512,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-DKT1smAv.mjs.map
+//# sourceMappingURL=config-D-TQRn-G.mjs.map