orval 8.12.3 → 8.13.0

package/dist/bin/orval.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as description, i as startWatcher, l as name, n as loadConfigFile, r as generateSpec, s as normalizeOptions, t as findConfigFile, u as version } from "../config-DDQgHurQ.mjs";
+import { c as description, i as startWatcher, l as name, n as loadConfigFile, r as generateSpec, s as normalizeOptions, t as findConfigFile, u as version } from "../config-Cyybmy9c.mjs";
 import path from "node:path";
 import { Option, program } from "@commander-js/extra-typings";
 import { ErrorWithTag, OutputClient, OutputMode, SupportedFormatter, getWarningCount, isString, log, logError, resetWarnings, setVerbose, startMessage } from "@orval/core";

package/dist/{config-DDQgHurQ.mjs → config-Cyybmy9c.mjs}

@@ -1,11 +1,11 @@
 import path from "node:path";
-import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SupportedFormatter, asyncReduce, collectReferencedComponents, conventionName, createSuccessMessage, dynamicImport, fixCrossDirectoryImports, fixRegularSchemaImports, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getBaseUrlRuntimeImports, getFileInfo, getFullRoute, getMockFileExtensionByTypeName, getRoute, isBoolean, isFunction, isNullish, isObject, isReference, isString, isUrl, jsDoc, log, logError, logVerbose, logWarning, pascal, removeFilesAndEmptyFolders, resolveInstalledVersions, resolveRef, splitSchemasByType, upath, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
+import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SupportedFormatter, asyncReduce, collectReferencedComponents, conventionName, createSuccessMessage, dynamicImport, fixCrossDirectoryImports, fixRegularSchemaImports, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getBaseUrlRuntimeImports, getFileInfo, getFullRoute, getImportExtension, getMockFileExtensionByTypeName, getRoute, isBoolean, isFunction, isNullish, isObject, isReference, isString, isUrl, jsDoc, log, logError, logVerbose, logWarning, pascal, removeFilesAndEmptyFolders, resolveInstalledVersions, resolveRef, splitSchemasByType, upath, writeGeneratedFile, writeSchemas, 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";
 import { isNullish as isNullish$1, pick, unique } from "remeda";
 import * as mock from "@orval/mock";
-import { generateMockImports, getDefaultMockOptionsForType } from "@orval/mock";
+import { generateFakerForSchemas, generateMockImports, getDefaultMockOptionsForType } from "@orval/mock";
 import angular from "@orval/angular";
 import axios from "@orval/axios";
 import fetchClient from "@orval/fetch";
@@ -28,7 +28,7 @@ import { createJiti } from "jiti";
 //#region package.json
 var name = "orval";
 var description = "A swagger client generator for typescript";
-var version = "8.12.3";
+var version = "8.13.0";
 //#endregion
 //#region src/client.ts
 const DEFAULT_CLIENT = OutputClient.AXIOS;
