@orval/core 8.1.0 → 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`;
@@ -813,9 +866,32 @@ 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());
+	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(" | ");
 }
 
@@ -1060,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
@@ -1085,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];
@@ -1119,7 +1199,8 @@ function resolveValue({ schema, name, context }) {
 		...getScalar({
 			item: schema,
 			name,
-			context
+			context,
+			formDataContext
 		}),
 		originalSchema: schema,
 		isRef: false
@@ -1161,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,
@@ -1199,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;
@@ -1224,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({
@@ -1259,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}[]`}`,
@@ -1288,321 +1374,424 @@ 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 ?? []
-			};
-		}
-		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) 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({
+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,
-			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: ""
+			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: 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) {
@@ -1637,7 +1826,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,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) => ({
@@ -1684,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 += "{";
@@ -1859,485 +2054,304 @@ function getObject({ item, name, context, nullable, propertyOverrides }) {
 }
 
 //#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;
+			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;
 			}
-			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
-			if (!isFormData && !isFormUrlEncoded || !effectivePropName) return {
-				...resolvedValue,
-				imports: resolvedValue.imports,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
+			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 {
+				value,
+				isEnum,
+				type: "string",
+				imports: [],
+				schemas: [],
+				isRef: false,
+				hasReadonlyProps: item.readOnly || false,
+				dependencies: [],
+				example: item.example,
+				examples: resolveExampleRefs(item.examples, context)
 			};
-			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
-				name: effectivePropName,
-				schemaObject: mediaType.schema,
+		}
+		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",
 				context,
-				isRequestBodyOptional: "required" in res && res.required === false,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
-				name: effectivePropName,
-				schemaObject: mediaType.schema,
+				nullable
+			});
+			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,
-				isUrlEncoded: true,
-				isRequestBodyOptional: "required" in res && res.required === false,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const additionalImports = getFormDataAdditionalImports({
-				schemaObject: mediaType.schema,
-				context
+				nullable,
+				formDataContext: formDataContext?.atPart === false || formDataContext?.atPart && hasCombiners ? formDataContext : void 0
 			});
 			return {
-				...resolvedValue,
-				imports: [...resolvedValue.imports, ...additionalImports],
-				formData,
-				formUrlEncoded,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
+				value,
+				...rest
 			};
-		}).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";
-}
-/**
-* 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"
-		};
-	}
-	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,
-				context,
-				isRequestBodyOptional,
-				encoding
-			});
-			form += formDataValues;
+
+//#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;
+		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 === "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()";
+	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("; ")}}` : ""}`);
 		}
-		return `${form}${propName}.forEach(value => ${variableName}.append('data', ${valueStr}))\n`;
 	}
-	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 (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
+	return values.join(" | ");
 }
-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()";
-			}
-			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`;
+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 (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) 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)
 	};
 }