@orval/core 8.12.2 → 8.13.0

package/dist/index.mjs

@@ -143,6 +143,16 @@ const TEMPLATE_TAG_REGEX = /\${(.+?)}/g;
 function isReference(obj) {
 	return !isNullish$1(obj) && Object.hasOwn(obj, "$ref");
 }
+/**
+* Discriminator helper for {@link OpenApiDynamicReferenceObject}.
+*
+* Returns `true` when `obj` has a `$dynamicRef` string property,
+* indicating it is an OpenAPI 3.1 dynamic reference rather than a
+* static `$ref`.
+*/
+function isDynamicReference(obj) {
+	return !isNullish$1(obj) && Object.hasOwn(obj, "$dynamicRef") && typeof obj.$dynamicRef === "string";
+}
 function isDirectory(pathValue) {
 	return !nodePath.extname(pathValue);
 }
@@ -741,13 +751,21 @@ function count(str = "", key) {
 var path_exports = /* @__PURE__ */ __exportAll({
 	getRelativeImportPath: () => getRelativeImportPath,
 	getSchemaFileName: () => getSchemaFileName,
+	isAbsolute: () => isAbsolute,
 	join: () => join,
 	joinSafe: () => joinSafe,
 	normalizeSafe: () => normalizeSafe,
 	relativeSafe: () => relativeSafe,
+	resolve: () => resolve,
 	separator: () => "/",
 	toUnix: () => toUnix
 });
+function isAbsolute(value) {
+	return nodePath.isAbsolute(value);
+}
+function resolve(...args) {
+	return toUnix(nodePath.resolve(...args));
+}
 function toUnix(value) {
 	value = value.replaceAll("\\", "/");
 	value = value.replaceAll(/(?<!^)\/+/g, "/");
@@ -1357,1591 +1375,1996 @@ function getRefInfo($ref, context) {
 		refPaths
 	};
 }
-//#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.
+* Extracts the anchor name from a fragment-only `$dynamicRef` (e.g. `#category` → `category`).
 *
-* @see https://spec.openapis.org/oas/v3.0.3#reference-object
-* @see https://spec.openapis.org/oas/v3.1.0#reference-object
+* Returns `undefined` for external-document `$dynamicRef` values (e.g. `other.json#anchor`)
+* which are not supported.
 */
-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);
-		}
+function getDynamicAnchorName(dynamicRef) {
+	if (!dynamicRef.startsWith("#") || dynamicRef.length <= 1) return;
+	return dynamicRef.slice(1);
+}
+//#endregion
+//#region src/getters/imports.ts
+function getAliasedImports({ name, resolvedValue, context }) {
+	return context.output.schemas && resolvedValue.isRef ? resolvedValue.imports.map((imp) => {
+		if (!needCreateImportAlias({
+			name,
+			imp
+		})) return imp;
 		return {
-			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));
+	}
+	const isAllEnums = resolvedData.isEnum.every(Boolean);
+	const isNullableEnumComposition = (separator === "anyOf" || separator === "oneOf") && !isAllEnums && resolvedData.isEnum.some(Boolean) && resolvedData.isEnum.every((isEnum, index) => isEnum && !resolvedData.isRef[index] || resolvedData.types[index] === "null");
+	if (isAllEnums && 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;
+	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: isNullableEnumComposition,
+		type: "object",
+		isRef: false,
+		hasReadonlyProps: resolvedData.hasReadonlyProps || (resolvedValue?.hasReadonlyProps ?? false),
+		example: schema.example,
+		examples: resolveExampleRefs(schema.examples, context)
+	};
 }
 //#endregion
-//#region src/getters/array.ts
+//#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: []
+	};
+}
 /**
-* Return the output type from an array
+* 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
+	});
+	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
+	};
+}
+/**
+* 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 === "array"
+* @param item item with type === "object"
 */
-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}[]`
-			});
-		}
+function getObject({ item, name, context, nullable, formDataContext }) {
+	if (isReference(item)) {
+		const { name } = getRefInfo(item.$ref, context);
 		return {
-			type: "array",
+			value: name + nullable,
+			imports: [{ name }],
+			schemas: [],
 			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)
+			type: "object",
+			isRef: true,
+			hasReadonlyProps: item.readOnly ?? false,
+			dependencies: [name],
+			example: item.example,
+			examples: resolveExampleRefs(item.examples, context)
 		};
 	}
-	if (schemaItems) {
-		const resolvedObject = resolveObject({
-			schema: schemaItems,
-			propName: name ? name + itemSuffix : void 0,
+	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,
-			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,
+	}
+	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: "array",
+			type: "object",
 			isRef: false,
-			hasReadonlyProps: resolvedObject.hasReadonlyProps,
-			example: schemaExample,
-			examples: resolveExampleRefs(schemaExamples, context)
+			hasReadonlyProps: false,
+			useTypeAlias: false,
+			dependencies: [],
+			example: schemaItem.example,
+			examples: resolveExampleRefs(schemaItem.examples, 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,
-		formDataContext
-	});
-	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,
+		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 (!isFormData && !isFormUrlEncoded || !effectivePropName || !mediaType.schema) return {
-				...resolvedValue,
-				imports: resolvedValue.imports,
-				dependencies: resolvedValue.dependencies,
-				contentType,
-				example: mediaType.example,
-				examples: resolveExampleRefs(mediaType.examples, context)
+			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;
+			}
+		}
+		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);
+			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
 /**
-* 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.
+* 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 contentType - The MIME content type (e.g., 'application/json', 'text/plain')
-* @returns The response type category to use for parsing
+* Accepts OAS 3.1 nullable unions (`type: ['string', 'null']`) since getScalar
+* normalizes those into `case 'string':` before invoking this predicate.
 */
-function getResponseTypeCategory(contentType) {
-	if (isBinaryContentType(contentType)) return "blob";
-	if (contentType === "application/json" || contentType.includes("+json") || contentType.includes("-json")) return "json";
-	return "text";
+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;
 }
 /**
-* Get the default content type from a list of content types.
-* Priority: application/json > any JSON-like type > first in list
+* Return the typescript equivalent of open-api data type
 *
-* @param contentTypes - Array of content types from OpenAPI spec
-* @returns The default content type to use
+* @param item
+* @ref https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#data-types
 */
-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`;
+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" || 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()";
-				}
+		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": {
+			const itemAllOf = item.allOf;
+			const itemOneOf = item.oneOf;
+			const itemAnyOf = item.anyOf;
+			let separator;
+			if (itemAllOf?.length) separator = "allOf";
+			else if (itemOneOf?.length) separator = "oneOf";
+			else if (itemAnyOf?.length) separator = "anyOf";
+			if (separator) return combineSchemas({
+				schema: Object.fromEntries(Object.entries(item).filter(([key]) => key !== "type")),
+				name,
+				separator,
+				context,
+				nullable: nullable || " | null",
+				formDataContext
+			});
+			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: ""
-		}
-	};
+//#region src/resolvers/ref.ts
+/** Convert a `$dynamicAnchor` name to a valid TypeScript generic parameter identifier. */
+function dynamicAnchorToParamName(anchor) {
+	return sanitize(anchor, {
+		underscore: "_",
+		whitespace: "_",
+		dash: "_",
+		es5keyword: true,
+		es5IdentifierName: true
+	});
 }
