@kubb/adapter-oas 5.15.3 → 5.16.0

package/dist/index.cjs

@@ -35,7 +35,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.15.3";
+var version = "5.16.0";
 // src/constants.ts
 /**
 * Default parser options applied when no explicit options are provided.
@@ -75,6 +75,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
@@ -399,6 +410,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) {
@@ -465,7 +484,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
 /**
@@ -631,8 +651,10 @@ async function readSource(sourcePath) {
 async function resolveSource(sourcePath) {
 	const data = await readSource(sourcePath);
 	if (sourcePath.toLowerCase().endsWith(".md")) return data;
+	const pathname = urlRegExp.test(sourcePath) ? new URL(sourcePath).pathname : sourcePath;
 	return parseYaml(data, {
 		origin: sourcePath,
+		json: !/\.ya?ml$/i.test(pathname),
 		help: "Fix the syntax at the reported line, or check that `input` points at the spec and not an HTML page."
 	});
 }
@@ -640,11 +662,19 @@ async function resolveSource(sourcePath) {
 * Parses a YAML (or JSON) spec. A syntax error throws `KUBB_INVALID_DOCUMENT` naming `origin`,
 * with the parser message, which keeps the line and column.
 *
-* JSON is valid YAML, so one parser handles both. `js-yaml` parses about ten times faster than
-* `yaml`, and unlike `JSON.parse` it rejects duplicate keys instead of keeping the last one. Its
-* core schema keeps timestamps as strings and `<<` as a plain key, as `yaml` does for YAML 1.2.
+* With `json` (the default), a document that starts with `{` or `[` goes through `JSON.parse`
+* first, about ten times faster than `js-yaml` on a JSON spec. A duplicate key then keeps the last
+* value, as every JSON parser does. YAML flow syntax also starts with `{`, so a parse failure falls
+* through to YAML. Pass `json: false` for a source known to be YAML.
+*
+* `js-yaml` parses about ten times faster than `yaml`, and rejects duplicate keys instead of
+* keeping the last one. Its core schema keeps timestamps as strings and `<<` as a plain key, as
+* `yaml` does for YAML 1.2.
 */