@@ -162,7 +162,10 @@ const generateOperations = (outputClient = DEFAULT_CLIENT, verbsOptions, options
 		const { client: generatorClient } = getGeneratorClient(outputClient, output);
 		const client = await generatorClient(verbOption, options, outputClient, output);
 		if (!client.implementation) return acc;
-		const mockOutputs = output.mock.generators.map((entry) => {
+		const mockOutputs = output.mock.generators.filter((entry) => {
+			if (!isFunction(entry) && entry.type === OutputMockType.FAKER && entry.operationResponses === false) return false;
+			return true;
+		}).map((entry) => {
 			const generated = invokeMockGenerator(verbOption, options, entry);
 			return {
 				type: isFunction(entry) ? OutputMockType.MSW : entry.type,
@@ -891,6 +894,15 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 		seenMockTypes.add(entry.type);
 	}
 	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;
+	const factoryMethodsConfig = outputOptions.factoryMethods;
+	let factoryMethods = void 0;
+	if (factoryMethodsConfig) factoryMethods = {
+		functionNamePrefix: factoryMethodsConfig.functionNamePrefix ?? "create",
+		mode: factoryMethodsConfig.mode ?? "split",
+		outputDirectory: factoryMethodsConfig.outputDirectory ? normalizePath(factoryMethodsConfig.outputDirectory, outputWorkspace) : outputOptions.schemas ? normalizePath(isString(outputOptions.schemas) ? outputOptions.schemas : outputOptions.schemas.path, outputWorkspace) : normalizePath(outputWorkspace, outputWorkspace),
+		includeOptionalProperty: factoryMethodsConfig.includeOptionalProperty ?? true
+	};
 	const globalQueryOptions = {
 		signal: true,
 		shouldExportMutatorHooks: true,
@@ -913,6 +925,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 			operationSchemas: outputOptions.operationSchemas ? normalizePath(outputOptions.operationSchemas, outputWorkspace) : void 0,
 			namingConvention: outputOptions.namingConvention ?? NamingConvention.CAMEL_CASE,
 			fileExtension: outputOptions.fileExtension ?? defaultFileExtension,
+			schemaFileExtension: outputOptions.schemaFileExtension ?? outputOptions.fileExtension ?? defaultSchemaFileExtension,
 			workspace: outputOptions.workspace ? outputWorkspace : void 0,
 			client: outputOptions.client ?? client ?? OutputClient.AXIOS_FUNCTIONS,
 			httpClient: outputOptions.httpClient ?? httpClient ?? ((outputOptions.client ?? client) === OutputClient.ANGULAR_QUERY ? OutputHttpClient.ANGULAR : OutputHttpClient.FETCH),
@@ -927,6 +940,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 			indexFiles: outputOptions.indexFiles ?? true,
 			baseUrl: outputOptions.baseUrl,
 			unionAddMissingProperties: outputOptions.unionAddMissingProperties ?? false,
+			factoryMethods,
 			override: {
 				...outputOptions.override,
 				mock: {
@@ -1001,6 +1015,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 					},
 					generateEachHttpStatus: outputOptions.override?.zod?.generateEachHttpStatus ?? false,
 					useBrandedTypes: outputOptions.override?.zod?.useBrandedTypes ?? false,
+					generateReusableSchemas: outputOptions.override?.zod?.generateReusableSchemas ?? false,
 					dateTimeOptions: outputOptions.override?.zod?.dateTimeOptions ?? { offset: true },
 					timeOptions: outputOptions.override?.zod?.timeOptions ?? {}
 				},
@@ -1170,6 +1185,7 @@ function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
 				},
 				generateEachHttpStatus: zod.generateEachHttpStatus ?? false,
 				useBrandedTypes: zod.useBrandedTypes ?? false,
+				generateReusableSchemas: zod.generateReusableSchemas ?? false,
 				dateTimeOptions: zod.dateTimeOptions ?? { offset: true },
 				timeOptions: zod.timeOptions ?? {}
 			} } : {},
@@ -1308,6 +1324,158 @@ async function startWatcher(watchOptions, watchFn, defaultTarget = ".") {
 	});
 }
 //#endregion
+//#region src/reusable-schemas.ts
+const lastRefSegment = (ref) => {
+	const raw = ref.split("/").pop() ?? "";
+	return decodeURIComponent(raw).replaceAll("~1", "/").replaceAll("~0", "~");
+};
+/**
+* Convert a single `#/components/schemas/X` ref into the export name we will
+* emit for it: the last `$ref` segment with `namingConvention` applied.
+*/
+const resolveSchemaName = (ref, namingConvention) => conventionName(lastRefSegment(ref), namingConvention);
+const JS_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/**
+* Resolve names for a set of refs, throwing on conflicts or on names that
+* aren't valid JS identifiers (e.g. `kebab-case` produces dashes). The mapping
+* is the single source of truth for cross-schema references — the generator,
+* the orchestrator's graph, and the sentinel rewriter all consult it.
+*/
+const resolveSchemaNames = (refs, namingConvention) => {
+	const resolved = /* @__PURE__ */ new Map();
+	const reverse = /* @__PURE__ */ new Map();
+	for (const ref of refs) {
+		const name = resolveSchemaName(ref, namingConvention);
+		if (!JS_IDENTIFIER_PATTERN.test(name)) throw new Error(`[orval/zod] generateReusableSchemas: ref ${ref} converts to "${name}" under namingConvention=${namingConvention}, which is not a valid JS identifier. Use camelCase, PascalCase, or snake_case for the project's namingConvention when this flag is enabled.`);
+		const previous = reverse.get(name);
+		if (previous !== void 0 && previous !== ref) throw new Error(`[orval/zod] generateReusableSchemas: refs ${previous} and ${ref} both convert to "${name}" under namingConvention=${namingConvention}. Rename one in the OpenAPI source or change the convention.`);
+		resolved.set(ref, name);
+		reverse.set(name, ref);
+	}
+	return resolved;
+};
+/**
+* For each component-schema ref, run the Zod generator + parser with
+* `useReusableSchemas: true`. The resulting `zod` strings contain
+* `__REF_<name>__` sentinels at every site that references another schema;
+* the SCC step (Task 10) decides whether each sentinel becomes a direct
+* identifier or a `z.lazy(() => Name)` wrapper.
+*/
+const generateReusableSchemaSet = (refs, context, options) => {
+	const componentSchemas = context.spec.components?.schemas ?? {};
+	const nameToRef = /* @__PURE__ */ new Map();
+	for (const schemaName of Object.keys(componentSchemas)) {
+		const ref = `#/components/schemas/${schemaName}`;
+		nameToRef.set(resolveSchemaName(ref, context.output.namingConvention), ref);
+	}
+	const queue = [...refs];
+	const seen = new Set(refs);
+	const entries = [];
+	for (const ref of queue) {
+		const schema = componentSchemas[ref.slice(21)];
+		if (!schema) continue;
+		const name = resolveSchemaName(ref, context.output.namingConvention);
+		const parsed = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, context, name, options.strict, options.isZodV4, {
+			required: true,
+			useReusableSchemas: true
+		}), context, options.coerce ?? false, options.strict, options.isZodV4);
+		entries.push({
+			ref,
+			name,
+			zod: parsed.zod,
+			consts: parsed.consts,
+			usedRefs: parsed.usedRefs
+		});
+		for (const usedName of parsed.usedRefs) {
+			const usedRef = nameToRef.get(usedName);
+			if (usedRef !== void 0 && !seen.has(usedRef)) {
+				seen.add(usedRef);
+				queue.push(usedRef);
+			}
+		}
+	}
+	return entries;
+};
+const edgeKey = (from, to) => `${from}->${to}`;
+const tarjan = (graph) => {
+	let index = 0;
+	const stack = [];
+	const onStack = /* @__PURE__ */ new Set();
+	const indices = /* @__PURE__ */ new Map();
+	const lowlinks = /* @__PURE__ */ new Map();
+	const sccs = [];
+	const lazyEdges = /* @__PURE__ */ new Set();
+	const strongconnect = (v) => {
+		indices.set(v, index);
+		lowlinks.set(v, index);
+		index += 1;
+		stack.push(v);
+		onStack.add(v);
+		const neighbors = graph.get(v) ?? /* @__PURE__ */ new Set();
+		for (const w of neighbors) {
+			if (v === w) {
+				lazyEdges.add(edgeKey(v, w));
+				continue;
+			}
+			if (!indices.has(w)) {
+				strongconnect(w);
+				lowlinks.set(v, Math.min(lowlinks.get(v) ?? -1, lowlinks.get(w) ?? -1));
+			} else if (onStack.has(w)) {
+				lazyEdges.add(edgeKey(v, w));
+				lowlinks.set(v, Math.min(lowlinks.get(v) ?? -1, indices.get(w) ?? -1));
+			}
+		}
+		if (lowlinks.get(v) === indices.get(v)) {
+			const scc = [];
+			let w;
+			do {
+				w = stack.pop();
+				if (w === void 0) break;
+				onStack.delete(w);
+				scc.push(w);
+			} while (w !== v);
+			sccs.push(scc);
+		}
+	};
+	for (const node of graph.keys()) if (!indices.has(node)) strongconnect(node);
+	return {
+		sccs,
+		lazyEdges
+	};
+};
+const SENTINEL_PATTERN = /__REF_([A-Za-z_$][A-Za-z0-9_$]*)__/g;
+/**
+* Replace every `__REF_<name>__` sentinel with either the bare identifier or
+* `zod.lazy(() => <name>)` based on whether the edge closes a cycle, then
+* reorder entries so that every non-lazy reference is emitted AFTER its
+* target. This avoids TDZ errors at module load.
+*
+* Both the lazy classification and the emit order come from a single Tarjan
+* run, guaranteeing they agree: a non-lazy edge u→v means v is visited (and
+* popped) before u in DFS, so v appears earlier in the SCC array → emitted
+* before u → safe.
+*/
+const rewriteReusableSchemas = (entries) => {
+	const graph = new Map(entries.map((e) => [e.name, new Set(e.usedRefs)]));
+	for (const e of entries) for (const ref of e.usedRefs) if (!graph.has(ref)) graph.set(ref, /* @__PURE__ */ new Set());
+	const { sccs, lazyEdges } = tarjan(graph);
+	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 [entry.name, {
+			...entry,
+			zod: newZod
+		}];
+	}));
+	const out = [];
+	for (const scc of sccs) for (const name of scc) {
+		const entry = rewritten.get(name);
+		if (entry !== void 0) out.push(entry);
+	}
+	return out;
+};
+//#endregion
 //#region src/write-zod-specs.ts
 function generateZodSchemaFileContent(header, schemas) {
 	return `${header}import { z as zod } from 'zod';
@@ -1362,6 +1530,7 @@ async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNam
 	await fs.outputFile(indexPath, `${header}\n${uniqueExports}\n`);
 }
 function generateZodSchemasInline(builder, output) {
+	if (output.override.zod.generateReusableSchemas === true) return generateZodSchemasInlineReusable(builder, output);
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
 	if (schemasWithOpenApiDef.length === 0) return "";
 	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
@@ -1386,7 +1555,33 @@ function generateZodSchemasInline(builder, output) {
 	if (schemas.length === 0) return "";
 	return generateZodSchemaFileContent("", schemas);
 }
+function generateZodSchemasInlineReusable(builder, output) {
+	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
+	if (schemasWithOpenApiDef.length === 0) return "";
+	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	const strict = output.override.zod.strict.body;
+	const coerce = output.override.zod.coerce.body;
+	const context = {
+		spec: builder.spec,
+		target: builder.target,
+		workspace: "",
+		output
+	};
+	const refs = schemasWithOpenApiDef.map(({ name }) => `#/components/schemas/${name}`);
+	resolveSchemaNames(refs, output.namingConvention);
+	return `import { z as zod } from 'zod';\n\n${rewriteReusableSchemas(generateReusableSchemaSet(refs, context, {
+		strict,
+		isZodV4,
+		coerce
+	})).map((entry) => {
+		return `${entry.consts ? `${entry.consts}\n\n` : ""}export const ${entry.name} = ${entry.zod};\n\nexport type ${entry.name} = zod.input<typeof ${entry.name}>;\nexport type ${entry.name}Output = zod.output<typeof ${entry.name}>;`;
+	}).join("\n\n")}\n`;
+}
 async function writeZodSchemas(builder, schemasPath, fileExtension, header, output) {
+	if (output.override.zod.generateReusableSchemas) {
+		await writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output);
+		return;
+	}
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
 	const schemasToWrite = [];
 	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
