@kubb/adapter-oas 5.0.0-alpha.15 → 5.0.0-alpha.17

package/dist/index.js

@@ -1,6 +1,6 @@
 import "./chunk--u3MIqq1.js";
 import path from "node:path";
-import { collect, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, narrowSchema, schemaTypes, transform } from "@kubb/ast";
+import { childName, collectImports, createDiscriminantNode, createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, enumPropName, extractRefName, findDiscriminator, mediaTypes, mergeAdjacentObjects, narrowSchema, resolveNames, schemaTypes, setDiscriminatorEnum, setEnumName, simplifyUnion } 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
 /**
@@ -916,136 +882,6 @@ 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;
-}
-/**
-* 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;
-	return createSchema({
-		...node,
-		properties: node.properties.map((prop) => {
-			if (prop.name !== propertyName) return prop;
-			const enumSchema = createSchema({
-				type: "enum",
-				primitive: "string",
-				enumValues: values,
-				name: enumName,
-				readOnly: prop.schema.readOnly,
-				writeOnly: prop.schema.writeOnly
-			});
-			return createProperty({
-				...prop,
-				schema: enumSchema
-			});
-		})
-	});
-}
-/**
-* 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;
-	}, []);
-}
-/**
-* 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;
-	});
-}
-/**
-* `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,
-*   }),
-* })
-* ```
-*/
-function getImports({ node, nameMapping, resolve }) {
-	return collect(node, { schema(schemaNode) {
-		if (schemaNode.type !== "ref" || !schemaNode.ref) return;
-		const rawName = extractRefName(schemaNode.ref);
-		const result = resolve(nameMapping.get(rawName) ?? rawName);
-		if (!result) return;
-		return {
-			name: [result.name],
-			path: result.path
-		};
-	} });
-}
-//#endregion
 //#region src/parser.ts
 /**
 * Looks up the Kubb `SchemaType` for a given OAS `format` string.
@@ -1070,7 +906,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
@@ -1093,14 +929,28 @@ function toMediaType(contentType) {
 */
 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.
@@ -1189,10 +1039,10 @@ function createOasParser(oas, { contentType } = {}) {
 	* 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;
@@ -1221,7 +1071,7 @@ function createOasParser(oas, { contentType } = {}) {
 			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 = findDiscriminator(deref.discriminator.mapping, childRef);
 				if (discriminatorValue) filteredDiscriminantValues.push({
 					propertyName: deref.discriminator.propertyName,
 					value: discriminatorValue
@@ -1229,7 +1079,7 @@ function createOasParser(oas, { contentType } = {}) {
 				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();
@@ -1244,31 +1094,22 @@ function createOasParser(oas, { contentType } = {}) {
 					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))],
+			members: [...mergeAdjacentObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjects(allOfMembers.slice(syntheticStart))],
 			...renderSchemaBase(schema, name, nullable, defaultValue)
 		});
 	}
@@ -1280,69 +1121,63 @@ function createOasParser(oas, { contentType } = {}) {
 	* 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 }) {
+		function pickDiscriminatorPropertyNode(node, propertyName) {
+			const discriminatorProperty = narrowSchema(node, "object")?.properties?.find((property) => property.name === propertyName);
+			if (!discriminatorProperty) return;
+			return createSchema({
+				type: "object",
+				primitive: "object",
+				properties: [discriminatorProperty]
+			});
+		}
 		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
-			}, 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({
-			type: "union",
-			...unionBase,
-			members: unionMembers.map((s) => {
+			}, rawOptions);
+		})() : void 0;
+		if (sharedPropertiesNode || discriminator?.mapping) {
+			const 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 = findDiscriminator(discriminator?.mapping, ref);
+				const memberNode = convertSchema({ schema: s }, rawOptions);
+				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, (sharedPropertiesNode ? pickDiscriminatorPropertyNode(setDiscriminatorEnum({
+						node: sharedPropertiesNode,
+						propertyName: discriminator.propertyName,
+						values: [discriminatorValue]
+					}), discriminator.propertyName) : void 0) ?? createDiscriminantNode({
+						propertyName: discriminator.propertyName,
+						value: discriminatorValue
 					})]
 				});