-function parseYaml(data, { origin, help }) {
+function parseYaml(data, { origin, help, json = true }) {
+	if (json && /^\s*[[{]/.test(data)) try {
+		return JSON.parse(data);
+	} catch {}
 	try {
 		const document = (0, js_yaml.load)(data, { schema: js_yaml.CORE_SCHEMA });
 		if (document !== void 0) return document;
@@ -879,6 +909,17 @@ function reportInvalidSpec(message) {
 * ```
 */
 async function validateDocument(document, { throwOnError = false } = {}) {
+	if (isOpenApi32(document)) {
+		const diagnostic = {
+			code: _kubb_kit.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 _kubb_kit.Diagnostics.Error(diagnostic);
+		_kubb_kit.Diagnostics.report(diagnostic);
+		return;
+	}
 	const { compileErrors, validate } = await import("@readme/openapi-parser");
 	let result;
 	try {
@@ -908,6 +949,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");
@@ -1178,6 +1220,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.
@@ -1290,6 +1449,13 @@ 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 }) {
@@ -1342,7 +1508,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);
@@ -1375,17 +1541,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 = [];
@@ -1407,6 +1615,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;
 }
@@ -1420,10 +1634,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
@@ -1446,16 +1665,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
 	}));
@@ -1469,20 +1689,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 = _kubb_kit.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 [_kubb_kit.ast.factory.createContent({
 			contentType: ct,
-			schema: _kubb_kit.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 ? {
@@ -1500,6 +1733,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
@@ -1508,10 +1747,17 @@ function parseOperation({ operation, ...ctx }) {
 				schema: raw,
 				name: responseName
 			}) : _kubb_kit.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) => _kubb_kit.ast.factory.createContent({
@@ -1542,7 +1788,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,
@@ -1637,6 +1883,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
@@ -1732,13 +1986,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 ?? "",
@@ -1783,7 +2039,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
 			});
@@ -1806,7 +2063,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
 	};
@@ -2128,10 +2385,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,
@@ -2184,7 +2443,7 @@ function convertUnion(context) {
 		members,
 		discriminatorPropertyName: explicitDiscriminatorPropertyName ?? _kubb_kit.ast.inferDiscriminatorPropertyName(members)
 	});
-	return _kubb_kit.ast.applyMacros(unionNode, [_kubb_kit.macroSimplifyUnion], { depth: "shallow" });
+	return _kubb_kit.ast.applyMacros(unionNode, [_kubb_kit.macroDedupeUnion], { depth: "shallow" });
 }
 /**
 * Converts an OAS 3.1 multi-type array (e.g. `type: ['string', 'number']`) into a `UnionSchemaNode`.
@@ -2249,6 +2508,34 @@ function getNumericConstraints(schema) {
 	};
 }
 /**
+* Whether an enum value fits the schema's numeric bounds.
+*/
+function isWithinBounds({ value, schema }) {
+	if (typeof value !== "number") return true;
+	const { min, max, exclusiveMinimum, exclusiveMaximum, multipleOf } = getNumericConstraints(schema);
+	if (min !== void 0 && value < min) return false;
+	if (max !== void 0 && value > max) return false;
+	if (exclusiveMinimum !== void 0 && value <= exclusiveMinimum) return false;
+	if (exclusiveMaximum !== void 0 && value >= exclusiveMaximum) return false;
+	if (multipleOf !== void 0 && Math.abs(value / multipleOf - Math.round(value / multipleOf)) > 1e-9) return false;
+	return true;
+}
+/**
+* Builds the test for which `enum` entries stay: not `null`, and within the numeric bounds. `enum` and the bounds
+* apply together, so a value outside them is never valid. Bounds that exclude every value are a spec error, so
+* they are ignored rather than leaving an empty enum.
+*/
+function createEnumMemberFilter(schema) {
+	const boundsApply = schema.enum.some((value) => value !== null && isWithinBounds({
+		value,
+		schema
+	}));
+	return (value) => value !== null && (!boundsApply || isWithinBounds({
+		value,
+		schema
+	}));
+}
+/**
 * Builds a `null` scalar node carrying the schema's documentation. Shared by the `const: null`
 * and the drf-spectacular `NullEnum` (`{ enum: [null] }`) branches, which render identically.
 */
@@ -2329,7 +2616,8 @@ function convertEnum({ schema, name, nullable, type, parse }) {
 		name
 	});
 	const nullInEnum = schema.enum.includes(null);
-	const filteredValues = nullInEnum ? schema.enum.filter((v) => v !== null) : schema.enum;
+	const isMember = createEnumMemberFilter(schema);
+	const filteredValues = schema.enum.filter(isMember);
 	if (nullInEnum && filteredValues.length === 0) return createNullNode(schema, name);
 	const enumNullable = nullable || nullInEnum || void 0;
 	const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
@@ -2348,8 +2636,9 @@ function convertEnum({ schema, name, nullable, type, parse }) {
 		primitive,
 		enumValues: uniqueValues
 	});
-	const rawEnumNames = extensionKey ? schema[extensionKey] : void 0;
-	const rawEnumDescriptions = descriptionKey ? schema[descriptionKey] : void 0;
+	const memberSlots = (list) => Array.isArray(list) ? list.filter((_, index) => isMember(schema.enum[index])) : void 0;
+	const rawEnumNames = extensionKey ? memberSlots(schema[extensionKey]) : void 0;
+	const rawEnumDescriptions = descriptionKey ? memberSlots(schema[descriptionKey]) : void 0;
 	const seenNames = /* @__PURE__ */ new Set();
 	return createNode(ctx, {
 		type: "enum",
@@ -2367,6 +2656,25 @@ function convertEnum({ schema, name, nullable, type, parse }) {
 	});
 }
 /**
+* Converts an `enum` with a handled `format` into a union of its literal values. A named enum node would rename
+* the exported type (`Status` becomes `StatusKey`), so the union keeps the name the format type had.
+*/
+function convertFormattedEnum(context) {
+	const { schema, nullable } = context;
+	const values = [...new Set(schema.enum.filter(createEnumMemberFilter(schema)))];
+	return createNode({
+		...context,
+		nullable: nullable || schema.enum.includes(null) || void 0
+	}, {
+		type: "union",
+		members: values.map((value) => _kubb_kit.ast.factory.createSchema({
+			type: "enum",
+			primitive: getPrimitiveType(typeof value),
+			enumValues: [value]
+		}))
+	});
+}
+/**
 * Converts a `type: 'string'` schema into a `StringSchemaNode`.
 */
 function convertString(context) {
@@ -2543,6 +2851,24 @@ function convertArray({ schema, name, nullable, defaultValue, options, parse })
 }
 // src/emit/parseSchema.ts
 /**
+* Whether the `format` rule owns the schema: a handled format, and for a date format a `dateType` that is not `false`.
+*/
+function matchesFormat({ schema, options }) {
+	if (!schema.format) return false;
+	if (schema.format === "date-time" || schema.format === "date" || schema.format === "time") return resolveDateTypeValue(options.dateType, schema.format) !== false;
+	return isHandledFormat(schema.format);
+}
+/**
+* Whether the format prints as a plain `string` or `number`, so narrowing it to literal values cannot break callers.
+* `Date`, `bigint` and `Blob` outputs keep the format.
+*/
+function formatPrintsPlainType({ schema, options, type }) {
+	const format = schema.format;
+	if (format === "date-time" || format === "date" || format === "time") return resolveDateTypeValue(options.dateType, format) !== "date";
+	if ((format === "int64" || format === "uint64") && type !== "string") return options.integerType !== "bigint";
+	return formatMap[format] !== "blob";
+}
+/**
 * Ordered schema rule table. Order is significant: composition keywords (`not`, `$ref`, `allOf`,
 * `oneOf`/`anyOf`) take precedence over `const` (except a `$ref` with a sibling `const`, where the
 * `const` wins), which takes precedence over a genuine OAS 3.1 multi-type array (more than one
@@ -2580,11 +2906,11 @@ const schemaRules = [
 		convert: convertMultiType
 	},
 	{
-		match: ({ schema, options }) => {
-			if (!schema.format) return false;
-			if (schema.format === "date-time" || schema.format === "date" || schema.format === "time") return resolveDateTypeValue(options.dateType, schema.format) !== false;
-			return isHandledFormat(schema.format);
-		},
+		match: (ctx) => ctx.type !== "array" && !!ctx.schema.enum?.some((value) => value !== null) && matchesFormat(ctx) && formatPrintsPlainType(ctx),
+		convert: convertFormattedEnum
+	},
+	{
+		match: matchesFormat,
 		convert: convertFormat
 	},
 	{
@@ -2594,6 +2920,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
@@ -2887,7 +3217,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.
@@ -2961,6 +3291,7 @@ const adapterOas = (0, _kubb_core.defineExtension)({
 			const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
 			const operationNodes = getOperations(document, refs).map((operation) => parseOperation({
 				operation,
+				document,
 				refs,
 				contentType,
 				options: parserOptions,