@orval/core 8.0.3 → 8.2.0

package/dist/index.mjs

@@ -388,6 +388,57 @@ function conventionName(name, convention) {
 	return nameConventionTransform(name);
 }
 
+//#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 effectiveContentType = partContentType ?? resolvedSchema.contentMediaType;
+	if (effectiveContentType) return isBinaryContentType(effectiveContentType) ? "binary" : "text";
+}
+
 //#endregion
 //#region src/utils/compare-version.ts
 function compareVersions(firstVersion, secondVersions, operator = ">=") {
@@ -797,11 +848,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`;
@@ -810,6 +863,37 @@ 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 = [];
+	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
@@ -895,6 +979,76 @@ const toNumberKey = (value) => {
 const getUnion = (value, enumName) => {
 	return `export type ${enumName} = ${value};`;
 };
+function getEnumUnionFromSchema(schema) {
+	if (!schema?.enum) return "";
+	return schema.enum.filter((val) => val !== null).map((val) => isString(val) ? `'${escape(val)}'` : `${val}`).join(" | ");
+}
+const stripNullUnion = (value) => value.replace(/\s*\|\s*null/g, "").trim();
+const isSpreadableEnumRef = (schema, refName) => {
+	if (!schema?.enum || !refName) return false;
+	if (!getEnumUnionFromSchema(schema)) return false;
+	const type = schema.type;
+	if (type === "boolean" || Array.isArray(type) && type.includes("boolean")) return false;
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(refName);
+};
+const buildInlineEnum = (schema, enumValue) => {
+	const names = getEnumNames(schema);
+	const descriptions = getEnumDescriptions(schema);
+	return getEnumImplementation(enumValue ?? getEnumUnionFromSchema(schema), names, descriptions);
+};
+function getCombinedEnumValue(inputs) {
+	const valueImports = [];
+	const hasNull = inputs.some((input) => {
+		if (input.value.includes("| null")) return true;
+		const schema = input.schema;
+		if (!schema) return false;
+		if (schema.nullable === true) return true;
+		if (Array.isArray(schema.type) && schema.type.includes("null")) return true;
+		return schema.enum?.includes(null) ?? false;
+	});
+	const addValueImport = (name) => {
+		if (!valueImports.includes(name)) valueImports.push(name);
+	};
+	if (inputs.length === 1) {
+		const input = inputs[0];
+		if (input.isRef) {
+			const refName = stripNullUnion(input.value);
+			if (isSpreadableEnumRef(input.schema, refName)) {
+				addValueImport(refName);
+				return {
+					value: refName,
+					valueImports,
+					hasNull
+				};
+			}
+			return {
+				value: `{${buildInlineEnum(input.schema)}} as const`,
+				valueImports,
+				hasNull
+			};
+		}
+		return {
+			value: `{${buildInlineEnum(input.schema, stripNullUnion(input.value))}} as const`,
+			valueImports,
+			hasNull
+		};
+	}
+	return {
+		value: `{${inputs.map((input) => {
+			if (input.isRef) {
+				const refName = stripNullUnion(input.value);
+				if (isSpreadableEnumRef(input.schema, refName)) {
+					addValueImport(refName);
+					return `...${refName},`;
+				}
+				return buildInlineEnum(input.schema);
+			}
+			return buildInlineEnum(input.schema, stripNullUnion(input.value));
+		}).join("")}} as const`,
+		valueImports,
+		hasNull
+	};
+}
 
 //#endregion
 //#region src/getters/ref.ts
@@ -982,6 +1136,10 @@ function getSchema$1(schema, context) {
 		...currentSchema,
 		nullable: schema.nullable
 	};
+	if ("type" in schema && Array.isArray(schema.type)) currentSchema = {
+		...currentSchema,
+		type: schema.type
+	};
 	return {
 		currentSchema,
 		refInfo
@@ -1007,7 +1165,7 @@ function resolveExampleRefs(examples, context) {
 
 //#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];
@@ -1041,7 +1199,8 @@ function resolveValue({ schema, name, context }) {
 		...getScalar({
 			item: schema,
 			name,
-			context
+			context,
+			formDataContext
 		}),
 		originalSchema: schema,
 		isRef: false
@@ -1083,11 +1242,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,
@@ -1121,19 +1281,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;
@@ -1146,18 +1308,19 @@ function resolveObject({ schema, propName, combined = false, context }) {
 *
 * @param item item with type === "array"
 */
-function getArray({ schema, name, context }) {
+function getArray({ schema, name, context, formDataContext }) {
 	const schema31 = schema;
+	const itemSuffix = context.output.override.components.schemas.itemSuffix;
 	if (schema31.prefixItems) {
 		const resolvedObjects = schema31.prefixItems.map((item, index) => resolveObject({
 			schema: item,
-			propName: name + context.output.override.components.schemas.itemSuffix + index,
+			propName: name ? name + itemSuffix + index : void 0,
 			context
 		}));
 		if (schema31.items) {
 			const additional = resolveObject({
 				schema: schema31.items,
-				propName: name + context.output.override.components.schemas.itemSuffix + "Additional",
+				propName: name ? name + itemSuffix + "Additional" : void 0,
 				context
 			});
 			resolvedObjects.push({
@@ -1181,8 +1344,9 @@ function getArray({ schema, name, context }) {
 	if (schema.items) {
 		const resolvedObject = resolveObject({
 			schema: schema.items,
-			propName: name + context.output.override.components.schemas.itemSuffix,
-			context
+			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}[]`}`,
@@ -1210,323 +1374,423 @@ 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 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 ?? []
-			};
+			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
+			}];
 		}
-		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 (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;
 			}
-			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: [],
-				schemas: [],
-				isRef: false,
-				hasReadonlyProps: item.readOnly || false,
-				dependencies: [],
-				example: item.example,
-				examples: resolveExampleRefs(item.examples, context)
-			};
-		}
-		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",
+			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) return {
+				...resolvedValue,
+				imports: resolvedValue.imports,
+				contentType,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context)
 			};
-			const { value, ...rest } = getObject({
-				item,
-				name,
+			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
+				name: effectivePropName,
+				schemaObject: mediaType.schema,
 				context,
-				nullable
+				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);
 }
-
-//#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("' | '")}'>`;
+/**
+* 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 = 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;
 		}
-		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;
+		if (schema.properties) {
+			const formDataValues = resolveSchemaPropertiesToFormData({
+				schema,
+				variableName,
+				propName,
+				context,
+				isRequestBodyOptional,
+				encoding
+			});
+			form += formDataValues;
+		}
+		return form;
 	}
-	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]);
-				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("; ")}}` : ""}`);
+	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()";
 		}
+		return `${form}${propName}.forEach(value => ${variableName}.append('data', ${valueStr}))\n`;
 	}
-	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
-	return values.join(" | ");
+	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 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 (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 && separator$1 !== "oneOf") {
-		const newEnum = `export const ${pascal(name)} = ${getCombineEnumValue(resolvedData)}`;
-		return {
-			value: `typeof ${pascal(name)}[keyof typeof ${pascal(name)}] ${nullable}`,
-			imports: [{ name: pascal(name) }],
-			schemas: [...resolvedData.schemas, {
-				imports: resolvedData.imports.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 (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,
+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 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,
-			nullable: ""
+			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;
+			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()";
+			}
+			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 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 (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 (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: 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: ""
+		}
 	};
 }
-const getCombineEnumValue = ({ values, isRef, originalSchema }) => {
-	if (values.length === 1) {
-		if (isRef[0]) return values[0];
-		return `{${getEnumImplementation(values[0])}} as const`;
-	}
-	return `{${values.map((e, i) => {
-		if (isRef[i]) return `...${e},`;
-		return getEnumImplementation(e, getEnumNames(originalSchema[i]), getEnumDescriptions(originalSchema[i]));
-	}).join("")}} as const`;
-};
+
+//#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
@@ -1552,12 +1816,17 @@ function getIndexSignatureKey(item) {
 	if (enumValues && enumValues.length > 0) return enumValues.map((val) => `'${val}'`).join(" | ");
 	return "string";
 }
+function getPropertyNamesRecordType(item, valueType) {
+	const enumValues = getPropertyNamesEnum(item);
+	if (!enumValues || enumValues.length === 0) return;
+	return `Partial<Record<${enumValues.map((val) => `'${val}'`).join(" | ")}, ${valueType}>>`;
+}
 /**
 * Return the output type from an object
 *
 * @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 {
@@ -1578,7 +1847,8 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 		name,
 		separator: item.allOf ? "allOf" : item.oneOf ? "oneOf" : "anyOf",
 		context,
-		nullable
+		nullable,
+		formDataContext
 	});
 	if (Array.isArray(item.type)) return combineSchemas({
 		schema: { anyOf: item.type.map((type) => ({
@@ -1604,10 +1874,15 @@ 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;
 			if (!index) acc.value += "{";
@@ -1635,23 +1910,39 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 				imports: aliasedImports
 			});
 			const propValue = needsValueImport ? alias : constLiteral ?? alias;
-			acc.value += `\n  ${doc ? `${doc}  ` : ""}${isReadOnly && !context.output.override.suppressReadonlyModifier ? "readonly " : ""}${getKey(key)}${isRequired ? "" : "?"}: ${propValue};`;
+			const finalPropValue = isRequired ? propValue : context.output.override.useNullForOptional === true ? `${propValue} | null` : propValue;
+			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) {
-					const keyType$1 = getIndexSignatureKey(item);
-					if (isBoolean(item.additionalProperties)) acc.value += `\n  [key: ${keyType$1}]: unknown;\n }`;
-					else {
-						const resolvedValue$1 = resolveValue({
-							schema: item.additionalProperties,
-							name,
-							context
-						});
+				if (item.additionalProperties) if (isBoolean(item.additionalProperties)) {
+					const recordType$1 = getPropertyNamesRecordType(item, "unknown");
+					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}]: unknown;\n }`;
+					}
+				} else {
+					const resolvedValue$1 = resolveValue({
+						schema: item.additionalProperties,
+						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.dependencies.push(...resolvedValue$1.dependencies);
+				}
+				else acc.value += "\n}";
 				acc.value += nullable;
 			}
 			return acc;
@@ -1664,40 +1955,68 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 			isRef: false,
 			schema: {},
 			hasReadonlyProps: false,
+			useTypeAlias: false,
 			dependencies: [],
 			example: item.example,
 			examples: resolveExampleRefs(item.examples, context)
 		});
 	}
 	if (item.additionalProperties) {
-		const keyType$1 = getIndexSignatureKey(item);
-		if (isBoolean(item.additionalProperties)) return {
-			value: `{ [key: ${keyType$1}]: unknown }` + nullable,
-			imports: [],
-			schemas: [],
-			isEnum: false,
-			type: "object",
-			isRef: false,
-			hasReadonlyProps: item.readOnly || false,
-			dependencies: []
-		};
+		if (isBoolean(item.additionalProperties)) {
+			const recordType$2 = getPropertyNamesRecordType(item, "unknown");
+			if (recordType$2) return {
+				value: recordType$2 + nullable,
+				imports: [],
+				schemas: [],
+				isEnum: false,
+				type: "object",
+				isRef: false,
+				hasReadonlyProps: item.readOnly || false,
+				useTypeAlias: true,
+				dependencies: []
+			};
+			return {
+				value: `{ [key: ${getIndexSignatureKey(item)}]: unknown }` + nullable,
+				imports: [],
+				schemas: [],
+				isEnum: false,
+				type: "object",
+				isRef: false,
+				hasReadonlyProps: item.readOnly || false,
+				useTypeAlias: false,
+				dependencies: []
+			};
+		}
 		const resolvedValue = resolveValue({
 			schema: item.additionalProperties,
 			name,
 			context
 		});
-		return {
-			value: `{[key: ${keyType$1}]: ${resolvedValue.value}}` + nullable,
+		const recordType$1 = getPropertyNamesRecordType(item, resolvedValue.value);
+		if (recordType$1) return {
+			value: recordType$1 + nullable,
 			imports: resolvedValue.imports ?? [],
 			schemas: resolvedValue.schemas ?? [],
 			isEnum: false,
 			type: "object",
 			isRef: false,
 			hasReadonlyProps: resolvedValue.hasReadonlyProps,
+			useTypeAlias: true,
 			dependencies: resolvedValue.dependencies
 		};
-	}
-	const itemWithConst = item;
+		return {
+			value: `{[key: ${getIndexSignatureKey(item)}]: ${resolvedValue.value}}` + nullable,
+			imports: resolvedValue.imports ?? [],
+			schemas: resolvedValue.schemas ?? [],
+			isEnum: false,
+			type: "object",
+			isRef: false,
+			hasReadonlyProps: resolvedValue.hasReadonlyProps,
+			useTypeAlias: false,
+			dependencies: resolvedValue.dependencies
+		};
+	}
+	const itemWithConst = item;
 	if (itemWithConst.const) return {
 		value: `'${itemWithConst.const}'`,
 		imports: [],
@@ -1709,6 +2028,18 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 		dependencies: []
 	};
 	const keyType = item.type === "object" ? getIndexSignatureKey(item) : "string";
+	const recordType = getPropertyNamesRecordType(item, "unknown");
+	if (item.type === "object" && recordType) return {
+		value: recordType + nullable,
+		imports: [],
+		schemas: [],
+		isEnum: false,
+		type: "object",
+		isRef: false,
+		hasReadonlyProps: item.readOnly || false,
+		useTypeAlias: true,
+		dependencies: []
+	};
 	return {
 		value: (item.type === "object" ? `{ [key: ${keyType}]: unknown }` : "unknown") + nullable,
 		imports: [],
@@ -1717,490 +2048,310 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 		type: "object",
 		isRef: false,
 		hasReadonlyProps: item.readOnly || 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;
+//#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, formDataContext }) {
+	const nullable = isArray(item.type) && item.type.includes("null") || item.nullable === true ? " | null" : "";
+	const enumItems = item.enum?.filter((enumItem) => enumItem !== null);
+	let itemType = item.type;
+	if (!itemType && item.items) {
+		item.type = "array";
+		itemType = "array";
 	}
-	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
-				}],
+	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",
 				schemas: [],
-				type: "unknown",
+				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",
 				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
-			}];
+				imports: [],
+				isRef: false,
+				hasReadonlyProps: item.readOnly || false,
+				dependencies: [],
+				example: item.example,
+				examples: resolveExampleRefs(item.examples, context)
+			};
 		}
-		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,
+		case "array": {
+			const { value, ...rest } = getArray({
+				schema: item,
+				name,
 				context,
-				isFormData,
-				contentType
+				formDataContext
 			});
-			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)
+			return {
+				value: value + nullable,
+				...rest,
+				dependencies: rest.dependencies ?? []
 			};
-			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
-			});
+		}
+		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";
+			else if (formDataContext?.atPart) {
+				const fileType = getFormDataFieldFileType(item, formDataContext.partContentType);
+				if (fileType) value = fileType === "binary" ? "Blob" : "Blob | string";
+			}
+			if (context.output.override.useDates && (item.format === "date" || item.format === "date-time")) value = "Date";
+			value += nullable;
+			const itemWithConst = item;
+			if (itemWithConst.const) value = `'${itemWithConst.const}'`;
 			return {
-				...resolvedValue,
-				imports: [...resolvedValue.imports, ...additionalImports],
-				formData,
-				formUrlEncoded,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
+				value,
+				isEnum,
+				type: "string",
+				imports: [],
+				schemas: [],
+				isRef: false,
+				hasReadonlyProps: item.readOnly || false,
+				dependencies: [],
+				example: item.example,
+				examples: resolveExampleRefs(item.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,
+		}
+		case "null": return {
+			value: "null",
+			isEnum: false,
+			type: "null",
 			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";
-}
-/**
-* Resolve form-data root object with file type overrides.
-* Returns undefined if no file type overrides needed (caller should use normal resolution).
-*/
-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"
+			hasReadonlyProps: item.readOnly || false,
+			dependencies: []
 		};
