orval 8.2.0 → 8.4.0

package/dist/{config-CfalXEai.mjs → config-FnusrAiH.mjs}

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMode, PropertySortOrder, RefComponentSuffix, asyncReduce, conventionName, createLogger, createSuccessMessage, dynamicImport, fixCrossDirectoryImports, fixRegularSchemaImports, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getFileInfo, getFullRoute, getMockFileExtensionByTypeName, getRoute, isBoolean, isFunction, isObject, isReference, isString, isUndefined, isUrl, jsDoc, log, logError, pascal, removeFilesAndEmptyFolders, resolveRef, splitSchemasByType, upath, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode } from "@orval/core";
+import { FormDataArrayHandling, GetterPropType, NamingConvention, OutputClient, OutputHttpClient, OutputMode, PropertySortOrder, RefComponentSuffix, asyncReduce, conventionName, createLogger, createSuccessMessage, dynamicImport, fixCrossDirectoryImports, fixRegularSchemaImports, generateComponentDefinition, generateDependencyImports, generateParameterDefinition, generateSchemasDefinition, generateVerbsOptions, getFileInfo, getFullRoute, getMockFileExtensionByTypeName, getRoute, isBoolean, isFunction, isNullish, isObject, isReference, isString, isUrl, jsDoc, log, logError, pascal, removeFilesAndEmptyFolders, resolveInstalledVersions, resolveRef, splitSchemasByType, upath, 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";
@@ -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.2.0";
+var version = "8.4.0";
 
 //#endregion
 //#region src/client.ts
@@ -65,9 +65,7 @@ const getGeneratorClient = (outputClient, output) => {
 		fetch: fetchClient()(),
 		mcp: mcp()()
 	};
-	const generator = isFunction(outputClient) ? outputClient(GENERATOR_CLIENT) : GENERATOR_CLIENT[outputClient];
-	if (!generator) throw new Error(`Oups... 🍻. Client not found: ${outputClient}`);
-	return generator;
+	return isFunction(outputClient) ? outputClient(GENERATOR_CLIENT) : GENERATOR_CLIENT[outputClient];
 };
 const generateClientImports = ({ client, implementation, imports, projectName, hasSchemaDir, isAllowSyntheticDefaultImports, hasGlobalMutator, hasTagsMutator, hasParamsSerializerOptions, packageJson, output }) => {
 	const { dependencies } = getGeneratorClient(client, output);
@@ -157,7 +155,7 @@ const generateOperations = (outputClient = DEFAULT_CLIENT, verbsOptions, options
 		const client = await generatorClient(verbOption, options, outputClient, output);
 		if (!client.implementation) return acc;
 		const generatedMock = generateMock(verbOption, options);
-		acc[verbOption.operationId] = {
+		acc[verbOption.operationName] = {
 			implementation: verbOption.doc + client.implementation,
 			imports: client.imports,
 			implementationMock: generatedMock.implementation,
@@ -187,7 +185,7 @@ async function getApiBuilder({ input, output, context }) {
 		const route = getRoute(pathRoute);
 		let resolvedVerbs = verbs;
 		if (isReference(verbs)) {
-			const { schema, imports } = resolveRef(verbs, context);
+			const { schema } = resolveRef(verbs, context);
 			resolvedVerbs = schema;
 		}
 		let verbsOptions = await generateVerbsOptions({
@@ -201,13 +199,13 @@ async function getApiBuilder({ input, output, context }) {
 		if (output.override.useDeprecatedOperations === false) verbsOptions = verbsOptions.filter((verb) => {
 			return !verb.deprecated;
 		});
-		const schemas = verbsOptions.reduce((acc$1, { queryParams, headers, body, response, props }) => {
-			if (props) acc$1.push(...props.flatMap((param) => param.type === GetterPropType.NAMED_PATH_PARAMS ? param.schema : []));
-			if (queryParams) acc$1.push(queryParams.schema, ...queryParams.deps);
-			if (headers) acc$1.push(headers.schema, ...headers.deps);
-			acc$1.push(...body.schemas, ...response.schemas);
-			return acc$1;
-		}, []);
+		const schemas = [];
+		for (const { queryParams, headers, body, response, props } of verbsOptions) {
+			schemas.push(...props.flatMap((param) => param.type === GetterPropType.NAMED_PATH_PARAMS ? param.schema : []));
+			if (queryParams) schemas.push(queryParams.schema, ...queryParams.deps);
+			if (headers) schemas.push(headers.schema, ...headers.deps);
+			schemas.push(...body.schemas, ...response.schemas);
+		}
 		const fullRoute = getFullRoute(route, verbs.servers ?? context.spec.servers, output.baseUrl);
 		if (!output.target) throw new Error("Output does not have a target");
 		const pathOperations = await generateOperations(output.client, verbsOptions, {
@@ -342,7 +340,7 @@ function dereferenceExternalRef(data) {
 	function scrub(obj) {
 		if (obj === null || obj === void 0) return obj;
 		if (Array.isArray(obj)) return obj.map((x) => scrub(x));
-		if (typeof obj === "object") {
+		if (isObject(obj)) {
 			const rec = obj;
 			const out = {};
 			for (const [k, v] of Object.entries(rec)) {
@@ -355,17 +353,17 @@ function dereferenceExternalRef(data) {
 	}
 	function replaceRefs(obj) {
 		if (obj === null || obj === void 0) return obj;
-		if (typeof obj === "object") {
-			if (Array.isArray(obj)) return obj.map((element) => replaceRefs(element));
+		if (Array.isArray(obj)) return obj.map((element) => replaceRefs(element));
+		if (isObject(obj)) {
 			const record = obj;
-			if ("$ref" in record && typeof record.$ref === "string") {
+			if ("$ref" in record && isString(record.$ref)) {
 				const refValue = record.$ref;
 				if (refValue.startsWith("#/x-ext/")) {
 					const parts = refValue.replace("#/x-ext/", "").split("/");
 					const extKey = parts.shift();
 					if (extKey) {
 						let refObj = extensions[extKey];
-						for (const p of parts) if (refObj && typeof refObj === "object" && p in refObj) refObj = refObj[p];
+						for (const p of parts) if (refObj && (isObject(refObj) || Array.isArray(refObj)) && p in refObj) refObj = refObj[p];
 						else {
 							refObj = void 0;
 							break;
@@ -414,7 +412,7 @@ const loadPackageJson = async (packageJson, workspace = process.cwd()) => {
 		const pkgPath = await findUp(["package.json"], { cwd: workspace });
 		if (pkgPath) {
 			const pkg = await dynamicImport(pkgPath, workspace);
-			if (isPackageJson(pkg)) return await maybeReplaceCatalog(pkg, workspace);
+			if (isPackageJson(pkg)) return resolveAndAttachVersions(await maybeReplaceCatalog(pkg, workspace), workspace);
 			else throw new Error("Invalid package.json file");
 		}
 		return;
@@ -422,11 +420,19 @@ const loadPackageJson = async (packageJson, workspace = process.cwd()) => {
 	const normalizedPath = normalizePath(packageJson, workspace);
 	if (fs.existsSync(normalizedPath)) {
 		const pkg = await dynamicImport(normalizedPath);
-		if (isPackageJson(pkg)) return await maybeReplaceCatalog(pkg, workspace);
+		if (isPackageJson(pkg)) return resolveAndAttachVersions(await maybeReplaceCatalog(pkg, workspace), workspace);
 		else throw new Error(`Invalid package.json file: ${normalizedPath}`);
 	}
 };
-const isPackageJson = (obj) => typeof obj === "object" && obj !== null;
+const isPackageJson = (obj) => isObject(obj);
+const resolveAndAttachVersions = (pkg, workspace) => {
+	const resolved = resolveInstalledVersions(pkg, workspace);
+	if (Object.keys(resolved).length > 0) {
+		pkg.resolvedVersions = resolved;
+		for (const [name$1, version$1] of Object.entries(resolved)) log(`  ${chalk.cyan("Detected")} ${chalk.green(name$1)} ${chalk.cyan(`v${version$1}`)} ${chalk.dim("(from node_modules)")}`);
+	}
+	return pkg;
+};
 const hasCatalogReferences = (pkg) => {
 	return [
 		...Object.entries(pkg.dependencies ?? {}),
@@ -453,7 +459,7 @@ const loadPackageJsonCatalog = async (workspace) => {
 	const filePaths = await findUpMultiple("package.json", { cwd: workspace });
 	for (const filePath of filePaths) try {
 		const pkg = await fs.readJson(filePath);
-		if (pkg?.catalog || pkg?.catalogs) return {
+		if (pkg.catalog || pkg.catalogs) return {
 			catalog: pkg.catalog,
 			catalogs: pkg.catalogs
 		};
@@ -518,7 +524,7 @@ const performSubstitution = (dependencies, catalogData) => {
 //#endregion
 //#region src/utils/tsconfig.ts
 const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
-	if (isUndefined(tsconfig)) {
+	if (isNullish(tsconfig)) {
 		const configPath = await findUp(["tsconfig.json", "jsconfig.json"], { cwd: workspace });
 		if (configPath) return (await parse(configPath)).tsconfig;
 		return;
@@ -527,7 +533,7 @@ const loadTsconfig = async (tsconfig, workspace = process.cwd()) => {
 		const normalizedPath = normalizePath(tsconfig, workspace);
 		if (fs.existsSync(normalizedPath)) {
 			const config = await parse(normalizedPath);
-			return config.referenced?.find(({ tsconfigFile }) => tsconfigFile === normalizedPath)?.tsconfig || config.tsconfig;
+			return config.referenced?.find(({ tsconfigFile }) => tsconfigFile === normalizedPath)?.tsconfig ?? config.tsconfig;
 		}
 		return;
 	}
@@ -583,13 +589,13 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 	if (!options.output) throw new Error(chalk.red(`Config require an output`));
 	const inputOptions = isString(options.input) ? { target: options.input } : options.input;
 	const outputOptions = isString(options.output) ? { target: options.output } : options.output;
-	const outputWorkspace = normalizePath(outputOptions.workspace || "", workspace);
+	const outputWorkspace = normalizePath(outputOptions.workspace ?? "", workspace);
 	const { clean, prettier, client, httpClient, mode, biome } = globalOptions;
-	const tsconfig = await loadTsconfig(outputOptions.tsconfig || globalOptions.tsconfig, workspace);
-	const packageJson = await loadPackageJson(outputOptions.packageJson || globalOptions.packageJson, workspace);
+	const tsconfig = await loadTsconfig(outputOptions.tsconfig ?? globalOptions.tsconfig, workspace);
+	const packageJson = await loadPackageJson(outputOptions.packageJson ?? globalOptions.packageJson, workspace);
 	const mockOption = outputOptions.mock ?? globalOptions.mock;
 	let mock$1;
-	if (typeof mockOption === "boolean" && mockOption) mock$1 = DEFAULT_MOCK_OPTIONS;
+	if (isBoolean(mockOption) && mockOption) mock$1 = DEFAULT_MOCK_OPTIONS;
 	else if (isFunction(mockOption)) mock$1 = mockOption;
 	else if (mockOption) mock$1 = {
 		...DEFAULT_MOCK_OPTIONS,
@@ -618,8 +624,8 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 			target: globalOptions.output ? normalizePath(globalOptions.output, process.cwd()) : normalizePath(outputOptions.target, outputWorkspace),
 			schemas: normalizeSchemasOption(outputOptions.schemas, outputWorkspace),
 			operationSchemas: outputOptions.operationSchemas ? normalizePath(outputOptions.operationSchemas, outputWorkspace) : void 0,
-			namingConvention: outputOptions.namingConvention || NamingConvention.CAMEL_CASE,
-			fileExtension: outputOptions.fileExtension || defaultFileExtension,
+			namingConvention: outputOptions.namingConvention ?? NamingConvention.CAMEL_CASE,
+			fileExtension: outputOptions.fileExtension ?? defaultFileExtension,
 			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),
@@ -649,9 +655,9 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 				tags: normalizeOperationsAndTags(outputOptions.override?.tags ?? {}, outputWorkspace, { query: globalQueryOptions }),
 				mutator: normalizeMutator(outputWorkspace, outputOptions.override?.mutator),
 				formData: createFormData(outputWorkspace, outputOptions.override?.formData),
-				formUrlEncoded: (isBoolean(outputOptions.override?.formUrlEncoded) ? outputOptions.override?.formUrlEncoded : normalizeMutator(outputWorkspace, outputOptions.override?.formUrlEncoded)) ?? true,
+				formUrlEncoded: (isBoolean(outputOptions.override?.formUrlEncoded) ? outputOptions.override.formUrlEncoded : normalizeMutator(outputWorkspace, outputOptions.override?.formUrlEncoded)) ?? true,
 				paramsSerializer: normalizeMutator(outputWorkspace, outputOptions.override?.paramsSerializer),
-				header: outputOptions.override?.header === false ? false : isFunction(outputOptions.override?.header) ? outputOptions.override?.header : getDefaultFilesHeader,
+				header: outputOptions.override?.header === false ? false : isFunction(outputOptions.override?.header) ? outputOptions.override.header : getDefaultFilesHeader,
 				requestOptions: outputOptions.override?.requestOptions ?? true,
 				namingConvention: outputOptions.override?.namingConvention ?? {},
 				components: {
@@ -720,10 +726,10 @@ async function normalizeOptions(optionsExport, workspace = process.cwd(), global
 					runtimeValidation: outputOptions.override?.fetch?.runtimeValidation ?? false,
 					...outputOptions.override?.fetch
 				},
-				useDates: outputOptions.override?.useDates || false,
+				useDates: outputOptions.override?.useDates ?? false,
 				useDeprecatedOperations: outputOptions.override?.useDeprecatedOperations ?? true,
 				enumGenerationType: outputOptions.override?.enumGenerationType ?? "const",
-				suppressReadonlyModifier: outputOptions.override?.suppressReadonlyModifier || false,
+				suppressReadonlyModifier: outputOptions.override?.suppressReadonlyModifier ?? false,
 				aliasCombinedTypes: outputOptions.override?.aliasCombinedTypes ?? false
 			},
 			allParamsOptional: outputOptions.allParamsOptional ?? false,
@@ -743,7 +749,7 @@ function normalizeMutator(workspace, mutator) {
 		return {
 			...mutator,
 			path: upath.resolve(workspace, mutator.path),
-			default: (mutator.default || !mutator.name) ?? false
+			default: mutator.default ?? !mutator.name
 		};
 	}
 	if (isString(mutator)) return {
@@ -794,9 +800,9 @@ function normalizeOperationsAndTags(operationsOrTags, workspace, global) {
 					...zod$1.preprocess?.body ? { body: normalizeMutator(workspace, zod$1.preprocess.body) } : {},
 					...zod$1.preprocess?.response ? { response: normalizeMutator(workspace, zod$1.preprocess.response) } : {}
 				},
-				generateEachHttpStatus: zod$1?.generateEachHttpStatus ?? false,
-				dateTimeOptions: zod$1?.dateTimeOptions ?? {},
-				timeOptions: zod$1?.timeOptions ?? {}
+				generateEachHttpStatus: zod$1.generateEachHttpStatus ?? false,
+				dateTimeOptions: zod$1.dateTimeOptions ?? {},
+				timeOptions: zod$1.timeOptions ?? {}
 			} } : {},
 			...transformer ? { transformer: normalizePath(transformer, workspace) } : {},
 			...mutator ? { mutator: normalizeMutator(workspace, mutator) } : {},
@@ -815,25 +821,13 @@ function normalizeOutputMode(mode) {
 	return mode;
 }
 function normalizeHooks(hooks) {
-	return Object.keys(hooks).reduce((acc, key) => {
-		if (isString(hooks[key])) return {
-			...acc,
-			[key]: [hooks[key]]
-		};
-		else if (Array.isArray(hooks[key])) return {
-			...acc,
-			[key]: hooks[key]
-		};
-		else if (isFunction(hooks[key])) return {
-			...acc,
-			[key]: [hooks[key]]
-		};
-		else if (isObject(hooks[key])) return {
-			...acc,
-			[key]: [hooks[key]]
-		};
-		return acc;
-	}, {});
+	const keys = Object.keys(hooks);
+	const result = {};
+	for (const key of keys) if (isString(hooks[key])) result[key] = [hooks[key]];
+	else if (Array.isArray(hooks[key])) result[key] = hooks[key];
+	else if (isFunction(hooks[key])) result[key] = [hooks[key]];
+	else if (isObject(hooks[key])) result[key] = [hooks[key]];
+	return result;
 }
 function normalizeHonoOptions(hono$1 = {}, workspace) {
 	return {
@@ -849,37 +843,39 @@ function normalizeJSDocOptions(jsdoc = {}) {
 function normalizeQueryOptions(queryOptions = {}, outputWorkspace, globalOptions = {}) {
 	if (queryOptions.options) console.warn("[WARN] Using query options is deprecated and will be removed in a future major release. Please use queryOptions or mutationOptions instead.");
 	return {
-		...isUndefined(queryOptions.usePrefetch) ? {} : { usePrefetch: queryOptions.usePrefetch },
-		...isUndefined(queryOptions.useInvalidate) ? {} : { useInvalidate: queryOptions.useInvalidate },
-		...isUndefined(queryOptions.useQuery) ? {} : { useQuery: queryOptions.useQuery },
-		...isUndefined(queryOptions.useSuspenseQuery) ? {} : { useSuspenseQuery: queryOptions.useSuspenseQuery },
-		...isUndefined(queryOptions.useMutation) ? {} : { useMutation: queryOptions.useMutation },
-		...isUndefined(queryOptions.useInfinite) ? {} : { useInfinite: queryOptions.useInfinite },
-		...isUndefined(queryOptions.useSuspenseInfiniteQuery) ? {} : { useSuspenseInfiniteQuery: queryOptions.useSuspenseInfiniteQuery },
+		...isNullish(queryOptions.usePrefetch) ? {} : { usePrefetch: queryOptions.usePrefetch },
+		...isNullish(queryOptions.useInvalidate) ? {} : { useInvalidate: queryOptions.useInvalidate },
+		...isNullish(queryOptions.useQuery) ? {} : { useQuery: queryOptions.useQuery },
+		...isNullish(queryOptions.useSuspenseQuery) ? {} : { useSuspenseQuery: queryOptions.useSuspenseQuery },
+		...isNullish(queryOptions.useMutation) ? {} : { useMutation: queryOptions.useMutation },
+		...isNullish(queryOptions.useInfinite) ? {} : { useInfinite: queryOptions.useInfinite },
+		...isNullish(queryOptions.useSuspenseInfiniteQuery) ? {} : { useSuspenseInfiniteQuery: queryOptions.useSuspenseInfiniteQuery },
 		...queryOptions.useInfiniteQueryParam ? { useInfiniteQueryParam: queryOptions.useInfiniteQueryParam } : {},
 		...queryOptions.options ? { options: queryOptions.options } : {},
 		...globalOptions.queryKey ? { queryKey: globalOptions.queryKey } : {},
-		...queryOptions?.queryKey ? { queryKey: normalizeMutator(outputWorkspace, queryOptions?.queryKey) } : {},
+		...queryOptions.queryKey ? { queryKey: normalizeMutator(outputWorkspace, queryOptions.queryKey) } : {},
 		...globalOptions.queryOptions ? { queryOptions: globalOptions.queryOptions } : {},
-		...queryOptions?.queryOptions ? { queryOptions: normalizeMutator(outputWorkspace, queryOptions?.queryOptions) } : {},
+		...queryOptions.queryOptions ? { queryOptions: normalizeMutator(outputWorkspace, queryOptions.queryOptions) } : {},
 		...globalOptions.mutationOptions ? { mutationOptions: globalOptions.mutationOptions } : {},
-		...queryOptions?.mutationOptions ? { mutationOptions: normalizeMutator(outputWorkspace, queryOptions?.mutationOptions) } : {},
-		...isUndefined(globalOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: globalOptions.shouldExportQueryKey },
-		...isUndefined(queryOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: queryOptions.shouldExportQueryKey },
-		...isUndefined(globalOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: globalOptions.shouldExportHttpClient },
-		...isUndefined(queryOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: queryOptions.shouldExportHttpClient },
-		...isUndefined(globalOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: globalOptions.shouldExportMutatorHooks },
-		...isUndefined(queryOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: queryOptions.shouldExportMutatorHooks },
-		...isUndefined(globalOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: globalOptions.shouldSplitQueryKey },
-		...isUndefined(queryOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: queryOptions.shouldSplitQueryKey },
-		...isUndefined(globalOptions.signal) ? {} : { signal: globalOptions.signal },
-		...isUndefined(globalOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: globalOptions.useOperationIdAsQueryKey },
-		...isUndefined(queryOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: queryOptions.useOperationIdAsQueryKey },
-		...isUndefined(globalOptions.signal) ? {} : { signal: globalOptions.signal },
-		...isUndefined(queryOptions.signal) ? {} : { signal: queryOptions.signal },
-		...isUndefined(globalOptions.version) ? {} : { version: globalOptions.version },
-		...isUndefined(queryOptions.version) ? {} : { version: queryOptions.version },
-		...queryOptions.mutationInvalidates ? { mutationInvalidates: queryOptions.mutationInvalidates } : {}
+		...queryOptions.mutationOptions ? { mutationOptions: normalizeMutator(outputWorkspace, queryOptions.mutationOptions) } : {},
+		...isNullish(globalOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: globalOptions.shouldExportQueryKey },
+		...isNullish(queryOptions.shouldExportQueryKey) ? {} : { shouldExportQueryKey: queryOptions.shouldExportQueryKey },
+		...isNullish(globalOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: globalOptions.shouldExportHttpClient },
+		...isNullish(queryOptions.shouldExportHttpClient) ? {} : { shouldExportHttpClient: queryOptions.shouldExportHttpClient },
+		...isNullish(globalOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: globalOptions.shouldExportMutatorHooks },
+		...isNullish(queryOptions.shouldExportMutatorHooks) ? {} : { shouldExportMutatorHooks: queryOptions.shouldExportMutatorHooks },
+		...isNullish(globalOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: globalOptions.shouldSplitQueryKey },
+		...isNullish(queryOptions.shouldSplitQueryKey) ? {} : { shouldSplitQueryKey: queryOptions.shouldSplitQueryKey },
+		...isNullish(globalOptions.signal) ? {} : { signal: globalOptions.signal },
+		...isNullish(globalOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: globalOptions.useOperationIdAsQueryKey },
+		...isNullish(queryOptions.useOperationIdAsQueryKey) ? {} : { useOperationIdAsQueryKey: queryOptions.useOperationIdAsQueryKey },
+		...isNullish(globalOptions.signal) ? {} : { signal: globalOptions.signal },
+		...isNullish(queryOptions.signal) ? {} : { signal: queryOptions.signal },
+		...isNullish(globalOptions.version) ? {} : { version: globalOptions.version },
+		...isNullish(queryOptions.version) ? {} : { version: queryOptions.version },
+		...queryOptions.mutationInvalidates ? { mutationInvalidates: queryOptions.mutationInvalidates } : {},
+		...isNullish(globalOptions.runtimeValidation) ? {} : { runtimeValidation: globalOptions.runtimeValidation },
+		...isNullish(queryOptions.runtimeValidation) ? {} : { runtimeValidation: queryOptions.runtimeValidation }
 	};
 }
 function getDefaultFilesHeader({ title, description: description$1, version: version$1 } = {}) {
@@ -914,7 +910,7 @@ async function startWatcher(watchOptions, watchFn, defaultTarget = ".") {
 	if (!watchOptions) return;
 	const { watch } = await import("chokidar");
 	const ignored = ["**/{.git,node_modules}/**"];
-	const watchPaths = typeof watchOptions === "boolean" ? defaultTarget : watchOptions;
+	const watchPaths = isBoolean(watchOptions) ? defaultTarget : watchOptions;
 	log(`Watching for changes in ${Array.isArray(watchPaths) ? watchPaths.map((v) => "\"" + v + "\"").join(" | ") : "\"" + watchPaths + "\""}`);
 	watch(watchPaths, {
 		ignorePermissionErrors: true,
@@ -929,14 +925,40 @@ async function startWatcher(watchOptions, watchFn, defaultTarget = ".") {
 
 //#endregion
 //#region src/write-zod-specs.ts
-function generateZodSchemaFileContent(header, schemaName, zodContent) {
+function generateZodSchemaFileContent(header, schemas) {
 	return `${header}import { z as zod } from 'zod';
 
-export const ${schemaName} = ${zodContent}
+${schemas.map(({ schemaName, consts, zodExpression }) => {
+		return `${consts ? `${consts}\n` : ""}export const ${schemaName} = ${zodExpression}
 
-export type ${schemaName} = zod.infer<typeof ${schemaName}>;
+export type ${schemaName} = zod.infer<typeof ${schemaName}>;`;
+	}).join("\n\n")}
 `;
 }
+const isValidSchemaIdentifier = (name$1) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(name$1);
+const isPrimitiveSchemaName = (name$1) => [
+	"string",
+	"number",
+	"boolean",
+	"void",
+	"unknown",
+	"Blob"
+].includes(name$1);
+const dedupeSchemasByName = (schemas) => {
+	const uniqueSchemas = /* @__PURE__ */ new Map();
+	for (const schema of schemas) if (!uniqueSchemas.has(schema.name)) uniqueSchemas.set(schema.name, schema);
+	return [...uniqueSchemas.values()];
+};
+const groupSchemasByFilePath = (schemas) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const schema of schemas) {
+		const key = schema.filePath.toLowerCase();
+		const existingGroup = grouped.get(key);
+		if (existingGroup) existingGroup.push(schema);
+		else grouped.set(key, [schema]);
+	}
+	return [...grouped.values()].map((group) => [...group].toSorted((a, b) => a.filePath.localeCompare(b.filePath))).toSorted((a, b) => a[0].filePath.localeCompare(b[0].filePath));
+};
 async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNames, namingConvention, shouldMergeExisting = false) {
 	const importFileExtension = fileExtension.replace(/\.ts$/, "");
 	const indexPath = upath.join(schemasPath, `index${fileExtension}`);
@@ -949,16 +971,20 @@ async function writeZodSchemaIndex(schemasPath, fileExtension, header, schemaNam
 	}
 	const newExports = schemaNames.map((schemaName) => {
 		return `export * from './${conventionName(schemaName, namingConvention)}${importFileExtension}';`;
-	}).sort().join("\n");
+	}).toSorted().join("\n");
 	const allExports = existingExports ? `${existingExports}\n${newExports}` : newExports;
-	const uniqueExports = [...new Set(allExports.split("\n"))].filter((line) => line.trim()).sort().join("\n");
+	const uniqueExports = [...new Set(allExports.split("\n"))].filter((line) => line.trim()).toSorted().join("\n");
 	await fs.outputFile(indexPath, `${header}\n${uniqueExports}\n`);
 }
 async function writeZodSchemas(builder, schemasPath, fileExtension, header, output) {
 	const schemasWithOpenApiDef = builder.schemas.filter((s) => s.schema);
-	await Promise.all(schemasWithOpenApiDef.map(async (generatorSchema) => {
+	const schemasToWrite = [];
+	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
+	const strict = output.override.zod.strict.body;
+	const coerce = output.override.zod.coerce.body;
+	for (const generatorSchema of schemasWithOpenApiDef) {
 		const { name: name$1, schema: schemaObject } = generatorSchema;
-		if (!schemaObject) return;
+		if (!schemaObject) continue;
 		const fileName = conventionName(name$1, output.namingConvention);
 		const filePath = upath.join(schemasPath, `${fileName}${fileExtension}`);
 		const context = {
@@ -967,60 +993,84 @@ async function writeZodSchemas(builder, schemasPath, fileExtension, header, outp
 			workspace: "",
 			output
 		};
-		const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
-		const strict = typeof output.override?.zod?.strict === "object" ? output.override.zod.strict.body ?? false : output.override?.zod?.strict ?? false;
-		const coerce = typeof output.override?.zod?.coerce === "object" ? output.override.zod.coerce.body ?? false : output.override?.zod?.coerce ?? false;
 		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(dereference(schemaObject, context), context, name$1, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
-		const fileContent = generateZodSchemaFileContent(header, name$1, parsedZodDefinition.consts ? `${parsedZodDefinition.consts}\n${parsedZodDefinition.zod}` : parsedZodDefinition.zod);
-		await fs.outputFile(filePath, fileContent);
-	}));
-	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, schemasWithOpenApiDef.map((schema) => schema.name), output.namingConvention, false);
+		schemasToWrite.push({
+			schemaName: name$1,
+			filePath,
+			consts: parsedZodDefinition.consts,
+			zodExpression: parsedZodDefinition.zod
+		});
+	}
+	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
+	for (const schemaGroup of groupedSchemasToWrite) {
+		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
+		await fs.outputFile(schemaGroup[0].filePath, fileContent);
+	}
+	if (output.indexFiles) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, false);
 }
 async function writeZodSchemasFromVerbs(verbOptions, schemasPath, fileExtension, header, output, context) {
+	const zodContext = context;
 	const verbOptionsArray = Object.values(verbOptions);
 	if (verbOptionsArray.length === 0) return;
 	const isZodV4 = !!output.packageJson && isZodVersionV4(output.packageJson);
-	const strict = typeof output.override?.zod?.strict === "object" ? output.override.zod.strict.body ?? false : output.override?.zod?.strict ?? false;
-	const coerce = typeof output.override?.zod?.coerce === "object" ? output.override.zod.coerce.body ?? false : output.override?.zod?.coerce ?? false;
-	const generateVerbsSchemas = verbOptionsArray.flatMap((verbOption) => {
+	const strict = output.override.zod.strict.body;
+	const coerce = output.override.zod.coerce.body;
+	const uniqueVerbsSchemas = dedupeSchemasByName(verbOptionsArray.flatMap((verbOption) => {
 		const operation = verbOption.originalOperation;
-		const bodySchema = operation.requestBody && "content" in operation.requestBody ? operation.requestBody.content["application/json"]?.schema : void 0;
+		const requestBody = operation.requestBody;
+		const bodySchema = (requestBody && "content" in requestBody ? requestBody.content : void 0)?.["application/json"]?.schema;
 		const bodySchemas = bodySchema ? [{
 			name: `${pascal(verbOption.operationName)}Body`,
-			schema: dereference(bodySchema, context)
+			schema: dereference(bodySchema, zodContext)
 		}] : [];
-		const queryParams = operation.parameters?.filter((p) => "in" in p && p.in === "query");
+		const parameters = operation.parameters;
+		const queryParams = parameters?.filter((p) => "in" in p && p.in === "query");
 		const queryParamsSchemas = queryParams && queryParams.length > 0 ? [{
 			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, context)])),
-				required: queryParams.filter((p) => p.required).map((p) => p.name)
+				properties: Object.fromEntries(queryParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, zodContext)])),
+				required: queryParams.filter((p) => p.required).map((p) => p.name).filter((name$1) => name$1 !== void 0)
 			}
 		}] : [];
-		const headerParams = operation.parameters?.filter((p) => "in" in p && p.in === "header");
+		const headerParams = parameters?.filter((p) => "in" in p && p.in === "header");
 		const headerParamsSchemas = headerParams && headerParams.length > 0 ? [{
 			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, context)])),
-				required: headerParams.filter((p) => p.required).map((p) => p.name)
+				properties: Object.fromEntries(headerParams.filter((p) => "schema" in p && p.schema).map((p) => [p.name, dereference(p.schema, zodContext)])),
+				required: headerParams.filter((p) => p.required).map((p) => p.name).filter((name$1) => name$1 !== void 0)
 			}
 		}] : [];
-		return [
+		const responseSchemas = [...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)
+		}));
+		return dedupeSchemasByName([
 			...bodySchemas,
 			...queryParamsSchemas,
-			...headerParamsSchemas
-		];
-	});
-	await Promise.all(generateVerbsSchemas.map(async ({ name: name$1, schema }) => {
+			...headerParamsSchemas,
+			...responseSchemas
+		]);
+	}));
+	const schemasToWrite = [];
+	for (const { name: name$1, schema } of uniqueVerbsSchemas) {
 		const fileName = conventionName(name$1, output.namingConvention);
 		const filePath = upath.join(schemasPath, `${fileName}${fileExtension}`);
-		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, context, name$1, strict, isZodV4, { required: true }), context, coerce, strict, isZodV4);
-		const fileContent = generateZodSchemaFileContent(header, name$1, parsedZodDefinition.consts ? `${parsedZodDefinition.consts}\n${parsedZodDefinition.zod}` : parsedZodDefinition.zod);
-		await fs.outputFile(filePath, fileContent);
-	}));
-	if (output.indexFiles && generateVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, generateVerbsSchemas.map((s) => s.name), output.namingConvention, true);
+		const parsedZodDefinition = parseZodValidationSchemaDefinition(generateZodValidationSchemaDefinition(schema, zodContext, name$1, strict, isZodV4, { required: true }), zodContext, coerce, strict, isZodV4);
+		schemasToWrite.push({
+			schemaName: name$1,
+			filePath,
+			consts: parsedZodDefinition.consts,
+			zodExpression: parsedZodDefinition.zod
+		});
+	}
+	const groupedSchemasToWrite = groupSchemasByFilePath(schemasToWrite);
+	for (const schemaGroup of groupedSchemasToWrite) {
+		const fileContent = generateZodSchemaFileContent(header, schemaGroup);
+		await fs.outputFile(schemaGroup[0].filePath, fileContent);
+	}
+	if (output.indexFiles && uniqueVerbsSchemas.length > 0) await writeZodSchemaIndex(schemasPath, fileExtension, header, groupedSchemasToWrite.map((schemaGroup) => schemaGroup[0].schemaName), output.namingConvention, true);
 }
 
 //#endregion
@@ -1038,12 +1088,12 @@ async function addOperationSchemasReExport(schemaPath, operationSchemasPath, fil
 	const relativePath = upath.relativeSafe(schemaPath, operationSchemasPath);
 	const schemaIndexPath = upath.join(schemaPath, `index${fileExtension}`);
 	const exportLine = `export * from '${relativePath}';\n`;
-	if (!await fs.pathExists(schemaIndexPath)) {
+	if (await fs.pathExists(schemaIndexPath)) {
+		const existingContent = await fs.readFile(schemaIndexPath, "utf8");
+		if (!new RegExp(String.raw`export\s*\*\s*from\s*['"]${relativePath.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)}['"]`).test(existingContent)) await fs.appendFile(schemaIndexPath, exportLine);
+	} else {
 		const content = header && header.trim().length > 0 ? `${header}\n${exportLine}` : exportLine;
 		await fs.outputFile(schemaIndexPath, content);
-	} else {
-		const existingContent = await fs.readFile(schemaIndexPath, "utf8");
-		if (!(/* @__PURE__ */ new RegExp(`export\\s*\\*\\s*from\\s*['"]${relativePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]`)).test(existingContent)) await fs.appendFile(schemaIndexPath, exportLine);
 	}
 }
 async function writeSpecs(builder, workspace, options, projectName) {
@@ -1058,8 +1108,8 @@ async function writeSpecs(builder, workspace, options, projectName) {
 			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);
-			fixRegularSchemaImports(regularSchemas, operationSchemaNames, schemaPath, output.operationSchemas, output.namingConvention);
+			fixCrossDirectoryImports(opSchemas, regularSchemaNames, schemaPath, output.operationSchemas, output.namingConvention, fileExtension);
+			fixRegularSchemaImports(regularSchemas, operationSchemaNames, schemaPath, output.operationSchemas, output.namingConvention, fileExtension);
 			if (regularSchemas.length > 0) await writeSchemas({
 				schemaPath,
 				schemas: regularSchemas,
@@ -1090,56 +1140,53 @@ async function writeSpecs(builder, workspace, options, projectName) {
 			header,
 			indexFiles: output.indexFiles
 		});
-	} else {
-		const schemaType = output.schemas.type;
-		if (schemaType === "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);
-				fixRegularSchemaImports(regularSchemas, operationSchemaNames, output.schemas.path, output.operationSchemas, output.namingConvention);
-				if (regularSchemas.length > 0) await writeSchemas({
-					schemaPath: output.schemas.path,
-					schemas: regularSchemas,
-					target,
-					namingConvention: output.namingConvention,
-					fileExtension,
-					header,
-					indexFiles: output.indexFiles
-				});
-				if (opSchemas.length > 0) {
-					await writeSchemas({
-						schemaPath: output.operationSchemas,
-						schemas: opSchemas,
-						target,
-						namingConvention: output.namingConvention,
-						fileExtension,
-						header,
-						indexFiles: output.indexFiles
-					});
-					if (output.indexFiles) await addOperationSchemasReExport(output.schemas.path, output.operationSchemas, fileExtension, header);
-				}
-			} else await writeSchemas({
+	} 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);
+			fixRegularSchemaImports(regularSchemas, operationSchemaNames, output.schemas.path, output.operationSchemas, output.namingConvention, fileExtension);
+			if (regularSchemas.length > 0) await writeSchemas({
 				schemaPath: output.schemas.path,
-				schemas,
+				schemas: regularSchemas,
 				target,
 				namingConvention: output.namingConvention,
 				fileExtension,
 				header,
 				indexFiles: output.indexFiles
 			});
-		} else if (schemaType === "zod") {
-			const fileExtension = ".zod.ts";
-			await writeZodSchemas(builder, output.schemas.path, fileExtension, header, output);
-			if (builder.verbOptions) await writeZodSchemasFromVerbs(builder.verbOptions, output.schemas.path, fileExtension, header, output, {
-				spec: builder.spec,
-				target: builder.target,
-				workspace,
-				output
-			});
-		}
+			if (opSchemas.length > 0) {
+				await writeSchemas({
+					schemaPath: output.operationSchemas,
+					schemas: opSchemas,
+					target,
+					namingConvention: output.namingConvention,
+					fileExtension,
+					header,
+					indexFiles: output.indexFiles
+				});
+				if (output.indexFiles) await addOperationSchemasReExport(output.schemas.path, output.operationSchemas, fileExtension, header);
+			}
+		} else await writeSchemas({
+			schemaPath: output.schemas.path,
+			schemas,
+			target,
+			namingConvention: output.namingConvention,
+			fileExtension,
+			header,
+			indexFiles: output.indexFiles
+		});
+	} 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
+		});
 	}
 	let implementationPaths = [];
 	if (output.target) implementationPaths = await getWriteMode(output.mode)({
@@ -1154,7 +1201,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		const workspacePath = output.workspace;
 		const imports = implementationPaths.filter((path$1) => !output.mock || !path$1.endsWith(`.${getMockFileExtensionByTypeName(output.mock)}.ts`)).map((path$1) => upath.relativeSafe(workspacePath, getFileInfo(path$1).pathWithoutExtension));
 		if (output.schemas) {
-			const schemasPath = typeof output.schemas === "string" ? output.schemas : output.schemas.path;
+			const schemasPath = isString(output.schemas) ? output.schemas : output.schemas.path;
 			imports.push(upath.relativeSafe(workspacePath, getFileInfo(schemasPath).dirname));
 		}
 		if (output.operationSchemas) imports.push(upath.relativeSafe(workspacePath, getFileInfo(output.operationSchemas).dirname));
@@ -1173,7 +1220,7 @@ async function writeSpecs(builder, workspace, options, projectName) {
 		implementationPaths = [...implementationPaths, ...builder.extraFiles.map((file) => file.path)];
 	}
 	const paths = [
-		...output.schemas ? [getFileInfo(typeof output.schemas === "string" ? output.schemas : output.schemas.path).dirname] : [],
+		...output.schemas ? [getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path).dirname] : [],
 		...output.operationSchemas ? [getFileInfo(output.operationSchemas).dirname] : [],
 		...implementationPaths
 	];
@@ -1196,9 +1243,9 @@ async function writeSpecs(builder, workspace, options, projectName) {
 	}
 	if (output.docs) try {
 		let config = {};
-		let configPath = null;
-		if (typeof output.docs === "object") {
-			({configPath = null, ...config} = output.docs);
+		let configPath;
+		if (isObject(output.docs)) {
+			({configPath, ...config} = output.docs);
 			if (configPath) config.options = configPath;
 		}
 		const getTypedocApplication = async () => {
@@ -1227,7 +1274,6 @@ function getWriteMode(mode) {
 		case OutputMode.SPLIT: return writeSplitMode;
 		case OutputMode.TAGS: return writeTagsMode;
 		case OutputMode.TAGS_SPLIT: return writeSplitTagsMode;
-		case OutputMode.SINGLE:
 		default: return writeSingleMode;
 	}
 }
@@ -1253,11 +1299,14 @@ async function generateSpec(workspace, options, projectName) {
 			"!**/*.d.ts",
 			...extraPatterns
 		], getFileInfo(options.output.target).dirname);
-		if (options.output.schemas) await removeFilesAndEmptyFolders([
-			"**/*",
-			"!**/*.d.ts",
-			...extraPatterns
-		], getFileInfo(options.output.schemas).dirname);
+		if (options.output.schemas) {
+			const schemasPath = isString(options.output.schemas) ? options.output.schemas : options.output.schemas.path;
+			await removeFilesAndEmptyFolders([
+				"**/*",
+				"!**/*.d.ts",
+				...extraPatterns
+			], getFileInfo(schemasPath).dirname);
+		}
 		log(`${projectName} Cleaning output folder`);
 	}
 	await writeSpecs(await importSpecs(workspace, options, projectName), workspace, options, projectName);
@@ -1316,4 +1365,4 @@ async function loadConfigFile(configFilePath) {
 
 //#endregion
 export { defineConfig as a, name as c, startWatcher as i, version as l, loadConfigFile as n, normalizeOptions as o, generateSpec as r, description as s, findConfigFile as t };
-//# sourceMappingURL=config-CfalXEai.mjs.map
+//# sourceMappingURL=config-FnusrAiH.mjs.map