oas 31.1.2 → 32.1.0

package/dist/{chunk-5EP6HY2E.js → chunk-HYH37HS2.js}

@@ -6,15 +6,7 @@ import {
   isOpenAPI30,
   isRef,
   isSchema
-} from "./chunk-7MARUOFZ.js";
-
-// src/lib/clone-object.ts
-function cloneObject(obj) {
-  if (typeof obj === "undefined") {
-    return void 0;
-  }
-  return JSON.parse(JSON.stringify(obj));
-}
+} from "./chunk-MNOEMVCF.js";
 
 // src/lib/matches-mimetype.ts
 function matchesMediaType(types2, mediaType) {
@@ -71,6 +63,9 @@ function getParameterContentType(contentKeys) {
   return contentKeys[0];
 }
 
+// src/lib/refs.ts
+import jsonpointer from "jsonpointer";
+
 // src/lib/helpers.ts
 function hasSchemaType(schema, discriminator) {
   if (Array.isArray(schema.type)) {
@@ -85,13 +80,18 @@ function isPrimitive(val) {
   return typeof val === "string" || typeof val === "number" || typeof val === "boolean";
 }
 
-// src/lib/openapi-to-json-schema.ts
-import mergeJSONSchemaAllOf from "json-schema-merge-allof";
-import jsonpointer2 from "jsonpointer";
-import removeUndefinedObjects from "remove-undefined-objects";
-
 // src/lib/refs.ts
-import jsonpointer from "jsonpointer";
+function decorateComponentSchemasWithRefName(api) {
+  if (!api?.components?.schemas || typeof api.components.schemas !== "object") {
+    return;
+  }
+  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;
+  });
+}
 function encodePointer(str) {
   return str.replaceAll("~", "~0").replaceAll("/", "~1");
 }
@@ -114,7 +114,7 @@ function findRef($ref, definition) {
   }
   return current;
 }
