@kubb/adapter-oas 5.15.4 → 5.16.1

package/dist/index.js

@@ -1,5 +1,5 @@
 import { defineExtension } from "@kubb/core";
-import { Diagnostics, ast, childName, enumPrimitive, enumPropName, extractRefName, macroDiscriminatorEnum, macroEnumName, macroSimplifyUnion, mergeAdjacentObjectsLazy } from "@kubb/kit";
+import { Diagnostics, ast, childName, enumPrimitive, enumPropName, extractRefName, macroDedupeUnion, macroDiscriminatorEnum, macroEnumName, mergeAdjacentObjectsLazy } from "@kubb/kit";
 import { join } from "node:path";
 import { access, readFile } from "node:fs/promises";
 import { upgrade } from "@scalar/openapi-upgrader";
@@ -19,7 +19,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.15.4";
+var version = "5.16.1";
 // src/constants.ts
 /**
 * Default parser options applied when no explicit options are provided.
@@ -59,6 +59,17 @@ const SUPPORTED_METHODS = /* @__PURE__ */ new Set([
 	"query"
 ]);
 /**
+* Media types OpenAPI 3.2 reads as a stream of items (its "sequential media types"), each described by `itemSchema`.
+*/
+const STREAM_MEDIA_TYPES = /* @__PURE__ */ new Set([
+	"application/jsonl",
+	"application/x-ndjson",
+	"application/json-seq",
+	"application/geo+json-seq",
+	"text/event-stream",
+	"multipart/mixed"
+]);
+/**
 * Set of JSON Schema keywords that prevent a schema fragment from being inlined during `allOf` flattening.
 *
 * A fragment that contains any of these keys carries structural meaning of its own and must stay as a separate
@@ -383,6 +394,14 @@ function isNullable(schema) {
 	return false;
 }
 /**
+* Returns `true` for an OpenAPI 3.2 or later document. Swagger 2.0 and OpenAPI 3.0 documents are
+* upgraded to 3.1 before parsing, so `openapi` is always set here.
+*/
+function isOpenApi32(document) {
+	const [major = 0, minor = 0] = String(document.openapi).split(".").map(Number);
+	return major > 3 || major === 3 && minor >= 2;
+}
+/**
 * Returns the `x-*` keys of `source` as-is, or `undefined` when there are none.
 */
 function pickExtensions(source) {
@@ -449,7 +468,8 @@ const jsonMimeFragments = [
 * ```
 */
 function isJsonMimeType(mimeType) {
-	return jsonMimeFragments.some((fragment) => mimeType.includes(fragment));
+	const lower = mimeType.toLowerCase();
+	return jsonMimeFragments.some((fragment) => lower.includes(fragment));
 }
 // src/refs.ts
 /**
@@ -873,6 +893,17 @@ function reportInvalidSpec(message) {
 * ```
 */
 async function validateDocument(document, { throwOnError = false } = {}) {
+	if (isOpenApi32(document)) {
+		const diagnostic = {
+			code: Diagnostics.code.invalidSpec,
+			severity: "warning",
+			message: "The document was not validated: `@readme/openapi-parser` does not support OpenAPI 3.2 yet.",
+			help: "Set `validate: false` on the adapter to skip this check until the validator supports OpenAPI 3.2."
+		};
+		if (throwOnError) throw new Diagnostics.Error(diagnostic);
+		Diagnostics.report(diagnostic);
+		return;
+	}
 	const { compileErrors, validate } = await import("@readme/openapi-parser");
 	let result;
 	try {
@@ -902,6 +933,7 @@ function reportValidationErrors({ errors, additionalErrors }) {
 * validating in place where worker threads are missing, as in edge runtimes.
 */
 async function validateDocumentInWorker(document) {
+	if (isOpenApi32(document)) return validateDocument(document);
 	let message;
 	try {
 		const { Worker } = await import("node:worker_threads");
@@ -1172,6 +1204,123 @@ function resolveServerUrl(server, overrides) {
 	}
 	return url;
 }
+// src/model/mediaType.ts
+/**
+* The media type without its parameters, so `text/event-stream; charset=utf-8` matches the bare name.
+*/
+function baseMediaType(contentType) {
+	return contentType.split(";")[0].trim().toLowerCase();
+}
+/**
+* Returns `true` for a media type read as a stream of items: one that OpenAPI 3.2 lists, or any that declares `itemSchema`.
+*/
+function isStream(contentType, mediaType) {
+	return STREAM_MEDIA_TYPES.has(baseMediaType(contentType)) || mediaType?.itemSchema !== void 0;
+}
+/**
+* Whether the media type is `text/event-stream`, with or without parameters.
+*/
+function isEventStream(contentType) {
+	return baseMediaType(contentType) === "text/event-stream";
+}
+/**
+* Replaces a `data` string that holds JSON with its `contentSchema`, so the event reads as parsed.
+*/
+function withParsedData(schema, refs) {
+	const data = schema.properties?.data;
+	const resolved = data && isReference(data) ? refs.resolve(data.$ref, { report: false }) : data;
+	if (!resolved?.contentSchema || !resolved.contentMediaType || !isJsonMimeType(resolved.contentMediaType)) return schema;
+	return {
+		...schema,
+		properties: {
+			...schema.properties,
+			data: resolved.contentSchema
+		}
+	};
+}
+/**
+* Keywords next to `$ref` that only annotate it, so a reference that carries nothing else stays a reference.
+*/
+const REF_ANNOTATIONS = /* @__PURE__ */ new Set([
+	"$ref",
+	"summary",
+	"description",
+	"$comment"
+]);
+/**
+* Applies `extra` on top of `base` the way JSON Schema does: `properties` and `required` add up, other keywords of `extra` win.
+*/
+function mergeSchemas(base, extra) {
+	const required = [.../* @__PURE__ */ new Set([...Array.isArray(base.required) ? base.required : [], ...Array.isArray(extra.required) ? extra.required : []])];
+	return {
+		type: "object",
+		...base,
+		...extra,
+		properties: {
+			...base.properties,
+			...extra.properties
+		},
+		...required.length ? { required } : {}
+	};
+}
+/**
+* Normalizes the OpenAPI 3.2 `text/event-stream` item schema into one schema per event.
+* - Keywords next to a `$ref` apply to the referenced schema.
+* - Shared `properties` merge into each inline `oneOf`/`anyOf` member.
+* - A JSON `data` string becomes its `contentSchema`.
+*/
+function toEventSchema(schema, refs) {
+	if (isReference(schema)) {
+		const siblings = Object.fromEntries(Object.entries(schema).filter(([key]) => !REF_ANNOTATIONS.has(key)));
+		const resolved = Object.keys(siblings).length ? refs.resolve(schema.$ref, { report: false }) : null;
+		return resolved ? toEventSchema(mergeSchemas(resolved, siblings), refs) : schema;
+	}
+	const key = schema.oneOf?.length ? "oneOf" : schema.anyOf?.length ? "anyOf" : void 0;
+	if (!key) return withParsedData(schema, refs);
+	const members = schema[key];
+	const { properties, required, ...rest } = schema;
+	const merge = !!properties && !members.some(isReference);
+	const shared = {
+		properties,
+		required
+	};
+	return {
+		...merge ? rest : schema,
+		[key]: members.map((member) => isReference(member) ? member : withParsedData(merge ? mergeSchemas(shared, member) : member, refs))
+	};
+}
+/**
+* Whether the schema, following `$ref`s, or a composition member of it declares an `event` or `data` property.
+*/
+function declaresEventFields(schema, refs, seen) {
+	if (isReference(schema)) {
+		if (seen.has(schema.$ref)) return false;
+		seen.add(schema.$ref);
+		const resolved = refs.resolve(schema.$ref, { report: false });
+		return !!resolved && declaresEventFields(resolved, refs, seen);
+	}
+	if (schema.properties && (Object.hasOwn(schema.properties, "event") || Object.hasOwn(schema.properties, "data"))) return true;
+	return [
+		...schema.oneOf ?? [],
+		...schema.anyOf ?? [],
+		...schema.allOf ?? []
+	].some((member) => declaresEventFields(member, refs, seen));
+}
+/**
+* Returns `'event'` when the item declares `event` or `data`, directly or in a composition member, else `'data'`.
+*/
+function getItemShape(schema, refs) {
+	return declaresEventFields(schema, refs, /* @__PURE__ */ new Set()) ? "event" : "data";
+}
+/**
+* Returns the raw item schema: `itemSchema`, or `schema` on `text/event-stream` as 3.0 and 3.1 documents write one event.
+*/
+function getItemSchema({ contentType, mediaType, refs, document }) {
+	if (!mediaType || !isStream(contentType, mediaType)) return null;
+	const raw = mediaType.itemSchema ?? (isEventStream(contentType) && !isOpenApi32(document) ? mediaType.schema : void 0);
+	if (!raw) return null;
+	return isEventStream(contentType) ? toEventSchema(raw, refs) : raw;
+}
 // src/emit/schemaShape.ts
 /**
 * Whether `format` maps to a dedicated type; `false` is what `KUBB_UNSUPPORTED_FORMAT` flags.
@@ -1229,7 +1378,7 @@ function flattenSchema(schema) {
 /**
 * Links one freshly converted schema and its nested schemas to their RFC 6901 pointers
 * (`#/components/schemas/Pet/properties/owner/properties/name`), and reports the advisory
-* diagnostics (`KUBB_UNSUPPORTED_FORMAT`, `KUBB_DEPRECATED`) against them.
+* diagnostics (`KUBB_UNSUPPORTED_FORMAT`, `KUBB_DEPRECATED`, `KUBB_DUPLICATE_DISCRIMINATOR`) against them.
 * Refs are not followed, so the resolved schema is handled under its own walk.
 * Reports land in the active build run, are a no-op outside one, and repeats are deduped by the build.
 */
@@ -1274,16 +1423,67 @@ function visit(node, pointer) {
 		for (const member of node.members ?? []) visit(member, `${pointer}/not`);
 		return;
 	}
+	if (node.type === "union" && node.discriminatorPropertyName) reportDuplicateDiscriminators(node, node.discriminatorPropertyName, pointer);
 	if (node.type === "union" || node.type === "intersection") {
 		const keyword = node.type === "intersection" ? "allOf" : node.strategy === "any" ? "anyOf" : "oneOf";
 		for (const [index, member] of (node.members ?? []).entries()) visit(member, `${pointer}/${keyword}/${index}`);
 	}
 }
+/**
+* Reports a declared discriminator whose value pins more than one member. The spec cannot tell
+* those members apart, and Zod's `z.discriminatedUnion` throws on the first parse.
+* One diagnostic per union, since the build dedupes by code and pointer.
+*/
+function reportDuplicateDiscriminators(node, propertyName, pointer) {
+	const keyword = node.strategy === "any" ? "anyOf" : "oneOf";
+	const membersByValue = /* @__PURE__ */ new Map();
+	for (const [index, member] of (node.members ?? []).entries()) {
+		const label = memberName(member) ?? `${keyword}/${index}`;
+		for (const value of memberValues(member, propertyName)) membersByValue.set(value, [...membersByValue.get(value) ?? [], label]);
+	}
+	const duplicates = [...membersByValue].filter(([, members]) => members.length > 1);
+	if (!duplicates.length) return;
+	Diagnostics.report({
+		code: Diagnostics.code.duplicateDiscriminator,
+		severity: "warning",
+		message: duplicates.map(([value, members]) => `Discriminator "${propertyName}" value ${JSON.stringify(value)} matches more than one member (${members.join(", ")}).`).join(" "),
+		help: `Give each member its own "${propertyName}" value, or drop the discriminator. Zod's z.discriminatedUnion throws on the first parse of this union.`,
+		location: {
+			kind: "schema",
+			pointer
+		}
+	});
+}
+function memberValues(node, propertyName, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(node)) return [];
+	seen.add(node);
+	const target = node.type === "ref" && node.schema ? node.schema : node;
+	if (target.type === "union") return [...new Set(target.members?.flatMap((member) => memberValues(member, propertyName, seen)))];
+	return intersect(ast.resolveSchemaProperties({
+		node,
+		propertyName
+	}).map((property) => [...ast.getSchemaLiteralValues(property.schema)]));
+}
+function intersect(slices) {
+	const pinned = slices.filter((values) => values.length > 0);
+	return pinned.reduce((acc, values) => acc.filter((value) => values.includes(value)), pinned[0] ?? []);
+}
+function memberName(member) {
+	if (member.type === "ref") return member.name ?? void 0;
+	if (member.type === "intersection") return member.members?.map(memberName).find(Boolean);
+}
 // src/operation.ts
 function slugify(value) {
 	return value.replace(/[^a-zA-Z0-9]/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
 }
 /**
+* Returns the operation's JSON pointer, under `additionalOperations` for an OpenAPI 3.2 method outside the fixed fields.
+*/
+function getOperationPointer({ path, method }) {
+	const pathPointer = `#/paths/${escapePointerToken(path)}`;
+	return SUPPORTED_METHODS.has(method.toLowerCase()) ? `${pathPointer}/${method.toLowerCase()}` : `${pathPointer}/additionalOperations/${escapePointerToken(method)}`;
+}
+/**
 * Returns the operation's `operationId`, falling back to `<method>_<slugified-path>` when absent.
 */
 function getOperationId({ path, method, schema }) {
@@ -1336,7 +1536,7 @@ function getParameters({ operation, refs }) {
 		}] : [];
 	});
 	const pathPointer = `#/paths/${escapePointerToken(operation.path)}`;
-	const operationParams = resolveParams(operation.schema?.parameters || [], `${pathPointer}/${operation.method.toLowerCase()}`);
+	const operationParams = resolveParams(operation.schema?.parameters || [], getOperationPointer(operation));
 	const pathLevelParams = resolveParams(operation.pathItem.parameters ?? [], pathPointer);
 	const paramMap = /* @__PURE__ */ new Map();
 	for (const entry of [...pathLevelParams, ...operationParams]) if (entry.param.name && entry.param.in) paramMap.set(`${entry.param.in}:${entry.param.name}`, entry);
@@ -1369,17 +1569,59 @@ function getEncoding(encoding) {
 	});
 	return entries.length ? Object.fromEntries(entries) : void 0;
 }
-/** Schema for one media type of a `content` map, with the binary fallback for an emptied non-JSON entry. */
-function getBodySchema({ content, contentType, refs }) {
-	const entry = contentType ? content?.[contentType] : void 0;
-	if (!entry) return null;
-	const binary = getBinaryFallbackSchema(contentType, entry.schema);
+/**
+* Returns the media type entry for `contentType`, resolving a `$ref` into `components.mediaTypes`. `null` when absent.
+*/
+function getMediaType({ content, contentType, refs }) {
+	return contentType ? refs.deref(content?.[contentType]) : null;
+}
+/**
+* Returns the schema for one media type of a `content` map, with the binary fallback for an emptied non-JSON
+* entry. For a stream this is the item schema, so `schema: string` next to `itemSchema` types one item.
+*/
+function getBodySchema({ content, contentType, refs, document }) {
+	const entry = getMediaType({
+		content,
+		contentType,
+		refs
+	});
+	if (!contentType || !entry) return null;
+	const schema = getItemSchema({
+		contentType,
+		mediaType: entry,
+		refs,
+		document
+	}) ?? entry.schema;
+	const binary = entry.itemSchema ? void 0 : getBinaryFallbackSchema(contentType, schema);
 	if (binary) return binary;
-	return entry.schema ? refs.derefKeepingRef(entry.schema) : null;
+	return schema ? refs.derefKeepingRef(schema) : null;
+}
+/** The `stream` field of a content node, set when the media type is a stream. `node` is the parsed item schema. */
+function getStreamField({ contentType, mediaType, refs, document, node }) {
+	if (!isStream(contentType, mediaType)) return {};
+	const raw = getItemSchema({
+		contentType,
+		mediaType,
+		refs,
+		document
+	});
+	return { stream: {
+		...raw ? { schema: node } : {},
+		...raw && isEventStream(contentType) ? { shape: getItemShape(raw, refs) } : {}
+	} };
+}
+/** The media type keyword the body schema was read from, for the diagnostic pointer. */
+function schemaKeyword(mediaType) {
+	return mediaType?.itemSchema ? "itemSchema" : "schema";
+}
+/** Pointer of a media type entry, following a `$ref` into `components.mediaTypes` so a diagnostic lands on the source. */
+function mediaTypePointer(content, contentType, fallback) {
+	const entry = content?.[contentType];
+	return isReference(entry) ? entry.$ref : fallback;
 }
 /**
-* Builds an `Operation` for every supported HTTP method on every path, in document order.
-* `x-` path keys and unresolvable path-item `$ref`s are skipped.
+* Builds an `Operation` for every supported HTTP method and every OpenAPI 3.2 `additionalOperations` entry on
+* every path, in document order. `x-` path keys and unresolvable path-item `$ref`s are skipped.
 */
 function getOperations(document, refs) {
 	const operations = [];
@@ -1401,6 +1643,12 @@ function getOperations(document, refs) {
 				pathItem
 			});
 		}
+		for (const [method, schema] of Object.entries(pathItem.additionalOperations ?? {})) if (schema && typeof schema === "object" && !SUPPORTED_METHODS.has(method.toLowerCase())) operations.push({
+			path,
+			method,
+			schema,
+			pathItem
+		});
 	}
 	return operations;
 }
