@orval/core 8.12.1 → 8.12.3

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./chunk-BpYLSNr0.mjs";
 import { createRequire } from "node:module";
 import { entries, groupBy, isArray, isBoolean, isBoolean as isBoolean$1, isEmptyish, isFunction, isFunction as isFunction$1, isNullish, isNullish as isNullish$1, isNumber, isString, isString as isString$1, prop, unique, uniqueBy, uniqueWith } from "remeda";
 import { keyword } from "esutils";
-import path from "node:path";
+import nodePath from "node:path";
 import { compare } from "compare-versions";
 import debug from "debug";
 import { pathToFileURL } from "node:url";
@@ -144,7 +144,7 @@ function isReference(obj) {
 	return !isNullish$1(obj) && Object.hasOwn(obj, "$ref");
 }
 function isDirectory(pathValue) {
-	return !path.extname(pathValue);
+	return !nodePath.extname(pathValue);
 }
 function isObject(x) {
 	return Object.prototype.toString.call(x) === "[object Object]";
@@ -507,8 +507,8 @@ async function dynamicImport(toImport, from = process.cwd(), takeDefault = true)
 	if (!toImport) return toImport;
 	try {
 		if (isString(toImport)) {
-			const filePath = path.resolve(from, toImport);
-			const extension = path.extname(filePath);
+			const filePath = nodePath.resolve(from, toImport);
+			const extension = nodePath.extname(filePath);
 			if (TS_MODULE_EXTENSIONS.has(extension)) {
 				const data = await createJiti(from, { interopDefault: true }).import(filePath);
 				if (takeDefault && (isObject(data) || isModule(data)) && data.default) return data.default;
@@ -533,14 +533,14 @@ function getExtension(path) {
 //#region src/utils/file.ts
 function getFileInfo(target = "", { backupFilename = "filename", extension = ".ts" } = {}) {
 	const isDir = isDirectory(target);
-	const filePath = isDir ? path.join(target, backupFilename + extension) : target;
+	const filePath = isDir ? nodePath.join(target, backupFilename + extension) : target;
 	return {
 		path: filePath,
 		pathWithoutExtension: filePath.replace(/\.[^/.]+$/, ""),
 		extension,
 		isDirectory: isDir,
-		dirname: path.dirname(filePath),
-		filename: path.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
+		dirname: nodePath.dirname(filePath),
+		filename: nodePath.basename(filePath, extension.startsWith(".") ? extension : `.${extension}`)
 	};
 }
 async function removeFilesAndEmptyFolders(patterns, dir) {
@@ -754,13 +754,13 @@ function toUnix(value) {
 	return value;
 }
 function join(...args) {
-	return toUnix(path.join(...args.map((a) => toUnix(a))));
+	return toUnix(nodePath.join(...args.map((a) => toUnix(a))));
 }
 /**
 * Behaves exactly like `path.relative(from, to)`, but keeps the first meaningful "./"
 */
 function relativeSafe(from, to) {
-	return normalizeSafe(`./${toUnix(path.relative(toUnix(from), toUnix(to)))}`);
+	return normalizeSafe(`./${toUnix(nodePath.relative(toUnix(from), toUnix(to)))}`);
 }
 function getSchemaFileName(path) {
 	return path.replace(`.${getExtension(path)}`, "").slice(path.lastIndexOf("/") + 1);
@@ -768,13 +768,13 @@ function getSchemaFileName(path) {
 function normalizeSafe(value) {
 	let result;
 	value = toUnix(value);
-	result = toUnix(path.normalize(value));
+	result = toUnix(nodePath.normalize(value));
 	if (value.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
 	else if (value.startsWith("//") && !result.startsWith("//")) result = value.startsWith("//./") ? "//." + result : "/" + result;
 	return result;
 }
 function joinSafe(...values) {
-	let result = toUnix(path.join(...values.map((v) => toUnix(v))));
+	let result = toUnix(nodePath.join(...values.map((v) => toUnix(v))));
 	if (values.length > 0) {
 		const firstValue = toUnix(values[0]);
 		if (firstValue.startsWith("./") && !result.startsWith("./") && !result.startsWith("..")) result = "./" + result;
@@ -805,14 +805,14 @@ function joinSafe(...values) {
 * @returns The relative import path string.
 */
 function getRelativeImportPath(importerFilePath, exporterFilePath, includeFileExtension = false) {
-	if (!path.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
-	if (!path.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
-	const importerDir = path.dirname(importerFilePath);
-	const relativePath = path.relative(importerDir, exporterFilePath);
-	let posixPath = path.posix.join(...relativePath.split(path.sep));
+	if (!nodePath.isAbsolute(importerFilePath)) throw new Error(`'importerFilePath' is not an absolute path. "${importerFilePath}"`);
+	if (!nodePath.isAbsolute(exporterFilePath)) throw new Error(`'exporterFilePath' is not an absolute path. "${exporterFilePath}"`);
+	const importerDir = nodePath.dirname(importerFilePath);
+	const relativePath = nodePath.relative(importerDir, exporterFilePath);
+	let posixPath = nodePath.posix.join(...relativePath.split(nodePath.sep));
 	if (!posixPath.startsWith("./") && !posixPath.startsWith("../")) posixPath = `./${posixPath}`;
 	if (!includeFileExtension) {
-		const ext = path.extname(posixPath);
+		const ext = nodePath.extname(posixPath);
 		if (ext && posixPath.endsWith(ext)) posixPath = posixPath.slice(0, -ext.length);
 	}
 	return posixPath;
@@ -821,20 +821,20 @@ function getRelativeImportPath(importerFilePath, exporterFilePath, includeFileEx
 //#region src/utils/resolve-version.ts
 function resolveInstalledVersion(packageName, fromDir) {
 	try {
-		const require = createRequire(path.join(fromDir, "noop.js"));
+		const require = createRequire(nodePath.join(fromDir, "noop.js"));
 		try {
 			return require(`${packageName}/package.json`).version;
 		} catch (directError) {
 			if (directError instanceof Error && "code" in directError && directError.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
 				const entryPath = require.resolve(packageName);
-				let dir = path.dirname(entryPath);
-				while (dir !== path.parse(dir).root) {
-					const pkgPath = path.join(dir, "package.json");
+				let dir = nodePath.dirname(entryPath);
+				while (dir !== nodePath.parse(dir).root) {
+					const pkgPath = nodePath.join(dir, "package.json");
 					if (existsSync(pkgPath)) {
 						const pkgData = JSON.parse(readFileSync(pkgPath, "utf8"));
 						if (pkgData.name === packageName) return pkgData.version;
 					}
-					dir = path.dirname(dir);
+					dir = nodePath.dirname(dir);
 				}
 				return;
 			}
@@ -1358,1589 +1358,1616 @@ function getRefInfo($ref, context) {
 	};
 }
 //#endregion
-//#region src/resolvers/ref.ts
-const REF_NOT_FOUND_PREFIX = "Oops... 🍻. Ref not found";
-/**
-* Recursively resolves a `$ref` in an OpenAPI document, following
-* nested schema refs and collecting imports along the way.
-*
-* Handles OpenAPI 3.0 `nullable` and 3.1 type-array hints on direct refs.
-*
-* @see https://spec.openapis.org/oas/v3.0.3#reference-object
-* @see https://spec.openapis.org/oas/v3.1.0#reference-object
-*/
-function resolveRef(schema, context, imports = []) {
-	const refPath = "$ref" in schema ? schema.$ref : void 0;
-	const nestedSchema = "schema" in schema ? schema.schema : void 0;
-	if (isObject(nestedSchema) && isReference(nestedSchema) && typeof nestedSchema.$ref === "string") {
-		const resolvedRef = resolveRef(nestedSchema, context, imports);
-		if ("examples" in schema) {
-			const schemaWithExamples = schema;
-			schemaWithExamples.examples = resolveExampleRefs(schemaWithExamples.examples, context);
-		}
-		if ("examples" in resolvedRef.schema) {
-			const resolvedWithExamples = resolvedRef.schema;
-			resolvedWithExamples.examples = resolveExampleRefs(resolvedWithExamples.examples, context);
-		}
-		return {
-			schema: {
-				...schema,
-				schema: resolvedRef.schema
-			},
-			imports: resolvedRef.imports
-		};
-	}
-	if (isDereferenced(schema)) {
-		if ("examples" in schema) {
-			const schemaWithExamples = schema;
-			schemaWithExamples.examples = resolveExampleRefs(schemaWithExamples.examples, context);
-		}
+//#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 {
-			schema,
-			imports
+			...imp,
+			alias: `__${imp.name}`
 		};
-	}
-	if (!refPath) throw new Error(`${REF_NOT_FOUND_PREFIX}: missing $ref`);
-	const { currentSchema, refInfo: { name, originalName } } = getSchema$1(schema, context);
-	if (!currentSchema) throw new Error(`${REF_NOT_FOUND_PREFIX}: ${refPath}`);
-	return resolveRef(currentSchema, { ...context }, [...imports, {
-		name,
-		schemaName: originalName
-	}]);
+	}) : resolvedValue.imports;
 }
-/**
-* Looks up a schema by its `$ref` path in the spec, applying suffix resolution.
-*
-* Preserves OpenAPI 3.0 `nullable` and 3.1 type-array (`["object", "null"]`)
-* hints from the referencing schema onto the resolved target.
-*
-* @see https://spec.openapis.org/oas/v3.0.3#fixed-fields-18 (nullable)
-* @see https://spec.openapis.org/oas/v3.1.0#schema-object (type as array)
-*/
-function getSchema$1(schema, context) {
-	if (!schema.$ref) throw new Error(`${REF_NOT_FOUND_PREFIX}: missing $ref`);
-	const refInfo = getRefInfo(schema.$ref, context);
-	const { refPaths } = refInfo;
-	const schemaByRefPaths = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
-	if (isObject(schemaByRefPaths) && isReference(schemaByRefPaths)) return getSchema$1(schemaByRefPaths, context);
-	let currentSchema = schemaByRefPaths;
-	if (isObject(currentSchema) && "nullable" in schema) {
-		const nullable = schema.nullable;
-		currentSchema = {
-			...currentSchema,
-			nullable
-		};
-	}
-	if (isObject(currentSchema) && "type" in schema && Array.isArray(schema.type)) {
-		const type = schema.type;
-		currentSchema = {
-			...currentSchema,
-			type
-		};
-	}
-	return {
-		currentSchema,
-		refInfo
-	};
+function needCreateImportAlias({ imp, name }) {
+	return !imp.alias && imp.name === name;
 }
-/** Recursively resolves `$ref` entries in an examples array or record. */
-function resolveExampleRefs(examples, context) {
-	if (!examples) return;
-	return Array.isArray(examples) ? examples.map((example) => {
-		if (isObject(example) && isReference(example)) {
-			const { schema } = resolveRef(example, context);
-			return schema.value;
-		}
-		return example;
-	}) : (() => {
-		const result = {};
-		for (const [key, example] of Object.entries(examples)) result[key] = isObject(example) && isReference(example) ? resolveRef(example, context).schema.value : example;
-		return result;
-	})();
+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/resolvers/value.ts
-function resolveValue({ schema, name, context, formDataContext }) {
-	if (isReference(schema)) {
-		const refValue = schema.$ref;
-		const { schema: schemaObject, imports } = resolveRef(schema, context);
-		if (refValue && !isComponentRef(refValue)) {
-			if (context.parents?.includes(refValue)) return {
-				value: "unknown",
-				imports: [],
-				schemas: [],
-				type: "unknown",
-				isEnum: false,
-				originalSchema: schemaObject,
-				hasReadonlyProps: false,
-				isRef: false,
-				dependencies: []
-			};
-			return {
-				...getScalar({
-					item: schemaObject,
-					name,
-					context: {
-						...context,
-						parents: [...context.parents ?? [], refValue]
-					},
-					formDataContext
-				}),
-				originalSchema: schemaObject,
-				isRef: false
-			};
+//#region src/getters/combine.ts
+const mergeableAllOfKeys = new Set([
+	"type",
+	"properties",
+	"required"
+]);
+function isMergeableAllOfObject(schema) {
+	if (isNullish$1(schema.properties)) return false;
+	if (schema.allOf || schema.anyOf || schema.oneOf) return false;
+	if (!isNullish$1(schema.type) && schema.type !== "object") return false;
+	return Object.keys(schema).every((key) => mergeableAllOfKeys.has(key));
+}
+function normalizeAllOfSchema(schema) {
+	const schemaAllOf = schema.allOf;
+	if (!schemaAllOf) return schema;
+	let didMerge = false;
+	const schemaProperties = schema.properties;
+	const schemaRequired = schema.required;
+	const mergedProperties = schemaProperties ? { ...schemaProperties } : {};
+	const mergedRequired = new Set(schemaRequired);
+	const remainingAllOf = [];
+	for (const subSchema of schemaAllOf) {
+		if (isSchema(subSchema) && isMergeableAllOfObject(subSchema)) {
+			didMerge = true;
+			if (subSchema.properties) Object.assign(mergedProperties, subSchema.properties);
+			const subRequired = subSchema.required;
+			if (subRequired) for (const prop of subRequired) mergedRequired.add(prop);
+			continue;
 		}
-		const resolvedImport = imports[0];
-		let hasReadonlyProps = false;
-		const refName = resolvedImport.name;
-		if (!context.parents?.includes(refName)) hasReadonlyProps = getScalar({
-			item: schemaObject,
-			name: refName,
-			context: {
-				...context,
-				parents: [...context.parents ?? [], refName]
-			}
-		}).hasReadonlyProps;
-		const isAnyOfNullable = schemaObject.anyOf?.some((anyOfItem) => !isReference(anyOfItem) && (anyOfItem.type === "null" || Array.isArray(anyOfItem.type) && anyOfItem.type.includes("null")));
-		const schemaType = schemaObject.type;
-		const nullable = Array.isArray(schemaType) && schemaType.includes("null") || schemaObject.nullable === true || isAnyOfNullable ? " | null" : "";
-		return {
-			value: resolvedImport.name + nullable,
-			imports: [{
-				name: resolvedImport.name,
-				schemaName: resolvedImport.schemaName
-			}],
-			type: schemaObject.type ?? "object",
-			schemas: [],
-			isEnum: !!schemaObject.enum,
-			originalSchema: schemaObject,
-			hasReadonlyProps,
-			isRef: true,
-			dependencies: [resolvedImport.name]
-		};
+		remainingAllOf.push(subSchema);
 	}
+	if (!didMerge || remainingAllOf.length === 0) return schema;
 	return {
-		...getScalar({
-			item: schema,
-			name,
-			context,
-			formDataContext
-		}),
-		originalSchema: schema,
-		isRef: false
-	};
-}
-//#endregion
-//#region src/resolvers/object.ts
-/**
-* Wraps inline object type in a type alias.
-* E.g. `{ foo: string }` → value becomes `FooBody`, schema gets `export type FooBody = { foo: string };`
-*/
-function createTypeAliasIfNeeded({ resolvedValue, propName, context }) {
-	if (!propName) return;
-	if (resolvedValue.isEnum || resolvedValue.type !== "object") return;
-	const aliasPattern = context.output.override.aliasCombinedTypes ? String.raw`{|&|\|` : "{";
-	if (!new RegExp(aliasPattern).test(resolvedValue.value)) return;
-	const { originalSchema } = resolvedValue;
-	const doc = jsDoc(originalSchema);
-	const isConstant = "const" in originalSchema;
-	const constantIsString = "type" in originalSchema && (originalSchema.type === "string" || Array.isArray(originalSchema.type) && originalSchema.type.includes("string"));
-	const model = isConstant ? `${doc}export const ${propName} = ${constantIsString ? `'${originalSchema.const}'` : originalSchema.const} as const;\n` : `${doc}export type ${propName} = ${resolvedValue.value};\n`;
-	return {
-		value: propName,
-		imports: [{
-			name: propName,
-			isConstant
-		}],
-		schemas: [...resolvedValue.schemas, {
-			name: propName,
-			model,
-			imports: resolvedValue.imports,
-			dependencies: resolvedValue.dependencies
-		}],
-		isEnum: false,
-		type: "object",
-		isRef: resolvedValue.isRef,
-		hasReadonlyProps: resolvedValue.hasReadonlyProps,
-		dependencies: resolvedValue.dependencies
+		...schema,
+		...Object.keys(mergedProperties).length > 0 && { properties: mergedProperties },
+		...mergedRequired.size > 0 && { required: [...mergedRequired] },
+		...remainingAllOf.length > 0 && { allOf: remainingAllOf }
 	};
 }
-function resolveObjectOriginal({ schema, propName, combined = false, context, formDataContext }) {
-	const resolvedValue = resolveValue({
-		schema,
-		name: propName,
-		context,
-		formDataContext
-	});
-	const aliased = createTypeAliasIfNeeded({
-		resolvedValue,
-		propName,
-		context
-	});
-	if (aliased) return {
-		...aliased,
-		originalSchema: resolvedValue.originalSchema
+function combineValues({ resolvedData, resolvedValue, separator, context, parentSchema }) {
+	if (resolvedData.isEnum.every(Boolean)) return `${resolvedData.values.join(` | `)}${resolvedValue ? ` | ${resolvedValue.value}` : ""}`;
+	if (separator === "allOf") {
+		let resolvedDataValue = resolvedData.values.map((v) => v.includes(" | ") ? `(${v})` : v).join(` & `);
+		if (resolvedData.originalSchema.length > 0 && resolvedValue) {
+			const discriminatedPropertySchemas = resolvedData.originalSchema.filter((s) => {
+				const disc = s?.discriminator;
+				return disc && resolvedValue.value.includes(` ${disc.propertyName}:`);
+			});
+			if (discriminatedPropertySchemas.length > 0) resolvedDataValue = `Omit<${resolvedDataValue}, '${discriminatedPropertySchemas.map((s) => s.discriminator?.propertyName).join("' | '")}'>`;
+		}
+		const resolvedValueStr = resolvedValue?.value.includes(" | ") ? `(${resolvedValue.value})` : resolvedValue?.value;
+		const joined = `${resolvedDataValue}${resolvedValue ? ` & ${resolvedValueStr}` : ""}`;
+		const overrideRequiredProperties = resolvedData.requiredProperties.filter((prop) => !resolvedData.originalSchema.some((schema) => {
+			const props = schema?.properties;
+			const req = schema?.required;
+			return props?.[prop] && req?.includes(prop);
+		}) && !(() => {
+			const parentProps = parentSchema?.properties;
+			const parentReq = parentSchema?.required;
+			return !!(parentProps?.[prop] && parentReq?.includes(prop));
+		})());
+		if (overrideRequiredProperties.length > 0) return `${joined} & Required<Pick<${joined}, '${overrideRequiredProperties.join("' | '")}'>>`;
+		return joined;
+	}
+	let values = resolvedData.values;
+	if (resolvedData.allProperties.length && context.output.unionAddMissingProperties) {
+		values = [];
+		for (let i = 0; i < resolvedData.values.length; i += 1) {
+			const subSchema = resolvedData.originalSchema[i];
+			if (subSchema?.type !== "object" || !subSchema.properties) {
+				values.push(resolvedData.values[i]);
+				continue;
+			}
+			const subSchemaProps = subSchema.properties;
+			const missingProperties = unique(resolvedData.allProperties.filter((p) => !Object.keys(subSchemaProps).includes(p)));
+			values.push(`${resolvedData.values[i]}${missingProperties.length > 0 ? ` & {${missingProperties.map((p) => `${p}?: never`).join("; ")}}` : ""}`);
+		}
+	}
+	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
+	return values.join(" | ");
+}
+function combineSchemas({ name, schema, separator, context, nullable, formDataContext }) {
+	const normalizedSchema = separator === "allOf" && !context.output.override.aliasCombinedTypes && !schema.oneOf && !schema.anyOf ? normalizeAllOfSchema(schema) : schema;
+	const items = normalizedSchema[separator] ?? [];
+	const resolvedData = {
+		values: [],
+		imports: [],
+		schemas: [],
+		isEnum: [],
+		isRef: [],
+		types: [],
+		dependencies: [],
+		originalSchema: [],
+		allProperties: [],
+		hasReadonlyProps: false,
+		example: schema.example,
+		examples: resolveExampleRefs(schema.examples, context),
+		requiredProperties: separator === "allOf" ? schema.required ?? [] : []
 	};
-	if (propName && resolvedValue.isEnum && !combined && !resolvedValue.isRef) {
-		const doc = jsDoc(resolvedValue.originalSchema);
-		const enumValue = getEnum(resolvedValue.value, propName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
+	for (const subSchema of items) {
+		let propName;
+		if (context.output.override.aliasCombinedTypes) {
+			propName = name ? name + pascal(separator) : void 0;
+			if (propName && resolvedData.schemas.length > 0) propName = propName + pascal(getNumberWord(resolvedData.schemas.length + 1));
+		}
+		if (separator === "allOf" && isSchema(subSchema) && subSchema.required) resolvedData.requiredProperties.push(...subSchema.required);
+		const resolvedValue = resolveObject({
+			schema: subSchema,
+			propName,
+			combined: true,
+			context,
+			formDataContext
+		});
+		const aliasedImports = getAliasedImports({
+			context,
+			name,
+			resolvedValue
+		});
+		const value = getImportAliasForRefOrValue({
+			context,
+			resolvedValue,
+			imports: aliasedImports
+		});
+		resolvedData.values.push(value);
+		resolvedData.imports.push(...aliasedImports);
+		resolvedData.schemas.push(...resolvedValue.schemas);
+		resolvedData.dependencies.push(...resolvedValue.dependencies);
+		resolvedData.isEnum.push(resolvedValue.isEnum);
+		resolvedData.types.push(resolvedValue.type);
+		resolvedData.isRef.push(resolvedValue.isRef);
+		resolvedData.originalSchema.push(resolvedValue.originalSchema);
+		if (resolvedValue.hasReadonlyProps) resolvedData.hasReadonlyProps = true;
+		const originalProps = resolvedValue.originalSchema.properties;
+		if (resolvedValue.type === "object" && originalProps) resolvedData.allProperties.push(...Object.keys(originalProps));
+	}
+	if (resolvedData.isEnum.every(Boolean) && name && items.length > 1 && context.output.override.enumGenerationType !== EnumGeneration.UNION) {
+		const { value: combinedEnumValue, valueImports, hasNull } = getCombinedEnumValue(resolvedData.values.map((value, index) => ({
+			value,
+			isRef: resolvedData.isRef[index],
+			schema: resolvedData.originalSchema[index]
+		})));
+		const newEnum = `export const ${pascal(name)} = ${combinedEnumValue}`;
+		const valueImportSet = new Set(valueImports);
+		const typeSuffix = `${nullable}${hasNull && !nullable.includes("null") ? " | null" : ""}`;
 		return {
-			value: propName,
-			imports: [{ name: propName }],
-			schemas: [...resolvedValue.schemas, {
-				name: propName,
-				model: doc + enumValue,
-				imports: resolvedValue.imports,
-				dependencies: resolvedValue.dependencies
+			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: "enum",
-			originalSchema: resolvedValue.originalSchema,
-			isRef: resolvedValue.isRef,
-			hasReadonlyProps: resolvedValue.hasReadonlyProps,
-			dependencies: [...resolvedValue.dependencies, propName]
+			type: "object",
+			isRef: false,
+			hasReadonlyProps: resolvedData.hasReadonlyProps,
+			dependencies: resolvedData.dependencies,
+			example: schema.example,
+			examples: resolveExampleRefs(schema.examples, context)
 		};
 	}
-	return resolvedValue;
-}
-const resolveObjectCacheMap = /* @__PURE__ */ new Map();
-function resolveObject({ schema, propName, combined = false, context, formDataContext }) {
-	const hashKey = JSON.stringify({
-		schema,
-		propName,
-		combined,
-		projectName: context.projectName ?? context.output.target,
-		formDataContext
-	});
-	if (resolveObjectCacheMap.has(hashKey)) return resolveObjectCacheMap.get(hashKey);
-	const result = resolveObjectOriginal({
-		schema,
-		propName,
-		combined,
+	let resolvedValue;
+	const normalizedProperties = normalizedSchema.properties;
+	const schemaOneOf = schema.oneOf;
+	const schemaAnyOf = schema.anyOf;
+	if (normalizedProperties) resolvedValue = getScalar({
+		item: Object.fromEntries(Object.entries(normalizedSchema).filter(([key]) => key !== separator)),
+		name,
 		context,
 		formDataContext
 	});
-	resolveObjectCacheMap.set(hashKey, result);
-	return result;
-}
-//#endregion
-//#region src/getters/array.ts
-/**
-* Return the output type from an array
-*
-* @param item item with type === "array"
-*/
-function getArray({ schema, name, context, formDataContext }) {
-	const schemaPrefixItems = schema.prefixItems;
-	const schemaItems = schema.items;
-	const schemaExample = schema.example;
-	const schemaExamples = schema.examples;
-	const itemSuffix = context.output.override.components.schemas.itemSuffix;
-	if (schemaPrefixItems) {
-		const resolvedObjects = schemaPrefixItems.map((item, index) => resolveObject({
-			schema: item,
-			propName: name ? name + itemSuffix + String(index) : void 0,
-			context
-		}));
-		if (schemaItems) {
-			const additional = resolveObject({
-				schema: schemaItems,
-				propName: name ? name + itemSuffix + "Additional" : void 0,
-				context
-			});
-			resolvedObjects.push({
-				...additional,
-				value: `...${additional.value}[]`
-			});
-		}
-		return {
-			type: "array",
-			isEnum: false,
-			isRef: false,
-			value: `[${resolvedObjects.map((o) => o.value).join(", ")}]`,
-			imports: resolvedObjects.flatMap((o) => o.imports),
-			schemas: resolvedObjects.flatMap((o) => o.schemas),
-			dependencies: resolvedObjects.flatMap((o) => o.dependencies),
-			hasReadonlyProps: resolvedObjects.some((o) => o.hasReadonlyProps),
-			example: schemaExample,
-			examples: resolveExampleRefs(schemaExamples, context)
-		};
-	}
-	if (schemaItems) {
-		const resolvedObject = resolveObject({
-			schema: schemaItems,
-			propName: name ? name + itemSuffix : void 0,
+	else if (separator === "allOf" && (schemaOneOf || schemaAnyOf)) {
+		const siblingCombiner = schemaOneOf ? "oneOf" : "anyOf";
+		const siblingSchemas = schemaOneOf ?? schemaAnyOf;
+		resolvedValue = combineSchemas({
+			schema: { [siblingCombiner]: siblingSchemas },
+			name,
+			separator: siblingCombiner,
 			context,
-			formDataContext
+			nullable: ""
 		});
-		return {
-			value: `${schema.readOnly === true && !context.output.override.suppressReadonlyModifier ? "readonly " : ""}${resolvedObject.value.includes("|") || resolvedObject.value.includes("&") ? `(${resolvedObject.value})[]` : `${resolvedObject.value}[]`}`,
-			imports: resolvedObject.imports,
-			schemas: resolvedObject.schemas,
-			dependencies: resolvedObject.dependencies,
-			isEnum: false,
-			type: "array",
-			isRef: false,
-			hasReadonlyProps: resolvedObject.hasReadonlyProps,
-			example: schemaExample,
-			examples: resolveExampleRefs(schemaExamples, context)
-		};
-	} else if (compareVersions(context.spec.openapi ?? "3.0.0", "3.1", ">=")) return {
-		value: "unknown[]",
-		imports: [],
-		schemas: [],
-		dependencies: [],
+	}
+	return {
+		value: dedupeUnionType(combineValues({
+			resolvedData,
+			separator,
+			resolvedValue,
+			context,
+			parentSchema: normalizedSchema
+		}) + nullable),
+		imports: resolvedValue ? [...resolvedData.imports, ...resolvedValue.imports] : resolvedData.imports,
+		schemas: resolvedValue ? [...resolvedData.schemas, ...resolvedValue.schemas] : resolvedData.schemas,
+		dependencies: resolvedValue ? [...resolvedData.dependencies, ...resolvedValue.dependencies] : resolvedData.dependencies,
 		isEnum: false,
-		type: "array",
+		type: "object",
 		isRef: false,
-		hasReadonlyProps: false
+		hasReadonlyProps: resolvedData.hasReadonlyProps || (resolvedValue?.hasReadonlyProps ?? false),
+		example: schema.example,
+		examples: resolveExampleRefs(schema.examples, context)
 	};
-	else throw new Error(`All arrays must have an \`items\` key defined (name=${name}, schema=${JSON.stringify(schema)})`);
 }
 //#endregion
-//#region src/getters/res-req-types.ts
-const getSchemaType$1 = (s) => s.type;
-const getSchemaCombined = (s) => s.oneOf ?? s.anyOf ?? s.allOf;
-const getSchemaOneOf = (s) => s.oneOf;
-const getSchemaAnyOf = (s) => s.anyOf;
-const getSchemaItems = (s) => s.items;
-const getSchemaRequired = (s) => s.required;
-const getSchemaProperties = (s) => s.properties;
-const resolveSchemaRef = (schema, context) => resolveRef(schema, context);
-const resolveResponseOrRequestRef = (schema, context) => resolveRef(schema, context);
-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 isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
-	const formDataContext = isFormData ? {
-		atPart: false,
-		encoding: mediaType.encoding ?? {}
-	} : isFormUrlEncoded ? {
-		atPart: false,
-		encoding: mediaType.encoding ?? {},
-		urlEncoded: true
-	} : void 0;
-	const resolvedObject = resolveObject({
-		schema: mediaType.schema,
-		propName,
-		context,
-		formDataContext
+//#region src/getters/keys.ts
+function getKey(key) {
+	return keyword.isIdentifierNameES5(key) ? key : `'${key}'`;
+}
+//#endregion
+//#region src/getters/object.ts
+function getPropertyNamesEnumKeyType(item) {
+	if (!("propertyNames" in item) || !item.propertyNames) return;
+	const propertyNames = item.propertyNames;
+	if (Array.isArray(propertyNames.enum)) {
+		const enumValues = propertyNames.enum.filter((val) => isString(val));
+		if (enumValues.length > 0) return {
+			value: enumValues.map((val) => `'${escape(val)}'`).join(" | "),
+			imports: [],
+			dependencies: []
+		};
+	}
+	if (isString(propertyNames.const)) return {
+		value: `'${escape(propertyNames.const)}'`,
+		imports: [],
+		dependencies: []
+	};
+}
+/**
+* Resolve a narrowed key type from OpenAPI 3.1 propertyNames.
+* Supports inline enum/const and $ref string enums.
+*/
+function getPropertyNamesKeyType(item, context) {
+	const inlineKeyType = getPropertyNamesEnumKeyType(item);
+	if (inlineKeyType) return inlineKeyType;
+	const propertyNames = item.propertyNames;
+	if (!propertyNames || !isReference(propertyNames)) return;
+	const resolvedValue = resolveValue({
+		schema: propertyNames,
+		context
 	});
-	if (!isFormData && isBinaryContentType(contentType)) return {
-		...resolvedObject,
-		value: "Blob"
+	const resolvedConst = resolvedValue.originalSchema.const;
+	const isStringConst = resolvedValue.type === "string" && isString(resolvedConst);
+	if (!resolvedValue.isEnum && !isStringConst) return;
+	return {
+		value: resolvedValue.value,
+		imports: resolvedValue.imports,
+		dependencies: resolvedValue.dependencies
 	};
-	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, schemaName }] } = resolveResponseOrRequestRef(res, context);
-			const firstEntry = Object.entries(bodySchema.content ?? {}).at(0);
-			if (!firstEntry) return [{
-				value: name,
-				imports: [{
-					name,
-					schemaName
-				}],
-				schemas: [],
-				type: "unknown",
-				isEnum: false,
-				isRef: true,
-				hasReadonlyProps: false,
-				dependencies: [name],
-				originalSchema: void 0,
-				example: void 0,
-				examples: void 0,
-				key,
-				contentType: ""
-			}];
-			const [contentType, mediaType] = firstEntry;
-			const isFormData = formDataContentTypes.has(contentType);
-			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
-			if (!isFormData && !isFormUrlEncoded || !mediaType.schema) return [{
-				value: name,
-				imports: [{
-					name,
-					schemaName
-				}],
-				schemas: [],
-				type: "unknown",
-				isEnum: false,
-				isRef: true,
-				hasReadonlyProps: false,
-				dependencies: [name],
-				originalSchema: mediaType.schema,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context),
-				key,
-				contentType
-			}];
-			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
-				name,
-				schemaObject: mediaType.schema,
+/**
+* Generate index signature key type based on propertyNames enum or const
+* Returns union type string like "'foo' | 'bar'", "'x'", or 'string' if neither
+*/
+function getIndexSignatureKey(item) {
+	return getPropertyNamesEnumKeyType(item)?.value ?? "string";
+}
+function getPropertyNamesRecordType(item, valueType, context) {
+	const keyType = getPropertyNamesKeyType(item, context);
+	if (!keyType) return;
+	return {
+		...keyType,
+		value: `Partial<Record<${keyType.value}, ${valueType}>>`
+	};
+}
+/**
+* Return the output type from an object
+*
+* @param item item with type === "object"
+*/
+function getObject({ item, name, context, nullable, formDataContext }) {
+	if (isReference(item)) {
+		const { name } = getRefInfo(item.$ref, context);
+		return {
+			value: name + nullable,
+			imports: [{ name }],
+			schemas: [],
+			isEnum: false,
+			type: "object",
+			isRef: true,
+			hasReadonlyProps: item.readOnly ?? false,
+			dependencies: [name],
+			example: item.example,
+			examples: resolveExampleRefs(item.examples, context)
+		};
+	}
+	const schemaItem = item;
+	const itemAllOf = schemaItem.allOf;
+	const itemOneOf = schemaItem.oneOf;
+	const itemAnyOf = schemaItem.anyOf;
+	const itemType = schemaItem.type;
+	if (itemAllOf || itemOneOf || itemAnyOf) return combineSchemas({
+		schema: schemaItem,
+		name,
+		separator: itemAllOf ? "allOf" : itemOneOf ? "oneOf" : "anyOf",
+		context,
+		nullable,
+		formDataContext
+	});
+	if (Array.isArray(itemType)) {
+		const typeArray = itemType;
+		const baseItem = schemaItem;
+		return combineSchemas({
+			schema: { anyOf: typeArray.map((type) => ({
+				...baseItem,
+				type
+			})) },
+			name,
+			separator: "anyOf",
+			context,
+			nullable
+		});
+	}
+	const itemProperties = schemaItem.properties;
+	if (itemProperties && Object.entries(itemProperties).length > 0) {
+		const entries = Object.entries(itemProperties);
+		if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries.sort((a, b) => {
+			return a[0].localeCompare(b[0], "en", { numeric: true });
+		});
+		const acc = {
+			imports: [],
+			schemas: [],
+			value: "",
+			isEnum: false,
+			type: "object",
+			isRef: false,
+			hasReadonlyProps: false,
+			useTypeAlias: false,
+			dependencies: [],
+			example: schemaItem.example,
+			examples: resolveExampleRefs(schemaItem.examples, context)
+		};
+		const itemRequired = schemaItem.required;
+		for (const [index, [key, schema]] of entries.entries()) {
+			const isRequired = (Array.isArray(itemRequired) ? itemRequired : []).includes(key);
+			let propName = "";
+			if (name) {
+				const isKeyStartWithUnderscore = key.startsWith("_");
+				propName += pascal(`${isKeyStartWithUnderscore ? "_" : ""}${name}_${key}`);
+			}
+			const allSpecSchemas = context.spec.components?.schemas ?? {};
+			if (Object.keys(allSpecSchemas).some((schemaName) => pascal(schemaName) === propName)) propName = propName + "Property";
+			const propertyFormDataContext = formDataContext && !formDataContext.atPart ? {
+				atPart: true,
+				partContentType: formDataContext.encoding[key]?.contentType,
+				urlEncoded: formDataContext.urlEncoded
+			} : void 0;
+			const resolvedValue = resolveObject({
+				schema,
+				propName,
 				context,
-				isRequestBodyOptional: bodySchema.required !== true,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
+				formDataContext: propertyFormDataContext
+			});
+			const isReadOnly = Boolean(schemaItem.readOnly) || Boolean(schema.readOnly);
+			if (!index) acc.value += "{";
+			const doc = jsDoc(schema, true, context);
+			const propertyDoc = doc ? `${doc.trimEnd().split("\n").map((line) => `  ${line}`).join("\n")}\n` : "";
+			if (isReadOnly || resolvedValue.hasReadonlyProps) acc.hasReadonlyProps = true;
+			const constValue = "const" in schema ? schema.const : void 0;
+			const hasConst = constValue !== void 0;
+			let constLiteral;
+			if (!hasConst) constLiteral = void 0;
+			else if (isString(constValue)) constLiteral = `'${escape(constValue)}'`;
+			else constLiteral = JSON.stringify(constValue);
+			const needsValueImport = hasConst && (resolvedValue.isEnum || resolvedValue.type === "enum");
+			const usedResolvedValue = !hasConst || needsValueImport;
+			const aliasedImports = needsValueImport ? resolvedValue.imports.map((imp) => ({
+				...imp,
+				isConstant: true
+			})) : hasConst ? [] : getAliasedImports({
 				name,
-				schemaObject: mediaType.schema,
 				context,
-				isRequestBodyOptional: bodySchema.required !== true,
-				isUrlEncoded: true,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const additionalImports = getFormDataAdditionalImports({
-				schemaObject: mediaType.schema,
-				context
+				resolvedValue
 			});
-			return [{
-				value: name,
-				imports: [{
-					name,
-					schemaName
-				}, ...additionalImports],
-				schemas: [],
-				type: "unknown",
-				isEnum: false,
-				hasReadonlyProps: false,
-				dependencies: [name],
-				formData,
-				formUrlEncoded,
-				isRef: true,
-				originalSchema: mediaType.schema,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context),
-				key,
-				contentType
-			}];
-		}
-		if (res.content) return Object.entries(res.content).map(([contentType, mediaType], index, arr) => {
-			let propName = key ? pascal(name) + pascal(key) : void 0;
-			if (propName && arr.length > 1) propName = propName + pascal(getNumberWord(index + 1));
-			const isFormData = formDataContentTypes.has(contentType);
-			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
-			let effectivePropName = propName;
-			if (mediaType.schema && isReference(mediaType.schema)) {
-				const { imports } = resolveSchemaRef(mediaType.schema, context);
-				if (imports[0]?.name) effectivePropName = imports[0].name;
-			} else if ((isFormData || isFormUrlEncoded) && mediaType.schema) {
-				const combinedRefs = getSchemaOneOf(mediaType.schema) ?? getSchemaAnyOf(mediaType.schema);
-				if (combinedRefs) {
-					const names = [];
-					for (const ref of combinedRefs) {
-						if (!isReference(ref)) continue;
-						const refName = resolveSchemaRef(ref, context).imports[0]?.name;
-						if (refName) names.push(refName);
-					}
-					if (names.length > 0) effectivePropName = names.join("");
-				}
-			}
-			const resolvedValue = getResReqContentTypes({
-				mediaType,
-				propName: effectivePropName,
+			if (aliasedImports.length > 0) acc.imports.push(...aliasedImports);
+			const alias = getImportAliasForRefOrValue({
 				context,
-				isFormData,
-				contentType
+				resolvedValue,
+				imports: aliasedImports
 			});
-			if (!resolvedValue) {
-				if (isBinaryContentType(contentType)) return {
-					value: "Blob",
-					imports: [],
-					schemas: [],
-					type: "Blob",
-					isEnum: false,
-					key,
-					isRef: false,
-					hasReadonlyProps: false,
-					contentType
-				};
-				return;
+			const propValue = needsValueImport ? alias : constLiteral ?? alias;
+			const finalPropValue = isRequired ? propValue : context.output.override.useNullForOptional === true ? `${propValue} | null` : propValue;
+			acc.value += `\n${propertyDoc}${isReadOnly && !context.output.override.suppressReadonlyModifier ? "  readonly " : "  "}${getKey(key)}${isRequired ? "" : "?"}: ${finalPropValue};`;
+			if (usedResolvedValue) {
+				acc.schemas.push(...resolvedValue.schemas);
+				acc.dependencies.push(...resolvedValue.dependencies);
+			}
+			if (entries.length - 1 === index) {
+				const additionalProps = schemaItem.additionalProperties;
+				if (additionalProps) if (additionalProps === true) {
+					const recordType = getPropertyNamesRecordType(schemaItem, "unknown", context);
+					if (recordType) {
+						acc.value += "\n}";
+						acc.value += ` & ${recordType.value}`;
+						acc.useTypeAlias = true;
+						acc.imports.push(...recordType.imports);
+						acc.dependencies.push(...recordType.dependencies);
+					} else {
+						const keyType = getIndexSignatureKey(schemaItem);
+						acc.value += `\n  [key: ${keyType}]: unknown;\n }`;
+					}
+				} else {
+					const resolvedValue = resolveValue({
+						schema: additionalProps,
+						name,
+						context
+					});
+					const recordType = getPropertyNamesRecordType(schemaItem, resolvedValue.value, context);
+					if (recordType) {
+						acc.value += "\n}";
+						acc.value += ` & ${recordType.value}`;
+						acc.useTypeAlias = true;
+						acc.imports.push(...recordType.imports);
+						acc.dependencies.push(...recordType.dependencies);
+					} else {
+						const keyType = getIndexSignatureKey(schemaItem);
+						acc.value += `\n  [key: ${keyType}]: ${resolvedValue.value};\n}`;
+					}
+					acc.imports.push(...resolvedValue.imports);
+					acc.schemas.push(...resolvedValue.schemas);
+					acc.dependencies.push(...resolvedValue.dependencies);
+				}
+				else acc.value += "\n}";
+				acc.value += nullable;
 			}
-			if (!isFormData && !isFormUrlEncoded || !effectivePropName || !mediaType.schema) return {
-				...resolvedValue,
-				imports: resolvedValue.imports,
-				dependencies: resolvedValue.dependencies,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
+		}
+		return acc;
+	}
+	const outerAdditionalProps = schemaItem.additionalProperties;
+	const readOnlyFlag = schemaItem.readOnly;
+	if (outerAdditionalProps) {
+		if (outerAdditionalProps === true) {
+			const recordType = getPropertyNamesRecordType(schemaItem, "unknown", context);
+			if (recordType) return {
+				value: recordType.value + nullable,
+				imports: recordType.imports,
+				schemas: [],
+				isEnum: false,
+				type: "object",
+				isRef: false,
+				hasReadonlyProps: readOnlyFlag ?? false,
+				useTypeAlias: true,
+				dependencies: recordType.dependencies
 			};
-			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
-				name: effectivePropName,
-				schemaObject: mediaType.schema,
-				context,
-				isRequestBodyOptional: res.required !== true,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
-				name: effectivePropName,
-				schemaObject: mediaType.schema,
-				context,
-				isUrlEncoded: true,
-				isRequestBodyOptional: res.required !== true,
-				isRef: true,
-				encoding: mediaType.encoding
-			}) : void 0;
-			const additionalImports = getFormDataAdditionalImports({
-				schemaObject: mediaType.schema,
-				context
-			});
 			return {
-				...resolvedValue,
-				imports: [...resolvedValue.imports, ...additionalImports],
-				formData,
-				formUrlEncoded,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
+				value: `{ [key: ${getIndexSignatureKey(schemaItem)}]: unknown }` + nullable,
+				imports: [],
+				schemas: [],
+				isEnum: false,
+				type: "object",
+				isRef: false,
+				hasReadonlyProps: readOnlyFlag ?? false,
+				useTypeAlias: false,
+				dependencies: []
 			};
-		}).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,
+		}
+		const resolvedValue = resolveValue({
+			schema: outerAdditionalProps,
+			name,
+			context
+		});
+		const recordType = getPropertyNamesRecordType(schemaItem, resolvedValue.value, context);
+		if (recordType) return {
+			value: recordType.value + nullable,
+			imports: [...recordType.imports, ...resolvedValue.imports],
+			schemas: resolvedValue.schemas,
+			isEnum: false,
+			type: "object",
+			isRef: false,
+			hasReadonlyProps: resolvedValue.hasReadonlyProps,
+			useTypeAlias: true,
+			dependencies: [...recordType.dependencies, ...resolvedValue.dependencies]
+		};
+		return {
+			value: `{[key: ${getIndexSignatureKey(schemaItem)}]: ${resolvedValue.value}}` + nullable,
+			imports: resolvedValue.imports,
+			schemas: resolvedValue.schemas,
+			isEnum: false,
+			type: "object",
+			isRef: false,
+			hasReadonlyProps: resolvedValue.hasReadonlyProps,
+			useTypeAlias: false,
+			dependencies: resolvedValue.dependencies
+		};
+	}
+	const constValue = schemaItem.const;
+	if (constValue !== void 0) {
+		let type;
+		if (Array.isArray(constValue)) type = "array";
+		else if (constValue === null) type = "null";
+		else if (typeof constValue === "string") type = "string";
+		else if (typeof constValue === "number") type = "number";
+		else if (typeof constValue === "boolean") type = "boolean";
+		else type = "object";
+		return {
+			value: typeof constValue === "string" ? `'${escape(constValue)}'` : JSON.stringify(constValue),
 			imports: [],
 			schemas: [],
-			type: defaultType,
 			isEnum: false,
-			dependencies: [],
-			key,
+			type,
 			isRef: false,
-			hasReadonlyProps: false,
-			contentType: "application/json"
-		}];
-	}).flat(), uniqueKey);
-}
-/**
-* Determine the responseType option based on success content types only.
-* This avoids error-response content types influencing the responseType.
-*/
-function getSuccessResponseType(response) {
-	const successContentTypes = response.types.success.map((t) => t.contentType).filter(Boolean);
-	if (response.isBlob) return "blob";
-	const hasJsonResponse = successContentTypes.some((contentType) => contentType.includes("json") || contentType.includes("+json"));
-	const hasTextResponse = successContentTypes.some((contentType) => contentType.startsWith("text/") || contentType.includes("xml"));
-	if (!hasJsonResponse && hasTextResponse) return "text";
-}
-/**
-* Determine the response type category for a given content type.
-* Used to set the correct responseType option in HTTP clients.
-*
-* @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";
+			hasReadonlyProps: readOnlyFlag ?? false,
+			dependencies: []
+		};
+	}
+	const keyType = itemType === "object" ? getIndexSignatureKey(schemaItem) : "string";
+	const recordType = getPropertyNamesRecordType(schemaItem, "unknown", context);
+	if (itemType === "object" && recordType) return {
+		value: recordType.value + nullable,
+		imports: recordType.imports,
+		schemas: [],
+		isEnum: false,
+		type: "object",
+		isRef: false,
+		hasReadonlyProps: readOnlyFlag ?? false,
+		useTypeAlias: true,
+		dependencies: recordType.dependencies
+	};
+	return {
+		value: (itemType === "object" ? `{ [key: ${keyType}]: unknown }` : "unknown") + nullable,
+		imports: [],
+		schemas: [],
+		isEnum: false,
+		type: "object",
+		isRef: false,
+		hasReadonlyProps: readOnlyFlag ?? false,
+		useTypeAlias: false,
+		dependencies: []
+	};
 }
+//#endregion
+//#region src/getters/scalar.ts
 /**
-* Get the default content type from a list of content types.
-* Priority: application/json > any JSON-like type > first in list
+* Returns true when a schema describes a raw binary string scalar — i.e. one
+* that getScalar's `case 'string':` branch would coerce to `Blob` outside a
+* url-encoded context (see the formDataContext.urlEncoded gate below). Shared
+* with resolveValue so the component-`$ref` urlEncoded short-circuit and the
+* inline scalar path stay in lockstep when new binary shapes are added
+* (#1624 / #3395 / #2410).
 *
-* @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 } = resolveSchemaRef(schemaObject, context);
-	if (schema.type !== "object") return [];
-	const combinedSchemas = getSchemaOneOf(schema) ?? getSchemaAnyOf(schema);
-	if (!combinedSchemas) return [];
-	return combinedSchemas.map((subSchema) => resolveSchemaRef(subSchema, context).imports[0]).filter(Boolean);
-}
-function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequestBodyOptional, isUrlEncoded, isRef, encoding }) {
-	const { schema, imports } = resolveSchemaRef(schemaObject, context);
-	const propName = camel(!isRef && isReference(schemaObject) ? imports[0].name : name);
-	const variableName = isUrlEncoded ? "formUrlEncoded" : "formData";
-	let form = isUrlEncoded ? `const ${variableName} = new URLSearchParams();\n` : `const ${variableName} = new FormData();\n`;
-	const combinedSchemas = getSchemaCombined(schema);
-	if (schema.type === "object" || schema.type === void 0 && combinedSchemas) {
-		if (combinedSchemas) if (!!getSchemaOneOf(schema) || !!getSchemaAnyOf(schema)) {
-			const directProperties = getSchemaProperties(schema);
-			const directKeys = directProperties ? Object.entries(directProperties).filter(([, value]) => !resolveSchemaRef(value, context).schema.readOnly).map(([key]) => key) : [];
-			const skipLine = directKeys.length > 0 ? `  if ([${directKeys.map((k) => JSON.stringify(k)).join(", ")}].includes(key)) return;\n` : "";
-			form += `Object.entries(${propName} ?? {}).forEach(([key, value]) => {\n`;
-			form += skipLine;
-			form += `  if (value !== undefined && value !== null) {\n`;
-			if (isUrlEncoded) {
-				form += `    if (Array.isArray(value)) {\n`;
-				form += `      value.forEach(v => {\n`;
-				form += `        ${variableName}.append(key, typeof v === 'object' ? JSON.stringify(v) : String(v));\n`;
-				form += `      });\n`;
-				form += `    } else if (typeof value === 'object') {\n`;
-				form += `      ${variableName}.append(key, JSON.stringify(value));\n`;
-				form += `    } else {\n`;
-				form += `      ${variableName}.append(key, String(value));\n`;
-				form += `    }\n`;
-			} else {
-				form += `    if ((typeof File !== 'undefined' && value instanceof File) || value instanceof Blob) {\n`;
-				form += `      ${variableName}.append(key, value);\n`;
-				form += `    } else if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {\n`;
-				form += `      ${variableName}.append(key, new Blob([Uint8Array.from(value)]));\n`;
-				form += `    } else if (Array.isArray(value)) {\n`;
-				form += `      value.forEach(v => {\n`;
-				form += `        if ((typeof File !== 'undefined' && v instanceof File) || v instanceof Blob) {\n`;
-				form += `          ${variableName}.append(key, v);\n`;
-				form += `        } else if (typeof Buffer !== 'undefined' && Buffer.isBuffer(v)) {\n`;
-				form += `          ${variableName}.append(key, new Blob([Uint8Array.from(v)]));\n`;
-				form += `        } else {\n`;
-				form += `          ${variableName}.append(key, typeof v === 'object' ? JSON.stringify(v) : String(v));\n`;
-				form += `        }\n`;
-				form += `      });\n`;
-				form += `    } else if (typeof value === 'object') {\n`;
-				form += `      ${variableName}.append(key, JSON.stringify(value));\n`;
-				form += `    } else {\n`;
-				form += `      ${variableName}.append(key, String(value));\n`;
-				form += `    }\n`;
+* Accepts OAS 3.1 nullable unions (`type: ['string', 'null']`) since getScalar
+* normalizes those into `case 'string':` before invoking this predicate.
+*/
+function isBinaryScalarSchema(schema) {
+	const schemaType = schema.type;
+	if (!(schemaType === "string" || isArray(schemaType) && schemaType.includes("string") && schemaType.every((type) => type === "string" || type === "null"))) return false;
+	if (schema.format === "binary") return true;
+	const contentMediaType = schema.contentMediaType;
+	const contentEncoding = schema.contentEncoding;
+	return contentMediaType === "application/octet-stream" && !contentEncoding;
+}
+/**
+* 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 schemaEnum = item.enum;
+	const schemaType = item.type;
+	const schemaReadOnly = item.readOnly;
+	const schemaExample = item.example;
+	const schemaExamples = item.examples;
+	const schemaConst = item.const;
+	const schemaFormat = item.format;
+	const schemaNullable = item.nullable;
+	const nullable = isArray(schemaType) && schemaType.includes("null") || schemaNullable === true ? " | null" : "";
+	const enumItems = schemaEnum?.filter((enumItem) => enumItem !== null);
+	let itemType = schemaType;
+	if (!itemType && item.items) {
+		item.type = "array";
+		itemType = "array";
+	}
+	if (isArray(schemaType) && schemaType.includes("null")) {
+		const typesWithoutNull = schemaType.filter((x) => x !== "null");
+		itemType = typesWithoutNull.length === 1 ? typesWithoutNull[0] : typesWithoutNull;
+	}
+	switch (itemType) {
+		case "number":
+		case "integer": {
+			let value = context.output.override.useBigInt && (schemaFormat === "int64" || schemaFormat === "uint64") ? "bigint" : "number";
+			let isEnum = false;
+			if (enumItems) {
+				value = enumItems.map((enumItem) => `${enumItem}`).join(" | ");
+				isEnum = true;
 			}
-			form += `  }\n`;
-			form += `});\n`;
-		} else {
-			const combinedSchemasFormData = combinedSchemas.map((subSchema) => {
-				const { schema: combinedSchema } = resolveSchemaRef(subSchema, context);
-				return resolveSchemaPropertiesToFormData({
-					schema: combinedSchema,
-					variableName,
-					propName,
-					context,
-					isRequestBodyOptional,
-					encoding
-				});
-			}).filter(Boolean).join("\n");
-			form += combinedSchemasFormData;
+			value += nullable;
+			if (schemaConst !== void 0) value = schemaConst;
+			return {
+				value,
+				isEnum,
+				type: "number",
+				schemas: [],
+				imports: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
 		}
-		if (schema.properties) {
-			const formDataValues = resolveSchemaPropertiesToFormData({
-				schema,
-				variableName,
-				propName,
+		case "boolean": {
+			let value = "boolean";
+			if (enumItems && !(enumItems.includes(true) && enumItems.includes(false))) value = enumItems.map((enumItem) => `${enumItem}`).join(" | ");
+			value += nullable;
+			if (schemaConst !== void 0) value = schemaConst;
+			return {
+				value,
+				type: "boolean",
+				isEnum: false,
+				schemas: [],
+				imports: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
+		}
+		case "array": {
+			const { value, ...rest } = getArray({
+				schema: item,
+				name,
 				context,
-				isRequestBodyOptional,
-				encoding
+				formDataContext
 			});
-			form += formDataValues;
-		}
-		return form;
-	}
-	if (schema.type === "array") {
-		let valueStr = "value";
-		const schemaItems = getSchemaItems(schema);
-		if (schemaItems) {
-			const { schema: itemSchema } = resolveSchemaRef(schemaItems, context);
-			if (itemSchema.type === "object" || itemSchema.type === "array") valueStr = "JSON.stringify(value)";
-			else if (itemSchema.type === "number" || itemSchema.type === "integer" || itemSchema.type === "boolean") valueStr = "value.toString()";
+			return {
+				value: value + nullable,
+				...rest,
+				dependencies: rest.dependencies
+			};
 		}
-		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`;
-}
-function resolveSchemaPropertiesToFormData({ schema, variableName, propName, context, isRequestBodyOptional, keyPrefix = "", depth = 0, encoding }) {
-	let formDataValues = "";
-	const isUrlEncoded = variableName === "formUrlEncoded";
-	const schemaProps = getSchemaProperties(schema) ?? {};
-	for (const [key, value] of Object.entries(schemaProps)) {
-		const { schema: property } = resolveSchemaRef(value, context);
-		if (property.readOnly) continue;
-		let formDataValue = "";
-		const partContentType = (depth === 0 ? encoding?.[key] : void 0)?.contentType;
-		const formattedKeyPrefix = isRequestBodyOptional ? keyword.isIdentifierNameES5(key) ? "?" : "?." : "";
-		const formattedKey = keyword.isIdentifierNameES5(key) ? `.${key}` : `['${key}']`;
-		const valueKey = `${propName}${formattedKeyPrefix}${formattedKey}`;
-		const nonOptionalValueKey = `${propName}${formattedKey}`;
-		const fileType = getFormDataFieldFileType(property, partContentType);
-		const effectiveContentType = partContentType ?? property.contentMediaType;
-		if (isUrlEncoded && (fileType || property.format === "binary")) formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
-		else 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
-		}) : `${variableName}.append(\`${keyPrefix}${key}\`, JSON.stringify(${nonOptionalValueKey}));\n`;
-		else if (property.type === "array") {
-			let valueStr = "value";
-			let hasNonPrimitiveChild = false;
-			const propertyItems = getSchemaItems(property);
-			if (propertyItems) {
-				const { schema: itemSchema } = resolveSchemaRef(propertyItems, context);
-				if (itemSchema.type === "object" || itemSchema.type === "array") if (context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE) {
-					hasNonPrimitiveChild = true;
-					const resolvedValue = resolveSchemaPropertiesToFormData({
-						schema: itemSchema,
-						variableName,
-						propName: "value",
-						context,
-						isRequestBodyOptional,
-						keyPrefix: `${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}].`,
-						depth: depth + 1
-					});
-					formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => {
-    ${resolvedValue}});\n`;
-				} else valueStr = "JSON.stringify(value)";
-				else {
-					const itemType = getSchemaType$1(itemSchema);
-					if (itemType === "number" || Array.isArray(itemType) && itemType.includes("number") || itemType === "integer" || Array.isArray(itemType) && itemType.includes("integer") || itemType === "boolean" || Array.isArray(itemType) && itemType.includes("boolean")) valueStr = "value.toString()";
-				}
+		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 (context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE) {
-				if (!hasNonPrimitiveChild) formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => ${variableName}.append(\`${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}]\`, ${valueStr}));\n`;
-			} else formDataValue = `${valueKey}.forEach(value => ${variableName}.append(\`${keyPrefix}${key}${context.output.override.formData.arrayHandling === FormDataArrayHandling.SERIALIZE_WITH_BRACKETS ? "[]" : ""}\`, ${valueStr}));\n`;
-		} else if ((() => {
-			const propType = getSchemaType$1(property);
-			return propType === "number" || Array.isArray(propType) && propType.includes("number") || propType === "integer" || Array.isArray(propType) && propType.includes("integer") || propType === "boolean" || Array.isArray(propType) && propType.includes("boolean");
-		})()) formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey}.toString())\n`;
-		else formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
-		let existSubSchemaNullable = false;
-		const combine = getSchemaCombined(property);
-		if (combine) {
-			const subSchemas = combine.map((c) => resolveObject({
-				schema: c,
-				combined: true,
-				context
-			}));
-			if (subSchemas.some((subSchema) => {
-				return [
-					"number",
-					"integer",
-					"boolean"
-				].includes(subSchema.type);
-			})) formDataValue = `${variableName}.append(\`${key}\`, ${nonOptionalValueKey}.toString())\n`;
-			if (subSchemas.some((subSchema) => {
-				return subSchema.type === "null";
-			})) existSubSchemaNullable = true;
-		}
-		const isRequired = getSchemaRequired(schema)?.includes(key) && !isRequestBodyOptional;
-		const propType = getSchemaType$1(property);
-		if (property.nullable || Array.isArray(propType) && propType.includes("null") || existSubSchemaNullable) {
-			if (isRequired) {
-				formDataValues += `if(${valueKey} !== null) {\n ${formDataValue} }\n`;
-				continue;
+			if (!formDataContext?.urlEncoded) {
+				if (schemaFormat === "binary") value = "Blob";
+				else if (formDataContext?.atPart) {
+					const fileType = getFormDataFieldFileType(item, formDataContext.partContentType);
+					if (fileType) value = fileType === "binary" ? "Blob" : "Blob | string";
+				} else if (isBinaryScalarSchema(item)) value = "Blob";
 			}
-			formDataValues += `if(${valueKey} !== undefined && ${nonOptionalValueKey} !== null) {\n ${formDataValue} }\n`;
-			continue;
+			if (context.output.override.useDates && (schemaFormat === "date" || schemaFormat === "date-time")) value = "Date";
+			value += nullable;
+			if (schemaConst) value = `'${schemaConst}'`;
+			return {
+				value,
+				isEnum,
+				type: "string",
+				imports: [],
+				schemas: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
 		}
-		if (isRequired) {
-			formDataValues += formDataValue;
-			continue;
+		case "null": return {
+			value: "null",
+			isEnum: false,
+			type: "null",
+			imports: [],
+			schemas: [],
+			isRef: false,
+			hasReadonlyProps: schemaReadOnly ?? false,
+			dependencies: []
+		};
+		default: {
+			if (isArray(itemType)) return combineSchemas({
+				schema: { anyOf: itemType.map((type) => Object.assign({}, item, { type })) },
+				name,
+				separator: "anyOf",
+				context,
+				nullable
+			});
+			if (enumItems) return {
+				value: enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : String(enumItem)).filter(Boolean).join(` | `) + nullable,
+				isEnum: true,
+				type: "string",
+				imports: [],
+				schemas: [],
+				isRef: false,
+				hasReadonlyProps: schemaReadOnly ?? false,
+				dependencies: [],
+				example: schemaExample,
+				examples: resolveExampleRefs(schemaExamples, context)
+			};
+			const hasCombiners = item.allOf ?? item.anyOf ?? item.oneOf;
+			const { value, ...rest } = getObject({
+				item,
+				name,
+				context,
+				nullable,
+				formDataContext: formDataContext?.atPart === false || formDataContext?.atPart && hasCombiners ? formDataContext : void 0
+			});
+			return {
+				value,
+				...rest
+			};
 		}
-		formDataValues += `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
 	}
-	return formDataValues;
 }
 //#endregion
-//#region src/getters/body.ts
-function buildBody(filteredBodyTypes, requestBody, operationName, context) {
-	const imports = filteredBodyTypes.flatMap(({ imports }) => imports);
-	const schemas = filteredBodyTypes.flatMap(({ schemas }) => schemas);
-	const definition = filteredBodyTypes.map(({ value }) => value).join(" | ");
-	const nonReadonlyDefinition = filteredBodyTypes.some((x) => x.hasReadonlyProps) && definition && context.output.override.preserveReadonlyRequestBodies !== "preserve" ? `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);
-			isOptional = bodySchema.required !== true;
-		} else isOptional = requestBody.required !== true;
-	}
-	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: ""
-		}
-	};
-}
-function getBody({ requestBody, operationName, context, contentType }) {
-	return buildBody(filterByContentType(getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context), contentType), requestBody, operationName, context);
-}
+//#region src/resolvers/ref.ts
+const REF_NOT_FOUND_PREFIX = "Oops... 🍻. Ref not found";
 /**
-* Returns per-content-type bodies when `splitByContentType` is enabled.
-* Each entry includes a `contentTypeSuffix` for generating distinct function names.
+* Recursively resolves a `$ref` in an OpenAPI document, following
+* nested schema refs and collecting imports along the way.
+*
+* Handles OpenAPI 3.0 `nullable` and 3.1 type-array hints on direct refs.
+*
+* @see https://spec.openapis.org/oas/v3.0.3#reference-object
+* @see https://spec.openapis.org/oas/v3.1.0#reference-object
 */
-function getBodiesByContentType({ requestBody, operationName, context, contentType }) {
-	const filteredBodyTypes = filterByContentType(getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context, void 0, (item) => `${item.value}::${item.contentType}`), contentType);
-	if (filteredBodyTypes.length <= 1) return [{
-		...buildBody(filteredBodyTypes, requestBody, operationName, context),
-		contentTypeSuffix: ""
-	}];
-	return filteredBodyTypes.map((bodyType) => {
-		const suffix = getContentTypeSuffix(bodyType.contentType);
+function resolveRef(schema, context, imports = []) {
+	const refPath = "$ref" in schema ? schema.$ref : void 0;
+	const nestedSchema = "schema" in schema ? schema.schema : void 0;
+	if (isObject(nestedSchema) && isReference(nestedSchema) && typeof nestedSchema.$ref === "string") {
+		const resolvedRef = resolveRef(nestedSchema, context, imports);
+		if ("examples" in schema) {
+			const schemaWithExamples = schema;
+			schemaWithExamples.examples = resolveExampleRefs(schemaWithExamples.examples, context);
+		}
+		if ("examples" in resolvedRef.schema) {
+			const resolvedWithExamples = resolvedRef.schema;
+			resolvedWithExamples.examples = resolveExampleRefs(resolvedWithExamples.examples, context);
+		}
 		return {
-			...buildBody([bodyType], requestBody, operationName, context),
-			contentTypeSuffix: suffix
+			schema: {
+				...schema,
+				schema: resolvedRef.schema
+			},
+			imports: resolvedRef.imports
 		};
-	});
-}
-const CONTENT_TYPE_SUFFIX_MAP = {
-	"application/json": "Json",
-	"multipart/form-data": "FormData",
-	"application/x-www-form-urlencoded": "UrlEncoded",
-	"text/plain": "Text",
-	"application/xml": "Xml",
-	"text/xml": "Xml",
-	"application/octet-stream": "Blob"
-};
-function getContentTypeSuffix(contentType) {
-	if (CONTENT_TYPE_SUFFIX_MAP[contentType]) return CONTENT_TYPE_SUFFIX_MAP[contentType];
-	return (contentType.split("/")[1] ?? contentType).split(/[-+.]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-//#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;
+	}
+	if (isDereferenced(schema)) {
+		if ("examples" in schema) {
+			const schemaWithExamples = schema;
+			schemaWithExamples.examples = resolveExampleRefs(schemaWithExamples.examples, context);
+		}
 		return {
-			...imp,
-			alias: `__${imp.name}`
+			schema,
+			imports
 		};
-	}) : resolvedValue.imports;
-}
-function needCreateImportAlias({ imp, name }) {
-	return !imp.alias && imp.name === name;
+	}
+	if (!refPath) throw new Error(`${REF_NOT_FOUND_PREFIX}: missing $ref`);
+	const { currentSchema, refInfo: { name, originalName } } = getSchema$1(schema, context);
+	if (!currentSchema) throw new Error(`${REF_NOT_FOUND_PREFIX}: ${refPath}`);
+	return resolveRef(currentSchema, { ...context }, [...imports, {
+		name,
+		schemaName: originalName
+	}]);
 }
-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;
+/**
+* Looks up a schema by its `$ref` path in the spec, applying suffix resolution.
+*
+* Preserves OpenAPI 3.0 `nullable` and 3.1 type-array (`["object", "null"]`)
+* hints from the referencing schema onto the resolved target.
+*
+* @see https://spec.openapis.org/oas/v3.0.3#fixed-fields-18 (nullable)
+* @see https://spec.openapis.org/oas/v3.1.0#schema-object (type as array)
+*/
+function getSchema$1(schema, context) {
+	if (!schema.$ref) throw new Error(`${REF_NOT_FOUND_PREFIX}: missing $ref`);
+	const refInfo = getRefInfo(schema.$ref, context);
+	const { refPaths } = refInfo;
+	const schemaByRefPaths = Array.isArray(refPaths) ? prop(context.spec, ...refPaths) : void 0;
+	if (isObject(schemaByRefPaths) && isReference(schemaByRefPaths)) return getSchema$1(schemaByRefPaths, context);
+	let currentSchema = schemaByRefPaths;
+	if (isObject(currentSchema) && "nullable" in schema) {
+		const nullable = schema.nullable;
+		currentSchema = {
+			...currentSchema,
+			nullable
+		};
+	}
+	if (isObject(currentSchema) && "type" in schema && Array.isArray(schema.type)) {
+		const type = schema.type;
+		currentSchema = {
+			...currentSchema,
+			type
+		};
+	}
+	return {
+		currentSchema,
+		refInfo
+	};
 }
-//#endregion
-//#region src/getters/keys.ts
-function getKey(key) {
-	return keyword.isIdentifierNameES5(key) ? key : `'${key}'`;
+/** Recursively resolves `$ref` entries in an examples array or record. */
+function resolveExampleRefs(examples, context) {
+	if (!examples) return;
+	return Array.isArray(examples) ? examples.map((example) => {
+		if (isObject(example) && isReference(example)) {
+			const { schema } = resolveRef(example, context);
+			return schema.value;
+		}
+		return example;
+	}) : (() => {
+		const result = {};
+		for (const [key, example] of Object.entries(examples)) result[key] = isObject(example) && isReference(example) ? resolveRef(example, context).schema.value : example;
+		return result;
+	})();
 }
 //#endregion
-//#region src/getters/object.ts
-function getPropertyNamesEnumKeyType(item) {
-	if (!("propertyNames" in item) || !item.propertyNames) return;
-	const propertyNames = item.propertyNames;
-	if (Array.isArray(propertyNames.enum)) {
-		const enumValues = propertyNames.enum.filter((val) => isString(val));
-		if (enumValues.length > 0) return {
-			value: enumValues.map((val) => `'${escape(val)}'`).join(" | "),
-			imports: [],
-			dependencies: []
+//#region src/resolvers/value.ts
+function resolveValue({ schema, name, context, formDataContext }) {
+	if (isReference(schema)) {
+		const refValue = schema.$ref;
+		const { schema: schemaObject, imports } = resolveRef(schema, context);
+		if (refValue && !isComponentRef(refValue)) {
+			if (context.parents?.includes(refValue)) return {
+				value: "unknown",
+				imports: [],
+				schemas: [],
+				type: "unknown",
+				isEnum: false,
+				originalSchema: schemaObject,
+				hasReadonlyProps: false,
+				isRef: false,
+				dependencies: []
+			};
+			return {
+				...getScalar({
+					item: schemaObject,
+					name,
+					context: {
+						...context,
+						parents: [...context.parents ?? [], refValue]
+					},
+					formDataContext
+				}),
+				originalSchema: schemaObject,
+				isRef: false
+			};
+		}
+		if (formDataContext?.urlEncoded && isBinaryScalarSchema(schemaObject)) return {
+			...getScalar({
+				item: schemaObject,
+				name,
+				context,
+				formDataContext
+			}),
+			originalSchema: schemaObject,
+			isRef: false
+		};
+		const resolvedImport = imports[0];
+		let hasReadonlyProps = false;
+		const refName = resolvedImport.name;
+		if (!context.parents?.includes(refName)) hasReadonlyProps = getScalar({
+			item: schemaObject,
+			name: refName,
+			context: {
+				...context,
+				parents: [...context.parents ?? [], refName]
+			}
+		}).hasReadonlyProps;
+		const isAnyOfNullable = schemaObject.anyOf?.some((anyOfItem) => !isReference(anyOfItem) && (anyOfItem.type === "null" || Array.isArray(anyOfItem.type) && anyOfItem.type.includes("null")));
+		const schemaType = schemaObject.type;
+		const nullable = Array.isArray(schemaType) && schemaType.includes("null") || schemaObject.nullable === true || isAnyOfNullable ? " | null" : "";
+		return {
+			value: resolvedImport.name + nullable,
+			imports: [{
+				name: resolvedImport.name,
+				schemaName: resolvedImport.schemaName
+			}],
+			type: schemaObject.type ?? "object",
+			schemas: [],
+			isEnum: !!schemaObject.enum,
+			originalSchema: schemaObject,
+			hasReadonlyProps,
+			isRef: true,
+			dependencies: [resolvedImport.name]
 		};
 	}
-	if (isString(propertyNames.const)) return {
-		value: `'${escape(propertyNames.const)}'`,
-		imports: [],
-		dependencies: []
+	return {
+		...getScalar({
+			item: schema,
+			name,
+			context,
+			formDataContext
+		}),
+		originalSchema: schema,
+		isRef: false
 	};
 }
+//#endregion
+//#region src/resolvers/object.ts
 /**
-* Resolve a narrowed key type from OpenAPI 3.1 propertyNames.
-* Supports inline enum/const and $ref string enums.
+* Wraps inline object type in a type alias.
+* E.g. `{ foo: string }` → value becomes `FooBody`, schema gets `export type FooBody = { foo: string };`
 */
-function getPropertyNamesKeyType(item, context) {
-	const inlineKeyType = getPropertyNamesEnumKeyType(item);
-	if (inlineKeyType) return inlineKeyType;
-	const propertyNames = item.propertyNames;
-	if (!propertyNames || !isReference(propertyNames)) return;
-	const resolvedValue = resolveValue({
-		schema: propertyNames,
-		context
-	});
-	const resolvedConst = resolvedValue.originalSchema.const;
-	const isStringConst = resolvedValue.type === "string" && isString(resolvedConst);
-	if (!resolvedValue.isEnum && !isStringConst) return;
+function createTypeAliasIfNeeded({ resolvedValue, propName, context }) {
+	if (!propName) return;
+	if (resolvedValue.isEnum || resolvedValue.type !== "object") return;
+	const aliasPattern = context.output.override.aliasCombinedTypes ? String.raw`{|&|\|` : "{";
+	if (!new RegExp(aliasPattern).test(resolvedValue.value)) return;
+	const { originalSchema } = resolvedValue;
+	const doc = jsDoc(originalSchema);
+	const isConstant = "const" in originalSchema;
+	const constantIsString = "type" in originalSchema && (originalSchema.type === "string" || Array.isArray(originalSchema.type) && originalSchema.type.includes("string"));
+	const model = isConstant ? `${doc}export const ${propName} = ${constantIsString ? `'${originalSchema.const}'` : originalSchema.const} as const;\n` : `${doc}export type ${propName} = ${resolvedValue.value};\n`;
 	return {
-		value: resolvedValue.value,
-		imports: resolvedValue.imports,
+		value: propName,
+		imports: [{
+			name: propName,
+			isConstant
+		}],
+		schemas: [...resolvedValue.schemas, {
+			name: propName,
+			model,
+			imports: resolvedValue.imports,
+			dependencies: resolvedValue.dependencies
+		}],
+		isEnum: false,
+		type: "object",
+		isRef: resolvedValue.isRef,
+		hasReadonlyProps: resolvedValue.hasReadonlyProps,
 		dependencies: resolvedValue.dependencies
 	};
 }
-/**
-* Generate index signature key type based on propertyNames enum or const
-* Returns union type string like "'foo' | 'bar'", "'x'", or 'string' if neither
-*/
-function getIndexSignatureKey(item) {
-	return getPropertyNamesEnumKeyType(item)?.value ?? "string";
-}
-function getPropertyNamesRecordType(item, valueType, context) {
-	const keyType = getPropertyNamesKeyType(item, context);
-	if (!keyType) return;
-	return {
-		...keyType,
-		value: `Partial<Record<${keyType.value}, ${valueType}>>`
+function resolveObjectOriginal({ schema, propName, combined = false, context, formDataContext }) {
+	const resolvedValue = resolveValue({
+		schema,
+		name: propName,
+		context,
+		formDataContext
+	});
+	const aliased = createTypeAliasIfNeeded({
+		resolvedValue,
+		propName,
+		context
+	});
+	if (aliased) return {
+		...aliased,
+		originalSchema: resolvedValue.originalSchema
 	};
+	if (propName && resolvedValue.isEnum && !combined && !resolvedValue.isRef) {
+		const doc = jsDoc(resolvedValue.originalSchema);
+		const enumValue = getEnum(resolvedValue.value, propName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
+		return {
+			value: propName,
+			imports: [{ name: propName }],
+			schemas: [...resolvedValue.schemas, {
+				name: propName,
+				model: doc + enumValue,
+				imports: resolvedValue.imports,
+				dependencies: resolvedValue.dependencies
+			}],
+			isEnum: false,
+			type: "enum",
+			originalSchema: resolvedValue.originalSchema,
+			isRef: resolvedValue.isRef,
+			hasReadonlyProps: resolvedValue.hasReadonlyProps,
+			dependencies: [...resolvedValue.dependencies, propName]
+		};
+	}
+	return resolvedValue;
+}
+const resolveObjectCacheMap = /* @__PURE__ */ new Map();
+function resolveObject({ schema, propName, combined = false, context, formDataContext }) {
+	const hashKey = JSON.stringify({
+		schema,
+		propName,
+		combined,
+		projectName: context.projectName ?? context.output.target,
+		formDataContext
+	});
+	if (resolveObjectCacheMap.has(hashKey)) return resolveObjectCacheMap.get(hashKey);
+	const result = resolveObjectOriginal({
+		schema,
+		propName,
+		combined,
+		context,
+		formDataContext
+	});
+	resolveObjectCacheMap.set(hashKey, result);
+	return result;
 }
+//#endregion
+//#region src/getters/array.ts
 /**
-* Return the output type from an object
+* Return the output type from an array
 *
-* @param item item with type === "object"
+* @param item item with type === "array"
 */
-function getObject({ item, name, context, nullable, formDataContext }) {
-	if (isReference(item)) {
-		const { name } = getRefInfo(item.$ref, context);
+function getArray({ schema, name, context, formDataContext }) {
+	const schemaPrefixItems = schema.prefixItems;
+	const schemaItems = schema.items;
+	const schemaExample = schema.example;
+	const schemaExamples = schema.examples;
+	const itemSuffix = context.output.override.components.schemas.itemSuffix;
+	if (schemaPrefixItems) {
+		const resolvedObjects = schemaPrefixItems.map((item, index) => resolveObject({
+			schema: item,
+			propName: name ? name + itemSuffix + String(index) : void 0,
+			context
+		}));
+		if (schemaItems) {
+			const additional = resolveObject({
+				schema: schemaItems,
+				propName: name ? name + itemSuffix + "Additional" : void 0,
+				context
+			});
+			resolvedObjects.push({
+				...additional,
+				value: `...${additional.value}[]`
+			});
+		}
 		return {
-			value: name + nullable,
-			imports: [{ name }],
-			schemas: [],
+			type: "array",
 			isEnum: false,
-			type: "object",
-			isRef: true,
-			hasReadonlyProps: item.readOnly ?? false,
-			dependencies: [name],
-			example: item.example,
-			examples: resolveExampleRefs(item.examples, context)
+			isRef: false,
+			value: `[${resolvedObjects.map((o) => o.value).join(", ")}]`,
+			imports: resolvedObjects.flatMap((o) => o.imports),
+			schemas: resolvedObjects.flatMap((o) => o.schemas),
+			dependencies: resolvedObjects.flatMap((o) => o.dependencies),
+			hasReadonlyProps: resolvedObjects.some((o) => o.hasReadonlyProps),
+			example: schemaExample,
+			examples: resolveExampleRefs(schemaExamples, context)
 		};
 	}
-	const schemaItem = item;
-	const itemAllOf = schemaItem.allOf;
-	const itemOneOf = schemaItem.oneOf;
-	const itemAnyOf = schemaItem.anyOf;
-	const itemType = schemaItem.type;
-	if (itemAllOf || itemOneOf || itemAnyOf) return combineSchemas({
-		schema: schemaItem,
-		name,
-		separator: itemAllOf ? "allOf" : itemOneOf ? "oneOf" : "anyOf",
+	if (schemaItems) {
+		const resolvedObject = resolveObject({
+			schema: schemaItems,
+			propName: name ? name + itemSuffix : void 0,
+			context,
+			formDataContext
+		});
+		return {
+			value: `${schema.readOnly === true && !context.output.override.suppressReadonlyModifier ? "readonly " : ""}${resolvedObject.value.includes("|") || resolvedObject.value.includes("&") ? `(${resolvedObject.value})[]` : `${resolvedObject.value}[]`}`,
+			imports: resolvedObject.imports,
+			schemas: resolvedObject.schemas,
+			dependencies: resolvedObject.dependencies,
+			isEnum: false,
+			type: "array",
+			isRef: false,
+			hasReadonlyProps: resolvedObject.hasReadonlyProps,
+			example: schemaExample,
+			examples: resolveExampleRefs(schemaExamples, context)
+		};
+	} else if (compareVersions(context.spec.openapi ?? "3.0.0", "3.1", ">=")) return {
+		value: "unknown[]",
+		imports: [],
+		schemas: [],
+		dependencies: [],
+		isEnum: false,
+		type: "array",
+		isRef: false,
+		hasReadonlyProps: false
+	};
+	else throw new Error(`All arrays must have an \`items\` key defined (name=${name}, schema=${JSON.stringify(schema)})`);
+}
+//#endregion
+//#region src/getters/res-req-types.ts
+const getSchemaType$1 = (s) => s.type;
+const getSchemaCombined = (s) => s.oneOf ?? s.anyOf ?? s.allOf;
+const getSchemaOneOf = (s) => s.oneOf;
+const getSchemaAnyOf = (s) => s.anyOf;
+const getSchemaItems = (s) => s.items;
+const getSchemaRequired = (s) => s.required;
+const getSchemaProperties = (s) => s.properties;
+const resolveSchemaRef = (schema, context) => resolveRef(schema, context);
+const resolveResponseOrRequestRef = (schema, context) => resolveRef(schema, context);
+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 isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
+	const formDataContext = isFormData ? {
+		atPart: false,
+		encoding: mediaType.encoding ?? {}
+	} : isFormUrlEncoded ? {
+		atPart: false,
+		encoding: mediaType.encoding ?? {},
+		urlEncoded: true
+	} : void 0;
+	const resolvedObject = resolveObject({
+		schema: mediaType.schema,
+		propName,
 		context,
-		nullable,
 		formDataContext
 	});
-	if (Array.isArray(itemType)) {
-		const typeArray = itemType;
-		const baseItem = schemaItem;
-		return combineSchemas({
-			schema: { anyOf: typeArray.map((type) => ({
-				...baseItem,
-				type
-			})) },
-			name,
-			separator: "anyOf",
-			context,
-			nullable
-		});
-	}
-	const itemProperties = schemaItem.properties;
-	if (itemProperties && Object.entries(itemProperties).length > 0) {
-		const entries = Object.entries(itemProperties);
-		if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries.sort((a, b) => {
-			return a[0].localeCompare(b[0], "en", { numeric: true });
-		});
-		const acc = {
-			imports: [],
-			schemas: [],
-			value: "",
-			isEnum: false,
-			type: "object",
-			isRef: false,
-			hasReadonlyProps: false,
-			useTypeAlias: false,
-			dependencies: [],
-			example: schemaItem.example,
-			examples: resolveExampleRefs(schemaItem.examples, context)
-		};
-		const itemRequired = schemaItem.required;
-		for (const [index, [key, schema]] of entries.entries()) {
-			const isRequired = (Array.isArray(itemRequired) ? itemRequired : []).includes(key);
-			let propName = "";
-			if (name) {
-				const isKeyStartWithUnderscore = key.startsWith("_");
-				propName += pascal(`${isKeyStartWithUnderscore ? "_" : ""}${name}_${key}`);
-			}
-			const allSpecSchemas = context.spec.components?.schemas ?? {};
-			if (Object.keys(allSpecSchemas).some((schemaName) => pascal(schemaName) === propName)) propName = propName + "Property";
-			const propertyFormDataContext = formDataContext && !formDataContext.atPart ? {
-				atPart: true,
-				partContentType: formDataContext.encoding[key]?.contentType,
-				urlEncoded: formDataContext.urlEncoded
-			} : void 0;
-			const resolvedValue = resolveObject({
-				schema,
-				propName,
-				context,
-				formDataContext: propertyFormDataContext
-			});
-			const isReadOnly = Boolean(schemaItem.readOnly) || Boolean(schema.readOnly);
-			if (!index) acc.value += "{";
-			const doc = jsDoc(schema, true, context);
-			const propertyDoc = doc ? `${doc.trimEnd().split("\n").map((line) => `  ${line}`).join("\n")}\n` : "";
-			if (isReadOnly || resolvedValue.hasReadonlyProps) acc.hasReadonlyProps = true;
-			const constValue = "const" in schema ? schema.const : void 0;
-			const hasConst = constValue !== void 0;
-			let constLiteral;
-			if (!hasConst) constLiteral = void 0;
-			else if (isString(constValue)) constLiteral = `'${escape(constValue)}'`;
-			else constLiteral = JSON.stringify(constValue);
-			const needsValueImport = hasConst && (resolvedValue.isEnum || resolvedValue.type === "enum");
-			const usedResolvedValue = !hasConst || needsValueImport;
-			const aliasedImports = needsValueImport ? resolvedValue.imports.map((imp) => ({
-				...imp,
-				isConstant: true
-			})) : hasConst ? [] : getAliasedImports({
+	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, schemaName }] } = resolveResponseOrRequestRef(res, context);
+			const firstEntry = Object.entries(bodySchema.content ?? {}).at(0);
+			if (!firstEntry) return [{
+				value: name,
+				imports: [{
+					name,
+					schemaName
+				}],
+				schemas: [],
+				type: "unknown",
+				isEnum: false,
+				isRef: true,
+				hasReadonlyProps: false,
+				dependencies: [name],
+				originalSchema: void 0,
+				example: void 0,
+				examples: void 0,
+				key,
+				contentType: ""
+			}];
+			const [contentType, mediaType] = firstEntry;
+			const isFormData = formDataContentTypes.has(contentType);
+			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
+			if (!isFormData && !isFormUrlEncoded || !mediaType.schema) return [{
+				value: name,
+				imports: [{
+					name,
+					schemaName
+				}],
+				schemas: [],
+				type: "unknown",
+				isEnum: false,
+				isRef: true,
+				hasReadonlyProps: false,
+				dependencies: [name],
+				originalSchema: mediaType.schema,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context),
+				key,
+				contentType
+			}];
+			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
 				name,
+				schemaObject: mediaType.schema,
 				context,
-				resolvedValue
-			});
-			if (aliasedImports.length > 0) acc.imports.push(...aliasedImports);
-			const alias = getImportAliasForRefOrValue({
+				isRequestBodyOptional: bodySchema.required !== true,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
+				name,
+				schemaObject: mediaType.schema,
 				context,
-				resolvedValue,
-				imports: aliasedImports
+				isRequestBodyOptional: bodySchema.required !== true,
+				isUrlEncoded: true,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const additionalImports = getFormDataAdditionalImports({
+				schemaObject: mediaType.schema,
+				context
 			});
-			const propValue = needsValueImport ? alias : constLiteral ?? alias;
-			const finalPropValue = isRequired ? propValue : context.output.override.useNullForOptional === true ? `${propValue} | null` : propValue;
-			acc.value += `\n${propertyDoc}${isReadOnly && !context.output.override.suppressReadonlyModifier ? "  readonly " : "  "}${getKey(key)}${isRequired ? "" : "?"}: ${finalPropValue};`;
-			if (usedResolvedValue) {
-				acc.schemas.push(...resolvedValue.schemas);
-				acc.dependencies.push(...resolvedValue.dependencies);
-			}
-			if (entries.length - 1 === index) {
-				const additionalProps = schemaItem.additionalProperties;
-				if (additionalProps) if (additionalProps === true) {
-					const recordType = getPropertyNamesRecordType(schemaItem, "unknown", context);
-					if (recordType) {
-						acc.value += "\n}";
-						acc.value += ` & ${recordType.value}`;
-						acc.useTypeAlias = true;
-						acc.imports.push(...recordType.imports);
-						acc.dependencies.push(...recordType.dependencies);
-					} else {
-						const keyType = getIndexSignatureKey(schemaItem);
-						acc.value += `\n  [key: ${keyType}]: unknown;\n }`;
-					}
-				} else {
-					const resolvedValue = resolveValue({
-						schema: additionalProps,
-						name,
-						context
-					});
-					const recordType = getPropertyNamesRecordType(schemaItem, resolvedValue.value, context);
-					if (recordType) {
-						acc.value += "\n}";
-						acc.value += ` & ${recordType.value}`;
-						acc.useTypeAlias = true;
-						acc.imports.push(...recordType.imports);
-						acc.dependencies.push(...recordType.dependencies);
-					} else {
-						const keyType = getIndexSignatureKey(schemaItem);
-						acc.value += `\n  [key: ${keyType}]: ${resolvedValue.value};\n}`;
+			return [{
+				value: name,
+				imports: [{
+					name,
+					schemaName
+				}, ...additionalImports],
+				schemas: [],
+				type: "unknown",
+				isEnum: false,
+				hasReadonlyProps: false,
+				dependencies: [name],
+				formData,
+				formUrlEncoded,
+				isRef: true,
+				originalSchema: mediaType.schema,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context),
+				key,
+				contentType
+			}];
+		}
+		if (res.content) return Object.entries(res.content).map(([contentType, mediaType], index, arr) => {
+			let propName = key ? pascal(name) + pascal(key) : void 0;
+			if (propName && arr.length > 1) propName = propName + pascal(getNumberWord(index + 1));
+			const isFormData = formDataContentTypes.has(contentType);
+			const isFormUrlEncoded = formUrlEncodedContentTypes.has(contentType);
+			let effectivePropName = propName;
+			if (mediaType.schema && isReference(mediaType.schema)) {
+				const { imports } = resolveSchemaRef(mediaType.schema, context);
+				if (imports[0]?.name) effectivePropName = imports[0].name;
+			} else if ((isFormData || isFormUrlEncoded) && mediaType.schema) {
+				const combinedRefs = getSchemaOneOf(mediaType.schema) ?? getSchemaAnyOf(mediaType.schema);
+				if (combinedRefs) {
+					const names = [];
+					for (const ref of combinedRefs) {
+						if (!isReference(ref)) continue;
+						const refName = resolveSchemaRef(ref, context).imports[0]?.name;
+						if (refName) names.push(refName);
 					}
-					acc.imports.push(...resolvedValue.imports);
-					acc.schemas.push(...resolvedValue.schemas);
-					acc.dependencies.push(...resolvedValue.dependencies);
+					if (names.length > 0) effectivePropName = names.join("");
 				}
-				else acc.value += "\n}";
-				acc.value += nullable;
 			}
-		}
-		return acc;
-	}
-	const outerAdditionalProps = schemaItem.additionalProperties;
-	const readOnlyFlag = schemaItem.readOnly;
-	if (outerAdditionalProps) {
-		if (outerAdditionalProps === true) {
-			const recordType = getPropertyNamesRecordType(schemaItem, "unknown", context);
-			if (recordType) return {
-				value: recordType.value + nullable,
-				imports: recordType.imports,
-				schemas: [],
-				isEnum: false,
-				type: "object",
-				isRef: false,
-				hasReadonlyProps: readOnlyFlag ?? false,
-				useTypeAlias: true,
-				dependencies: recordType.dependencies
+			const resolvedValue = getResReqContentTypes({
+				mediaType,
+				propName: effectivePropName,
+				context,
+				isFormData,
+				contentType
+			});
+			if (!resolvedValue) {
+				if (isBinaryContentType(contentType)) return {
+					value: "Blob",
+					imports: [],
+					schemas: [],
+					type: "Blob",
+					isEnum: false,
+					key,
+					isRef: false,
+					hasReadonlyProps: false,
+					contentType
+				};
+				return;
+			}
+			if (!isFormData && !isFormUrlEncoded || !effectivePropName || !mediaType.schema) return {
+				...resolvedValue,
+				imports: resolvedValue.imports,
+				dependencies: resolvedValue.dependencies,
+				contentType,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context)
 			};
+			const formData = isFormData ? getSchemaFormDataAndUrlEncoded({
+				name: effectivePropName,
+				schemaObject: mediaType.schema,
+				context,
+				isRequestBodyOptional: res.required !== true,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const formUrlEncoded = isFormUrlEncoded ? getSchemaFormDataAndUrlEncoded({
+				name: effectivePropName,
+				schemaObject: mediaType.schema,
+				context,
+				isUrlEncoded: true,
+				isRequestBodyOptional: res.required !== true,
+				isRef: true,
+				encoding: mediaType.encoding
+			}) : void 0;
+			const additionalImports = getFormDataAdditionalImports({
+				schemaObject: mediaType.schema,
+				context
+			});
 			return {
-				value: `{ [key: ${getIndexSignatureKey(schemaItem)}]: unknown }` + nullable,
-				imports: [],
-				schemas: [],
-				isEnum: false,
-				type: "object",
-				isRef: false,
-				hasReadonlyProps: readOnlyFlag ?? false,
-				useTypeAlias: false,
-				dependencies: []
+				...resolvedValue,
+				imports: [...resolvedValue.imports, ...additionalImports],
+				formData,
+				formUrlEncoded,
+				contentType,
+				example: mediaType.example,
+				examples: resolveExampleRefs(mediaType.examples, context)
 			};
-		}
-		const resolvedValue = resolveValue({
-			schema: outerAdditionalProps,
-			name,
-			context
-		});
-		const recordType = getPropertyNamesRecordType(schemaItem, resolvedValue.value, context);
-		if (recordType) return {
-			value: recordType.value + nullable,
-			imports: [...recordType.imports, ...resolvedValue.imports],
-			schemas: resolvedValue.schemas,
-			isEnum: false,
-			type: "object",
-			isRef: false,
-			hasReadonlyProps: resolvedValue.hasReadonlyProps,
-			useTypeAlias: true,
-			dependencies: [...recordType.dependencies, ...resolvedValue.dependencies]
-		};
-		return {
-			value: `{[key: ${getIndexSignatureKey(schemaItem)}]: ${resolvedValue.value}}` + nullable,
-			imports: resolvedValue.imports,
-			schemas: resolvedValue.schemas,
-			isEnum: false,
-			type: "object",
-			isRef: false,
-			hasReadonlyProps: resolvedValue.hasReadonlyProps,
-			useTypeAlias: false,
-			dependencies: resolvedValue.dependencies
-		};
-	}
-	const constValue = schemaItem.const;
-	if (constValue !== void 0) {
-		let type;
-		if (Array.isArray(constValue)) type = "array";
-		else if (constValue === null) type = "null";
-		else if (typeof constValue === "string") type = "string";
-		else if (typeof constValue === "number") type = "number";
-		else if (typeof constValue === "boolean") type = "boolean";
-		else type = "object";
-		return {
-			value: typeof constValue === "string" ? `'${escape(constValue)}'` : JSON.stringify(constValue),
+		}).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,
-			type,
+			dependencies: [],
+			key,
 			isRef: false,
-			hasReadonlyProps: readOnlyFlag ?? false,
-			dependencies: []
-		};
-	}
-	const keyType = itemType === "object" ? getIndexSignatureKey(schemaItem) : "string";
-	const recordType = getPropertyNamesRecordType(schemaItem, "unknown", context);
-	if (itemType === "object" && recordType) return {
-		value: recordType.value + nullable,
-		imports: recordType.imports,
-		schemas: [],
-		isEnum: false,
-		type: "object",
-		isRef: false,
-		hasReadonlyProps: readOnlyFlag ?? false,
-		useTypeAlias: true,
-		dependencies: recordType.dependencies
-	};
-	return {
-		value: (itemType === "object" ? `{ [key: ${keyType}]: unknown }` : "unknown") + nullable,
-		imports: [],
-		schemas: [],
-		isEnum: false,
-		type: "object",
-		isRef: false,
-		hasReadonlyProps: readOnlyFlag ?? false,
-		useTypeAlias: false,
-		dependencies: []
-	};
+			hasReadonlyProps: false,
+			contentType: "application/json"
+		}];
+	}).flat(), uniqueKey);
 }
-//#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
+* Determine the responseType option based on success content types only.
+* This avoids error-response content types influencing the responseType.
 */
-function getScalar({ item, name, context, formDataContext }) {
-	const schemaEnum = item.enum;
-	const schemaType = item.type;
-	const schemaReadOnly = item.readOnly;
-	const schemaExample = item.example;
-	const schemaExamples = item.examples;
-	const schemaConst = item.const;
-	const schemaFormat = item.format;
-	const schemaNullable = item.nullable;
-	const schemaContentMediaType = item.contentMediaType;
-	const schemaContentEncoding = item.contentEncoding;
-	const nullable = isArray(schemaType) && schemaType.includes("null") || schemaNullable === true ? " | null" : "";
-	const enumItems = schemaEnum?.filter((enumItem) => enumItem !== null);
-	let itemType = schemaType;
-	if (!itemType && item.items) {
-		item.type = "array";
-		itemType = "array";
-	}
-	if (isArray(schemaType) && schemaType.includes("null")) {
-		const typesWithoutNull = schemaType.filter((x) => x !== "null");
-		itemType = typesWithoutNull.length === 1 ? typesWithoutNull[0] : typesWithoutNull;
-	}
-	switch (itemType) {
-		case "number":
-		case "integer": {
-			let value = context.output.override.useBigInt && (schemaFormat === "int64" || schemaFormat === "uint64") ? "bigint" : "number";
-			let isEnum = false;
-			if (enumItems) {
-				value = enumItems.map((enumItem) => `${enumItem}`).join(" | ");
-				isEnum = true;
-			}
-			value += nullable;
-			if (schemaConst !== void 0) value = schemaConst;
-			return {
-				value,
-				isEnum,
-				type: "number",
-				schemas: [],
-				imports: [],
-				isRef: false,
-				hasReadonlyProps: schemaReadOnly ?? false,
-				dependencies: [],
-				example: schemaExample,
-				examples: resolveExampleRefs(schemaExamples, context)
-			};
-		}
-		case "boolean": {
-			let value = "boolean";
-			if (enumItems && !(enumItems.includes(true) && enumItems.includes(false))) value = enumItems.map((enumItem) => `${enumItem}`).join(" | ");
-			value += nullable;
-			if (schemaConst !== void 0) value = schemaConst;
-			return {
-				value,
-				type: "boolean",
-				isEnum: false,
-				schemas: [],
-				imports: [],
-				isRef: false,
-				hasReadonlyProps: schemaReadOnly ?? false,
-				dependencies: [],
-				example: schemaExample,
-				examples: resolveExampleRefs(schemaExamples, context)
-			};
-		}
-		case "array": {
-			const { value, ...rest } = getArray({
-				schema: item,
-				name,
-				context,
-				formDataContext
-			});
-			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 (!formDataContext?.urlEncoded) {
-				if (schemaFormat === "binary") value = "Blob";
-				else if (formDataContext?.atPart) {
-					const fileType = getFormDataFieldFileType(item, formDataContext.partContentType);
-					if (fileType) value = fileType === "binary" ? "Blob" : "Blob | string";
-				} else if (schemaContentMediaType === "application/octet-stream" && !schemaContentEncoding) value = "Blob";
+function getSuccessResponseType(response) {
+	const successContentTypes = response.types.success.map((t) => t.contentType).filter(Boolean);
+	if (response.isBlob) return "blob";
+	const hasJsonResponse = successContentTypes.some((contentType) => contentType.includes("json") || contentType.includes("+json"));
+	const hasTextResponse = successContentTypes.some((contentType) => contentType.startsWith("text/") || contentType.includes("xml"));
+	if (!hasJsonResponse && hasTextResponse) return "text";
+}
+/**
+* Determine the response type category for a given content type.
+* Used to set the correct responseType option in HTTP clients.
+*
+* @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 } = resolveSchemaRef(schemaObject, context);
+	if (schema.type !== "object") return [];
+	const combinedSchemas = getSchemaOneOf(schema) ?? getSchemaAnyOf(schema);
+	if (!combinedSchemas) return [];
+	return combinedSchemas.map((subSchema) => resolveSchemaRef(subSchema, context).imports[0]).filter(Boolean);
+}
+function getSchemaFormDataAndUrlEncoded({ name, schemaObject, context, isRequestBodyOptional, isUrlEncoded, isRef, encoding }) {
+	const { schema, imports } = resolveSchemaRef(schemaObject, context);
+	const propName = camel(!isRef && isReference(schemaObject) ? imports[0].name : name);
+	const variableName = isUrlEncoded ? "formUrlEncoded" : "formData";
+	let form = isUrlEncoded ? `const ${variableName} = new URLSearchParams();\n` : `const ${variableName} = new FormData();\n`;
+	const combinedSchemas = getSchemaCombined(schema);
+	if (schema.type === "object" || schema.type === void 0 && combinedSchemas) {
+		if (combinedSchemas) if (!!getSchemaOneOf(schema) || !!getSchemaAnyOf(schema)) {
+			const directProperties = getSchemaProperties(schema);
+			const directKeys = directProperties ? Object.entries(directProperties).filter(([, value]) => !resolveSchemaRef(value, context).schema.readOnly).map(([key]) => key) : [];
+			const skipLine = directKeys.length > 0 ? `  if ([${directKeys.map((k) => JSON.stringify(k)).join(", ")}].includes(key)) return;\n` : "";
+			form += `Object.entries(${propName} ?? {}).forEach(([key, value]) => {\n`;
+			form += skipLine;
+			form += `  if (value !== undefined && value !== null) {\n`;
+			if (isUrlEncoded) {
+				form += `    if (Array.isArray(value)) {\n`;
+				form += `      value.forEach(v => {\n`;
+				form += `        ${variableName}.append(key, typeof v === 'object' ? JSON.stringify(v) : String(v));\n`;
+				form += `      });\n`;
+				form += `    } else if (typeof value === 'object') {\n`;
+				form += `      ${variableName}.append(key, JSON.stringify(value));\n`;
+				form += `    } else {\n`;
+				form += `      ${variableName}.append(key, String(value));\n`;
+				form += `    }\n`;
+			} else {
+				form += `    if ((typeof File !== 'undefined' && value instanceof File) || value instanceof Blob) {\n`;
+				form += `      ${variableName}.append(key, value);\n`;
+				form += `    } else if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {\n`;
+				form += `      ${variableName}.append(key, new Blob([Uint8Array.from(value)]));\n`;
+				form += `    } else if (Array.isArray(value)) {\n`;
+				form += `      value.forEach(v => {\n`;
+				form += `        if ((typeof File !== 'undefined' && v instanceof File) || v instanceof Blob) {\n`;
+				form += `          ${variableName}.append(key, v);\n`;
+				form += `        } else if (typeof Buffer !== 'undefined' && Buffer.isBuffer(v)) {\n`;
+				form += `          ${variableName}.append(key, new Blob([Uint8Array.from(v)]));\n`;
+				form += `        } else {\n`;
+				form += `          ${variableName}.append(key, typeof v === 'object' ? JSON.stringify(v) : String(v));\n`;
+				form += `        }\n`;
+				form += `      });\n`;
+				form += `    } else if (typeof value === 'object') {\n`;
+				form += `      ${variableName}.append(key, JSON.stringify(value));\n`;
+				form += `    } else {\n`;
+				form += `      ${variableName}.append(key, String(value));\n`;
+				form += `    }\n`;
 			}
-			if (context.output.override.useDates && (schemaFormat === "date" || schemaFormat === "date-time")) value = "Date";
-			value += nullable;
-			if (schemaConst) value = `'${schemaConst}'`;
-			return {
-				value,
-				isEnum,
-				type: "string",
-				imports: [],
-				schemas: [],
-				isRef: false,
-				hasReadonlyProps: schemaReadOnly ?? false,
-				dependencies: [],
-				example: schemaExample,
-				examples: resolveExampleRefs(schemaExamples, context)
-			};
+			form += `  }\n`;
+			form += `});\n`;
+		} else {
+			const combinedSchemasFormData = combinedSchemas.map((subSchema) => {
+				const { schema: combinedSchema } = resolveSchemaRef(subSchema, context);
+				return resolveSchemaPropertiesToFormData({
+					schema: combinedSchema,
+					variableName,
+					propName,
+					context,
+					isRequestBodyOptional,
+					encoding
+				});
+			}).filter(Boolean).join("\n");
+			form += combinedSchemasFormData;
 		}
-		case "null": return {
-			value: "null",
-			isEnum: false,
-			type: "null",
-			imports: [],
-			schemas: [],
-			isRef: false,
-			hasReadonlyProps: schemaReadOnly ?? false,
-			dependencies: []
-		};
-		default: {
-			if (isArray(itemType)) return combineSchemas({
-				schema: { anyOf: itemType.map((type) => Object.assign({}, item, { type })) },
-				name,
-				separator: "anyOf",
-				context,
-				nullable
-			});
-			if (enumItems) return {
-				value: enumItems.map((enumItem) => isString(enumItem) ? `'${escape(enumItem)}'` : String(enumItem)).filter(Boolean).join(` | `) + nullable,
-				isEnum: true,
-				type: "string",
-				imports: [],
-				schemas: [],
-				isRef: false,
-				hasReadonlyProps: schemaReadOnly ?? false,
-				dependencies: [],
-				example: schemaExample,
-				examples: resolveExampleRefs(schemaExamples, context)
-			};
-			const hasCombiners = item.allOf ?? item.anyOf ?? item.oneOf;
-			const { value, ...rest } = getObject({
-				item,
-				name,
+		if (schema.properties) {
+			const formDataValues = resolveSchemaPropertiesToFormData({
+				schema,
+				variableName,
+				propName,
 				context,
-				nullable,
-				formDataContext: formDataContext?.atPart === false || formDataContext?.atPart && hasCombiners ? formDataContext : void 0
+				isRequestBodyOptional,
+				encoding
 			});
-			return {
-				value,
-				...rest
-			};
+			form += formDataValues;
 		}
+		return form;
 	}
-}
-//#endregion
-//#region src/getters/combine.ts
-const mergeableAllOfKeys = new Set([
-	"type",
-	"properties",
-	"required"
-]);
-function isMergeableAllOfObject(schema) {
-	if (isNullish$1(schema.properties)) return false;
-	if (schema.allOf || schema.anyOf || schema.oneOf) return false;
-	if (!isNullish$1(schema.type) && schema.type !== "object") return false;
-	return Object.keys(schema).every((key) => mergeableAllOfKeys.has(key));
-}
-function normalizeAllOfSchema(schema) {
-	const schemaAllOf = schema.allOf;
-	if (!schemaAllOf) return schema;
-	let didMerge = false;
-	const schemaProperties = schema.properties;
-	const schemaRequired = schema.required;
-	const mergedProperties = schemaProperties ? { ...schemaProperties } : {};
-	const mergedRequired = new Set(schemaRequired);
-	const remainingAllOf = [];
-	for (const subSchema of schemaAllOf) {
-		if (isSchema(subSchema) && isMergeableAllOfObject(subSchema)) {
-			didMerge = true;
-			if (subSchema.properties) Object.assign(mergedProperties, subSchema.properties);
-			const subRequired = subSchema.required;
-			if (subRequired) for (const prop of subRequired) mergedRequired.add(prop);
-			continue;
+	if (schema.type === "array") {
+		let valueStr = "value";
+		const schemaItems = getSchemaItems(schema);
+		if (schemaItems) {
+			const { schema: itemSchema } = resolveSchemaRef(schemaItems, context);
+			if (itemSchema.type === "object" || itemSchema.type === "array") valueStr = "JSON.stringify(value)";
+			else if (itemSchema.type === "number" || itemSchema.type === "integer" || itemSchema.type === "boolean") valueStr = "value.toString()";
 		}
-		remainingAllOf.push(subSchema);
+		return `${form}${propName}.forEach(value => ${variableName}.append('data', ${valueStr}))\n`;
 	}
-	if (!didMerge || remainingAllOf.length === 0) return schema;
-	return {
-		...schema,
-		...Object.keys(mergedProperties).length > 0 && { properties: mergedProperties },
-		...mergedRequired.size > 0 && { required: [...mergedRequired] },
-		...remainingAllOf.length > 0 && { allOf: remainingAllOf }
-	};
+	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 combineValues({ resolvedData, resolvedValue, separator, context, parentSchema }) {
-	if (resolvedData.isEnum.every(Boolean)) return `${resolvedData.values.join(` | `)}${resolvedValue ? ` | ${resolvedValue.value}` : ""}`;
-	if (separator === "allOf") {
-		let resolvedDataValue = resolvedData.values.map((v) => v.includes(" | ") ? `(${v})` : v).join(` & `);
-		if (resolvedData.originalSchema.length > 0 && resolvedValue) {
-			const discriminatedPropertySchemas = resolvedData.originalSchema.filter((s) => {
-				const disc = s?.discriminator;
-				return disc && resolvedValue.value.includes(` ${disc.propertyName}:`);
-			});
-			if (discriminatedPropertySchemas.length > 0) resolvedDataValue = `Omit<${resolvedDataValue}, '${discriminatedPropertySchemas.map((s) => s.discriminator?.propertyName).join("' | '")}'>`;
+function resolveSchemaPropertiesToFormData({ schema, variableName, propName, context, isRequestBodyOptional, keyPrefix = "", depth = 0, encoding }) {
+	let formDataValues = "";
+	const isUrlEncoded = variableName === "formUrlEncoded";
+	const schemaProps = getSchemaProperties(schema) ?? {};
+	for (const [key, value] of Object.entries(schemaProps)) {
+		const { schema: property } = resolveSchemaRef(value, context);
+		if (property.readOnly) continue;
+		let formDataValue = "";
+		const partContentType = (depth === 0 ? encoding?.[key] : void 0)?.contentType;
+		const formattedKeyPrefix = isRequestBodyOptional ? keyword.isIdentifierNameES5(key) ? "?" : "?." : "";
+		const formattedKey = keyword.isIdentifierNameES5(key) ? `.${key}` : `['${key}']`;
+		const valueKey = `${propName}${formattedKeyPrefix}${formattedKey}`;
+		const nonOptionalValueKey = `${propName}${formattedKey}`;
+		const fileType = getFormDataFieldFileType(property, partContentType);
+		const effectiveContentType = partContentType ?? property.contentMediaType;
+		if (isUrlEncoded && (fileType || property.format === "binary")) formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
+		else 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" || Array.isArray(property.type) && property.type.includes("object")) formDataValue = context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE ? resolveSchemaPropertiesToFormData({
+			schema: property,
+			variableName,
+			propName: nonOptionalValueKey,
+			context,
+			isRequestBodyOptional,
+			keyPrefix: `${keyPrefix}${key}.`,
+			depth: depth + 1,
+			encoding
+		}) : `${variableName}.append(\`${keyPrefix}${key}\`, JSON.stringify(${nonOptionalValueKey}));\n`;
+		else if (property.type === "array" || Array.isArray(property.type) && property.type.includes("array")) {
+			let valueStr = "value";
+			let hasNonPrimitiveChild = false;
+			const propertyItems = getSchemaItems(property);
+			if (propertyItems) {
+				const { schema: itemSchema } = resolveSchemaRef(propertyItems, context);
+				if (itemSchema.type === "object" || itemSchema.type === "array") if (context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE) {
+					hasNonPrimitiveChild = true;
+					const resolvedValue = resolveSchemaPropertiesToFormData({
+						schema: itemSchema,
+						variableName,
+						propName: "value",
+						context,
+						isRequestBodyOptional,
+						keyPrefix: `${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}].`,
+						depth: depth + 1
+					});
+					formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => {
+    ${resolvedValue}});\n`;
+				} else valueStr = "JSON.stringify(value)";
+				else {
+					const itemType = getSchemaType$1(itemSchema);
+					if (itemType === "number" || Array.isArray(itemType) && itemType.includes("number") || itemType === "integer" || Array.isArray(itemType) && itemType.includes("integer") || itemType === "boolean" || Array.isArray(itemType) && itemType.includes("boolean")) valueStr = "value.toString()";
+				}
+			}
+			if (context.output.override.formData.arrayHandling === FormDataArrayHandling.EXPLODE) {
+				if (!hasNonPrimitiveChild) formDataValue = `${valueKey}.forEach((value, index${depth > 0 ? depth : ""}) => ${variableName}.append(\`${keyPrefix}${key}[\${index${depth > 0 ? depth : ""}}]\`, ${valueStr}));\n`;
+			} else formDataValue = `${valueKey}.forEach(value => ${variableName}.append(\`${keyPrefix}${key}${context.output.override.formData.arrayHandling === FormDataArrayHandling.SERIALIZE_WITH_BRACKETS ? "[]" : ""}\`, ${valueStr}));\n`;
+		} else if ((() => {
+			const propType = getSchemaType$1(property);
+			return propType === "number" || Array.isArray(propType) && propType.includes("number") || propType === "integer" || Array.isArray(propType) && propType.includes("integer") || propType === "boolean" || Array.isArray(propType) && propType.includes("boolean");
+		})()) formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey}.toString())\n`;
+		else formDataValue = `${variableName}.append(\`${keyPrefix}${key}\`, ${nonOptionalValueKey});\n`;
+		let existSubSchemaNullable = false;
+		const combine = getSchemaCombined(property);
+		if (combine) {
+			const subSchemas = combine.map((c) => resolveObject({
+				schema: c,
+				combined: true,
+				context
+			}));
+			if (subSchemas.some((subSchema) => {
+				return [
+					"number",
+					"integer",
+					"boolean"
+				].includes(subSchema.type);
+			})) formDataValue = `${variableName}.append(\`${key}\`, ${nonOptionalValueKey}.toString())\n`;
+			if (subSchemas.some((subSchema) => {
+				return subSchema.type === "null";
+			})) existSubSchemaNullable = true;
 		}
-		const resolvedValueStr = resolvedValue?.value.includes(" | ") ? `(${resolvedValue.value})` : resolvedValue?.value;
-		const joined = `${resolvedDataValue}${resolvedValue ? ` & ${resolvedValueStr}` : ""}`;
-		const overrideRequiredProperties = resolvedData.requiredProperties.filter((prop) => !resolvedData.originalSchema.some((schema) => {
-			const props = schema?.properties;
-			const req = schema?.required;
-			return props?.[prop] && req?.includes(prop);
-		}) && !(() => {
-			const parentProps = parentSchema?.properties;
-			const parentReq = parentSchema?.required;
-			return !!(parentProps?.[prop] && parentReq?.includes(prop));
-		})());
-		if (overrideRequiredProperties.length > 0) return `${joined} & Required<Pick<${joined}, '${overrideRequiredProperties.join("' | '")}'>>`;
-		return joined;
-	}
-	let values = resolvedData.values;
-	if (resolvedData.allProperties.length && context.output.unionAddMissingProperties) {
-		values = [];
-		for (let i = 0; i < resolvedData.values.length; i += 1) {
-			const subSchema = resolvedData.originalSchema[i];
-			if (subSchema?.type !== "object" || !subSchema.properties) {
-				values.push(resolvedData.values[i]);
+		const isRequired = getSchemaRequired(schema)?.includes(key) && !isRequestBodyOptional;
+		const propType = getSchemaType$1(property);
+		if (property.nullable || Array.isArray(propType) && propType.includes("null") || existSubSchemaNullable) {
+			if (isRequired) {
+				formDataValues += `if(${valueKey} !== null) {\n ${formDataValue} }\n`;
 				continue;
 			}
-			const subSchemaProps = subSchema.properties;
-			const missingProperties = unique(resolvedData.allProperties.filter((p) => !Object.keys(subSchemaProps).includes(p)));
-			values.push(`${resolvedData.values[i]}${missingProperties.length > 0 ? ` & {${missingProperties.map((p) => `${p}?: never`).join("; ")}}` : ""}`);
+			formDataValues += `if(${valueKey} !== undefined && ${nonOptionalValueKey} !== null) {\n ${formDataValue} }\n`;
+			continue;
+		}
+		if (isRequired) {
+			formDataValues += formDataValue;
+			continue;
 		}
+		formDataValues += `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
 	}
-	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
-	return values.join(" | ");
+	return formDataValues;
 }
-function combineSchemas({ name, schema, separator, context, nullable, formDataContext }) {
-	const normalizedSchema = separator === "allOf" && !context.output.override.aliasCombinedTypes && !schema.oneOf && !schema.anyOf ? normalizeAllOfSchema(schema) : schema;
-	const items = normalizedSchema[separator] ?? [];
-	const resolvedData = {
-		values: [],
-		imports: [],
-		schemas: [],
-		isEnum: [],
-		isRef: [],
-		types: [],
-		dependencies: [],
-		originalSchema: [],
-		allProperties: [],
-		hasReadonlyProps: false,
-		example: schema.example,
-		examples: resolveExampleRefs(schema.examples, context),
-		requiredProperties: separator === "allOf" ? schema.required ?? [] : []
-	};
-	for (const subSchema of items) {
-		let propName;
-		if (context.output.override.aliasCombinedTypes) {
-			propName = name ? name + pascal(separator) : void 0;
-			if (propName && resolvedData.schemas.length > 0) propName = propName + pascal(getNumberWord(resolvedData.schemas.length + 1));
-		}
-		if (separator === "allOf" && isSchema(subSchema) && subSchema.required) resolvedData.requiredProperties.push(...subSchema.required);
-		const resolvedValue = resolveObject({
-			schema: subSchema,
-			propName,
-			combined: true,
-			context,
-			formDataContext
-		});
-		const aliasedImports = getAliasedImports({
-			context,
-			name,
-			resolvedValue
-		});
-		const value = getImportAliasForRefOrValue({
-			context,
-			resolvedValue,
-			imports: aliasedImports
+//#endregion
+//#region src/getters/body.ts
+function buildBody(filteredBodyTypes, requestBody, operationName, context) {
+	const imports = filteredBodyTypes.flatMap(({ imports }) => imports);
+	const schemas = filteredBodyTypes.flatMap(({ schemas }) => schemas);
+	const definition = filteredBodyTypes.map(({ value }) => value).join(" | ");
+	const nonReadonlyDefinition = filteredBodyTypes.some((x) => x.hasReadonlyProps) && definition && context.output.override.preserveReadonlyRequestBodies !== "preserve" ? `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
 		});
-		resolvedData.values.push(value);
-		resolvedData.imports.push(...aliasedImports);
-		resolvedData.schemas.push(...resolvedValue.schemas);
-		resolvedData.dependencies.push(...resolvedValue.dependencies);
-		resolvedData.isEnum.push(resolvedValue.isEnum);
-		resolvedData.types.push(resolvedValue.type);
-		resolvedData.isRef.push(resolvedValue.isRef);
-		resolvedData.originalSchema.push(resolvedValue.originalSchema);
-		if (resolvedValue.hasReadonlyProps) resolvedData.hasReadonlyProps = true;
-		const originalProps = resolvedValue.originalSchema.properties;
-		if (resolvedValue.type === "object" && originalProps) resolvedData.allProperties.push(...Object.keys(originalProps));
+		if (isReference(requestBody)) {
+			const { schema: bodySchema } = resolveRef(requestBody, context);
+			isOptional = bodySchema.required !== true;
+		} else isOptional = requestBody.required !== true;
 	}
-	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 {
+		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: ""
+		}
+	};
+}
+function getBody({ requestBody, operationName, context, contentType }) {
+	return buildBody(filterByContentType(getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context), contentType), requestBody, operationName, context);
+}
+/**
+* Returns per-content-type bodies when `splitByContentType` is enabled.
+* Each entry includes a `contentTypeSuffix` for generating distinct function names.
+*/
+function getBodiesByContentType({ requestBody, operationName, context, contentType }) {
+	const filteredBodyTypes = filterByContentType(getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context, void 0, (item) => `${item.value}::${item.contentType}`), contentType);
+	if (filteredBodyTypes.length <= 1) return [{
+		...buildBody(filteredBodyTypes, requestBody, operationName, context),
+		contentTypeSuffix: ""
+	}];
+	return filteredBodyTypes.map((bodyType) => {
+		const suffix = getContentTypeSuffix(bodyType.contentType);
 		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)
+			...buildBody([bodyType], requestBody, operationName, context),
+			contentTypeSuffix: suffix
 		};
-	}
-	let resolvedValue;
-	const normalizedProperties = normalizedSchema.properties;
-	const schemaOneOf = schema.oneOf;
-	const schemaAnyOf = schema.anyOf;
-	if (normalizedProperties) resolvedValue = getScalar({
-		item: Object.fromEntries(Object.entries(normalizedSchema).filter(([key]) => key !== separator)),
-		name,
-		context,
-		formDataContext
 	});
-	else if (separator === "allOf" && (schemaOneOf || schemaAnyOf)) {
-		const siblingCombiner = schemaOneOf ? "oneOf" : "anyOf";
-		const siblingSchemas = schemaOneOf ?? schemaAnyOf;
-		resolvedValue = combineSchemas({
-			schema: { [siblingCombiner]: siblingSchemas },
-			name,
-			separator: siblingCombiner,
-			context,
-			nullable: ""
-		});
-	}
-	return {
-		value: dedupeUnionType(combineValues({
-			resolvedData,
-			separator,
-			resolvedValue,
-			context,
-			parentSchema: normalizedSchema
-		}) + nullable),
-		imports: resolvedValue ? [...resolvedData.imports, ...resolvedValue.imports] : resolvedData.imports,
-		schemas: resolvedValue ? [...resolvedData.schemas, ...resolvedValue.schemas] : resolvedData.schemas,
-		dependencies: resolvedValue ? [...resolvedData.dependencies, ...resolvedValue.dependencies] : resolvedData.dependencies,
-		isEnum: false,
-		type: "object",
-		isRef: false,
-		hasReadonlyProps: resolvedData.hasReadonlyProps || (resolvedValue?.hasReadonlyProps ?? false),
-		example: schema.example,
-		examples: resolveExampleRefs(schema.examples, context)
-	};
+}
+const CONTENT_TYPE_SUFFIX_MAP = {
+	"application/json": "Json",
+	"multipart/form-data": "FormData",
+	"application/x-www-form-urlencoded": "UrlEncoded",
+	"text/plain": "Text",
+	"application/xml": "Xml",
+	"text/xml": "Xml",
+	"application/octet-stream": "Blob"
+};
+function getContentTypeSuffix(contentType) {
+	if (CONTENT_TYPE_SUFFIX_MAP[contentType]) return CONTENT_TYPE_SUFFIX_MAP[contentType];
+	return (contentType.split("/")[1] ?? contentType).split(/[-+.]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 //#endregion
 //#region src/getters/discriminators.ts
@@ -4636,8 +4663,8 @@ function getSchema({ schema: { imports, model }, header, namingConvention = Nami
 	file += model;
 	return file;
 }
-function getPath(path$1, name, fileExtension) {
-	return path.join(path$1, `${name}${fileExtension}`);
+function getPath(path, name, fileExtension) {
+	return nodePath.join(path, `${name}${fileExtension}`);
 }
 function writeModelInline(acc, model) {
 	return acc + `${model}\n`;
@@ -4689,7 +4716,7 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		});
 	}
 	if (indexFiles) {
-		const schemaFilePath = path.join(schemaPath, `index.ts`);
+		const schemaFilePath = nodePath.join(schemaPath, `index.ts`);
 		await fs$1.ensureFile(schemaFilePath);
 		const ext = getImportExtension(fileExtension, tsconfig);
 		const conventionNamesSet = new Set(Object.values(schemaGroups).map((group) => conventionName(group[0].name, namingConvention)));
@@ -5000,7 +5027,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 			packageJson: output.packageJson,
 			output
 		});
-		const schemasPath = !output.schemas && needSchema ? path.join(dirname, filename + ".schemas" + extension) : void 0;
+		const schemasPath = !output.schemas && needSchema ? nodePath.join(dirname, filename + ".schemas" + extension) : void 0;
 		if (schemasPath) await writeGeneratedFile(schemasPath, generateSchemasInline ? header + generateSchemasInline() : header + generateModelsInline(builder.schemas));
 		if (mutators) implementationData += generateMutatorImports({
 			mutators,
@@ -5022,7 +5049,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 		}
 		implementationData += `\n${implementation}`;
 		const implementationFilename = filename + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-		const implementationPath = path.join(dirname, implementationFilename);
+		const implementationPath = nodePath.join(dirname, implementationFilename);
 		await writeGeneratedFile(implementationPath, implementationData);
 		const mockPaths = [];
 		for (const mockOutput of mockOutputs) {
@@ -5039,7 +5066,7 @@ async function writeSplitMode({ builder, output, projectName, header, needSchema
 				options: entry
 			});
 			mockData += `\n${mockOutput.implementation}`;
-			const mockPath = path.join(dirname, filename + "." + getMockFileExtensionByTypeName(entry) + extension);
+			const mockPath = nodePath.join(dirname, filename + "." + getMockFileExtensionByTypeName(entry) + extension);
 			await writeGeneratedFile(mockPath, mockData);
 			mockPaths.push(mockPath);
 		}
@@ -5235,7 +5262,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 	const indexFilePathsByType = /* @__PURE__ */ new Map();
 	if (output.mock.indexMockFiles) for (const entry of generatorEntries) {
 		const ext = getMockFileExtensionByTypeName(entry);
-		const indexPath = path.join(dirname, `index.${ext}${extension}`);
+		const indexPath = nodePath.join(dirname, `index.${ext}${extension}`);
 		indexFilePathsByType.set(ext, indexPath);
 		await fs$1.outputFile(indexPath, "");
 	}
@@ -5244,19 +5271,19 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 		try {
 			const { imports, implementation, mockOutputs, mutators, clientMutators, formData, fetchReviver, formUrlEncoded, paramsSerializer, paramsFilter } = target;
 			let implementationData = header;
-			const importerPath = path.join(dirname, tag, tag + extension);
+			const importerPath = nodePath.join(dirname, tag, tag + extension);
 			const relativeSchemasPath = output.schemas ? getRelativeImportPath(importerPath, getFileInfo(isString(output.schemas) ? output.schemas : output.schemas.path, { extension: output.fileExtension }).dirname) : "../" + filename + ".schemas" + extension.replace(/\.ts$/, "");
 			const tagNames = new Set(tagEntries.map(([t]) => t));
 			const serviceSuffix = OutputClient.ANGULAR === output.client ? ".service" : "";
 			const importsForBuilder = generateImportsForBuilder(output, imports.map((imp) => {
 				if (!imp.importPath) return imp;
 				if (!imp.importPath.startsWith(".")) return imp;
-				const resolvedPath = path.resolve(dirname, imp.importPath);
-				const targetBasename = path.basename(resolvedPath);
+				const resolvedPath = nodePath.resolve(dirname, imp.importPath);
+				const targetBasename = nodePath.basename(resolvedPath);
 				let targetFile;
 				if (tagNames.has(targetBasename)) {
 					const tagFilename = targetBasename + serviceSuffix + extension;
-					targetFile = path.join(resolvedPath, tagFilename);
+					targetFile = nodePath.join(resolvedPath, tagFilename);
 				} else targetFile = resolvedPath + extension;
 				const adjustedPath = getRelativeImportPath(importerPath, targetFile);
 				return {
@@ -5277,7 +5304,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 				packageJson: output.packageJson,
 				output
 			});
-			const schemasPath = !output.schemas && needSchema ? path.join(dirname, filename + ".schemas" + extension) : void 0;
+			const schemasPath = !output.schemas && needSchema ? nodePath.join(dirname, filename + ".schemas" + extension) : void 0;
 			if (schemasPath) await writeGeneratedFile(schemasPath, generateSchemasInline ? header + generateSchemasInline() : header + generateModelsInline(builder.schemas));
 			if (mutators) implementationData += generateMutatorImports({
 				mutators,
@@ -5318,7 +5345,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 			}
 			implementationData += `\n${implementation}`;
 			const implementationFilename = tag + (OutputClient.ANGULAR === output.client ? ".service" : "") + extension;
-			const implementationPath = path.join(dirname, tag, implementationFilename);
+			const implementationPath = nodePath.join(dirname, tag, implementationFilename);
 			await writeGeneratedFile(implementationPath, implementationData);
 			const mockPaths = [];
 			for (const mockOutput of mockOutputs) {
@@ -5335,7 +5362,7 @@ async function writeSplitTagsMode({ builder, output, projectName, header, needSc
 					options: entry
 				});
 				mockData += `\n${mockOutput.implementation}`;
-				const mockPath = path.join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(entry) + extension);
+				const mockPath = nodePath.join(dirname, tag, tag + "." + getMockFileExtensionByTypeName(entry) + extension);
 				await writeGeneratedFile(mockPath, mockData);
 				mockPaths.push(mockPath);
 			}
@@ -5413,7 +5440,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 					options: entry && !isFunction(entry) ? entry : void 0
 				});
 			}
-			const schemasPath = !output.schemas && needSchema ? path.join(dirname, filename + ".schemas" + extension) : void 0;
+			const schemasPath = !output.schemas && needSchema ? nodePath.join(dirname, filename + ".schemas" + extension) : void 0;
 			if (schemasPath) await writeGeneratedFile(schemasPath, generateSchemasInline ? header + generateSchemasInline() : header + generateModelsInline(builder.schemas));
 			if (mutators) data += generateMutatorImports({
 				mutators,
@@ -5439,7 +5466,7 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 				data += "\n\n";
 				data += implementationMock;
 			}
-			const implementationPath = path.join(dirname, `${kebab(tag)}${extension}`);
+			const implementationPath = nodePath.join(dirname, `${kebab(tag)}${extension}`);
 			await writeGeneratedFile(implementationPath, data);
 			return [implementationPath, ...schemasPath ? [schemasPath] : []];
 		} catch (error) {
@@ -5448,6 +5475,6 @@ async function writeTagsMode({ builder, output, projectName, header, needSchema,
 	}))).flat();
 }
 //#endregion
-export { BODY_TYPE_NAME, DefaultTag, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NAMED_COMPONENT_SECTIONS, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, SupportedFormatter, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, addDependency, asyncReduce, buildAngularParamsFilterExpression, camel, collectReferencedComponents, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, escapeRegExp, filterByContentType, filteredVerbs, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getAngularFilteredParamsCallExpression, getAngularFilteredParamsExpression, getAngularFilteredParamsHelperBody, getArray, getBaseUrlRuntimeImports, getBodiesByContentType, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getImportExtension, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSuccessResponseType, getTypedResponse, getWarningCount, isBinaryContentType, isBoolean, isComponentRef, isDirectory, isFakerMock, isFunction, isModule, isMswMock, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, isVerbose, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, logVerbose, logWarning, makeRouteSafe, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resetWarnings, resolveDiscriminators, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, setVerbose, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, wrapRouteParameters, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
+export { BODY_TYPE_NAME, DefaultTag, EnumGeneration, ErrorWithTag, FormDataArrayHandling, GetterPropType, LogLevels, NAMED_COMPONENT_SECTIONS, NamingConvention, OutputClient, OutputHttpClient, OutputMockType, OutputMode, PropertySortOrder, RefComponentSuffix, SchemaType, SupportedFormatter, TEMPLATE_TAG_REGEX, URL_REGEX, VERBS_WITH_BODY, Verbs, addDependency, asyncReduce, buildAngularParamsFilterExpression, camel, collectReferencedComponents, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicImport, escape, escapeRegExp, filterByContentType, filteredVerbs, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFormDataAndUrlEncodedFunction, generateImports, generateModelInline, generateModelsInline, generateMutator, generateMutatorConfig, generateMutatorImports, generateMutatorRequestOptions, generateOptions, generateParameterDefinition, generateQueryParamsAxiosConfig, generateSchemasDefinition, generateTarget, generateTargetForTags, generateVerbImports, generateVerbOptions, generateVerbsOptions, getAngularFilteredParamsCallExpression, getAngularFilteredParamsExpression, getAngularFilteredParamsHelperBody, getArray, getBaseUrlRuntimeImports, getBodiesByContentType, getBody, getCombinedEnumValue, getDefaultContentType, getEnum, getEnumDescriptions, getEnumImplementation, getEnumNames, getEnumUnionFromSchema, getExtension, getFileInfo, getFormDataFieldFileType, getFullRoute, getImportExtension, getIsBodyVerb, getKey, getMockFileExtensionByTypeName, getNumberWord, getObject, getOperationId, getOrvalGeneratedTypes, getParameters, getParams, getParamsInPath, getPropertySafe, getProps, getQueryParams, getRefInfo, getResReqTypes, getResponse, getResponseTypeCategory, getRoute, getRouteAsArray, getScalar, getSuccessResponseType, getTypedResponse, getWarningCount, isBinaryContentType, isBinaryScalarSchema, isBoolean, isComponentRef, isDirectory, isFakerMock, isFunction, isModule, isMswMock, isNullish, isNumber, isNumeric, isObject, isReference, isSchema, isString, isStringLike, isSyntheticDefaultImportsAllow, isUrl, isVerb, isVerbose, jsDoc, jsStringEscape, kebab, keyValuePairsToJsDoc, log, logError, logVerbose, logWarning, makeRouteSafe, mergeDeep, mismatchArgsMessage, pascal, removeFilesAndEmptyFolders, resetWarnings, resolveDiscriminators, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, setVerbose, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, wrapRouteParameters, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
 
 //# sourceMappingURL=index.mjs.map