-function dereferenceRef(value, definition, seenRefs) {
+function dereferenceRef(value, definition, seenRefs = /* @__PURE__ */ new Set()) {
   if (value === void 0) {
     return void 0;
   }
@@ -123,23 +123,17 @@ function dereferenceRef(value, definition, seenRefs) {
       return value;
     }
     const ref = value.$ref;
-    if (seenRefs?.has(ref)) {
+    if (seenRefs.has(ref)) {
       return value;
     }
-    const localSeenRefs = seenRefs || /* @__PURE__ */ new Set();
-    localSeenRefs.add(ref);
+    seenRefs.add(ref);
     try {
       const dereferenced = findRef(ref, definition);
       if (isRef(dereferenced)) {
-        return dereferenceRef(dereferenced, definition, localSeenRefs);
+        return dereferenceRef(dereferenced, definition, seenRefs);
       }
-      const refName = ref.split("/").pop();
       return {
-        ...dereferenced,
-        // Because dereferencing will eliminate any lineage back to the original `$ref`,
-        // information that we might need at some point, we should preserve the original schema
-        // name through a custom extension.
-        "x-readme-ref-name": refName
+        ...dereferenced
       };
     } catch {
       return value;
@@ -164,14 +158,196 @@ function getDereferencingOptions(circularRefs) {
     }
   };
 }
+function collectRefsInSchema(schema) {
+  const refs = /* @__PURE__ */ new Set();
+  if (!schema || typeof schema !== "object") return refs;
+  const obj = schema;
+  if (isRef(obj)) {
+    refs.add(obj.$ref);
+  }
+  for (const value of Object.values(obj)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        for (const r of collectRefsInSchema(item)) refs.add(r);
+      }
+    } else if (value && typeof value === "object") {
+      for (const r of collectRefsInSchema(value)) refs.add(r);
+    }
+  }
+  return refs;
+}
+function filterRequiredRefsToReferenced(requiredRefs, usedSchemas) {
+  const referenced = new Set(requiredRefs);
+  let prevSize = 0;
+  while (referenced.size > prevSize) {
+    prevSize = referenced.size;
+    for (const ref of referenced) {
+      const schema = usedSchemas.get(ref);
+      if (schema) {
+        for (const r of collectRefsInSchema(schema)) {
+          referenced.add(r);
+        }
+      }
+    }
+  }
+  const filtered = /* @__PURE__ */ new Map();
+  for (const ref of referenced) {
+    const s = usedSchemas.get(ref);
+    if (s !== void 0) {
+      filtered.set(ref, s);
+    }
+  }
+  return filtered;
+}
+function getRefPathSegments(ref) {
+  if (!ref.startsWith("#/")) return null;
+  const path = ref.slice(2).split("/").map((seg) => seg);
+  if (path.length < 2) {
+    return null;
+  }
+  return path;
+}
+function mergeReferencedSchemasIntoRoot(root, refToSchema) {
+  for (const [ref, schema] of refToSchema) {
+    const segments = getRefPathSegments(ref);
+    if (!segments || segments.length === 0) {
+      continue;
+    }
+    let current = root;
+    for (let i = 0; i < segments.length - 1; i++) {
+      const seg = segments[i];
+      let next = current[seg];
+      if (!next || typeof next !== "object" || Array.isArray(next)) {
+        next = {};
+        current[seg] = next;
+      }
+      current = next;
+    }
+    current[segments[segments.length - 1]] = schema;
+  }
+}
+
+// src/lib/clone-object.ts
+function cloneObject(obj) {
+  if (typeof obj === "undefined") {
+    return void 0;
+  }
+  return JSON.parse(JSON.stringify(obj));
+}
+
+// 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(definition) {
+  const childrenMap = /* @__PURE__ */ new Map();
+  const childrenRefMap = /* @__PURE__ */ new Map();
+  if (!definition?.components?.schemas || typeof definition.components.schemas !== "object") {
+    return { children: childrenMap, refs: childrenRefMap };
+  }
+  const schemas = definition.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) => ref.split("/").pop()).filter((ref) => ref !== void 0);
+      }
+    }
+    if (!childSchemaNames.length) {
+      childSchemaNames = schemaNames.filter((name) => {
+        if (name === baseName) return false;
+        return allOfReferencesSchema(schemas[name], baseName);
+      });
+    }
+    if (childSchemaNames.length) {
+      for (const childName of childSchemaNames) {
+        childrenRefMap.set(childName, `#/components/schemas/${childName}`);
+      }
+      childrenMap.set(baseName, childSchemaNames);
+      childrenRefMap.set(baseName, `#/components/schemas/${baseName}`);
+    }
+  }
+  return { children: childrenMap, refs: childrenRefMap };
+}
+function applyDiscriminatorOneOfToUsedSchemas(definition, usedSchemas, getOrAddSchema) {
+  const { children: childrenMap, refs: childrenRefMap } = findDiscriminatorChildren(definition);
+  if (!childrenMap.size) return;
+  for (const [baseName, childNames] of childrenMap) {
+    const baseRef = childrenRefMap.get(baseName);
+    if (!baseRef) continue;
+    const baseSchema = usedSchemas.get(baseRef);
+    if (!baseSchema || typeof baseSchema !== "object") continue;
+    const oneOf = [];
+    for (const childName of childNames) {
+      const childRef = childrenRefMap.get(childName);
+      if (!childRef) continue;
+      const childSchema = getOrAddSchema(childRef);
+      if (childSchema) {
+        oneOf.push({
+          $ref: childRef
+        });
+      }
+    }
+    if (oneOf.length > 0) {
+      baseSchema.oneOf = oneOf;
+    }
+  }
+  for (const [parentSchemaName, childNames] of childrenMap) {
+    for (const childName of childNames) {
+      const childRef = childrenRefMap.get(childName);
+      if (!childRef) continue;
+      const childSchema = usedSchemas.get(childRef);
+      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/lib/openapi-to-json-schema.ts
+import mergeJSONSchemaAllOf from "json-schema-merge-allof";
+import jsonpointer2 from "jsonpointer";
+import removeUndefinedObjects from "remove-undefined-objects";
 var UNSUPPORTED_SCHEMA_PROPS = [
   "example",
   // OpenAPI supports `example` but we're mapping it to `examples` in this library.
   "externalDocs",
   "xml"
 ];
+var PENDING_SCHEMA = { __pending: true };
+function isPendingSchema(s) {
+  return isObject(s) && "__pending" in s && s.__pending === true;
+}
 function getSchemaVersionString(schema, api) {
   if (isOpenAPI30(api)) {
     return "http://json-schema.org/draft-04/schema#";
@@ -187,6 +363,101 @@ function getSchemaVersionString(schema, api) {
 function isPolymorphicSchema(schema) {
   return "allOf" in schema || "anyOf" in schema || "oneOf" in schema;
 }
+function inlinePropertyRefsForMerge(schema, usedSchemas) {
+  const out = structuredClone(schema);
+  if (!("properties" in out) || typeof out.properties !== "object" || out.properties === null) {
+    return out;
+  }
+  for (const key of Object.keys(out.properties)) {
+    const val = out.properties[key];
+    if (isRef(val)) {
+      const resolved = usedSchemas.get(val.$ref);
+      if (resolved !== void 0 && !isPendingSchema(resolved)) {
+        out.properties[key] = {
+          ...structuredClone(resolved)
+        };
+      }
+    }
+  }
+  return out;
+}
+function resolveAndCacheRefSchema({
+  schema,
+  definition,
+  usedSchemas,
+  seenRefs,
+  conversionOptions,
+  returnMode,
+  refLogger
+}) {
+  const ref = schema.$ref;
+  const existing = usedSchemas.get(ref);
+  if (existing !== void 0 && !isPendingSchema(existing)) {
+    return returnMode === "converted" ? existing : { $ref: ref };
+  }
+  if (existing !== void 0 && isPendingSchema(existing)) {
+    return { $ref: ref };
+  }
+  usedSchemas.set(ref, PENDING_SCHEMA);
+  if (returnMode === "ref") {
+    let resolved;
+    try {
+      const dereferenced = dereferenceRef(schema, definition, seenRefs);
+      if (isRef(dereferenced)) {
+        refLogger(dereferenced.$ref, "ref");
+        let converted2;
+        try {
+          const pointer = ref.startsWith("#") ? decodeURIComponent(ref.substring(1)) : ref;
+          const rawSchema = jsonpointer2.get(definition, pointer);
+          if (rawSchema && typeof rawSchema === "object") {
+            converted2 = toJSONSchema(structuredClone(rawSchema), { ...conversionOptions, seenRefs });
+          } else {
+            converted2 = { $ref: ref };
+          }
+        } catch {
+          converted2 = { $ref: ref };
+        }
+        usedSchemas.set(ref, converted2);
+        refLogger(ref, "ref");
+        return { $ref: ref };
+      }
+      resolved = dereferenced;
+    } catch {
+      refLogger(ref, "ref");
+      usedSchemas.set(ref, { $ref: ref });
+      return { $ref: ref };
+    }
+    const converted = toJSONSchema(structuredClone(resolved), { ...conversionOptions, seenRefs });
+    usedSchemas.set(ref, converted);
+    refLogger(ref, "ref");
+    return { $ref: ref };
+  }
+  try {
+    const dereferenced = dereferenceRef(schema, definition, seenRefs);
+    if (isRef(dereferenced)) {
+      let converted2;
+      try {
+        const pointer = ref.startsWith("#") ? decodeURIComponent(ref.substring(1)) : ref;
+        const rawSchema = jsonpointer2.get(definition, pointer);
+        if (rawSchema && typeof rawSchema === "object") {
+          converted2 = toJSONSchema(structuredClone(rawSchema), { ...conversionOptions, seenRefs });
+        } else {
+          converted2 = { $ref: ref };
+        }
+      } catch {
+        converted2 = { $ref: ref };
+      }
+      usedSchemas.set(ref, converted2);
+      return converted2;
+    }
+    const converted = toJSONSchema(structuredClone(dereferenced), { ...conversionOptions, seenRefs });
+    usedSchemas.set(ref, converted);
+    return converted;
+  } catch {
+    usedSchemas.set(ref, { $ref: ref });
+    return { $ref: ref };
+  }
+}
 function isRequestBodySchema(schema) {
   return "content" in schema;
 }
@@ -232,12 +503,13 @@ function searchForValueByPropAndPointer(property, pointer, schemas = []) {
   }
   return foundValue;
 }
-function toJSONSchema(data, opts = {}) {
+function toJSONSchema(data, opts) {
   let schema = data === true ? {} : { ...data };
   const schemaAdditionalProperties = isSchema(schema) ? schema.additionalProperties : null;
   const {
     addEnumsToDescriptions,
     currentLocation,
+    definition,
     globalDefaults,
     hideReadOnlyProperties,
     hideWriteOnlyProperties,
@@ -245,7 +517,8 @@ function toJSONSchema(data, opts = {}) {
     prevDefaultSchemas = [],
     prevExampleSchemas = [],
     refLogger,
-    transformer
+    seenRefs,
+    usedSchemas
   } = {
     addEnumsToDescriptions: false,
     currentLocation: "",
@@ -256,15 +529,64 @@ function toJSONSchema(data, opts = {}) {
     prevDefaultSchemas: [],
     prevExampleSchemas: [],
     refLogger: () => true,
-    transformer: (s) => s,
+    seenRefs: /* @__PURE__ */ new Set(),
+    usedSchemas: /* @__PURE__ */ new Map(),
     ...opts
   };
+  const polyOptions = {
+    addEnumsToDescriptions,
+    currentLocation,
+    definition,
+    globalDefaults,
+    hideReadOnlyProperties,
+    hideWriteOnlyProperties,
+    isPolymorphicAllOfChild: false,
+    prevDefaultSchemas,
+    prevExampleSchemas,
+    refLogger,
+    seenRefs,
+    usedSchemas
+  };
   if (isRef(schema)) {
+    if (definition && usedSchemas) {
+      return resolveAndCacheRefSchema({
+        schema,
+        definition,
+        usedSchemas,
+        seenRefs,
+        conversionOptions: polyOptions,
+        returnMode: "ref",
+        refLogger
+      });
+    }
     refLogger(schema.$ref, "ref");
-    return transformer(schema);
+    return schema;
   }
   if (isSchema(schema, isPolymorphicAllOfChild)) {
     if ("allOf" in schema && Array.isArray(schema.allOf)) {
+      let allOfSchemas = schema.allOf;
+      if (definition && usedSchemas) {
+        const allOfOptions = schema.allOf.length > 1 ? { ...polyOptions, refLogger: () => {
+        } } : polyOptions;
+        allOfSchemas = schema.allOf.map((item) => {
+          if (isRef(item)) {
+            return resolveAndCacheRefSchema({
+              schema: item,
+              definition,
+              usedSchemas,
+              seenRefs,
+              conversionOptions: allOfOptions,
+              returnMode: "converted",
+              refLogger
+            });
+          }
+          return toJSONSchema(item, allOfOptions);
+        });
+        schema = {
+          ...schema,
+          allOf: allOfSchemas.map((s) => inlinePropertyRefsForMerge(s, usedSchemas))
+        };
+      }
       try {
         schema = mergeJSONSchemaAllOf(schema, {
           ignoreAdditionalProperties: true,
@@ -301,9 +623,12 @@ function toJSONSchema(data, opts = {}) {
         schema = schemaWithoutAllOf;
         delete schema.allOf;
       }
+      collectRefsInSchema(schema).forEach((ref) => {
+        refLogger(ref, "ref");
+      });
       if (isRef(schema)) {
         refLogger(schema.$ref, "ref");
-        return transformer(schema);
+        return schema;
       }
     }
     ["anyOf", "oneOf"].forEach((polyType) => {
@@ -313,56 +638,72 @@ function toJSONSchema(data, opts = {}) {
           if (!schema[polyType]?.[idx]) {
             return;
           }
-          const polyOptions = {
-            addEnumsToDescriptions,
-            currentLocation: `${currentLocation}/${idx}`,
-            globalDefaults,
-            hideReadOnlyProperties,
-            hideWriteOnlyProperties,
-            isPolymorphicAllOfChild: false,
-            prevDefaultSchemas,
-            prevExampleSchemas,
-            refLogger,
-            transformer
+          const itemOptions = {
+            ...polyOptions,
+            currentLocation: `${currentLocation}/${idx}`
           };
           if ("properties" in schema) {
             schema[polyType][idx] = toJSONSchema(
-              { required: schema.required, allOf: [item, { properties: schema.properties }] },
-              polyOptions
+              {
+                required: schema.required,
+                allOf: [item, { properties: schema.properties }]
+              },
+              itemOptions
             );
           } else if ("items" in schema) {
             schema[polyType][idx] = toJSONSchema(
-              { allOf: [item, { items: schema.items }] },
-              polyOptions
+              {
+                allOf: [item, { items: schema.items }]
+              },
+              itemOptions
             );
           } else {
-            schema[polyType][idx] = toJSONSchema(item, polyOptions);
+            schema[polyType][idx] = toJSONSchema(item, itemOptions);
           }
-          if (isObject(schema[polyType][idx]) && "required" in schema[polyType][idx] && typeof schema[polyType][idx].required === "boolean") {
-            delete schema[polyType][idx].required;
+          if ("required" in schema[polyType][idx]) {
+            if (Array.isArray(schema[polyType][idx].required) && schema[polyType][idx].required.length === 0) {
+              delete schema[polyType][idx].required;
+            } else if (isObject(schema[polyType][idx]) && typeof schema[polyType][idx].required === "boolean") {
+              delete schema[polyType][idx].required;
+            }
           }
-          if (discriminatorPropertyName && isObject(schema[polyType][idx])) {
+          if (discriminatorPropertyName) {
             const childSchema = schema[polyType][idx];
-            if ("discriminator" in childSchema) {
-              delete childSchema.discriminator;
-            }
-            if ("oneOf" in childSchema) {
-              delete childSchema.oneOf;
+            if (isObject(childSchema)) {
+              if ("discriminator" in childSchema) {
+                delete childSchema.discriminator;
+              }
+              if ("oneOf" in childSchema) {
+                delete childSchema.oneOf;
+              }
+              if ("anyOf" in childSchema) {
+                delete childSchema.anyOf;
+              }
             }
-            if ("anyOf" in childSchema) {
-              delete childSchema.anyOf;
+            if (definition && usedSchemas && isRef(childSchema)) {
+              const resolved = usedSchemas.get(childSchema.$ref);
+              if (resolved && typeof resolved === "object" && !isPendingSchema(resolved)) {
+                if ("discriminator" in resolved) {
+                  delete resolved.discriminator;
+                }
+                if ("oneOf" in resolved) {
+                  delete resolved.oneOf;
+                }
+                if ("anyOf" in resolved) {
+                  delete resolved.anyOf;
+                }
+                usedSchemas.set(childSchema.$ref, resolved);
+              }
             }
           }
         });
       }
     });
-    if ("discriminator" in schema) {
-      if ("mapping" in schema.discriminator && typeof schema.discriminator.mapping === "object") {
-        const mapping = schema.discriminator.mapping;
-        Object.keys(mapping).forEach((k) => {
-          refLogger(mapping[k], "discriminator");
-        });
-      }
+    if (schema?.discriminator?.mapping && typeof schema.discriminator.mapping === "object") {
+      const mapping = schema.discriminator.mapping;
+      Object.keys(mapping).forEach((k) => {
+        refLogger(mapping[k], "discriminator");
+      });
     }
   }
   if (!("type" in schema) && !isPolymorphicSchema(schema) && !isRequestBodySchema(schema)) {
@@ -519,21 +860,21 @@ function toJSONSchema(data, opts = {}) {
     }
     if (hasSchemaType(schema, "array")) {
       if ("items" in schema && schema.items !== void 0) {
-        if (!Array.isArray(schema.items) && Object.keys(schema.items).length === 1 && isRef(schema.items)) {
+        if (!(definition && usedSchemas) && !Array.isArray(schema.items) && Object.keys(schema.items).length === 1 && isRef(schema.items)) {
           refLogger(schema.items.$ref, "ref");
         } else if (schema.items !== true) {
           schema.items = toJSONSchema(schema.items, {
-            addEnumsToDescriptions,
+            ...polyOptions,
             currentLocation: `${currentLocation}/0`,
-            globalDefaults,
-            hideReadOnlyProperties,
-            hideWriteOnlyProperties,
-            prevExampleSchemas,
-            refLogger,
-            transformer
+            prevDefaultSchemas: [],
+            prevExampleSchemas
           });
-          if (isObject(schema.items) && "required" in schema.items && !Array.isArray(schema.items.required)) {
-            delete schema.items.required;
+          if ("required" in schema.items) {
+            if (Array.isArray(schema.items.required) && schema.items.required.length === 0) {
+              delete schema.items.required;
+            } else if (isObject(schema.items) && !Array.isArray(schema.items.required)) {
+              delete schema.items.required;
+            }
           }
         }
       } else if ("properties" in schema || "additionalProperties" in schema) {
@@ -546,15 +887,10 @@ function toJSONSchema(data, opts = {}) {
         Object.keys(schema.properties).forEach((prop) => {
           if (Array.isArray(schema.properties?.[prop]) || typeof schema.properties?.[prop] === "object" && schema.properties?.[prop] !== null) {
             const newPropSchema = toJSONSchema(schema.properties[prop], {
-              addEnumsToDescriptions,
+              ...polyOptions,
               currentLocation: `${currentLocation}/${encodePointer(prop)}`,
-              globalDefaults,
-              hideReadOnlyProperties,
-              hideWriteOnlyProperties,
               prevDefaultSchemas,
-              prevExampleSchemas,
-              refLogger,
-              transformer
+              prevExampleSchemas
             });
             let propShouldBeUpdated = true;
             if ((hideReadOnlyProperties || hideWriteOnlyProperties) && !Object.keys(newPropSchema).length) {
@@ -578,7 +914,7 @@ function toJSONSchema(data, opts = {}) {
         });
         if (hideReadOnlyProperties || hideWriteOnlyProperties) {
           if (!Object.keys(schema.properties).length) {
-            return transformer({});
+            return {};
           }
         }
       }
@@ -588,15 +924,10 @@ function toJSONSchema(data, opts = {}) {
           schema.additionalProperties = true;
         } else {
           schema.additionalProperties = toJSONSchema(schemaAdditionalProperties, {
-            addEnumsToDescriptions,
+            ...polyOptions,
             currentLocation,
-            globalDefaults,
-            hideReadOnlyProperties,
-            hideWriteOnlyProperties,
             prevDefaultSchemas,
-            prevExampleSchemas,
-            refLogger,
-            transformer
+            prevExampleSchemas
           });
         }
       }
@@ -658,10 +989,10 @@ ${enums}`;
   } else if (hideWriteOnlyProperties && "writeOnly" in schema && schema.writeOnly === true) {
     return {};
   }
-  return transformer(schema);
+  return schema;
 }
 
-// src/operation/lib/get-parameters-as-json-schema.ts
+// src/operation/transformers/get-parameters-as-json-schema.ts
 var types = {
   path: "Path Params",
   query: "Query Params",
@@ -673,54 +1004,25 @@ var types = {
   // This a special type reserved for https://npm.im/api
 };
 function getParametersAsJSONSchema(operation, api, opts) {
-  let hasCircularRefs = false;
-  let hasDiscriminatorMappingRefs = false;
-  function refLogger(ref, type) {
-    if (type === "ref") {
-      hasCircularRefs = true;
-    } else {
-      hasDiscriminatorMappingRefs = true;
-    }
-  }
-  function getDeprecated(schema, type) {
-    if (opts?.retainDeprecatedProperties) {
-      return null;
+  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);
     }
-    if (!schema || !schema.properties) return null;
-    const deprecatedBody = cloneObject(schema);
-    const requiredParams = schema.required || [];
-    const allDeprecatedProps = {};
-    Object.keys(deprecatedBody.properties || {}).forEach((key) => {
-      const deprecatedProp = deprecatedBody.properties?.[key];
-      if (deprecatedProp.deprecated && !requiredParams.includes(key) && !deprecatedProp.readOnly) {
-        allDeprecatedProps[key] = deprecatedProp;
-      }
-    });
-    deprecatedBody.properties = allDeprecatedProps;
-    const deprecatedSchema = toJSONSchema(deprecatedBody, {
-      globalDefaults: opts?.globalDefaults,
-      hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-      hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
-      prevExampleSchemas: [],
-      refLogger,
-      transformer: opts?.transformer
-    });
-    if (Object.keys(deprecatedSchema).length === 0 || Object.keys(deprecatedSchema.properties || {}).length === 0) {
-      return null;
-    }
-    Object.keys(schema.properties).forEach((key) => {
-      if ((schema.properties?.[key]).deprecated && !requiredParams.includes(key)) {
-        delete schema.properties?.[key];
-      }
-    });
-    return {
-      type,
-      schema: isPrimitive(deprecatedSchema) ? deprecatedSchema : {
-        ...deprecatedSchema,
-        $schema: getSchemaVersionString(deprecatedSchema, api)
-      }
-    };
+    return set;
   }
+  const baseSchemaOptions = {
+    definition: api,
+    globalDefaults: opts?.globalDefaults,
+    hideReadOnlyProperties: opts?.hideReadOnlyProperties,
+    hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
+    seenRefs,
+    usedSchemas
+  };
   function transformRequestBody() {
     const requestBody = operation.getRequestBody();
     if (!requestBody || !Array.isArray(requestBody)) return null;
@@ -734,9 +1036,12 @@ function getParametersAsJSONSchema(operation, api, opts) {
       prevExampleSchemas.push({ example: mediaTypeObject.example });
     } else if ("examples" in mediaTypeObject) {
       prevExampleSchemas.push({
-        examples: Object.values(mediaTypeObject.examples || {}).map((example) => {
+        examples: Object.values(mediaTypeObject.examples || {}).map((ex) => {
+          let example = ex;
+          if (!example) return void 0;
           if (isRef(example)) {
-            return void 0;
+            example = dereferenceRef(example, operation.api);
+            if (!example || isRef(example)) return void 0;
           }
           return example.value;
         }).filter((item) => item !== void 0)
@@ -744,12 +1049,9 @@ function getParametersAsJSONSchema(operation, api, opts) {
     }
     const requestSchema = cloneObject(mediaTypeObject.schema);
     const cleanedSchema = toJSONSchema(requestSchema, {
-      globalDefaults: opts?.globalDefaults,
-      hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-      hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
+      ...baseSchemaOptions,
       prevExampleSchemas,
-      refLogger,
-      transformer: opts?.transformer
+      refLogger: (ref) => refLoggerForSchemaGroup(type).add(ref)
     });
     if (!Object.keys(cleanedSchema).length) {
       return null;
@@ -761,43 +1063,9 @@ function getParametersAsJSONSchema(operation, api, opts) {
         ...cleanedSchema,
         $schema: getSchemaVersionString(cleanedSchema, api)
       },
-      deprecatedProps: getDeprecated(cleanedSchema, type) ?? void 0,
       ...description ? { description } : {}
     };
   }
-  function transformComponents() {
-    if (!("components" in api) || !api.components) {
-      return false;
-    }
-    const components2 = {
-      ...Object.keys(api.components).map((componentType) => ({ [componentType]: {} })).reduce((prev, next) => Object.assign(prev, next), {})
-    };
-    Object.keys(api.components).forEach((componentType) => {
-      const cType = componentType;
-      if (typeof api.components?.[cType] === "object" && !Array.isArray(api.components[cType])) {
-        Object.keys(api.components?.[cType] || {}).forEach((schemaName) => {
-          const componentSchema = cloneObject(api.components?.[cType]?.[schemaName]);
-          if (!components2[cType]) {
-            components2[cType] = {};
-          }
-          components2[cType][schemaName] = toJSONSchema(componentSchema, {
-            globalDefaults: opts?.globalDefaults,
-            hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-            hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
-            refLogger,
-            transformer: opts?.transformer
-          });
-        });
-      }
-    });
-    Object.keys(components2).forEach((componentType) => {
-      const cType = componentType;
-      if (!Object.keys(components2?.[cType] || {}).length) {
-        delete components2?.[cType];
-      }
-    });
-    return components2;
-  }
   function transformParameters() {
     const operationParams = operation.getParameters();
     const transformed = Object.keys(types).map((type) => {
@@ -817,20 +1085,11 @@ function getParametersAsJSONSchema(operation, api, opts) {
           }
           if (current.deprecated) currentSchema.deprecated = current.deprecated;
           const interimSchema = toJSONSchema(currentSchema, {
+            ...baseSchemaOptions,
             currentLocation: `/${current.name}`,
-            globalDefaults: opts?.globalDefaults,
-            hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-            hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
-            refLogger,
-            transformer: opts?.transformer
+            refLogger: (ref) => refLoggerForSchemaGroup(type).add(ref)
           });
-          schema2 = isPrimitive(interimSchema) ? interimSchema : {
-            ...interimSchema,
-            // Note: this applies a `$schema` version to each field in the larger schema
-            // object. It's not really **correct** but it's what we have to do because
-            // there's a chance that the end user has indicated the schemas are different.
-            $schema: getSchemaVersionString(currentSchema, api)
-          };
+          schema2 = isPrimitive(interimSchema) ? interimSchema : { ...interimSchema };
         } else if ("content" in current && typeof current.content === "object") {
           const contentKeys = Object.keys(current.content);
           if (contentKeys.length) {
@@ -844,20 +1103,11 @@ function getParametersAsJSONSchema(operation, api, opts) {
               }
               if (current.deprecated) currentSchema.deprecated = current.deprecated;
               const interimSchema = toJSONSchema(currentSchema, {
+                ...baseSchemaOptions,
                 currentLocation: `/${current.name}`,
-                globalDefaults: opts?.globalDefaults,
-                hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-                hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
-                refLogger,
-                transformer: opts?.transformer
+                refLogger: (ref) => refLoggerForSchemaGroup(type).add(ref)
               });
-              schema2 = isPrimitive(interimSchema) ? interimSchema : {
-                ...interimSchema,
-                // Note: this applies a `$schema` version to each field in the larger schema
-                // object. It's not really **correct** but it's what we have to do because
-                // there's a chance that the end user has indicated the schemas are different.
-                $schema: getSchemaVersionString(currentSchema, api)
-              };
+              schema2 = isPrimitive(interimSchema) ? interimSchema : { ...interimSchema };
             }
           }
         }
@@ -873,15 +1123,15 @@ function getParametersAsJSONSchema(operation, api, opts) {
         return prev;
       }, {});
       const schema = {
+        $schema: getSchemaVersionString({}, api),
         type: "object",
         properties,
-        required
+        ...required.length > 0 ? { required } : {}
       };
       return {
         type,
         label: types[type],
-        schema,
-        deprecatedProps: getDeprecated(schema, type) ?? void 0
+        schema
       };
     }).filter((item) => item !== null);
     if (!opts?.mergeIntoBodyAndMetadata) {
@@ -889,20 +1139,13 @@ function getParametersAsJSONSchema(operation, api, opts) {
     } else if (!transformed.length) {
       return [];
     }
-    const deprecatedProps = transformed.map((r) => r.deprecatedProps?.schema || null).filter(Boolean);
     return [
       {
         type: "metadata",
         label: types.metadata,
         schema: {
           allOf: transformed.map((r) => r.schema)
-        },
-        deprecatedProps: deprecatedProps.length ? {
-          type: "metadata",
-          schema: {
-            allOf: deprecatedProps
-          }
-        } : void 0
+        }
       }
     ];
   }
@@ -913,31 +1156,59 @@ function getParametersAsJSONSchema(operation, api, opts) {
   typeKeys[typeKeys.indexOf("form")] = "formData";
   typeKeys.push("metadata");
   const jsonSchema = [transformRequestBody()].concat(...transformParameters()).filter((item) => item !== null);
-  const shouldIncludeComponents = hasCircularRefs || hasDiscriminatorMappingRefs && opts?.includeDiscriminatorMappingRefs;
-  const components = shouldIncludeComponents ? transformComponents() : false;
+  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;
+    }
+  });
   return jsonSchema.map((group) => {
-    if (components && shouldIncludeComponents) {
-      group.schema.components = components;
+    if (group.schema && typeof group.schema === "object") {
+      const refsInGroup = refsByGroup.get(group.type) ?? /* @__PURE__ */ new Set();
+      const referencedSchemas = filterRequiredRefsToReferenced(refsInGroup, usedSchemas);
+      if (referencedSchemas.size > 0) {
+        mergeReferencedSchemasIntoRoot(group.schema, referencedSchemas);
+      }
     }
-    if (!group.deprecatedProps) delete group.deprecatedProps;
     return group;
   }).sort((a, b) => {
     return typeKeys.indexOf(a.type) - typeKeys.indexOf(b.type);
   });
 }
 
+// src/utils.ts
+var supportedMethods = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+var SERVER_VARIABLE_REGEX = /{([-_a-zA-Z0-9:.[\]]+)}/g;
+
 export {
-  cloneObject,
+  isObject,
+  isPrimitive,
+  decorateComponentSchemasWithRefName,
   decodePointer,
   dereferenceRef,
   getDereferencingOptions,
-  isObject,
-  isPrimitive,
+  filterRequiredRefsToReferenced,
+  mergeReferencedSchemasIntoRoot,
   matches_mimetype_default,
   getParameterContentType,
+  cloneObject,
+  applyDiscriminatorOneOfToUsedSchemas,
   getSchemaVersionString,
   toJSONSchema,
   types,
-  getParametersAsJSONSchema
+  getParametersAsJSONSchema,
+  supportedMethods,
+  SERVER_VARIABLE_REGEX
 };
-//# sourceMappingURL=chunk-5EP6HY2E.js.map
+//# sourceMappingURL=chunk-HYH37HS2.js.map