-function getBody({ requestBody, operationName, context, contentType }) {
-	return buildBody(filterByContentType(getResReqTypes([[context.output.override.components.requestBodies.suffix, requestBody]], operationName, context), contentType), requestBody, operationName, context);
+function dynamicAnchorsToUniqueParamNames(anchors) {
+	const result = /* @__PURE__ */ new Map();
+	const usedNames = /* @__PURE__ */ new Map();
+	for (const anchor of anchors) {
+		const base = dynamicAnchorToParamName(anchor);
+		const count = usedNames.get(base) ?? 0;
+		usedNames.set(base, count + 1);
+		const paramName = count === 0 ? base : `${base}${count + 1}`;
+		result.set(anchor, paramName);
+	}
+	return result;
 }
+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;
-}
-function getImportAliasForRefOrValue({ context, imports, resolvedValue }) {
-	if (!context.output.schemas || !resolvedValue.isRef) return resolvedValue.value;
-	return imports.find((imp) => imp.name === resolvedValue.value)?.alias ?? resolvedValue.value;
-}
-//#endregion
-//#region src/getters/keys.ts
-function getKey(key) {
-	return keyword.isIdentifierNameES5(key) ? key : `'${key}'`;
+	}
+	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
+	}]);
 }
-//#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: []
-		};
+/** Check whether a schema reference has at least one `$defs` entry with both `$dynamicAnchor` and `$ref`. */
+function isBoundAlias(schema) {
+	const defs = schema.$defs;
+	if (!defs || typeof defs !== "object") return false;
+	for (const defSchema of Object.values(defs)) {
+		if (!defSchema || typeof defSchema !== "object") continue;
+		const rec = defSchema;
+		if (typeof rec.$dynamicAnchor === "string" && typeof rec.$ref === "string") return true;
 	}
-	if (isString(propertyNames.const)) return {
-		value: `'${escape(propertyNames.const)}'`,
-		imports: [],
-		dependencies: []
-	};
+	return false;
 }
 /**
-* Resolve a narrowed key type from OpenAPI 3.1 propertyNames.
-* Supports inline enum/const and $ref string enums.
+* Extract bound-alias information from a schema that references a generic template
+* and binds `$dynamicAnchor` entries to concrete types via `$defs`.
 */
-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 extractBoundAliasInfo(schema, context) {
+	let bindingElement;
+	let extraSchemas;
+	if (isReference(schema) && isBoundAlias(schema)) bindingElement = schema;
+	else {
+		const allOf = schema.allOf;
+		if (Array.isArray(allOf)) for (let i = 0; i < allOf.length; i++) {
+			const element = allOf[i];
+			if (isReference(element) && isBoundAlias(element)) {
+				bindingElement = element;
+				extraSchemas = allOf.filter((_, j) => j !== i);
+				break;
+			}
+		}
+	}
+	if (!bindingElement) return void 0;
+	const defs = bindingElement.$defs;
+	if (!defs || typeof defs !== "object") return void 0;
+	const bindingByAnchor = /* @__PURE__ */ new Map();
+	for (const defSchema of Object.values(defs)) {
+		if (!defSchema || typeof defSchema !== "object") continue;
+		const rec = defSchema;
+		if (rec.$dynamicAnchor === void 0) continue;
+		const ref = rec.$ref;
+		if (!ref || !isComponentRef(ref)) continue;
+		const anchor = rec.$dynamicAnchor;
+		const { name, originalName } = getRefInfo(ref, context);
+		bindingByAnchor.set(anchor, {
+			typeName: name,
+			originalName
+		});
+	}
+	if (bindingByAnchor.size === 0) return void 0;
+	const refPath = bindingElement.$ref;
+	if (typeof refPath !== "string") return void 0;
+	const { name: genericName, refPaths: templateRefPaths } = getRefInfo(refPath, context);
+	const templateDefs = (templateRefPaths ? prop(context.spec, ...templateRefPaths) : void 0)?.$defs;
+	const typeArgs = [];
+	const genericParams = [];
+	const imports = [];
+	if (templateDefs && typeof templateDefs === "object") {
+		const templateAnchors = [];
+		for (const defSchema of Object.values(templateDefs)) {
+			if (!defSchema || typeof defSchema !== "object") continue;
+			const rec = defSchema;
+			if (rec.$dynamicAnchor === void 0 || rec.$ref !== void 0) continue;
+			templateAnchors.push(rec.$dynamicAnchor);
+		}
+		const uniqueNames = dynamicAnchorsToUniqueParamNames(templateAnchors);
+		for (const anchor of templateAnchors) {
+			const binding = bindingByAnchor.get(anchor);
+			if (binding) {
+				typeArgs.push(binding.typeName);
+				imports.push({
+					name: binding.typeName,
+					schemaName: binding.originalName
+				});
+			} else {
+				const paramName = uniqueNames.get(anchor) ?? dynamicAnchorToParamName(anchor);
+				typeArgs.push(paramName);
+				genericParams.push(paramName);
+			}
+		}
+	}
+	if (typeArgs.length === 0) for (const { typeName, originalName } of bindingByAnchor.values()) {
+		typeArgs.push(typeName);
+		imports.push({
+			name: typeName,
+			schemaName: originalName
+		});
+	}
 	return {
-		value: resolvedValue.value,
-		imports: resolvedValue.imports,
-		dependencies: resolvedValue.dependencies
+		genericName,
+		genericParams,
+		typeArgs,
+		imports,
+		extraSchemas
 	};
 }
