@orval/core 8.2.0 → 8.4.0

package/dist/index.mjs

@@ -1,12 +1,13 @@
-import { t as __export } from "./chunk-C6wwvPpM.mjs";
-import { entries, groupBy, isArray, isEmptyish, prop, unique, uniqueBy, uniqueWith } from "remeda";
+import { t as __export } from "./chunk-1-as6MWF.mjs";
+import { createRequire } from "node:module";
+import { entries, groupBy, isArray, isBoolean, isBoolean as isBoolean$1, isEmptyish, isFunction, isNullish, isNullish as isNullish$1, isNumber, isString, isString as isString$1, prop, unique, uniqueBy, uniqueWith } from "remeda";
 import { keyword } from "esutils";
 import path from "node:path";
-import fs from "node:fs";
-import { globby } from "globby";
 import { compare } from "compare-versions";
 import debug from "debug";
 import { pathToFileURL } from "node:url";
+import fs, { existsSync, readFileSync } from "node:fs";
+import { globby } from "globby";
 import readline from "node:readline";
 import chalk from "chalk";
 import { isDereferenced } from "@scalar/openapi-types/helpers";
@@ -108,124 +109,20 @@ const generalJSTypes = [
 	"object",
 	"blob"
 ];
-const generalJSTypesWithArray = generalJSTypes.reduce((acc, type) => {
-	acc.push(type, `Array<${type}>`, `${type}[]`);
-	return acc;
-}, []);
+const generalJSTypesWithArray = generalJSTypes.flatMap((type) => [
+	type,
+	`Array<${type}>`,
+	`${type}[]`
+]);
 const VERBS_WITH_BODY = [
 	Verbs.POST,
 	Verbs.PUT,
 	Verbs.PATCH,
 	Verbs.DELETE
 ];