@@ -1418,6 +1613,39 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 	}
 	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, false);
 }
+async function writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output) {
+	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	const strict = output.override.zod.strict.body;
+	const coerce = output.override.zod.coerce.body;
+	const context = {
+		spec: builder.spec,
+		target: builder.target,
+		workspace: "",
+		output
+	};
+	const refs = builder.schemas.map(({ name }) => `#/components/schemas/${name}`).filter((ref) => {
+		const schemaName = ref.slice(21);
+		return (builder.spec.components?.schemas ?? {})[schemaName] !== void 0;
+	});
+	resolveSchemaNames(refs, output.namingConvention);
+	const rewritten = rewriteReusableSchemas(generateReusableSchemaSet(refs, context, {
+		strict,
+		isZodV4,
+		coerce
+	}));
+	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 imports = [...entry.usedRefs].filter((r) => r !== entry.name).toSorted().map((r) => {
+			return `import { ${r} } from './${conventionName(r, output.namingConvention)}${importExt}';`;
+		}).join("\n");
+		const consts = entry.consts ? `${entry.consts}\n\n` : "";
+		const fileContent = `${header}import { z as zod } from 'zod';\n` + (imports ? `${imports}\n\n` : "\n") + `${consts}export const ${entry.name} = ${entry.zod};\n\nexport type ${entry.name} = zod.input<typeof ${entry.name}>;\nexport type ${entry.name}Output = zod.output<typeof ${entry.name}>;\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);
+}
 async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension, header, output, context) {
 	const zodContext = context;
 	const verbOptionsArray = Object.values(verbOptions);
@@ -1425,6 +1653,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
 	const strict = output.override.zod.strict.body;
 	const coerce = output.override.zod.coerce.body;
+	const useReusableSchemas = output.override.zod.generateReusableSchemas === true;
 	const uniqueVerbsSchemas = dedupeSchemasByName(verbOptionsArray.flatMap((verbOption) => {
 		const operation = verbOption.originalOperation;
 		const shouldGenerate = {
@@ -1440,7 +1669,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 		const bodySchema = bodyMedia?.schema;
 		const bodySchemas = shouldGenerate.body && bodySchema ? [{
 			name: `${pascal(verbOption.operationName)}Body`,
-			schema: dereference(bodySchema, zodContext),
+			schema: useReusableSchemas ? bodySchema : dereference(bodySchema, zodContext),
 			bodyContentType,
 			encoding: bodyMedia?.encoding
 		}] : [];
@@ -1450,7 +1679,7 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 			name: `${pascal(verbOption.operationName)}Params`,
 			schema: {
 				type: "object",
-				properties: Object.fromEntries(queryParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, zodContext)])),
+				properties: Object.fromEntries(queryParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, useReusableSchemas ? p.schema : dereference(p.schema, zodContext)])),
 				required: queryParams.filter((p) => p.required).map((p) => p.name).filter((name) => name !== void 0)
 			}
 		}] : [];
@@ -1459,13 +1688,13 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 			name: `${pascal(verbOption.operationName)}Headers`,
 			schema: {
 				type: "object",
-				properties: Object.fromEntries(headerParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, zodContext)])),
+				properties: Object.fromEntries(headerParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, useReusableSchemas ? p.schema : dereference(p.schema, zodContext)])),
 				required: headerParams.filter((p) => p.required).map((p) => p.name).filter((name) => name !== void 0)
 			}
 		}] : [];
 		const responseSchemas = shouldGenerate.response ? [...verbOption.response.types.success, ...verbOption.response.types.errors].filter((responseType) => !!responseType.originalSchema && !responseType.isRef && isValidSchemaIdentifier(responseType.value) && !isPrimitiveSchemaName(responseType.value)).map((responseType) => ({
 			name: responseType.value,
-			schema: dereference(responseType.originalSchema, zodContext)
+			schema: useReusableSchemas ? responseType.originalSchema : dereference(responseType.originalSchema, zodContext)
 		})) : [];
 		return dedupeSchemasByName([
 			...bodySchemas,
@@ -1476,10 +1705,14 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 	}));
 	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 parsedZodDefinition = parseZodValidationSchemaDefinition("bodyContentType" in entry && entry.bodyContentType === "multipart/form-data" ? generateFormDataZodSchema(schema, zodContext, name, strict, isZodV4, "encoding" in entry ? entry.encoding : void 0) : generateZodValidationSchemaDefinition(schema, zodContext, name, strict, isZodV4, { required: true }), zodContext, coerce, strict, isZodV4);
+		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);
 		schemasToWrite.push({
 			schemaName: name,
 			filePath,
@@ -1545,104 +1778,128 @@ async function addOperationSchemasReExport(schemaPath, operationSchemasPath, hea
 		await fs.outputFile(schemaIndexPath, content);
 	}
 }
+/**
+* Emit `<schemas-dir>/index.faker.ts` (or `<output-root>/schemas.faker.ts`
+* when `output.schemas` is not configured) when a faker generator entry has
+* `schemas: true`. Each `components/schemas` entry becomes a
+* `get<SchemaName>Mock(overrides)` factory in the file. Returns the written
+* file path so callers can include it in formatter / hook runs, or
+* `undefined` if no file was written.
+*/
+async function writeFakerSchemaMocks(builder, options, header) {
+	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 } = generateFakerForSchemas(schemasWithDef, {
+		spec: builder.spec,
+		target: builder.target,
+		workspace: "",
+		output
+	}, fakerEntry);
+	if (!implementation.trim()) return;
+	let filePath;
+	let schemaImportPath;
+	const fileExtension = output.fileExtension || ".ts";
+	if (output.schemas) {
+		const schemasDir = isString(output.schemas) ? output.schemas : output.schemas.path;
+		filePath = path.join(schemasDir, `index.faker${fileExtension}`);
+		schemaImportPath = ".";
+	} else {
+		const targetInfo = output.target ? getFileInfo(output.target, { extension: fileExtension }) : void 0;
+		const dir = targetInfo?.dirname ?? process.cwd();
+		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 grouped = /* @__PURE__ */ new Map();
+	for (const imp of reroutedImports) {
+		const key = imp.importPath ?? "";
+		if (!key) continue;
+		const bucket = grouped.get(key) ?? [];
+		bucket.push(imp);
+		grouped.set(key, bucket);
+	}
+	const content = `${header}${generateDependencyImports(implementation, [{
+		exports: [{
+			name: "faker",
+			values: true
+		}],
+		dependency: fakerEntry.locale ? `@faker-js/faker/locale/${fakerEntry.locale}` : "@faker-js/faker"
+	}, ...[...grouped.entries()].map(([dependency, exports]) => ({
+		exports,
+		dependency
+	}))], void 0, !!output.schemas, false)}\n\n${implementation}`;
+	await writeGeneratedFile(filePath, content);
+	return filePath;
+}
 async function writeSpecs(builder, workspace, options, projectName) {
 	const { info, schemas, target } = builder;
 	const { output } = options;
 	const projectTitle = projectName ?? info.title;
 	const header = getHeader(output.override.header, info);
-	if (output.schemas) if (isString(output.schemas)) {
-		const fileExtension = output.fileExtension || ".ts";
-		const schemaPath = output.schemas;
-		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));
-			fixCrossDirectoryImports(opSchemas, regularSchemaNames, schemaPath, output.operationSchemas, output.namingConvention, fileExtension, output.tsconfig);
-			fixRegularSchemaImports(regularSchemas, operationSchemaNames, schemaPath, output.operationSchemas, output.namingConvention, fileExtension, output.tsconfig);
-			if (regularSchemas.length > 0) await writeSchemas({
-				schemaPath,
-				schemas: regularSchemas,
-				target,
-				namingConvention: output.namingConvention,
-				fileExtension,
-				header,
-				indexFiles: output.indexFiles,
-				tsconfig: output.tsconfig
+	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 fileExtension = output.schemaFileExtension;
+			await writeZodSchemas(builder, schemasPath, fileExtension, header, output);
+			await writeZodSchemasFromVerbs(builder.verbOptions, schemasPath, fileExtension, header, output, {
+				spec: builder.spec,
+				target: builder.target,
+				workspace,
+				output
 			});
-			if (opSchemas.length > 0) {
-				await writeSchemas({
-					schemaPath: output.operationSchemas,
-					schemas: opSchemas,
+		} else {
+			const fileExtension = output.fileExtension || ".ts";
+			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));
+				fixCrossDirectoryImports(opSchemas, regularSchemaNames, schemasPath, output.operationSchemas, output.namingConvention, fileExtension, output.tsconfig);
+				fixRegularSchemaImports(regularSchemas, operationSchemaNames, schemasPath, output.operationSchemas, output.namingConvention, fileExtension, output.tsconfig);
+				if (regularSchemas.length > 0) await writeSchemas({
+					schemaPath: schemasPath,
+					schemas: regularSchemas,
 					target,
 					namingConvention: output.namingConvention,
 					fileExtension,
 					header,
 					indexFiles: output.indexFiles,
-					tsconfig: output.tsconfig
+					tsconfig: output.tsconfig,
+					factoryOutputDirectory: output.factoryMethods?.outputDirectory
 				});
-				if (output.indexFiles) await addOperationSchemasReExport(schemaPath, output.operationSchemas, header);
-			}
-		} else await writeSchemas({
-			schemaPath,
-			schemas,
-			target,
-			namingConvention: output.namingConvention,
-			fileExtension,
-			header,
-			indexFiles: output.indexFiles,
-			tsconfig: output.tsconfig
-		});
-	} else if (output.schemas.type === "typescript") {
-		const fileExtension = output.fileExtension || ".ts";
-		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));
-			fixCrossDirectoryImports(opSchemas, regularSchemaNames, output.schemas.path, output.operationSchemas, output.namingConvention, fileExtension, output.tsconfig);
-			fixRegularSchemaImports(regularSchemas, operationSchemaNames, output.schemas.path, output.operationSchemas, output.namingConvention, fileExtension, output.tsconfig);
-			if (regularSchemas.length > 0) await writeSchemas({
-				schemaPath: output.schemas.path,
-				schemas: regularSchemas,
+				if (opSchemas.length > 0) {
+					await writeSchemas({
+						schemaPath: output.operationSchemas,
+						schemas: opSchemas,
+						target,
+						namingConvention: output.namingConvention,
+						fileExtension,
+						header,
+						indexFiles: output.indexFiles,
+						tsconfig: output.tsconfig,
+						factoryOutputDirectory: output.factoryMethods?.outputDirectory
+					});
+					if (output.indexFiles) await addOperationSchemasReExport(schemasPath, output.operationSchemas, header);
+				}
+			} else await writeSchemas({
+				schemaPath: schemasPath,
+				schemas,
 				target,
 				namingConvention: output.namingConvention,
 				fileExtension,
 				header,
 				indexFiles: output.indexFiles,
-				tsconfig: output.tsconfig
+				tsconfig: output.tsconfig,
+				factoryOutputDirectory: output.factoryMethods?.outputDirectory
 			});
-			if (opSchemas.length > 0) {
-				await writeSchemas({
-					schemaPath: output.operationSchemas,
-					schemas: opSchemas,
-					target,
-					namingConvention: output.namingConvention,
-					fileExtension,
-					header,
-					indexFiles: output.indexFiles,
-					tsconfig: output.tsconfig
-				});
-				if (output.indexFiles) await addOperationSchemasReExport(output.schemas.path, output.operationSchemas, header);
-			}
-		} else await writeSchemas({
-			schemaPath: output.schemas.path,
-			schemas,
-			target,
-			namingConvention: output.namingConvention,
-			fileExtension,
-			header,
-			indexFiles: output.indexFiles,
-			tsconfig: output.tsconfig
-		});
-	} else {
-		const fileExtension = ".zod.ts";
-		await writeZodSchemas(builder, output.schemas.path, fileExtension, header, output);
-		await writeZodSchemasFromVerbs(builder.verbOptions, output.schemas.path, fileExtension, header, output, {
-			spec: builder.spec,
-			target: builder.target,
-			workspace,
-			output
-		});
+		}
 	}
+	const fakerSchemaPath = await writeFakerSchemaMocks(builder, options, header);
 	let implementationPaths = [];
 	if (output.target) {
 		const writeMode = getWriteMode(output.mode);
@@ -1684,6 +1941,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 	}
 	const paths = [
 		...output.schemas ? [getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path).dirname] : [],
+		...fakerSchemaPath ? [fakerSchemaPath] : [],
 		...output.operationSchemas ? [getFileInfo(output.operationSchemas).dirname] : [],
 		...implementationPaths
 	];
@@ -1814,4 +2072,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-DDQgHurQ.mjs.map
+//# sourceMappingURL=config-Cyybmy9c.mjs.map