@orval/core 8.1.0 → 8.3.0

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import { t as __export } from "./chunk-C6wwvPpM.mjs";
-import { entries, groupBy, isArray, isEmptyish, prop, unique, uniqueBy, uniqueWith } from "remeda";
+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 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 +108,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 +130,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 +161,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 +202,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 +212,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 +227,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 +251,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;
@@ -396,6 +277,87 @@ function compareVersions(firstVersion, secondVersions, operator = ">=") {
 	return compare(firstVersion.replace(/(\s(.*))/, ""), secondVersions, operator);
 }
 
+//#endregion
+//#region src/utils/content-type.ts
+/**
+* Determine if a content type is binary (vs text-based).
+*/
+function isBinaryContentType(contentType) {
+	if (contentType === "application/octet-stream") return true;
+	if (contentType.startsWith("image/")) return true;
+	if (contentType.startsWith("audio/")) return true;
+	if (contentType.startsWith("video/")) return true;
+	if (contentType.startsWith("font/")) return true;
+	if (contentType.startsWith("text/")) return false;
+	if ([
+		"+json",
+		"-json",
+		"+xml",
+		"-xml",
+		"+yaml",
+		"-yaml",
+		"+rss",
+		"-rss",
+		"+csv",
+		"-csv"
+	].some((suffix) => contentType.includes(suffix))) return false;
+	return !new Set([
+		"application/json",
+		"application/xml",
+		"application/yaml",
+		"application/x-www-form-urlencoded",
+		"application/javascript",
+		"application/ecmascript",
+		"application/graphql"
+	]).has(contentType);
+}
+/**
+* Determine if a form-data field should be treated as a file (binary or text).
+*
+* Precedence (per OAS 3.1): encoding.contentType > schema.contentMediaType
+*
+* Returns:
+* - 'binary': binary file (Blob)
+* - 'text': text file (Blob | string)
+* - undefined: not a file, use standard string resolution
+*/
+function getFormDataFieldFileType(resolvedSchema, partContentType) {
+	if (resolvedSchema.type !== "string") return;
+	if (resolvedSchema.contentEncoding) return;
+	const contentMediaType = resolvedSchema.contentMediaType;
+	const effectiveContentType = partContentType ?? contentMediaType;
+	if (effectiveContentType) return isBinaryContentType(effectiveContentType) ? "binary" : "text";
+}
+/**
+* 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
 //#region src/utils/debug.ts
 const filter = process.env.ORVAL_DEBUG_FILTER;
@@ -403,7 +365,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;
@@ -417,13 +379,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,
@@ -438,7 +400,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;
@@ -505,10 +467,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) {
@@ -557,7 +558,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);
@@ -644,16 +645,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
@@ -663,9 +664,65 @@ 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/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;
@@ -689,17 +746,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
@@ -723,7 +783,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);
@@ -748,7 +808,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",
@@ -772,7 +836,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.
@@ -797,11 +861,13 @@ function escape(str, char = "'") {
 * @param input String to escape
 */
 function jsStringEscape(input) {
-	return input.replaceAll(/["'\\\n\r\u2028\u2029]/g, (character) => {
+	return input.replaceAll(/["'\\\n\r\u2028\u2029/*]/g, (character) => {
 		switch (character) {
 			case "\"":
 			case "'":
-			case "\\": return "\\" + character;
+			case "\\":
+			case "/":
+			case "*": return "\\" + character;
 			case "\n": return String.raw`\n`;
 			case "\r": return String.raw`\r`;
 			case "\u2028": return String.raw`\u2028`;
@@ -813,12 +879,35 @@ function jsStringEscape(input) {
 /**
 * Deduplicates a TypeScript union type string.
 * Handles types like "A | B | B" → "A | B" and "null | null" → "null".
+* Only splits on top-level | (not inside {} () [] <> or string literals).
 */
 function dedupeUnionType(unionType) {
-	const parts = unionType.split("|").map((part) => part.trim());
-	return [...new Set(parts)].join(" | ");
-}
-
+	const parts = [];
+	let current = "";
+	let depth = 0;
+	let quote = "";
+	let escaped = false;
+	for (const c of unionType) {
+		if (!escaped && (c === "'" || c === "\"")) {
+			if (!quote) quote = c;
+			else if (quote === c) quote = "";
+		}
+		if (!quote) {
+			if ("{([<".includes(c)) depth++;
+			if ("})]>".includes(c)) depth--;
+			if (c === "|" && depth === 0) {
+				parts.push(current.trim());
+				current = "";
+				continue;
+			}
+		}
+		current += c;
+		escaped = !!quote && !escaped && c === "\\";
+	}
+	if (current.trim()) parts.push(current.trim());
+	return [...new Set(parts)].join(" | ");
+}
+
 //#endregion
 //#region src/utils/tsconfig.ts
 function isSyntheticDefaultImportsAllow(config) {
@@ -841,8 +930,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}]`;
@@ -858,11 +946,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, {
@@ -872,17 +965,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, {
@@ -892,8 +991,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)}`;
@@ -905,9 +1005,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;
@@ -1053,13 +1153,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
-	};
+	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
@@ -1073,19 +1183,16 @@ 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
 //#region src/resolvers/value.ts
-function resolveValue({ schema, name, context }) {
+function resolveValue({ schema, name, context, formDataContext }) {
 	if (isReference(schema)) {
 		const { schema: schemaObject, imports } = resolveRef(schema, context);
 		const resolvedImport = imports[0];
@@ -1099,7 +1206,8 @@ function resolveValue({ schema, name, context }) {
 				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: [{
@@ -1119,7 +1227,8 @@ function resolveValue({ schema, name, context }) {
 		...getScalar({
 			item: schema,
 			name,
-			context
+			context,
+			formDataContext
 		}),
 		originalSchema: schema,
 		isRef: false
@@ -1135,7 +1244,7 @@ function resolveValue({ schema, name, context }) {
 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);
@@ -1161,11 +1270,12 @@ function createTypeAliasIfNeeded({ resolvedValue, propName, context }) {
 		dependencies: resolvedValue.dependencies
 	};
 }
-function resolveObjectOriginal({ schema, propName, combined = false, context }) {
+function resolveObjectOriginal({ schema, propName, combined = false, context, formDataContext }) {
 	const resolvedValue = resolveValue({
 		schema,
 		name: propName,
-		context
+		context,
+		formDataContext
 	});
 	const aliased = createTypeAliasIfNeeded({
 		resolvedValue,
@@ -1177,8 +1287,8 @@ function resolveObjectOriginal({ schema, propName, combined = false, context })
 		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 }],
@@ -1199,19 +1309,21 @@ function resolveObjectOriginal({ schema, propName, combined = false, context })
 	return resolvedValue;
 }
 const resolveObjectCacheMap = /* @__PURE__ */ new Map();
-function resolveObject({ schema, propName, combined = false, context }) {
+function resolveObject({ schema, propName, combined = false, context, formDataContext }) {
 	const hashKey = JSON.stringify({
 		schema,
 		propName,
 		combined,
-		projectName: context.projectName ?? context.output.target
+		projectName: context.projectName ?? context.output.target,
+		formDataContext
 	});
 	if (resolveObjectCacheMap.has(hashKey)) return resolveObjectCacheMap.get(hashKey);
 	const result = resolveObjectOriginal({
 		schema,
 		propName,
 		combined,
-		context
+		context,
+		formDataContext
 	});
 	resolveObjectCacheMap.set(hashKey, result);
 	return result;
@@ -1224,18 +1336,22 @@ function resolveObject({ schema, propName, combined = false, context }) {
 *
 * @param item item with type === "array"
 */
-function getArray({ schema, name, context }) {
-	const schema31 = schema;
-	if (schema31.prefixItems) {
-		const resolvedObjects = schema31.prefixItems.map((item, index) => resolveObject({
+function getArray({ schema, name, context, formDataContext }) {
+	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 (schemaPrefixItems) {
+		const resolvedObjects = schemaPrefixItems.map((item, index) => resolveObject({
 			schema: item,
-			propName: name + context.output.override.components.schemas.itemSuffix + index,
+			propName: name ? name + itemSuffix + String(index) : void 0,
 			context
 		}));
-		if (schema31.items) {
+		if (schemaItems) {
 			const additional = resolveObject({
-				schema: schema31.items,
-				propName: name + context.output.override.components.schemas.itemSuffix + "Additional",
+				schema: schemaItems,
+				propName: name ? name + itemSuffix + "Additional" : void 0,
 				context
 			});
 			resolvedObjects.push({
@@ -1252,15 +1368,16 @@ function getArray({ schema, name, context }) {
 			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,
-			propName: name + context.output.override.components.schemas.itemSuffix,
-			context
+			schema: schemaItems,
+			propName: name ? name + itemSuffix : void 0,
+			context,
+			formDataContext
 		});
 		return {
 			value: `${schema.readOnly === true && !context.output.override.suppressReadonlyModifier ? "readonly " : ""}${resolvedObject.value.includes("|") ? `(${resolvedObject.value})[]` : `${resolvedObject.value}[]`}`,
@@ -1271,8 +1388,8 @@ function getArray({ schema, name, context }) {
 			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[]",
@@ -1288,321 +1405,452 @@ function getArray({ schema, name, context }) {
 }
 
 //#endregion
-//#region src/getters/imports.ts
-function getAliasedImports({ name, resolvedValue, context }) {
-	return context.output.schemas && resolvedValue.isRef ? resolvedValue.imports.map((imp) => {
-		if (!needCreateImportAlias({
-			name,
-			imp
-		})) return imp;
-		return {
-			...imp,
-			alias: `__${imp.name}`
-		};
-	}) : resolvedValue.imports;
-}
-function needCreateImportAlias({ imp, name }) {
-	return !imp.alias && imp.name === name;
-}
-function getImportAliasForRefOrValue({ context, imports, resolvedValue }) {
-	if (!context.output.schemas || !resolvedValue.isRef) return resolvedValue.value;
-	return imports.find((imp) => imp.name === resolvedValue.value)?.alias ?? resolvedValue.value;
+//#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 }) {
+	if (!mediaType.schema) return;
+	const formDataContext = isFormData ? {
+		atPart: false,
+		encoding: mediaType.encoding ?? {}
+	} : void 0;
+	const resolvedObject = resolveObject({
+		schema: mediaType.schema,
+		propName,
+		context,
+		formDataContext
+	});
+	if (!isFormData && isBinaryContentType(contentType)) return {
+		...resolvedObject,
+		value: "Blob"
+	};
+	return resolvedObject;
 }
-
-//#endregion
-//#region src/getters/scalar.ts
-/**
-* Return the typescript equivalent of open-api data type
-*
-* @param item
-* @ref https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#data-types
-*/
-function getScalar({ item, name, context }) {
-	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;
-	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");
-		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 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;
-			return {
-				value,
-				isEnum,
-				type: "number",
+function getResReqTypes(responsesOrRequests, name, context, defaultType = "unknown", uniqueKey = (item) => item.value) {
+	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 isFormData = formDataContentTypes.has(contentType);
+			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
+			if (!isFormData && !isFormUrlEncoded || !mediaType.schema) return [{
+				value: name$1,
+				imports: [{
+					name: name$1,
+					schemaName
+				}],
 				schemas: [],
-				imports: [],
-				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
-				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
-			};
-		}
-		case "boolean": {
-			let value = "boolean" + nullable;
-			const itemWithConst = item;
-			if (itemWithConst.const !== void 0) value = itemWithConst.const;
-			return {
-				value,
-				type: "boolean",
+				type: "unknown",
 				isEnum: false,
-				schemas: [],
-				imports: [],
-				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
-				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
-			};
-		}
-		case "array": {
-			const { value, ...rest } = getArray({
-				schema: item,
-				name,
+				isRef: true,
+				hasReadonlyProps: false,
+				originalSchema: mediaType.schema,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context),
+				key,
+				contentType
+			}];
+			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
+				name: name$1,
+				schemaObject: mediaType.schema,
+				context,
+				isRequestBodyOptional: "required" in bodySchema && bodySchema.required === false,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
+				name: name$1,
+				schemaObject: mediaType.schema,
+				context,
+				isRequestBodyOptional: "required" in bodySchema && bodySchema.required === false,
+				isUrlEncoded: true,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const additionalImports = getFormDataAdditionalImports({
+				schemaObject: mediaType.schema,
 				context
 			});
-			return {
-				value: value + nullable,
-				...rest,
-				dependencies: rest.dependencies ?? []
-			};
-		}
-		case "string": {
-			let value = "string";
-			let isEnum = false;
-			if (enumItems) {
-				value = enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : `${enumItem}`).filter(Boolean).join(` | `);
-				isEnum = true;
-			}
-			if (item.format === "binary") value = "Blob";
-			if (context.output.override.useDates && (item.format === "date" || item.format === "date-time")) value = "Date";
-			value += nullable;
-			const itemWithConst = item;
-			if (itemWithConst.const) value = `'${itemWithConst.const}'`;
-			return {
-				value,
-				isEnum,
-				type: "string",
-				imports: [],
+			return [{
+				value: name$1,
+				imports: [{
+					name: name$1,
+					schemaName
+				}, ...additionalImports],
 				schemas: [],
-				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
-				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
-			};
+				type: "unknown",
+				isEnum: false,
+				hasReadonlyProps: false,
+				formData,
+				formUrlEncoded,
+				isRef: true,
+				originalSchema: mediaType.schema,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context),
+				key,
+				contentType
+			}];
 		}
-		case "null": return {
-			value: "null",
-			isEnum: false,
-			type: "null",
-			imports: [],
-			schemas: [],
-			isRef: false,
-			hasReadonlyProps: item.readOnly || false,
-			dependencies: []
-		};
-		case "object":
-		default: {
-			if (isArray(itemType)) return combineSchemas({
-				schema: { anyOf: itemType.map((type) => ({
-					...item,
-					type
-				})) },
-				name,
-				separator: "anyOf",
+		if (res.content) return Object.entries(res.content).map(([contentType, mediaType], index, arr) => {
+			let propName = key ? pascal(name) + pascal(key) : void 0;
+			if (propName && arr.length > 1) propName = propName + pascal(getNumberWord(index + 1));
+			let effectivePropName = propName;
+			if (mediaType.schema && isReference(mediaType.schema)) {
+				const { imports } = resolveRef(mediaType.schema, context);
+				if (imports[0]?.name) effectivePropName = imports[0].name;
+			}
+			const isFormData = formDataContentTypes.has(contentType);
+			const resolvedValue = getResReqContentTypes({
+				mediaType,
+				propName: effectivePropName,
 				context,
-				nullable
+				isFormData,
+				contentType
 			});
-			if (enumItems) return {
-				value: enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : `${enumItem}`).filter(Boolean).join(` | `) + nullable,
-				isEnum: true,
-				type: "string",
-				imports: [],
-				schemas: [],
-				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
-				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
+			if (!resolvedValue) {
+				if (isBinaryContentType(contentType)) return {
+					value: "Blob",
+					imports: [],
+					schemas: [],
+					type: "Blob",
+					isEnum: false,
+					key,
+					isRef: false,
+					hasReadonlyProps: false,
+					contentType
+				};
+				return;
+			}
+			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
+			if (!isFormData && !isFormUrlEncoded || !effectivePropName || !mediaType.schema) return {
+				...resolvedValue,
+				imports: resolvedValue.imports,
+				contentType,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context)
 			};
-			const { value, ...rest } = getObject({
-				item,
-				name,
-				context,
-				nullable
+			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
+				name: effectivePropName,
+				schemaObject: mediaType.schema,
+				context,
+				isRequestBodyOptional: "required" in res && res.required === false,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
+				name: effectivePropName,
+				schemaObject: mediaType.schema,
+				context,
+				isUrlEncoded: true,
+				isRequestBodyOptional: "required" in res && res.required === false,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const additionalImports = getFormDataAdditionalImports({
+				schemaObject: mediaType.schema,
+				context
 			});
 			return {
-				value,
-				...rest
+				...resolvedValue,
+				imports: [...resolvedValue.imports, ...additionalImports],
+				formData,
+				formUrlEncoded,
+				contentType,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context)
 			};
+		}).filter(Boolean).map((x) => ({
+			...x,
+			key
+		}));
+		const swaggerSchema = "schema" in res ? res.schema : void 0;
+		if (swaggerSchema) return [{
+			...resolveObject({
+				schema: swaggerSchema,
+				propName: key ? pascal(name) + pascal(key) : void 0,
+				context
+			}),
+			contentType: "application/json",
+			key
+		}];
+		return [{
+			value: defaultType,
+			imports: [],
+			schemas: [],
+			type: defaultType,
+			isEnum: false,
+			key,
+			isRef: false,
+			hasReadonlyProps: false,
+			contentType: "application/json"
+		}];
+	}).flat(), uniqueKey);
+}
+/**
+* Determine the response type category for a given content type.
+* Used to set the correct responseType option in HTTP clients.
+*
+* @param contentType - The MIME content type (e.g., 'application/json', 'text/plain')
+* @returns The response type category to use for parsing
+*/
+function getResponseTypeCategory(contentType) {
+	if (isBinaryContentType(contentType)) return "blob";
+	if (contentType === "application/json" || contentType.includes("+json") || contentType.includes("-json")) return "json";
+	return "text";
+}
+/**
+* Get the default content type from a list of content types.
+* Priority: application/json > any JSON-like type > first in list
+*
+* @param contentTypes - Array of content types from OpenAPI spec
+* @returns The default content type to use
+*/
+function getDefaultContentType(contentTypes) {
+	if (contentTypes.length === 0) return "application/json";
+	if (contentTypes.includes("application/json")) return "application/json";
+	const jsonType = contentTypes.find((ct) => ct.includes("+json") || ct.includes("-json"));
+	if (jsonType) return jsonType;
+	return contentTypes[0];
+}
+function getFormDataAdditionalImports({ schemaObject, context }) {
+	const { schema } = resolveRef(schemaObject, context);
+	if (schema.type !== "object") return [];
+	const combinedSchemas = getSchemaOneOf(schema) ?? getSchemaAnyOf(schema);
+	if (!combinedSchemas) return [];
+	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);
+	const propName = camel(!isRef && isReference(schemaObject) ? imports[0].name : name);
+	const additionalImports = [];
+	const variableName = isUrlEncoded ? "formUrlEncoded" : "formData";
+	let form = isUrlEncoded ? `const ${variableName} = new URLSearchParams();\n` : `const ${variableName} = new FormData();\n`;
+	const combinedSchemas = getSchemaCombined(schema);
+	if (schema.type === "object" || schema.type === void 0 && combinedSchemas) {
+		if (combinedSchemas) {
+			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]) {
+					additionalImports.push(imports$1[0]);
+					newPropName = `${propName}${pascal(imports$1[0].name)}`;
+					newPropDefinition = `const ${newPropName} = (${propName} as ${imports$1[0].name}${isRequestBodyOptional ? " | undefined" : ""});\n`;
+				}
+				return newPropDefinition + resolveSchemaPropertiesToFormData({
+					schema: combinedSchema,
+					variableName,
+					propName: newPropName,
+					context,
+					isRequestBodyOptional,
+					encoding
+				});
+			}).filter(Boolean).join("\n");
+			form += combinedSchemasFormData;
+		}
+		if (schema.properties) {
+			const formDataValues = resolveSchemaPropertiesToFormData({
+				schema,
+				variableName,
+				propName,
+				context,
+				isRequestBodyOptional,
+				encoding
+			});
+			form += formDataValues;
 		}
+		return form;
 	}
-}
-
-//#endregion
-//#region src/getters/combine.ts
-function combineValues({ resolvedData, resolvedValue, separator: separator$1, context }) {
-	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}:`));
-			if (discriminatedPropertySchemas.length > 0) resolvedDataValue = `Omit<${resolvedDataValue}, '${discriminatedPropertySchemas.map((s) => s.discriminator?.propertyName).join("' | '")}'>`;
+	if (schema.type === "array") {
+		let valueStr = "value";
+		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()";
 		}
-		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)));
-		if (overrideRequiredProperties.length > 0) return `${joined} & Required<Pick<${joined}, '${overrideRequiredProperties.join("' | '")}'>>`;
-		return joined;
+		return `${form}${propName}.forEach(value => ${variableName}.append('data', ${valueStr}))\n`;
 	}
-	let values = resolvedData.values;
-	if (resolvedData.allProperties.length && context.output.unionAddMissingProperties) {
-		values = [];
-		for (let i = 0; i < resolvedData.values.length; i += 1) {
-			const subSchema = resolvedData.originalSchema[i];
-			if (subSchema?.type !== "object") {
-				values.push(resolvedData.values[i]);
+	if (schema.type === "number" || schema.type === "integer" || schema.type === "boolean") return `${form}${variableName}.append('data', ${propName}.toString())\n`;
+	return `${form}${variableName}.append('data', ${propName})\n`;
+}
+function resolveSchemaPropertiesToFormData({ schema, variableName, propName, context, isRequestBodyOptional, keyPrefix = "", depth = 0, encoding }) {
+	let formDataValues = "";
+	const schemaProps = getSchemaProperties(schema) ?? {};
+	for (const [key, value] of Object.entries(schemaProps)) {
+		const { schema: property } = resolveRef(value, context);
+		if (property.readOnly) continue;
+		let formDataValue = "";
+		const partContentType = (depth === 0 ? encoding?.[key] : void 0)?.contentType;
+		const formattedKeyPrefix = isRequestBodyOptional ? keyword.isIdentifierNameES5(key) ? "?" : "?." : "";
+		const formattedKey = keyword.isIdentifierNameES5(key) ? `.${key}` : `['${key}']`;
+		const valueKey = `${propName}${formattedKeyPrefix}${formattedKey}`;
+		const nonOptionalValueKey = `${propName}${formattedKey}`;
+		const fileType = getFormDataFieldFileType(property, partContentType);
+		const effectiveContentType = partContentType ?? property.contentMediaType;
+		if (fileType === "binary" || property.format === "binary") formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
+		else if (fileType === "text") formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey} instanceof Blob ? ${nonOptionalValueKey} : new Blob([${nonOptionalValueKey}], { type: '${effectiveContentType}' }));\n`;
+		else if (property.type === "object") formDataValue = context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE ? resolveSchemaPropertiesToFormData({
+			schema: property,
+			variableName,
+			propName: nonOptionalValueKey,
+			context,
+			isRequestBodyOptional,
+			keyPrefix: `${keyPrefix}${key}.`,
+			depth: depth + 1,
+			encoding
+		}) : partContentType ? `${variableName}.append(\`${keyPrefix}${key}\`, new Blob([JSON.stringify(${nonOptionalValueKey})], { type: '${partContentType}' }));\n` : `${variableName}.append(\`${keyPrefix}${key}\`, JSON.stringify(${nonOptionalValueKey}));\n`;
+		else if (property.type === "array") {
+			let valueStr = "value";
+			let hasNonPrimitiveChild = false;
+			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({
+						schema: itemSchema,
+						variableName,
+						propName: "value",
+						context,
+						isRequestBodyOptional,
+						keyPrefix: `${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}].`,
+						depth: depth + 1
+					});
+					formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => {
+    ${resolvedValue}});\n`;
+				} else valueStr = "JSON.stringify(value)";
+				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 ((() => {
+			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;
+		const combine = getSchemaCombined(property);
+		if (combine) {
+			const subSchemas = combine.map((c) => resolveObject({
+				schema: c,
+				combined: true,
+				context
+			}));
+			if (subSchemas.some((subSchema) => {
+				return [
+					"number",
+					"integer",
+					"boolean"
+				].includes(subSchema.type);
+			})) formDataValue = `${variableName}.append(\`${key}\`, ${nonOptionalValueKey}.toString())\n`;
+			if (subSchemas.some((subSchema) => {
+				return subSchema.type === "null";
+			})) existSubSchemaNullable = true;
+		}
+		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;
 			}
-			const missingProperties = unique(resolvedData.allProperties.filter((p) => !Object.keys(subSchema.properties).includes(p)));
-			values.push(`${resolvedData.values[i]}${missingProperties.length > 0 ? ` & {${missingProperties.map((p) => `${p}?: never`).join("; ")}}` : ""}`);
+			formDataValues += `if(${valueKey} !== undefined && ${nonOptionalValueKey} !== null) {\n ${formDataValue} }\n`;
+			continue;
 		}
-	}
-	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
-	return values.join(" | ");
-}
-function combineSchemas({ name, schema, separator: separator$1, context, nullable }) {
-	const items = schema[separator$1] ?? [];
-	const resolvedData = items.reduce((acc, subSchema) => {
-		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 (isRequired) {
+			formDataValues += formDataValue;
+			continue;
 		}
-		if (separator$1 === "allOf" && isSchema(subSchema) && subSchema.required) acc.requiredProperties.push(...subSchema.required);
-		const resolvedValue$1 = resolveObject({
-			schema: subSchema,
-			propName,
-			combined: true,
-			context
-		});
-		const aliasedImports = getAliasedImports({
-			context,
-			name,
-			resolvedValue: resolvedValue$1
-		});
-		const value = getImportAliasForRefOrValue({
-			context,
-			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 ?? [] : []
-	});
-	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,
-			isRef: resolvedData.isRef[index],
-			schema: resolvedData.originalSchema[index]
-		})));
-		const newEnum = `export const ${pascal(name)} = ${combinedEnumValue}`;
-		const valueImportSet = new Set(valueImports);
-		const typeSuffix = `${nullable}${hasNull && !nullable.includes("null") ? " | null" : ""}`;
-		return {
-			value: `typeof ${pascal(name)}[keyof typeof ${pascal(name)}]${typeSuffix}`,
-			imports: [{ name: pascal(name) }],
-			schemas: [...resolvedData.schemas, {
-				imports: resolvedData.imports.filter((toImport) => valueImportSet.has(toImport.alias ?? toImport.name)).map((toImport) => ({
-					...toImport,
-					values: true
-				})),
-				model: newEnum,
-				name
-			}],
-			isEnum: false,
-			type: "object",
-			isRef: false,
-			hasReadonlyProps: resolvedData.hasReadonlyProps,
-			dependencies: resolvedData.dependencies,
-			example: schema.example,
-			examples: resolveExampleRefs(schema.examples, context)
-		};
+		formDataValues += `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
 	}
-	let resolvedValue;
-	if (schema.properties) resolvedValue = getScalar({
-		item: Object.fromEntries(Object.entries(schema).filter(([key]) => key !== separator$1)),
-		name,
-		context
-	});
-	else if (separator$1 === "allOf" && (schema.oneOf || schema.anyOf)) {
-		const siblingCombiner = schema.oneOf ? "oneOf" : "anyOf";
-		resolvedValue = combineSchemas({
-			schema: { [siblingCombiner]: schema[siblingCombiner] },
-			name,
-			separator: siblingCombiner,
-			context,
-			nullable: ""
+	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 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(" | ");
+	const nonReadonlyDefinition = filteredBodyTypes.some((x) => x.hasReadonlyProps) && definition ? `NonReadonly<${definition}>` : definition;
+	let implementation = generalJSTypesWithArray.includes(definition.toLowerCase()) || filteredBodyTypes.length > 1 ? camel(operationName) + context.output.override.components.requestBodies.suffix : camel(definition);
+	let isOptional = false;
+	if (implementation) {
+		implementation = sanitize(implementation, {
+			underscore: "_",
+			whitespace: "_",
+			dash: true,
+			es5keyword: true,
+			es5IdentifierName: true
 		});
+		if (isReference(requestBody)) {
+			const { schema: bodySchema } = resolveRef(requestBody, context);
+			if (bodySchema.required !== void 0) isOptional = !bodySchema.required;
+		} else if (requestBody.required !== void 0) isOptional = !requestBody.required;
 	}
 	return {
-		value: dedupeUnionType(combineValues({
-			resolvedData,
-			separator: separator$1,
-			resolvedValue,
-			context
-		}) + nullable),
-		imports: resolvedValue ? [...resolvedData.imports, ...resolvedValue.imports] : resolvedData.imports,
-		schemas: resolvedValue ? [...resolvedData.schemas, ...resolvedValue.schemas] : resolvedData.schemas,
-		dependencies: resolvedValue ? [...resolvedData.dependencies, ...resolvedValue.dependencies] : resolvedData.dependencies,
-		isEnum: false,
-		type: "object",
-		isRef: false,
-		hasReadonlyProps: resolvedData?.hasReadonlyProps || resolvedValue?.hasReadonlyProps || false,
-		example: schema.example,
-		examples: resolveExampleRefs(schema.examples, context)
+		originalSchema: requestBody,
+		definition: nonReadonlyDefinition,
+		implementation,
+		imports,
+		schemas,
+		isOptional,
+		...filteredBodyTypes.length === 1 ? {
+			formData: filteredBodyTypes[0].formData,
+			formUrlEncoded: filteredBodyTypes[0].formUrlEncoded,
+			contentType: filteredBodyTypes[0].contentType
+		} : {
+			formData: "",
+			formUrlEncoded: "",
+			contentType: ""
+		}
 	};
 }
 
+//#endregion
+//#region src/getters/imports.ts
+function getAliasedImports({ name, resolvedValue, context }) {
+	return context.output.schemas && resolvedValue.isRef ? resolvedValue.imports.map((imp) => {
+		if (!needCreateImportAlias({
+			name,
+			imp
+		})) return imp;
+		return {
+			...imp,
+			alias: `__${imp.name}`
+		};
+	}) : resolvedValue.imports;
+}
+function needCreateImportAlias({ imp, name }) {
+	return !imp.alias && imp.name === name;
+}
+function getImportAliasForRefOrValue({ context, imports, resolvedValue }) {
+	if (!context.output.schemas || !resolvedValue.isRef) return resolvedValue.value;
+	return imports.find((imp) => imp.name === resolvedValue.value)?.alias ?? resolvedValue.value;
+}
+
 //#endregion
 //#region src/getters/keys.ts
 function getKey(key) {
@@ -1616,7 +1864,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
@@ -1637,7 +1888,7 @@ function getPropertyNamesRecordType(item, valueType) {
 *
 * @param item item with type === "object"
 */
-function getObject({ item, name, context, nullable, propertyOverrides }) {
+function getObject({ item, name, context, nullable, formDataContext }) {
 	if (isReference(item)) {
 		const { name: name$1 } = getRefInfo(item.$ref, context);
 		return {
@@ -1658,25 +1909,46 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 		name,
 		separator: item.allOf ? "allOf" : item.oneOf ? "oneOf" : "anyOf",
 		context,
-		nullable
-	});
-	if (Array.isArray(item.type)) return combineSchemas({
-		schema: { anyOf: item.type.map((type) => ({
-			...item,
-			type
-		})) },
-		name,
-		separator: "anyOf",
-		context,
-		nullable
+		nullable,
+		formDataContext
 	});
-	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("_");
@@ -1684,21 +1956,26 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 			}
 			const allSpecSchemas = context.spec.components?.schemas ?? {};
 			if (Object.keys(allSpecSchemas).some((schemaName) => pascal(schemaName) === propName)) propName = propName + "Property";
-			const resolvedValue = propertyOverrides?.[key] ?? resolveObject({
+			const propertyFormDataContext = formDataContext && !formDataContext.atPart ? {
+				atPart: true,
+				partContentType: formDataContext.encoding[key]?.contentType
+			} : void 0;
+			const resolvedValue = resolveObject({
 				schema,
 				propName,
-				context
+				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,
@@ -1719,8 +1996,9 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 			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}";
@@ -1732,42 +2010,31 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 					}
 				} else {
 					const resolvedValue$1 = resolveValue({
-						schema: item.additionalProperties,
+						schema: additionalProps,
 						name,
 						context
 					});
 					const recordType$1 = getPropertyNamesRecordType(item, resolvedValue$1.value);
 					if (recordType$1) {
-						acc.value += "\n}";
-						acc.value += ` & ${recordType$1}`;
-						acc.useTypeAlias = true;
-					} else {
-						const keyType$1 = getIndexSignatureKey(item);
-						acc.value += `\n  [key: ${keyType$1}]: ${resolvedValue$1.value};\n}`;
-					}
-					acc.dependencies.push(...resolvedValue$1.dependencies);
-				}
-				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)
-		});
+						acc.value += "\n}";
+						acc.value += ` & ${recordType$1}`;
+						acc.useTypeAlias = true;
+					} else {
+						const keyType$1 = getIndexSignatureKey(item);
+						acc.value += `\n  [key: ${keyType$1}]: ${resolvedValue$1.value};\n}`;
+					}
+					acc.dependencies.push(...resolvedValue$1.dependencies);
+				}
+				else acc.value += "\n}";
+				acc.value += nullable;
+			}
+		}
+		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,
@@ -1776,7 +2043,7 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 				isEnum: false,
 				type: "object",
 				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
+				hasReadonlyProps: readOnlyFlag ?? false,
 				useTypeAlias: true,
 				dependencies: []
 			};
@@ -1787,21 +2054,21 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 				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,
@@ -1811,8 +2078,8 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 		};
 		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,
@@ -1821,15 +2088,15 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 			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";
@@ -1841,7 +2108,7 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 		isEnum: false,
 		type: "object",
 		isRef: false,
-		hasReadonlyProps: item.readOnly || false,
+		hasReadonlyProps: readOnlyFlag ?? false,
 		useTypeAlias: true,
 		dependencies: []
 	};
@@ -1852,492 +2119,367 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 		isEnum: false,
 		type: "object",
 		isRef: false,
-		hasReadonlyProps: item.readOnly || false,
+		hasReadonlyProps: readOnlyFlag ?? false,
 		useTypeAlias: false,
 		dependencies: []
 	};
 }
 
 //#endregion
-//#region src/getters/res-req-types.ts
-const formDataContentTypes = new Set(["multipart/form-data"]);
-const formUrlEncodedContentTypes = new Set(["application/x-www-form-urlencoded"]);
-function getResReqContentTypes({ mediaType, propName, context, isFormData, contentType }) {
-	if (!mediaType.schema) return;
-	if (isFormData) {
-		const formDataResult = resolveFormDataRootObject({
-			schemaOrRef: mediaType.schema,
-			propName,
-			context,
-			encoding: mediaType.encoding
-		});
-		if (formDataResult) return formDataResult;
-	}
-	const resolvedObject = resolveObject({
-		schema: mediaType.schema,
-		propName,
-		context
-	});
-	if (!isFormData && isBinaryContentType(contentType)) return {
-		...resolvedObject,
-		value: "Blob"
-	};
-	return resolvedObject;
-}
-function getResReqTypes(responsesOrRequests, name, context, defaultType = "unknown", uniqueKey = (item) => item.value) {
-	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 isFormData = formDataContentTypes.has(contentType);
-			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
-			if (!isFormData && !isFormUrlEncoded || !mediaType.schema) return [{
-				value: name$1,
-				imports: [{
-					name: name$1,
-					schemaName
-				}],
-				schemas: [],
-				type: "unknown",
-				isEnum: false,
-				isRef: true,
-				hasReadonlyProps: false,
-				originalSchema: mediaType?.schema,
-				example: mediaType?.example,
-				examples: resolveExampleRefs(mediaType?.examples, context),
-				key,
-				contentType
-			}];
-			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
-				name: name$1,
-				schemaObject: mediaType.schema,
-				context,
-				isRequestBodyOptional: "required" in bodySchema && bodySchema.required === false,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
-				name: name$1,
-				schemaObject: mediaType.schema,
-				context,
-				isRequestBodyOptional: "required" in bodySchema && bodySchema.required === false,
-				isUrlEncoded: true,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const additionalImports = getFormDataAdditionalImports({
-				schemaObject: mediaType.schema,
-				context
-			});
-			return [{
-				value: name$1,
-				imports: [{
-					name: name$1,
-					schemaName
-				}, ...additionalImports],
-				schemas: [],
-				type: "unknown",
-				isEnum: false,
-				hasReadonlyProps: false,
-				formData,
-				formUrlEncoded,
-				isRef: true,
-				originalSchema: mediaType.schema,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context),
-				key,
-				contentType
-			}];
-		}
-		if (res.content) return Object.entries(res.content).map(([contentType, mediaType], index, arr) => {
-			let propName = key ? pascal(name) + pascal(key) : void 0;
-			if (propName && arr.length > 1) propName = propName + pascal(getNumberWord(index + 1));
-			let effectivePropName = propName;
-			if (mediaType.schema && isReference(mediaType.schema)) {
-				const { imports } = resolveRef(mediaType.schema, context);
-				if (imports[0]?.name) effectivePropName = imports[0].name;
-			}
-			const isFormData = formDataContentTypes.has(contentType);
-			const resolvedValue = getResReqContentTypes({
-				mediaType,
-				propName: effectivePropName,
-				context,
-				isFormData,
-				contentType
-			});
-			if (!resolvedValue) {
-				if (isBinaryContentType(contentType)) return {
-					value: "Blob",
-					imports: [],
-					schemas: [],
-					type: "Blob",
-					isEnum: false,
-					key,
-					isRef: false,
-					hasReadonlyProps: false,
-					contentType
-				};
-				return;
-			}
-			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
-			if (!isFormData && !isFormUrlEncoded || !effectivePropName) return {
-				...resolvedValue,
-				imports: resolvedValue.imports,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
-			};
-			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
-				name: effectivePropName,
-				schemaObject: mediaType.schema,
-				context,
-				isRequestBodyOptional: "required" in res && res.required === false,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
-				name: effectivePropName,
-				schemaObject: mediaType.schema,
-				context,
-				isUrlEncoded: true,
-				isRequestBodyOptional: "required" in res && res.required === false,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const additionalImports = getFormDataAdditionalImports({
-				schemaObject: mediaType.schema,
-				context
-			});
-			return {
-				...resolvedValue,
-				imports: [...resolvedValue.imports, ...additionalImports],
-				formData,
-				formUrlEncoded,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
-			};
-		}).filter(Boolean).map((x) => ({
-			...x,
-			key
-		}));
-		const swaggerSchema = "schema" in res ? res.schema : void 0;
-		if (swaggerSchema) return [{
-			...resolveObject({
-				schema: swaggerSchema,
-				propName: key ? pascal(name) + pascal(key) : void 0,
-				context
-			}),
-			contentType: "application/json",
-			key
-		}];
-		return [{
-			value: defaultType,
-			imports: [],
-			schemas: [],
-			type: defaultType,
-			isEnum: false,
-			key,
-			isRef: false,
-			hasReadonlyProps: false,
-			contentType: "application/json"
-		}];
-	}).flat(), uniqueKey);
-}
-function isBinaryContentType(contentType) {
-	if (contentType === "application/octet-stream") return true;
-	if (contentType.startsWith("image/")) return true;
-	if (contentType.startsWith("audio/")) return true;
-	if (contentType.startsWith("video/")) return true;
-	if (contentType.startsWith("font/")) return true;
-	if (contentType.startsWith("text/")) return false;
-	if ([
-		"+json",
-		"-json",
-		"+xml",
-		"-xml",
-		"+yaml",
-		"-yaml",
-		"+rss",
-		"-rss",
-		"+csv",
-		"-csv"
-	].some((suffix) => contentType.includes(suffix))) return false;
-	return !new Set([
-		"application/json",
-		"application/xml",
-		"application/yaml",
-		"application/x-www-form-urlencoded",
-		"application/javascript",
-		"application/ecmascript",
-		"application/graphql"
-	]).has(contentType);
-}
-/**
-* Determine the response type category for a given content type.
-* Used to set the correct responseType option in HTTP clients.
-*
-* @param contentType - The MIME content type (e.g., 'application/json', 'text/plain')
-* @returns The response type category to use for parsing
-*/
-function getResponseTypeCategory(contentType) {
-	if (isBinaryContentType(contentType)) return "blob";
-	if (contentType === "application/json" || contentType.includes("+json") || contentType.includes("-json")) return "json";
-	return "text";
-}
-/**
-* Get the default content type from a list of content types.
-* Priority: application/json > any JSON-like type > first in list
-*
-* @param contentTypes - Array of content types from OpenAPI spec
-* @returns The default content type to use
-*/
-function getDefaultContentType(contentTypes) {
-	if (contentTypes.length === 0) return "application/json";
-	if (contentTypes.includes("application/json")) return "application/json";
-	const jsonType = contentTypes.find((ct) => ct.includes("+json") || ct.includes("-json"));
-	if (jsonType) return jsonType;
-	return contentTypes[0];
-}
-/**
-* Determine if a form-data root field should be treated as binary or text file
-* based on encoding.contentType or contentMediaType.
-*
-* Returns:
-* - 'binary': field is a binary file (Blob in types, File in zod)
-* - 'text': field is a text file that can accept string (Blob | string in types, File | string in zod)
-* - undefined: no override, use standard resolution
-*/
-function getFormDataFieldFileType(resolvedSchema, encodingContentType) {
-	if (resolvedSchema.type !== "string") return;
-	if (resolvedSchema.contentEncoding) return;
-	const effectiveContentType = encodingContentType ?? resolvedSchema.contentMediaType;
-	if (effectiveContentType) return isBinaryContentType(effectiveContentType) ? "binary" : "text";
-}
+//#region src/getters/scalar.ts
 /**
-* Resolve form-data root object with file type overrides.
-* Returns undefined if no file type overrides needed (caller should use normal resolution).
+* Return the typescript equivalent of open-api data type
+*
+* @param item
+* @ref https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#data-types
 */
-function resolveFormDataRootObject({ schemaOrRef, propName, context, encoding }) {
-	const { schema } = resolveRef(schemaOrRef, context);
-	if (!schema.properties) return;
-	const propertyOverrides = {};
-	for (const key of Object.keys(schema.properties)) {
-		const propSchema = schema.properties[key];
-		const { schema: resolvedSchema } = resolveRef(propSchema, context);
-		const fileType = getFormDataFieldFileType(resolvedSchema, encoding?.[key]?.contentType);
-		if (fileType) propertyOverrides[key] = {
-			...getScalar({
-				item: resolvedSchema,
-				name: propName,
-				context
-			}),
-			value: fileType === "binary" ? "Blob" : "Blob | string"
-		};
+function getScalar({ item, name, context, formDataContext }) {
+	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 (Object.keys(propertyOverrides).length === 0) return;
-	const result = getObject({
-		item: schema,
-		name: propName,
-		context,
-		nullable: "",
-		propertyOverrides
-	});
-	return createTypeAliasIfNeeded({
-		resolvedValue: {
-			...result,
-			originalSchema: schema
-		},
-		propName,
-		context
-	}) ?? result;
-}
-function getFormDataAdditionalImports({ schemaObject, context }) {
-	const { schema } = resolveRef(schemaObject, context);
-	if (schema.type !== "object") return [];
-	const combinedSchemas = schema.oneOf || schema.anyOf;
-	if (!combinedSchemas) return [];
-	return combinedSchemas.map((schema$1) => resolveRef(schema$1, context).imports[0]).filter(Boolean);
-}
-function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequestBodyOptional, isUrlEncoded, isRef, encoding }) {
-	const { schema, imports } = resolveRef(schemaObject, context);
-	const propName = camel(!isRef && isReference(schemaObject) ? imports[0].name : name);
-	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;
-	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);
-				let newPropName = propName;
-				let newPropDefinition = "";
-				if (shouldCast && imports$1[0]) {
-					additionalImports.push(imports$1[0]);
-					newPropName = `${propName}${pascal(imports$1[0].name)}`;
-					newPropDefinition = `const ${newPropName} = (${propName} as ${imports$1[0].name}${isRequestBodyOptional ? " | undefined" : ""});\n`;
-				}
-				return newPropDefinition + resolveSchemaPropertiesToFormData({
-					schema: combinedSchema,
-					variableName,
-					propName: newPropName,
-					context,
-					isRequestBodyOptional,
-					encoding
-				});
-			}).filter(Boolean).join("\n");
-			form += combinedSchemasFormData;
+	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 && (schemaFormat === "int64" || schemaFormat === "uint64") ? "bigint" : "number";
+			let isEnum = false;
+			if (enumItems) {
+				value = enumItems.map((enumItem) => `${enumItem}`).join(" | ");
+				isEnum = true;
+			}
+			value += nullable;
+			if (schemaConst !== void 0) value = schemaConst;
+			return {
+				value,
+				isEnum,
+				type: "number",
+				schemas: [],
+				imports: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
 		}
-		if (schema.properties) {
-			const formDataValues = resolveSchemaPropertiesToFormData({
-				schema,
-				variableName,
-				propName,
+		case "boolean": {
+			let value = "boolean" + nullable;
+			if (schemaConst !== void 0) value = schemaConst;
+			return {
+				value,
+				type: "boolean",
+				isEnum: false,
+				schemas: [],
+				imports: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
+		}
+		case "array": {
+			const { value, ...rest } = getArray({
+				schema: item,
+				name,
 				context,
-				isRequestBodyOptional,
-				encoding
+				formDataContext
 			});
-			form += formDataValues;
+			return {
+				value: value + nullable,
+				...rest,
+				dependencies: rest.dependencies
+			};
+		}
+		case "string": {
+			let value = "string";
+			let isEnum = false;
+			if (enumItems) {
+				value = enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : `${enumItem}`).filter(Boolean).join(` | `);
+				isEnum = true;
+			}
+			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 && (schemaFormat === "date" || schemaFormat === "date-time")) value = "Date";
+			value += nullable;
+			if (schemaConst) value = `'${schemaConst}'`;
+			return {
+				value,
+				isEnum,
+				type: "string",
+				imports: [],
+				schemas: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
+		}
+		case "null": return {
+			value: "null",
+			isEnum: false,
+			type: "null",
+			imports: [],
+			schemas: [],
+			isRef: false,
+			hasReadonlyProps: schemaReadOnly ?? false,
+			dependencies: []
+		};
+		default: {
+			if (isArray(itemType)) return combineSchemas({
+				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)}'` : String(enumItem)).filter(Boolean).join(` | `) + nullable,
+				isEnum: true,
+				type: "string",
+				imports: [],
+				schemas: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
+			const hasCombiners = item.allOf ?? item.anyOf ?? item.oneOf;
+			const { value, ...rest } = getObject({
+				item,
+				name,
+				context,
+				nullable,
+				formDataContext: formDataContext?.atPart === false || formDataContext?.atPart && hasCombiners ? formDataContext : void 0
+			});
+			return {
+				value,
+				...rest
+			};
 		}
-		return form;
 	}
-	if (schema.type === "array") {
-		let valueStr = "value";
-		if (schema.items) {
-			const { schema: itemSchema } = resolveRef(schema.items, 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()";
+}
+
+//#endregion
+//#region src/getters/combine.ts
+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;
 		}
-		return `${form}${propName}.forEach(value => ${variableName}.append('data', ${valueStr}))\n`;
+		remainingAllOf.push(subSchema);
 	}
-	if (schema.type === "number" || schema.type === "integer" || schema.type === "boolean") return `${form}${variableName}.append('data', ${propName}.toString())\n`;
-	return `${form}${variableName}.append('data', ${propName})\n`;
+	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 resolveSchemaPropertiesToFormData({ schema, variableName, propName, context, isRequestBodyOptional, keyPrefix = "", depth = 0, encoding }) {
-	return Object.entries(schema.properties ?? {}).reduce((acc, [key, value]) => {
-		const { schema: property } = resolveRef(value, context);
-		if (property.readOnly) return acc;
-		let formDataValue = "";
-		const encodingContentType = (depth === 0 ? encoding?.[key] : void 0)?.contentType;
-		const formattedKeyPrefix = isRequestBodyOptional ? keyword.isIdentifierNameES5(key) ? "?" : "?." : "";
-		const formattedKey = keyword.isIdentifierNameES5(key) ? `.${key}` : `['${key}']`;
-		const valueKey = `${propName}${formattedKeyPrefix}${formattedKey}`;
-		const nonOptionalValueKey = `${propName}${formattedKey}`;
-		const fileType = getFormDataFieldFileType(property, encodingContentType);
-		const effectiveContentType = encodingContentType ?? property.contentMediaType;
-		if (fileType === "binary" || property.format === "binary") formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
-		else if (fileType === "text") formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey} instanceof Blob ? ${nonOptionalValueKey} : new Blob([${nonOptionalValueKey}], { type: '${effectiveContentType}' }));\n`;
-		else if (property.type === "object") formDataValue = context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE ? resolveSchemaPropertiesToFormData({
-			schema: property,
-			variableName,
-			propName: nonOptionalValueKey,
-			context,
-			isRequestBodyOptional,
-			keyPrefix: `${keyPrefix}${key}.`,
-			depth: depth + 1,
-			encoding
-		}) : encodingContentType ? `${variableName}.append(\`${keyPrefix}${key}\`, new Blob([JSON.stringify(${nonOptionalValueKey})], { type: '${encodingContentType}' }));\n` : `${variableName}.append(\`${keyPrefix}${key}\`, JSON.stringify(${nonOptionalValueKey}));\n`;
-		else if (property.type === "array") {
-			let valueStr = "value";
-			let hasNonPrimitiveChild = false;
-			if (property.items) {
-				const { schema: itemSchema } = resolveRef(property.items, context);
-				if (itemSchema.type === "object" || itemSchema.type === "array") if (context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE) {
-					hasNonPrimitiveChild = true;
-					const resolvedValue = resolveSchemaPropertiesToFormData({
-						schema: itemSchema,
-						variableName,
-						propName: "value",
-						context,
-						isRequestBodyOptional,
-						keyPrefix: `${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}].`,
-						depth: depth + 1
-					});
-					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()";
+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) => {
+				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) => {
+			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;
+	}
+	let values = resolvedData.values;
+	if (resolvedData.allProperties.length && context.output.unionAddMissingProperties) {
+		values = [];
+		for (let i = 0; i < resolvedData.values.length; i += 1) {
+			const subSchema = resolvedData.originalSchema[i];
+			if (subSchema?.type !== "object" || !subSchema.properties) {
+				values.push(resolvedData.values[i]);
+				continue;
 			}
-			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 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({
-				schema: c,
-				combined: true,
-				context
-			}));
-			if (subSchemas?.some((subSchema) => {
-				return [
-					"number",
-					"integer",
-					"boolean"
-				].includes(subSchema.type);
-			})) formDataValue = `${variableName}.append(\`${key}\`, ${nonOptionalValueKey}.toString())\n`;
-			if (subSchemas?.some((subSchema) => {
-				return subSchema.type === "null";
-			})) existSubSchemaNullable = true;
+			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("; ")}}` : ""}`);
 		}
-		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`;
+	}
+	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
+	return values.join(" | ");
+}
+function combineSchemas({ name, schema, separator: separator$1, context, nullable, formDataContext }) {
+	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 && resolvedData.schemas.length > 0) propName = propName + pascal(getNumberWord(resolvedData.schemas.length + 1));
 		}
-		if (isRequired) return acc + formDataValue;
-		return acc + `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
-	}, "");
-}
-
-//#endregion
-//#region src/getters/body.ts
-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 imports = filteredBodyTypes.flatMap(({ imports: imports$1 }) => imports$1);
-	const schemas = filteredBodyTypes.flatMap(({ schemas: schemas$1 }) => schemas$1);
-	const definition = filteredBodyTypes.map(({ value }) => value).join(" | ");
-	const nonReadonlyDefinition = filteredBodyTypes.some((x) => x.hasReadonlyProps) && definition ? `NonReadonly<${definition}>` : definition;
-	let implementation = generalJSTypesWithArray.includes(definition.toLowerCase()) || filteredBodyTypes.length > 1 ? camel(operationName) + context.output.override.components.requestBodies.suffix : camel(definition);
-	let isOptional = false;
-	if (implementation) {
-		implementation = sanitize(implementation, {
-			underscore: "_",
-			whitespace: "_",
-			dash: true,
-			es5keyword: true,
-			es5IdentifierName: true
+		if (separator$1 === "allOf" && isSchema(subSchema) && subSchema.required) resolvedData.requiredProperties.push(...subSchema.required);
+		const resolvedValue$1 = resolveObject({
+			schema: subSchema,
+			propName,
+			combined: true,
+			context,
+			formDataContext
+		});
+		const aliasedImports = getAliasedImports({
+			context,
+			name,
+			resolvedValue: resolvedValue$1
+		});
+		const value = getImportAliasForRefOrValue({
+			context,
+			resolvedValue: resolvedValue$1,
+			imports: aliasedImports
+		});
+		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,
+			isRef: resolvedData.isRef[index],
+			schema: resolvedData.originalSchema[index]
+		})));
+		const newEnum = `export const ${pascal(name)} = ${combinedEnumValue}`;
+		const valueImportSet = new Set(valueImports);
+		const typeSuffix = `${nullable}${hasNull && !nullable.includes("null") ? " | null" : ""}`;
+		return {
+			value: `typeof ${pascal(name)}[keyof typeof ${pascal(name)}]${typeSuffix}`,
+			imports: [{ name: pascal(name) }],
+			schemas: [...resolvedData.schemas, {
+				imports: resolvedData.imports.filter((toImport) => valueImportSet.has(toImport.alias ?? toImport.name)).map((toImport) => ({
+					...toImport,
+					values: true
+				})),
+				model: newEnum,
+				name
+			}],
+			isEnum: false,
+			type: "object",
+			isRef: false,
+			hasReadonlyProps: resolvedData.hasReadonlyProps,
+			dependencies: resolvedData.dependencies,
+			example: schema.example,
+			examples: resolveExampleRefs(schema.examples, context)
+		};
+	}
+	let resolvedValue;
+	if (normalizedSchema.properties) resolvedValue = getScalar({
+		item: Object.fromEntries(Object.entries(normalizedSchema).filter(([key]) => key !== separator$1)),
+		name,
+		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]: siblingSchemas },
+			name,
+			separator: siblingCombiner,
+			context,
+			nullable: ""
 		});
-		if (isReference(requestBody)) {
-			const { schema: bodySchema } = resolveRef(requestBody, context);
-			if (bodySchema.required !== void 0) isOptional = !bodySchema.required;
-		} else if (requestBody.required !== void 0) isOptional = !requestBody.required;
 	}
 	return {
-		originalSchema: requestBody,
-		definition: nonReadonlyDefinition,
-		implementation,
-		imports,
-		schemas,
-		isOptional,
-		...filteredBodyTypes.length === 1 ? {
-			formData: filteredBodyTypes[0].formData,
-			formUrlEncoded: filteredBodyTypes[0].formUrlEncoded,
-			contentType: filteredBodyTypes[0].contentType
-		} : {
-			formData: "",
-			formUrlEncoded: "",
-			contentType: ""
-		}
+		value: dedupeUnionType(combineValues({
+			resolvedData,
+			separator: separator$1,
+			resolvedValue,
+			context,
+			parentSchema: normalizedSchema
+		}) + nullable),
+		imports: resolvedValue ? [...resolvedData.imports, ...resolvedValue.imports] : resolvedData.imports,
+		schemas: resolvedValue ? [...resolvedData.schemas, ...resolvedValue.schemas] : resolvedData.schemas,
+		dependencies: resolvedValue ? [...resolvedData.dependencies, ...resolvedValue.dependencies] : resolvedData.dependencies,
+		isEnum: false,
+		type: "object",
+		isRef: false,
+		hasReadonlyProps: resolvedData.hasReadonlyProps || (resolvedValue?.hasReadonlyProps ?? false),
+		example: schema.example,
+		examples: resolveExampleRefs(schema.examples, context)
 	};
 }
 
@@ -2346,7 +2488,9 @@ function getBody({ requestBody, operationName, context, contentType }) {
 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)) {
@@ -2357,17 +2501,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])];
 			}
 		}
 	}