-const URL_REGEX = /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$/;
+const URL_REGEX = /^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w.-]+)+[\w\-._~:/?#[\]@!$&'()*+,;=.]+$/;
 const TEMPLATE_TAG_REGEX = /\${(.+?)}/g;
 
-//#endregion
-//#region src/utils/extension.ts
-function getExtension(path$2) {
-	return path$2.toLowerCase().includes(".yaml") || path$2.toLowerCase().includes(".yml") ? "yaml" : "json";
-}
-
-//#endregion
-//#region src/utils/file.ts
-function getFileInfo(target = "", { backupFilename = "filename", extension = ".ts" } = {}) {
-	const isDir = isDirectory(target);
-	const filePath = isDir ? path.join(target, backupFilename + extension) : target;
-	return {
-		path: filePath,
-		pathWithoutExtension: filePath.replace(/\.[^/.]+$/, ""),
-		extension,
-		isDirectory: isDir,
-		dirname: path.dirname(filePath),
-		filename: path.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
-	};
-}
-async function removeFilesAndEmptyFolders(patterns, dir) {
-	const files = await globby(patterns, {
-		cwd: dir,
-		absolute: true
-	});
-	await Promise.all(files.map((file) => fs.promises.unlink(file)));
-	const sortedDirectories = (await globby(["**/*"], {
-		cwd: dir,
-		absolute: true,
-		onlyDirectories: true
-	})).toSorted((a, b) => {
-		const depthA = a.split("/").length;
-		return b.split("/").length - depthA;
-	});
-	for (const directory of sortedDirectories) try {
-		if ((await fs.promises.readdir(directory)).length === 0) await fs.promises.rmdir(directory);
-	} catch {}
-}
-
-//#endregion
-//#region src/utils/path.ts
-var path_exports = /* @__PURE__ */ __export({
-	basename: () => basename,
-	dirname: () => dirname,
-	extname: () => extname,
-	getSchemaFileName: () => getSchemaFileName,
-	isAbsolute: () => isAbsolute,
-	join: () => join,
-	joinSafe: () => joinSafe,
-	normalizeSafe: () => normalizeSafe,
-	relativeSafe: () => relativeSafe,
-	resolve: () => resolve,
-	separator: () => separator
-});
-const path$1 = {};
-const isFunction$1 = (val) => typeof val == "function";
-const isString$1 = (val) => {
-	if (typeof val === "string") return true;
-	if (typeof val === "object" && val !== null) return Object.toString.call(val) == "[object String]";
-	return false;
-};
-for (const [propName, propValue] of Object.entries(path)) if (isFunction$1(propValue)) path$1[propName] = ((propName$1) => {
-	return (...args) => {
-		args = args.map((p) => {
-			return isString$1(p) ? toUnix(p) : p;
-		});
-		const result = path[propName$1](...args);
-		return isString$1(result) ? toUnix(result) : result;
-	};
-})(propName);
-else path$1[propName] = propValue;
-const { join, resolve, extname, dirname, basename, isAbsolute } = path$1;
-/**
-* Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
-*/
-function relativeSafe(from, to) {
-	return normalizeSafe(`.${separator}${path$1.relative(from, to)}`);
-}
-function getSchemaFileName(path$2) {
-	return path$2.replace(`.${getExtension(path$2)}`, "").slice(path$2.lastIndexOf("/") + 1);
-}
-const separator = "/";
-const toUnix = function(value) {
-	value = value.replaceAll("\\", "/");
-	value = value.replaceAll(/(?<!^)\/+/g, "/");
-	return value;
-};
-function normalizeSafe(value) {
-	let result;
-	value = toUnix(value);
-	result = path$1.normalize(value);
-	if (value.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
-	else if (value.startsWith("//") && !result.startsWith("//")) result = value.startsWith("//./") ? "//." + result : "/" + result;
-	return result;
-}
-function joinSafe(...values) {
-	let result = path$1.join(...values);
-	if (values.length > 0) {
-		const firstValue = toUnix(values[0]);
-		if (firstValue.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
-		else if (firstValue.startsWith("//") && !result.startsWith("//")) result = firstValue.startsWith("//./") ? "//." + result : "/" + result;
-	}
-	return result;
-}
-
 //#endregion
 //#region src/utils/assertion.ts
 /**
@@ -234,42 +131,29 @@ function joinSafe(...values) {
 * @param property
 */
 function isReference(obj) {
-	return !isNull(obj) && Object.hasOwn(obj, "$ref");
+	return !isNullish$1(obj) && Object.hasOwn(obj, "$ref");
 }
-function isDirectory(path$2) {
-	return !extname(path$2);
+function isDirectory(pathValue) {
+	return !path.extname(pathValue);
 }
 function isObject(x) {
 	return Object.prototype.toString.call(x) === "[object Object]";
 }
+function isStringLike(val) {
+	if (isString$1(val)) return true;
+	return Object.prototype.toString.call(val) === "[object String]";
+}
 function isModule(x) {
 	return Object.prototype.toString.call(x) === "[object Module]";
 }
-function isString(x) {
-	return typeof x === "string";
-}
-function isNumber(x) {
-	return typeof x === "number";
-}
 function isNumeric(x) {
-	return /^-?\d+$/.test(x);
-}
-function isBoolean(x) {
-	return typeof x === "boolean";
-}
-function isFunction(x) {
-	return typeof x === "function";
-}
-function isUndefined(x) {
-	return x === void 0;
-}
-function isNull(x) {
-	return x === null;
+	if (typeof x === "number") return Number.isInteger(x);
+	return isString$1(x) && /^-?\d+$/.test(x);
 }
 function isSchema(x) {
 	if (!isObject(x)) return false;
-	if (isString(x.type) && Object.values(SchemaType).includes(x.type)) return true;
-	const combine = x.allOf || x.anyOf || x.oneOf;
+	if (isString$1(x.type) && Object.values(SchemaType).includes(x.type)) return true;
+	const combine = x.allOf ?? x.anyOf ?? x.oneOf;
 	if (Array.isArray(combine)) return true;
 	if (isObject(x.properties)) return true;
 	return false;
@@ -278,27 +162,26 @@ function isVerb(verb) {
 	return Object.values(Verbs).includes(verb);
 }
 function isUrl(str) {
-	let givenURL;
+	if (!str.trim()) return false;
 	try {
-		givenURL = new URL(str);
+		const url = new URL(str);
+		return ["http:", "https:"].includes(url.protocol);
 	} catch {
 		return false;
 	}
-	return givenURL.protocol === "http:" || givenURL.protocol === "https:";
 }
 
 //#endregion
 //#region src/utils/async-reduce.ts
 async function asyncReduce(array, reducer, initValue) {
-	let accumulate = typeof initValue === "object" ? Object.create(initValue) : initValue;
+	let accumulate = initValue === null || initValue === Object(initValue) && !isFunction(initValue) ? Object.create(initValue) : initValue;
 	for (const item of array) accumulate = await reducer(accumulate, item);
 	return accumulate;
 }
 
 //#endregion
 //#region src/utils/case.ts
-const unicodes = function(s, prefix) {
-	prefix = prefix || "";
+const unicodes = function(s, prefix = "") {
 	return s.replaceAll(/(^|-)/g, String.raw`$1\u` + prefix).replaceAll(",", String.raw`\u` + prefix);
 };
 const symbols = unicodes("20-26,28-2F,3A-40,5B-60,7B-7E,A0-BF,D7,F7", "00");
@@ -320,8 +203,8 @@ const regexps = {
 const deapostrophe = (s) => {
 	return s.replace(regexps.apostrophe, "");
 };
-const up = String.prototype.toUpperCase;
-const low = String.prototype.toLowerCase;
+const up = (s) => s.toUpperCase();
+const low = (s) => s.toLowerCase();
 const fill = (s, fillWith, isDeapostrophe = false) => {
 	s = s.replace(regexps.fill, function(m, next) {
 		return next ? fillWith + next : "";
@@ -330,14 +213,13 @@ const fill = (s, fillWith, isDeapostrophe = false) => {
 	return s;
 };
 const decap = (s, char = 0) => {
-	return low.call(s.charAt(char)) + s.slice(char + 1);
+	return low(s.charAt(char)) + s.slice(char + 1);
 };
 const relax = (m, before, acronym, caps) => {
 	return before + " " + (acronym ? acronym + " " : "") + caps;
 };
 const prep = (s, isFill = false, isPascal = false, isUpper = false) => {
-	s = s == void 0 ? "" : s + "";
-	if (!isUpper && regexps.upper.test(s)) s = low.call(s);
+	if (!isUpper && regexps.upper.test(s)) s = low(s);
 	if (!isFill && !regexps.hole.test(s)) {
 		var holey = fill(s, " ");
 		if (regexps.hole.test(holey)) s = holey;
@@ -346,20 +228,20 @@ const prep = (s, isFill = false, isPascal = false, isUpper = false) => {
 	return s;
 };
 const lower = (s, fillWith, isDeapostrophe) => {
-	return fill(low.call(prep(s, !!fillWith)), fillWith, isDeapostrophe);
+	return fill(low(prep(s, !!fillWith)), fillWith, isDeapostrophe);
 };
 const pascalMemory = {};
-function pascal(s) {
+function pascal(s = "") {
 	if (pascalMemory[s]) return pascalMemory[s];
-	const isStartWithUnderscore = s?.startsWith("_");
-	if (regexps.upper.test(s)) s = low.call(s);
-	const pascalString = (s?.match(/[a-zA-Z0-9\u00C0-\u017F]+/g) || []).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+	const isStartWithUnderscore = s.startsWith("_");
+	if (regexps.upper.test(s)) s = low(s);
+	const pascalString = (s.match(/[a-zA-Z0-9\u00C0-\u017F]+/g) ?? []).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
 	const pascalWithUnderscore = isStartWithUnderscore ? `_${pascalString}` : pascalString;
 	pascalMemory[s] = pascalWithUnderscore;
 	return pascalWithUnderscore;
 }
-function camel(s) {
-	const isStartWithUnderscore = s?.startsWith("_");
+function camel(s = "") {
+	const isStartWithUnderscore = s.startsWith("_");
 	const camelString = decap(pascal(s), isStartWithUnderscore ? 1 : 0);
 	return isStartWithUnderscore ? `_${camelString}` : camelString;
 }
@@ -370,7 +252,7 @@ function kebab(s) {
 	return lower(s, "-", true);
 }
 function upper(s, fillWith, isDeapostrophe) {
-	return fill(up.call(prep(s, !!fillWith, false, true)), fillWith, isDeapostrophe);
+	return fill(up(prep(s, !!fillWith, false, true)), fillWith, isDeapostrophe);
 }
 function conventionName(name, convention) {
 	let nameConventionTransform = camel;
@@ -388,6 +270,14 @@ function conventionName(name, convention) {
 	return nameConventionTransform(name);
 }
 
+//#endregion
+//#region src/utils/compare-version.ts
+function compareVersions(firstVersion, secondVersions, operator = ">=") {
+	if (firstVersion === "latest" || firstVersion === "*") return true;
+	if (firstVersion.startsWith("catalog:")) return true;
+	return compare(firstVersion.replace(/(\s(.*))/, ""), secondVersions, operator);
+}
+
 //#endregion
 //#region src/utils/content-type.ts
 /**
@@ -435,16 +325,38 @@ function isBinaryContentType(contentType) {
 function getFormDataFieldFileType(resolvedSchema, partContentType) {
 	if (resolvedSchema.type !== "string") return;
 	if (resolvedSchema.contentEncoding) return;
-	const effectiveContentType = partContentType ?? resolvedSchema.contentMediaType;
+	const contentMediaType = resolvedSchema.contentMediaType;
+	const effectiveContentType = partContentType ?? contentMediaType;
 	if (effectiveContentType) return isBinaryContentType(effectiveContentType) ? "binary" : "text";
 }
-
-//#endregion
-//#region src/utils/compare-version.ts
-function compareVersions(firstVersion, secondVersions, operator = ">=") {
-	if (firstVersion === "latest" || firstVersion === "*") return true;
-	if (firstVersion.startsWith("catalog:")) return true;
-	return compare(firstVersion.replace(/(\s(.*))/, ""), secondVersions, operator);
+/**
+* Filters items by content type based on include/exclude rules
+*
+* @param items - Array of items with contentType property
+* @param filter - Optional filter configuration
+* @returns Filtered array
+*
+* @example
+* ```ts
+* const types = [
+*   { contentType: 'application/json', value: '...' },
+*   { contentType: 'text/xml', value: '...' }
+* ];
+*
+* // Include only JSON
+* filterByContentType(types, { include: ['application/json'] });
+*
+* // Exclude XML
+* filterByContentType(types, { exclude: ['text/xml'] });
+* ```
+*/
+function filterByContentType(items, filter$1) {
+	if (!filter$1) return items;
+	return items.filter((item) => {
+		const shouldInclude = !filter$1.include || filter$1.include.includes(item.contentType);
+		const shouldExclude = filter$1.exclude?.includes(item.contentType) ?? false;
+		return shouldInclude && !shouldExclude;
+	});
 }
 
 //#endregion
@@ -454,7 +366,7 @@ const DEBUG = process.env.DEBUG;
 function createDebugger(ns, options = {}) {
 	const log$1 = debug(ns);
 	const { onlyWhenFocused } = options;
-	const focus = typeof onlyWhenFocused === "string" ? onlyWhenFocused : ns;
+	const focus = isString(onlyWhenFocused) ? onlyWhenFocused : ns;
 	return (msg, ...args) => {
 		if (filter && !msg.includes(filter)) return;
 		if (onlyWhenFocused && !DEBUG?.includes(focus)) return;
@@ -468,13 +380,13 @@ const search = String.raw`\*/`;
 const replacement = String.raw`*\/`;
 const regex$1 = new RegExp(search, "g");
 function jsDoc(schema, tryOneLine = false, context) {
-	if (context?.output?.override?.jsDoc) {
+	if (context?.output.override.jsDoc) {
 		const { filter: filter$1 } = context.output.override.jsDoc;
 		if (filter$1) return keyValuePairsToJsDoc(filter$1(schema));
 	}
 	const { description, deprecated, summary, minLength, maxLength, minimum, maximum, exclusiveMinimum, exclusiveMaximum, minItems, maxItems, pattern } = schema;
 	const isNullable = schema.type === "null" || Array.isArray(schema.type) && schema.type.includes("null");
-	const lines = (Array.isArray(description) ? description.filter((d) => !d.includes("eslint-disable")) : [description || ""]).map((line) => line.replaceAll(regex$1, replacement));
+	const lines = (Array.isArray(description) ? description.filter((d) => !d.includes("eslint-disable")) : [description ?? ""]).map((line) => line.replaceAll(regex$1, replacement));
 	const count$1 = [
 		description,
 		deprecated,
@@ -489,7 +401,7 @@ function jsDoc(schema, tryOneLine = false, context) {
 		maxItems?.toString(),
 		isNullable ? "null" : "",
 		pattern
-	].reduce((acc, it) => it ? acc + 1 : acc, 0);
+	].filter(Boolean).length;
 	if (!count$1) return "";
 	const oneLine = count$1 === 1 && tryOneLine;
 	const eslintDisable = Array.isArray(description) ? description.find((d) => d.includes("eslint-disable"))?.replaceAll(regex$1, replacement) : void 0;
@@ -556,10 +468,49 @@ async function dynamicImport(toImport, from = process.cwd(), takeDefault = true)
 		}
 		return toImport;
 	} catch (error) {
-		throw new Error(`Oups... 🍻. Path: ${toImport} => ${error}`);
+		throw new Error(`Oups... 🍻. Path: ${String(toImport)} => ${String(error)}`);
 	}
 }
 
+//#endregion
+//#region src/utils/extension.ts
+function getExtension(path$2) {
+	return path$2.toLowerCase().includes(".yaml") || path$2.toLowerCase().includes(".yml") ? "yaml" : "json";
+}
+
+//#endregion
+//#region src/utils/file.ts
+function getFileInfo(target = "", { backupFilename = "filename", extension = ".ts" } = {}) {
+	const isDir = isDirectory(target);
+	const filePath = isDir ? path.join(target, backupFilename + extension) : target;
+	return {
+		path: filePath,
+		pathWithoutExtension: filePath.replace(/\.[^/.]+$/, ""),
+		extension,
+		isDirectory: isDir,
+		dirname: path.dirname(filePath),
+		filename: path.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
+	};
+}
+async function removeFilesAndEmptyFolders(patterns, dir) {
+	const files = await globby(patterns, {
+		cwd: dir,
+		absolute: true
+	});
+	await Promise.all(files.map((file) => fs.promises.unlink(file)));
+	const sortedDirectories = (await globby(["**/*"], {
+		cwd: dir,
+		absolute: true,
+		onlyDirectories: true
+	})).toSorted((a, b) => {
+		const depthA = a.split("/").length;
+		return b.split("/").length - depthA;
+	});
+	for (const directory of sortedDirectories) try {
+		if ((await fs.promises.readdir(directory)).length === 0) await fs.promises.rmdir(directory);
+	} catch {}
+}
+
 //#endregion
 //#region src/utils/file-extensions.ts
 function getMockFileExtensionByTypeName(mock) {
@@ -608,7 +559,7 @@ function logError(err, tag) {
 	if (err instanceof Error) {
 		message = (err.message || err.stack) ?? "Unknown error";
 		if (err.cause) {
-			const causeMsg = err.cause instanceof Error ? err.cause.message : typeof err.cause === "string" ? err.cause : JSON.stringify(err.cause, void 0, 2);
+			const causeMsg = err.cause instanceof Error ? err.cause.message : isString(err.cause) ? err.cause : JSON.stringify(err.cause, void 0, 2);
 			message += `\n  Cause: ${causeMsg}`;
 		}
 	} else message = String(err);
@@ -695,16 +646,16 @@ function createLogger(level = "info", options = {}) {
 
 //#endregion
 //#region src/utils/merge-deep.ts
-const isObject$1 = (obj) => obj && typeof obj === "object";
 function mergeDeep(source, target) {
-	if (!isObject$1(target) || !isObject$1(source)) return source;
-	return Object.entries(target).reduce((acc, [key, value]) => {
+	if (!isObject(target) || !isObject(source)) return source;
+	const acc = Object.assign({}, source);
+	for (const [key, value] of Object.entries(target)) {
 		const sourceValue = acc[key];
 		if (Array.isArray(sourceValue) && Array.isArray(value)) acc[key] = [...sourceValue, ...value];
-		else if (isObject$1(sourceValue) && isObject$1(value)) acc[key] = mergeDeep(sourceValue, value);
+		else if (isObject(sourceValue) && isObject(value)) acc[key] = mergeDeep(sourceValue, value);
 		else acc[key] = value;
-		return acc;
-	}, Object.assign({}, source));
+	}
+	return acc;
 }
 
 //#endregion
@@ -714,9 +665,106 @@ function count(str = "", key) {
 	return (str.match(new RegExp(key, "g")) ?? []).length;
 }
 
+//#endregion
+//#region src/utils/path.ts
+var path_exports = /* @__PURE__ */ __export({
+	basename: () => basename,
+	dirname: () => dirname,
+	extname: () => extname,
+	getSchemaFileName: () => getSchemaFileName,
+	isAbsolute: () => isAbsolute,
+	join: () => join,
+	joinSafe: () => joinSafe,
+	normalizeSafe: () => normalizeSafe,
+	relativeSafe: () => relativeSafe,
+	resolve: () => resolve,
+	separator: () => separator
+});
+function wrapPathFn(fn) {
+	return (...args) => {
+		const result = fn(...args.map((p) => isStringLike(p) ? toUnix(p) : p));
+		return isStringLike(result) ? toUnix(result) : result;
+	};
+}
+const path$1 = Object.fromEntries(Object.entries(path).map(([key, value]) => [key, isFunction(value) ? wrapPathFn(value) : value]));
+const { join, resolve, extname, dirname, basename, isAbsolute } = path$1;
+/**
+* Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
+*/
+function relativeSafe(from, to) {
+	return normalizeSafe(`.${separator}${path$1.relative(from, to)}`);
+}
+function getSchemaFileName(path$2) {
+	return path$2.replace(`.${getExtension(path$2)}`, "").slice(path$2.lastIndexOf("/") + 1);
+}
+const separator = "/";
+const toUnix = function(value) {
+	value = value.replaceAll("\\", "/");
+	value = value.replaceAll(/(?<!^)\/+/g, "/");
+	return value;
+};
+function normalizeSafe(value) {
+	let result;
+	value = toUnix(value);
+	result = path$1.normalize(value);
+	if (value.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
+	else if (value.startsWith("//") && !result.startsWith("//")) result = value.startsWith("//./") ? "//." + result : "/" + result;
+	return result;
+}
+function joinSafe(...values) {
+	let result = path$1.join(...values);
+	if (values.length > 0) {
+		const firstValue = toUnix(values[0]);
+		if (firstValue.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
+		else if (firstValue.startsWith("//") && !result.startsWith("//")) result = firstValue.startsWith("//./") ? "//." + result : "/" + result;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/utils/resolve-version.ts
+function resolveInstalledVersion(packageName, fromDir) {
+	try {
+		const require = createRequire(path.join(fromDir, "noop.js"));
+		try {
+			return require(`${packageName}/package.json`).version;
+		} catch (directError) {
+			if (directError instanceof Error && "code" in directError && directError.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+				const entryPath = require.resolve(packageName);
+				let dir = path.dirname(entryPath);
+				while (dir !== path.parse(dir).root) {
+					const pkgPath = path.join(dir, "package.json");
+					if (existsSync(pkgPath)) {
+						const pkgData = JSON.parse(readFileSync(pkgPath, "utf8"));
+						if (pkgData.name === packageName) return pkgData.version;
+					}
+					dir = path.dirname(dir);
+				}
+				return;
+			}
+			throw directError;
+		}
+	} catch {
+		return;
+	}
+}
+function resolveInstalledVersions(packageJson, fromDir) {
+	const resolved = {};
+	const allDeps = new Set([
+		...Object.keys(packageJson.dependencies ?? {}),
+		...Object.keys(packageJson.devDependencies ?? {}),
+		...Object.keys(packageJson.peerDependencies ?? {})
+	]);
+	for (const pkgName of allDeps) {
+		const version = resolveInstalledVersion(pkgName, fromDir);
+		if (version) resolved[pkgName] = version;
+	}
+	return resolved;
+}
+
 //#endregion
 //#region src/utils/sort.ts
-const sortByPriority = (arr) => arr.sort((a, b) => {
+const sortByPriority = (arr) => arr.toSorted((a, b) => {
 	if (a.default) return 1;
 	if (b.default) return -1;
 	if (a.required && b.required) return 0;
@@ -740,17 +788,20 @@ const sortByPriority = (arr) => arr.sort((a, b) => {
 * stringify({ a: 1, b: 'test' }) // returns "{ a: 1, b: 'test', }"
 */
 function stringify(data) {
-	if (isUndefined(data) || isNull(data)) return;
+	if (isNullish$1(data)) return;
 	if (isString(data)) return `'${data.replaceAll("'", String.raw`\'`)}'`;
-	if (isNumber(data) || isBoolean(data) || isFunction(data)) return `${data}`;
-	if (Array.isArray(data)) return `[${data.map(stringify).join(", ")}]`;
-	return Object.entries(data).reduce((acc, [key, value], index, arr) => {
+	if (isNumber(data) || isBoolean(data) || isFunction(data)) return String(data);
+	if (Array.isArray(data)) return `[${data.map((item) => stringify(item)).join(", ")}]`;
+	const entries$1 = Object.entries(data);
+	let result = "";
+	for (const [index, [key, value]] of entries$1.entries()) {
 		const strValue = stringify(value);
-		if (arr.length === 1) return `{ ${key}: ${strValue}, }`;
-		if (!index) return `{ ${key}: ${strValue}, `;
-		if (arr.length - 1 === index) return acc + `${key}: ${strValue}, }`;
-		return acc + `${key}: ${strValue}, `;
-	}, "");
+		if (entries$1.length === 1) result = `{ ${key}: ${strValue}, }`;
+		else if (!index) result = `{ ${key}: ${strValue}, `;
+		else if (entries$1.length - 1 === index) result += `${key}: ${strValue}, }`;
+		else result += `${key}: ${strValue}, `;
+	}
+	return result;
 }
 /**
 * Sanitizes a string value by removing or replacing special characters and ensuring
@@ -774,7 +825,7 @@ function stringify(data) {
 function sanitize(value, options) {
 	const { whitespace = "", underscore = "", dot = "", dash = "", es5keyword = false, es5IdentifierName = false, special = false } = options ?? {};
 	let newValue = value;
-	if (!special) newValue = newValue.replaceAll(/[!"`'#%&,:;<>=@{}~\$\(\)\*\+\/\\\?\[\]\^\|]/g, "");
+	if (!special) newValue = newValue.replaceAll(/[!"`'#%&,:;<>=@{}~$()*+/\\?[\]^|]/g, "");
 	if (whitespace !== true) newValue = newValue.replaceAll(/[\s]/g, whitespace);
 	if (underscore !== true) newValue = newValue.replaceAll(/['_']/g, underscore);
 	if (dot !== true) newValue = newValue.replaceAll(/[.]/g, dot);
@@ -799,7 +850,11 @@ function sanitize(value, options) {
 */
 function toObjectString(props, path$2) {
 	if (props.length === 0) return "";
-	return (typeof path$2 === "string" ? props.map((prop$1) => path$2.split(".").reduce((obj, key) => obj && typeof obj === "object" ? obj[key] : void 0, prop$1)) : props).join(",\n    ") + ",";
+	return (isString(path$2) ? props.map((prop$1) => {
+		let obj = prop$1;
+		for (const key of path$2.split(".")) obj = obj && (isObject(obj) || Array.isArray(obj)) ? obj[key] : void 0;
+		return obj;
+	}) : props).join(",\n    ") + ",";
 }
 const NUMBERS = {
 	"0": "zero",
@@ -823,7 +878,7 @@ const NUMBERS = {
 * getNumberWord(42) // returns "fourtwo"
 */
 function getNumberWord(num) {
-	return num.toString().split("").reduce((acc, n) => acc + NUMBERS[n], "");
+	return [...num.toString()].reduce((acc, n) => acc + NUMBERS[n], "");
 }
 /**
 * Escapes a specific character in a string by prefixing it with a backslash.
@@ -917,8 +972,7 @@ function getEnumDescriptions(schemaObject) {
 function getEnum(value, enumName, names, enumGenerationType, descriptions, enumNamingConvention) {
 	if (enumGenerationType === EnumGeneration.CONST) return getTypeConstEnum(value, enumName, names, descriptions, enumNamingConvention);
 	if (enumGenerationType === EnumGeneration.ENUM) return getNativeEnum(value, enumName, names, enumNamingConvention);
-	if (enumGenerationType === EnumGeneration.UNION) return getUnion(value, enumName);
-	throw new Error(`Invalid enumGenerationType: ${enumGenerationType}`);
+	return getUnion(value, enumName);
 }
 const getTypeConstEnum = (value, enumName, names, descriptions, enumNamingConvention) => {
 	let enumValue = `export type ${enumName} = typeof ${enumName}[keyof typeof ${enumName}]`;
@@ -934,11 +988,16 @@ const getTypeConstEnum = (value, enumName, names, descriptions, enumNamingConven
 };
 function getEnumImplementation(value, names, descriptions, enumNamingConvention) {
 	if (value === "") return "";
-	return [...new Set(value.split(" | "))].reduce((acc, val, index) => {
+	const uniqueValues = [...new Set(value.split(" | "))];
+	let result = "";
+	for (const [index, val] of uniqueValues.entries()) {
 		const name = names?.[index];
 		const description = descriptions?.[index];
 		const comment = description ? `  /** ${description} */\n` : "";
-		if (name) return acc + comment + `  ${keyword.isIdentifierNameES5(name) ? name : `'${name}'`}: ${val},\n`;
+		if (name) {
+			result += comment + `  ${keyword.isIdentifierNameES5(name) ? name : `'${name}'`}: ${val},\n`;
+			continue;
+		}
 		let key = val.startsWith("'") ? val.slice(1, -1) : val;
 		if (isNumeric(key)) key = toNumberKey(key);
 		if (key.length > 1) key = sanitize(key, {
@@ -948,17 +1007,23 @@ function getEnumImplementation(value, names, descriptions, enumNamingConvention)
 			special: true
 		});
 		if (enumNamingConvention) key = conventionName(key, enumNamingConvention);
-		return acc + comment + `  ${keyword.isIdentifierNameES5(key) ? key : `'${key}'`}: ${val},\n`;
-	}, "");
+		result += comment + `  ${keyword.isIdentifierNameES5(key) ? key : `'${key}'`}: ${val},\n`;
+	}
+	return result;
 }
 const getNativeEnum = (value, enumName, names, enumNamingConvention) => {
 	return `export enum ${enumName} {\n${getNativeEnumItems(value, names, enumNamingConvention)}\n}`;
 };
 const getNativeEnumItems = (value, names, enumNamingConvention) => {
 	if (value === "") return "";
-	return [...new Set(value.split(" | "))].reduce((acc, val, index) => {
+	const uniqueValues = [...new Set(value.split(" | "))];
+	let result = "";
+	for (const [index, val] of uniqueValues.entries()) {
 		const name = names?.[index];
-		if (name) return acc + `  ${keyword.isIdentifierNameES5(name) ? name : `'${name}'`}= ${val},\n`;
+		if (name) {
+			result += `  ${keyword.isIdentifierNameES5(name) ? name : `'${name}'`}= ${val},\n`;
+			continue;
+		}
 		let key = val.startsWith("'") ? val.slice(1, -1) : val;
 		if (isNumeric(key)) key = toNumberKey(key);
 		if (key.length > 1) key = sanitize(key, {
@@ -968,8 +1033,9 @@ const getNativeEnumItems = (value, names, enumNamingConvention) => {
 			special: true
 		});
 		if (enumNamingConvention) key = conventionName(key, enumNamingConvention);
-		return acc + `  ${keyword.isIdentifierNameES5(key) ? key : `'${key}'`}= ${val},\n`;
-	}, "");
+		result += `  ${keyword.isIdentifierNameES5(key) ? key : `'${key}'`}= ${val},\n`;
+	}
+	return result;
 };
 const toNumberKey = (value) => {
 	if (value.startsWith("-")) return `NUMBER_MINUS_${value.slice(1)}`;
@@ -981,9 +1047,9 @@ const getUnion = (value, enumName) => {
 };
 function getEnumUnionFromSchema(schema) {
 	if (!schema?.enum) return "";
-	return schema.enum.filter((val) => val !== null).map((val) => isString(val) ? `'${escape(val)}'` : `${val}`).join(" | ");
+	return schema.enum.filter((val) => val !== null).map((val) => isString(val) ? `'${escape(val)}'` : String(val)).join(" | ");
 }
-const stripNullUnion = (value) => value.replace(/\s*\|\s*null/g, "").trim();
+const stripNullUnion = (value) => value.replaceAll(/\s*\|\s*null/g, "").trim();
 const isSpreadableEnumRef = (schema, refName) => {
 	if (!schema?.enum || !refName) return false;
 	if (!getEnumUnionFromSchema(schema)) return false;
@@ -1129,17 +1195,23 @@ function getSchema$1(schema, context) {
 	const refInfo = getRefInfo(schema.$ref, context);
 	const { refPaths } = refInfo;
 	let schemaByRefPaths = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
-	if (!schemaByRefPaths) schemaByRefPaths = context.spec;
+	schemaByRefPaths ??= context.spec;
 	if (isReference(schemaByRefPaths)) return getSchema$1(schemaByRefPaths, context);
-	let currentSchema = schemaByRefPaths ? schemaByRefPaths : context.spec;
-	if ("nullable" in schema) currentSchema = {
-		...currentSchema,
-		nullable: schema.nullable
-	};
-	if ("type" in schema && Array.isArray(schema.type)) currentSchema = {
-		...currentSchema,
-		type: schema.type
-	};
+	let currentSchema = schemaByRefPaths || context.spec;
+	if ("nullable" in schema) {
+		const nullable = schema.nullable;
+		currentSchema = {
+			...currentSchema,
+			nullable
+		};
+	}
+	if ("type" in schema && Array.isArray(schema.type)) {
+		const type = schema.type;
+		currentSchema = {
+			...currentSchema,
+			type
+		};
+	}
 	return {
 		currentSchema,
 		refInfo
@@ -1153,14 +1225,11 @@ function resolveExampleRefs(examples, context) {
 			return schema.value;
 		}
 		return example;
-	}) : Object.entries(examples).reduce((acc, [key, example]) => {
-		let schema = example;
-		if (isReference(example)) schema = resolveRef(example, context).schema.value;
-		return {
-			...acc,
-			[key]: schema
-		};
-	}, {});
+	}) : (() => {
+		const result = {};
+		for (const [key, example] of Object.entries(examples)) result[key] = isReference(example) ? resolveRef(example, context).schema.value : example;
+		return result;
+	})();
 }
 
 //#endregion
@@ -1179,7 +1248,8 @@ function resolveValue({ schema, name, context, formDataContext }) {
 				parents: [...context.parents ?? [], refName]
 			}
 		}).hasReadonlyProps;
-		const nullable = Array.isArray(schemaObject.type) && schemaObject.type.includes("null") || schemaObject.nullable === true ? " | null" : "";
+		const isAnyOfNullable = schemaObject.anyOf?.some((anyOfItem) => !isReference(anyOfItem) && (anyOfItem.type === "null" || Array.isArray(anyOfItem.type) && anyOfItem.type.includes("null")));
+		const nullable = Array.isArray(schemaObject.type) && schemaObject.type.includes("null") || schemaObject.nullable === true || isAnyOfNullable ? " | null" : "";
 		return {
 			value: resolvedImport.name + nullable,
 			imports: [{
@@ -1216,7 +1286,7 @@ function resolveValue({ schema, name, context, formDataContext }) {
 function createTypeAliasIfNeeded({ resolvedValue, propName, context }) {
 	if (!propName) return;
 	if (resolvedValue.isEnum || resolvedValue.type !== "object") return;
-	const aliasPattern = context.output.override.aliasCombinedTypes ? "{|&|\\|" : "{";
+	const aliasPattern = context.output.override.aliasCombinedTypes ? String.raw`{|&|\|` : "{";
 	if (!new RegExp(aliasPattern).test(resolvedValue.value)) return;
 	const { originalSchema } = resolvedValue;
 	const doc = jsDoc(originalSchema);
@@ -1259,8 +1329,8 @@ function resolveObjectOriginal({ schema, propName, combined = false, context, fo
 		originalSchema: resolvedValue.originalSchema
 	};
 	if (propName && resolvedValue.isEnum && !combined && !resolvedValue.isRef) {
-		const doc = jsDoc(resolvedValue.originalSchema ?? {});
-		const enumValue = getEnum(resolvedValue.value, propName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention?.enum);
+		const doc = jsDoc(resolvedValue.originalSchema);
+		const enumValue = getEnum(resolvedValue.value, propName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
 		return {
 			value: propName,
 			imports: [{ name: propName }],
@@ -1309,17 +1379,20 @@ function resolveObject({ schema, propName, combined = false, context, formDataCo
 * @param item item with type === "array"
 */
 function getArray({ schema, name, context, formDataContext }) {
-	const schema31 = schema;
+	const schemaPrefixItems = schema.prefixItems;
+	const schemaItems = schema.items;
+	const schemaExample = schema.example;
+	const schemaExamples = schema.examples;
 	const itemSuffix = context.output.override.components.schemas.itemSuffix;
-	if (schema31.prefixItems) {
-		const resolvedObjects = schema31.prefixItems.map((item, index) => resolveObject({
+	if (schemaPrefixItems) {
+		const resolvedObjects = schemaPrefixItems.map((item, index) => resolveObject({
 			schema: item,
-			propName: name ? name + itemSuffix + index : void 0,
+			propName: name ? name + itemSuffix + String(index) : void 0,
 			context
 		}));
-		if (schema31.items) {
+		if (schemaItems) {
 			const additional = resolveObject({
-				schema: schema31.items,
+				schema: schemaItems,
 				propName: name ? name + itemSuffix + "Additional" : void 0,
 				context
 			});
@@ -1337,13 +1410,13 @@ function getArray({ schema, name, context, formDataContext }) {
 			schemas: resolvedObjects.flatMap((o) => o.schemas),
 			dependencies: resolvedObjects.flatMap((o) => o.dependencies),
 			hasReadonlyProps: resolvedObjects.some((o) => o.hasReadonlyProps),
-			example: schema.example,
-			examples: resolveExampleRefs(schema.examples, context)
+			example: schemaExample,
+			examples: resolveExampleRefs(schemaExamples, context)
 		};
 	}
-	if (schema.items) {
+	if (schemaItems) {
 		const resolvedObject = resolveObject({
-			schema: schema.items,
+			schema: schemaItems,
 			propName: name ? name + itemSuffix : void 0,
 			context,
 			formDataContext
@@ -1357,8 +1430,8 @@ function getArray({ schema, name, context, formDataContext }) {
 			type: "array",
 			isRef: false,
 			hasReadonlyProps: resolvedObject.hasReadonlyProps,
-			example: schema.example,
-			examples: resolveExampleRefs(schema.examples, context)
+			example: schemaExample,
+			examples: resolveExampleRefs(schemaExamples, context)
 		};
 	} else if (compareVersions(context.spec.openapi, "3.1", ">=")) return {
 		value: "unknown[]",
@@ -1375,6 +1448,13 @@ function getArray({ schema, name, context, formDataContext }) {
 
 //#endregion
 //#region src/getters/res-req-types.ts
+const getSchemaType = (s) => s.type;
+const getSchemaCombined = (s) => s.oneOf ?? s.anyOf ?? s.allOf;
+const getSchemaOneOf = (s) => s.oneOf;
+const getSchemaAnyOf = (s) => s.anyOf;
+const getSchemaItems = (s) => s.items;
+const getSchemaRequired = (s) => s.required;
+const getSchemaProperties = (s) => s.properties;
 const formDataContentTypes = new Set(["multipart/form-data"]);
 const formUrlEncodedContentTypes = new Set(["application/x-www-form-urlencoded"]);
 function getResReqContentTypes({ mediaType, propName, context, isFormData, contentType }) {
@@ -1396,10 +1476,28 @@ function getResReqContentTypes({ mediaType, propName, context, isFormData, conte
 	return resolvedObject;
 }
 function getResReqTypes(responsesOrRequests, name, context, defaultType = "unknown", uniqueKey = (item) => item.value) {
-	return uniqueBy(responsesOrRequests.filter(([_, res]) => Boolean(res)).map(([key, res]) => {
+	return uniqueBy(responsesOrRequests.filter(([, res]) => Boolean(res)).map(([key, res]) => {
 		if (isReference(res)) {
 			const { schema: bodySchema, imports: [{ name: name$1, schemaName }] } = resolveRef(res, context);
-			const [contentType, mediaType] = Object.entries(bodySchema.content ?? {})[0] ?? [];
+			const firstEntry = Object.entries(bodySchema.content ?? {}).at(0);
+			if (!firstEntry) return [{
+				value: name$1,
+				imports: [{
+					name: name$1,
+					schemaName
+				}],
+				schemas: [],
+				type: "unknown",
+				isEnum: false,
+				isRef: true,
+				hasReadonlyProps: false,
+				originalSchema: void 0,
+				example: void 0,
+				examples: void 0,
+				key,
+				contentType: void 0
+			}];
+			const [contentType, mediaType] = firstEntry;
 			const isFormData = formDataContentTypes.has(contentType);
 			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
 			if (!isFormData && !isFormUrlEncoded || !mediaType.schema) return [{
@@ -1413,9 +1511,9 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				isEnum: false,
 				isRef: true,
 				hasReadonlyProps: false,
-				originalSchema: mediaType?.schema,
-				example: mediaType?.example,
-				examples: resolveExampleRefs(mediaType?.examples, context),
+				originalSchema: mediaType.schema,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context),
 				key,
 				contentType
 			}];
@@ -1491,7 +1589,7 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 				return;
 			}
 			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
-			if (!isFormData && !isFormUrlEncoded || !effectivePropName) return {
+			if (!isFormData && !isFormUrlEncoded || !effectivePropName || !mediaType.schema) return {
 				...resolvedValue,
 				imports: resolvedValue.imports,
 				contentType,
@@ -1556,6 +1654,17 @@ function getResReqTypes(responsesOrRequests, name, context, defaultType = "unkno
 	}).flat(), uniqueKey);
 }
 /**
+* Determine the responseType option based on success content types only.
+* This avoids error-response content types influencing the responseType.
+*/
+function getSuccessResponseType(response) {
+	const successContentTypes = response.types.success.map((t) => t.contentType).filter(Boolean);
+	if (response.isBlob) return "blob";
+	const hasJsonResponse = successContentTypes.some((contentType) => contentType.includes("json") || contentType.includes("+json"));
+	const hasTextResponse = successContentTypes.some((contentType) => contentType.startsWith("text/") || contentType.includes("xml"));
+	if (!hasJsonResponse && hasTextResponse) return "text";
+}
+/**
 * Determine the response type category for a given content type.
 * Used to set the correct responseType option in HTTP clients.
 *
@@ -1584,9 +1693,9 @@ function getDefaultContentType(contentTypes) {
 function getFormDataAdditionalImports({ schemaObject, context }) {
 	const { schema } = resolveRef(schemaObject, context);
 	if (schema.type !== "object") return [];
-	const combinedSchemas = schema.oneOf || schema.anyOf;
+	const combinedSchemas = getSchemaOneOf(schema) ?? getSchemaAnyOf(schema);
 	if (!combinedSchemas) return [];
-	return combinedSchemas.map((schema$1) => resolveRef(schema$1, context).imports[0]).filter(Boolean);
+	return combinedSchemas.map((subSchema) => resolveRef(subSchema, context).imports[0]).filter(Boolean);
 }
 function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequestBodyOptional, isUrlEncoded, isRef, encoding }) {
 	const { schema, imports } = resolveRef(schemaObject, context);
@@ -1594,12 +1703,12 @@ function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequest
 	const additionalImports = [];
 	const variableName = isUrlEncoded ? "formUrlEncoded" : "formData";
 	let form = isUrlEncoded ? `const ${variableName} = new URLSearchParams();\n` : `const ${variableName} = new FormData();\n`;
-	const combinedSchemas = schema.oneOf || schema.anyOf || schema.allOf;
+	const combinedSchemas = getSchemaCombined(schema);
 	if (schema.type === "object" || schema.type === void 0 && combinedSchemas) {
 		if (combinedSchemas) {
-			const shouldCast = !!schema.oneOf || !!schema.anyOf;
-			const combinedSchemasFormData = combinedSchemas.map((schema$1) => {
-				const { schema: combinedSchema, imports: imports$1 } = resolveRef(schema$1, context);
+			const shouldCast = !!getSchemaOneOf(schema) || !!getSchemaAnyOf(schema);
+			const combinedSchemasFormData = combinedSchemas.map((subSchema) => {
+				const { schema: combinedSchema, imports: imports$1 } = resolveRef(subSchema, context);
 				let newPropName = propName;
 				let newPropDefinition = "";
 				if (shouldCast && imports$1[0]) {
@@ -1633,8 +1742,9 @@ function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequest
 	}
 	if (schema.type === "array") {
 		let valueStr = "value";
-		if (schema.items) {
-			const { schema: itemSchema } = resolveRef(schema.items, context);
+		const schemaItems = getSchemaItems(schema);
+		if (schemaItems) {
+			const { schema: itemSchema } = resolveRef(schemaItems, context);
 			if (itemSchema.type === "object" || itemSchema.type === "array") valueStr = "JSON.stringify(value)";
 			else if (itemSchema.type === "number" || itemSchema.type === "integer" || itemSchema.type === "boolean") valueStr = "value.toString()";
 		}
@@ -1644,9 +1754,11 @@ function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequest
 	return `${form}${variableName}.append('data', ${propName})\n`;
 }
 function resolveSchemaPropertiesToFormData({ schema, variableName, propName, context, isRequestBodyOptional, keyPrefix = "", depth = 0, encoding }) {
-	return Object.entries(schema.properties ?? {}).reduce((acc, [key, value]) => {
+	let formDataValues = "";
+	const schemaProps = getSchemaProperties(schema) ?? {};
+	for (const [key, value] of Object.entries(schemaProps)) {
 		const { schema: property } = resolveRef(value, context);
-		if (property.readOnly) return acc;
+		if (property.readOnly) continue;
 		let formDataValue = "";
 		const partContentType = (depth === 0 ? encoding?.[key] : void 0)?.contentType;
 		const formattedKeyPrefix = isRequestBodyOptional ? keyword.isIdentifierNameES5(key) ? "?" : "?." : "";
@@ -1670,8 +1782,9 @@ function resolveSchemaPropertiesToFormData({ schema, variableName, propName, con
 		else if (property.type === "array") {
 			let valueStr = "value";
 			let hasNonPrimitiveChild = false;
-			if (property.items) {
-				const { schema: itemSchema } = resolveRef(property.items, context);
+			const propertyItems = getSchemaItems(property);
+			if (propertyItems) {
+				const { schema: itemSchema } = resolveRef(propertyItems, context);
 				if (itemSchema.type === "object" || itemSchema.type === "array") if (context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE) {
 					hasNonPrimitiveChild = true;
 					const resolvedValue = resolveSchemaPropertiesToFormData({
@@ -1686,52 +1799,69 @@ function resolveSchemaPropertiesToFormData({ schema, variableName, propName, con
 					formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => {
     ${resolvedValue}});\n`;
 				} else valueStr = "JSON.stringify(value)";
-				else if (itemSchema.type === "number" || itemSchema.type?.includes("number") || itemSchema.type === "integer" || itemSchema.type?.includes("integer") || itemSchema.type === "boolean" || itemSchema.type?.includes("boolean")) valueStr = "value.toString()";
+				else {
+					const itemType = getSchemaType(itemSchema);
+					if (itemType === "number" || Array.isArray(itemType) && itemType.includes("number") || itemType === "integer" || Array.isArray(itemType) && itemType.includes("integer") || itemType === "boolean" || Array.isArray(itemType) && itemType.includes("boolean")) valueStr = "value.toString()";
+				}
 			}
 			if (context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE) {
 				if (!hasNonPrimitiveChild) formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => ${variableName}.append(\`${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}]\`, ${valueStr}));\n`;
 			} else formDataValue = `${valueKey}.forEach(value => ${variableName}.append(\`${keyPrefix}${key}${context.output.override.formData.arrayHandling === FormDataArrayHandling.SERIALIZE_WITH_BRACKETS ? "[]" : ""}\`, ${valueStr}));\n`;
-		} else if (property.type === "number" || property.type?.includes("number") || property.type === "integer" || property.type?.includes("integer") || property.type === "boolean" || property.type?.includes("boolean")) formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey}.toString())\n`;
+		} else if ((() => {
+			const propType$1 = getSchemaType(property);
+			return propType$1 === "number" || Array.isArray(propType$1) && propType$1.includes("number") || propType$1 === "integer" || Array.isArray(propType$1) && propType$1.includes("integer") || propType$1 === "boolean" || Array.isArray(propType$1) && propType$1.includes("boolean");
+		})()) formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey}.toString())\n`;
 		else formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
 		let existSubSchemaNullable = false;
-		if (property.allOf || property.anyOf || property.oneOf) {
-			const subSchemas = (property.allOf || property.anyOf || property.oneOf)?.map((c) => resolveObject({
+		const combine = getSchemaCombined(property);
+		if (combine) {
+			const subSchemas = combine.map((c) => resolveObject({
 				schema: c,
 				combined: true,
 				context
 			}));
-			if (subSchemas?.some((subSchema) => {
+			if (subSchemas.some((subSchema) => {
 				return [
 					"number",
 					"integer",
 					"boolean"
 				].includes(subSchema.type);
 			})) formDataValue = `${variableName}.append(\`${key}\`, ${nonOptionalValueKey}.toString())\n`;
-			if (subSchemas?.some((subSchema) => {
+			if (subSchemas.some((subSchema) => {
 				return subSchema.type === "null";
 			})) existSubSchemaNullable = true;
 		}
-		const isRequired = schema.required?.includes(key) && !isRequestBodyOptional;
-		if (property.nullable || property.type?.includes("null") || existSubSchemaNullable) {
-			if (isRequired) return acc + `if(${valueKey} !== null) {\n ${formDataValue} }\n`;
-			return acc + `if(${valueKey} !== undefined && ${nonOptionalValueKey} !== null) {\n ${formDataValue} }\n`;
+		const isRequired = getSchemaRequired(schema)?.includes(key) && !isRequestBodyOptional;
+		const propType = getSchemaType(property);
+		if (property.nullable || Array.isArray(propType) && propType.includes("null") || existSubSchemaNullable) {
+			if (isRequired) {
+				formDataValues += `if(${valueKey} !== null) {\n ${formDataValue} }\n`;
+				continue;
+			}
+			formDataValues += `if(${valueKey} !== undefined && ${nonOptionalValueKey} !== null) {\n ${formDataValue} }\n`;
+			continue;
+		}
+		if (isRequired) {
+			formDataValues += formDataValue;
+			continue;
 		}
-		if (isRequired) return acc + formDataValue;
-		return acc + `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
-	}, "");
+		formDataValues += `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
+	}
+	return formDataValues;
 }
 
 //#endregion
 //#region src/getters/body.ts
+/**
+* Extract all content types from a requestBody (#2812)
+*/
+function getRequestBodyContentTypes(requestBody, context) {
+	if (!requestBody) return [];
+	const content = (isReference(requestBody) ? resolveRef(requestBody, context).schema : requestBody).content;
+	return content ? Object.keys(content) : [];
+}
 function getBody({ requestBody, operationName, context, contentType }) {
-	const allBodyTypes = getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context);
-	const filteredBodyTypes = contentType ? allBodyTypes.filter((type) => {
-		let include = true;
-		let exclude = false;
-		if (contentType.include) include = contentType.include.includes(type.contentType);
-		if (contentType.exclude) exclude = contentType.exclude.includes(type.contentType);
-		return include && !exclude;
-	}) : allBodyTypes;
+	const filteredBodyTypes = filterByContentType(getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context), contentType);
 	const imports = filteredBodyTypes.flatMap(({ imports: imports$1 }) => imports$1);
 	const schemas = filteredBodyTypes.flatMap(({ schemas: schemas$1 }) => schemas$1);
 	const definition = filteredBodyTypes.map(({ value }) => value).join(" | ");
@@ -1805,7 +1935,10 @@ function getKey(key) {
 * Returns undefined if propertyNames doesn't have an enum
 */
 function getPropertyNamesEnum(item) {
-	if ("propertyNames" in item && item.propertyNames && "enum" in item.propertyNames && Array.isArray(item.propertyNames.enum)) return item.propertyNames.enum.filter((val) => typeof val === "string");
+	if ("propertyNames" in item && item.propertyNames && "enum" in item.propertyNames) {
+		const propertyNames = item.propertyNames;
+		if (Array.isArray(propertyNames.enum)) return propertyNames.enum.filter((val) => isString(val));
+	}
 }
 /**
 * Generate index signature key type based on propertyNames enum
@@ -1850,23 +1983,43 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 		nullable,
 		formDataContext
 	});
-	if (Array.isArray(item.type)) return combineSchemas({
-		schema: { anyOf: item.type.map((type) => ({
-			...item,
-			type
-		})) },
-		name,
-		separator: "anyOf",
-		context,
-		nullable
-	});
-	if (item.properties && Object.entries(item.properties).length > 0) {
-		const entries$1 = Object.entries(item.properties);
+	if (Array.isArray(item.type)) {
+		const typeArray = item.type;
+		const baseItem = item;
+		return combineSchemas({
+			schema: { anyOf: typeArray.map((type) => ({
+				...baseItem,
+				type
+			})) },
+			name,
+			separator: "anyOf",
+			context,
+			nullable
+		});
+	}
+	const itemProperties = item.properties;
+	if (itemProperties && Object.entries(itemProperties).length > 0) {
+		const entries$1 = Object.entries(itemProperties);
 		if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries$1.sort((a, b) => {
 			return a[0].localeCompare(b[0]);
 		});
-		return entries$1.reduce((acc, [key, schema], index, arr) => {
-			const isRequired = (Array.isArray(item.required) ? item.required : []).includes(key);
+		const acc = {
+			imports: [],
+			schemas: [],
+			value: "",
+			isEnum: false,
+			type: "object",
+			isRef: false,
+			schema: {},
+			hasReadonlyProps: false,
+			useTypeAlias: false,
+			dependencies: [],
+			example: item.example,
+			examples: resolveExampleRefs(item.examples, context)
+		};
+		const itemRequired = item.required;
+		for (const [index, [key, schema]] of entries$1.entries()) {
+			const isRequired = (Array.isArray(itemRequired) ? itemRequired : []).includes(key);
 			let propName = "";
 			if (name) {
 				const isKeyStartWithUnderscore = key.startsWith("_");
@@ -1884,16 +2037,16 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 				context,
 				formDataContext: propertyFormDataContext
 			});
-			const isReadOnly = item.readOnly || schema.readOnly;
+			const isReadOnly = item.readOnly ?? schema.readOnly;
 			if (!index) acc.value += "{";
 			const doc = jsDoc(schema, true, context);
-			acc.hasReadonlyProps ||= isReadOnly || false;
-			const constValue = "const" in schema ? schema.const : void 0;
-			const hasConst = constValue !== void 0;
+			if (isReadOnly ?? false) acc.hasReadonlyProps = true;
+			const constValue$1 = "const" in schema ? schema.const : void 0;
+			const hasConst = constValue$1 !== void 0;
 			let constLiteral;
 			if (!hasConst) constLiteral = void 0;
-			else if (typeof constValue === "string") constLiteral = `'${escape(constValue)}'`;
-			else constLiteral = JSON.stringify(constValue);
+			else if (isString(constValue$1)) constLiteral = `'${escape(constValue$1)}'`;
+			else constLiteral = JSON.stringify(constValue$1);
 			const needsValueImport = hasConst && (resolvedValue.isEnum || resolvedValue.type === "enum");
 			const aliasedImports = needsValueImport ? resolvedValue.imports.map((imp) => ({
 				...imp,
@@ -1914,8 +2067,9 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			acc.value += `\n  ${doc ? `${doc}  ` : ""}${isReadOnly && !context.output.override.suppressReadonlyModifier ? "readonly " : ""}${getKey(key)}${isRequired ? "" : "?"}: ${finalPropValue};`;
 			acc.schemas.push(...resolvedValue.schemas);
 			acc.dependencies.push(...resolvedValue.dependencies);
-			if (arr.length - 1 === index) {
-				if (item.additionalProperties) if (isBoolean(item.additionalProperties)) {
+			if (entries$1.length - 1 === index) {
+				const additionalProps = item.additionalProperties;
+				if (additionalProps) if (isBoolean(additionalProps)) {
 					const recordType$1 = getPropertyNamesRecordType(item, "unknown");
 					if (recordType$1) {
 						acc.value += "\n}";
@@ -1927,7 +2081,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 					}
 				} else {
 					const resolvedValue$1 = resolveValue({
-						schema: item.additionalProperties,
+						schema: additionalProps,
 						name,
 						context
 					});
@@ -1945,24 +2099,13 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 				else acc.value += "\n}";
 				acc.value += nullable;
 			}
-			return acc;
-		}, {
-			imports: [],
-			schemas: [],
-			value: "",
-			isEnum: false,
-			type: "object",
-			isRef: false,
-			schema: {},
-			hasReadonlyProps: false,
-			useTypeAlias: false,
-			dependencies: [],
-			example: item.example,
-			examples: resolveExampleRefs(item.examples, context)
-		});
+		}
+		return acc;
 	}
-	if (item.additionalProperties) {
-		if (isBoolean(item.additionalProperties)) {
+	const outerAdditionalProps = item.additionalProperties;
+	const readOnlyFlag = item.readOnly;
+	if (outerAdditionalProps) {
+		if (isBoolean(outerAdditionalProps)) {
 			const recordType$2 = getPropertyNamesRecordType(item, "unknown");
 			if (recordType$2) return {
 				value: recordType$2 + nullable,
@@ -1971,7 +2114,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 				isEnum: false,
 				type: "object",
 				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
+				hasReadonlyProps: readOnlyFlag ?? false,
 				useTypeAlias: true,
 				dependencies: []
 			};
@@ -1982,21 +2125,21 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 				isEnum: false,
 				type: "object",
 				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
+				hasReadonlyProps: readOnlyFlag ?? false,
 				useTypeAlias: false,
 				dependencies: []
 			};
 		}
 		const resolvedValue = resolveValue({
-			schema: item.additionalProperties,
+			schema: outerAdditionalProps,
 			name,
 			context
 		});
 		const recordType$1 = getPropertyNamesRecordType(item, resolvedValue.value);
 		if (recordType$1) return {
 			value: recordType$1 + nullable,
-			imports: resolvedValue.imports ?? [],
-			schemas: resolvedValue.schemas ?? [],
+			imports: resolvedValue.imports,
+			schemas: resolvedValue.schemas,
 			isEnum: false,
 			type: "object",
 			isRef: false,
@@ -2006,8 +2149,8 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 		};
 		return {
 			value: `{[key: ${getIndexSignatureKey(item)}]: ${resolvedValue.value}}` + nullable,
-			imports: resolvedValue.imports ?? [],
-			schemas: resolvedValue.schemas ?? [],
+			imports: resolvedValue.imports,
+			schemas: resolvedValue.schemas,
 			isEnum: false,
 			type: "object",
 			isRef: false,
@@ -2016,15 +2159,15 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 			dependencies: resolvedValue.dependencies
 		};
 	}
-	const itemWithConst = item;
-	if (itemWithConst.const) return {
-		value: `'${itemWithConst.const}'`,
+	const constValue = item.const;
+	if (constValue) return {
+		value: `'${constValue}'`,
 		imports: [],
 		schemas: [],
 		isEnum: false,
 		type: "string",
 		isRef: false,
-		hasReadonlyProps: item.readOnly || false,
+		hasReadonlyProps: readOnlyFlag ?? false,
 		dependencies: []
 	};
 	const keyType = item.type === "object" ? getIndexSignatureKey(item) : "string";
@@ -2036,7 +2179,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 		isEnum: false,
 		type: "object",
 		isRef: false,
-		hasReadonlyProps: item.readOnly || false,
+		hasReadonlyProps: readOnlyFlag ?? false,
 		useTypeAlias: true,
 		dependencies: []
 	};
@@ -2047,7 +2190,7 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 		isEnum: false,
 		type: "object",
 		isRef: false,
-		hasReadonlyProps: item.readOnly || false,
+		hasReadonlyProps: readOnlyFlag ?? false,
 		useTypeAlias: false,
 		dependencies: []
 	};
@@ -2062,29 +2205,36 @@ function getObject({ item, name, context, nullable, formDataContext }) {
 * @ref https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#data-types
 */
 function getScalar({ item, name, context, formDataContext }) {
-	const nullable = isArray(item.type) && item.type.includes("null") || item.nullable === true ? " | null" : "";
-	const enumItems = item.enum?.filter((enumItem) => enumItem !== null);
-	let itemType = item.type;
+	const schemaEnum = item.enum;
+	const schemaType = item.type;
+	const schemaReadOnly = item.readOnly;
+	const schemaExample = item.example;
+	const schemaExamples = item.examples;
+	const schemaConst = item.const;
+	const schemaFormat = item.format;
+	const schemaNullable = item.nullable;
+	const nullable = isArray(schemaType) && schemaType.includes("null") || schemaNullable === true ? " | null" : "";
+	const enumItems = schemaEnum?.filter((enumItem) => enumItem !== null);
+	let itemType = schemaType;
 	if (!itemType && item.items) {
 		item.type = "array";
 		itemType = "array";
 	}
-	if (isArray(item.type) && item.type.includes("null")) {
-		const typesWithoutNull = item.type.filter((x) => x !== "null");
+	if (isArray(schemaType) && schemaType.includes("null")) {
+		const typesWithoutNull = schemaType.filter((x) => x !== "null");
 		itemType = typesWithoutNull.length === 1 ? typesWithoutNull[0] : typesWithoutNull;
 	}
 	switch (itemType) {
 		case "number":
 		case "integer": {
-			let value = context.output.override.useBigInt && (item.format === "int64" || item.format === "uint64") ? "bigint" : "number";
+			let value = context.output.override.useBigInt && (schemaFormat === "int64" || schemaFormat === "uint64") ? "bigint" : "number";
 			let isEnum = false;
 			if (enumItems) {
 				value = enumItems.map((enumItem) => `${enumItem}`).join(" | ");
 				isEnum = true;
 			}
 			value += nullable;
-			const itemWithConst = item;
-			if (itemWithConst.const !== void 0) value = itemWithConst.const;
+			if (schemaConst !== void 0) value = schemaConst;
 			return {
 				value,
 				isEnum,
@@ -2092,16 +2242,15 @@ function getScalar({ item, name, context, formDataContext }) {
 				schemas: [],
 				imports: [],
 				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
+				hasReadonlyProps: schemaReadOnly ?? false,
 				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
 			};
 		}
 		case "boolean": {
 			let value = "boolean" + nullable;
-			const itemWithConst = item;
-			if (itemWithConst.const !== void 0) value = itemWithConst.const;
+			if (schemaConst !== void 0) value = schemaConst;
 			return {
 				value,
 				type: "boolean",
@@ -2109,10 +2258,10 @@ function getScalar({ item, name, context, formDataContext }) {
 				schemas: [],
 				imports: [],
 				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
+				hasReadonlyProps: schemaReadOnly ?? false,
 				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
 			};
 		}
 		case "array": {
@@ -2125,7 +2274,7 @@ function getScalar({ item, name, context, formDataContext }) {
 			return {
 				value: value + nullable,
 				...rest,
-				dependencies: rest.dependencies ?? []
+				dependencies: rest.dependencies
 			};
 		}
 		case "string": {
@@ -2135,15 +2284,14 @@ function getScalar({ item, name, context, formDataContext }) {
 				value = enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : `${enumItem}`).filter(Boolean).join(` | `);
 				isEnum = true;
 			}
-			if (item.format === "binary") value = "Blob";
+			if (schemaFormat === "binary") value = "Blob";
 			else if (formDataContext?.atPart) {
 				const fileType = getFormDataFieldFileType(item, formDataContext.partContentType);
 				if (fileType) value = fileType === "binary" ? "Blob" : "Blob | string";
 			}
-			if (context.output.override.useDates && (item.format === "date" || item.format === "date-time")) value = "Date";
+			if (context.output.override.useDates && (schemaFormat === "date" || schemaFormat === "date-time")) value = "Date";
 			value += nullable;
-			const itemWithConst = item;
-			if (itemWithConst.const) value = `'${itemWithConst.const}'`;
+			if (schemaConst) value = `'${schemaConst}'`;
 			return {
 				value,
 				isEnum,
@@ -2151,10 +2299,10 @@ function getScalar({ item, name, context, formDataContext }) {
 				imports: [],
 				schemas: [],
 				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
+				hasReadonlyProps: schemaReadOnly ?? false,
 				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
 			};
 		}
 		case "null": return {
@@ -2164,34 +2312,30 @@ function getScalar({ item, name, context, formDataContext }) {
 			imports: [],
 			schemas: [],
 			isRef: false,
-			hasReadonlyProps: item.readOnly || false,
+			hasReadonlyProps: schemaReadOnly ?? false,
 			dependencies: []
 		};
-		case "object":
 		default: {
 			if (isArray(itemType)) return combineSchemas({
-				schema: { anyOf: itemType.map((type) => ({
-					...item,
-					type
-				})) },
+				schema: { anyOf: itemType.map((type) => Object.assign({}, item, { type })) },
 				name,
 				separator: "anyOf",
 				context,
 				nullable
 			});
 			if (enumItems) return {
-				value: enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : `${enumItem}`).filter(Boolean).join(` | `) + nullable,
+				value: enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : String(enumItem)).filter(Boolean).join(` | `) + nullable,
 				isEnum: true,
 				type: "string",
 				imports: [],
 				schemas: [],
 				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
+				hasReadonlyProps: schemaReadOnly ?? false,
 				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
 			};
-			const hasCombiners = item.allOf || item.anyOf || item.oneOf;
+			const hasCombiners = item.allOf ?? item.anyOf ?? item.oneOf;
 			const { value, ...rest } = getObject({
 				item,
 				name,
@@ -2209,17 +2353,66 @@ function getScalar({ item, name, context, formDataContext }) {
 
 //#endregion
 //#region src/getters/combine.ts
-function combineValues({ resolvedData, resolvedValue, separator: separator$1, context }) {
+const mergeableAllOfKeys = new Set([
+	"type",
+	"properties",
+	"required"
+]);
+function isMergeableAllOfObject(schema) {
+	if (isNullish$1(schema.properties)) return false;
+	if (schema.allOf || schema.anyOf || schema.oneOf) return false;
+	if (!isNullish$1(schema.type) && schema.type !== "object") return false;
+	return Object.keys(schema).every((key) => mergeableAllOfKeys.has(key));
+}
+function normalizeAllOfSchema(schema) {
+	const schemaAllOf = schema.allOf;
+	if (!schemaAllOf) return schema;
+	let didMerge = false;
+	const schemaProperties = schema.properties;
+	const schemaRequired = schema.required;
+	const mergedProperties = { ...schemaProperties };
+	const mergedRequired = new Set(schemaRequired);
+	const remainingAllOf = [];
+	for (const subSchema of schemaAllOf) {
+		if (isSchema(subSchema) && isMergeableAllOfObject(subSchema)) {
+			didMerge = true;
+			if (subSchema.properties) Object.assign(mergedProperties, subSchema.properties);
+			const subRequired = subSchema.required;
+			if (subRequired) for (const prop$1 of subRequired) mergedRequired.add(prop$1);
+			continue;
+		}
+		remainingAllOf.push(subSchema);
+	}
+	if (!didMerge || remainingAllOf.length === 0) return schema;
+	return {
+		...schema,
+		...Object.keys(mergedProperties).length > 0 && { properties: mergedProperties },
+		...mergedRequired.size > 0 && { required: [...mergedRequired] },
+		...remainingAllOf.length > 0 && { allOf: remainingAllOf }
+	};
+}
+function combineValues({ resolvedData, resolvedValue, separator: separator$1, context, parentSchema }) {
 	if (resolvedData.isEnum.every(Boolean)) return `${resolvedData.values.join(` | `)}${resolvedValue ? ` | ${resolvedValue.value}` : ""}`;
 	if (separator$1 === "allOf") {
 		let resolvedDataValue = resolvedData.values.map((v) => v.includes(" | ") ? `(${v})` : v).join(` & `);
 		if (resolvedData.originalSchema.length > 0 && resolvedValue) {
-			const discriminatedPropertySchemas = resolvedData.originalSchema.filter((s) => s?.discriminator && resolvedValue.value.includes(` ${s.discriminator.propertyName}:`));
+			const discriminatedPropertySchemas = resolvedData.originalSchema.filter((s) => {
+				const disc = s?.discriminator;
+				return disc && resolvedValue.value.includes(` ${disc.propertyName}:`);
+			});
 			if (discriminatedPropertySchemas.length > 0) resolvedDataValue = `Omit<${resolvedDataValue}, '${discriminatedPropertySchemas.map((s) => s.discriminator?.propertyName).join("' | '")}'>`;
 		}
 		const resolvedValueStr = resolvedValue?.value.includes(" | ") ? `(${resolvedValue.value})` : resolvedValue?.value;
 		const joined = `${resolvedDataValue}${resolvedValue ? ` & ${resolvedValueStr}` : ""}`;
-		const overrideRequiredProperties = resolvedData.requiredProperties.filter((prop$1) => !resolvedData.originalSchema.some((schema) => schema?.properties?.[prop$1] && schema.required?.includes(prop$1)));
+		const overrideRequiredProperties = resolvedData.requiredProperties.filter((prop$1) => !resolvedData.originalSchema.some((schema) => {
+			const props = schema?.properties;
+			const req = schema?.required;
+			return props?.[prop$1] && req?.includes(prop$1);
+		}) && !(() => {
+			const parentProps = parentSchema?.properties;
+			const parentReq = parentSchema?.required;
+			return !!(parentProps?.[prop$1] && parentReq?.includes(prop$1));
+		})());
 		if (overrideRequiredProperties.length > 0) return `${joined} & Required<Pick<${joined}, '${overrideRequiredProperties.join("' | '")}'>>`;
 		return joined;
 	}
@@ -2228,11 +2421,12 @@ function combineValues({ resolvedData, resolvedValue, separator: separator$1, co
 		values = [];
 		for (let i = 0; i < resolvedData.values.length; i += 1) {
 			const subSchema = resolvedData.originalSchema[i];
-			if (subSchema?.type !== "object") {
+			if (subSchema?.type !== "object" || !subSchema.properties) {
 				values.push(resolvedData.values[i]);
 				continue;
 			}
-			const missingProperties = unique(resolvedData.allProperties.filter((p) => !Object.keys(subSchema.properties).includes(p)));
+			const subSchemaProps = subSchema.properties;
+			const missingProperties = unique(resolvedData.allProperties.filter((p) => !Object.keys(subSchemaProps).includes(p)));
 			values.push(`${resolvedData.values[i]}${missingProperties.length > 0 ? ` & {${missingProperties.map((p) => `${p}?: never`).join("; ")}}` : ""}`);
 		}
 	}
@@ -2240,14 +2434,30 @@ function combineValues({ resolvedData, resolvedValue, separator: separator$1, co
 	return values.join(" | ");
 }
 function combineSchemas({ name, schema, separator: separator$1, context, nullable, formDataContext }) {
-	const items = schema[separator$1] ?? [];
-	const resolvedData = items.reduce((acc, subSchema) => {
+	const normalizedSchema = separator$1 === "allOf" && !context.output.override.aliasCombinedTypes && !schema.oneOf && !schema.anyOf ? normalizeAllOfSchema(schema) : schema;
+	const items = normalizedSchema[separator$1] ?? [];
+	const resolvedData = {
+		values: [],
+		imports: [],
+		schemas: [],
+		isEnum: [],
+		isRef: [],
+		types: [],
+		dependencies: [],
+		originalSchema: [],
+		allProperties: [],
+		hasReadonlyProps: false,
+		example: schema.example,
+		examples: resolveExampleRefs(schema.examples, context),
+		requiredProperties: separator$1 === "allOf" ? schema.required ?? [] : []
+	};
+	for (const subSchema of items) {
 		let propName;
 		if (context.output.override.aliasCombinedTypes) {
 			propName = name ? name + pascal(separator$1) : void 0;
-			if (propName && acc.schemas.length > 0) propName = propName + pascal(getNumberWord(acc.schemas.length + 1));
+			if (propName && resolvedData.schemas.length > 0) propName = propName + pascal(getNumberWord(resolvedData.schemas.length + 1));
 		}
-		if (separator$1 === "allOf" && isSchema(subSchema) && subSchema.required) acc.requiredProperties.push(...subSchema.required);
+		if (separator$1 === "allOf" && isSchema(subSchema) && subSchema.required) resolvedData.requiredProperties.push(...subSchema.required);
 		const resolvedValue$1 = resolveObject({
 			schema: subSchema,
 			propName,
@@ -2265,32 +2475,18 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 			resolvedValue: resolvedValue$1,
 			imports: aliasedImports
 		});
-		acc.values.push(value);
-		acc.imports.push(...aliasedImports);
-		acc.schemas.push(...resolvedValue$1.schemas);
-		acc.dependencies.push(...resolvedValue$1.dependencies);
-		acc.isEnum.push(resolvedValue$1.isEnum);
-		acc.types.push(resolvedValue$1.type);
-		acc.isRef.push(resolvedValue$1.isRef);
-		acc.originalSchema.push(resolvedValue$1.originalSchema);
-		acc.hasReadonlyProps ||= resolvedValue$1.hasReadonlyProps;
-		if (resolvedValue$1.type === "object" && resolvedValue$1.originalSchema.properties) acc.allProperties.push(...Object.keys(resolvedValue$1.originalSchema.properties));
-		return acc;
-	}, {
-		values: [],
-		imports: [],
-		schemas: [],
-		isEnum: [],
-		isRef: [],
-		types: [],
-		dependencies: [],
-		originalSchema: [],
-		allProperties: [],
-		hasReadonlyProps: false,
-		example: schema.example,
-		examples: resolveExampleRefs(schema.examples, context),
-		requiredProperties: separator$1 === "allOf" ? schema.required ?? [] : []
-	});
+		resolvedData.values.push(value);
+		resolvedData.imports.push(...aliasedImports);
+		resolvedData.schemas.push(...resolvedValue$1.schemas);
+		resolvedData.dependencies.push(...resolvedValue$1.dependencies);
+		resolvedData.isEnum.push(resolvedValue$1.isEnum);
+		resolvedData.types.push(resolvedValue$1.type);
+		resolvedData.isRef.push(resolvedValue$1.isRef);
+		resolvedData.originalSchema.push(resolvedValue$1.originalSchema);
+		if (resolvedValue$1.hasReadonlyProps) resolvedData.hasReadonlyProps = true;
+		const originalProps = resolvedValue$1.originalSchema.properties;
+		if (resolvedValue$1.type === "object" && originalProps) resolvedData.allProperties.push(...Object.keys(originalProps));
+	}
 	if (resolvedData.isEnum.every(Boolean) && name && items.length > 1 && context.output.override.enumGenerationType !== EnumGeneration.UNION) {
 		const { value: combinedEnumValue, valueImports, hasNull } = getCombinedEnumValue(resolvedData.values.map((value, index) => ({
 			value,
@@ -2321,15 +2517,17 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 		};
 	}
 	let resolvedValue;
-	if (schema.properties) resolvedValue = getScalar({
-		item: Object.fromEntries(Object.entries(schema).filter(([key]) => key !== separator$1)),
+	if (normalizedSchema.properties) resolvedValue = getScalar({
+		item: Object.fromEntries(Object.entries(normalizedSchema).filter(([key]) => key !== separator$1)),
 		name,
-		context
+		context,
+		formDataContext
 	});
 	else if (separator$1 === "allOf" && (schema.oneOf || schema.anyOf)) {
 		const siblingCombiner = schema.oneOf ? "oneOf" : "anyOf";
+		const siblingSchemas = schema[siblingCombiner];
 		resolvedValue = combineSchemas({
-			schema: { [siblingCombiner]: schema[siblingCombiner] },
+			schema: { [siblingCombiner]: siblingSchemas },
 			name,
 			separator: siblingCombiner,
 			context,
@@ -2341,7 +2539,8 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 			resolvedData,
 			separator: separator$1,
 			resolvedValue,
-			context
+			context,
+			parentSchema: normalizedSchema
 		}) + nullable),
 		imports: resolvedValue ? [...resolvedData.imports, ...resolvedValue.imports] : resolvedData.imports,
 		schemas: resolvedValue ? [...resolvedData.schemas, ...resolvedValue.schemas] : resolvedData.schemas,
@@ -2349,7 +2548,7 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 		isEnum: false,
 		type: "object",
 		isRef: false,
-		hasReadonlyProps: resolvedData?.hasReadonlyProps || resolvedValue?.hasReadonlyProps || false,
+		hasReadonlyProps: resolvedData.hasReadonlyProps || (resolvedValue?.hasReadonlyProps ?? false),
 		example: schema.example,
 		examples: resolveExampleRefs(schema.examples, context)
 	};
@@ -2360,7 +2559,9 @@ function combineSchemas({ name, schema, separator: separator$1, context, nullabl
 function resolveDiscriminators(schemas, context) {
 	const transformedSchemas = schemas;
 	for (const schema of Object.values(transformedSchemas)) {
-		if (typeof schema === "boolean") continue;
+		if (isBoolean$1(schema)) continue;
+		const discriminator = schema.discriminator;
+		if (!schema.oneOf && isArray(discriminator?.oneOf)) schema.oneOf = discriminator.oneOf;
 		if (schema.discriminator?.mapping) {
 			const { mapping, propertyName } = schema.discriminator;
 			for (const [mappingKey, mappingValue] of Object.entries(mapping)) {
@@ -2371,17 +2572,25 @@ function resolveDiscriminators(schemas, context) {
 				} catch {
 					subTypeSchema = transformedSchemas[mappingValue];
 				}
-				if (typeof subTypeSchema === "boolean" || propertyName === void 0) continue;
+				if (isBoolean$1(subTypeSchema) || propertyName === void 0) continue;
 				const property = subTypeSchema.properties?.[propertyName];
-				if (typeof property === "boolean" || property === void 0) continue;
+				if (isBoolean$1(property)) continue;
+				const schemaProperty = property && !isReference(property) ? property : void 0;
+				const enumProperty = schemaProperty ? getPropertySafe(schemaProperty, "enum") : {
+					hasProperty: false,
+					value: void 0
+				};
+				const mergedEnumValues = [...((enumProperty.hasProperty && Array.isArray(enumProperty.value) ? enumProperty.value : void 0) ?? []).filter((value) => value !== mappingKey), mappingKey];
+				const mergedProperty = {
+					...schemaProperty,
+					type: "string",
+					enum: mergedEnumValues
+				};
 				subTypeSchema.properties = {
 					...subTypeSchema.properties,
-					[propertyName]: {
-						type: "string",
-						enum: [...property?.enum?.filter((value) => value !== mappingKey) ?? [], mappingKey]
-					}
+					[propertyName]: mergedProperty
 				};
-				subTypeSchema.required = [...subTypeSchema.required ?? [], propertyName];
+				subTypeSchema.required = [...new Set([...subTypeSchema.required ?? [], propertyName])];
 			}
 		}
 	}
@@ -2403,23 +2612,22 @@ function getOperationId(operation, route, verb) {
 //#endregion
 //#region src/getters/parameters.ts
 function getParameters({ parameters, context }) {
-	return parameters.reduce((acc, p) => {
-		if (isReference(p)) {
-			const { schema: parameter, imports } = resolveRef(p, context);
-			if (parameter.in === "path" || parameter.in === "query" || parameter.in === "header") acc[parameter.in].push({
-				parameter,
-				imports
-			});
-		} else if (p.in === "query" || p.in === "path" || p.in === "header") acc[p.in].push({
-			parameter: p,
-			imports: []
-		});
-		return acc;
-	}, {
+	const result = {
 		path: [],
 		query: [],
 		header: []
+	};
+	for (const p of parameters) if (isReference(p)) {
+		const { schema: parameter, imports } = resolveRef(p, context);
+		if (parameter.in === "path" || parameter.in === "query" || parameter.in === "header") result[parameter.in].push({
+			parameter,
+			imports
+		});
+	} else if (p.in === "query" || p.in === "path" || p.in === "header") result[p.in].push({
+		parameter: p,
+		imports: []
 	});
+	return result;
 }
 
 //#endregion
@@ -2463,16 +2671,18 @@ function getParams({ route, pathParams = [], operationId, context, output }) {
 			schema,
 			context
 		});
+		const originalSchema = resolvedValue.originalSchema;
+		const schemaDefault = originalSchema.default;
 		let paramType = resolvedValue.value;
 		if (output.allParamsOptional) paramType = `${paramType} | undefined | null`;
 		return {
 			name,
-			definition: `${name}${!required || resolvedValue.originalSchema.default ? "?" : ""}: ${paramType}`,
-			implementation: `${name}${!required && !resolvedValue.originalSchema.default ? "?" : ""}${resolvedValue.originalSchema.default ? `: ${paramType} = ${stringify(resolvedValue.originalSchema.default)}` : `: ${paramType}`}`,
-			default: resolvedValue.originalSchema.default,
+			definition: `${name}${!required || schemaDefault ? "?" : ""}: ${paramType}`,
+			implementation: `${name}${!required && !schemaDefault ? "?" : ""}${schemaDefault ? `: ${paramType} = ${stringify(schemaDefault)}` : `: ${paramType}`}`,
+			default: schemaDefault,
 			required,
 			imports: resolvedValue.imports,
-			originalSchema: resolvedValue.originalSchema
+			originalSchema
 		};
 	});
 }
@@ -2493,7 +2703,7 @@ function getProps({ body, queryParams, params, operationName, headers, context }
 		definition: getQueryParamDefinition(queryParams, context),
 		implementation: getQueryParamDefinition(queryParams, context),
 		default: false,
-		required: isUndefined(queryParams?.isOptional) ? !context.output.allParamsOptional || context.output.optionsParamRequired : !queryParams?.isOptional && !context.output.allParamsOptional || context.output.optionsParamRequired,
+		required: isNullish(queryParams?.isOptional) ? !context.output.allParamsOptional || context.output.optionsParamRequired : !queryParams.isOptional && !context.output.allParamsOptional || context.output.optionsParamRequired,
 		type: GetterPropType.QUERY_PARAM
 	};
 	const headersProp = {
@@ -2501,7 +2711,7 @@ function getProps({ body, queryParams, params, operationName, headers, context }
 		definition: `headers${headers?.isOptional && !context.output.optionsParamRequired ? "?" : ""}: ${headers?.schema.name}`,
 		implementation: `headers${headers?.isOptional && !context.output.optionsParamRequired ? "?" : ""}: ${headers?.schema.name}`,
 		default: false,
-		required: isUndefined(headers?.isOptional) ? false : !headers?.isOptional || context.output.optionsParamRequired,
+		required: isNullish(headers?.isOptional) ? false : !headers.isOptional || context.output.optionsParamRequired,
 		type: GetterPropType.HEADER
 	};
 	let paramGetterProps;
@@ -2538,13 +2748,27 @@ function getProps({ body, queryParams, params, operationName, headers, context }
 	]);
 }
 function getQueryParamDefinition(queryParams, context) {
-	let paramType = queryParams?.schema.name;
-	if (OutputClient.ANGULAR === context.output.client) paramType = `DeepNonNullable<${paramType}>`;
+	const paramType = queryParams?.schema.name;
 	return `params${(queryParams?.isOptional || context.output.allParamsOptional) && !context.output.optionsParamRequired ? "?" : ""}: ${paramType}`;
 }
 
 //#endregion
 //#region src/getters/query-params.ts
+const isOpenApiSchemaObject = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return !("$ref" in value);
+};
+const isSchemaNullable = (schema) => {
+	if (schema.nullable === true) return true;
+	if (schema.type === "null") return true;
+	if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+	const oneOfVariants = Array.isArray(schema.oneOf) ? schema.oneOf : [];
+	const anyOfVariants = Array.isArray(schema.anyOf) ? schema.anyOf : [];
+	return [...oneOfVariants, ...anyOfVariants].some((variant) => {
+		if (!isOpenApiSchemaObject(variant)) return false;
+		return isSchemaNullable(variant);
+	});
+};
 function getQueryParamsTypes(queryParams, operationName, context) {
 	return queryParams.map(({ parameter, imports: parameterImports }) => {
 		const { name, required, schema: schemaParam, content } = parameter;
@@ -2555,18 +2779,22 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 			es5keyword: true,
 			es5IdentifierName: true
 		});
-		const schema = schemaParam || content["application/json"].schema;
+		const schema = schemaParam ?? content?.["application/json"]?.schema;
+		if (!schema) throw new Error(`Query parameter "${name}" has no schema or content definition`);
 		const resolvedValue = resolveValue({
 			schema,
 			context,
 			name: queryName
 		});
 		const key = getKey(name);
+		const schemaForDoc = schema;
 		const doc = jsDoc({
 			description: parameter.description,
-			...schema
+			...schemaForDoc
 		}, void 0, context);
 		if (parameterImports.length > 0) return {
+			name,
+			required,
 			definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${parameterImports[0].name};`,
 			imports: parameterImports,
 			schemas: [],
@@ -2574,8 +2802,10 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 		};
 		if (resolvedValue.isEnum && !resolvedValue.isRef) {
 			const enumName = queryName;
-			const enumValue = getEnum(resolvedValue.value, enumName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention?.enum);
+			const enumValue = getEnum(resolvedValue.value, enumName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
 			return {
+				name,
+				required,
 				definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${enumName};`,
 				imports: [{ name: enumName }],
 				schemas: [...resolvedValue.schemas, {
@@ -2587,6 +2817,8 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 			};
 		}
 		return {
+			name,
+			required,
 			definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${resolvedValue.value};`,
 			imports: resolvedValue.imports,
 			schemas: resolvedValue.schemas,
@@ -2602,6 +2834,7 @@ function getQueryParams({ queryParams, operationName, context, suffix = "params"
 	const name = `${pascal(operationName)}${pascal(suffix)}`;
 	const type = types.map(({ definition }) => definition).join("\n");
 	const allOptional = queryParams.every(({ parameter }) => !parameter.required);
+	const requiredNullableKeys = types.filter(({ required, originalSchema }) => required && isSchemaNullable(originalSchema)).map(({ name: name$1 }) => name$1);
 	return {
 		schema: {
 			name,
@@ -2609,46 +2842,24 @@ function getQueryParams({ queryParams, operationName, context, suffix = "params"
 			imports
 		},
 		deps: schemas,
-		isOptional: allOptional
+		isOptional: allOptional,
+		requiredNullableKeys
 	};
 }
 
 //#endregion
 //#region src/getters/response.ts
 function getResponse({ responses, operationName, context, contentType }) {
-	if (!responses) return {
-		imports: [],
-		definition: {
-			success: "",
-			errors: ""
-		},
-		isBlob: false,
-		types: {
-			success: [],
-			errors: []
-		},
-		schemas: [],
-		contentTypes: []
-	};
-	const types = getResReqTypes(Object.entries(responses), operationName, context, "void", (type) => `${type.key}-${type.value}`);
-	const filteredTypes = contentType ? types.filter((type) => {
-		let include = true;
-		let exclude = false;
-		if (contentType.include) include = contentType.include.includes(type.contentType);
-		if (contentType.exclude) exclude = contentType.exclude.includes(type.contentType);
-		return include && !exclude;
-	}) : types;
+	const filteredTypes = filterByContentType(getResReqTypes(Object.entries(responses), operationName, context, "void", (type) => `${type.key}-${type.value}-${type.contentType}`), contentType);
 	const imports = filteredTypes.flatMap(({ imports: imports$1 }) => imports$1);
 	const schemas = filteredTypes.flatMap(({ schemas: schemas$1 }) => schemas$1);
 	const contentTypes = [...new Set(filteredTypes.map(({ contentType: contentType$1 }) => contentType$1))];
-	const groupedByStatus = filteredTypes.reduce((acc, type) => {
-		if (type.key.startsWith("2")) acc.success.push(type);
-		else acc.errors.push(type);
-		return acc;
-	}, {
+	const groupedByStatus = {
 		success: [],
 		errors: []
-	});
+	};
+	for (const type of filteredTypes) if (type.key.startsWith("2")) groupedByStatus.success.push(type);
+	else groupedByStatus.errors.push(type);
 	const success = dedupeUnionType(groupedByStatus.success.map(({ value, formData }) => formData ? "Blob" : value).join(" | "));
 	const errors = dedupeUnionType(groupedByStatus.errors.map(({ value }) => value).join(" | "));
 	const defaultType = filteredTypes.find(({ key }) => key === "default")?.value;
@@ -2684,16 +2895,18 @@ const getRoutePath = (path$2) => {
 	return hasParam(path$2) ? `${prev}\${${param}}${next}` : `${prev}${param}${next}`;
 };
 function getRoute(route) {
-	return route.split("/").reduce((acc, path$2, i) => {
-		if (!path$2 && !i) return acc;
-		if (!path$2.includes("{")) return `${acc}/${path$2}`;
-		return `${acc}/${getRoutePath(path$2)}`;
-	}, "");
+	const splittedRoute = route.split("/");
+	let result = "";
+	for (const [i, path$2] of splittedRoute.entries()) {
+		if (!path$2 && !i) continue;
+		result += path$2.includes("{") ? `/${getRoutePath(path$2)}` : `/${path$2}`;
+	}
+	return result;
 }
 function getFullRoute(route, servers, baseUrl) {
 	const getBaseUrl = () => {
 		if (!baseUrl) return "";
-		if (typeof baseUrl === "string") return baseUrl;
+		if (isString(baseUrl)) return baseUrl;
 		if (baseUrl.getBaseUrlFromSpecification) {
 			if (!servers) throw new Error("Orval is configured to use baseUrl from the specifications 'servers' field, but there exist no servers in the specification.");
 			const server = servers.at(Math.min(baseUrl.index ?? 0, servers.length - 1));
@@ -2756,7 +2969,7 @@ function generateComponentDefinition(responses = {}, context, suffix) {
 //#region src/generators/imports.ts
 function generateImports({ imports, namingConvention = NamingConvention.CAMEL_CASE }) {
 	if (imports.length === 0) return "";
-	const grouped = groupBy(uniqueWith(imports, (a, b) => a.name === b.name && a.default === b.default).map((imp) => ({
+	const grouped = groupBy(uniqueWith(imports, (a, b) => a.name === b.name && a.default === b.default && a.alias === b.alias && a.values === b.values && a.isConstant === b.isConstant && a.namespaceImport === b.namespaceImport && a.syntheticDefaultImport === b.syntheticDefaultImport && a.importPath === b.importPath).map((imp) => ({
 		...imp,
 		importPath: imp.importPath ?? `./${conventionName(imp.name, namingConvention)}`
 	})), (imp) => !imp.default && !imp.namespaceImport && !imp.syntheticDefaultImport && !imp.values && !imp.isConstant ? `aggregate|${imp.importPath}` : `single|${imp.importPath}|${imp.name}|${imp.alias ?? ""}|${String(imp.default)}|${String(imp.namespaceImport)}|${String(imp.syntheticDefaultImport)}|${String(imp.values)}|${String(imp.isConstant)}`);
@@ -2768,25 +2981,26 @@ function generateImports({ imports, namingConvention = NamingConvention.CAMEL_CA
 	}).join("\n");
 }
 function generateMutatorImports({ mutators, implementation, oneMore }) {
-	return uniqueWith(mutators, (a, b) => a.name === b.name && a.default === b.default).reduce((acc, mutator) => {
+	let imports = "";
+	for (const mutator of uniqueWith(mutators, (a, b) => a.name === b.name && a.default === b.default)) {
 		const path$2 = `${oneMore ? "../" : ""}${mutator.path}`;
 		const importDefault = mutator.default ? mutator.name : `{ ${mutator.name} }`;
-		acc += `import ${importDefault} from '${path$2}';`;
-		acc += "\n";
+		imports += `import ${importDefault} from '${path$2}';`;
+		imports += "\n";
 		if (implementation && (mutator.hasErrorType || mutator.bodyTypeName)) {
 			let errorImportName = "";
 			const targetErrorImportName = mutator.default ? `ErrorType as ${mutator.errorTypeName}` : mutator.errorTypeName;
-			if (mutator.hasErrorType && implementation.includes(mutator.errorTypeName) && !acc.includes(`{ ${targetErrorImportName} `)) errorImportName = targetErrorImportName;
+			if (mutator.hasErrorType && implementation.includes(mutator.errorTypeName) && !imports.includes(`{ ${targetErrorImportName} `)) errorImportName = targetErrorImportName;
 			let bodyImportName = "";
 			const targetBodyImportName = mutator.default ? `BodyType as ${mutator.bodyTypeName}` : mutator.bodyTypeName;
-			if (mutator.bodyTypeName && implementation.includes(mutator.bodyTypeName) && !acc.includes(` ${targetBodyImportName} }`)) bodyImportName = targetBodyImportName;
+			if (mutator.bodyTypeName && implementation.includes(mutator.bodyTypeName) && !imports.includes(` ${targetBodyImportName} }`)) bodyImportName = targetBodyImportName ?? "";
 			if (bodyImportName || errorImportName) {
-				acc += `import type { ${errorImportName}${errorImportName && bodyImportName ? " , " : ""}${bodyImportName} } from '${path$2}';`;
-				acc += "\n";
+				imports += `import type { ${errorImportName}${errorImportName && bodyImportName ? " , " : ""}${bodyImportName} } from '${path$2}';`;
+				imports += "\n";
 			}
 		}
-		return acc;
-	}, "");
+	}
+	return imports;
 }
 function generateDependency({ deps, isAllowSyntheticDefaultImports, dependency, projectName, key, onlyTypes }) {
 	const defaultDep = deps.find((e) => e.default && (isAllowSyntheticDefaultImports || !e.syntheticDefaultImport));
@@ -2801,31 +3015,25 @@ function generateDependency({ deps, isAllowSyntheticDefaultImports, dependency,
 	importString += `import ${onlyTypes ? "type " : ""}${defaultDep ? `${defaultDep.name}${depsString ? "," : ""}` : ""}${depsString ? `{\n  ${depsString}\n}` : ""} from '${dependency}${key !== "default" && projectName ? `/${projectName}` : ""}';`;
 	return importString;
 }
-function addDependency({ implementation, exports, dependency, projectName, hasSchemaDir, isAllowSyntheticDefaultImports }) {
+function addDependency({ implementation, exports, dependency, projectName, isAllowSyntheticDefaultImports }) {
 	const toAdds = exports.filter((e) => {
 		const searchWords = [e.alias, e.name].filter((p) => p?.length).join("|");
 		const pattern = new RegExp(String.raw`\b(${searchWords})\b`, "g");
 		return implementation.match(pattern);
 	});
 	if (toAdds.length === 0) return;
-	const groupedBySpecKey = toAdds.reduce((acc, dep) => {
+	const groupedBySpecKey = { default: {
+		types: [],
+		values: []
+	} };
+	for (const dep of toAdds) {
 		const key = "default";
-		if (dep.values && (isAllowSyntheticDefaultImports || !dep.syntheticDefaultImport)) {
-			acc[key] = {
-				...acc[key],
-				values: [...acc[key]?.values ?? [], dep]
-			};
-			return acc;
-		}
-		acc[key] = {
-			...acc[key],
-			types: [...acc[key]?.types ?? [], dep]
-		};
-		return acc;
-	}, {});
+		if (dep.values && (isAllowSyntheticDefaultImports || !dep.syntheticDefaultImport)) groupedBySpecKey[key].values.push(dep);
+		else groupedBySpecKey[key].types.push(dep);
+	}
 	return Object.entries(groupedBySpecKey).map(([key, { values, types }]) => {
 		let dep = "";
-		if (values) dep += generateDependency({
+		if (values.length > 0) dep += generateDependency({
 			deps: values,
 			isAllowSyntheticDefaultImports,
 			dependency,
@@ -2833,10 +3041,10 @@ function addDependency({ implementation, exports, dependency, projectName, hasSc
 			key,
 			onlyTypes: false
 		});
-		if (types) {
+		if (types.length > 0) {
 			let uniqueTypes = types;
-			if (values) {
-				uniqueTypes = types.filter((t) => !values.some((v) => v.name === t.name));
+			if (values.length > 0) {
+				uniqueTypes = types.filter((t) => !values.some((v) => v.name === t.name && (v.alias ?? "") === (t.alias ?? "")));
 				dep += "\n";
 			}
 			dep += generateDependency({
@@ -2862,7 +3070,7 @@ function generateDependencyImports(implementation, imports, projectName, hasSche
 		projectName,
 		hasSchemaDir,
 		isAllowSyntheticDefaultImports
-	})).filter(Boolean).sort((a, b) => {
+	})).filter((x) => Boolean(x)).toSorted((a, b) => {
 		const aLib = getLibName(a);
 		const bLib = getLibName(b);
 		if (aLib === bLib) return 0;
@@ -2879,7 +3087,17 @@ function generateVerbImports({ response, body, queryParams, props, headers, para
 		...queryParams ? [{ name: queryParams.schema.name }] : [],
 		...headers ? [{ name: headers.schema.name }] : [],
 		...params.flatMap(({ imports }) => imports)
-	];
+	].flatMap((imp) => {
+		if (imp.name !== "Error" || !imp.values || imp.alias) return [imp];
+		return [{
+			...imp,
+			values: void 0
+		}, {
+			...imp,
+			alias: "ErrorSchema",
+			values: true
+		}];
+	});
 }
 
 //#endregion
@@ -2888,7 +3106,10 @@ function generateModelInline(acc, model) {
 	return acc + `${model}\n`;
 }
 function generateModelsInline(obj) {
-	return Object.values(obj).flat().reduce((acc, { model }) => generateModelInline(acc, model), "");
+	const schemas = Object.values(obj).flat();
+	let result = "";
+	for (const { model } of schemas) result = generateModelInline(result, model);
+	return result;
 }
 
 //#endregion
@@ -2914,7 +3135,7 @@ async function bundleFile(root, fileName, alias, external, compilerOptions) {
 		treeShaking: false,
 		keepNames: false,
 		alias,
-		external: external || ["*"]
+		external: external ?? ["*"]
 	})).outputFiles[0];
 	return text;
 }
@@ -3038,46 +3259,143 @@ function removeComments(file) {
 
 //#endregion
 //#region src/generators/options.ts
+/**
+* Filters query params for Angular's HttpClient.
+*
+* Why: Angular's HttpParams / HttpClient `params` type does not accept `null` or
+* `undefined` values, and arrays must only contain string/number/boolean.
+* Orval models often include nullable query params, so we remove nullish values
+* (including nulls inside arrays) before passing params to HttpClient or a
+* paramsSerializer to avoid runtime and type issues.
+*
+* Returns an inline IIFE expression. For paths that benefit from a shared helper
+* (e.g. observe-mode branches), prefer getAngularFilteredParamsCallExpression +
+* getAngularFilteredParamsHelperBody instead.
+*/
+const getAngularFilteredParamsExpression = (paramsExpression, requiredNullableParamKeys = []) => `(() => {
+  const requiredNullableParamKeys = new Set<string>(${JSON.stringify(requiredNullableParamKeys)});
+  const filteredParams = {} as Record<string, string | number | boolean | null | Array<string | number | boolean>>;
+  for (const [key, value] of Object.entries(${paramsExpression})) {
+    if (Array.isArray(value)) {
+      const filtered = value.filter(
+        (item) =>
+          item != null &&
+          (typeof item === 'string' ||
+            typeof item === 'number' ||
+            typeof item === 'boolean'),
+          ) as Array<string | number | boolean>;
+      if (filtered.length) {
+        filteredParams[key] = filtered;
+      }
+    } else if (value === null && requiredNullableParamKeys.has(key)) {
+      filteredParams[key] = value;
+    } else if (
+      value != null &&
+      (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean')
+    ) {
+      filteredParams[key] = value as string | number | boolean;
+    }
+  }
+  return filteredParams as unknown as Record<string, string | number | boolean | Array<string | number | boolean>>;
+})()`;
+/**
+* Returns the body of a standalone `filterParams` helper function
+* to be emitted once in the generated file header, replacing the
+* inline IIFE that was previously duplicated in every method.
+*/
+const getAngularFilteredParamsHelperBody = () => `function filterParams(
+  params: Record<string, unknown>,
+  requiredNullableKeys: Set<string> = new Set(),
+): Record<string, string | number | boolean | Array<string | number | boolean>> {
+  const filteredParams: Record<string, string | number | boolean | null | Array<string | number | boolean>> = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      const filtered = value.filter(
+        (item) =>
+          item != null &&
+          (typeof item === 'string' ||
+            typeof item === 'number' ||
+            typeof item === 'boolean'),
+      ) as Array<string | number | boolean>;
+      if (filtered.length) {
+        filteredParams[key] = filtered;
+      }
+    } else if (value === null && requiredNullableKeys.has(key)) {
+      filteredParams[key] = value;
+    } else if (
+      value != null &&
+      (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean')
+    ) {
+      filteredParams[key] = value as string | number | boolean;
+    }
+  }
+  return filteredParams as Record<string, string | number | boolean | Array<string | number | boolean>>;
+}`;
+/**
+* Returns a call expression to the `filterParams` helper function.
+*/
+const getAngularFilteredParamsCallExpression = (paramsExpression, requiredNullableParamKeys = []) => `filterParams(${paramsExpression}, new Set<string>(${JSON.stringify(requiredNullableParamKeys)}))`;
 function generateBodyOptions(body, isFormData, isFormUrlEncoded) {
 	if (isFormData && body.formData) return "\n      formData,";
 	if (isFormUrlEncoded && body.formUrlEncoded) return "\n      formUrlEncoded,";
 	if (body.implementation) return `\n      ${body.implementation},`;
 	return "";
 }
-function generateAxiosOptions({ response, isExactOptionalPropertyTypes, queryParams, headers, requestOptions, hasSignal, hasSignalParam = false, isVue, isAngular, paramsSerializer, paramsSerializerOptions }) {
+function generateAxiosOptions({ response, isExactOptionalPropertyTypes, angularObserve, angularParamsRef, requiredNullableQueryParamKeys, queryParams, headers, requestOptions, hasSignal, hasSignalParam = false, isVue, isAngular, paramsSerializer, paramsSerializerOptions }) {
 	const isRequestOptions = requestOptions !== false;
 	const signalVar = hasSignalParam ? "querySignal" : "signal";
 	const signalProp = hasSignalParam ? `signal: ${signalVar}` : "signal";
 	if (!queryParams && !headers && !response.isBlob && response.definition.success !== "string") {
-		if (isRequestOptions) return "options";
+		if (isRequestOptions) return isAngular ? angularObserve ? `{
+        ...(options as Omit<NonNullable<typeof options>, 'observe'>),
+        observe: '${angularObserve}',
+      }` : "(options as Omit<NonNullable<typeof options>, 'observe'>)" : "options";
 		if (hasSignal) return isExactOptionalPropertyTypes ? `...(${signalVar} ? { ${signalProp} } : {})` : signalProp;
 		return "";
 	}
 	let value = "";
 	if (!isRequestOptions) {
-		if (queryParams) value += "\n        params,";
+		if (queryParams) if (isAngular) {
+			const iifeExpr = getAngularFilteredParamsExpression("params ?? {}", requiredNullableQueryParamKeys);
+			value += paramsSerializer ? `\n        params: ${paramsSerializer.name}(${iifeExpr}),` : `\n        params: ${iifeExpr},`;
+		} else value += "\n        params,";
 		if (headers) value += "\n        headers,";
 		if (hasSignal) value += isExactOptionalPropertyTypes ? `\n        ...(${signalVar} ? { ${signalProp} } : {}),` : `\n        ${signalProp},`;
 	}
-	if (!isObject(requestOptions) || !requestOptions.hasOwnProperty("responseType")) {
-		if (response.isBlob) value += `\n        responseType: 'blob',`;
-		else if (response.contentTypes.at(0) === "text/plain") value += `\n        responseType: 'text',`;
+	if (!isObject(requestOptions) || !Object.hasOwn(requestOptions, "responseType")) {
+		const successResponseType = getSuccessResponseType(response);
+		if (successResponseType) value += `\n        responseType: '${successResponseType}',`;
 	}
 	if (isObject(requestOptions)) value += `\n ${stringify(requestOptions)?.slice(1, -1)}`;
 	if (isRequestOptions) {
-		value += "\n    ...options,";
+		value += isAngular ? "\n    ...(options as Omit<NonNullable<typeof options>, 'observe'>)," : "\n    ...options,";
+		if (isAngular && angularObserve) value += `\n        observe: '${angularObserve}',`;
 		if (queryParams) if (isVue) value += "\n        params: {...unref(params), ...options?.params},";
-		else if (isAngular && paramsSerializer) value += `\n        params: ${paramsSerializer.name}({...params, ...options?.params}),`;
+		else if (isAngular && angularParamsRef) value += `\n        params: ${angularParamsRef},`;
+		else if (isAngular && paramsSerializer) {
+			const callExpr = getAngularFilteredParamsCallExpression("{...params, ...options?.params}", requiredNullableQueryParamKeys);
+			value += `\n        params: ${paramsSerializer.name}(${callExpr}),`;
+		} else if (isAngular) value += `\n        params: ${getAngularFilteredParamsCallExpression("{...params, ...options?.params}", requiredNullableQueryParamKeys)},`;
 		else value += "\n        params: {...params, ...options?.params},";
 		if (headers) value += "\n        headers: {...headers, ...options?.headers},";
 	}
-	if (!isAngular && queryParams && (paramsSerializer || paramsSerializerOptions?.qs)) value += paramsSerializer ? `\n        paramsSerializer: ${paramsSerializer.name},` : `\n        paramsSerializer: (params) => qs.stringify(params, ${JSON.stringify(paramsSerializerOptions.qs)}),`;
+	if (!isAngular && queryParams && (paramsSerializer || paramsSerializerOptions?.qs)) {
+		const qsOptions = paramsSerializerOptions?.qs;
+		value += paramsSerializer ? `\n        paramsSerializer: ${paramsSerializer.name},` : `\n        paramsSerializer: (params) => qs.stringify(params, ${JSON.stringify(qsOptions)}),`;
+	}
 	return value;
 }
-function generateOptions({ route, body, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, hasSignalParam, isVue, paramsSerializer, paramsSerializerOptions }) {
+function generateOptions({ route, body, angularObserve, angularParamsRef, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, hasSignalParam, isVue, paramsSerializer, paramsSerializerOptions }) {
 	const bodyOptions = getIsBodyVerb(verb) ? generateBodyOptions(body, isFormData, isFormUrlEncoded) : "";
 	const axiosOptions = generateAxiosOptions({
 		response,
+		angularObserve,
+		angularParamsRef,
+		requiredNullableQueryParamKeys: queryParams?.requiredNullableKeys,
 		queryParams: queryParams?.schema,
 		headers: headers?.schema,
 		requestOptions,
@@ -3089,12 +3407,15 @@ function generateOptions({ route, body, headers, queryParams, response, verb, re
 		paramsSerializer,
 		paramsSerializerOptions
 	});
-	const options = axiosOptions ? `{${axiosOptions}}` : "";
+	const isRawOptionsArgument = axiosOptions === "options" || axiosOptions.startsWith("(") && axiosOptions.endsWith(")");
+	const optionsArgument = axiosOptions ? isRawOptionsArgument ? axiosOptions : `{${axiosOptions}}` : "";
 	if (verb === Verbs.DELETE) {
-		if (!bodyOptions) return `\n      \`${route}\`,${axiosOptions === "options" ? axiosOptions : options}\n    `;
-		return `\n      \`${route}\`,{${isAngular ? "body" : "data"}:${bodyOptions} ${axiosOptions === "options" ? `...${axiosOptions}` : axiosOptions}}\n    `;
+		if (!bodyOptions) return `\n      \`${route}\`${optionsArgument ? `,${optionsArgument}` : ""}\n    `;
+		const deleteBodyOptions = isRawOptionsArgument ? `...${optionsArgument}` : axiosOptions;
+		return `\n      \`${route}\`,{${isAngular ? "body" : "data"}:${bodyOptions} ${axiosOptions ? deleteBodyOptions : ""}}\n    `;
 	}
-	return `\n      \`${route}\`,${getIsBodyVerb(verb) ? bodyOptions || "undefined," : ""}${axiosOptions === "options" ? axiosOptions : options}\n    `;
+	const bodyOrOptions = getIsBodyVerb(verb) ? bodyOptions || "undefined," : "";
+	return `\n      \`${route}\`${bodyOrOptions || optionsArgument ? "," : ""}${bodyOrOptions}${optionsArgument}\n    `;
 }
 function generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) {
 	if (isFormData && body.formData) return ",\n       data: formData";
@@ -3102,17 +3423,19 @@ function generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) {
 	if (body.implementation) return `,\n      data: ${body.implementation}`;
 	return "";
 }
-function generateQueryParamsAxiosConfig(response, isVue, queryParams) {
+function generateQueryParamsAxiosConfig(response, isVue, isAngular, requiredNullableQueryParamKeys, queryParams) {
 	if (!queryParams && !response.isBlob) return "";
 	let value = "";
-	if (queryParams) value += isVue ? ",\n        params: unref(params)" : ",\n        params";
+	if (queryParams) if (isVue) value += ",\n        params: unref(params)";
+	else if (isAngular) value += `,\n        params: ${getAngularFilteredParamsExpression("params ?? {}", requiredNullableQueryParamKeys)}`;
+	else value += ",\n        params";
 	if (response.isBlob) value += `,\n        responseType: 'blob'`;
 	return value;
 }
-function generateMutatorConfig({ route, body, headers, queryParams, response, verb, isFormData, isFormUrlEncoded, hasSignal, hasSignalParam = false, isExactOptionalPropertyTypes, isVue }) {
+function generateMutatorConfig({ route, body, headers, queryParams, response, verb, isFormData, isFormUrlEncoded, hasSignal, hasSignalParam = false, isExactOptionalPropertyTypes, isVue, isAngular }) {
 	const bodyOptions = getIsBodyVerb(verb) ? generateBodyMutatorConfig(body, isFormData, isFormUrlEncoded) : "";
-	const queryParamsOptions = generateQueryParamsAxiosConfig(response, isVue ?? false, queryParams);
-	const headerOptions = body.contentType ? `,\n      headers: {'Content-Type': '${body.contentType}', ${headers ? "...headers" : ""}}` : headers ? ",\n      headers" : "";
+	const queryParamsOptions = generateQueryParamsAxiosConfig(response, isVue ?? false, isAngular ?? false, queryParams?.requiredNullableKeys, queryParams);
+	const headerOptions = body.contentType && !["multipart/form-data"].includes(body.contentType) ? `,\n      headers: {'Content-Type': '${body.contentType}', ${headers ? "...headers" : ""}}` : headers ? ",\n      headers" : "";
 	const signalVar = hasSignalParam ? "querySignal" : "signal";
 	const signalProp = hasSignalParam ? `signal: ${signalVar}` : "signal";
 	return `{url: \`${route}\`, method: '${verb.toUpperCase()}'${headerOptions}${bodyOptions}${queryParamsOptions}${hasSignal ? `, ${isExactOptionalPropertyTypes ? `...(${signalVar} ? { ${signalProp} }: {})` : signalProp}` : ""}\n    }`;
@@ -3194,18 +3517,20 @@ function generateInterface({ name, schema, context }) {
 		context
 	});
 	const isEmptyObject = scalar.value === "{}";
-	const shouldUseTypeAlias = context?.output.override?.useTypeOverInterfaces || scalar.useTypeAlias;
+	const shouldUseTypeAlias = context.output.override.useTypeOverInterfaces ?? scalar.useTypeAlias;
 	let model = "";
 	model += jsDoc(schema);
 	if (isEmptyObject) model += "// eslint-disable-next-line @typescript-eslint/no-empty-interface\n";
-	if (scalar.type === "object" && !shouldUseTypeAlias) if (scalar.type === "object" && schema.properties && Object.values(schema.properties).length > 0 && Object.values(schema.properties).every((item) => "const" in item)) {
-		const mappedScalarValue = scalar.value.replaceAll(";", ",").replaceAll("?:", ":");
-		model += `export const ${name}Value = ${mappedScalarValue} as const;\nexport type ${name} = typeof ${name}Value;\n`;
-	} else {
-		const blankInterfaceValue = scalar.value === "unknown" ? "{}" : scalar.value;
-		model += `export interface ${name} ${blankInterfaceValue}\n`;
-	}
-	else model += `export type ${name} = ${scalar.value};\n`;
+	if (scalar.type === "object" && !shouldUseTypeAlias) {
+		const properties = schema.properties;
+		if (properties && Object.values(properties).length > 0 && Object.values(properties).every((item) => "const" in item)) {
+			const mappedScalarValue = scalar.value.replaceAll(";", ",").replaceAll("?:", ":");
+			model += `export const ${name}Value = ${mappedScalarValue} as const;\nexport type ${name} = typeof ${name}Value;\n`;
+		} else {
+			const blankInterfaceValue = scalar.value === "unknown" ? "{}" : scalar.value;
+			model += `export interface ${name} ${blankInterfaceValue}\n`;
+		}
+	} else model += `export type ${name} = ${scalar.value};\n`;
 	const externalModulesImportsOnly = scalar.imports.filter((importName) => importName.alias ? importName.alias !== name : importName.name !== name);
 	return [...scalar.schemas, {
 		name,
@@ -3255,7 +3580,7 @@ function sortSchemasByDependencies(schemas) {
 			for (const dependencyName of schema.dependencies) if (dependencyName && schemaNames.has(dependencyName)) dependencies.add(dependencyName);
 		}
 		for (const imp of schema.imports) {
-			const dependencyName = imp.alias || imp.name;
+			const dependencyName = imp.alias ?? imp.name;
 			if (dependencyName && schemaNames.has(dependencyName)) dependencies.add(dependencyName);
 		}
 		dependencyMap.set(schema.name, dependencies);
@@ -3292,7 +3617,7 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 		es5keyword: true,
 		es5IdentifierName: true
 	});
-	if (typeof schema === "boolean") return [{
+	if (isBoolean(schema)) return [{
 		name: sanitizedSchemaName,
 		model: `export type ${sanitizedSchemaName} = ${schema ? "any" : "never"};\n`,
 		imports: [],
@@ -3311,7 +3636,7 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 	let output = "";
 	let imports = resolvedValue.imports;
 	output += jsDoc(schema);
-	if (resolvedValue.isEnum && !resolvedValue.isRef) output += getEnum(resolvedValue.value, sanitizedSchemaName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention?.enum);
+	if (resolvedValue.isEnum && !resolvedValue.isRef) output += getEnum(resolvedValue.value, sanitizedSchemaName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
 	else if (sanitizedSchemaName === resolvedValue.value && resolvedValue.isRef) {
 		const { schema: referredSchema } = resolveRef(schema, context);
 		if (!shouldCreateInterface(referredSchema)) {
@@ -3330,7 +3655,7 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 		resolvedValue.schemas = resolvedValue.schemas.filter((schema$1) => {
 			if (schema$1.name !== sanitizedSchemaName) return true;
 			output += `${schema$1.model}\n`;
-			imports = imports.concat(schema$1.imports);
+			imports = [...imports, ...schema$1.imports];
 			resolvedValue.dependencies.push(...schema$1.dependencies ?? []);
 			return false;
 		});
@@ -3347,26 +3672,56 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 
 //#endregion
 //#region src/generators/verbs-options.ts
-async function generateVerbOptions({ verb, output, operation, route, pathRoute, verbParameters = [], context }) {
-	const { responses, requestBody, parameters: operationParameters, tags = [], deprecated, description, summary } = operation;
+/**
+* Get a content-type specific suffix for operation names (#2812)
+*/
+function getContentTypeSuffix(contentType) {
+	return {
+		"application/json": "Json",
+		"multipart/form-data": "FormData",
+		"application/x-www-form-urlencoded": "UrlEncoded",
+		"application/xml": "Xml",
+		"text/plain": "Text"
+	}[contentType] || pascal(contentType.replaceAll(/[^a-zA-Z0-9]/g, "_"));
+}
+async function generateVerbOptions({ verb, output, operation, route, pathRoute, verbParameters = [], context, contentType }) {
+	const { responses, requestBody, parameters: operationParameters, tags: rawTags, deprecated: rawDeprecated, description: rawDescription, summary: rawSummary } = operation;
+	const tags = rawTags ?? [];
+	const deprecated = rawDeprecated;
+	const description = rawDescription;
+	const summary = rawSummary;
 	const operationId = getOperationId(operation, route, verb);
 	const overrideOperation = output.override.operations[operationId];
-	const overrideTag = Object.entries(output.override.tags).reduce((acc, [tag, options]) => tags.includes(tag) && options ? mergeDeep(acc, options) : acc, {});
-	const override = mergeDeep(mergeDeep(output.override, overrideTag), overrideOperation);
+	let overrideTag = {};
+	for (const [tag, options] of Object.entries(output.override.tags)) if (tags.includes(tag) && options) overrideTag = mergeDeep(overrideTag, options);
+	const override = mergeDeep(mergeDeep(output.override, overrideTag), overrideOperation ?? {});
+	const originalContentTypeFilter = override.contentType;
+	const requestBodyContentTypeFilter = contentType ? { include: [contentType] } : override.contentType;
 	const overrideOperationName = overrideOperation?.operationName ?? output.override.operationName;
-	const operationName = overrideOperationName ? overrideOperationName(operation, route, verb) : sanitize(camel(operationId), { es5keyword: true });
+	let operationName = overrideOperationName ? overrideOperationName(operation, route, verb) : sanitize(camel(operationId), { es5keyword: true });
+	if (contentType) operationName = operationName + "With" + getContentTypeSuffix(contentType);
 	const response = getResponse({
-		responses,
+		responses: responses ?? {},
 		operationName,
 		context,
-		contentType: override.contentType
+		contentType: originalContentTypeFilter
 	});
-	const body = getBody({
+	const body = requestBody ? getBody({
 		requestBody,
 		operationName,
 		context,
-		contentType: override.contentType
-	});
+		contentType: requestBodyContentTypeFilter
+	}) : {
+		originalSchema: {},
+		definition: "",
+		implementation: "",
+		imports: [],
+		schemas: [],
+		formData: "",
+		formUrlEncoded: "",
+		contentType: "",
+		isOptional: false
+	};
 	const parameters = getParameters({
 		parameters: [...verbParameters, ...operationParameters ?? []],
 		context
@@ -3442,7 +3797,7 @@ async function generateVerbOptions({ verb, output, operation, route, pathRoute,
 		tags,
 		route,
 		pathRoute,
-		summary: operation.summary,
+		summary,
 		operationId,
 		operationName,
 		response,
@@ -3467,23 +3822,39 @@ async function generateVerbOptions({ verb, output, operation, route, pathRoute,
 function generateVerbsOptions({ verbs, input, output, route, pathRoute, context }) {
 	return asyncReduce(_filteredVerbs(verbs, input.filters), async (acc, [verb, operation]) => {
 		if (isVerb(verb)) {
-			const verbOptions = await generateVerbOptions({
-				verb,
-				output,
-				verbParameters: verbs.parameters,
-				route,
-				pathRoute,
-				operation,
-				context
-			});
-			acc.push(verbOptions);
+			const contentTypes = getRequestBodyContentTypes(operation.requestBody, context);
+			if (contentTypes.length > 1) for (const contentType of contentTypes) {
+				const verbOptions = await generateVerbOptions({
+					verb,
+					output,
+					verbParameters: verbs.parameters,
+					route,
+					pathRoute,
+					operation,
+					context,
+					contentType
+				});
+				acc.push(verbOptions);
+			}
+			else {
+				const verbOptions = await generateVerbOptions({
+					verb,
+					output,
+					verbParameters: verbs.parameters,
+					route,
+					pathRoute,
+					operation,
+					context
+				});
+				acc.push(verbOptions);
+			}
 		}
 		return acc;
 	}, []);
 }
 function _filteredVerbs(verbs, filters) {
 	if (filters?.tags === void 0) return Object.entries(verbs);
-	const filterTags = filters.tags || [];
+	const filterTags = filters.tags;
 	const filterMode = filters.mode ?? "include";
 	return Object.entries(verbs).filter(([, operation]) => {
 		const isMatch = (operation.tags ?? []).some((tag) => filterTags.some((filterTag) => filterTag instanceof RegExp ? filterTag.test(tag) : filterTag === tag));
@@ -3529,17 +3900,25 @@ function splitSchemasByType(schemas) {
 	};
 }
 /**
+* Get the import extension from a file extension.
+* Removes `.ts` suffix since TypeScript doesn't need it in imports.
+*/
+function getImportExtension(fileExtension) {
+	return fileExtension.replace(/\.ts$/, "") || "";
+}
+/**
 * Fix cross-directory imports when schemas reference other schemas in a different directory.
 * Updates import paths to use correct relative paths between directories.
 */
-function fixSchemaImports(schemas, targetSchemaNames, fromPath, toPath, namingConvention) {
+function fixSchemaImports(schemas, targetSchemaNames, fromPath, toPath, namingConvention, fileExtension) {
 	const relativePath = relativeSafe(fromPath, toPath);
+	const importExtension = getImportExtension(fileExtension);
 	for (const schema of schemas) schema.imports = schema.imports.map((imp) => {
 		if (targetSchemaNames.has(imp.name)) {
 			const fileName = conventionName(imp.name, namingConvention);
 			return {
 				...imp,
-				importPath: joinSafe(relativePath, fileName)
+				importPath: joinSafe(relativePath, fileName) + importExtension
 			};
 		}
 		return imp;
@@ -3548,14 +3927,14 @@ function fixSchemaImports(schemas, targetSchemaNames, fromPath, toPath, namingCo
 /**
 * Fix imports in operation schemas that reference regular schemas.
 */
-function fixCrossDirectoryImports(operationSchemas, regularSchemaNames, schemaPath, operationSchemaPath, namingConvention) {
-	fixSchemaImports(operationSchemas, regularSchemaNames, operationSchemaPath, schemaPath, namingConvention);
+function fixCrossDirectoryImports(operationSchemas, regularSchemaNames, schemaPath, operationSchemaPath, namingConvention, fileExtension) {
+	fixSchemaImports(operationSchemas, regularSchemaNames, operationSchemaPath, schemaPath, namingConvention, fileExtension);
 }
 /**
 * Fix imports in regular schemas that reference operation schemas.
 */
-function fixRegularSchemaImports(regularSchemas, operationSchemaNames, schemaPath, operationSchemaPath, namingConvention) {
-	fixSchemaImports(regularSchemas, operationSchemaNames, schemaPath, operationSchemaPath, namingConvention);
+function fixRegularSchemaImports(regularSchemas, operationSchemaNames, schemaPath, operationSchemaPath, namingConvention, fileExtension) {
+	fixSchemaImports(regularSchemas, operationSchemaNames, schemaPath, operationSchemaPath, namingConvention, fileExtension);
 }
 function getSchemaKey(schemaPath, schemaName, namingConvention, fileExtension) {
 	return getPath(schemaPath, conventionName(schemaName, namingConvention), fileExtension).toLowerCase().replaceAll("\\", "/");
@@ -3608,7 +3987,7 @@ function removeFileExtension(path$2, fileExtension) {
 function getSchema({ schema: { imports, model }, target, header, namingConvention = NamingConvention.CAMEL_CASE }) {
 	let file = header;
 	file += generateImports({
-		imports: imports.filter((imp) => !model.includes(`type ${imp.alias || imp.name} =`) && !model.includes(`interface ${imp.alias || imp.name} {`)),
+		imports: imports.filter((imp) => !model.includes(`type ${imp.alias ?? imp.name} =`) && !model.includes(`interface ${imp.alias ?? imp.name} {`)),
 		target,
 		namingConvention
 	});
@@ -3637,7 +4016,7 @@ async function writeSchema({ path: path$2, schema, target, namingConvention, fil
 			namingConvention
 		}));
 	} catch (error) {
-		throw new Error(`Oups... 🍻. An Error occurred while writing schema ${name} => ${error}`);
+		throw new Error(`Oups... 🍻. An Error occurred while writing schema ${name} => ${String(error)}`);
 	}
 }
 async function writeSchemas({ schemaPath, schemas, target, namingConvention, fileExtension, header, indexFiles }) {
@@ -3672,14 +4051,14 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		try {
 			const currentExports = [...conventionNamesSet].map((schemaName) => `export * from './${schemaName}${ext}';`).toSorted((a, b) => a.localeCompare(b));
 			const existingExports = (await fs$1.readFile(schemaFilePath, "utf8")).match(/export\s+\*\s+from\s+['"][^'"]+['"]/g)?.map((statement) => {
-				const match = statement.match(/export\s+\*\s+from\s+['"]([^'"]+)['"]/);
-				if (!match) return void 0;
+				const match = /export\s+\*\s+from\s+['"]([^'"]+)['"]/.exec(statement);
+				if (!match) return;
 				return `export * from '${match[1]}';`;
-			}).filter((statement) => Boolean(statement)) ?? [];
+			}).filter(Boolean) ?? [];
 			const fileContent = `${header}\n${[...new Set([...existingExports, ...currentExports])].toSorted((a, b) => a.localeCompare(b)).join("\n")}`;
 			await fs$1.writeFile(schemaFilePath, fileContent, { encoding: "utf8" });
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while writing schema index file ${schemaFilePath} => ${error}`);
+			throw new Error(`Oups... 🍻. An Error occurred while writing schema index file ${schemaFilePath} => ${String(error)}`);
 		}
 	}
 }
@@ -3688,58 +4067,76 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 //#region src/writers/generate-imports-for-builder.ts
 function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 	const isZodSchemaOutput = isObject(output.schemas) && output.schemas.type === "zod";
-	if (!output.indexFiles) return uniqueBy(imports, (x) => x.name).map((i) => {
-		const name = conventionName(i.schemaName || i.name, output.namingConvention);
+	let schemaImports = [];
+	if (output.indexFiles) schemaImports = isZodSchemaOutput ? [{
+		exports: imports.filter((i) => !i.importPath),
+		dependency: joinSafe(relativeSchemasPath, "index.zod")
+	}] : [{
+		exports: imports.filter((i) => !i.importPath),
+		dependency: relativeSchemasPath
+	}];
+	else schemaImports = uniqueBy(imports.filter((i) => !i.importPath), (x) => x.name).map((i) => {
+		const name = conventionName(i.schemaName ?? i.name, output.namingConvention);
 		const suffix = isZodSchemaOutput ? ".zod" : "";
-		const importExtension = output.fileExtension?.replace(/\.ts$/, "") || "";
+		const importExtension = output.fileExtension.replace(/\.ts$/, "") || "";
 		return {
-			exports: isZodSchemaOutput ? [{
-				...i,
-				values: true
-			}] : [i],
+			exports: [i],
 			dependency: joinSafe(relativeSchemasPath, `${name}${suffix}${importExtension}`)
 		};
 	});
-	else if (isZodSchemaOutput) return [{
-		exports: imports.map((i) => ({
-			...i,
-			values: true
-		})),
-		dependency: joinSafe(relativeSchemasPath, "index.zod")
-	}];
-	else return [{
-		exports: imports,
-		dependency: relativeSchemasPath
-	}];
+	const otherImports = uniqueBy(imports.filter((i) => !!i.importPath), (x) => x.name + (x.importPath ?? "")).map((i) => {
+		return {
+			exports: [i],
+			dependency: i.importPath
+		};
+	});
+	return [...schemaImports, ...otherImports];
 }
 
 //#endregion
 //#region src/writers/target.ts
 function generateTarget(builder, options) {
 	const operationNames = Object.values(builder.operations).map(({ operationName }) => operationName);
-	const isAngularClient = options?.client === OutputClient.ANGULAR;
+	const isAngularClient = options.client === OutputClient.ANGULAR;
 	const titles = builder.title({
 		outputClient: options.client,
 		title: pascal(builder.info.title),
 		customTitleFunc: options.override.title,
 		output: options
 	});
-	const target = Object.values(builder.operations).reduce((acc, operation, index, arr) => {
-		acc.imports.push(...operation.imports);
-		acc.importsMock.push(...operation.importsMock);
-		acc.implementation += operation.implementation + "\n";
-		acc.implementationMock.function += operation.implementationMock.function;
-		acc.implementationMock.handler += operation.implementationMock.handler;
-		const handlerNameSeparator = acc.implementationMock.handlerName.length > 0 ? ",\n  " : "  ";
-		acc.implementationMock.handlerName += handlerNameSeparator + operation.implementationMock.handlerName + "()";
-		if (operation.mutator) acc.mutators.push(operation.mutator);
-		if (operation.formData) acc.formData.push(operation.formData);
-		if (operation.formUrlEncoded) acc.formUrlEncoded.push(operation.formUrlEncoded);
-		if (operation.paramsSerializer) acc.paramsSerializer.push(operation.paramsSerializer);
-		if (operation.clientMutators) acc.clientMutators.push(...operation.clientMutators);
-		if (operation.fetchReviver) acc.fetchReviver.push(operation.fetchReviver);
-		if (index === arr.length - 1) {
-			const isMutator = acc.mutators.some((mutator) => isAngularClient ? mutator.hasThirdArg : mutator.hasSecondArg);
+	const target = {
+		imports: [],
+		implementation: "",
+		implementationMock: {
+			function: "",
+			handler: "",
+			handlerName: ""
+		},
+		importsMock: [],
+		mutators: [],
+		clientMutators: [],
+		formData: [],
+		formUrlEncoded: [],
+		paramsSerializer: [],
+		fetchReviver: []
+	};
+	const operations = Object.values(builder.operations);
+	for (const [index, operation] of operations.entries()) {
+		target.imports.push(...operation.imports);
+		target.importsMock.push(...operation.importsMock);
+		target.implementation += operation.implementation + "\n";
+		target.implementationMock.function += operation.implementationMock.function;
+		target.implementationMock.handler += operation.implementationMock.handler;
+		const handlerNameSeparator = target.implementationMock.handlerName.length > 0 ? ",\n  " : "  ";
+		target.implementationMock.handlerName += handlerNameSeparator + operation.implementationMock.handlerName + "()";
+		if (operation.mutator) target.mutators.push(operation.mutator);
+		if (operation.formData) target.formData.push(operation.formData);
+		if (operation.formUrlEncoded) target.formUrlEncoded.push(operation.formUrlEncoded);
+		if (operation.paramsSerializer) target.paramsSerializer.push(operation.paramsSerializer);
+		if (operation.clientMutators) target.clientMutators.push(...operation.clientMutators);
+		if (operation.fetchReviver) target.fetchReviver.push(operation.fetchReviver);
+		if (index === operations.length - 1) {
+			const isMutator = target.mutators.some((mutator) => isAngularClient ? mutator.hasThirdArg : mutator.hasSecondArg);
 			const hasAwaitedType = compareVersions(options.packageJson?.dependencies?.typescript ?? options.packageJson?.devDependencies?.typescript ?? "4.4.0", "4.5.0");
 			const header = builder.header({
 				outputClient: options.client,
@@ -3751,38 +4148,22 @@ function generateTarget(builder, options) {
 				titles,
 				output: options,
 				verbOptions: builder.verbOptions,
-				clientImplementation: acc.implementation
+				clientImplementation: target.implementation
 			});
-			acc.implementation = header.implementation + acc.implementation;
-			acc.implementationMock.handler = acc.implementationMock.handler + header.implementationMock + acc.implementationMock.handlerName;
+			target.implementation = header.implementation + target.implementation;
+			target.implementationMock.handler = target.implementationMock.handler + header.implementationMock + target.implementationMock.handlerName;
 			const footer = builder.footer({
-				outputClient: options?.client,
+				outputClient: options.client,
 				operationNames,
-				hasMutator: acc.mutators.length > 0,
+				hasMutator: target.mutators.length > 0,
 				hasAwaitedType,
 				titles,
 				output: options
 			});
-			acc.implementation += footer.implementation;
-			acc.implementationMock.handler += footer.implementationMock;
+			target.implementation += footer.implementation;
+			target.implementationMock.handler += footer.implementationMock;
 		}
-		return acc;
-	}, {
-		imports: [],
-		implementation: "",
-		implementationMock: {
-			function: "",
-			handler: "",
-			handlerName: ""
-		},
-		importsMock: [],
-		mutators: [],
-		clientMutators: [],
-		formData: [],
-		formUrlEncoded: [],
-		paramsSerializer: [],
-		fetchReviver: []
-	});
+	}
 	return {
 		...target,
 		implementationMock: target.implementationMock.function + target.implementationMock.handler
@@ -3838,7 +4219,7 @@ async function writeSingleMode({ builder, output, projectName, header, needSchem
 		});
 		const { imports, importsMock, implementation, implementationMock, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, fetchReviver } = generateTarget(builder, output);
 		let data = header;
-		const schemasPath = output.schemas ? relativeSafe(dirname$1, getFileInfo(typeof output.schemas === "string" ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
+		const schemasPath = output.schemas ? relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : void 0;
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 		const importsForBuilder = schemasPath ? generateImportsForBuilder(output, imports.filter((imp) => !importsMock.some((impMock) => imp.name === impMock.name)), schemasPath) : [];
 		data += builder.imports({
@@ -3907,7 +4288,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, paramsSerializer, fetchReviver } = generateTarget(builder, output);
 		let implementationData = header;
 		let mockData = header;
-		const relativeSchemasPath = output.schemas ? relativeSafe(dirname$1, getFileInfo(typeof output.schemas === "string" ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
+		const relativeSchemasPath = output.schemas ? relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
 		const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
 		const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 		implementationData += builder.imports({
@@ -3967,7 +4348,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			...mockPath ? [mockPath] : []
 		];
 	} catch (error) {
-		throw new Error(`Oups... 🍻. An Error occurred while splitting => ${error}`);
+		throw new Error(`Oups... 🍻. An Error occurred while splitting => ${String(error)}`);
 	}
 }
 
@@ -3981,8 +4362,7 @@ function addDefaultTagIfEmpty(operation) {
 }
 function generateTargetTags(currentAcc, operation) {
 	const tag = kebab(operation.tags[0]);
-	const currentOperation = currentAcc[tag];
-	if (!currentOperation) {
+	if (!(tag in currentAcc)) {
 		currentAcc[tag] = {
 			imports: operation.imports,
 			importsMock: operation.importsMock,
@@ -4001,6 +4381,7 @@ function generateTargetTags(currentAcc, operation) {
 		};
 		return currentAcc;
 	}
+	const currentOperation = currentAcc[tag];
 	currentAcc[tag] = {
 		implementation: currentOperation.implementation + operation.implementation,
 		imports: [...currentOperation.imports, ...operation.imports],
@@ -4021,66 +4402,69 @@ function generateTargetTags(currentAcc, operation) {
 }
 function generateTargetForTags(builder, options) {
 	const isAngularClient = options.client === OutputClient.ANGULAR;
-	const allTargetTags = Object.values(builder.operations).map((operation) => addDefaultTagIfEmpty(operation)).reduce((acc, operation, index, arr) => {
-		const targetTags = generateTargetTags(acc, operation);
-		if (index === arr.length - 1) return Object.entries(targetTags).reduce((acc$1, [tag, target]) => {
-			const isMutator = !!target.mutators?.some((mutator) => isAngularClient ? mutator.hasThirdArg : mutator.hasSecondArg);
-			const operationNames = Object.values(builder.operations).filter(({ tags }) => tags.map((tag$1) => kebab(tag$1)).indexOf(kebab(tag)) === 0).map(({ operationName }) => operationName);
-			const hasAwaitedType = compareVersions(options.packageJson?.dependencies?.typescript ?? options.packageJson?.devDependencies?.typescript ?? "4.4.0", "4.5.0");
-			const titles = builder.title({
-				outputClient: options.client,
-				title: pascal(tag),
-				customTitleFunc: options.override.title,
-				output: options
-			});
-			const footer = builder.footer({
-				outputClient: options?.client,
-				operationNames,
-				hasMutator: !!target.mutators?.length,
-				hasAwaitedType,
-				titles,
-				output: options
-			});
-			const header = builder.header({
-				outputClient: options.client,
-				isRequestOptions: options.override.requestOptions !== false,
-				isMutator,
-				isGlobalMutator: !!options.override.mutator,
-				provideIn: options.override.angular.provideIn,
-				hasAwaitedType,
-				titles,
-				output: options,
-				verbOptions: builder.verbOptions,
-				tag,
-				clientImplementation: target.implementation
-			});
-			acc$1[tag] = {
-				implementation: header.implementation + target.implementation + footer.implementation,
-				implementationMock: {
-					function: target.implementationMock.function,
-					handler: target.implementationMock.handler + header.implementationMock + target.implementationMock.handlerName + footer.implementationMock,
-					handlerName: target.implementationMock.handlerName
-				},
-				imports: target.imports,
-				importsMock: target.importsMock,
-				mutators: target.mutators,
-				clientMutators: target.clientMutators,
-				formData: target.formData,
-				formUrlEncoded: target.formUrlEncoded,
-				paramsSerializer: target.paramsSerializer,
-				fetchReviver: target.fetchReviver
-			};
-			return acc$1;
-		}, {});
-		return targetTags;
-	}, {});
-	return Object.entries(allTargetTags).reduce((acc, [tag, target]) => {
-		acc[tag] = {
-			...target,
-			implementationMock: target.implementationMock.function + target.implementationMock.handler
-		};
-		return acc;
-	}, {});
+	const operations = Object.values(builder.operations).map((operation) => addDefaultTagIfEmpty(operation));
+	let allTargetTags = {};
+	for (const [index, operation] of operations.entries()) {
+		allTargetTags = generateTargetTags(allTargetTags, operation);
+		if (index === operations.length - 1) {
+			const transformed = {};
+			for (const [tag, target] of Object.entries(allTargetTags)) {
+				const isMutator = !!target.mutators?.some((mutator) => isAngularClient ? mutator.hasThirdArg : mutator.hasSecondArg);
+				const operationNames = Object.values(builder.operations).filter(({ tags }) => tags.map((tag$1) => kebab(tag$1)).indexOf(kebab(tag)) === 0).map(({ operationName }) => operationName);
+				const hasAwaitedType = compareVersions(options.packageJson?.dependencies?.typescript ?? options.packageJson?.devDependencies?.typescript ?? "4.4.0", "4.5.0");
+				const titles = builder.title({
+					outputClient: options.client,
+					title: pascal(tag),
+					customTitleFunc: options.override.title,
+					output: options
+				});
+				const footer = builder.footer({
+					outputClient: options.client,
+					operationNames,
+					hasMutator: !!target.mutators?.length,
+					hasAwaitedType,
+					titles,
+					output: options
+				});
+				const header = builder.header({
+					outputClient: options.client,
+					isRequestOptions: options.override.requestOptions !== false,
+					isMutator,
+					isGlobalMutator: !!options.override.mutator,
+					provideIn: options.override.angular.provideIn,
+					hasAwaitedType,
+					titles,
+					output: options,
+					verbOptions: builder.verbOptions,
+					tag,
+					clientImplementation: target.implementation
+				});
+				transformed[tag] = {
+					implementation: header.implementation + target.implementation + footer.implementation,
+					implementationMock: {
+						function: target.implementationMock.function,
+						handler: target.implementationMock.handler + header.implementationMock + target.implementationMock.handlerName + footer.implementationMock,
+						handlerName: target.implementationMock.handlerName
+					},
+					imports: target.imports,
+					importsMock: target.importsMock,
+					mutators: target.mutators,
+					clientMutators: target.clientMutators,
+					formData: target.formData,
+					formUrlEncoded: target.formUrlEncoded,
+					paramsSerializer: target.paramsSerializer,
+					fetchReviver: target.fetchReviver
+				};
+			}
+			allTargetTags = transformed;
+		}
+	}
+	const result = {};
+	for (const [tag, target] of Object.entries(allTargetTags)) result[tag] = {
+		...target,
+		implementationMock: target.implementationMock.function + target.implementationMock.handler
+	};
+	return result;
 }
 
 //#endregion
@@ -4092,14 +4476,15 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 	});
 	const target = generateTargetForTags(builder, output);
 	const isAllowSyntheticDefaultImports = isSyntheticDefaultImportsAllow(output.tsconfig);
-	const indexFilePath = output.mock && !isFunction(output.mock) && output.mock.indexMockFiles ? join(dirname$1, "index." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
+	const mockOption = output.mock && !isFunction(output.mock) ? output.mock : void 0;
+	const indexFilePath = mockOption?.indexMockFiles ? join(dirname$1, "index." + getMockFileExtensionByTypeName(mockOption) + extension) : void 0;
 	if (indexFilePath) await fs$1.outputFile(indexFilePath, "");
 	return (await Promise.all(Object.entries(target).map(async ([tag, target$1]) => {
 		try {
 			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, fetchReviver, formUrlEncoded, paramsSerializer } = target$1;
 			let implementationData = header;
 			let mockData = header;
-			const relativeSchemasPath = output.schemas ? "../" + relativeSafe(dirname$1, getFileInfo(typeof output.schemas === "string" ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas";
+			const relativeSchemasPath = output.schemas ? "../" + relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas";
 			const importsForBuilder = generateImportsForBuilder(output, imports, relativeSchemasPath);
 			implementationData += builder.imports({
 				client: output.client,
@@ -4169,9 +4554,9 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			const mockPath = output.mock ? join(dirname$1, tag, tag + "." + getMockFileExtensionByTypeName(output.mock) + extension) : void 0;
 			if (mockPath) {
 				await fs$1.outputFile(mockPath, mockData);
-				if (indexFilePath) {
-					const localMockPath = joinSafe("./", tag, tag + "." + getMockFileExtensionByTypeName(output.mock));
-					fs$1.appendFile(indexFilePath, `export { get${pascal(tag)}Mock } from '${localMockPath}'\n`);
+				if (indexFilePath && mockOption) {
+					const localMockPath = joinSafe("./", tag, tag + "." + getMockFileExtensionByTypeName(mockOption));
+					await fs$1.appendFile(indexFilePath, `export { get${pascal(tag)}Mock } from '${localMockPath}'\n`);
 				}
 			}
 			return [
@@ -4180,7 +4565,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				...mockPath ? [mockPath] : []
 			];
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while splitting tag ${tag} => ${error}`);
+			throw new Error(`Oups... 🍻. An Error occurred while splitting tag ${tag} => ${String(error)}`);
 		}
 	}))).flat();
 }
@@ -4198,7 +4583,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 		try {
 			const { imports, implementation, implementationMock, importsMock, mutators, clientMutators, formData, formUrlEncoded, fetchReviver, paramsSerializer } = target$1;
 			let data = header;
-			const schemasPathRelative = output.schemas ? relativeSafe(dirname$1, getFileInfo(typeof output.schemas === "string" ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
+			const schemasPathRelative = output.schemas ? relativeSafe(dirname$1, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "./" + filename + ".schemas";
 			const importsForBuilder = generateImportsForBuilder(output, imports.filter((imp) => !importsMock.some((impMock) => imp.name === impMock.name)), schemasPathRelative);
 			data += builder.imports({
 				client: output.client,
@@ -4256,11 +4641,11 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 			await fs$1.outputFile(implementationPath, data);
 			return [implementationPath, ...schemasPath ? [schemasPath] : []];
 		} catch (error) {
-			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${error}`);
+			throw new Error(`Oups... 🍻. An Error occurred while writing tag ${tag} => ${String(error)}`);
 		}
 	}))).flat();
 }
 
 //#endregion
-export { BODY_TYPE_NAME, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getArray, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getTypedResponse, isBinaryContentType, isBoolean, isDirectory, isFunction, isModule, isNull, isNumber, isNumeric, isObject, isReference, isSchema, isString, isSyntheticDefaultImportsAllow, isUndefined, isUrl, isVerb, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
+export { BODY_TYPE_NAME, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, _filteredVerbs, addDependency, asyncReduce, camel, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, filterByContentType, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getAngularFilteredParamsCallExpression, getAngularFilteredParamsExpression, getAngularFilteredParamsHelperBody, getArray, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getRequestBodyContentTypes, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSuccessResponseType, getTypedResponse, isBinaryContentType, isBoolean, isDirectory, isFunction, isModule, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resolveDiscriminators, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
 //# sourceMappingURL=index.mjs.map