orval 8.12.3 → 8.14.0

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

@@ -1,13 +1,14 @@
 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, 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 { 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 effect from "@orval/effect";
 import fetchClient from "@orval/fetch";
 import hono from "@orval/hono";
 import mcp from "@orval/mcp";
@@ -28,7 +29,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.14.0";
 //#endregion
 //#region src/client.ts
 const DEFAULT_CLIENT = OutputClient.AXIOS;
@@ -61,6 +62,7 @@ const getGeneratorClient = (outputClient, output) => {
 		})(),
 		swr: swr()(),
 		zod: zod()(),
+		effect: effect()(),
 		hono: hono()(),
 		fetch: fetchClient()(),
 		mcp: mcp()()
@@ -162,7 +164,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,
@@ -851,6 +856,26 @@ function normalizeSchemasOption(schemas, workspace) {
 		type: schemas.type
 	};
 }
+function normalizeEffectOptions(effect) {
+	return {
+		strict: {
+			param: effect?.strict?.param ?? false,
+			query: effect?.strict?.query ?? false,
+			header: effect?.strict?.header ?? false,
+			body: effect?.strict?.body ?? false,
+			response: effect?.strict?.response ?? false
+		},
+		generate: {
+			param: effect?.generate?.param ?? true,
+			query: effect?.generate?.query ?? true,
+			header: effect?.generate?.header ?? true,
+			body: effect?.generate?.body ?? true,
+			response: effect?.generate?.response ?? true
+		},
+		generateEachHttpStatus: effect?.generateEachHttpStatus ?? false,
+		useBrandedTypes: effect?.useBrandedTypes ?? false
+	};
+}
 async function normalizeOptions(optionsExport, workspace = process.cwd(), globalOptions = {}) {
 	const options = await (isFunction(optionsExport) ? optionsExport() : optionsExport);
 	if (!options.input) throw new Error(styleText("red", `Config requires an input.`));
@@ -891,11 +916,21 @@ 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,
 		shouldExportHttpClient: true,
 		shouldExportQueryKey: true,
+		shouldFilterQueryKey: false,
 		shouldSplitQueryKey: false,
 		...normalizeQueryOptions(outputOptions.override?.query, workspace)
 	};
@@ -913,6 +948,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 +963,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: {
@@ -999,11 +1036,15 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 						...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?.params ? { params: normalizeMutator(workspace, outputOptions.override.zod.params) } : {},
 					generateEachHttpStatus: outputOptions.override?.zod?.generateEachHttpStatus ?? false,
 					useBrandedTypes: outputOptions.override?.zod?.useBrandedTypes ?? false,
+					generateReusableSchemas: outputOptions.override?.zod?.generateReusableSchemas ?? false,
+					generateMeta: outputOptions.override?.zod?.generateMeta ?? false,
 					dateTimeOptions: outputOptions.override?.zod?.dateTimeOptions ?? { offset: true },
 					timeOptions: outputOptions.override?.zod?.timeOptions ?? {}
 				},