@@ -2389,23 +2541,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
@@ -2449,16 +2600,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
 		};
 	});
 }
@@ -2479,7 +2632,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 = {
@@ -2487,7 +2640,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;
@@ -2541,16 +2694,18 @@ 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 {
 			definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${parameterImports[0].name};`,
@@ -2560,7 +2715,7 @@ 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 {
 				definition: `${doc}${key}${!required || schema.default ? "?" : ""}: ${enumName};`,
 				imports: [{ name: enumName }],
@@ -2602,39 +2757,16 @@ function getQueryParams({ queryParams, operationName, context, suffix = "params"
 //#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}`), 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;
@@ -2670,16 +2802,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));
@@ -2754,25 +2888,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));
@@ -2787,31 +2922,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,
@@ -2819,9 +2948,9 @@ function addDependency({ implementation, exports, dependency, projectName, hasSc
 			key,
 			onlyTypes: false
 		});
-		if (types) {
+		if (types.length > 0) {
 			let uniqueTypes = types;
-			if (values) {
+			if (values.length > 0) {
 				uniqueTypes = types.filter((t) => !values.some((v) => v.name === t.name));
 				dep += "\n";
 			}
@@ -2848,7 +2977,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;
@@ -2874,7 +3003,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
@@ -2900,7 +3032,7 @@ async function bundleFile(root, fileName, alias, external, compilerOptions) {
 		treeShaking: false,
 		keepNames: false,
 		alias,
-		external: external || ["*"]
+		external: external ?? ["*"]
 	})).outputFiles[0];
 	return text;
 }
