orval 8.13.0 → 8.14.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-Cyybmy9c.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-yIkhToq8.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-Cyybmy9c.mjs → config-yIkhToq8.mjs}

@@ -1,5 +1,5 @@
 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, 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 { 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";
@@ -8,6 +8,7 @@ import * as mock 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.13.0";
+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()()
@@ -854,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.`));
@@ -908,6 +930,7 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 		shouldExportMutatorHooks: true,
 		shouldExportHttpClient: true,
 		shouldExportQueryKey: true,
+		shouldFilterQueryKey: false,
 		shouldSplitQueryKey: false,
 		...normalizeQueryOptions(outputOptions.override?.query, workspace)
 	};
@@ -1013,12 +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
@@ -1144,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: {
@@ -1183,12 +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) },
@@ -1258,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 },
@@ -1325,30 +1356,29 @@ 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.
+* 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, namingConvention) => conventionName(lastRefSegment(ref), namingConvention);
-const JS_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const resolveSchemaName = (ref, context) => getRefInfo(ref, context).name;
 /**
-* 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.
+* 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, namingConvention) => {
+const resolveSchemaNames = (refs, context) => {
 	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 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 convert to "${name}" under namingConvention=${namingConvention}. Rename one in the OpenAPI source or change the convention.`);
+		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);
 	}
@@ -1366,7 +1396,7 @@ const generateReusableSchemaSet = (refs, context, options) => {
 	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);
+		nameToRef.set(resolveSchemaName(ref, context), ref);
 	}
 	const queue = [...refs];
 	const seen = new Set(refs);
@@ -1374,11 +1404,17 @@ const generateReusableSchemaSet = (refs, context, options) => {
 	for (const ref of queue) {
 		const schema = componentSchemas[ref.slice(21)];
 		if (!schema) continue;
-		const name = resolveSchemaName(ref, context.output.namingConvention);
+		const name = resolveSchemaName(ref, context);
 		const parsed = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, context, name, options.strict, options.isZodV4, {
 			required: true,
-			useReusableSchemas: true
-		}), context, options.coerce ?? false, options.strict, options.isZodV4);
+			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,
@@ -1445,11 +1481,27 @@ const tarjan = (graph) => {
 };
 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
@@ -1459,13 +1511,17 @@ 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
+			zod: newZod,
+			isRecursive: recursiveNames.has(entry.name)
 		}];
 	}));
 	const out = [];
@@ -1477,18 +1533,99 @@ const rewriteReusableSchemas = (entries) => {
 };
 //#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",
@@ -1529,8 +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) {
-	if (output.override.zod.generateReusableSchemas === true) return generateZodSchemasInlineReusable(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);
@@ -1545,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,
@@ -1553,11 +1693,9 @@ function generateZodSchemasInline(builder, output) {
 		});
 	}
 	if (schemas.length === 0) return "";
-	return generateZodSchemaFileContent("", schemas);
+	return generateZodSchemaFileContent("", schemas, includeZodImport);
 }
-function generateZodSchemasInlineReusable(builder, output) {
-	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
-	if (schemasWithOpenApiDef.length === 0) return "";
+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;
@@ -1567,19 +1705,24 @@ function generateZodSchemasInlineReusable(builder, output) {
 		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, {
+	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
-	})).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`;
+		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);
+		await writeZodSchemasReusable(builder, schemasPath, fileExtension, header, output, paramsMutator);
 		return;
 	}
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
@@ -1598,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,
@@ -1613,7 +1759,7 @@ 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) {
+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;
@@ -1623,25 +1769,33 @@ async function writeZodSchemasReusable(builder, schemasPath, fileExtension, head
 		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 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
+		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 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`;
+		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);
@@ -1713,11 +1867,21 @@ async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension,
 			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);
@@ -1837,6 +2001,17 @@ async function writeFakerSchemaMocks(builder, options, header) {
 	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;
@@ -1846,7 +2021,13 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		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 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,
@@ -1903,17 +2084,26 @@ async function writeSpecs(builder, workspace, options, projectName) {
 	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) {
@@ -2072,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-Cyybmy9c.mjs.map
+//# sourceMappingURL=config-yIkhToq8.mjs.map