oas 31.1.2 → 32.1.0

package/dist/{chunk-B5WP4BJM.cjs → chunk-7RDMAMMI.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } function _optionalChainDelete(ops) { const result = _optionalChain(ops); return result == null ? true : result; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 
 var _chunkAYA3UT4Lcjs = require('./chunk-AYA3UT4L.cjs');
@@ -6,15 +6,7 @@ var _chunkAYA3UT4Lcjs = require('./chunk-AYA3UT4L.cjs');
 
 
 
-var _chunkVQBEI5WIcjs = require('./chunk-VQBEI5WI.cjs');
-
-// src/lib/clone-object.ts
-function cloneObject(obj) {
-  if (typeof obj === "undefined") {
-    return void 0;
-  }
-  return JSON.parse(JSON.stringify(obj));
-}
+var _chunkYPR7YTHMcjs = require('./chunk-YPR7YTHM.cjs');
 
 // src/lib/matches-mimetype.ts
 function matchesMediaType(types2, mediaType) {
@@ -71,6 +63,9 @@ function getParameterContentType(contentKeys) {
   return contentKeys[0];
 }
 
+// src/lib/refs.ts
+var _jsonpointer = require('jsonpointer'); var _jsonpointer2 = _interopRequireDefault(_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
-var _jsonschemamergeallof = require('json-schema-merge-allof'); var _jsonschemamergeallof2 = _interopRequireDefault(_jsonschemamergeallof);
-var _jsonpointer = require('jsonpointer'); var _jsonpointer2 = _interopRequireDefault(_jsonpointer);
-var _removeundefinedobjects = require('remove-undefined-objects'); var _removeundefinedobjects2 = _interopRequireDefault(_removeundefinedobjects);
-
 // src/lib/refs.ts
-
+function decorateComponentSchemasWithRefName(api) {
+  if (!_optionalChain([api, 'optionalAccess', _2 => _2.components, 'optionalAccess', _3 => _3.schemas]) || typeof api.components.schemas !== "object") {
+    return;
+  }
+  Object.keys(api.components.schemas).forEach((schemaName) => {
+    if (isPrimitive(_optionalChain([api, 'access', _4 => _4.components, 'optionalAccess', _5 => _5.schemas, 'optionalAccess', _6 => _6[schemaName]])) || Array.isArray(_optionalChain([api, 'access', _7 => _7.components, 'optionalAccess', _8 => _8.schemas, 'optionalAccess', _9 => _9[schemaName]])) || _optionalChain([api, 'access', _10 => _10.components, 'optionalAccess', _11 => _11.schemas, 'optionalAccess', _12 => _12[schemaName]]) === null) {
+      return;
+    }
+    (_optionalChain([api, 'access', _13 => _13.components, 'optionalAccess', _14 => _14.schemas, 'optionalAccess', _15 => _15[schemaName]]))["x-readme-ref-name"] = schemaName;
+  });
+}
 function encodePointer(str) {
   return str.replaceAll("~", "~0").replaceAll("/", "~1");
 }
@@ -114,32 +114,26 @@ 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;
   }
-  if (_chunkVQBEI5WIcjs.isRef.call(void 0, value)) {
+  if (_chunkYPR7YTHMcjs.isRef.call(void 0, value)) {
     if (!definition) {
       return value;
     }
     const ref = value.$ref;
-    if (_optionalChain([seenRefs, 'optionalAccess', _2 => _2.has, 'call', _3 => _3(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 (_chunkVQBEI5WIcjs.isRef.call(void 0, dereferenced)) {
-        return dereferenceRef(dereferenced, definition, localSeenRefs);
+      if (_chunkYPR7YTHMcjs.isRef.call(void 0, dereferenced)) {
+        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 (e2) {
       return value;
@@ -164,16 +158,198 @@ function getDereferencingOptions(circularRefs) {
     }
   };
 }
+function collectRefsInSchema(schema) {
+  const refs = /* @__PURE__ */ new Set();
+  if (!schema || typeof schema !== "object") return refs;
+  const obj = schema;
+  if (_chunkYPR7YTHMcjs.isRef.call(void 0, 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 (_chunkYPR7YTHMcjs.isRef.call(void 0, 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 (!_optionalChain([definition, 'optionalAccess', _16 => _16.components, 'optionalAccess', _17 => _17.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
+var _jsonschemamergeallof = require('json-schema-merge-allof'); var _jsonschemamergeallof2 = _interopRequireDefault(_jsonschemamergeallof);
+
+var _removeundefinedobjects = require('remove-undefined-objects'); var _removeundefinedobjects2 = _interopRequireDefault(_removeundefinedobjects);
 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 (_chunkVQBEI5WIcjs.isOpenAPI30.call(void 0, api)) {
+  if (_chunkYPR7YTHMcjs.isOpenAPI30.call(void 0, api)) {
     return "http://json-schema.org/draft-04/schema#";
   }
   if (schema.$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 (_chunkYPR7YTHMcjs.isRef.call(void 0, 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 (_chunkYPR7YTHMcjs.isRef.call(void 0, dereferenced)) {
+        refLogger(dereferenced.$ref, "ref");
+        let converted2;
+        try {
+          const pointer = ref.startsWith("#") ? decodeURIComponent(ref.substring(1)) : ref;
+          const rawSchema = _jsonpointer2.default.get(definition, pointer);
+          if (rawSchema && typeof rawSchema === "object") {
+            converted2 = toJSONSchema(structuredClone(rawSchema), { ...conversionOptions, seenRefs });
+          } else {
+            converted2 = { $ref: ref };
+          }
+        } catch (e3) {
+          converted2 = { $ref: ref };
+        }
+        usedSchemas.set(ref, converted2);
+        refLogger(ref, "ref");
+        return { $ref: ref };
+      }
+      resolved = dereferenced;
+    } catch (e4) {
+      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 (_chunkYPR7YTHMcjs.isRef.call(void 0, dereferenced)) {
+      let converted2;
+      try {
+        const pointer = ref.startsWith("#") ? decodeURIComponent(ref.substring(1)) : ref;
+        const rawSchema = _jsonpointer2.default.get(definition, pointer);
+        if (rawSchema && typeof rawSchema === "object") {
+          converted2 = toJSONSchema(structuredClone(rawSchema), { ...conversionOptions, seenRefs });
+        } else {
+          converted2 = { $ref: ref };
+        }
+      } catch (e5) {
+        converted2 = { $ref: ref };
+      }
+      usedSchemas.set(ref, converted2);
+      return converted2;
+    }
+    const converted = toJSONSchema(structuredClone(dereferenced), { ...conversionOptions, seenRefs });
+    usedSchemas.set(ref, converted);
+    return converted;
+  } catch (e6) {
+    usedSchemas.set(ref, { $ref: ref });
+    return { $ref: ref };
+  }
+}
 function isRequestBodySchema(schema) {
   return "content" in schema;
 }
@@ -220,7 +491,7 @@ function searchForValueByPropAndPointer(property, pointer, schemas = []) {
       }
       try {
         foundValue = _jsonpointer2.default.get(schema, pointers[i]);
-      } catch (e3) {
+      } catch (e7) {
       }
       if (foundValue !== void 0) {
         break;
@@ -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 = _chunkVQBEI5WIcjs.isSchema.call(void 0, schema) ? schema.additionalProperties : null;
+  const schemaAdditionalProperties = _chunkYPR7YTHMcjs.isSchema.call(void 0, 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
   };
-  if (_chunkVQBEI5WIcjs.isRef.call(void 0, schema)) {
+  const polyOptions = {
+    addEnumsToDescriptions,
+    currentLocation,
+    definition,
+    globalDefaults,
+    hideReadOnlyProperties,
+    hideWriteOnlyProperties,
+    isPolymorphicAllOfChild: false,
+    prevDefaultSchemas,
+    prevExampleSchemas,
+    refLogger,
+    seenRefs,
+    usedSchemas
+  };
+  if (_chunkYPR7YTHMcjs.isRef.call(void 0, 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 (_chunkVQBEI5WIcjs.isSchema.call(void 0, schema, isPolymorphicAllOfChild)) {
+  if (_chunkYPR7YTHMcjs.isSchema.call(void 0, 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 (_chunkYPR7YTHMcjs.isRef.call(void 0, 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 = _jsonschemamergeallof2.default.call(void 0, schema, {
           ignoreAdditionalProperties: true,
@@ -296,73 +618,92 @@ function toJSONSchema(data, opts = {}) {
             defaultResolver: _jsonschemamergeallof2.default.options.resolvers.title
           }
         });
-      } catch (e4) {
+      } catch (e8) {
         const { ...schemaWithoutAllOf } = schema;
         schema = schemaWithoutAllOf;
         delete schema.allOf;
       }
-      if (_chunkVQBEI5WIcjs.isRef.call(void 0, schema)) {
+      collectRefsInSchema(schema).forEach((ref) => {
+        refLogger(ref, "ref");
+      });
+      if (_chunkYPR7YTHMcjs.isRef.call(void 0, schema)) {
         refLogger(schema.$ref, "ref");
-        return transformer(schema);
+        return schema;
       }
     }
     ["anyOf", "oneOf"].forEach((polyType) => {
       if (polyType in schema && Array.isArray(schema[polyType])) {
         const discriminatorPropertyName = "discriminator" in schema && schema.discriminator && isObject(schema.discriminator) ? schema.discriminator.propertyName : void 0;
         schema[polyType].forEach((item, idx) => {
-          if (!_optionalChain([schema, 'access', _4 => _4[polyType], 'optionalAccess', _5 => _5[idx]])) {
+          if (!_optionalChain([schema, 'access', _18 => _18[polyType], 'optionalAccess', _19 => _19[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 && _chunkYPR7YTHMcjs.isRef.call(void 0, 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 (_optionalChain([schema, 'optionalAccess', _20 => _20.discriminator, 'optionalAccess', _21 => _21.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)) {
@@ -427,7 +768,7 @@ function toJSONSchema(data, opts = {}) {
               "required"
             ]
           }).forEach(([typeKey, keywords]) => {
-            if (!_optionalChain([schema, 'access', _6 => _6.type, 'optionalAccess', _7 => _7.includes, 'call', _8 => _8(typeKey)])) {
+            if (!_optionalChain([schema, 'access', _22 => _22.type, 'optionalAccess', _23 => _23.includes, 'call', _24 => _24(typeKey)])) {
               return;
             }
             const reducedSchema = _removeundefinedobjects2.default.call(void 0, {
@@ -460,7 +801,7 @@ function toJSONSchema(data, opts = {}) {
       }
     }
   }
-  if (_chunkVQBEI5WIcjs.isSchema.call(void 0, schema, isPolymorphicAllOfChild)) {
+  if (_chunkYPR7YTHMcjs.isSchema.call(void 0, schema, isPolymorphicAllOfChild)) {
     if ("default" in schema && isObject(schema.default)) {
       prevDefaultSchemas.push({ default: schema.default });
     }
@@ -481,7 +822,7 @@ function toJSONSchema(data, opts = {}) {
       if (typeof schema.examples === "object" && schema.examples !== null && !Array.isArray(schema.examples)) {
         const examples = [];
         Object.keys(schema.examples).forEach((name) => {
-          const example = _optionalChain([schema, 'access', _9 => _9.examples, 'optionalAccess', _10 => _10[name]]);
+          const example = _optionalChain([schema, 'access', _25 => _25.examples, 'optionalAccess', _26 => _26[name]]);
           if ("$ref" in example) {
             refLogger(example.$ref, "ref");
           } else if ("value" in example) {
@@ -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 && _chunkVQBEI5WIcjs.isRef.call(void 0, schema.items)) {
+        if (!(definition && usedSchemas) && !Array.isArray(schema.items) && Object.keys(schema.items).length === 1 && _chunkYPR7YTHMcjs.isRef.call(void 0, 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) {
@@ -544,17 +885,12 @@ function toJSONSchema(data, opts = {}) {
     } else if (hasSchemaType(schema, "object")) {
       if ("properties" in schema && schema.properties !== void 0) {
         Object.keys(schema.properties).forEach((prop) => {
-          if (Array.isArray(_optionalChain([schema, 'access', _11 => _11.properties, 'optionalAccess', _12 => _12[prop]])) || typeof _optionalChain([schema, 'access', _13 => _13.properties, 'optionalAccess', _14 => _14[prop]]) === "object" && _optionalChain([schema, 'access', _15 => _15.properties, 'optionalAccess', _16 => _16[prop]]) !== null) {
+          if (Array.isArray(_optionalChain([schema, 'access', _27 => _27.properties, 'optionalAccess', _28 => _28[prop]])) || typeof _optionalChain([schema, 'access', _29 => _29.properties, 'optionalAccess', _30 => _30[prop]]) === "object" && _optionalChain([schema, 'access', _31 => _31.properties, 'optionalAccess', _32 => _32[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
           });
         }
       }
@@ -605,13 +936,13 @@ function toJSONSchema(data, opts = {}) {
       }
     }
   }
-  if (_chunkVQBEI5WIcjs.isSchema.call(void 0, schema, isPolymorphicAllOfChild) && globalDefaults && Object.keys(globalDefaults).length > 0 && currentLocation) {
+  if (_chunkYPR7YTHMcjs.isSchema.call(void 0, schema, isPolymorphicAllOfChild) && globalDefaults && Object.keys(globalDefaults).length > 0 && currentLocation) {
     try {
       const userJwtDefault = _jsonpointer2.default.get(globalDefaults, currentLocation);
       if (userJwtDefault) {
         schema.default = userJwtDefault;
       }
-    } catch (e5) {
+    } catch (e9) {
     }
   }
   if ("default" in schema && typeof schema.default !== "undefined") {
@@ -627,7 +958,7 @@ function toJSONSchema(data, opts = {}) {
       schema.default = foundDefault;
     }
   }
-  if (_chunkVQBEI5WIcjs.isSchema.call(void 0, schema, isPolymorphicAllOfChild) && "enum" in schema && Array.isArray(schema.enum)) {
+  if (_chunkYPR7YTHMcjs.isSchema.call(void 0, schema, isPolymorphicAllOfChild) && "enum" in schema && Array.isArray(schema.enum)) {
     schema.enum = Array.from(new Set(schema.enum));
     if (addEnumsToDescriptions) {
       const enums = schema.enum.filter((v) => v !== void 0 && (typeof v !== "string" || v.trim() !== "")).map((str) => `\`${str}\``).join(" ");
@@ -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 (_optionalChain([opts, 'optionalAccess', _17 => _17.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 = _optionalChain([deprecatedBody, 'access', _18 => _18.properties, 'optionalAccess', _19 => _19[key]]);
-      if (deprecatedProp.deprecated && !requiredParams.includes(key) && !deprecatedProp.readOnly) {
-        allDeprecatedProps[key] = deprecatedProp;
-      }
-    });
-    deprecatedBody.properties = allDeprecatedProps;
-    const deprecatedSchema = toJSONSchema(deprecatedBody, {
-      globalDefaults: _optionalChain([opts, 'optionalAccess', _20 => _20.globalDefaults]),
-      hideReadOnlyProperties: _optionalChain([opts, 'optionalAccess', _21 => _21.hideReadOnlyProperties]),
-      hideWriteOnlyProperties: _optionalChain([opts, 'optionalAccess', _22 => _22.hideWriteOnlyProperties]),
-      prevExampleSchemas: [],
-      refLogger,
-      transformer: _optionalChain([opts, 'optionalAccess', _23 => _23.transformer])
-    });
-    if (Object.keys(deprecatedSchema).length === 0 || Object.keys(deprecatedSchema.properties || {}).length === 0) {
-      return null;
-    }
-    Object.keys(schema.properties).forEach((key) => {
-      if ((_optionalChain([schema, 'access', _24 => _24.properties, 'optionalAccess', _25 => _25[key]])).deprecated && !requiredParams.includes(key)) {
-         _optionalChainDelete([schema, 'access', _26 => _26.properties, 'optionalAccess', _27 => delete _27[key]]);
-      }
-    });
-    return {
-      type,
-      schema: isPrimitive(deprecatedSchema) ? deprecatedSchema : {
-        ...deprecatedSchema,
-        $schema: getSchemaVersionString(deprecatedSchema, api)
-      }
-    };
+    return set;
   }
+  const baseSchemaOptions = {
+    definition: api,
+    globalDefaults: _optionalChain([opts, 'optionalAccess', _33 => _33.globalDefaults]),
+    hideReadOnlyProperties: _optionalChain([opts, 'optionalAccess', _34 => _34.hideReadOnlyProperties]),
+    hideWriteOnlyProperties: _optionalChain([opts, 'optionalAccess', _35 => _35.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) => {
-          if (_chunkVQBEI5WIcjs.isRef.call(void 0, example)) {
-            return void 0;
+        examples: Object.values(mediaTypeObject.examples || {}).map((ex) => {
+          let example = ex;
+          if (!example) return void 0;
+          if (_chunkYPR7YTHMcjs.isRef.call(void 0, example)) {
+            example = dereferenceRef(example, operation.api);
+            if (!example || _chunkYPR7YTHMcjs.isRef.call(void 0, 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: _optionalChain([opts, 'optionalAccess', _28 => _28.globalDefaults]),
-      hideReadOnlyProperties: _optionalChain([opts, 'optionalAccess', _29 => _29.hideReadOnlyProperties]),
-      hideWriteOnlyProperties: _optionalChain([opts, 'optionalAccess', _30 => _30.hideWriteOnlyProperties]),
+      ...baseSchemaOptions,
       prevExampleSchemas,
-      refLogger,
-      transformer: _optionalChain([opts, 'optionalAccess', _31 => _31.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: _nullishCoalesce(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 _optionalChain([api, 'access', _32 => _32.components, 'optionalAccess', _33 => _33[cType]]) === "object" && !Array.isArray(api.components[cType])) {
-        Object.keys(_optionalChain([api, 'access', _34 => _34.components, 'optionalAccess', _35 => _35[cType]]) || {}).forEach((schemaName) => {
-          const componentSchema = cloneObject(_optionalChain([api, 'access', _36 => _36.components, 'optionalAccess', _37 => _37[cType], 'optionalAccess', _38 => _38[schemaName]]));
-          if (!components2[cType]) {
-            components2[cType] = {};
-          }
-          components2[cType][schemaName] = toJSONSchema(componentSchema, {
-            globalDefaults: _optionalChain([opts, 'optionalAccess', _39 => _39.globalDefaults]),
-            hideReadOnlyProperties: _optionalChain([opts, 'optionalAccess', _40 => _40.hideReadOnlyProperties]),
-            hideWriteOnlyProperties: _optionalChain([opts, 'optionalAccess', _41 => _41.hideWriteOnlyProperties]),
-            refLogger,
-            transformer: _optionalChain([opts, 'optionalAccess', _42 => _42.transformer])
-          });
-        });
-      }
-    });
-    Object.keys(components2).forEach((componentType) => {
-      const cType = componentType;
-      if (!Object.keys(_optionalChain([components2, 'optionalAccess', _43 => _43[cType]]) || {}).length) {
-         _optionalChainDelete([components2, 'optionalAccess', _44 => delete _44[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: _optionalChain([opts, 'optionalAccess', _45 => _45.globalDefaults]),
-            hideReadOnlyProperties: _optionalChain([opts, 'optionalAccess', _46 => _46.hideReadOnlyProperties]),
-            hideWriteOnlyProperties: _optionalChain([opts, 'optionalAccess', _47 => _47.hideWriteOnlyProperties]),
-            refLogger,
-            transformer: _optionalChain([opts, 'optionalAccess', _48 => _48.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: _optionalChain([opts, 'optionalAccess', _49 => _49.globalDefaults]),
-                hideReadOnlyProperties: _optionalChain([opts, 'optionalAccess', _50 => _50.hideReadOnlyProperties]),
-                hideWriteOnlyProperties: _optionalChain([opts, 'optionalAccess', _51 => _51.hideWriteOnlyProperties]),
-                refLogger,
-                transformer: _optionalChain([opts, 'optionalAccess', _52 => _52.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,36 +1123,29 @@ 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: _nullishCoalesce(getDeprecated(schema, type), () => ( void 0))
+        schema
       };
     }).filter((item) => item !== null);
-    if (!_optionalChain([opts, 'optionalAccess', _53 => _53.mergeIntoBodyAndMetadata])) {
+    if (!_optionalChain([opts, 'optionalAccess', _36 => _36.mergeIntoBodyAndMetadata])) {
       return transformed;
     } else if (!transformed.length) {
       return [];
     }
-    const deprecatedProps = transformed.map((r) => _optionalChain([r, 'access', _54 => _54.deprecatedProps, 'optionalAccess', _55 => _55.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,19 +1156,47 @@ 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 && _optionalChain([opts, 'optionalAccess', _56 => _56.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 (_chunkYPR7YTHMcjs.isRef.call(void 0, resolved)) return void 0;
+      const converted = toJSONSchema(structuredClone(resolved), {
+        ...baseSchemaOptions,
+        seenRefs
+      });
+      usedSchemas.set(ref, converted);
+      return converted;
+    } catch (e10) {
+      return void 0;
+    }
+  });
   return jsonSchema.map((group) => {
-    if (components && shouldIncludeComponents) {
-      group.schema.components = components;
+    if (group.schema && typeof group.schema === "object") {
+      const refsInGroup = _nullishCoalesce(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;
+
+
+
+
+
+
+
 
 
 
@@ -939,5 +1210,5 @@ function getParametersAsJSONSchema(operation, api, opts) {
 
 
 
-exports.cloneObject = cloneObject; exports.decodePointer = decodePointer; exports.dereferenceRef = dereferenceRef; exports.getDereferencingOptions = getDereferencingOptions; exports.isObject = isObject; exports.isPrimitive = isPrimitive; exports.matches_mimetype_default = matches_mimetype_default; exports.getParameterContentType = getParameterContentType; exports.getSchemaVersionString = getSchemaVersionString; exports.toJSONSchema = toJSONSchema; exports.types = types; exports.getParametersAsJSONSchema = getParametersAsJSONSchema;
-//# sourceMappingURL=chunk-B5WP4BJM.cjs.map
+exports.isObject = isObject; exports.isPrimitive = isPrimitive; exports.decorateComponentSchemasWithRefName = decorateComponentSchemasWithRefName; exports.decodePointer = decodePointer; exports.dereferenceRef = dereferenceRef; exports.getDereferencingOptions = getDereferencingOptions; exports.filterRequiredRefsToReferenced = filterRequiredRefsToReferenced; exports.mergeReferencedSchemasIntoRoot = mergeReferencedSchemasIntoRoot; exports.matches_mimetype_default = matches_mimetype_default; exports.getParameterContentType = getParameterContentType; exports.cloneObject = cloneObject; exports.applyDiscriminatorOneOfToUsedSchemas = applyDiscriminatorOneOfToUsedSchemas; exports.getSchemaVersionString = getSchemaVersionString; exports.toJSONSchema = toJSONSchema; exports.types = types; exports.getParametersAsJSONSchema = getParametersAsJSONSchema; exports.supportedMethods = supportedMethods; exports.SERVER_VARIABLE_REGEX = SERVER_VARIABLE_REGEX;
+//# sourceMappingURL=chunk-7RDMAMMI.cjs.map