@@ -3045,7 +3177,7 @@ function generateAxiosOptions({ response, isExactOptionalPropertyTypes, queryPar
 		if (headers) value += "\n        headers,";
 		if (hasSignal) value += isExactOptionalPropertyTypes ? `\n        ...(${signalVar} ? { ${signalProp} } : {}),` : `\n        ${signalProp},`;
 	}
-	if (!isObject(requestOptions) || !requestOptions.hasOwnProperty("responseType")) {
+	if (!isObject(requestOptions) || !Object.hasOwn(requestOptions, "responseType")) {
 		if (response.isBlob) value += `\n        responseType: 'blob',`;
 		else if (response.contentTypes.at(0) === "text/plain") value += `\n        responseType: 'text',`;
 	}
@@ -3057,7 +3189,7 @@ function generateAxiosOptions({ response, isExactOptionalPropertyTypes, queryPar
 		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)) value += paramsSerializer ? `\n        paramsSerializer: ${paramsSerializer.name},` : `\n        paramsSerializer: (params) => qs.stringify(params, ${JSON.stringify(paramsSerializerOptions?.qs)}),`;
 	return value;
 }
 function generateOptions({ route, body, headers, queryParams, response, verb, requestOptions, isFormData, isFormUrlEncoded, isAngular, isExactOptionalPropertyTypes, hasSignal, hasSignalParam, isVue, paramsSerializer, paramsSerializerOptions }) {
@@ -3098,7 +3230,7 @@ function generateQueryParamsAxiosConfig(response, isVue, queryParams) {
 function generateMutatorConfig({ route, body, headers, queryParams, response, verb, isFormData, isFormUrlEncoded, hasSignal, hasSignalParam = false, isExactOptionalPropertyTypes, isVue }) {
 	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 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    }`;
@@ -3180,18 +3312,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,
@@ -3241,7 +3375,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);
@@ -3278,7 +3412,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: [],
@@ -3297,7 +3431,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)) {
@@ -3316,7 +3450,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;
 		});
@@ -3333,26 +3467,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
@@ -3428,7 +3592,7 @@ async function generateVerbOptions({ verb, output, operation, route, pathRoute,
 		tags,
 		route,
 		pathRoute,
-		summary: operation.summary,
+		summary,
 		operationId,
 		operationName,
 		response,
@@ -3453,23 +3617,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));
@@ -3515,17 +3695,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;
@@ -3534,14 +3722,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("\\", "/");
@@ -3594,7 +3782,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
 	});
@@ -3623,7 +3811,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 }) {
@@ -3658,14 +3846,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)}`);
 		}
 	}
 }
