@kubb/adapter-oas 5.0.0-alpha.14 → 5.0.0-alpha.16

package/dist/index.js

@@ -1,6 +1,6 @@
-import "./chunk--u3MIqq1.js";
+import { t as __name } from "./chunk--u3MIqq1.js";
 import path from "node:path";
-import { collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, narrowSchema, schemaTypes, transform } from "@kubb/ast";
+import { applyDiscriminatorEnum, collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, extractRefName, mediaTypes, mergeAdjacentAnonymousObjects, narrowSchema, schemaTypes, simplifyUnionMembers, transform } from "@kubb/ast";
 import { createAdapter } from "@kubb/core";
 import { bundle, loadConfig } from "@redocly/openapi-core";
 import yaml from "@stoplight/yaml";
@@ -76,44 +76,10 @@ const formatMap = {
 	double: "number"
 };
 /**
-* Exhaustive list of media types that Kubb recognizes.
-*/
-const knownMediaTypes = new Set([
-	"application/json",
-	"application/xml",
-	"application/x-www-form-urlencoded",
-	"application/octet-stream",
-	"application/pdf",
-	"application/zip",
-	"application/graphql",
-	"multipart/form-data",
-	"text/plain",
-	"text/html",
-	"text/csv",
-	"text/xml",
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp",
-	"image/svg+xml",
-	"audio/mpeg",
-	"video/mp4"
-]);
-/**
 * Vendor extension keys used to attach human-readable labels to enum values.
 * Checked in priority order: the first key found wins.
 */
 const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
-/**
-* Scalar primitive schema types used for union member simplification.
-*/
-const SCALAR_PRIMITIVE_TYPES = new Set([
-	"string",
-	"number",
-	"integer",
-	"bigint",
-	"boolean"
-]);
 //#endregion
 //#region src/oas/resolveServerUrl.ts
 /**
@@ -196,27 +162,6 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
-//#region ../../internals/utils/src/names.ts
-/**
-* Returns a unique name by appending an incrementing numeric suffix when the name has already been used.
-* Mutates `data` in-place as a usage counter so subsequent calls remain consistent.
-*
-* @example
-* const seen: Record<string, number> = {}
-* getUniqueName('Foo', seen) // 'Foo'
-* getUniqueName('Foo', seen) // 'Foo2'
-* getUniqueName('Foo', seen) // 'Foo3'
-*/
-function getUniqueName(originalName, data) {
-	let used = data[originalName] || 0;
-	if (used) {
-		data[originalName] = ++used;
-		originalName += used;
-	}
-	data[originalName] = 1;
-	return originalName;
-}
-//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * Returns `true` when `name` is a syntactically valid JavaScript variable name.
@@ -620,7 +565,6 @@ var Oas = class extends BaseOas {
 			"requestBodies",
 			"responses"
 		];
-		const shouldResolveCollisions = options.collisionDetection ?? this.#options.collisionDetection ?? false;
 		const components = this.getDefinition().components;
 		const schemasWithMeta = [];
 		if (includes.includes("schemas")) {
@@ -674,7 +618,7 @@ var Oas = class extends BaseOas {
 				}
 			}
 		}