+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 encodeJsonPointerSegment(segment) {
+	return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
 /**
-* Generate index signature key type based on propertyNames enum or const
-* Returns union type string like "'foo' | 'bar'", "'x'", or 'string' if neither
+* Build the dynamic scope for a schema: maps `$dynamicAnchor` names to concrete
+* type entries for self-referential resolution, `$defs` bindings, and sibling anchors.
 */
-function getIndexSignatureKey(item) {
-	return getPropertyNamesEnumKeyType(item)?.value ?? "string";
+function buildDynamicScope(schemaName, schema, context) {
+	const scope = {};
+	const getSchemaScopeEntry = (name) => {
+		const refInfo = getRefInfo(`#/components/schemas/${encodeJsonPointerSegment(name)}`, context);
+		return {
+			name: refInfo.name,
+			schemaName: refInfo.originalName
+		};
+	};
+	const schemaRecord = schema;
+	if (typeof schemaRecord.$dynamicAnchor === "string") scope[schemaRecord.$dynamicAnchor] = getSchemaScopeEntry(schemaName);
+	const defs = schemaRecord.$defs;
+	if (defs && typeof defs === "object") {
+		const unboundAnchors = [];
+		for (const [, defSchema] of Object.entries(defs)) {
+			if (!defSchema || typeof defSchema !== "object") continue;
+			const defRecord = defSchema;
+			if (typeof defRecord.$dynamicAnchor === "string") {
+				const anchorName = defRecord.$dynamicAnchor;
+				const refInDef = defSchema.$ref;
+				if (refInDef?.startsWith("#/components/schemas/")) {
+					const { name, originalName } = getRefInfo(refInDef, context);
+					scope[anchorName] = {
+						name,
+						schemaName: originalName
+					};
+				} else if (!refInDef) unboundAnchors.push(anchorName);
+			}
+		}
+		if (unboundAnchors.length > 0) {
+			const uniqueNames = dynamicAnchorsToUniqueParamNames(unboundAnchors);
+			for (const anchor of unboundAnchors) {
+				const paramName = uniqueNames.get(anchor);
+				if (paramName === void 0) continue;
+				scope[anchor] = {
+					name: paramName,
+					schemaName: paramName,
+					isParameter: true
+				};
+			}
+		}
+	}
+	return scope;
 }
-function getPropertyNamesRecordType(item, valueType, context) {
-	const keyType = getPropertyNamesKeyType(item, context);
-	if (!keyType) return;
+/**
+* Resolve a `$dynamicRef` anchor to its concrete type using the current dynamic scope.
+* Returns `{ schema: {}, resolvedTypeName: 'unknown' }` when no scope override exists.
+*/
+function resolveDynamicRef(anchorName, context, imports = []) {
+	let scopeEntry = (context.dynamicScope ?? {})[anchorName];
+	if (!scopeEntry) {
+		const schemas = context.spec.components?.schemas;
+		if (schemas && typeof schemas === "object") for (const [schemaName, schemaObj] of Object.entries(schemas)) {
+			if (!schemaObj || typeof schemaObj !== "object") continue;
+			if (schemaObj.$dynamicAnchor === anchorName) {
+				const refInfo = getRefInfo(`#/components/schemas/${encodeJsonPointerSegment(schemaName)}`, context);
+				scopeEntry = {
+					name: refInfo.name,
+					schemaName: refInfo.originalName
+				};
+				break;
+			}
+		}
+	}
+	if (!scopeEntry) return {
+		schema: {},
+		imports,
+		resolvedTypeName: "unknown"
+	};
+	if (scopeEntry.isParameter) return {
+		schema: {},
+		imports,
+		resolvedTypeName: scopeEntry.name
+	};
+	const resolvedTypeName = scopeEntry.name;
+	const schemaRef = `#/components/schemas/${encodeJsonPointerSegment(scopeEntry.schemaName)}`;
+	try {
+		const { schema: resolvedSchema, imports: resolvedImports } = resolveRef({ $ref: schemaRef }, context, imports);
+		return {
+			schema: resolvedSchema,
+			imports: resolvedImports,
+			resolvedTypeName
+		};
+	} catch {
+		return {
+			schema: {},
+			imports,
+			resolvedTypeName: "unknown"
+		};
+	}
+}
+/** 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/resolvers/value.ts
+const schemaArrayKeys = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+const schemaObjectKeys = [
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+];
+const schemaMapKeys = [
+	"$defs",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+];
+/**
+* Recursively walks a schema value and returns `true` if any nested
+* `$dynamicRef` resolves — via the current `context.dynamicScope` — to a
+* schema *other* than `refName`.
+*
+* Used by `resolveValue` to decide whether a `$ref`'d schema must be
+* instantiated with its bound type arguments rather than referenced by name.
+*
+* @param value   - The schema node (or sub-node) to inspect.
+* @param context - Current resolution context, including the dynamic scope.
+* @param refName - The resolved name of the enclosing `$ref` schema; dynamic
+*                  refs that resolve to this same name are considered
+*                  self-references and do not count as "scope-affected".
+* @param seen    - Cycle-guard; tracks already-visited objects.
+*/
+function hasScopeAffectedDynamicRef(value, context, refName, seen = /* @__PURE__ */ new WeakSet()) {
+	if (!value || typeof value !== "object") return false;
+	if (!context.dynamicScope || Object.keys(context.dynamicScope).length === 0) return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	if (isDynamicReference(value) && value.$dynamicRef.startsWith("#")) {
+		const anchorName = getDynamicAnchorName(value.$dynamicRef);
+		if (anchorName) {
+			const scopeEntry = context.dynamicScope[anchorName];
+			if (scopeEntry && scopeEntry.name !== refName) return true;
+		}
+	}
+	const schema = value;
+	for (const key of schemaArrayKeys) {
+		const items = schema[key];
+		if (Array.isArray(items) && items.some((item) => hasScopeAffectedDynamicRef(item, context, refName, seen))) return true;
+	}
+	for (const key of schemaObjectKeys) if (hasScopeAffectedDynamicRef(schema[key], context, refName, seen)) return true;
+	for (const key of schemaMapKeys) {
+		const schemaMap = schema[key];
+		if (schemaMap && typeof schemaMap === "object" && Object.values(schemaMap).some((item) => hasScopeAffectedDynamicRef(item, context, refName, seen))) return true;
+	}
+	return false;
+}
+function makeUnknownValue(originalSchema) {
 	return {
-		...keyType,
-		value: `Partial<Record<${keyType.value}, ${valueType}>>`
+		value: "unknown",
+		imports: [],
+		type: "unknown",
+		isEnum: false,
+		schemas: [],
+		isRef: false,
+		hasReadonlyProps: false,
+		originalSchema,
+		dependencies: []
 	};
 }
 /**
-* Return the output type from an object
+* Resolves an OpenAPI schema or reference object to a {@link ResolverValue}
+* that carries the TypeScript type string, required imports, and metadata.
 *
-* @param item item with type === "object"
+* Handles all schema forms in priority order:
+* 1. **Bound generic alias** — a `$ref` with `$defs` overrides; emits an
+*    instantiated generic expression such as `Paginated<User>`.
+* 2. **Component `$ref`** — a named `$ref` pointing to `#/components/…`;
+*    emits the schema name as a reference import.
+* 3. **Non-component `$ref`** — an anonymous or path-level ref; inlines the
+*    resolved schema via {@link getScalar} (cycle-safe).
+* 4. **`$dynamicRef`** — resolved via the active dynamic scope; falls back to
+*    `unknown` when the anchor is absent or the ref is a bare `#`.
+* 5. **Plain schema** — delegates to {@link getScalar} for all other cases
+*    (primitives, objects, arrays, enums, …).
 */
-function getObject({ item, name, context, nullable, formDataContext }) {
-	if (isReference(item)) {
-		const { name } = getRefInfo(item.$ref, context);
+function resolveValue({ schema, name, context, formDataContext }) {
+	if (isReference(schema)) {
+		const alias = extractBoundAliasInfo(schema, context);
+		if (alias) {
+			const value = `${alias.genericName}<${alias.typeArgs.join(", ")}>`;
+			const allImports = [{
+				name: alias.genericName,
+				schemaName: alias.genericName
+			}, ...alias.imports];
+			return {
+				value,
+				imports: allImports,
+				type: "object",
+				schemas: [],
+				isEnum: false,
+				originalSchema: schema,
+				hasReadonlyProps: false,
+				isRef: true,
+				dependencies: allImports.map((i) => i.name)
+			};
+		}
+		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) && hasScopeAffectedDynamicRef(schemaObject, context, refName)) return {
+			...getScalar({
+				item: schemaObject,
+				name: name ?? refName,
+				context: {
+					...context,
+					parents: [...context.parents ?? [], refName]
+				},
+				formDataContext
+			}),
+			originalSchema: schemaObject,
+			isRef: false
+		};
+		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: name + nullable,
-			imports: [{ name }],
+			value: resolvedImport.name + nullable,
+			imports: [{
+				name: resolvedImport.name,
+				schemaName: resolvedImport.schemaName
+			}],
+			type: schemaObject.type ?? "object",
 			schemas: [],
-			isEnum: false,
+			isEnum: !!schemaObject.enum,
+			originalSchema: schemaObject,
+			hasReadonlyProps,
+			isRef: true,
+			dependencies: [resolvedImport.name]
+		};
+	}
+	if (isDynamicReference(schema)) {
+		const dynamicRef = schema.$dynamicRef;
+		if (!dynamicRef.startsWith("#")) return makeUnknownValue(schema);
+		const anchorName = getDynamicAnchorName(dynamicRef);
+		if (!anchorName) return makeUnknownValue(schema);
+		const { imports: resolvedImports, resolvedTypeName } = resolveDynamicRef(anchorName, context);
+		if (resolvedTypeName === "unknown") return makeUnknownValue(schema);
+		return {
+			value: resolvedTypeName,
+			imports: resolvedImports,
 			type: "object",
+			isEnum: false,
+			schemas: [],
 			isRef: true,
-			hasReadonlyProps: item.readOnly ?? false,
-			dependencies: [name],
-			example: item.example,
-			examples: resolveExampleRefs(item.examples, context)
+			hasReadonlyProps: false,
+			originalSchema: schema,
+			dependencies: [resolvedTypeName]
 		};
 	}
-	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
-			})) },
+	return {
+		...getScalar({
+			item: schema,
 			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 });
+			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
+	};
+}
+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,
+		dynamicScope: context.dynamicScope
+	});
+	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 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,
+			context,
+			formDataContext
 		});