@@ -3674,10 +3862,20 @@ 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);
+	if (output.indexFiles) return isZodSchemaOutput ? [{
+		exports: imports.map((i) => ({
+			...i,
+			values: true
+		})),
+		dependency: joinSafe(relativeSchemasPath, "index.zod")
+	}] : [{
+		exports: imports,
+		dependency: relativeSchemasPath
+	}];
+	else return uniqueBy(imports, (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,
@@ -3686,46 +3884,52 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 			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
-	}];
 }
 
 //#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,
@@ -3737,38 +3941,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
@@ -3824,7 +4012,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({
@@ -3893,7 +4081,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({
@@ -3953,7 +4141,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)}`);
 	}
 }
 
@@ -3967,8 +4155,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,
@@ -3987,6 +4174,7 @@ function generateTargetTags(currentAcc, operation) {
 		};
 		return currentAcc;
 	}
+	const currentOperation = currentAcc[tag];
 	currentAcc[tag] = {
 		implementation: currentOperation.implementation + operation.implementation,
 		imports: [...currentOperation.imports, ...operation.imports],
@@ -4007,66 +4195,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
@@ -4078,14 +4269,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,
@@ -4155,9 +4347,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 [
@@ -4166,7 +4358,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();
 }
@@ -4184,7 +4376,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,
@@ -4242,11 +4434,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, 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, 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, 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