@@ -1414,10 +1662,15 @@ function collectPropertyKeysByFlag(schema, flag) {
 	}
 	return keys.length ? keys : null;
 }
-function parseParameter({ param, pointer, parentName, options, parseSchema }) {
+/** Converts one parameter into a `ParameterNode`, naming an inline schema after the operation and the parameter. */
+function parseParameter({ param, pointer, parentName, options, parseSchema, refs }) {
 	const schemaName = parentName && param.name ? pascalCase(`${parentName} ${param.name}`) : void 0;
 	const contentType = param.schema ? void 0 : Object.keys(param.content ?? {})[0];
-	const rawSchema = param.schema ?? (contentType ? param.content?.[contentType]?.schema : void 0);
+	const rawSchema = param.schema ?? getMediaType({
+		content: param.content,
+		contentType,
+		refs
+	})?.schema;
 	const schema = rawSchema ? parseSchema({
 		schema: rawSchema,
 		name: schemaName
@@ -1440,16 +1693,17 @@ function parseParameter({ param, pointer, parentName, options, parseSchema }) {
 * Converts an OAS `Operation` into an `OperationNode`.
 */
 function parseOperation({ operation, ...ctx }) {
-	const { refs, contentType, options, parseSchema } = ctx;
+	const { document, refs, contentType, options, parseSchema } = ctx;
 	const operationId = getOperationId(operation);
 	const operationName = operationId ? pascalCase(operationId) : void 0;
-	const pointer = `#/paths/${escapePointerToken(operation.path)}/${operation.method.toLowerCase()}`;
+	const pointer = getOperationPointer(operation);
 	const parameters = getParameters({
 		operation,
 		refs
 	}).map((entry) => parseParameter({
 		options,
 		parseSchema,
+		refs,
 		...entry,
 		parentName: operationName
 	}));
@@ -1463,20 +1717,33 @@ function parseOperation({ operation, ...ctx }) {
 		const schema = getBodySchema({
 			content: body?.content,
 			contentType: ct,
-			refs
+			refs,
+			document
 		});
 		if (!schema) return [];
-		const node = parseSchema({
+		const mediaType = getMediaType({
+			content: body?.content,
+			contentType: ct,
+			refs
+		});
+		const node = ast.optionality(parseSchema({
 			schema,
 			name: requestBodyName
-		});
-		scanSchema(node, `${pointer}/requestBody/content/${escapePointerToken(ct)}/schema`);
-		const encoding = getEncoding(body?.content?.[ct]?.encoding);
+		}), bodyRequired);
+		scanSchema(node, `${mediaTypePointer(body?.content, ct, `${pointer}/requestBody/content/${escapePointerToken(ct)}`)}/${schemaKeyword(mediaType)}`);
+		const encoding = getEncoding(mediaType?.encoding);
 		return [ast.factory.createContent({
 			contentType: ct,
-			schema: ast.optionality(node, bodyRequired),
+			schema: node,
 			keysToOmit: collectPropertyKeysByFlag(schema, "readOnly"),
-			...encoding && { encoding }
+			...encoding && { encoding },
+			...getStreamField({
+				contentType: ct,
+				mediaType,
+				refs,
+				document,
+				node
+			})
 		})];
 	});
 	const requestBody = content.length > 0 || body?.description ? {
@@ -1494,6 +1761,12 @@ function parseOperation({ operation, ...ctx }) {
 		const responseName = operationName ? `${operationName}Status${statusCode}` : void 0;
 		const parseEntrySchema = (ct) => {
 			const raw = getBodySchema({
+				content: response?.content,
+				contentType: ct,
+				refs,
+				document
+			});
+			const mediaType = getMediaType({
 				content: response?.content,
 				contentType: ct,
 				refs
@@ -1502,10 +1775,17 @@ function parseOperation({ operation, ...ctx }) {
 				schema: raw,
 				name: responseName
 			}) : ast.factory.createSchema({ type: options.emptySchemaType });
-			if (raw && ct) scanSchema(node, `${pointer}/responses/${statusCode}/content/${escapePointerToken(ct)}/schema`);
+			if (raw && ct) scanSchema(node, `${mediaTypePointer(response?.content, ct, `${pointer}/responses/${statusCode}/content/${escapePointerToken(ct)}`)}/${schemaKeyword(mediaType)}`);
 			return {
 				schema: node,
-				keysToOmit: collectPropertyKeysByFlag(raw, "writeOnly")
+				keysToOmit: collectPropertyKeysByFlag(raw, "writeOnly"),
+				...ct ? getStreamField({
+					contentType: ct,
+					mediaType,
+					refs,
+					document,
+					node
+				}) : {}
 			};
 		};
 		const responseContent = (contentType ? [contentType] : Object.keys(response?.content ?? {})).map((ct) => ast.factory.createContent({
@@ -1536,7 +1816,7 @@ function parseOperation({ operation, ...ctx }) {
 		pointer,
 		operationId,
 		protocol: "http",
-		method: operation.method.toUpperCase(),
+		method: SUPPORTED_METHODS.has(operation.method) ? operation.method.toUpperCase() : operation.method,
 		path: operation.path,
 		tags: Array.isArray(operation.schema.tags) ? operation.schema.tags.map(String) : [],
 		summary: pickDoc("summary") || void 0,
@@ -1631,6 +1911,14 @@ function createDiscriminantNode({ propertyName, values }) {
 	});
 }
 /**
+* Returns the `$ref` of an OpenAPI 3.2 `defaultMapping`, written as a schema name or a `$ref`; `undefined` when none.
+*/
+function getDefaultMappingRef(discriminator) {
+	const value = discriminator?.defaultMapping;
+	if (!value) return void 0;
+	return value.includes("/") ? value : `${SCHEMA_REF_PREFIX}${value}`;
+}
+/**
 * Returns every discriminator key whose mapping value matches `ref`, in mapping order.
 *
 * A mapping may point several keys at the same schema, in which case the member has to be
@@ -1726,13 +2014,15 @@ function narrowUnionMembers({ unionMembers, discriminator, sharedPropertiesNode,
 		}
 		return constrains(variant) ? null : value;
 	}
+	const defaultRef = getDefaultMappingRef(discriminator);
 	return unionMembers.map((s) => {
 		const ref = isReference(s) ? s.$ref : void 0;
-		const mappedValues = findDiscriminators({
+		const isDefault = ref !== void 0 && ref === defaultRef;
+		const mappedValues = isDefault ? [] : findDiscriminators({
 			mapping: discriminator?.mapping,
 			ref
 		});
-		const implicitValue = mappedValues.length ? null : implicitDiscriminantValue(s);
+		const implicitValue = mappedValues.length || isDefault ? null : implicitDiscriminantValue(s);
 		const propertyType = propertyTypeOf({
 			schema: s,
 			propertyName: discriminator?.propertyName ?? "",
@@ -1777,7 +2067,8 @@ function extractDiscriminatedAllOfMembers({ allOfMembers, name, refs }) {
 			const parentUnion = deref?.oneOf ?? deref?.anyOf;
 			if (!deref || !discriminator || isDiscriminator(deref) && !parentUnion) return true;
 			const childRef = `${SCHEMA_REF_PREFIX}${name}`;
-			const values = findDiscriminators({
+			const isDefault = childRef === getDefaultMappingRef(discriminator);
+			const values = isDefault ? [] : findDiscriminators({
 				mapping: discriminator.mapping,
 				ref: childRef
 			});
@@ -1800,7 +2091,7 @@ function extractDiscriminatedAllOfMembers({ allOfMembers, name, refs }) {
 					})
 				});
 			}
-			return !(parentUnion && (values.length > 0 || parentUnion.some((member) => isReference(member) && member.$ref === childRef)));
+			return !(parentUnion && (isDefault || values.length > 0 || parentUnion.some((member) => isReference(member) && member.$ref === childRef)));
 		}),
 		discriminantValues
 	};
@@ -2122,10 +2413,12 @@ function convertUnion(context) {
 		nullable,
 		defaultValue
 	};
-	const unionMembers = resolveUnionMembers([...schema.oneOf ?? [], ...schema.anyOf ?? []], schema.properties ?? {});
-	const strategy = schema.oneOf ? "one" : "any";
-	const explicitDiscriminatorPropertyName = isDiscriminator(schema) ? schema.discriminator.propertyName : void 0;
 	const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
+	const declaredMembers = [...schema.oneOf ?? [], ...schema.anyOf ?? []];
+	const defaultRef = getDefaultMappingRef(discriminator);
+	const unionMembers = resolveUnionMembers(defaultRef && !declaredMembers.some((member) => isReference(member) && member.$ref === defaultRef) ? [...declaredMembers, { $ref: defaultRef }] : declaredMembers, schema.properties ?? {});
+	const strategy = schema.oneOf ? "one" : "any";
+	const explicitDiscriminatorPropertyName = discriminator?.propertyName;
 	const { oneOf: _o, anyOf: _a, discriminator: _d, ...memberBaseSchema } = schema;
 	const sharedPropertiesNode = schema.properties ? parse({
 		schema: memberBaseSchema,
@@ -2178,7 +2471,7 @@ function convertUnion(context) {
 		members,
 		discriminatorPropertyName: explicitDiscriminatorPropertyName ?? ast.inferDiscriminatorPropertyName(members)
 	});
-	return ast.applyMacros(unionNode, [macroSimplifyUnion], { depth: "shallow" });
+	return ast.applyMacros(unionNode, [macroDedupeUnion], { depth: "shallow" });
 }
 /**
 * Converts an OAS 3.1 multi-type array (e.g. `type: ['string', 'number']`) into a `UnionSchemaNode`.
@@ -2655,6 +2948,10 @@ const schemaRules = [
 			primitive: "string"
 		})
 	},
+	{
+		match: ({ schema, type }) => !type && !schema.enum?.length && (schema.contentMediaType !== void 0 || schema.contentSchema !== void 0),
+		convert: convertString
+	},
 	{
 		match: ({ schema, type }) => !type && (schema.minLength !== void 0 || schema.maxLength !== void 0 || schema.pattern !== void 0),
 		convert: convertString
@@ -2949,7 +3246,7 @@ const locate = (source, location) => {
 */
 const adapterOasName = "oas";
 /**
-* Default Kubb adapter for OpenAPI 2.0, 3.0, and 3.1 specifications. Reads the
+* Default Kubb adapter for OpenAPI 2.0, 3.0, 3.1, and 3.2 specifications. Reads the
 * spec from `input` (a file path, URL, inline content, or parsed object), validates
 * it, resolves the base URL, and converts every schema and operation into the
 * universal AST that every downstream plugin consumes.
@@ -3023,6 +3320,7 @@ const adapterOas = defineExtension({
 			const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
 			const operationNodes = getOperations(document, refs).map((operation) => parseOperation({
 				operation,
+				document,
 				refs,
 				contentType,
 				options: parserOptions,