-			})
-		});
+			});
+			const unionNode = createSchema({
+				type: "union",
+				...unionBase,
+				members
+			});
+			if (!sharedPropertiesNode) return unionNode;
+			return createSchema({
+				type: "intersection",
+				...renderSchemaBase(schema, name, nullable, defaultValue),
+				members: [unionNode, sharedPropertiesNode]
+			});
+		}
 		return createSchema({
 			type: "union",
 			...unionBase,
-			members: simplifyUnionMembers(unionMembers.map((s) => convertSchema({ schema: s }, options)))
+			members: simplifyUnion(unionMembers.map((s) => convertSchema({ schema: s }, rawOptions)))
 		});
 	}
 	/**
@@ -1372,10 +1207,10 @@ function createOasParser(oas, { contentType } = {}) {
 	* 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,
@@ -1384,7 +1219,7 @@ function createOasParser(oas, { contentType } = {}) {
 			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,
@@ -1429,28 +1264,19 @@ function createOasParser(oas, { contentType } = {}) {
 	* - 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,
@@ -1462,38 +1288,19 @@ function createOasParser(oas, { contentType } = {}) {
 			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 enumPrimitiveType = 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) => ({
+				primitive: enumPrimitiveType,
+				namedEnumValues: sourceValues.map((label, index) => ({
 					name: String(label),
-					value: filteredValues[index] ?? label,
-					format: enumType
+					value: extensionKey ? filteredValues[index] ?? label : label,
+					primitive: enumPrimitiveType
 				}))
 			});
 		}
-		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)]
@@ -1511,57 +1318,18 @@ function createOasParser(oas, { contentType } = {}) {
 	* - not required + not nullable → `optional: true`
 	* - not required + nullable → `nullish: true`
 	*/
-	/**
-	* Builds the propagation name for a child property during recursive schema conversion.
-	*
-	* The parent name is prepended so the full path is encoded
-	*   (e.g. `OrderParams` when parent is `Order`).
-	*/
-	function resolveChildName(parentName, propName) {
-		return parentName ? pascalCase([parentName, propName].join(" ")) : void 0;
-	}
-	/**
-	* Derives the final name for an enum property schema node.
-	*
-	* The resulting name always includes the enum suffix and full parent path context
-	* (e.g. `OrderParamsStatusEnum`).
-	*/
-	function resolveEnumPropName(parentName, propName, enumSuffix) {
-		return pascalCase([
-			parentName,
-			propName,
-			enumSuffix
-		].filter(Boolean).join(" "));
-	}
-	/**
-	* 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;
 			const propNullable = isNullable(resolvedPropSchema);
-			let schemaNode = applyEnumName(convertSchema({
+			let schemaNode = setEnumName(convertSchema({
 				schema: resolvedPropSchema,
-				name: resolveChildName(name, propName)
-			}, options), name, propName, mergedOptions.enumSuffix);
+				name: childName(name, propName)
+			}, 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) => setEnumName(item, name, propName, options.enumSuffix));
 				if (namedItems.some((item, i) => item !== tupleNode.items[i])) schemaNode = {
 					...tupleNode,
 					items: namedItems
@@ -1579,11 +1347,11 @@ function createOasParser(oas, { contentType } = {}) {
 		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",
@@ -1594,11 +1362,11 @@ function createOasParser(oas, { contentType } = {}) {
 		});
 		if (isDiscriminator(schema) && schema.discriminator.mapping) {
 			const discPropName = schema.discriminator.propertyName;
-			return applyDiscriminatorEnum({
+			return setDiscriminatorEnum({
 				node: objectNode,
 				propertyName: discPropName,
 				values: Object.keys(schema.discriminator.mapping),
-				enumName: name ? resolveEnumPropName(name, discPropName, mergedOptions.enumSuffix) : void 0
+				enumName: name ? enumPropName(name, discPropName, options.enumSuffix) : void 0
 			});
 		}
 		return objectNode;
@@ -1611,12 +1379,12 @@ function createOasParser(oas, { contentType } = {}) {
 	* 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)
@@ -1628,16 +1396,16 @@ function createOasParser(oas, { contentType } = {}) {
 	* 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 ? enumPropName(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,
@@ -1711,16 +1479,16 @@ function createOasParser(oas, { contentType } = {}) {
 	* 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;
@@ -1730,8 +1498,8 @@ function createOasParser(oas, { contentType } = {}) {
 			nullable,
 			defaultValue,
 			type,
-			options,
-			mergedOptions
+			rawOptions,
+			options
 		};
 		if (isReference(schema)) return convertRef(ctx);
 		if (schema.allOf?.length) return convertAllOf(ctx);
@@ -1757,7 +1525,7 @@ function createOasParser(oas, { contentType } = {}) {
 						type: t
 					},
 					name
-				}, options)),
+				}, rawOptions)),
 				...renderSchemaBase(schema, name, arrayNullable, defaultValue)
 			});
 		}
@@ -1775,7 +1543,7 @@ function createOasParser(oas, { contentType } = {}) {
 		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
@@ -1861,34 +1629,12 @@ function createOasParser(oas, { contentType } = {}) {
 			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
-				};
-			}
-		} });
-	}
+	const resolveRefs = (node, resolveName, resolveEnumName) => resolveNames({
+		node,
+		nameMapping,
+		resolveName,
+		resolveEnumName
+	});
 	return {
 		parse,
 		convertSchema,
@@ -1937,10 +1683,17 @@ const adapterOas = createAdapter((options) => {
 			nameMapping
 		},
 		getImports(node, resolve) {
-			return getImports({
+			return collectImports({
 				node,
 				nameMapping,
-				resolve
+				resolve: (schemaName) => {
+					const result = resolve(schemaName);
+					if (!result) return;
+					return {
+						name: [result.name],
+						path: result.path
+					};
+				}
 			});
 		},
 		async parse(source) {