-		const acc = {
-			imports: [],
-			schemas: [],
-			value: "",
+		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: "object",
+			type: "array",
 			isRef: false,
-			hasReadonlyProps: false,
-			useTypeAlias: false,
-			dependencies: [],
-			example: schemaItem.example,
-			examples: resolveExampleRefs(schemaItem.examples, context)
+			hasReadonlyProps: resolvedObject.hasReadonlyProps,
+			example: schemaExample,
+			examples: resolveExampleRefs(schemaExamples, 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({
+	} 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,
+		formDataContext
+	});
+	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
+* 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 item
-* @ref https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#data-types
+* @param contentType - The MIME content type (e.g., 'application/json', 'text/plain')
+* @returns The response type category to use for parsing
 */
-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 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
-			});
-			return {
-				value,
-				...rest
-			};
-		}
-	}
-}
-//#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;
-		}
-		remainingAllOf.push(subSchema);
-	}
-	if (!didMerge || remainingAllOf.length === 0) return schema;
-	return {
-		...schema,
-		...Object.keys(mergedProperties).length > 0 && { properties: mergedProperties },
-		...mergedRequired.size > 0 && { required: [...mergedRequired] },
-		...remainingAllOf.length > 0 && { allOf: remainingAllOf }
-	};
-}
-function combineValues({ resolvedData, resolvedValue, separator, 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}:`);
+				isRequestBodyOptional,
+				encoding
 			});
-			if (discriminatedPropertySchemas.length > 0) resolvedDataValue = `Omit<${resolvedDataValue}, '${discriminatedPropertySchemas.map((s) => s.discriminator?.propertyName).join("' | '")}'>`;
+			form += formDataValues;
 		}
-		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;
+		return form;
 	}
-	let values = resolvedData.values;
-	if (resolvedData.allProperties.length && context.output.unionAddMissingProperties) {
-		values = [];
-		for (let i = 0; i < resolvedData.values.length; i += 1) {
-			const subSchema = resolvedData.originalSchema[i];
-			if (subSchema?.type !== "object" || !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 (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 `${form}${propName}.forEach(value => ${variableName}.append('data', ${valueStr}))\n`;
 	}
-	if (resolvedValue) return `(${values.join(` & ${resolvedValue.value}) | (`)} & ${resolvedValue.value})`;
-	return values.join(" | ");
+	if (schema.type === "number" || schema.type === "integer" || schema.type === "boolean") return `${form}${variableName}.append('data', ${propName}.toString())\n`;
+	return `${form}${variableName}.append('data', ${propName})\n`;
 }
-function combineSchemas({ name, schema, separator, 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({
+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,
-			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: `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)
-		};
+			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 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;
+			}
+			formDataValues += `if(${valueKey} !== undefined && ${nonOptionalValueKey} !== null) {\n ${formDataValue} }\n`;
+			continue;
+		}
+		if (isRequired) {
+			formDataValues += formDataValue;
+			continue;
+		}
+		formDataValues += `if(${valueKey} !== undefined) {\n ${formDataValue} }\n`;
 	}
-	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 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 {
-		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)
+		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 {
+			...buildBody([bodyType], requestBody, operationName, context),
+			contentTypeSuffix: suffix
+		};
+	});
+}
+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
 function resolveDiscriminators(schemas, context) {
@@ -2991,6 +3414,61 @@ function resolveDiscriminators(schemas, context) {
 			}
 		}
 	}
+	for (const [parentName, parentSchema] of Object.entries(transformedSchemas)) {
+		if (isBoolean$1(parentSchema)) continue;
+		if (!parentSchema.oneOf || !parentSchema.discriminator?.mapping) continue;
+		const { mapping, propertyName } = parentSchema.discriminator;
+		if (!propertyName) continue;
+		const parentProperties = parentSchema.properties;
+		const parentRequired = parentSchema.required;
+		const inheritableProps = {};
+		if (parentProperties) {
+			for (const [key, value] of Object.entries(parentProperties)) if (key !== propertyName) inheritableProps[key] = value;
+		}
+		const inheritableRequired = parentRequired?.filter((key) => key !== propertyName);
+		const hasInheritableProps = Object.keys(inheritableProps).length > 0;
+		for (const mappingValue of Object.values(mapping)) {
+			let variantSchema;
+			try {
+				const { originalName } = getRefInfo(mappingValue, context);
+				variantSchema = transformedSchemas[pascal(originalName)] ?? transformedSchemas[originalName];
+			} catch {
+				variantSchema = transformedSchemas[mappingValue];
+			}
+			if (!variantSchema || isBoolean$1(variantSchema)) continue;
+			const variantAllOf = variantSchema.allOf;
+			if (!variantAllOf) continue;
+			const rewritten = [];
+			for (const item of variantAllOf) {
+				if (!isReference(item) || !item.$ref) {
+					rewritten.push(item);
+					continue;
+				}
+				let refOriginalName;
+				try {
+					refOriginalName = getRefInfo(item.$ref, context).originalName;
+				} catch {
+					refOriginalName = void 0;
+				}
+				if (!(refOriginalName === parentName || refOriginalName !== void 0 && pascal(refOriginalName) === pascal(parentName))) {
+					rewritten.push(item);
+					continue;
+				}
+				const inlinedParent = { ...parentSchema };
+				delete inlinedParent.oneOf;
+				delete inlinedParent.discriminator;
+				delete inlinedParent.allOf;
+				delete inlinedParent.anyOf;
+				if (hasInheritableProps) inlinedParent.properties = { ...inheritableProps };
+				else delete inlinedParent.properties;
+				if (inheritableRequired && inheritableRequired.length > 0) inlinedParent.required = [...inheritableRequired];
+				else delete inlinedParent.required;
+				if (Object.keys(inlinedParent).filter((key) => key !== "type").length > 0) rewritten.push(inlinedParent);
+			}
+			if (rewritten.length === 0) delete variantSchema.allOf;
+			else variantSchema.allOf = rewritten;
+		}
+	}
 	return transformedSchemas;
 }
 //#endregion