+				effect: normalizeEffectOptions(outputOptions.override?.effect),
 				swr: {
 					generateErrorTypes: false,
 					...outputOptions.override?.swr
@@ -1129,7 +1170,7 @@ function normalizePath(path$1, workspace) {
 	return path.resolve(workspace, path$1);
 }
 function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
-	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, paramsFilter, query, angular, zod, ...rest }]) => {
+	return Object.fromEntries(Object.entries(operationsOrTags).map(([key, { transformer, mutator, formData, formUrlEncoded, paramsSerializer, paramsFilter, query, angular, zod, effect, ...rest }]) => {
 		return [key, {
 			...rest,
 			...angular ? { angular: {
@@ -1168,11 +1209,15 @@ function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
 					...zod.preprocess?.body ? { body: normalizeMutator(workspace, zod.preprocess.body) } : {},
 					...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 ?? {}
 			} } : {},
+			...effect ? { effect: normalizeEffectOptions(effect) } : {},
 			...transformer ? { transformer: normalizePath(transformer, workspace) } : {},
 			...mutator ? { mutator: normalizeMutator(workspace, mutator) } : {},
 			...formData === void 0 ? {} : { formData: createFormData(workspace, formData) },
@@ -1242,6 +1287,8 @@ function normalizeQueryOptions(queryOptions = {}, outputWorkspace, globalOptions
 		...queryOptions.mutationOptions ? { mutationOptions: normalizeMutator(outputWorkspace, queryOptions.mutationOptions) } : {},
 		...isNullish(globalOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: globalOptions.shouldExportQueryKey },
 		...isNullish(queryOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: queryOptions.shouldExportQueryKey },
+		...isNullish(globalOptions.shouldFilterQueryKey) ? {} : { shouldFilterQueryKey: globalOptions.shouldFilterQueryKey },
+		...isNullish(queryOptions.shouldFilterQueryKey) ? {} : { shouldFilterQueryKey: queryOptions.shouldFilterQueryKey },
 		...isNullish(globalOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: globalOptions.shouldExportHttpClient },
 		...isNullish(queryOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: queryOptions.shouldExportHttpClient },
 		...isNullish(globalOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: globalOptions.shouldExportMutatorHooks },
@@ -1308,19 +1355,277 @@ async function startWatcher(watchOptions, watchFn, defaultTarget = ".") {
 	});
 }
 //#endregion
+//#region src/reusable-schemas.ts
+/**
+* Resolve the export identifier for a `#/components/schemas/X` ref. We reuse
+* `@orval/core`'s `getRefInfo(...).name` (`pascal` + sanitize + component
+* suffix) so reusable zod schema exports match the operation wrappers and the
+* TS model types exactly. `namingConvention` deliberately does NOT influence
+* the identifier — it governs file names only, consistent with the rest of
+* orval. The same call powers the generator's `namedRef` emission, so the
+* definition name and every reference stay in sync.
+*/
+const resolveSchemaName = (ref, context) => getRefInfo(ref, context).name;
+/**
+* Resolve names for a set of refs, throwing on conflicts (two distinct refs
+* collapsing to the same identifier). 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, context) => {
+	const resolved = /* @__PURE__ */ new Map();
+	const reverse = /* @__PURE__ */ new Map();
+	for (const ref of refs) {
+		const name = resolveSchemaName(ref, context);
+		const previous = reverse.get(name);
+		if (previous !== void 0 && previous !== ref) throw new Error(`[orval/zod] generateReusableSchemas: refs ${previous} and ${ref} both resolve to the export name "${name}". Rename one in the OpenAPI source.`);
+		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), 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);
+		const parsed = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, context, name, options.strict, options.isZodV4, {
+			required: true,
+			useReusableSchemas: true,
+			emitMeta: options.generateMeta
+		}), context, options.coerce ?? false, options.strict, options.isZodV4, void 0, options.paramsMutator ? {
+			mutator: options.paramsMutator,
+			operationId: "",
+			location: "schema",
+			schemaName: name
+		} : void 0);
+		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 the bare identifier. Use this
+* for schemas that sit at the top of the dependency graph (operation params,
+* bodies, responses) — they can never participate in a cycle with the
+* component schemas they reference, so every ref is a direct (non-lazy) one.
+*/
+const rewriteSentinelsToDirect = (zod) => zod.replaceAll(SENTINEL_PATTERN, (_match, refName) => refName);
+/**
+* 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.
+*
+* Entries that sit in a cycle (SCC of size > 1, or a self-loop) are flagged
+* `isRecursive`. Their generated `const` reads its own binding inside the
+* initializer (through the `zod.lazy` wrapper), which TypeScript rejects with
+* TS7022 ("'X' implicitly has type 'any' ... referenced directly or indirectly
+* in its own initializer") unless the `const` carries an explicit type
+* annotation. The writer (`write-zod-specs`) supplies that annotation —
+* `const X: zod.ZodType<X>` — backed by a generated TS type, which both
+* silences TS7022 and preserves full `z.infer` typing through the recursion.
+*
+* 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 recursiveNames = /* @__PURE__ */ new Set();
+	for (const scc of sccs) if (scc.length > 1) for (const name of scc) recursiveNames.add(name);
+	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 [entry.name, {
+			...entry,
+			zod: newZod,
+			isRecursive: recursiveNames.has(entry.name)
+		}];
+	}));
+	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';
-
-${schemas.map(({ schemaName, consts, zodExpression }) => {
+/**
+* Render the `import { ... } from '...'` line for a resolved
+* `GeneratorMutator`. Mirrors the format produced by
+* `generateMutatorImports` in `@orval/core` but inlined to avoid pulling in
+* its full surface area for a single statement.
+*/
+function buildMutatorImportStatement(mutator) {
+	return `import ${mutator.default ? mutator.name : `{ ${mutator.name} }`} from '${mutator.path}';`;
+}
+/**
+* Whole-word substring check for a resolved mutator alias inside generated
+* code. Plain `String.includes` would false-positive when the user names the
+* mutator something like `min` against `.min(1)`.
+*/
+function bodyReferencesMutator(body, mutator) {
+	return new RegExp(String.raw`\b${mutator.name}\b`).test(body);
+}
+function generateZodSchemaFileContent(header, schemas, 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 schemaContent = schemas.map(({ schemaName, consts, zodExpression }) => {
 		return `${consts ? `${consts}\n` : ""}export const ${schemaName} = ${zodExpression}
 
 export type ${schemaName} = zod.input<typeof ${schemaName}>;
 export type ${schemaName}Output = zod.output<typeof ${schemaName}>;`;
-	}).join("\n\n")}
-`;
+	}).join("\n\n");
+	return `${header}${importBlock ? `${importBlock}\n\n` : ""}${schemaContent}\n`;
+}
+function renderReusableSchemaEntry(entry, context) {
+	const consts = entry.consts ? `${entry.consts}\n\n` : "";
+	if (entry.isRecursive) {
+		const rawName = isComponentRef(entry.ref) ? getRefInfo(entry.ref, context).originalName : void 0;
+		const schema = rawName ? context.spec.components?.schemas?.[rawName] : void 0;
+		const resolved = schema ? resolveValue({
+			schema,
+			name: entry.name,
+			context
+		}) : void 0;
+		const typeBody = resolved ? resolved.value : "unknown";
+		const seen = /* @__PURE__ */ new Set();
+		const extraImports = [];
+		for (const imp of resolved?.imports ?? []) {
+			if (!imp.name || imp.name === entry.name) continue;
+			const bindingKey = imp.alias ?? imp.name;
+			if (seen.has(bindingKey)) continue;
+			seen.add(bindingKey);
+			extraImports.push({
+				name: imp.name,
+				...imp.alias ? { alias: imp.alias } : {}
+			});
+		}
+		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}>;`,
+			extraImports
+		};
+	}
+	return {
+		content: `${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}>;`,
+		extraImports: []
+	};
 }
 const isValidSchemaIdentifier = (name) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+/**
+* Build the sibling-file `import { … } from './…'` block for one reusable
+* schema file. Two sources feed in:
+*   - `usedRefs` — names from the zod runtime expression. Sourced from the
+*     sentinel parser, so always unaliased.
+*   - `extraImports` — names the recursive TS body needs that the zod runtime
+*     collapsed (`propertyNames` $refs, etc.). May carry `alias`.
+* Keyed by export name (`name`) so an aliased `extraImports` entry overrides
+* a bare `usedRefs` entry — the recursive TS body uses the local binding, so
+* the aliased form has to win for the file to compile. Self-refs and
+* non-component identifiers are filtered out.
+*
+* Exported for unit-test coverage of the alias-propagation path; no
+* `resolveValue` producer surfaces aliases here today, so the integration
+* tests can't exercise it.
+*/
+function buildSiblingImports({ usedRefs, extraImports, entryName, componentNames, namingConvention, importExt }) {
+	const importsByName = /* @__PURE__ */ new Map();
+	for (const name of usedRefs) {
+		if (name === entryName) continue;
+		importsByName.set(name, { name });
+	}
+	for (const imp of extraImports) {
+		if (imp.name === entryName || !componentNames.has(imp.name)) continue;
+		importsByName.set(imp.name, imp);
+	}
+	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}';`;
+	}).join("\n");
+}
 const isPrimitiveSchemaName = (name) => [
 	"string",
 	"number",
@@ -1361,7 +1666,8 @@ 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`);
 }
-function generateZodSchemasInline(builder, output) {
+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);
@@ -1376,7 +1682,10 @@ function generateZodSchemasInline(builder, output) {
 			workspace: "",
 			output
 		};
-		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
+		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, {
+			required: true,
+			emitMeta: output.override.zod.generateMeta
+		}), context, coerce, strict, isZodV4);
 		schemas.push({
 			schemaName: name,
 			consts: parsedZodDefinition.consts,
@@ -1384,9 +1693,38 @@ function generateZodSchemasInline(builder, output) {
 		});
 	}
 	if (schemas.length === 0) return "";
-	return generateZodSchemaFileContent("", schemas);
+	return generateZodSchemaFileContent("", schemas, includeZodImport);
+}
+function generateZodSchemasInlineReusable(builder, output, includeZodImport = true, paramsMutator, includeParamsImport = false) {
+	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 componentSchemas = builder.spec.components?.schemas ?? {};
+	const refs = Object.keys(componentSchemas).map((schemaName) => `#/components/schemas/${schemaName}`);
+	if (refs.length === 0) return "";
+	resolveSchemaNames(refs, context);
+	const body = rewriteReusableSchemas(generateReusableSchemaSet(refs, context, {
+		strict,
+		isZodV4,
+		coerce,
+		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` : "";
+	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) {
+async function writeZodSchemas(builder, schemasPath, fileExtension, header, output, paramsMutator) {
+	if (output.override.zod.generateReusableSchemas) {
+		await writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator);
+		return;
+	}
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
 	const schemasToWrite = [];
 	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
@@ -1403,7 +1741,10 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 			workspace: "",
 			output
 		};
-		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
+		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name, strict, isZodV4, {
+			required: true,
+			emitMeta: output.override.zod.generateMeta
+		}), context, coerce, strict, isZodV4);
 		schemasToWrite.push({
 			schemaName: name,
 			filePath,
@@ -1418,6 +1759,47 @@ 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, paramsMutator) {
+	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 componentSchemas = builder.spec.components?.schemas ?? {};
+	const refs = Object.keys(componentSchemas).map((schemaName) => `#/components/schemas/${schemaName}`);
+	resolveSchemaNames(refs, context);
+	const rewritten = rewriteReusableSchemas(generateReusableSchemaSet(refs, context, {
+		strict,
+		isZodV4,
+		coerce,
+		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 importExt = fileExtension.replace(/\.ts$/, "");
+		const rendered = renderReusableSchemaEntry(entry, context);
+		const refImports = buildSiblingImports({
+			usedRefs: entry.usedRefs,
+			extraImports: rendered.extraImports,
+			entryName: entry.name,
+			componentNames,
+			namingConvention: output.namingConvention,
+			importExt
+		});
+		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`;
+		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 +1807,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 +1823,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 +1833,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 +1842,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,15 +1859,29 @@ 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);
+		let zodExpression = parsedZodDefinition.zod;
+		let importStatements;
+		if (useReusableSchemas && parsedZodDefinition.usedRefs.size > 0) {
+			zodExpression = rewriteSentinelsToDirect(zodExpression);
+			const importExt = fileExtension.replace(/\.ts$/, "");
+			importStatements = [...parsedZodDefinition.usedRefs].filter((refName) => refName !== name).toSorted().map((refName) => {
+				return `import { ${refName} } from './${conventionName(refName, output.namingConvention)}${importExt}';`;
+			});
+		}
 		schemasToWrite.push({
 			schemaName: name,
 			filePath,
 			consts: parsedZodDefinition.consts,
-			zodExpression: parsedZodDefinition.zod
+			zodExpression,
+			importStatements
 		});
 	}
 	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
@@ -1545,118 +1942,168 @@ 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;
+}
+function isSchemaValidatorClient(client) {
+	return client === "zod" || client === "effect";
+}
+function shouldGenerateZodSchemasInline(output, hasOperations) {
+	if (output.client !== "zod" || output.schemas) return false;
+	if (output.override.zod.generateReusableSchemas) return true;
+	return !hasOperations;
+}
+function shouldGenerateSchemas(output, hasOperations) {
+	return !output.schemas && !isSchemaValidatorClient(output.client) || shouldGenerateZodSchemasInline(output, hasOperations);
+}
 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,
+	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, 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
 			});
-			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);
-		const isZodClient = output.client === "zod";
 		const hasOperations = Object.keys(builder.operations).length > 0;
-		const needZodSchemasInline = isZodClient && !output.schemas && !hasOperations;
+		const needZodSchemasInline = shouldGenerateZodSchemasInline(output, hasOperations);
+		const includeZodImport = !Object.values(builder.operations).some((operation) => /\bzod\b/.test(operation.implementation));
+		const inlineSchemasParamsMutator = needZodSchemasInline && output.override.zod.params ? await generateMutator({
+			output: output.target,
+			mutator: output.override.zod.params,
+			name: "zodParams",
+			workspace,
+			tsconfig: output.tsconfig
+		}) : void 0;
+		const isSchemasInSeparateFile = output.mode !== OutputMode.SINGLE;
+		const includeParamsImport = !hasOperations || isSchemasInSeparateFile;
 		implementationPaths = await writeMode({
 			builder,
 			workspace,
 			output,
 			projectName,
 			header,
-			needSchema: !output.schemas && !isZodClient || needZodSchemasInline,
-			generateSchemasInline: needZodSchemasInline ? () => generateZodSchemasInline(builder, output) : void 0
+			needSchema: shouldGenerateSchemas(output, hasOperations),
+			generateSchemasInline: needZodSchemasInline ? () => generateZodSchemasInline(builder, output, includeZodImport, inlineSchemasParamsMutator, includeParamsImport) : void 0
 		});
 	}
 	if (output.workspace) {
@@ -1684,6 +2131,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 +2262,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-yIkhToq8.mjs.map