@mintlify/validation 0.1.889 → 0.1.891

package/dist/openapi/v2/mapPaths.js

@@ -1,4 +1,5 @@
 import { v4 as uuidv4 } from 'uuid';
+import { activePathItemsOf, resolvePathItemReference } from '../pathItemReferences.js';
 import { getObjectById } from './getObjectById.js';
 import { mapPath } from './mapPath.js';
 export const mapPaths = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId, }) => {
@@ -8,13 +9,25 @@ export const mapPaths = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, d
     const document = getObjectById({ uuidObjectHashMap, hashedNodeMap, id: documentId });
     if (!document)
         return;
-    Object.entries(paths).forEach(([path, pathItem]) => {
-        if (!pathItem)
+    Object.entries(paths).forEach(([path, rawPathItem]) => {
+        var _a;
+        if (!rawPathItem)
             return;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- resolved items keep the PathObject shape
+        const pathItem = structuredClone((_a = resolvePathItemReference(rawPathItem, spec.components)) !== null && _a !== void 0 ? _a : rawPathItem);
         const uuid = uuidv4();
         // map to uuidObjectHashMap, hashedNodeMap
         // map path + operation in refUuidMap in mapPath
-        mapPath({ pathItem, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, path });
+        mapPath({
+            pathItem,
+            refUuidMap,
+            uuidObjectHashMap,
+            hashedNodeMap,
+            uuid,
+            path,
+            components: spec.components,
+            activePathItems: activePathItemsOf(rawPathItem),
+        });
         // add path to document
         document.paths.push(uuid);
     });

package/dist/openapi/v2/mapRequestBody.d.ts

@@ -1,5 +1,5 @@
 import { HashedNodeMap, RequestBodyOrRefObject, RefUuidMap, UUID, UUIDObjectHashMap } from './types/index.js';
-export declare const mapRequestBody: ({ requestBody, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+export declare const mapRequestBody: ({ requestBody: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
     requestBody: RequestBodyOrRefObject;
     refUuidMap: RefUuidMap;
     uuidObjectHashMap: UUIDObjectHashMap;

package/dist/openapi/v2/mapRequestBody.js

@@ -1,17 +1,17 @@
 import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
 import { mapMedia } from './mapMedia.js';
-export const mapRequestBody = ({ requestBody, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+import { ownCopy } from './ownCopy.js';
+export const mapRequestBody = ({ requestBody: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
     // hash the raw object
-    const objectHash = hash(requestBody);
+    const objectHash = hash(input);
     // map uuid and hash to uuidObjectHashMap
     uuidObjectHashMap[uuid] = objectHash;
     // if we've seen this exact object before, skip processing
     if (objectHash in hashedNodeMap) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        requestBody = objectHash;
         return;
     }
+    const requestBody = ownCopy(input, ['content']);
     // if ref, replace with uuid
     if ('$ref' in requestBody && requestBody.$ref) {
         const refId = requestBody.$ref;

package/dist/openapi/v2/mapResponse.d.ts

@@ -1,5 +1,5 @@
 import { RefUuidMap, UUIDObjectHashMap, ResponseOrRefObject, HashedNodeMap, UUID } from './types/index.js';
-export declare const mapResponse: ({ response, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
+export declare const mapResponse: ({ response: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
     response: ResponseOrRefObject;
     refUuidMap: RefUuidMap;
     uuidObjectHashMap: UUIDObjectHashMap;

package/dist/openapi/v2/mapResponse.js

@@ -2,11 +2,13 @@ import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
 import { mapHeader } from './mapHeader.js';
 import { mapMedia } from './mapMedia.js';
-export const mapResponse = ({ response, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
+import { ownCopy } from './ownCopy.js';
+export const mapResponse = ({ response: input, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
     // hash the raw object
-    const objectHash = hash(response);
+    const objectHash = hash(input);
     // map uuid and hash to uuidObjectHashMap
     uuidObjectHashMap[uuid] = objectHash;
+    const response = ownCopy(input, ['headers', 'content']);
     // if ref, replace with uuid
     if ('$ref' in response && response.$ref) {
         const refId = response.$ref;

package/dist/openapi/v2/mapSchemaComponents.js

@@ -1,6 +1,6 @@
 import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
-import { replaceSchemaRefs } from './replaceSchemaRefs.js';
+import { bindDiscriminatorDefault, replaceSchemaRefs } from './replaceSchemaRefs.js';
 export const mapSchemaComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
     var _a;
     const schemaComponents = (_a = spec.components) === null || _a === void 0 ? void 0 : _a.schemas;
@@ -21,4 +21,7 @@ export const mapSchemaComponents = ({ spec, refUuidMap, uuidObjectHashMap, hashe
         // add to hashedNodeMap
         hashedNodeMap[objectHash] = schema;
     });
+    Object.values(hashedNodeMap).forEach((schema) => {
+        bindDiscriminatorDefault({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap });
+    });
 };

package/dist/openapi/v2/mapSecurityRequirement.d.ts

@@ -1,4 +1,5 @@
 import { RefUuidMap, SecurityRequirementObject, UUIDObjectHashMap, HashedNodeMap, UUID } from './types/index.js';
+export declare const resolveSecuritySchemeName: (key: string, refUuidMap: RefUuidMap) => string | undefined;
 export declare const mapSecurityRequirement: ({ security, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }: {
     security: SecurityRequirementObject;
     refUuidMap: RefUuidMap;

package/dist/openapi/v2/mapSecurityRequirement.js

@@ -1,17 +1,26 @@
 import hash from 'object-hash';
 import { v4 as uuidv4 } from 'uuid';
+import { getSecuritySchemeNameFromFragment } from '../componentRefs.js';
+const SECURITY_SCHEMES_POINTER = '#/components/securitySchemes/';
+export const resolveSecuritySchemeName = (key, refUuidMap) => {
+    const hasScheme = (name) => Object.prototype.hasOwnProperty.call(refUuidMap, `${SECURITY_SCHEMES_POINTER}${name}`);
+    if (hasScheme(key))
+        return key;
+    const name = getSecuritySchemeNameFromFragment(key);
+    if (name === undefined)
+        return undefined;
+    return hasScheme(name) ? name : undefined;
+};
 export const mapSecurityRequirement = ({ security, refUuidMap, uuidObjectHashMap, hashedNodeMap, uuid, }) => {
     const securityRequirementObject = {};
     Object.entries(security).forEach(([securitySchemeName, securitySchemeScopes]) => {
         // create security requirement object
         // add $ref to matching security scheme from components.securitySchemes
         // add scopes to the security requirement object
-        const refId = `#/components/securitySchemes/${securitySchemeName}`;
-        const refUuid = refUuidMap[refId] || uuidv4();
-        securityRequirementObject[securitySchemeName] = {
-            $ref: refUuid,
-            scopes: securitySchemeScopes,
-        };
+        const schemeName = resolveSecuritySchemeName(securitySchemeName, refUuidMap);
+        const refId = schemeName === undefined ? undefined : `${SECURITY_SCHEMES_POINTER}${schemeName}`;
+        const refUuid = (refId && refUuidMap[refId]) || uuidv4();
+        securityRequirementObject[securitySchemeName] = Object.assign({ $ref: refUuid, scopes: securitySchemeScopes }, (schemeName !== undefined ? { schemeName } : {}));
     });
     const objectHash = hash(securityRequirementObject);
     uuidObjectHashMap[uuid] = objectHash;

package/dist/openapi/v2/mapWebhooks.js

@@ -1,4 +1,5 @@
 import { v4 as uuidv4 } from 'uuid';
+import { activePathItemsOf, resolvePathItemReference } from '../pathItemReferences.js';
 import { getObjectById } from './getObjectById.js';
 import { mapPath } from './mapPath.js';
 export const mapWebhooks = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap, documentId, }) => {
@@ -10,9 +11,12 @@ export const mapWebhooks = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap
     const document = getObjectById({ uuidObjectHashMap, hashedNodeMap, id: documentId });
     if (!document)
         return;
-    Object.entries(webhooks).forEach(([webhookPath, webhook]) => {
-        if (!webhook)
+    Object.entries(webhooks).forEach(([webhookPath, rawWebhook]) => {
+        var _a;
+        if (!rawWebhook)
             return;
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- resolved items keep the PathObjectOrRef shape
+        const webhook = structuredClone((_a = resolvePathItemReference(rawWebhook, spec.components)) !== null && _a !== void 0 ? _a : rawWebhook);
         const uuid = uuidv4();
         // map to uuidObjectHashMap, hashedNodeMap
         // map path + operation in refUuidMap in mapPath
@@ -24,6 +28,8 @@ export const mapWebhooks = ({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap
             uuid,
             path: webhookPath,
             isWebhook: true,
+            components: spec.components,
+            activePathItems: activePathItemsOf(rawWebhook),
         });
         // add webhook to document
         document.webhooks.push(uuid);

package/dist/openapi/v2/openApiToSchemaGraph.js

@@ -4,6 +4,7 @@ import { mapCallbackComponents } from './mapCallbackComponents.js';
 import { mapDocument } from './mapDocument.js';
 import { mapExampleComponents } from './mapExampleComponents.js';
 import { mapHeaderComponents } from './mapHeaderComponents.js';
+import { mapMediaTypeComponents } from './mapMediaTypeComponents.js';
 import { mapParameterComponents } from './mapParameterComponents.js';
 import { mapPathComponents } from './mapPathComponents.js';
 import { mapPaths } from './mapPaths.js';
@@ -29,6 +30,7 @@ export const openApiToSchemaGraph = ({ spec, originalFileLocation, }) => {
     // (starting with the components section, which already have uuids in refUuidMap)
     // document.components.schemas -> Schema
     mapSchemaComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
+    mapMediaTypeComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.responses -> Response, possibly Header, Schema, Example, Media, Encoding
     mapResponseComponents({ spec, refUuidMap, uuidObjectHashMap, hashedNodeMap });
     // document.components.parameters -> Parameter, possibly Schema, Example, Media, Encoding

package/dist/openapi/v2/ownCopy.d.ts

@@ -0,0 +1 @@
+export declare const ownCopy: <T extends object>(value: T, nestedRecords: readonly string[]) => T;

package/dist/openapi/v2/ownCopy.js

@@ -0,0 +1,11 @@
+import { isObject } from '../utils.js';
+export const ownCopy = (value, nestedRecords) => {
+    const copy = Object.assign({}, value);
+    for (const key of nestedRecords) {
+        const nested = Reflect.get(copy, key);
+        if (isObject(nested)) {
+            Reflect.set(copy, key, Object.assign({}, nested));
+        }
+    }
+    return copy;
+};

package/dist/openapi/v2/replaceSchemaRefs.d.ts

@@ -1,4 +1,4 @@
-import { RefUuidMap, SchemaOrRefObject, UUIDObjectHashMap, HashedNodeMap, UUID } from './types/index.js';
+import { RefUuidMap, SchemaOrRefObject, UUIDObjectHashMap, HashedNodeMap, UUID, GraphNode } from './types/index.js';
 export declare const replaceSchemaRefs: ({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, schemaToUuidMap, }: {
     schema: SchemaOrRefObject;
     refUuidMap: RefUuidMap;
@@ -6,3 +6,9 @@ export declare const replaceSchemaRefs: ({ schema, refUuidMap, uuidObjectHashMap
     hashedNodeMap: HashedNodeMap;
     schemaToUuidMap?: WeakMap<SchemaOrRefObject, UUID>;
 }) => void;
+export declare const bindDiscriminatorDefault: ({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, }: {
+    schema: GraphNode;
+    refUuidMap: RefUuidMap;
+    uuidObjectHashMap: UUIDObjectHashMap;
+    hashedNodeMap: HashedNodeMap;
+}) => void;

package/dist/openapi/v2/replaceSchemaRefs.js

@@ -1,11 +1,13 @@
 import hash from 'object-hash';
-import { v4 as uuidv4 } from 'uuid';
+import { v4 as uuidv4, validate as uuidValidate } from 'uuid';
+import { getComponentNameFromRef } from '../componentRefs.js';
 export const replaceSchemaRefs = ({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, schemaToUuidMap = new WeakMap(), }) => {
     if ('$ref' in schema) {
-        const refId = schema.$ref;
-        const uuid = refUuidMap[refId] || uuidv4();
-        schema.$ref = uuid;
-        return;
+        if (!uuidValidate(schema.$ref)) {
+            schema.$ref = lookupSchemaRef(schema.$ref, refUuidMap) || uuidv4();
+        }
+        if (Object.keys(schema).length === 1)
+            return;
     }
     if (schemaToUuidMap.has(schema)) {
         const value = schemaToUuidMap.get(schema);
@@ -141,15 +143,111 @@ export const replaceSchemaRefs = ({ schema, refUuidMap, uuidObjectHashMap, hashe
         const mapping = schema.discriminator.mapping;
         for (const key of Object.keys(mapping)) {
             const value = mapping[key];
-            if (typeof value === 'string' && value.startsWith('#/')) {
-                const uuid = refUuidMap[value];
-                if (uuid) {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    mapping[key] = uuid;
-                }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const uuid = typeof value === 'string' ? discriminatorTargetUuid(value, refUuidMap) : undefined;
+            if (uuid) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                mapping[key] = uuid;
             }
         }
     }
+    bindDiscriminatorDefault({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap });
+};
+const ALIAS_KEYS = new Set(['$ref', 'summary', 'description']);
+export const bindDiscriminatorDefault = ({ schema, refUuidMap, uuidObjectHashMap, hashedNodeMap, }) => {
+    var _a, _b, _c;
+    if (typeof schema !== 'object' ||
+        !('discriminator' in schema) ||
+        typeof schema.discriminator !== 'object' ||
+        schema.discriminator === null ||
+        !('defaultMapping' in schema.discriminator) ||
+        typeof schema.discriminator.defaultMapping !== 'string') {
+        return;
+    }
+    const target = schema.discriminator.defaultMapping;
+    const uuid = (_a = discriminatorTargetUuid(target, refUuidMap)) !== null && _a !== void 0 ? _a : (target in uuidObjectHashMap ? target : undefined);
+    if (!uuid)
+        return;
+    const nodeOf = (nodeUuid) => {
+        const objectHash = uuidObjectHashMap[nodeUuid];
+        return objectHash === undefined ? undefined : hashedNodeMap[objectHash];
+    };
+    const { union, mapped } = unionVariantUuids(schema, nodeOf);
+    if (union.includes(target) || mapped.includes(target))
+        return;
+    const canonical = (nodeUuid) => {
+        const seen = new Set();
+        let current = nodeUuid;
+        while (!seen.has(current)) {
+            seen.add(current);
+            const node = nodeOf(current);
+            if (typeof node !== 'object' || !('$ref' in node) || typeof node.$ref !== 'string')
+                break;
+            if (Object.keys(node).some((key) => !ALIAS_KEYS.has(key)))
+                break;
+            current = node.$ref;
+        }
+        return current;
+    };
+    const canonicalDefault = canonical(uuid);
+    const pick = (candidates) => candidates.includes(uuid)
+        ? uuid
+        : candidates.find((candidate) => canonical(candidate) === canonicalDefault);
+    schema.discriminator.defaultMapping = (_c = (_b = pick(union)) !== null && _b !== void 0 ? _b : pick(mapped)) !== null && _c !== void 0 ? _c : uuid;
+};
+const uuidsIn = (members) => Array.isArray(members)
+    ? members.flatMap((member) => (typeof member === 'string' ? [member] : []))
+    : [];
+const mappingUuids = (discriminator) => typeof discriminator === 'object' &&
+    discriminator !== null &&
+    'mapping' in discriminator &&
+    typeof discriminator.mapping === 'object' &&
+    discriminator.mapping !== null
+    ? uuidsIn(Object.values(discriminator.mapping))
+    : [];
+const unionVariantUuids = (holder, nodeOf, seen = new Set([holder])) => {
+    if (typeof holder !== 'object')
+        return { union: [], mapped: [] };
+    const composition = compositionOf(holder, nodeOf, new Set(seen));
+    const nested = uuidsIn(composition.allOf).flatMap((uuid) => {
+        const target = nodeOf(uuid);
+        if (target === undefined || seen.has(target))
+            return [];
+        seen.add(target);
+        return [unionVariantUuids(target, nodeOf, seen)];
+    });
+    return {
+        union: [
+            ...uuidsIn(composition.oneOf),
+            ...uuidsIn(composition.anyOf),
+            ...nested.flatMap((inner) => inner.union),
+        ],
+        mapped: [
+            ...mappingUuids(composition.discriminator),
+            ...nested.flatMap((inner) => inner.mapped),
+        ],
+    };
+};
+const compositionOf = (holder, nodeOf, seen) => {
+    if (typeof holder !== 'object')
+        return {};
+    const own = Object.assign(Object.assign(Object.assign(Object.assign({}, ('oneOf' in holder ? { oneOf: holder.oneOf } : {})), ('anyOf' in holder ? { anyOf: holder.anyOf } : {})), ('allOf' in holder ? { allOf: holder.allOf } : {})), ('discriminator' in holder ? { discriminator: holder.discriminator } : {}));
+    if (!('$ref' in holder) || typeof holder.$ref !== 'string')
+        return own;
+    const target = nodeOf(holder.$ref);
+    if (target === undefined || seen.has(target))
+        return own;
+    seen.add(target);
+    return Object.assign(Object.assign({}, compositionOf(target, nodeOf, seen)), own);
+};
+const discriminatorTargetUuid = (target, refUuidMap) => target.startsWith('#')
+    ? lookupSchemaRef(target, refUuidMap)
+    : refUuidMap[`#/components/schemas/${target.startsWith('./') ? target.slice(2) : target}`];
+const lookupSchemaRef = (ref, refUuidMap) => {
+    const componentName = getComponentNameFromRef(ref, 'schemas');
+    return componentName === undefined
+        ? refUuidMap[ref]
+        : refUuidMap[`#/components/schemas/${componentName}`];
 };
 const processChildSchema = ({ childSchema, refUuidMap, uuidObjectHashMap, hashedNodeMap, schemaToUuidMap, }) => {
     if (typeof childSchema !== 'object') {
@@ -157,7 +255,8 @@ const processChildSchema = ({ childSchema, refUuidMap, uuidObjectHashMap, hashed
     }
     // preserve sibling properties when resolving $ref
     if ('$ref' in childSchema) {
-        const refId = childSchema.$ref;
+        const componentName = getComponentNameFromRef(childSchema.$ref, 'schemas');
+        const refId = componentName === undefined ? childSchema.$ref : `#/components/schemas/${componentName}`;
         const refUuid = refUuidMap[refId] || uuidv4();
         // if no siblings, safe to return ref uuid directly
         const siblingKeys = Object.keys(childSchema).filter((key) => key !== '$ref');
@@ -174,6 +273,13 @@ const processChildSchema = ({ childSchema, refUuidMap, uuidObjectHashMap, hashed
             return childUuid;
         }
         uuidObjectHashMap[childUuid] = objectHash;
+        replaceSchemaRefs({
+            schema: childSchema,
+            refUuidMap,
+            uuidObjectHashMap,
+            hashedNodeMap,
+            schemaToUuidMap,
+        });
         hashedNodeMap[objectHash] = childSchema;
         schemaToUuidMap.set(childSchema, childUuid);
         return childUuid;

package/dist/openapi/v2/schemaGraphToOpenApi.js

@@ -1,4 +1,5 @@
 import { httpMethods, isFixedHttpMethod } from '../types/endpoint.js';
+import { resolveSecuritySchemeName } from './mapSecurityRequirement.js';
 /**
  * Converts a SchemaGraphData back to an OpenAPI specification.
  * Optionally filters to a specific operation if path and method are provided.
@@ -29,10 +30,14 @@ export function schemaGraphToOpenApi({ schemaGraphData, targetPath, targetMethod
     const usedSecuritySchemes = new Set();
     // Helper to transform security requirements from internal format to OpenAPI format
     const transformSecurityRequirement = (securityReq) => {
+        var _a;
         const transformed = {};
         for (const [key, value] of Object.entries(securityReq)) {
             // Track this security scheme as used
-            usedSecuritySchemes.add(key);
+            const schemeName = typeof value === 'object' && !Array.isArray(value) && typeof value.schemeName === 'string'
+                ? value.schemeName
+                : ((_a = resolveSecuritySchemeName(key, refUuidMap)) !== null && _a !== void 0 ? _a : key);
+            usedSecuritySchemes.add(schemeName);
             if (typeof value === 'object' && !Array.isArray(value) && 'scopes' in value) {
                 // Extract just the scopes array from internal format
                 // Create a new array to avoid YAML anchor references
@@ -45,6 +50,12 @@ export function schemaGraphToOpenApi({ schemaGraphData, targetPath, targetMethod
         }
         return transformed;
     };
+    const toReferenceString = (refPath) => {
+        const match = /^(#\/components\/[^/]+\/)(.+)$/.exec(refPath);
+        if (!(match === null || match === void 0 ? void 0 : match[1]) || !match[2])
+            return refPath;
+        return `${match[1]}${match[2].replace(/%/g, '%25').replace(/~/g, '~0').replace(/\//g, '~1')}`;
+    };
     // Helper to convert UUID references back to $ref or inline objects
     const convertValue = (value, depth = 0) => {
         // Prevent infinite recursion - return empty object as fallback
@@ -58,7 +69,7 @@ export function schemaGraphToOpenApi({ schemaGraphData, targetPath, targetMethod
             // If this UUID corresponds to a component ref, use $ref
             if (refPath && refPath.startsWith('#/components/')) {
                 usedComponents.add(refPath);
-                return { $ref: refPath };
+                return { $ref: toReferenceString(refPath) };
             }
             // Otherwise try to resolve and inline it
             const resolved = resolveNode(value);
@@ -82,7 +93,7 @@ export function schemaGraphToOpenApi({ schemaGraphData, targetPath, targetMethod
                     const refPath = uuidRefMap.get(refValue);
                     if (refPath && refPath.startsWith('#/components/')) {
                         usedComponents.add(refPath);
-                        convertedRef = refPath;
+                        convertedRef = toReferenceString(refPath);
                     }
                     else {
                         convertedRef = refValue;
@@ -100,19 +111,54 @@ export function schemaGraphToOpenApi({ schemaGraphData, targetPath, targetMethod
                 const result = { $ref: convertedRef };
                 for (const [key, val] of Object.entries(value)) {
                     if (key !== '$ref') {
-                        result[key] = convertValue(val, depth + 1);
+                        result[key] = convertProperty(key, val, depth + 1);
                     }
                 }
                 return result;
             }
             const result = {};
             for (const [key, val] of Object.entries(value)) {
-                result[key] = convertValue(val, depth + 1);
+                result[key] = convertProperty(key, val, depth + 1);
             }
             return result;
         }
         return value;
     };
+    const discriminatorTarget = (target, hops = 0) => {
+        if (typeof target !== 'string' || hops > 5)
+            return target;
+        const refPath = uuidRefMap.get(target);
+        if (refPath && refPath.startsWith('#/components/')) {
+            usedComponents.add(refPath);
+            return toReferenceString(refPath);
+        }
+        const resolved = resolveNode(target);
+        if (resolved && typeof resolved === 'object' && '$ref' in resolved) {
+            return discriminatorTarget(resolved.$ref, hops + 1);
+        }
+        return target;
+    };
+    const convertProperty = (key, val, depth) => {
+        if (key !== 'discriminator' ||
+            typeof val !== 'object' ||
+            val === null ||
+            Array.isArray(val) ||
+            !('propertyName' in val) ||
+            typeof val.propertyName !== 'string') {
+            return convertValue(val, depth);
+        }
+        const discriminator = Object.assign({}, val);
+        if (typeof discriminator.mapping === 'object' && discriminator.mapping !== null) {
+            discriminator.mapping = Object.fromEntries(Object.entries(discriminator.mapping).map(([name, target]) => [
+                name,
+                discriminatorTarget(target),
+            ]));
+        }
+        if ('defaultMapping' in discriminator) {
+            discriminator.defaultMapping = discriminatorTarget(discriminator.defaultMapping);
+        }
+        return discriminator;
+    };
     // Get the document root
     const docObj = resolveNode(documentId);
     if (!docObj) {

package/dist/openapi/v2/types/index.d.ts

@@ -6,8 +6,13 @@ export type HashId = string;
 export type RefUuidMap = Record<string, UUID>;
 export type UUIDObjectHashMap = Record<UUID, HashId>;
 export type HashedNodeMap = Record<HashId, GraphNode>;
-export type GraphNode = SchemaOrRef | ResponseOrRef | HeaderOrRef | ParameterOrRef | Media | ExampleOrRef | RequestBodyOrRef | SecuritySchemeOrRef | CallbackOrRef | ServerObject | PathOrRef | Operation | SecurityRequirement | Document;
-export type SchemaObject = OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject;
+export type GraphNode = SchemaOrRef | ResponseOrRef | HeaderOrRef | ParameterOrRef | Media | MediaRef | ExampleOrRef | RequestBodyOrRef | SecuritySchemeOrRef | CallbackOrRef | ServerObject | PathOrRef | Operation | SecurityRequirement | Document;
+type DiscriminatorObject = OpenAPIV3.DiscriminatorObject & Pick<OpenAPIV3_2.DiscriminatorObject, 'defaultMapping'>;
+export type SchemaObject = (OpenAPIV3.SchemaObject & {
+    discriminator?: DiscriminatorObject;
+}) | (OpenAPIV3_1.SchemaObject & {
+    discriminator?: DiscriminatorObject;
+});
 export type ArraySchemaObject = OpenAPIV3_1.ArraySchemaObject & {
     prefixItems?: SchemaObject[];
 };
@@ -37,7 +42,7 @@ export type SchemaOrRef = (SchemaOrRefObject & {
     oneOf?: never;
     not?: never;
 }) | HashId;
-export type ResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject;
+export type ResponseObject = (Omit<OpenAPIV3.ResponseObject, 'description'> | Omit<OpenAPIV3_1.ResponseObject, 'description'>) & Pick<OpenAPIV3_2.ResponseObject, 'summary' | 'description'>;
 export type ResponseOrRefObject = ResponseObject | RefObject;
 export type ResponseOrRef = (ResponseObject & {
     headers?: {
@@ -96,17 +101,26 @@ export type ParameterOrRef = (ParameterObject & {
     examples?: never;
     content?: never;
 });
-export type MediaObject = OpenAPIV3.MediaTypeObject | (Omit<OpenAPIV3_1.MediaTypeObject, 'examples'> & {
+export type MediaObject = OpenAPIV3.MediaTypeObject | (Omit<OpenAPIV3_1.MediaTypeObject, 'examples' | 'encoding'> & {
     examples?: Record<string, OpenAPIV3_1.ReferenceObject | ExampleObject>;
+    itemSchema?: OpenAPIV3_2.MediaTypeObject['itemSchema'];
+    encoding?: Record<string, EncodingObject>;
+    prefixEncoding?: EncodingObject[];
+    itemEncoding?: EncodingObject;
 });
+export type EncodingObject = OpenAPIV3_1.EncodingObject & {
+    prefixEncoding?: EncodingObject[];
+    itemEncoding?: EncodingObject;
+};
+export type MediaRef = RefObject & {
+    $ref: UUID;
+};
 export type Media = MediaObject & {
     schema?: UUID;
+    itemSchema?: UUID;
     examples?: {
         [name: string]: UUID;
     };
-    encoding?: {
-        [encoding: string]: UUID;
-    };
 };
 export type ExampleObject = OpenAPIV3.ExampleObject | OpenAPIV3_1.ExampleObject | OpenAPIV3_2.ExampleObject;
 export type ExampleOrRefObject = ExampleObject | RefObject;
@@ -144,11 +158,12 @@ export type CallbackOrRef = (CallbackObject & {
 }) | (RefObject & {
     $ref: UUID;
 });
-export type ServerObject = OpenAPIV3.ServerObject | OpenAPIV3_1.ServerObject;
+export type ServerObject = (OpenAPIV3.ServerObject | OpenAPIV3_1.ServerObject) & Pick<OpenAPIV3_2.ServerObject, 'name'>;
 export type PathObject = OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject;
 export type PathObjectOrRef = PathObject | RefObject;
 export type PathOrRef = (PathObject & {
     path: string;
+    isWebhook?: true;
     parameters?: UUID[];
     servers?: UUID[];
 } & {
@@ -159,6 +174,7 @@ export type PathOrRef = (PathObject & {
     $ref?: never;
 }) | (RefObject & {
     path: string;
+    isWebhook?: true;
     $ref: UUID;
 } & {
     parameters?: never;
@@ -195,6 +211,7 @@ export type SecurityRequirement = {
     [name: string]: {
         $ref?: UUID;
         scopes?: string[];
+        schemeName?: string;
     };
 };
 export type DocumentObject = OpenAPIV3.Document | OpenAPIV3_1.Document;
@@ -213,3 +230,4 @@ export type SchemaGraphData = {
         refUuidMap: RefUuidMap;
     };
 };
+export {};