oas 31.1.2 → 32.1.0

package/dist/{chunk-HGVFNEKW.js → chunk-5245ZLBC.js}

@@ -1,128 +1,29 @@
 import {
-  supportedMethods
-} from "./chunk-VA3NKXX7.js";
-import {
+  applyDiscriminatorOneOfToUsedSchemas,
   cloneObject,
+  decorateComponentSchemasWithRefName,
   dereferenceRef,
+  filterRequiredRefsToReferenced,
   getDereferencingOptions,
   getParametersAsJSONSchema,
   getSchemaVersionString,
   isObject,
   isPrimitive,
   matches_mimetype_default,
+  mergeReferencedSchemasIntoRoot,
+  supportedMethods,
   toJSONSchema
-} from "./chunk-5EP6HY2E.js";
+} from "./chunk-HYH37HS2.js";
 import {
   getExtension
 } from "./chunk-S27IGTVG.js";
 import {
   isRef
-} from "./chunk-7MARUOFZ.js";
+} from "./chunk-MNOEMVCF.js";
 
 // src/operation/index.ts
 import { $RefParser } from "@apidevtools/json-schema-ref-parser";
 
-// src/lib/build-discriminator-one-of.ts
-function hasDiscriminatorWithoutPolymorphism(schema) {
-  if (!schema || typeof schema !== "object") return false;
-  if (!("discriminator" in schema)) return false;
-  if ("oneOf" in schema || "anyOf" in schema) return false;
-  return true;
-}
-function allOfReferencesSchema(schema, targetSchemaName) {
-  if (!schema || typeof schema !== "object") return false;
-  if (!("allOf" in schema) || !Array.isArray(schema.allOf)) return false;
-  return schema.allOf.some((item) => {
-    if (isRef(item)) {
-      const refParts = item.$ref.split("/");
-      const refSchemaName = refParts[refParts.length - 1];
-      return refSchemaName === targetSchemaName;
-    }
-    return false;
-  });
-}
-function findDiscriminatorChildren(api) {
-  const childrenMap = /* @__PURE__ */ new Map();
-  const invertedChildrenMap = /* @__PURE__ */ new Map();
-  if (!api?.components?.schemas || typeof api.components.schemas !== "object") {
-    return { children: childrenMap, inverted: invertedChildrenMap };
-  }
-  const schemas = api.components.schemas;
-  const schemaNames = Object.keys(schemas);
-  const discriminatorSchemas = schemaNames.filter((name) => {
-    return hasDiscriminatorWithoutPolymorphism(schemas[name]);
-  });
-  for (const baseName of discriminatorSchemas) {
-    const baseSchema = schemas[baseName];
-    const discriminator = baseSchema.discriminator;
-    let childSchemaNames;
-    if (discriminator.mapping && typeof discriminator.mapping === "object") {
-      const mappingRefs = Object.values(discriminator.mapping);
-      if (mappingRefs.length > 0) {
-        childSchemaNames = mappingRefs.map((ref) => {
-          const parts = ref.split("/");
-          return parts[parts.length - 1];
-        });
-      }
-    }
-    if (!childSchemaNames || childSchemaNames.length === 0) {
-      childSchemaNames = schemaNames.filter((name) => {
-        if (name === baseName) return false;
-        return allOfReferencesSchema(schemas[name], baseName);
-      });
-    }
-    if (childSchemaNames.length > 0) {
-      childrenMap.set(baseName, childSchemaNames);
-    }
-  }
-  for (const [key, values] of childrenMap) {
-    for (const value of values) {
-      if (invertedChildrenMap.has(value)) {
-        invertedChildrenMap.get(value)?.push(key);
-      } else {
-        invertedChildrenMap.set(value, [key]);
-      }
-    }
-  }
-  return { children: childrenMap, inverted: invertedChildrenMap };
-}
-function buildDiscriminatorOneOf(api, childrenMap) {
-  if (!api?.components?.schemas || typeof api.components.schemas !== "object") {
-    return;
-  } else if (childrenMap.size === 0) {
-    return;
-  }
-  for (const [schemaName, childNames] of childrenMap) {
-    const schema = api.components.schemas[schemaName];
-    if (!schema) continue;
-    const oneOf = [];
-    for (const childName of childNames) {
-      if (api.components.schemas[childName]) {
-        oneOf.push(cloneObject(api.components.schemas[childName]));
-      }
-    }
-    if (oneOf.length > 0) {
-      schema.oneOf = oneOf;
-    }
-  }
-  for (const [parentSchemaName, childNames] of childrenMap) {
-    for (const childName of childNames) {
-      const childSchema = api.components.schemas[childName];
-      if (!childSchema || !("allOf" in childSchema) || !Array.isArray(childSchema.allOf)) {
-        continue;
-      }
-      for (let i = 0; i < childSchema.allOf.length; i++) {
-        const item = childSchema.allOf[i];
-        if (item && typeof item === "object" && "x-readme-ref-name" in item && item["x-readme-ref-name"] === parentSchemaName && "oneOf" in item) {
-          const clonedItem = cloneObject(item);
-          delete clonedItem.oneOf;
-          childSchema.allOf[i] = clonedItem;
-        }
-      }
-    }
-  }
-}
-
 // src/operation/lib/dedupe-common-parameters.ts
 function dedupeCommonParameters(parameters, commonParameters) {
   return commonParameters.filter((param) => {
@@ -224,27 +125,51 @@ var primitive = (schema) => {
   return `Unknown Type: ${objectifiedSchema.type}`;
 };
 function sampleFromSchema(schema, opts = {}) {
-  const objectifySchema = objectify(schema);
-  let { type } = objectifySchema;
-  const hasPolymorphism = usesPolymorphism(objectifySchema);
+  const seenRefs = opts.seenRefs || /* @__PURE__ */ new Set();
+  let objectifySchema = objectify(schema);
+  let refToRelease;
+  if (opts.definition && isRef(objectifySchema)) {
+    refToRelease = objectifySchema.$ref;
+    if (seenRefs.has(refToRelease)) {
+      return void 0;
+    }
+    objectifySchema = dereferenceRef(objectifySchema, opts.definition, seenRefs);
+    if (!objectifySchema || isRef(objectifySchema)) {
+      return void 0;
+    }
+  }
+  try {
+    return sampleFromResolvedSchema(objectifySchema, opts, seenRefs);
+  } finally {
+    if (refToRelease) {
+      seenRefs.delete(refToRelease);
+    }
+  }
+}
+function sampleFromResolvedSchema(schema, opts, seenRefs) {
+  let { type } = schema;
+  const hasPolymorphism = usesPolymorphism(schema);
   if (hasPolymorphism === "allOf") {
     try {
       return sampleFromSchema(
-        mergeJSONSchemaAllOf(objectifySchema, {
+        mergeJSONSchemaAllOf(schema, {
           resolvers: {
             // Ignore any unrecognized OAS-specific keywords that might be present on the schema
             // (like `xml`).
             defaultResolver: mergeJSONSchemaAllOf.options.resolvers.title
           }
         }),
-        opts
+        {
+          ...opts,
+          seenRefs
+        }
       );
     } catch {
       return void 0;
     }
   } else if (hasPolymorphism) {
-    const samples = objectifySchema[hasPolymorphism].map((s) => {
-      return sampleFromSchema(s, opts);
+    const samples = schema[hasPolymorphism].map((s) => {
+      return sampleFromSchema(s, { ...opts, seenRefs });
     });
     if (samples.length === 1) {
       return samples[0];
@@ -253,7 +178,7 @@ function sampleFromSchema(schema, opts = {}) {
     }
     return samples[0];
   }
-  const { example, additionalProperties, properties, items } = objectifySchema;
+  const { example, additionalProperties, properties, items } = schema;
   const { includeReadOnly, includeWriteOnly } = opts;
   if (example !== void 0) {
     return deeplyStripKey(example, "$$ref", (val) => {
@@ -286,13 +211,13 @@ function sampleFromSchema(schema, opts = {}) {
         obj[name] = props[name].examples[0];
         continue;
       }
-      obj[name] = sampleFromSchema(props[name], opts);
+      obj[name] = sampleFromSchema(props[name], { ...opts, seenRefs });
     }
     if (additionalProperties === true) {
       obj.additionalProp = {};
     } else if (additionalProperties) {
       const additionalProps = objectify(additionalProperties);
-      const additionalPropVal = sampleFromSchema(additionalProps, opts);
+      const additionalPropVal = sampleFromSchema(additionalProps, { ...opts, seenRefs });
       obj.additionalProp = additionalPropVal;
     }
     return obj;
@@ -302,12 +227,22 @@ function sampleFromSchema(schema, opts = {}) {
       return [];
     }
     if (Array.isArray(items.anyOf)) {
-      return items.anyOf.map((i) => sampleFromSchema(i, opts));
+      return items.anyOf.map(
+        (i) => sampleFromSchema(i, {
+          ...opts,
+          seenRefs
+        })
+      );
     }
     if (Array.isArray(items.oneOf)) {
-      return items.oneOf.map((i) => sampleFromSchema(i, opts));
+      return items.oneOf.map(
+        (i) => sampleFromSchema(i, {
+          ...opts,
+          seenRefs
+        })
+      );
     }
-    return [sampleFromSchema(items, opts)];
+    return [sampleFromSchema(items, { ...opts, seenRefs })];
   }
   if (schema.enum) {
     if (schema.default) {
@@ -324,7 +259,7 @@ var memo = memoize(sampleFromSchema);
 var samples_default = memo;
 
 // src/operation/lib/get-mediatype-examples.ts
-function getMediaTypeExamples(mediaType, mediaTypeObject, opts = {}) {
+function getMediaTypeExamples(mediaType, mediaTypeObject, definition, opts = {}) {
   if (mediaTypeObject.example) {
     return [
       {
@@ -365,7 +300,10 @@ function getMediaTypeExamples(mediaType, mediaTypeObject, opts = {}) {
     if (!matches_mimetype_default.xml(mediaType)) {
       return [
         {
-          value: samples_default(JSON.parse(JSON.stringify(mediaTypeObject.schema)), opts)
+          value: samples_default(structuredClone(mediaTypeObject.schema), {
+            ...opts,
+            definition
+          })
         }
       ];
     }
@@ -374,19 +312,21 @@ function getMediaTypeExamples(mediaType, mediaTypeObject, opts = {}) {
 }
 
 // src/operation/lib/get-response-examples.ts
-function getResponseExamples(operation) {
+function getResponseExamples(operation, definition) {
   return Object.keys(operation.responses || {}).map((status) => {
-    const response = operation.responses?.[status];
+    let response = operation.responses?.[status];
     let onlyHeaders = false;
-    if (!response || isRef(response)) {
-      return false;
+    if (!response) return false;
+    if (isRef(response)) {
+      response = dereferenceRef(response, definition);
+      if (!response || isRef(response)) return false;
     }
     const mediaTypes = {};
     (response?.content ? Object.keys(response.content) : []).forEach((mediaType) => {
       if (!mediaType) return;
       const mediaTypeObject = response.content?.[mediaType];
       if (!mediaTypeObject) return;
-      const examples = getMediaTypeExamples(mediaType, mediaTypeObject, {
+      const examples = getMediaTypeExamples(mediaType, mediaTypeObject, definition, {
         includeReadOnly: true,
         includeWriteOnly: false
       });
@@ -410,20 +350,31 @@ function getResponseExamples(operation) {
 }
 
 // src/operation/lib/get-callback-examples.ts
-function getCallbackExamples(operation) {
+function getCallbackExamples(operation, definition) {
   if (!operation.callbacks) {
     return [];
   }
   const examples = Object.keys(operation.callbacks).map((identifier) => {
-    const callback = operation.callbacks?.[identifier];
-    if (!callback || isRef(callback)) {
-      return [];
+    let callback = operation.callbacks?.[identifier];
+    if (!callback) return [];
+    if (isRef(callback)) {
+      callback = dereferenceRef(callback, definition);
+      if (!callback || isRef(callback)) return [];
     }
     const items = Object.keys(callback).map((expression) => {
-      return Object.keys(callback[expression]).map((method) => {
-        const pathItem = callback[expression];
-        const example = getResponseExamples(pathItem[method]);
-        if (example.length === 0) return false;
+      let callbackPath = callback[expression];
+      if (!callbackPath) return [];
+      if (isRef(callbackPath)) {
+        callbackPath = dereferenceRef(callbackPath, definition);
+        if (!callbackPath || isRef(callbackPath)) return [];
+      }
+      return Object.keys(callbackPath).map((method) => {
+        if (["servers", "parameters", "summary", "description"].includes(method)) {
+          return false;
+        }
+        const pathItem = callbackPath;
+        const example = getResponseExamples(pathItem[method], definition);
+        if (!example.length) return false;
         return {
           identifier,
           expression,
@@ -495,17 +446,19 @@ function getExampleGroups(operation) {
   }
   operation.getParameters().forEach((param) => {
     Object.entries(param.examples || {}).forEach(([exampleKey, paramExample]) => {
-      if (isRef(paramExample)) {
-        return;
+      let example = paramExample;
+      if (isRef(example)) {
+        example = dereferenceRef(example, operation.api);
+        if (!example || isRef(example)) return;
       }
       groups[exampleKey] = {
         ...groups[exampleKey],
-        name: groups[exampleKey]?.name || paramExample.summary || exampleKey,
+        name: groups[exampleKey]?.name || example.summary || exampleKey,
         request: {
           ...groups[exampleKey]?.request,
           [param.in]: {
             ...groups[exampleKey]?.request?.[param.in],
-            [param.name]: paramExample.value
+            [param.name]: example.value
           }
         }
       };
@@ -538,14 +491,19 @@ function getExampleGroups(operation) {
 }
 
 // src/operation/lib/get-requestbody-examples.ts
-function getRequestBodyExamples(operation) {
-  const requestBody = operation.requestBody;
+function getRequestBodyExamples(operation, definition) {
+  let requestBody = operation.requestBody;
+  if (!requestBody) {
+    return [];
+  } else if (isRef(requestBody)) {
+    requestBody = dereferenceRef(requestBody, definition);
+  }
   if (!requestBody || isRef(requestBody) || !requestBody.content) {
     return [];
   }
   return Object.keys(requestBody.content || {}).map((mediaType) => {
     const mediaTypeObject = requestBody.content[mediaType];
-    const examples = getMediaTypeExamples(mediaType, mediaTypeObject, {
+    const examples = getMediaTypeExamples(mediaType, mediaTypeObject, definition, {
       includeReadOnly: false,
       includeWriteOnly: true
     });
@@ -559,9 +517,52 @@ function getRequestBodyExamples(operation) {
   }).filter((item) => item !== false);
 }
 
-// src/operation/lib/get-response-as-json-schema.ts
+// src/operation/lib/operationId.ts
+function hasOperationId(operation) {
+  return Boolean("operationId" in operation && operation.operationId?.length);
+}
+function getOperationId(path, method, operation, opts = {}) {
+  function sanitize(id) {
+    return id.replace(opts?.camelCase || opts?.friendlyCase ? /[^a-zA-Z0-9_]/g : /[^a-zA-Z0-9]/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "");
+  }
+  const operationIdExists = hasOperationId(operation);
+  let operationId;
+  if (operationIdExists) {
+    operationId = operation.operationId;
+  } else {
+    operationId = sanitize(path).toLowerCase();
+  }
+  const currMethod = method.toLowerCase();
+  if (opts?.camelCase || opts?.friendlyCase) {
+    if (opts?.friendlyCase) {
+      operationId = operationId.replaceAll("_", " ");
+      if (!operationIdExists) {
+        operationId = operationId.replace(/[^a-zA-Z0-9_]+(.)/g, (_, chr) => ` ${chr}`).split(" ").filter((word, i, arr) => word !== arr[i - 1]).join(" ");
+      }
+    }
+    operationId = operationId.replace(/[^a-zA-Z0-9_]+(.)/g, (_, chr) => chr.toUpperCase());
+    if (operationIdExists) {
+      operationId = sanitize(operationId);
+    }
+    operationId = operationId.replace(/^[0-9]/g, (match) => `_${match}`);
+    operationId = operationId.charAt(0).toLowerCase() + operationId.slice(1);
+    if (operationId.startsWith(currMethod)) {
+      return operationId;
+    }
+    if (operationIdExists) {
+      return operationId;
+    }
+    operationId = operationId.charAt(0).toUpperCase() + operationId.slice(1);
+    return `${currMethod}${operationId}`;
+  } else if (operationIdExists) {
+    return operationId;
+  }
+  return `${currMethod}_${operationId}`;
+}
+
+// src/operation/transformers/get-response-as-json-schema.ts
 var isJSON = matches_mimetype_default.json;
-function buildHeadersSchema(response, opts) {
+function buildHeadersSchema(response, schemaOptions) {
   const headersSchema = {
     type: "object",
     properties: {}
@@ -578,7 +579,7 @@ function buildHeadersSchema(response, opts) {
         }
         headersSchema.properties[key] = toJSONSchema(header.schema, {
           addEnumsToDescriptions: true,
-          transformer: opts?.transformer
+          ...schemaOptions
         });
         if (header.description) {
           headersSchema.properties[key].description = header.description;
@@ -602,15 +603,24 @@ function getResponseAsJSONSchema(operation, api, statusCode, opts) {
   if (!response) {
     return null;
   }
-  let hasCircularRefs = false;
-  let hasDiscriminatorMappingRefs = false;
-  function refLogger(ref, type) {
-    if (type === "ref") {
-      hasCircularRefs = true;
-    } else {
-      hasDiscriminatorMappingRefs = true;
-    }
-  }
+  const usedSchemas = /* @__PURE__ */ new Map();
+  const seenRefs = /* @__PURE__ */ new Set();
+  const refsByGroup = /* @__PURE__ */ new Map();
+  function refLoggerForSchemaGroup(group) {
+    let set = refsByGroup.get(group);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      refsByGroup.set(group, set);
+    }
+    return set;
+  }
+  const baseSchemaOptions = {
+    addEnumsToDescriptions: true,
+    definition: api,
+    seenRefs,
+    usedSchemas,
+    refLogger: (ref) => refLoggerForSchemaGroup("body").add(ref)
+  };
   function getPreferredSchema(content, preferredContentType) {
     if (!content) {
       return null;
@@ -625,11 +635,7 @@ function getResponseAsJSONSchema(operation, api, statusCode, opts) {
         if (!schema2) {
           return null;
         }
-        return toJSONSchema(schema2, {
-          addEnumsToDescriptions: true,
-          refLogger,
-          transformer: opts?.transformer
-        });
+        return toJSONSchema(schema2, baseSchemaOptions);
       }
       return null;
     }
@@ -639,11 +645,7 @@ function getResponseAsJSONSchema(operation, api, statusCode, opts) {
         if (!schema2) {
           return {};
         }
-        return toJSONSchema(schema2, {
-          addEnumsToDescriptions: true,
-          refLogger,
-          transformer: opts?.transformer
-        });
+        return toJSONSchema(schema2, baseSchemaOptions);
       }
     }
     const contentType = contentTypes.shift();
@@ -654,23 +656,25 @@ function getResponseAsJSONSchema(operation, api, statusCode, opts) {
     if (!schema) {
       return {};
     }
-    return toJSONSchema(schema, {
-      addEnumsToDescriptions: true,
-      refLogger,
-      transformer: opts?.transformer
-    });
+    return toJSONSchema(schema, baseSchemaOptions);
   }
   const foundSchema = getPreferredSchema(response.content, opts?.contentType);
   if (opts?.contentType && !foundSchema) {
     return null;
   }
   if (foundSchema) {
-    const schema = cloneObject(foundSchema);
+    const schema = structuredClone(foundSchema);
+    let schemaType = foundSchema.type;
+    if (schemaType === void 0 && isRef(foundSchema) && usedSchemas.size > 0) {
+      const resolvedSchema = usedSchemas.get(foundSchema.$ref);
+      const resolvedType = resolvedSchema && typeof resolvedSchema === "object" && "type" in resolvedSchema ? resolvedSchema.type : void 0;
+      schemaType = Array.isArray(resolvedType) ? resolvedType[0] : resolvedType;
+    }
     const schemaWrapper = {
       // If there's no `type` then the root schema is a circular `$ref` that we likely won't be
       // able to render so instead of generating a JSON Schema with an `undefined` type we should
       // default to `string` so there's at least *something* the end-user can interact with.
-      type: foundSchema.type || "string",
+      type: schemaType ?? "string",
       schema: isPrimitive(schema) ? schema : {
         ...schema,
         $schema: getSchemaVersionString(schema, api)
@@ -680,66 +684,55 @@ function getResponseAsJSONSchema(operation, api, statusCode, opts) {
     if (response.description && schemaWrapper.schema) {
       schemaWrapper.description = response.description;
     }
-    if (api.components && schemaWrapper.schema) {
-      if (hasCircularRefs || hasDiscriminatorMappingRefs && opts?.includeDiscriminatorMappingRefs) {
-        schemaWrapper.schema.components = cloneObject(
-          api.components
-        );
+    applyDiscriminatorOneOfToUsedSchemas(api, usedSchemas, (ref) => {
+      if (usedSchemas.has(ref)) {
+        return usedSchemas.get(ref);
+      }
+      try {
+        const resolved = dereferenceRef({ $ref: ref }, api, seenRefs);
+        if (isRef(resolved)) return void 0;
+        const converted = toJSONSchema(structuredClone(resolved), {
+          ...baseSchemaOptions,
+          seenRefs
+        });
+        usedSchemas.set(ref, converted);
+        return converted;
+      } catch {
+        return void 0;
+      }
+    });
+    if (schemaWrapper.schema && usedSchemas.size > 0) {
+      const refsInGroup = refsByGroup.get("body") ?? /* @__PURE__ */ new Set();
+      const referencedSchemas = filterRequiredRefsToReferenced(refsInGroup, usedSchemas);
+      if (referencedSchemas.size > 0) {
+        mergeReferencedSchemasIntoRoot(schemaWrapper.schema, referencedSchemas);
       }
     }
     jsonSchema.push(schemaWrapper);
   }
   if (response.headers) {
-    jsonSchema.push(buildHeadersSchema(response, opts));
-  }
-  return jsonSchema.length ? jsonSchema : null;
-}
-
-// src/operation/lib/operationId.ts
-function hasOperationId(operation) {
-  return Boolean("operationId" in operation && operation.operationId?.length);
-}
-function getOperationId(path, method, operation, opts = {}) {
-  function sanitize(id) {
-    return id.replace(opts?.camelCase || opts?.friendlyCase ? /[^a-zA-Z0-9_]/g : /[^a-zA-Z0-9]/g, "-").replace(/--+/g, "-").replace(/^-|-$/g, "");
-  }
-  const operationIdExists = hasOperationId(operation);
-  let operationId;
-  if (operationIdExists) {
-    operationId = operation.operationId;
-  } else {
-    operationId = sanitize(path).toLowerCase();
-  }
-  const currMethod = method.toLowerCase();
-  if (opts?.camelCase || opts?.friendlyCase) {
-    if (opts?.friendlyCase) {
-      operationId = operationId.replaceAll("_", " ");
-      if (!operationIdExists) {
-        operationId = operationId.replace(/[^a-zA-Z0-9_]+(.)/g, (_, chr) => ` ${chr}`).split(" ").filter((word, i, arr) => word !== arr[i - 1]).join(" ");
+    const headersWrapper = buildHeadersSchema(response, {
+      ...baseSchemaOptions,
+      refLogger: (ref) => refLoggerForSchemaGroup("headers").add(ref)
+    });
+    if (headersWrapper.schema && usedSchemas.size > 0) {
+      const refsInGroup = refsByGroup.get("headers") ?? /* @__PURE__ */ new Set();
+      const referencedSchemas = filterRequiredRefsToReferenced(refsInGroup, usedSchemas);
+      if (referencedSchemas.size > 0) {
+        mergeReferencedSchemasIntoRoot(headersWrapper.schema, referencedSchemas);
       }
     }
-    operationId = operationId.replace(/[^a-zA-Z0-9_]+(.)/g, (_, chr) => chr.toUpperCase());
-    if (operationIdExists) {
-      operationId = sanitize(operationId);
-    }
-    operationId = operationId.replace(/^[0-9]/g, (match) => `_${match}`);
-    operationId = operationId.charAt(0).toLowerCase() + operationId.slice(1);
-    if (operationId.startsWith(currMethod)) {
-      return operationId;
-    }
-    if (operationIdExists) {
-      return operationId;
-    }
-    operationId = operationId.charAt(0).toUpperCase() + operationId.slice(1);
-    return `${currMethod}${operationId}`;
-  } else if (operationIdExists) {
-    return operationId;
+    jsonSchema.push(headersWrapper);
   }
-  return `${currMethod}_${operationId}`;
+  return jsonSchema.length ? jsonSchema : null;
 }
 
 // src/operation/index.ts
 var Operation = class {
+  /**
+   * The `Oas` instance that this operation belongs to.
+   */
+  oas;
   /**
    * Schema of the operation from the API Definition.
    */
@@ -791,9 +784,17 @@ var Operation = class {
    * it doesn't initiate multiple dereferencing processes.
    */
   dereferencing;
-  constructor(api, path, method, operation) {
+  /**
+   * Have the component schemas within this API definition been decorated with our
+   * `x-readme-ref-name` extension?
+   *
+   * @see {@link decorateComponentSchemas}
+   */
+  schemasDecorated = false;
+  constructor(oas, path, method, operation) {
+    this.oas = oas;
     this.schema = operation;
-    this.api = api;
+    this.api = oas.api;
     this.path = path;
     this.method = method;
     this.contentType = void 0;
@@ -954,14 +955,16 @@ var Operation = class {
       const keysWithTypes = keys.map((key) => {
         let security;
         try {
-          if (!this.api.components?.securitySchemes?.[key] || isRef(this.api.components.securitySchemes[key])) {
-            return false;
+          security = this.api?.components?.securitySchemes?.[key];
+          if (!security) return false;
+          if (isRef(security)) {
+            security = dereferenceRef(security, this.api);
+            if (!security || isRef(security)) return false;
           }
-          security = this.api.components.securitySchemes[key];
         } catch {
           return false;
         }
-        if (!security) return false;
+        if (!security || isRef(security)) return false;
         let type = null;
         if (security.type === "http") {
           if (security.scheme === "basic") type = "Basic";
@@ -1034,37 +1037,56 @@ var Operation = class {
     if (this.schema.parameters) {
       this.headers.request = this.headers.request.concat(
         this.schema.parameters.map((p) => {
-          if (isRef(p)) {
-            return void 0;
+          let param = p;
+          if (isRef(param)) {
+            param = dereferenceRef(param, this.api);
+            if (!param || isRef(param)) return void 0;
           }
-          if (p.in && p.in === "header") return p.name;
+          if (param.in && param.in === "header") return param.name;
           return void 0;
         }).filter((item) => item !== void 0)
       );
     }
     if (this.schema.responses) {
       this.headers.response = Object.keys(this.schema.responses).map((r) => {
-        const response = this.schema.responses?.[r];
-        if (!response || isRef(response)) {
-          return [];
+        let response = this.schema.responses[r];
+        if (!response) return [];
+        if (isRef(response)) {
+          this.schema.responses[r] = dereferenceRef(response, this.api);
+          response = this.schema.responses[r];
+          if (!response || isRef(response)) {
+            return [];
+          }
         }
         return response?.headers ? Object.keys(response.headers) : [];
       }).reduce((a, b) => a.concat(b), []);
     }
     if (!this.headers.request.includes("Content-Type") && this.schema.requestBody) {
-      const requestBody = this.schema.requestBody;
-      if (requestBody && !isRef(requestBody) && "content" in requestBody && Object.keys(requestBody.content)) {
-        this.headers.request.push("Content-Type");
+      let requestBody = this.schema.requestBody;
+      if (requestBody) {
+        if (isRef(requestBody)) {
+          this.schema.requestBody = dereferenceRef(requestBody, this.api);
+          requestBody = this.schema.requestBody;
+        }
+        if (requestBody && !isRef(requestBody) && "content" in requestBody && Object.keys(requestBody.content)) {
+          this.headers.request.push("Content-Type");
+        }
       }
     }
     if (this.schema.responses) {
-      if (Object.keys(this.schema.responses).some((r) => {
-        const response = this.schema.responses?.[r];
-        if (!response || isRef(response)) {
-          return false;
+      const hasResponseContent = Object.keys(this.schema.responses).some((r) => {
+        let response = this.schema.responses?.[r];
+        if (!response) return false;
+        if (isRef(response)) {
+          this.schema.responses[r] = dereferenceRef(response, this.api);
+          response = this.schema.responses[r];
+          if (!response || isRef(response)) {
+            return false;
+          }
         }
-        return response?.content && Object.keys(response.content).length > 0;
-      })) {
+        return response.content && Object.keys(response.content).length > 0;
+      });
+      if (hasResponseContent) {
         if (!this.headers.request.includes("Accept")) this.headers.request.push("Accept");
         if (!this.headers.response.includes("Content-Type")) this.headers.response.push("Content-Type");
       }
@@ -1159,17 +1181,26 @@ var Operation = class {
   /**
    * Return the parameters (non-request body) on the operation.
    *
-   * @todo Add support for `ReferenceObject`
    * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#user-content-operationparameters}
    * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#user-content-operation-parameters}
    */
   getParameters() {
-    let parameters = (this.schema?.parameters || []).filter(
-      (param) => param && !isRef(param)
-    );
-    const commonParams = (this.api?.paths?.[this.path]?.parameters || []).filter(
-      (param) => param && !isRef(param)
-    );
+    let parameters = (this.schema?.parameters || []).map((p) => {
+      let param = p;
+      if (isRef(param)) {
+        param = dereferenceRef(param, this.api);
+        if (!param || isRef(param)) return void 0;
+      }
+      return param;
+    }).filter((param) => param !== void 0);
+    const commonParams = (this.api?.paths?.[this.path]?.parameters || []).map((p) => {
+      let param = p;
+      if (isRef(param)) {
+        param = dereferenceRef(param, this.api);
+        if (!param || isRef(param)) return void 0;
+      }
+      return param;
+    }).filter((param) => param !== void 0);
     if (commonParams.length) {
       parameters = parameters.concat(dedupeCommonParameters(parameters, commonParams) || []);
     }
@@ -1188,26 +1219,54 @@ var Operation = class {
    * Convert the operation into an array of JSON Schema schemas for each available type of
    * parameter available on the operation.
    *
+   * Note that this method is not compatible with an operation or OpenAPI definition that has been
+   * processed with `.dereference()`. This method can only be called with the _original_ API
+   * definition that was used to initialize the `Operation` and `Oas` instance. If a dereferenced
+   * schema is present when this is called a `TypeError` will be thrown.
+   *
+   * @throws {TypeError} If the operation or OpenAPI definition has been run through `.dereference().`
+   *
    */
   getParametersAsJSONSchema(opts = {}) {
+    if (this.isDereferenced()) {
+      throw new Error(
+        "`.getParametersAsJSONSchema()` is not compatible with an operation or OpenAPI definition that has been run through `.dereference().`"
+      );
+    }
+    if (!this.schemasDecorated) {
+      decorateComponentSchemasWithRefName(this.api);
+      this.schemasDecorated = true;
+    }
     return getParametersAsJSONSchema(this, this.api, {
       includeDiscriminatorMappingRefs: true,
-      transformer: (s) => s,
       ...opts
     });
   }
   /**
    * Get a single response for this status code, formatted as JSON schema.
    *
+   * Note that this method is not compatible with an operation or OpenAPI definition that has been
+   * processed with `.dereference()`. This method can only be called with the _original_ API
+   * definition that was used to initialize the `Operation` and `Oas` instance. If a dereferenced
+   * schema is present when this is called a `TypeError` will be thrown.
+   *
    * @param statusCode Status code to pull a JSON Schema response for.
    * @param opts Options for schema generation.
    * @param opts.contentType Optional content-type to use. If specified and the response doesn't have
    *   this content-type, the function will return null.
    */
   getResponseAsJSONSchema(statusCode, opts = {}) {
+    if (this.isDereferenced()) {
+      throw new Error(
+        "`.getResponseAsJSONSchema()` is not compatible with an operation or OpenAPI definition that has been run through `.dereference().`"
+      );
+    }
+    if (!this.schemasDecorated) {
+      decorateComponentSchemasWithRefName(this.api);
+      this.schemasDecorated = true;
+    }
     return getResponseAsJSONSchema(this, this.api, statusCode, {
       includeDiscriminatorMappingRefs: true,
-      transformer: (s) => s,
       ...opts
     });
   }
@@ -1218,6 +1277,30 @@ var Operation = class {
   getResponseStatusCodes() {
     return this.schema.responses ? Object.keys(this.schema.responses) : [];
   }
+  /**
+   * Retrieve an array of all content types that this operation can return.
+   *
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#response-object}
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#response-object}
+   */
+  getResponseContentTypes() {
+    if (!this.schema.responses) return [];
+    const contentTypes = /* @__PURE__ */ new Set();
+    Object.values(this.schema.responses).forEach((response) => {
+      let resp = response;
+      if (!resp) return;
+      if (isRef(resp)) {
+        resp = dereferenceRef(resp, this.api);
+        if (!resp || isRef(resp)) {
+          return;
+        }
+      }
+      Object.keys(resp.content || {}).forEach((mimeType) => {
+        contentTypes.add(mimeType);
+      });
+    });
+    return Array.from(contentTypes);
+  }
   /**
    * Determine if the operation has any request bodies.
    *
@@ -1227,6 +1310,23 @@ var Operation = class {
   hasRequestBody() {
     return !!this.schema.requestBody;
   }
+  /**
+   * Return the current `requestBody` object, dereferencing it in the process if it's a `$ref`
+   * pointer.
+   *
+   */
+  getResolvedRequestBody() {
+    let requestBody = this.schema.requestBody;
+    if (!requestBody) return false;
+    if (isRef(requestBody)) {
+      this.schema.requestBody = dereferenceRef(requestBody, this.api);
+      requestBody = this.schema.requestBody;
+      if (!requestBody || isRef(requestBody)) {
+        return false;
+      }
+    }
+    return requestBody;
+  }
   /**
    * Retrieve the list of all available media types that the operations request body can accept.
    *
@@ -1237,10 +1337,8 @@ var Operation = class {
     if (!this.hasRequestBody()) {
       return [];
     }
-    const requestBody = this.schema.requestBody;
-    if (!requestBody || isRef(requestBody)) {
-      return [];
-    }
+    const requestBody = this.getResolvedRequestBody();
+    if (!requestBody) return [];
     return Object.keys(requestBody.content);
   }
   /**
@@ -1253,10 +1351,8 @@ var Operation = class {
     if (!this.hasRequestBody()) {
       return false;
     }
-    const requestBody = this.schema.requestBody;
-    if (!requestBody || isRef(requestBody)) {
-      return false;
-    }
+    const requestBody = this.getResolvedRequestBody();
+    if (!requestBody) return false;
     if (requestBody.required) {
       return true;
     }
@@ -1282,10 +1378,8 @@ var Operation = class {
     if (!this.hasRequestBody()) {
       return false;
     }
-    const requestBody = this.schema.requestBody;
-    if (!requestBody || isRef(requestBody)) {
-      return false;
-    }
+    const requestBody = this.getResolvedRequestBody();
+    if (!requestBody) return false;
     if (mediaType) {
       if (!(mediaType in requestBody.content)) {
         return false;
@@ -1326,7 +1420,7 @@ var Operation = class {
     if (this.requestBodyExamples && isRequestExampleValueDefined) {
       return this.requestBodyExamples;
     }
-    this.requestBodyExamples = getRequestBodyExamples(this.schema);
+    this.requestBodyExamples = getRequestBodyExamples(this.schema, this.api);
     return this.requestBodyExamples;
   }
   /**
@@ -1340,9 +1434,14 @@ var Operation = class {
     if (!this.schema.responses) {
       return false;
     }
-    const response = this.schema.responses[statusCode];
-    if (!response || isRef(response)) {
-      return false;
+    let response = this.schema.responses[statusCode];
+    if (!response) return false;
+    if (isRef(response)) {
+      this.schema.responses[statusCode] = dereferenceRef(response, this.api);
+      response = this.schema.responses[statusCode];
+      if (!response || isRef(response)) {
+        return false;
+      }
     }
     return response;
   }
@@ -1356,7 +1455,7 @@ var Operation = class {
     if (this.responseExamples) {
       return this.responseExamples;
     }
-    this.responseExamples = getResponseExamples(this.schema);
+    this.responseExamples = getResponseExamples(this.schema, this.api);
     return this.responseExamples;
   }
   /**
@@ -1379,15 +1478,28 @@ var Operation = class {
    */
   getCallback(identifier, expression, method) {
     if (!this.schema.callbacks) return false;
-    const callbackObj = this.schema.callbacks[identifier];
-    if (!callbackObj || isRef(callbackObj)) {
-      return false;
+    let callbackObj = this.schema.callbacks[identifier];
+    if (!callbackObj) return false;
+    if (isRef(callbackObj)) {
+      this.schema.callbacks[identifier] = dereferenceRef(callbackObj, this.api);
+      callbackObj = this.schema.callbacks[identifier];
+      if (!callbackObj || isRef(callbackObj)) {
+        return false;
+      }
+    }
+    let callback = callbackObj[expression];
+    if (!callback) return false;
+    if (isRef(callback)) {
+      callbackObj[expression] = dereferenceRef(callback, this.api);
+      callback = callbackObj[expression];
+      if (!callback || isRef(callback)) {
+        return false;
+      }
     }
-    const callback = callbackObj[expression];
-    if (!callback || isRef(callback) || !callback[method]) {
+    if (!callback[method]) {
       return false;
     }
-    return new Callback(this.api, expression, method, callback[method], identifier, callback);
+    return new Callback(this.oas, expression, method, callback[method], identifier, callback);
   }
   /**
    * Retrieve an array of operations created from each callback.
@@ -1398,17 +1510,27 @@ var Operation = class {
   getCallbacks() {
     if (!this.hasCallbacks()) return [];
     const callbacks = [];
-    Object.keys(this.schema.callbacks || {}).forEach((callback) => {
-      const cb = this.schema.callbacks?.[callback];
-      if (!cb || isRef(cb)) {
-        return;
+    Object.keys(this.schema.callbacks).forEach((callback) => {
+      let cb = this.schema.callbacks?.[callback];
+      if (!cb) return;
+      if (isRef(cb)) {
+        this.schema.callbacks[callback] = dereferenceRef(cb, this.api);
+        cb = this.schema.callbacks[callback];
+        if (!cb || isRef(cb)) {
+          return;
+        }
       }
       Object.keys(cb).forEach((expression) => {
-        const exp = cb[expression];
-        if (!exp || isRef(exp)) {
-          return;
+        let callbackPath = cb[expression];
+        if (!callbackPath) return;
+        if (isRef(callbackPath)) {
+          cb[expression] = dereferenceRef(callbackPath, this.api);
+          callbackPath = cb[expression];
+          if (!callbackPath || isRef(callbackPath)) {
+            return;
+          }
         }
-        Object.keys(exp).forEach((method) => {
+        Object.keys(callbackPath).forEach((method) => {
           if (!supportedMethods.includes(method)) return;
           const found = this.getCallback(callback, expression, method);
           if (found) {
@@ -1429,7 +1551,7 @@ var Operation = class {
     if (this.callbackExamples) {
       return this.callbackExamples;
     }
-    this.callbackExamples = getCallbackExamples(this.schema);
+    this.callbackExamples = getCallbackExamples(this.schema, this.api);
     return this.callbackExamples;
   }
   /**
@@ -1486,16 +1608,11 @@ var Operation = class {
       });
     }
     this.dereferencing.processing = true;
-    const { children: discriminatorChildrenMap, inverted: discriminatorChildrenMapInverted } = findDiscriminatorChildren(this.api);
-    const { api, schema, promises } = this;
-    if (api?.components?.schemas && typeof api.components.schemas === "object") {
-      Object.keys(api.components.schemas).forEach((schemaName) => {
-        if (isPrimitive(api.components?.schemas?.[schemaName]) || Array.isArray(api.components?.schemas?.[schemaName]) || api.components?.schemas?.[schemaName] === null) {
-          return;
-        }
-        (api.components?.schemas?.[schemaName])["x-readme-ref-name"] = schemaName;
-      });
+    if (!this.schemasDecorated) {
+      decorateComponentSchemasWithRefName(this.api);
+      this.schemasDecorated = true;
     }
+    const { api, schema, promises } = this;
     const circularRefs = /* @__PURE__ */ new Set();
     const dereferencingOptions = getDereferencingOptions(circularRefs);
     const parser = new $RefParser();
@@ -1530,30 +1647,12 @@ var Operation = class {
             if (path === "#/paths" || path.startsWith("#/paths/")) {
               return true;
             }
-            if (discriminatorChildrenMap.size > 0 || discriminatorChildrenMapInverted.size > 0) {
-              if (path.startsWith("#/components/") && path !== "#/components/schemas" && !path.startsWith("#/components/schemas/")) {
-                return true;
-              }
-              if (path.startsWith("#/components/schemas/")) {
-                const schemaName = path.split("/").pop();
-                if (schemaName && (discriminatorChildrenMap.has(schemaName) || discriminatorChildrenMapInverted.has(schemaName))) {
-                  if (path === `#/components/schemas/${schemaName}` || path.startsWith(`#/components/schemas/${schemaName}/`)) {
-                    return false;
-                  }
-                  return true;
-                }
-              }
-              return false;
-            }
             return path === "#/components" || path.startsWith("#/components/");
           }
         }
       }
     ).then((res) => {
       const dereferenced = res;
-      if (dereferenced?.components?.schemas && discriminatorChildrenMap.size > 0) {
-        buildDiscriminatorOneOf({ components: dereferenced.components }, discriminatorChildrenMap);
-      }
       this.schema = dereferenced.__INTERNAL__;
       this.promises = promises;
       this.dereferencing = {
@@ -1573,6 +1672,15 @@ var Operation = class {
       throw err;
     });
   }
+  /**
+   * Determine if the current operation schema, or the OpenAPI definition it's part of, has been
+   * dereferenced or not with `.dereference()`.
+   *
+   * @see Operation.dereference
+   */
+  isDereferenced() {
+    return this.oas.isDereferenced() || this.dereferencing.processing || this.dereferencing.complete;
+  }
   /**
    * Retrieve any circular `$ref` pointers that maybe present within operation schema.
    *
@@ -1610,6 +1718,12 @@ var Callback = class extends Operation {
   getIdentifier() {
     return this.identifier;
   }
+  /**
+   * Retrieve the `summary` for this callback.
+   *
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#user-content-operationsummary}
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#user-content-operation-summary}
+   */
   getSummary() {
     if (this.schema?.summary && typeof this.schema.summary === "string") {
       return this.schema.summary;
@@ -1618,6 +1732,12 @@ var Callback = class extends Operation {
     }
     return void 0;
   }
+  /**
+   * Retrieve the `description` for this operation.
+   *
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#user-content-operationdescription}
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#user-content-operation-description}
+   */
   getDescription() {
     if (this.schema?.description && typeof this.schema.description === "string") {
       return this.schema.description;
@@ -1626,9 +1746,29 @@ var Callback = class extends Operation {
     }
     return void 0;
   }
+  /**
+   * Return the parameters (non-request body) on the operation.
+   *
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#user-content-operationparameters}
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#user-content-operation-parameters}
+   */
   getParameters() {
-    let parameters = this.schema?.parameters || [];
-    const commonParams = this.parentSchema.parameters || [];
+    let parameters = (this.schema?.parameters || []).map((p) => {
+      let param = p;
+      if (isRef(param)) {
+        param = dereferenceRef(param, this.api);
+        if (!param || isRef(param)) return void 0;
+      }
+      return param;
+    }).filter((param) => param !== void 0);
+    const commonParams = (this.parentSchema.parameters || []).map((p) => {
+      let param = p;
+      if (isRef(param)) {
+        param = dereferenceRef(param, this.api);
+        if (!param || isRef(param)) return void 0;
+      }
+      return param;
+    }).filter((param) => param !== void 0);
     if (commonParams.length) {
       parameters = parameters.concat(dedupeCommonParameters(parameters, commonParams) || []);
     }
@@ -1636,35 +1776,47 @@ var Callback = class extends Operation {
   }
 };
 var Webhook = class extends Operation {
+  /**
+   * Retrieve the `summary` for this callback.
+   *
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#user-content-operationsummary}
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#user-content-operation-summary}
+   */
   getSummary() {
     if (this.schema?.summary && typeof this.schema.summary === "string") {
       return this.schema.summary;
+    } else if (!this.api.webhooks) {
+      return void 0;
     }
-    const webhookPath = this.api.webhooks?.[this.path];
-    if (webhookPath && !isRef(webhookPath)) {
-      if (webhookPath?.summary && typeof webhookPath.summary === "string") {
-        return webhookPath.summary;
-      }
+    let webhookPath = this.api.webhooks[this.path];
+    if (isRef(webhookPath)) {
+      this.api.webhooks[this.path] = dereferenceRef(webhookPath, this.api);
+      webhookPath = this.api.webhooks[this.path];
     }
-    return void 0;
+    return webhookPath?.summary;
   }
+  /**
+   * Retrieve the `description` for this operation.
+   *
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#user-content-operationdescription}
+   * @see {@link https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.2.md#user-content-operation-description}
+   */
   getDescription() {
     if (this.schema?.description && typeof this.schema.description === "string") {
       return this.schema.description;
+    } else if (!this.api.webhooks) {
+      return void 0;
     }
-    const webhookPath = this.api.webhooks?.[this.path];
-    if (webhookPath && !isRef(webhookPath)) {
-      if (webhookPath?.description && typeof webhookPath.description === "string") {
-        return webhookPath.description;
-      }
+    let webhookPath = this.api.webhooks[this.path];
+    if (isRef(webhookPath)) {
+      this.api.webhooks[this.path] = dereferenceRef(webhookPath, this.api);
+      webhookPath = this.api.webhooks[this.path];
     }
-    return void 0;
+    return webhookPath?.description;
   }
 };
 
 export {
-  findDiscriminatorChildren,
-  buildDiscriminatorOneOf,
   Operation,
   Callback,
   Webhook
@@ -1681,4 +1833,4 @@ export {
  * @license Apache-2.0
  * @see {@link https://github.com/swagger-api/swagger-ui/blob/master/src/core/plugins/samples/fn.js}
  */
-//# sourceMappingURL=chunk-HGVFNEKW.js.map
+//# sourceMappingURL=chunk-5245ZLBC.js.map