-	}
-	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 (schema.properties) {
-			const formDataValues = resolveSchemaPropertiesToFormData({
-				schema,
-				variableName,
-				propName,
+		case "object":
+		default: {
+			if (isArray(itemType)) return combineSchemas({
+				schema: { anyOf: itemType.map((type) => ({
+					...item,
+					type
+				})) },
+				name,
+				separator: "anyOf",
 				context,
-				isRequestBodyOptional,
-				encoding
+				nullable
 			});
-			form += formDataValues;
+			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)
+			};
+			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
+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("' | '")}'>`;
 		}
-		return `${form}${propName}.forEach(value => ${variableName}.append('data', ${valueStr}))\n`;
+		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;
 	}
-	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 }) {
-	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()";
+	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]);
+				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 isRequired = schema.required?.includes(key) && !isRequestBodyOptional;
-		if (property.nullable || property.type?.includes("null") || existSubSchemaNullable) {
-			if (isRequired) return acc + `if(${valueKey} !== null) {\n ${formDataValue} }\n`;
-			return acc + `if(${valueKey} !== undefined && ${nonOptionalValueKey} !== null) {\n ${formDataValue} }\n`;
+			const 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("; ")}}` : ""}`);
 		}
-		if (isRequired) return acc + formDataValue;
-		return acc + `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
-	}, "");
+	}
+	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
+	return values.join(" | ");
 }
-
-//#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
+function combineSchemas({ name, schema, separator: separator$1, context, nullable, formDataContext }) {
+	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 (separator$1 === "allOf" && isSchema(subSchema) && subSchema.required) acc.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
+		});
+		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)
+		};
+	}
+	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: ""
 		});
-		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
+		}) + 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)
 	};
 }
 
@@ -2240,7 +2391,7 @@ function resolveDiscriminators(schemas, context) {
 //#endregion
 //#region src/getters/operation.ts
 function getOperationId(operation, route, verb) {
-	if (operation.operationId) return operation.operationId;
+	if (isString(operation.operationId)) return operation.operationId;
 	return pascal([verb, ...route.split("/").map((p) => sanitize(p, {
 		dash: true,
 		underscore: "-",
@@ -2331,10 +2482,10 @@ function getParams({ route, pathParams = [], operationId, context, output }) {
 function getProps({ body, queryParams, params, operationName, headers, context }) {
 	const bodyProp = {
 		name: body.implementation,
-		definition: `${body.implementation}${body.isOptional ? "?" : ""}: ${body.definition}`,
-		implementation: `${body.implementation}${body.isOptional ? "?" : ""}: ${body.definition}`,
+		definition: `${body.implementation}${body.isOptional && !context.output.optionsParamRequired ? "?" : ""}: ${body.definition}`,
+		implementation: `${body.implementation}${body.isOptional && !context.output.optionsParamRequired ? "?" : ""}: ${body.definition}`,
 		default: false,
-		required: !body.isOptional,
+		required: !body.isOptional || context.output.optionsParamRequired,
 		type: GetterPropType.BODY
 	};
 	const queryParamsProp = {
@@ -2342,15 +2493,15 @@ 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 : !queryParams?.isOptional && !context.output.allParamsOptional,
+		required: isUndefined(queryParams?.isOptional) ? !context.output.allParamsOptional || context.output.optionsParamRequired : !queryParams?.isOptional && !context.output.allParamsOptional || context.output.optionsParamRequired,
 		type: GetterPropType.QUERY_PARAM
 	};
 	const headersProp = {
 		name: "headers",
-		definition: `headers${headers?.isOptional ? "?" : ""}: ${headers?.schema.name}`,
-		implementation: `headers${headers?.isOptional ? "?" : ""}: ${headers?.schema.name}`,
+		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,
+		required: isUndefined(headers?.isOptional) ? false : !headers?.isOptional || context.output.optionsParamRequired,
 		type: GetterPropType.HEADER
 	};
 	let paramGetterProps;
@@ -2358,7 +2509,7 @@ function getProps({ body, queryParams, params, operationName, headers, context }
 		const parameterTypeName = `${pascal(operationName)}PathParameters`;
 		const name = "pathParams";
 		const namedParametersTypeDefinition = `export type ${parameterTypeName} = {\n ${params.map((property) => property.definition).join(",\n    ")},\n }`;
-		const isOptional = params.every((param) => param.default);
+		const isOptional = context.output.optionsParamRequired || params.every((param) => param.default);
 		const implementation = `{ ${params.map((property) => property.default ? `${property.name} = ${property.default}` : property.name).join(", ")} }: ${parameterTypeName}${isOptional ? " = {}" : ""}`;
 		const destructured = `{ ${params.map((property) => property.name).join(", ")} }`;
 		paramGetterProps = [{
@@ -2389,7 +2540,7 @@ function getProps({ body, queryParams, params, operationName, headers, context }
 function getQueryParamDefinition(queryParams, context) {
 	let paramType = queryParams?.schema.name;
 	if (OutputClient.ANGULAR === context.output.client) paramType = `DeepNonNullable<${paramType}>`;
-	return `params${queryParams?.isOptional || context.output.allParamsOptional ? "?" : ""}: ${paramType}`;
+	return `params${(queryParams?.isOptional || context.output.allParamsOptional) && !context.output.optionsParamRequired ? "?" : ""}: ${paramType}`;
 }
 
 //#endregion
@@ -2498,8 +2649,8 @@ function getResponse({ responses, operationName, context, contentType }) {
 		success: [],
 		errors: []
 	});
-	const success = groupedByStatus.success.map(({ value, formData }) => formData ? "Blob" : value).join(" | ");
-	const errors = groupedByStatus.errors.map(({ value }) => value).join(" | ");
+	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;
 	return {
 		imports,
@@ -3043,10 +3194,11 @@ function generateInterface({ name, schema, context }) {
 		context
 	});
 	const isEmptyObject = scalar.value === "{}";
+	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" && !context?.output.override?.useTypeOverInterfaces) if (scalar.type === "object" && schema.properties && Object.values(schema.properties).length > 0 && Object.values(schema.properties).every((item) => "const" in item)) {
+	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 {
@@ -3198,7 +3350,7 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 async function generateVerbOptions({ verb, output, operation, route, pathRoute, verbParameters = [], context }) {
 	const { responses, requestBody, parameters: operationParameters, tags = [], deprecated, description, summary } = operation;
 	const operationId = getOperationId(operation, route, verb);
-	const overrideOperation = output.override.operations[operation.operationId];
+	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);
 	const overrideOperationName = overrideOperation?.operationName ?? output.override.operationName;
@@ -3518,7 +3670,13 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		const ext = fileExtension.endsWith(".ts") ? fileExtension.slice(0, -3) : fileExtension;
 		const conventionNamesSet = new Set(Object.values(schemaGroups).map((group) => conventionName(group[0].name, namingConvention)));
 		try {
-			const fileContent = `${header}\n${[...conventionNamesSet].map((schemaName) => `export * from './${schemaName}${ext}';`).toSorted((a, b) => a.localeCompare(b)).join("\n")}`;
+			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;
+				return `export * from '${match[1]}';`;
+			}).filter((statement) => Boolean(statement)) ?? [];
+			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}`);
@@ -4104,5 +4262,5 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema
 }
 
 //#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, 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, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, 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, 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 };
 //# sourceMappingURL=index.mjs.map