@@ -3243,7 +3721,8 @@ function getQueryParamsTypes(queryParams, operationName, context) {
 		};
 		if (resolvedValue.isEnum && !resolvedValue.isRef) {
 			const enumName = queryName;
-			const enumValue = getEnum(resolvedValue.value, enumName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
+			const parameterAsSchema = parameter;
+			const enumValue = getEnum(resolvedValue.value, enumName, getEnumNames(resolvedValue.originalSchema) ?? getEnumNames(parameterAsSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema) ?? getEnumDescriptions(parameterAsSchema), context.output.override.namingConvention.enum);
 			return {
 				name,
 				required,
@@ -3285,6 +3764,7 @@ function getQueryParams({ queryParams, operationName, context, suffix = "params"
 		},
 		deps: schemas,
 		isOptional: allOptional,
+		paramNames: types.map(({ name }) => name),
 		requiredNullableKeys,
 		...nonPrimitiveKeys.length > 0 ? { nonPrimitiveKeys } : {}
 	};
@@ -3443,6 +3923,231 @@ function generateComponentDefinition(responses = {}, context, suffix) {
 	return generatorSchemas;
 }
 //#endregion
+//#region src/generators/factory.ts
+const circularRefCache = /* @__PURE__ */ new WeakMap();
+function getSchemasPath(context) {
+	const { schemas, target } = context.output;
+	if (schemas) return normalizeSafe(isString(schemas) ? schemas : schemas.path);
+	const { dirname, filename } = getFileInfo(target);
+	return joinSafe(dirname, filename + ".schemas");
+}
+function getSchemaImportPath(refName, context) {
+	if (context.output.factoryMethods?.mode === "single") return;
+	let outputDir = context.output.factoryMethods?.outputDirectory;
+	let schemasPath = getSchemasPath(context);
+	if (context.output.workspace) {
+		if (outputDir && !isAbsolute(outputDir)) outputDir = resolve(context.output.workspace, outputDir);
+		if (schemasPath && !isAbsolute(schemasPath)) schemasPath = resolve(context.output.workspace, schemasPath);
+	}
+	return joinSafe(outputDir ? relativeSafe(outputDir, schemasPath) : "./", conventionName(refName, context.output.namingConvention));
+}
+function isReference$1(schema) {
+	return "$ref" in schema;
+}
+function getResolvedRef(schema, context) {
+	return resolveRef(schema, context);
+}
+function getProperties(schema) {
+	return schema.properties ?? {};
+}
+function getItems(schema) {
+	return schema.items;
+}
+function getAdditionalProperties(schema) {
+	return schema.additionalProperties;
+}
+function getSchemas(schemas) {
+	return schemas;
+}
+function getExtendedProps(schema) {
+	const extended = schema;
+	return {
+		constValue: extended.const,
+		prefixItems: extended.prefixItems,
+		minItems: extended.minItems
+	};
+}
+function generateFactory(schema, name, context) {
+	if (!canGenerateSchema(schema) || !context.output.factoryMethods) return void 0;
+	const { functionNamePrefix, mode } = context.output.factoryMethods;
+	const factoryName = `${functionNamePrefix}${pascal(name)}`;
+	const imports = [];
+	const payload = buildPayload(schema, context, [name], imports);
+	if (mode !== "single") {
+		const schemaImportPath = getSchemaImportPath(name, context);
+		imports.push({
+			name,
+			importPath: schemaImportPath
+		});
+	}
+	return {
+		model: `export function ${factoryName}(): ${name} {\n  return ${payload};\n}\n`,
+		imports
+	};
+}
+function canGenerateSchema(schema) {
+	return schema.type === "object" || schema.type === "array" || !!schema.properties || !!schema.allOf || !!schema.oneOf || !!schema.anyOf || !!schema.items || !!schema.enum;
+}
+function hasCircularReference(target, sourceName, context, visited = /* @__PURE__ */ new Set()) {
+	if (isReference$1(target)) {
+		const { imports, schema } = getResolvedRef(target, context);
+		const refName = imports[0]?.name;
+		if (refName === sourceName) return true;
+		if (refName && visited.has(refName)) return false;
+		if (refName) visited.add(refName);
+		let cache = circularRefCache.get(context);
+		if (!cache) {
+			cache = /* @__PURE__ */ new Map();
+			circularRefCache.set(context, cache);
+		}
+		const cacheKey = refName ? `${sourceName}::${refName}` : void 0;
+		if (cacheKey) {
+			const cached = cache.get(cacheKey);
+			if (cached !== void 0) return cached;
+		}
+		const result = hasCircularReference(schema, sourceName, context, visited);
+		if (cacheKey) cache.set(cacheKey, result);
+		return result;
+	}
+	const check = (schemas) => schemas?.some((s) => hasCircularReference(s, sourceName, context, visited)) ?? false;
+	const items = getItems(target);
+	const additionalProperties = getAdditionalProperties(target);
+	return check(getSchemas(target.allOf)) || check(getSchemas(target.oneOf)) || check(getSchemas(target.anyOf)) || Object.values(getProperties(target)).some((s) => hasCircularReference(s, sourceName, context, visited)) || !!items && hasCircularReference(items, sourceName, context, visited) || typeof additionalProperties === "object" && hasCircularReference(additionalProperties, sourceName, context, visited);
+}
+function buildPayload(target, context, parents, imports) {
+	if (isReference$1(target)) return buildRefPayload(target, context, parents, imports);
+	const schema = target;
+	if (schema.allOf) return buildAllOfPayload(getSchemas(schema.allOf) ?? [], context, parents, imports);
+	if (schema.oneOf) return buildFirstOfPayload(getSchemas(schema.oneOf) ?? [], context, parents, imports);
+	if (schema.anyOf) return buildFirstOfPayload(getSchemas(schema.anyOf) ?? [], context, parents, imports);
+	const { constValue } = getExtendedProps(schema);
+	if (constValue !== void 0) return formatValue(constValue);
+	if (schema.default !== void 0) return buildDefaultPayload(schema, context);
+	const schemaType = inferSchemaType(schema);
+	if (schemaType === "object" || schema.properties) return buildObjectPayload(schema, context, parents, imports);
+	if (schemaType === "array") return buildArrayPayload(schema, context, parents, imports);
+	return buildPrimitivePayload(schema, schemaType, context);
+}
+function buildRefPayload(schema, context, parents, imports) {
+	const { schema: resolved, imports: refImports } = getResolvedRef(schema, context);
+	const refName = refImports[0]?.name;
+	if (!refName) return "{}";
+	if (parents.includes(refName) || hasCircularReference(resolved, parents[0], context)) {
+		imports.push({
+			name: refName,
+			importPath: getSchemaImportPath(refName, context)
+		});
+		return `{} as ${refName}`;
+	}
+	const { functionNamePrefix = "create", mode = "single" } = context.output.factoryMethods ?? {};
+	const refFactoryName = `${functionNamePrefix}${pascal(refName)}`;
+	if (mode !== "single-split") {
+		const importPath = resolveImportPath(mode, refName, context);
+		imports.push({
+			name: refFactoryName,
+			importPath,
+			isConstant: true
+		});
+	}
+	imports.push({
+		name: refName,
+		importPath: getSchemaImportPath(refName, context)
+	});
+	return `${refFactoryName}()`;
+}
+function resolveImportPath(mode, refName, context) {
+	const baseName = conventionName(refName, context.output.namingConvention);
+	switch (mode) {
+		case "split": return `./${baseName}.factory`;
+		case "single-split": return `./${conventionName("factoryMethods", context.output.namingConvention)}`;
+		case "single": return `./${baseName}`;
+	}
+}
+function buildAllOfPayload(allOf, context, parents, imports) {
+	const payloads = allOf.map((s) => buildPayload(s, context, parents, imports));
+	return payloads.length > 0 ? `Object.assign({}, ${payloads.join(", ")})` : "{}";
+}
+function buildFirstOfPayload(schemas, context, parents, imports) {
+	const first = schemas[0];
+	return first ? buildPayload(first, context, parents, imports) : "{}";
+}
+function buildObjectPayload(schema, context, parents, imports) {
+	const { includeOptionalProperty = false } = context.output.factoryMethods ?? {};
+	const props = getProperties(schema);
+	const requiredProps = schema.required ?? [];
+	const entries = Object.entries(props);
+	if (context.output.propertySortOrder === PropertySortOrder.ALPHABETICAL) entries.sort(([a], [b]) => a.localeCompare(b));
+	const includeOptional = includeOptionalProperty;
+	const lines = [];
+	for (const [key, prop] of entries) {
+		const isRequired = requiredProps.includes(key);
+		const resolved = isReference$1(prop) ? getResolvedRef(prop, context).schema : prop;
+		const isReadOnly = !!prop.readOnly || !!resolved.readOnly;
+		const isWriteOnly = !!prop.writeOnly || !!resolved.writeOnly;
+		if (!isRequired) {
+			if (isReadOnly) continue;
+			if (!isWriteOnly && !includeOptional) continue;
+		}
+		const payload = buildPayload(prop, context, parents, imports);
+		const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+		lines.push(`${safeKey}: ${payload}`);
+	}
+	return `{\n    ${lines.join(",\n    ")}\n  }`;
+}
+function buildArrayPayload(schema, context, parents, imports) {
+	const { prefixItems, minItems } = getExtendedProps(schema);
+	const items = getItems(schema);
+	if (prefixItems && prefixItems.length > 0) return `[${prefixItems.map((item) => buildPayload(item, context, parents, imports)).join(", ")}]`;
+	if (minItems && items) {
+		const MAX_MIN_ITEMS = 50;
+		if (minItems > MAX_MIN_ITEMS) logWarning(`Warning: minItems is ${minItems}, capping at ${MAX_MIN_ITEMS} to prevent massive payload.`);
+		const count = Math.min(minItems, MAX_MIN_ITEMS);
+		const itemPayload = buildPayload(items, context, parents, imports);
+		return `[${Array.from({ length: count }).fill(itemPayload).join(", ")}]`;
+	}
+	return "[]";
+}
+function inferSchemaType(schema) {
+	let type = schema.type;
+	if (Array.isArray(type)) {
+		const nonNull = type.filter((t) => t !== "null");
+		type = nonNull.length > 0 ? nonNull[0] : "null";
+	}
+	if (!type && schema.items) return "array";
+	if (!type && schema.enum) {
+		const first = schema.enum[0];
+		if (typeof first === "number") return "number";
+		if (typeof first === "boolean") return "boolean";
+		return "string";
+	}
+	return type;
+}
+function buildDefaultPayload(schema, context) {
+	if (context.output.override.useDates && typeof schema.default === "string" && (schema.format === "date" || schema.format === "date-time")) return `new Date('${schema.default}')`;
+	return formatValue(schema.default);
+}
+function buildPrimitivePayload(schema, schemaType, context) {
+	if (schemaType === "null") return "null";
+	const enumValues = schema.enum;
+	if (schemaType === "boolean") return enumValues && enumValues.length > 0 ? String(enumValues[0]) : "false";
+	if (schemaType === "number" || schemaType === "integer") return enumValues && enumValues.length > 0 ? String(enumValues[0]) : "0";
+	if (schemaType === "string") {
+		if (enumValues && enumValues.length > 0) {
+			const first = enumValues[0];
+			return typeof first === "string" ? JSON.stringify(first) : String(first);
+		}
+		if (schema.format === "date" || schema.format === "date-time") return context.output.override.useDates ? "new Date(0)" : `'${(/* @__PURE__ */ new Date(0)).toISOString()}'`;
+		return "''";
+	}
+	return "undefined as unknown";
+}
+function formatValue(val) {
+	if (val === null) return "null";
+	if (typeof val === "string") return JSON.stringify(val);
+	if (typeof val === "object") return JSON.stringify(val);
+	return String(val);
+}
+//#endregion
 //#region src/generators/imports.ts
 function generateImports({ imports, namingConvention = NamingConvention.CAMEL_CASE, importExtension = "" }) {
 	if (imports.length === 0) return "";
@@ -4133,7 +4838,7 @@ function generateParameterDefinition(parameters = {}, context, suffix) {
 * @param name interface name
 * @param schema
 */
-function generateInterface({ name, schema, context }) {
+function generateInterface({ name, schema, context, genericParams }) {
 	const scalar = getScalar({
 		item: schema,
 		name,
@@ -4141,6 +4846,7 @@ function generateInterface({ name, schema, context }) {
 	});
 	const isEmptyObject = scalar.value === "{}";
 	const shouldUseTypeAlias = context.output.override.useTypeOverInterfaces ?? scalar.useTypeAlias;
+	const genericSuffix = genericParams && genericParams.length > 0 ? `<${genericParams.join(", ")}>` : "";
 	let model = "";
 	model += jsDoc(schema);
 	if (isEmptyObject) model += "// eslint-disable-next-line @typescript-eslint/no-empty-interface\n";
@@ -4148,12 +4854,12 @@ function generateInterface({ name, schema, context }) {
 		const properties = schema.properties;
 		if (properties && Object.values(properties).length > 0 && Object.values(properties).every((item) => "const" in item)) {
 			const mappedScalarValue = scalar.value.replaceAll(";", ",").replaceAll("?:", ":");
-			model += `export const ${name}Value = ${mappedScalarValue} as const;\nexport type ${name} = typeof ${name}Value;\n`;
+			model += `export const ${name}Value = ${mappedScalarValue} as const;\nexport type ${name}${genericSuffix} = typeof ${name}Value;\n`;
 		} else {
 			const blankInterfaceValue = scalar.value === "unknown" ? "{}" : scalar.value;
-			model += `export interface ${name} ${blankInterfaceValue}\n`;
+			model += `export interface ${name}${genericSuffix} ${blankInterfaceValue}\n`;
 		}
-	} else model += `export type ${name} = ${scalar.value};\n`;
+	} else model += `export type ${name}${genericSuffix} = ${scalar.value};\n`;
 	const externalModulesImportsOnly = scalar.imports.filter((importName) => importName.alias ? importName.alias !== name : importName.name !== name);
 	return [...scalar.schemas, {
 		name,
@@ -4187,6 +4893,17 @@ function generateSchemasDefinition(schemas = {}, context, suffix, filters) {
 		const normalizedName = conventionName(schema.name, context.output.namingConvention);
 		if (!seenNames.has(normalizedName)) {
 			seenNames.add(normalizedName);
+			if (context.output.factoryMethods && schema.schema) {
+				const factoryData = generateFactory(schema.schema, schema.name, context);
+				if (factoryData) if (context.output.factoryMethods.mode === "single") {
+					schema.model += `\n${factoryData.model}`;
+					for (const imp of factoryData.imports) if (!schema.imports.some((existing) => existing.name === imp.name)) schema.imports.push(imp);
+				} else {
+					schema.factory = factoryData.model;
+					schema.factoryImports = factoryData.imports;
+					schema.factoryMode = context.output.factoryMethods.mode;
+				}
+			}
 			deduplicatedModels.push(schema);
 		}
 	}
@@ -4231,6 +4948,21 @@ function shouldCreateInterface(schema) {
 	const isNullable = isArray(schema.type) && schema.type.includes("null");
 	return (!schema.type || schema.type === "object") && !schema.allOf && !schema.oneOf && !schema.anyOf && isDereferenced(schema) && !schema.enum && !isNullable;
 }
+function collectGenericParams(schema) {
+	const defs = schema.$defs;
+	if (!defs || typeof defs !== "object") return [];
+	const anchors = [];
+	for (const defSchema of Object.values(defs)) {
+		if (!defSchema || typeof defSchema !== "object") continue;
+		const rec = defSchema;
+		if (rec.$dynamicAnchor !== void 0 && rec.$ref === void 0) anchors.push(rec.$dynamicAnchor);
+	}
+	const uniqueNames = dynamicAnchorsToUniqueParamNames(anchors);
+	return anchors.map((anchor) => ({
+		anchorName: anchor,
+		paramName: uniqueNames.get(anchor) ?? dynamicAnchorToParamName(anchor)
+	}));
+}
 function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 	const sanitizedSchemaName = sanitize(`${pascal(schemaName)}${suffix}`, {
 		underscore: "_",
@@ -4245,22 +4977,82 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 		imports: [],
 		schema
 	}];
+	const alias = extractBoundAliasInfo(schema, context);
+	if (alias) {
+		const genericParams = alias.genericParams.map((paramName) => ({
+			anchorName: paramName,
+			paramName
+		}));
+		const genericSuffix = genericParams.length > 0 ? `<${genericParams.map((p) => p.paramName).join(", ")}>` : "";
+		const typeArgsStr = alias.typeArgs.join(", ");
+		const genericPart = `${alias.genericName}<${typeArgsStr}>`;
+		const schemaType = schema.type;
+		const nullable = Array.isArray(schemaType) && schemaType.includes("null") || schema.nullable === true ? " | null" : "";
+		let model;
+		const allImports = [{
+			name: alias.genericName,
+			schemaName: alias.genericName
+		}, ...alias.imports];
+		if (alias.extraSchemas && alias.extraSchemas.length > 0) {
+			const aliasScopedContext = {
+				...context,
+				dynamicScope: buildDynamicScope(schemaName, schema, context)
+			};
+			const subSchemas = [];
+			model = `export type ${sanitizedSchemaName}${genericSuffix} = (${[genericPart, ...alias.extraSchemas.map((extraSchema) => {
+				const resolved = resolveValue({
+					schema: extraSchema,
+					name: sanitizedSchemaName,
+					context: aliasScopedContext
+				});
+				for (const imp of resolved.imports) {
+					const impSchemaName = imp.schemaName ?? imp.name;
+					if (!allImports.some((a) => a.name === imp.name && a.schemaName === impSchemaName)) allImports.push({
+						name: imp.name,
+						schemaName: impSchemaName
+					});
+				}
+				for (const sub of resolved.schemas) if (sub.name !== sanitizedSchemaName) subSchemas.push(sub);
+				return resolved.value;
+			})].join(" & ")})${nullable};\n`;
+			return [...subSchemas, {
+				name: sanitizedSchemaName,
+				model,
+				imports: allImports,
+				dependencies: allImports.map((i) => i.name),
+				schema
+			}];
+		} else model = `export type ${sanitizedSchemaName}${genericSuffix} = ${genericPart}${nullable};\n`;
+		return [{
+			name: sanitizedSchemaName,
+			model,
+			imports: allImports,
+			dependencies: allImports.map((i) => i.name),
+			schema
+		}];
+	}
+	const scopedContext = isBoolean(schema) ? context : {
+		...context,
+		dynamicScope: buildDynamicScope(schemaName, schema, context)
+	};
+	const genericParams = collectGenericParams(schema);
 	if (shouldCreateInterface(schema)) return generateInterface({
 		name: sanitizedSchemaName,
 		schema,
-		context
+		context: scopedContext,
+		genericParams: genericParams.length > 0 ? genericParams.map((p) => p.paramName) : void 0
 	});
 	const resolvedValue = resolveValue({
 		schema,
 		name: sanitizedSchemaName,
-		context
+		context: scopedContext
 	});
 	let output = "";
 	let imports = resolvedValue.imports;
 	output += jsDoc(schema);
 	if (resolvedValue.isEnum && !resolvedValue.isRef) output += getEnum(resolvedValue.value, sanitizedSchemaName, getEnumNames(resolvedValue.originalSchema), context.output.override.enumGenerationType, getEnumDescriptions(resolvedValue.originalSchema), context.output.override.namingConvention.enum);
 	else if (sanitizedSchemaName === resolvedValue.value && resolvedValue.isRef) {
-		const { schema: referredSchema } = resolveRef(schema, context);
+		const { schema: referredSchema } = resolveRef(schema, scopedContext);
 		if (!shouldCreateInterface(referredSchema)) {
 			const imp = resolvedValue.imports.find((imp) => imp.name === sanitizedSchemaName);
 			if (imp) {
@@ -4281,7 +5073,8 @@ function generateSchemaDefinitions(schemaName, schema, context, suffix) {
 			resolvedValue.dependencies.push(...schema.dependencies ?? []);
 			return false;
 		});
-		output += `export type ${sanitizedSchemaName} = ${resolvedValue.value};\n`;
+		const genericSuffix = genericParams.length > 0 ? `<${genericParams.map((p) => p.paramName).join(", ")}>` : "";
+		output += `export type ${sanitizedSchemaName}${genericSuffix} = ${resolvedValue.value};\n`;
 	}
 	return [...resolvedValue.schemas, {
 		name: sanitizedSchemaName,
@@ -4593,33 +5386,54 @@ function getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtensi
 		canonicalNameMap
 	};
 }
-function normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension, tsconfig) {
+function normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension, tsconfig, factoryOutputDirectory) {
 	const importExtension = getImportExtension(fileExtension, tsconfig);
-	for (const schema of schemas) schema.imports = schema.imports.map((imp) => {
-		const canonicalByName = canonicalNameMap.get(imp.name);
-		const resolvedImportKey = resolveImportKey(schemaPath, imp.importPath ?? `./${conventionName(imp.name, namingConvention)}`, fileExtension);
-		const canonicalByPath = canonicalPathMap.get(resolvedImportKey);
-		const canonical = canonicalByName ?? canonicalByPath;
-		if (!canonical?.importPath) return imp;
-		const relative = relativeSafe(schemaPath, canonical.importPath.replaceAll("\\", "/"));
-		const importPath = `${relative.endsWith(fileExtension) ? relative.slice(0, -fileExtension.length) : relative.replace(/\.ts$/, "")}${importExtension}`;
-		return {
-			...imp,
-			importPath
-		};
-	});
+	const factoryDir = factoryOutputDirectory ?? schemaPath;
+	for (const schema of schemas) {
+		schema.imports = schema.imports.map((imp) => {
+			const canonicalByName = canonicalNameMap.get(imp.name);
+			const resolvedImportKey = resolveImportKey(schemaPath, imp.importPath ?? `./${conventionName(imp.name, namingConvention)}`, fileExtension);
+			const canonicalByPath = canonicalPathMap.get(resolvedImportKey);
+			const canonical = canonicalByName ?? canonicalByPath;
+			if (!canonical?.importPath) return imp;
+			const relative = relativeSafe(schemaPath, canonical.importPath.replaceAll("\\", "/"));
+			const importPath = `${relative.endsWith(fileExtension) ? relative.slice(0, -fileExtension.length) : relative.replace(/\.ts$/, "")}${importExtension}`;
+			return {
+				...imp,
+				importPath
+			};
+		});
+		if (schema.factoryImports) schema.factoryImports = schema.factoryImports.map((imp) => {
+			const canonicalByName = canonicalNameMap.get(imp.name);
+			const resolvedImportKey = resolveImportKey(factoryDir, imp.importPath ?? `./${conventionName(imp.name, namingConvention)}`, fileExtension);
+			const canonicalByPath = canonicalPathMap.get(resolvedImportKey);
+			const canonical = canonicalByName ?? canonicalByPath;
+			if (!canonical?.importPath) return imp;
+			const relative = relativeSafe(factoryDir, canonical.importPath.replaceAll("\\", "/"));
+			const importPath = `${relative.endsWith(fileExtension) ? relative.slice(0, -fileExtension.length) : relative.replace(/\.ts$/, "")}${importExtension}`;
+			return {
+				...imp,
+				importPath
+			};
+		});
+	}
 }
 function mergeSchemaGroup(schemas) {
 	const baseSchemaName = schemas[0].name;
 	const baseSchema = schemas[0].schema;
 	const mergedImports = [...new Map(schemas.flatMap((schema) => schema.imports).map((imp) => [JSON.stringify(imp), imp])).values()];
 	const mergedDependencies = [...new Set(schemas.flatMap((schema) => schema.dependencies ?? []))];
+	const mergedFactory = schemas.map((s) => s.factory).filter(Boolean).join("\n");
+	const mergedFactoryImports = [...new Map(schemas.flatMap((schema) => schema.factoryImports ?? []).map((imp) => [JSON.stringify(imp), imp])).values()];
 	return {
 		name: baseSchemaName,
 		schema: baseSchema,
 		model: schemas.map((schema) => schema.model).join("\n"),
 		imports: mergedImports,
-		dependencies: mergedDependencies
+		dependencies: mergedDependencies,
+		factory: mergedFactory || void 0,
+		factoryImports: mergedFactoryImports,
+		factoryMode: schemas[0].factoryMode
 	};
 }
 function resolveImportKey(schemaPath, importPath, fileExtension) {
@@ -4661,10 +5475,39 @@ async function writeSchema({ path, schema, target, namingConvention, fileExtensi
 		throw new Error(`Oups... 🍻. An Error occurred while writing schema ${name} => ${String(error)}`, { cause: error });
 	}
 }
-async function writeSchemas({ schemaPath, schemas, target, namingConvention, fileExtension, header, indexFiles, tsconfig }) {
+async function emitFactoryForSchema(schema, namingConvention, header, factoryDir, fileExtension, helpers) {
+	if (schema.factory && schema.factoryMode) {
+		const mode = schema.factoryMode;
+		if (mode === "split") {
+			const factoryName = `${conventionName(schema.name, namingConvention)}.factory`;
+			helpers.separateFactoryNames.push(factoryName);
+			const factoryFile = `${header}\n${generateImports({
+				imports: schema.factoryImports ?? [],
+				namingConvention
+			})}\n\n${schema.factory}`;
+			await writeGeneratedFile(getPath(factoryDir, factoryName, fileExtension), factoryFile);
+		} else if (mode === "single-split") {
+			helpers.isCombined.value = true;
+			helpers.combinedFactoryContent.value += `${schema.factory}\n`;
+			helpers.combinedFactoryImports.push(...schema.factoryImports ?? []);
+		}
+	}
+}
+async function writeSchemas({ schemaPath, schemas, target, namingConvention, fileExtension, header, indexFiles, tsconfig, factoryOutputDirectory }) {
 	const schemaGroups = getSchemaGroups(schemaPath, schemas, namingConvention, fileExtension);
 	const { canonicalPathMap, canonicalNameMap } = getCanonicalMap(schemaGroups, schemaPath, namingConvention, fileExtension);
-	normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension, tsconfig);
+	normalizeCanonicalImportPaths(schemas, canonicalPathMap, canonicalNameMap, schemaPath, namingConvention, fileExtension, tsconfig, factoryOutputDirectory);
+	const factoryDir = factoryOutputDirectory ?? schemaPath;
+	const combinedFactoryContent = { value: "" };
+	const combinedFactoryImports = [];
+	const isCombined = { value: false };
+	const separateFactoryNames = [];
+	const factoryHelpers = {
+		separateFactoryNames,
+		combinedFactoryContent,
+		combinedFactoryImports,
+		isCombined
+	};
 	for (const groupSchemas of Object.values(schemaGroups)) {
 		if (groupSchemas.length === 1) {
 			await writeSchema({
@@ -4676,17 +5519,29 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 				header,
 				tsconfig
 			});
+			const singleSchema = groupSchemas[0];
+			await emitFactoryForSchema(singleSchema, namingConvention, header, factoryDir, fileExtension, factoryHelpers);
 			continue;
 		}
+		const mergedSchema = mergeSchemaGroup(groupSchemas);
 		await writeSchema({
 			path: schemaPath,
-			schema: mergeSchemaGroup(groupSchemas),
+			schema: mergedSchema,
 			target,
 			namingConvention,
 			fileExtension,
 			header,
 			tsconfig
 		});
+		await emitFactoryForSchema(mergedSchema, namingConvention, header, factoryDir, fileExtension, factoryHelpers);
+	}
+	if (isCombined.value) {
+		const factoryFileName = conventionName("factoryMethods", namingConvention);
+		const factoryFile = `${header}\n${generateImports({
+			imports: combinedFactoryImports,
+			namingConvention
+		})}\n\n${combinedFactoryContent.value}`;
+		await writeGeneratedFile(getPath(factoryDir, factoryFileName, fileExtension), factoryFile);
 	}
 	if (indexFiles) {
 		const schemaFilePath = nodePath.join(schemaPath, `index.ts`);
@@ -4694,7 +5549,25 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 		const ext = getImportExtension(fileExtension, tsconfig);
 		const conventionNamesSet = new Set(Object.values(schemaGroups).map((group) => conventionName(group[0].name, namingConvention)));
 		try {
-			await writeGeneratedFile(schemaFilePath, `${header}\n${[...conventionNamesSet].map((schemaName) => `export * from './${schemaName}${ext}';`).toSorted((a, b) => a.localeCompare(b, "en", { numeric: true })).join("\n")}\n`);
+			const currentExports = [...conventionNamesSet].map((schemaName) => `export * from './${schemaName}${ext}';`);
+			if (factoryOutputDirectory && normalizeSafe(factoryOutputDirectory) !== normalizeSafe(schemaPath) && (isCombined.value || separateFactoryNames.length > 0)) {
+				const factoryIndexFilePath = nodePath.join(factoryOutputDirectory, `index.ts`);
+				await fs$1.ensureFile(factoryIndexFilePath);
+				const factoryExports = [];
+				if (isCombined.value) {
+					const factoryFileName = conventionName("factoryMethods", namingConvention);
+					factoryExports.push(`export * from './${factoryFileName}${ext}';`);
+				}
+				for (const fName of separateFactoryNames) factoryExports.push(`export * from './${fName}${ext}';`);
+				await writeGeneratedFile(factoryIndexFilePath, `${header}\n${factoryExports.join("\n")}\n`);
+			} else {
+				if (isCombined.value) {
+					const factoryFileName = conventionName("factoryMethods", namingConvention);
+					currentExports.push(`export * from './${factoryFileName}${ext}';`);
+				}
+				for (const fName of separateFactoryNames) currentExports.push(`export * from './${fName}${ext}';`);
+			}
+			await writeGeneratedFile(schemaFilePath, `${header}\n${[...new Set(currentExports)].toSorted((a, b) => a.localeCompare(b, "en", { numeric: true })).join("\n")}\n`);
 		} catch (error) {
 			throw new Error(`Oups... 🍻. An Error occurred while writing schema index file ${schemaFilePath} => ${String(error)}`, { cause: error });
 		}
@@ -4704,6 +5577,13 @@ async function writeSchemas({ schemaPath, schemas, target, namingConvention, fil
 //#region src/writers/generate-imports-for-builder.ts
 function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 	const isZodSchemaOutput = isObject(output.schemas) && output.schemas.type === "zod";
+	const schemaFactoryImports = imports.filter((i) => i.schemaFactory);
+	const schemaFactoryImportExtension = getImportExtension(output.fileExtension, output.tsconfig);
+	const schemaFactoryDeps = schemaFactoryImports.length > 0 ? [{
+		exports: uniqueBy(schemaFactoryImports, (entry) => `${entry.name}|${entry.alias ?? ""}`),
+		dependency: joinSafe(relativeSchemasPath, `index.faker${schemaFactoryImportExtension}`)
+	}] : [];
+	imports = imports.filter((i) => !i.schemaFactory);
 	let schemaImports;
 	if (output.indexFiles) schemaImports = isZodSchemaOutput ? [{
 		exports: imports.filter((i) => !i.importPath),
@@ -4730,7 +5610,11 @@ function generateImportsForBuilder(output, imports, relativeSchemasPath) {
 			dependency: i.importPath
 		};
 	});
-	return [...schemaImports, ...otherImports];
+	return [
+		...schemaImports,
+		...schemaFactoryDeps,
+		...otherImports
+	];
 }
 //#endregion
 //#region src/writers/mock-outputs.ts
@@ -5448,6 +6332,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, buildDynamicScope, camel, collectReferencedComponents, combineSchemas, compareVersions, conventionName, count, createDebugger, createLogger, createSuccessMessage, createTypeAliasIfNeeded, dedupeUnionType, dynamicAnchorToParamName, dynamicAnchorsToUniqueParamNames, dynamicImport, escape, escapeRegExp, extractBoundAliasInfo, filterByContentType, filteredVerbs, fixCrossDirectoryImports, fixRegularSchemaImports, generalJSTypes, generalJSTypesWithArray, generateAxiosOptions, generateBodyMutatorConfig, generateBodyOptions, generateComponentDefinition, generateDependencyImports, generateFactory, 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, getDynamicAnchorName, 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, isDynamicReference, 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, resolveDynamicRef, resolveExampleRefs, resolveInstalledVersion, resolveInstalledVersions, resolveObject, resolveRef, resolveValue, sanitize, setVerbose, snake, sortByPriority, splitSchemasByType, startMessage, stringify, toObjectString, path_exports as upath, upper, wrapRouteParameters, writeGeneratedFile, writeModelInline, writeModelsInline, writeSchema, writeSchemas, writeSingleMode, writeSplitMode, writeSplitTagsMode, writeTagsMode };
 
 //# sourceMappingURL=index.mjs.map