-		const { schemas, nameMapping } = shouldResolveCollisions ? resolveCollisions(schemasWithMeta) : legacyResolve(schemasWithMeta);
+		const { schemas, nameMapping } = resolveCollisions(schemasWithMeta);
 		return {
 			schemas: sortSchemas(schemas),
 			nameMapping
@@ -895,23 +839,6 @@ function getSemanticSuffix(source) {
 	return semanticSuffixes[source];
 }
 /**
-* Builds `GetSchemasResult` without any collision detection.
-* Each schema is registered under its original component name and its full
-* `#/components/<source>/<name>` ref path.
-*/
-function legacyResolve(schemasWithMeta) {
-	const schemas = {};
-	const nameMapping = /* @__PURE__ */ new Map();
-	for (const item of schemasWithMeta) {
-		schemas[item.originalName] = item.schema;
-		nameMapping.set(`#/components/${item.source}/${item.originalName}`, item.originalName);
-	}
-	return {
-		schemas,
-		nameMapping
-	};
-}
-/**
 * Builds `GetSchemasResult` with automatic name-collision resolution.
 *
 * When two or more schemas normalize to the same PascalCase name:
@@ -955,122 +882,54 @@ function resolveCollisions(schemasWithMeta) {
 	};
 }
 //#endregion
-//#region src/utils.ts
-/**
-* Extracts the schema name from a `$ref` string.
-* For `#/components/schemas/Order` this returns `'Order'`.
-* Falls back to the full ref string when no slash is present.
-*/
-function extractRefName($ref) {
-	return $ref.split("/").at(-1) ?? $ref;
+//#region src/discriminator.ts
+function resolveDiscriminatorValue(mapping, ref) {
+	if (!mapping || !ref) return void 0;
+	return Object.entries(mapping).find(([, value]) => value === ref)?.[0];
 }
-/**
-* Replaces the discriminator property's schema inside an `ObjectSchemaNode`
-* with an enum of the given `values`.
-*
-* - When `enumName` is provided the enum is named, which lets printers emit a
-*   standalone enum declaration + type reference (e.g. `PetTypeEnum`).
-* - When `enumName` is omitted the enum stays anonymous, so printers inline it
-*   as a literal union (e.g. `'dog'`).
-*
-* Returns the node unchanged when it is not an object or lacks the target property.
-*/
-function applyDiscriminatorEnum({ node, propertyName, values, enumName }) {
-	if (node.type !== "object" || !node.properties?.length) return node;
-	if (!node.properties.some((prop) => prop.name === propertyName)) return node;
+function createDiscriminantNode(propertyName, value) {
 	return createSchema({
-		...node,
-		properties: node.properties.map((prop) => {
-			if (prop.name !== propertyName) return prop;
-			const enumSchema = createSchema({
+		type: "object",
+		primitive: "object",
+		properties: [createProperty({
+			name: propertyName,
+			schema: createSchema({
 				type: "enum",
 				primitive: "string",
-				enumValues: values,
-				name: enumName,
-				readOnly: prop.schema.readOnly,
-				writeOnly: prop.schema.writeOnly
-			});
-			return createProperty({
-				...prop,
-				schema: enumSchema
-			});
-		})
+				enumValues: [value]
+			}),
+			required: true
+		})]
 	});
 }
-/**
-* Merges consecutive anonymous (`name`-less) `ObjectSchemaNode`s in `members` into a
-* single object by combining their `properties` arrays.
-*
-* Only adjacent pairs are merged — non-object or named nodes act as boundaries.
-* This collapses patterns like `Address & { streetNumber } & { streetName }` into
-* `Address & { streetNumber; streetName }`.
-*/
-function mergeAdjacentAnonymousObjects(members) {
-	return members.reduce((acc, member) => {
-		const obj = narrowSchema(member, "object");
-		if (obj && !obj.name) {
-			const prev = acc[acc.length - 1];
-			const prevObj = prev ? narrowSchema(prev, "object") : null;
-			if (prevObj && !prevObj.name) {
-				acc[acc.length - 1] = createSchema({
-					...prevObj,
-					properties: [...prevObj.properties ?? [], ...obj.properties ?? []]
-				});
-				return acc;
-			}
-		}
-		acc.push(member);
-		return acc;
-	}, []);
+//#endregion
+//#region src/naming.ts
+function resolveChildName(parentName, propName) {
+	return parentName ? pascalCase([parentName, propName].join(" ")) : void 0;
 }
-/**
-* Simplifies a union member list by removing `enum` nodes whose `primitive` type is
-* already represented by a broader scalar node in the same union.
-*
-* For example `['placed', 'approved'] | string` collapses to `string` because
-* `string` subsumes all string literals.  `'' | string` similarly becomes `string`.
-*
-* Only scalar primitives (`string`, `number`, `integer`, `bigint`, `boolean`) are
-* considered — object, array, and ref members are left untouched.
-*
-* Const-derived enums (those without an `enumType`, produced from an OpenAPI `const`
-* keyword) are **never** removed — `'accepted' | string` must stay as-is because the
-* literal is intentional.
-*/
-function simplifyUnionMembers(members) {
-	const scalarPrimitives = new Set(members.filter((m) => SCALAR_PRIMITIVE_TYPES.has(m.type)).map((m) => m.type));
-	if (!scalarPrimitives.size) return members;
-	return members.filter((m) => {
-		if (m.type !== "enum") return true;
-		const prim = m.primitive;
-		if (!prim) return true;
-		if (!m.enumType) return true;
-		if (scalarPrimitives.has(prim)) return false;
-		if ((prim === "integer" || prim === "number") && (scalarPrimitives.has("integer") || scalarPrimitives.has("number"))) return false;
-		return true;
-	});
+function resolveEnumPropName(parentName, propName, enumSuffix) {
+	return pascalCase([
+		parentName,
+		propName,
+		enumSuffix
+	].filter(Boolean).join(" "));
+}
+function applyEnumName(propNode, parentName, propName, enumSuffix) {
+	const enumNode = narrowSchema(propNode, "enum");
+	if (enumNode?.primitive === "boolean") return {
+		...propNode,
+		name: void 0
+	};
+	if (enumNode) return {
+		...propNode,
+		name: resolveEnumPropName(parentName, propName, enumSuffix)
+	};
+	return propNode;
 }
+//#endregion
+//#region src/refResolver.ts
 /**
-* `nameMapping`, and calls `resolve` to obtain the `{ name, path }` pair for
-* each import. When `oas` is supplied, only `$ref`s that are resolvable in the
-* spec are included; omit it to skip the existence check.
-*
-* This function is the pure, state-free alternative to `OasParser.getImports`.
-* Because it receives `nameMapping` explicitly it can be called without holding
-* a reference to the parser or the OAS instance.
-*
-* @example
-* ```ts
-* // Use adapter state directly — no parser reference needed
-* const imports = getImports({
-*   node: schemaNode,
-*   nameMapping: adapter.options.nameMapping,
-*   resolve: (schemaName) => ({
-*     name: schemaManager.getName(schemaName, { type: 'type' }),
-*     path: schemaManager.getFile(schemaName).path,
-*   }),
-* })
-* ```
+* Collects import entries for all `ref` schema nodes in `node`.
 */
 function getImports({ node, nameMapping, resolve }) {
 	return collect(node, { schema(schemaNode) {
@@ -1084,6 +943,29 @@ function getImports({ node, nameMapping, resolve }) {
 		};
 	} });
 }
+/**
+* Walks a schema tree and resolves `ref`/`enum` names through callbacks.
+*/
+function resolveRefs({ node, nameMapping, resolveName, resolveEnumName }) {
+	return transform(node, { schema(schemaNode) {
+		const schemaRef = narrowSchema(schemaNode, schemaTypes.ref);
+		if (schemaRef && (schemaRef.ref || schemaRef.name)) {
+			const rawRef = schemaRef.ref ?? schemaRef.name;
+			const resolved = resolveName(nameMapping.get(rawRef) ?? rawRef);
+			if (resolved) return {
+				...schemaNode,
+				name: resolved
+			};
+		}
+		if (schemaNode.type === "enum" && schemaNode.name) {
+			const resolved = (resolveEnumName ?? resolveName)(schemaNode.name);
+			if (resolved) return {
+				...schemaNode,
+				name: resolved
+			};
+		}
+	} });
+}
 //#endregion
 //#region src/parser.ts
 /**
@@ -1109,7 +991,7 @@ function getPrimitiveType(type) {
 * Returns `undefined` for content types not present in `KNOWN_MEDIA_TYPES`.
 */
 function toMediaType(contentType) {
-	return knownMediaTypes.has(contentType) ? contentType : void 0;
+	return Object.values(mediaTypes).includes(contentType) ? contentType : void 0;
 }
 /**
 * Creates an OAS parser that converts an OpenAPI/Swagger spec into
@@ -1130,21 +1012,30 @@ function toMediaType(contentType) {
 * const root = parser.parse({ emptySchemaType: 'unknown' })
 * ```
 */
-function createOasParser(oas, { contentType, collisionDetection } = {}) {
-	const { schemas: schemaObjects, nameMapping } = oas.getSchemas({
-		contentType,
-		collisionDetection
-	});
-	const usedEnumNames = {};
-	const isLegacyNaming = collisionDetection === false;
+function createOasParser(oas, { contentType } = {}) {
+	const { schemas: schemaObjects, nameMapping } = oas.getSchemas({ contentType });
+	const TYPE_OPTION_MAP = {
+		any: schemaTypes.any,
+		unknown: schemaTypes.unknown,
+		void: schemaTypes.void
+	};
 	/**
 	* Maps an `'any' | 'unknown' | 'void'` option string to the corresponding `SchemaType` constant.
 	* Used for both `unknownType` (unannotated schemas) and `emptySchemaType` (empty `{}` schemas).
 	*/
 	function resolveTypeOption(value) {
-		if (value === "any") return schemaTypes.any;
-		if (value === "void") return schemaTypes.void;
-		return schemaTypes.unknown;
+		return TYPE_OPTION_MAP[value];
+	}
+	function normalizeArrayEnum(schema) {
+		const normalizedItems = {
+			...typeof schema.items === "object" && !Array.isArray(schema.items) ? schema.items : {},
+			enum: schema.enum
+		};
+		const { enum: _enum, ...schemaWithoutEnum } = schema;
+		return {
+			...schemaWithoutEnum,
+			items: normalizedItems
+		};
 	}
 	/**
 	* Resolves the AST type and datetime modifiers for a date/time format, honoring the `dateType` option.
@@ -1233,10 +1124,10 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* Circular references through discriminator parents are detected and skipped to prevent
 	* infinite recursion during code generation.
 	*/
-	function convertAllOf({ schema, name, nullable, defaultValue, options }) {
+	function convertAllOf({ schema, name, nullable, defaultValue, rawOptions }) {
 		if (schema.allOf.length === 1 && !schema.properties && !(Array.isArray(schema.required) && schema.required.length) && schema.additionalProperties === void 0) {
 			const [memberSchema] = schema.allOf;
-			const memberNode = convertSchema({ schema: memberSchema }, options);
+			const memberNode = convertSchema({ schema: memberSchema }, rawOptions);
 			const { kind: _kind, ...memberNodeProps } = memberNode;
 			const mergedNullable = nullable || memberNode.nullable || void 0;
 			const mergedDefault = schema.default === null && mergedNullable ? void 0 : schema.default ?? memberNode.default;
@@ -1265,7 +1156,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			const inOneOf = parentUnion.some((oneOfItem) => isReference(oneOfItem) && oneOfItem.$ref === childRef);
 			const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef);
 			if (inOneOf || inMapping) {
-				const discriminatorValue = Object.entries(deref.discriminator.mapping ?? {}).find(([, v]) => v === childRef)?.[0];
+				const discriminatorValue = resolveDiscriminatorValue(deref.discriminator.mapping, childRef);
 				if (discriminatorValue) filteredDiscriminantValues.push({
 					propertyName: deref.discriminator.propertyName,
 					value: discriminatorValue
@@ -1273,7 +1164,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 				return false;
 			}
 			return true;
-		}).map((s) => convertSchema({ schema: s }, options));
+		}).map((s) => convertSchema({ schema: s }, rawOptions));
 		const syntheticStart = allOfMembers.length;
 		if (Array.isArray(schema.required) && schema.required.length) {
 			const outerKeys = schema.properties ? new Set(Object.keys(schema.properties)) : /* @__PURE__ */ new Set();
@@ -1288,28 +1179,16 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 					allOfMembers.push(convertSchema({ schema: {
 						properties: { [key]: resolved.properties[key] },
 						required: [key]
-					} }, options));
+					} }, rawOptions));
 					break;
 				}
 			}
 		}
 		if (schema.properties) {
 			const { allOf: _allOf, ...schemaWithoutAllOf } = schema;
-			allOfMembers.push(convertSchema({ schema: schemaWithoutAllOf }, options));
+			allOfMembers.push(convertSchema({ schema: schemaWithoutAllOf }, rawOptions));
 		}
-		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(createSchema({
-			type: "object",
-			primitive: "object",
-			properties: [createProperty({
-				name: propertyName,
-				schema: createSchema({
-					type: "enum",
-					primitive: "string",
-					enumValues: [value]
-				}),
-				required: true
-			})]
-		}));
+		for (const { propertyName, value } of filteredDiscriminantValues) allOfMembers.push(createDiscriminantNode(propertyName, value));
 		return createSchema({
 			type: "intersection",
 			members: [...mergeAdjacentAnonymousObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentAnonymousObjects(allOfMembers.slice(syntheticStart))],
@@ -1324,69 +1203,46 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* individually intersected with the shared properties node to match the OAS pattern of
 	* adding common fields next to a discriminated union.
 	*/
-	function convertUnion({ schema, name, nullable, defaultValue, options }) {
+	function convertUnion({ schema, name, nullable, defaultValue, rawOptions }) {
 		const unionMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
 		const unionBase = {
 			...renderSchemaBase(schema, name, nullable, defaultValue),
 			discriminatorPropertyName: isDiscriminator(schema) ? schema.discriminator.propertyName : void 0
 		};
-		if (schema.properties) {
+		const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
+		const sharedPropertiesNode = schema.properties ? (() => {
 			const { oneOf: _oneOf, anyOf: _anyOf, ...schemaWithoutUnion } = schema;
-			const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
-			const sharedPropertiesNode = convertSchema({
+			return convertSchema({
 				schema: discriminator ? Object.fromEntries(Object.entries(schemaWithoutUnion).filter(([key]) => key !== "discriminator")) : schemaWithoutUnion,
-				name: isLegacyNaming ? void 0 : name
-			}, options);
-			return createSchema({
-				type: "union",
-				...unionBase,
-				members: unionMembers.map((s) => {
-					const ref = isReference(s) ? s.$ref : void 0;
-					const discriminatorValue = discriminator?.mapping && ref ? Object.entries(discriminator.mapping).find(([, v]) => v === ref)?.[0] : void 0;
-					let propertiesNode = sharedPropertiesNode;
-					if (discriminatorValue && discriminator) propertiesNode = applyDiscriminatorEnum({
-						node: propertiesNode,
-						propertyName: discriminator.propertyName,
-						values: [discriminatorValue]
-					});
-					return createSchema({
-						type: "intersection",
-						members: [convertSchema({ schema: s }, options), propertiesNode]
-					});
-				})
-			});
-		}
-		const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
-		if (discriminator?.mapping) return createSchema({
+				name
+			}, rawOptions);
+		})() : void 0;
+		if (sharedPropertiesNode || discriminator?.mapping) return createSchema({
 			type: "union",
 			...unionBase,
 			members: unionMembers.map((s) => {
 				const ref = isReference(s) ? s.$ref : void 0;
-				const discriminatorValue = ref ? Object.entries(discriminator.mapping).find(([, v]) => v === ref)?.[0] : void 0;
-				const memberNode = convertSchema({ schema: s }, options);
-				if (!discriminatorValue) return memberNode;
+				const discriminatorValue = resolveDiscriminatorValue(discriminator?.mapping, ref);
+				const memberNode = convertSchema({ schema: s }, rawOptions);
+				if (sharedPropertiesNode) return createSchema({
+					type: "intersection",
+					members: [memberNode, discriminatorValue && discriminator ? applyDiscriminatorEnum({
+						node: sharedPropertiesNode,
+						propertyName: discriminator.propertyName,
+						values: [discriminatorValue]
+					}) : sharedPropertiesNode]
+				});
+				if (!discriminatorValue || !discriminator) return memberNode;
 				return createSchema({
 					type: "intersection",
-					members: [memberNode, createSchema({
-						type: "object",
-						primitive: "object",
-						properties: [createProperty({
-							name: discriminator.propertyName,
-							schema: createSchema({
-								type: "enum",
-								primitive: "string",
-								enumValues: [discriminatorValue]
-							}),
-							required: true
-						})]
-					})]
+					members: [memberNode, createDiscriminantNode(discriminator.propertyName, discriminatorValue)]
 				});
 			})
 		});
 		return createSchema({
 			type: "union",
 			...unionBase,
-			members: simplifyUnionMembers(unionMembers.map((s) => convertSchema({ schema: s }, options)))
+			members: simplifyUnionMembers(unionMembers.map((s) => convertSchema({ schema: s }, rawOptions)))
 		});
 	}
 	/**
@@ -1416,10 +1272,10 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* Returns `undefined` when the format should fall through to string handling
 	* (i.e. `format: 'date-time'` with `dateType: false`).
 	*/
-	function convertFormat({ schema, name, nullable, defaultValue, mergedOptions }) {
+	function convertFormat({ schema, name, nullable, defaultValue, options }) {
 		const base = renderSchemaBase(schema, name, nullable, defaultValue);
 		if (schema.format === "int64") return createSchema({
-			type: mergedOptions.integerType === "bigint" ? "bigint" : "integer",
+			type: options.integerType === "bigint" ? "bigint" : "integer",
 			primitive: "integer",
 			...base,
 			min: schema.minimum,
@@ -1428,7 +1284,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			exclusiveMaximum: typeof schema.exclusiveMaximum === "number" ? schema.exclusiveMaximum : void 0
 		});
 		if (schema.format === "date-time" || schema.format === "date" || schema.format === "time") {
-			const dateType = getDateType(mergedOptions, schema.format);
+			const dateType = getDateType(options, schema.format);
 			if (!dateType) return void 0;
 			if (dateType.type === "datetime") return createSchema({
 				...base,
@@ -1473,28 +1329,19 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* - Numeric and boolean enums require a const-map representation because most generators cannot
 	*   use string-enum syntax for non-string values.
 	*/
-	function convertEnum({ schema, name, nullable, type, options }) {
-		if (type === "array") {
-			const normalizedItems = {
-				...typeof schema.items === "object" && !Array.isArray(schema.items) ? schema.items : {},
-				enum: schema.enum
-			};
-			const { enum: _enum, ...schemaWithoutEnum } = schema;
-			return convertSchema({
-				schema: {
-					...schemaWithoutEnum,
-					items: normalizedItems
-				},
-				name
-			}, options);
-		}
+	function convertEnum({ schema, name, nullable, type, rawOptions }) {
+		if (type === "array") return convertSchema({
+			schema: normalizeArrayEnum(schema),
+			name
+		}, rawOptions);
 		const nullInEnum = schema.enum.includes(null);
 		const filteredValues = nullInEnum ? schema.enum.filter((v) => v !== null) : schema.enum;
 		const enumNullable = nullable || nullInEnum || void 0;
 		const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
+		const enumPrimitive = getPrimitiveType(type);
 		const enumBase = {
 			type: "enum",
-			primitive: getPrimitiveType(type),
+			primitive: enumPrimitive,
 			name,
 			title: schema.title,
 			description: schema.description,
@@ -1506,38 +1353,19 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			example: schema.example
 		};
 		const extensionKey = enumExtensionKeys.find((key) => key in schema);
-		if (extensionKey) {
-			const rawNames = schema[extensionKey];
-			const uniqueNames = [...new Set(rawNames)];
-			const enumType = getPrimitiveType(type) === "number" || getPrimitiveType(type) === "integer" ? "number" : getPrimitiveType(type) === "boolean" ? "boolean" : "string";
+		if (extensionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
+			const enumType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
+			const sourceValues = extensionKey ? [...new Set(schema[extensionKey])] : [...new Set(filteredValues)];
 			return createSchema({
 				...enumBase,
 				enumType,
-				namedEnumValues: uniqueNames.map((label, index) => ({
+				namedEnumValues: sourceValues.map((label, index) => ({
 					name: String(label),
-					value: filteredValues[index] ?? label,
+					value: extensionKey ? filteredValues[index] ?? label : label,
 					format: enumType
 				}))
 			});
 		}
-		if (type === "number" || type === "integer") return createSchema({
-			...enumBase,
-			enumType: "number",
-			namedEnumValues: [...new Set(filteredValues)].map((value) => ({
-				name: String(value),
-				value,
-				format: "number"
-			}))
-		});
-		if (type === "boolean") return createSchema({
-			...enumBase,
-			enumType: "boolean",
-			namedEnumValues: [...new Set(filteredValues)].map((value) => ({
-				name: String(value),
-				value,
-				format: "boolean"
-			}))
-		});
 		return createSchema({
 			...enumBase,
 			enumValues: [...new Set(filteredValues)]
@@ -1555,51 +1383,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* - not required + not nullable → `optional: true`
 	* - not required + nullable → `nullish: true`
 	*/
-	/**
-	* Builds the propagation name for a child property during recursive schema conversion.
-	*
-	* - **Legacy naming** (`isLegacyNaming`): only the immediate property key is used
-	*   (e.g. `Params` for property `params`), keeping nested names short.
-	* - **Default naming**: the parent name is prepended so the full path is encoded
-	*   (e.g. `OrderParams` when parent is `Order`).
-	*/
-	function resolveChildName(parentName, propName) {
-		if (isLegacyNaming) return pascalCase(propName);
-		return parentName ? pascalCase([parentName, propName].join(" ")) : void 0;
-	}
-	/**
-	* Derives the final name for an enum property schema node.
-	*
-	* The raw name always includes the enum suffix (e.g. `StatusEnum`).
-	* In legacy mode an additional deduplication step appends a numeric suffix
-	* when the same name has already been used (e.g. `ParamsStatusEnum2`).
-	*/
-	function resolveEnumPropName(parentName, propName, enumSuffix) {
-		const raw = pascalCase([
-			parentName,
-			propName,
-			enumSuffix
-		].filter(Boolean).join(" "));
-		return isLegacyNaming ? getUniqueName(raw, usedEnumNames) : raw;
-	}
-	/**
-	* Given a freshly-converted property schema, returns the node with a correct
-	* `name` attached — or stripped — depending on whether the node is a named
-	* enum, a boolean const-enum (always inlined), or a regular schema.
-	*/
-	function applyEnumName(propNode, parentName, propName, enumSuffix) {
-		const enumNode = narrowSchema(propNode, "enum");
-		if (enumNode?.primitive === "boolean") return {
-			...propNode,
-			name: void 0
-		};
-		if (enumNode) return {
-			...propNode,
-			name: resolveEnumPropName(parentName, propName, enumSuffix)
-		};
-		return propNode;
-	}
-	function convertObject({ schema, name, nullable, defaultValue, options, mergedOptions }) {
+	function convertObject({ schema, name, nullable, defaultValue, rawOptions, options }) {
 		const properties = schema.properties ? Object.entries(schema.properties).map(([propName, propSchema]) => {
 			const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required;
 			const resolvedPropSchema = propSchema;
@@ -1607,10 +1391,10 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			let schemaNode = applyEnumName(convertSchema({
 				schema: resolvedPropSchema,
 				name: resolveChildName(name, propName)
-			}, options), name, propName, mergedOptions.enumSuffix);
+			}, rawOptions), name, propName, options.enumSuffix);
 			const tupleNode = narrowSchema(schemaNode, "tuple");
 			if (tupleNode?.items) {
-				const namedItems = tupleNode.items.map((item) => applyEnumName(item, name, propName, mergedOptions.enumSuffix));
+				const namedItems = tupleNode.items.map((item) => applyEnumName(item, name, propName, options.enumSuffix));
 				if (namedItems.some((item, i) => item !== tupleNode.items[i])) schemaNode = {
 					...tupleNode,
 					items: namedItems
@@ -1628,11 +1412,11 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		const additionalProperties = schema.additionalProperties;
 		let additionalPropertiesNode;
 		if (additionalProperties === true) additionalPropertiesNode = true;
-		else if (additionalProperties && Object.keys(additionalProperties).length > 0) additionalPropertiesNode = convertSchema({ schema: additionalProperties }, options);
+		else if (additionalProperties && Object.keys(additionalProperties).length > 0) additionalPropertiesNode = convertSchema({ schema: additionalProperties }, rawOptions);
 		else if (additionalProperties === false) additionalPropertiesNode = void 0;
-		else if (additionalProperties) additionalPropertiesNode = createSchema({ type: resolveTypeOption(mergedOptions.unknownType) });
+		else if (additionalProperties) additionalPropertiesNode = createSchema({ type: resolveTypeOption(options.unknownType) });
 		const rawPatternProperties = "patternProperties" in schema ? schema.patternProperties : void 0;
-		const patternProperties = rawPatternProperties ? Object.fromEntries(Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [pattern, patternSchema === true || typeof patternSchema === "object" && Object.keys(patternSchema).length === 0 ? createSchema({ type: resolveTypeOption(mergedOptions.unknownType) }) : convertSchema({ schema: patternSchema }, options)])) : void 0;
+		const patternProperties = rawPatternProperties ? Object.fromEntries(Object.entries(rawPatternProperties).map(([pattern, patternSchema]) => [pattern, patternSchema === true || typeof patternSchema === "object" && Object.keys(patternSchema).length === 0 ? createSchema({ type: resolveTypeOption(options.unknownType) }) : convertSchema({ schema: patternSchema }, rawOptions)])) : void 0;
 		const objectNode = createSchema({
 			type: "object",
 			primitive: "object",
@@ -1647,7 +1431,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 				node: objectNode,
 				propertyName: discPropName,
 				values: Object.keys(schema.discriminator.mapping),
-				enumName: name ? resolveEnumPropName(name, discPropName, mergedOptions.enumSuffix) : void 0
+				enumName: name ? resolveEnumPropName(name, discPropName, options.enumSuffix) : void 0
 			});
 		}
 		return objectNode;
@@ -1660,12 +1444,12 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* a rest element of type `any` is emitted to match JSON Schema semantics (absent `items`
 	* means additional items are allowed).
 	*/
-	function convertTuple({ schema, name, nullable, defaultValue, options }) {
+	function convertTuple({ schema, name, nullable, defaultValue, rawOptions }) {
 		return createSchema({
 			type: "tuple",
 			primitive: "array",
-			items: (schema.prefixItems ?? []).map((item) => convertSchema({ schema: item }, options)),
-			rest: schema.items ? convertSchema({ schema: schema.items }, options) : createSchema({ type: "any" }),
+			items: (schema.prefixItems ?? []).map((item) => convertSchema({ schema: item }, rawOptions)),
+			rest: schema.items ? convertSchema({ schema: schema.items }, rawOptions) : createSchema({ type: "any" }),
 			min: schema.minItems,
 			max: schema.maxItems,
 			...renderSchemaBase(schema, name, nullable, defaultValue)
@@ -1677,16 +1461,16 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* When the items schema is an inline enum, a name derived from the parent array's name and
 	* `enumSuffix` is forwarded so generators can emit a named enum declaration.
 	*/
-	function convertArray({ schema, name, nullable, defaultValue, options, mergedOptions }) {
+	function convertArray({ schema, name, nullable, defaultValue, rawOptions, options }) {
 		const rawItems = schema.items;
-		const itemName = rawItems?.enum?.length && name ? resolveEnumPropName(void 0, name, mergedOptions.enumSuffix) : void 0;
+		const itemName = rawItems?.enum?.length && name ? resolveEnumPropName(void 0, name, options.enumSuffix) : void 0;
 		return createSchema({
 			type: "array",
 			primitive: "array",
 			items: rawItems ? [convertSchema({
 				schema: rawItems,
 				name: itemName
-			}, options)] : [],
+			}, rawOptions)] : [],
 			min: schema.minItems,
 			max: schema.maxItems,
 			unique: schema.uniqueItems ?? void 0,
@@ -1760,16 +1544,16 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 	* 10. Object / array / tuple / scalar by `type`
 	* 11. Empty schema fallback (`emptySchemaType` option)
 	*/
-	function convertSchema({ schema, name }, options) {
-		const mergedOptions = {
+	function convertSchema({ schema, name }, rawOptions) {
+		const options = {
 			...DEFAULT_PARSER_OPTIONS,
-			...options
+			...rawOptions
 		};
 		const flattenedSchema = flattenSchema(schema);
 		if (flattenedSchema && flattenedSchema !== schema) return convertSchema({
 			schema: flattenedSchema,
 			name
-		}, options);
+		}, rawOptions);
 		const nullable = isNullable(schema) || void 0;
 		const defaultValue = schema.default === null && nullable ? void 0 : schema.default;
 		const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
@@ -1779,8 +1563,8 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			nullable,
 			defaultValue,
 			type,
-			options,
-			mergedOptions
+			rawOptions,
+			options
 		};
 		if (isReference(schema)) return convertRef(ctx);
 		if (schema.allOf?.length) return convertAllOf(ctx);
@@ -1806,7 +1590,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 						type: t
 					},
 					name
-				}, options)),
+				}, rawOptions)),
 				...renderSchemaBase(schema, name, arrayNullable, defaultValue)
 			});
 		}
@@ -1824,7 +1608,7 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 		if (type === "boolean") return convertBoolean(ctx);
 		if (type === "null") return convertNull(ctx);
 		return createSchema({
-			type: resolveTypeOption(mergedOptions.emptySchemaType),
+			type: resolveTypeOption(options.emptySchemaType),
 			name,
 			title: schema.title,
 			description: schema.description
@@ -1910,38 +1694,15 @@ function createOasParser(oas, { contentType, collisionDetection } = {}) {
 			operations: Object.entries(paths).flatMap(([_path, methods]) => Object.entries(methods).map(([, operation]) => operation ? parseOperation(mergedOptions, oas, operation) : null).filter((op) => op !== null))
 		});
 	}
-	/**
-	* Walks a `SchemaNode` tree and resolves all `ref` node names through the provided callbacks.
-	*
-	* `resolveName` handles all schema types; `resolveEnumName` (when provided) takes precedence
-	* for `enum` nodes, enabling a separate naming strategy for enums (e.g. different suffix).
-	*
-	* Collision-resolved names (from `nameMapping`) are applied before user-supplied resolvers.
-	*/
-	function resolveRefs(node, resolveName, resolveEnumName) {
-		return transform(node, { schema(schemaNode) {
-			const schemaRef = narrowSchema(schemaNode, schemaTypes.ref);
-			if (schemaRef && (schemaRef.ref || schemaRef.name)) {
-				const rawRef = schemaRef.ref ?? schemaRef.name;
-				const resolved = resolveName(nameMapping.get(rawRef) ?? rawRef);
-				if (resolved) return {
-					...schemaNode,
-					name: resolved
-				};
-			}
-			if (schemaNode.type === "enum" && schemaNode.name) {
-				const resolved = (resolveEnumName ?? resolveName)(schemaNode.name);
-				if (resolved) return {
-					...schemaNode,
-					name: resolved
-				};
-			}
-		} });
-	}
 	return {
 		parse,
 		convertSchema,
-		resolveRefs,
+		resolveRefs: /* @__PURE__ */ __name((node, resolveName, resolveEnumName) => resolveRefs({
+			node,
+			nameMapping,
+			resolveName,
+			resolveEnumName
+		}), "resolveRefs"),
 		nameMapping
 	};
 }
@@ -1967,7 +1728,7 @@ const adapterOasName = "oas";
 * ```
 */
 const adapterOas = createAdapter((options) => {
-	const { validate = true, oasClass, contentType, serverIndex, serverVariables, discriminator = "strict", collisionDetection = true, dateType = DEFAULT_PARSER_OPTIONS.dateType, integerType = DEFAULT_PARSER_OPTIONS.integerType, unknownType = DEFAULT_PARSER_OPTIONS.unknownType, enumSuffix = DEFAULT_PARSER_OPTIONS.enumSuffix, emptySchemaType = unknownType || DEFAULT_PARSER_OPTIONS.emptySchemaType } = options;
+	const { validate = true, oasClass, contentType, serverIndex, serverVariables, discriminator = "strict", dateType = DEFAULT_PARSER_OPTIONS.dateType, integerType = DEFAULT_PARSER_OPTIONS.integerType, unknownType = DEFAULT_PARSER_OPTIONS.unknownType, enumSuffix = DEFAULT_PARSER_OPTIONS.enumSuffix, emptySchemaType = unknownType || DEFAULT_PARSER_OPTIONS.emptySchemaType } = options;
 	const nameMapping = /* @__PURE__ */ new Map();
 	return {
 		name: "oas",
@@ -1978,7 +1739,6 @@ const adapterOas = createAdapter((options) => {
 			serverIndex,
 			serverVariables,
 			discriminator,
-			collisionDetection,
 			dateType,
 			integerType,
 			unknownType,
@@ -1997,18 +1757,14 @@ const adapterOas = createAdapter((options) => {
 			const oas = await parseFromConfig(sourceToFakeConfig(source), oasClass);
 			oas.setOptions({
 				contentType,
-				discriminator,
-				collisionDetection
+				discriminator
 			});
 			if (validate) try {
 				await oas.validate();
 			} catch (_err) {}
 			const server = serverIndex !== void 0 ? oas.api.servers?.at(serverIndex) : void 0;
 			const baseURL = server?.url ? resolveServerUrl(server, serverVariables) : void 0;
-			const parser = createOasParser(oas, {
-				contentType,
-				collisionDetection
-			});
+			const parser = createOasParser(oas, { contentType });
 			const root = parser.parse({
 				dateType,
 				integerType,