@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.38

package/.output/server/node_modules/oas/dist/chunk-5EP6HY2E.js

@@ -1,943 +0,0 @@
-import {
-  PARAMETER_ORDERING,
-  getExtension
-} from "./chunk-S27IGTVG.js";
-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));
-}
-
-// src/lib/matches-mimetype.ts
-function matchesMediaType(types2, mediaType) {
-  return types2.some((type) => {
-    return mediaType.indexOf(type) > -1;
-  });
-}
-var matches_mimetype_default = {
-  formUrlEncoded: (mimeType) => {
-    return matchesMediaType(["application/x-www-form-urlencoded"], mimeType);
-  },
-  json: (contentType) => {
-    return matchesMediaType(
-      ["application/json", "application/x-json", "text/json", "text/x-json", "+json"],
-      contentType
-    );
-  },
-  multipart: (contentType) => {
-    return matchesMediaType(
-      ["multipart/mixed", "multipart/related", "multipart/form-data", "multipart/alternative"],
-      contentType
-    );
-  },
-  wildcard: (contentType) => {
-    return contentType === "*/*";
-  },
-  xml: (contentType) => {
-    return matchesMediaType(
-      [
-        "application/xml",
-        "application/xml-external-parsed-entity",
-        "application/xml-dtd",
-        "text/xml",
-        "text/xml-external-parsed-entity",
-        "+xml"
-      ],
-      contentType
-    );
-  }
-};
-
-// src/lib/get-parameter-content-type.ts
-function getParameterContentType(contentKeys) {
-  if (contentKeys.length === 0) {
-    return void 0;
-  }
-  if (contentKeys.length === 1) {
-    return contentKeys[0];
-  }
-  const jsonLikeContentTypes = contentKeys.filter((k) => matches_mimetype_default.json(k));
-  if (jsonLikeContentTypes.length) {
-    return jsonLikeContentTypes[0];
-  }
-  return contentKeys[0];
-}
-
-// src/lib/helpers.ts
-function hasSchemaType(schema, discriminator) {
-  if (Array.isArray(schema.type)) {
-    return schema.type.includes(discriminator);
-  }
-  return schema.type === discriminator;
-}
-function isObject(val) {
-  return typeof val === "object" && val !== null && !Array.isArray(val);
-}
-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 encodePointer(str) {
-  return str.replaceAll("~", "~0").replaceAll("/", "~1");
-}
-function decodePointer(str) {
-  return str.replace(/~([01])/g, (_, digit) => digit === "0" ? "~" : "/");
-}
-function findRef($ref, definition) {
-  let currRef = $ref.trim();
-  if (currRef === "") {
-    return false;
-  }
-  if (currRef.startsWith("#")) {
-    currRef = decodeURIComponent(currRef.substring(1));
-  } else {
-    throw new Error(`Could not find a definition for ${$ref}.`);
-  }
-  const current = jsonpointer.get(definition, currRef);
-  if (current === void 0) {
-    throw new Error(`Could not find a definition for ${$ref}.`);
-  }
-  return current;
-}
-function dereferenceRef(value, definition, seenRefs) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (isRef(value)) {
-    if (!definition) {
-      return value;
-    }
-    const ref = value.$ref;
-    if (seenRefs?.has(ref)) {
-      return value;
-    }
-    const localSeenRefs = seenRefs || /* @__PURE__ */ new Set();
-    localSeenRefs.add(ref);
-    try {
-      const dereferenced = findRef(ref, definition);
-      if (isRef(dereferenced)) {
-        return dereferenceRef(dereferenced, definition, localSeenRefs);
-      }
-      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
-      };
-    } catch {
-      return value;
-    }
-  }
-  return value;
-}
-function getDereferencingOptions(circularRefs) {
-  return {
-    resolve: {
-      // We shouldn't be resolving external pointers at this point so just ignore them.
-      external: false
-    },
-    dereference: {
-      // If circular `$refs` are ignored they'll remain in the schema as `$ref: String`, otherwise
-      // `$ref` just won't exist. This, in tandem with `onCircular`, allows us to do easy and
-      // accumulate a list of circular references.
-      circular: "ignore",
-      onCircular: (path) => {
-        circularRefs.add(`#${path.split("#")[1]}`);
-      }
-    }
-  };
-}
-
-// src/lib/openapi-to-json-schema.ts
-var UNSUPPORTED_SCHEMA_PROPS = [
-  "example",
-  // OpenAPI supports `example` but we're mapping it to `examples` in this library.
-  "externalDocs",
-  "xml"
-];
-function getSchemaVersionString(schema, api) {
-  if (isOpenAPI30(api)) {
-    return "http://json-schema.org/draft-04/schema#";
-  }
-  if (schema.$schema) {
-    return schema.$schema;
-  }
-  if (api.jsonSchemaDialect) {
-    return api.jsonSchemaDialect;
-  }
-  return "https://json-schema.org/draft/2020-12/schema#";
-}
-function isPolymorphicSchema(schema) {
-  return "allOf" in schema || "anyOf" in schema || "oneOf" in schema;
-}
-function isRequestBodySchema(schema) {
-  return "content" in schema;
-}
-function searchForValueByPropAndPointer(property, pointer, schemas = []) {
-  if (!schemas.length || !pointer.length) {
-    return void 0;
-  }
-  const locSplit = pointer.split("/").filter(Boolean).reverse();
-  const pointers = [];
-  let point = "";
-  for (let i = 0; i < locSplit.length; i += 1) {
-    point = `/${locSplit[i]}${point}`;
-    pointers.push(point);
-  }
-  let foundValue;
-  const rev = [...schemas].reverse();
-  for (let i = 0; i < pointers.length; i += 1) {
-    for (let ii = 0; ii < rev.length; ii += 1) {
-      let schema = rev[ii];
-      if (property === "example") {
-        if ("example" in schema) {
-          schema = schema.example;
-        } else {
-          if (!Array.isArray(schema.examples) || !schema.examples.length) {
-            continue;
-          }
-          schema = [...schema.examples].shift();
-        }
-      } else {
-        schema = schema.default;
-      }
-      try {
-        foundValue = jsonpointer2.get(schema, pointers[i]);
-      } catch {
-      }
-      if (foundValue !== void 0) {
-        break;
-      }
-    }
-    if (foundValue !== void 0) {
-      break;
-    }
-  }
-  return foundValue;
-}
-function toJSONSchema(data, opts = {}) {
-  let schema = data === true ? {} : { ...data };
-  const schemaAdditionalProperties = isSchema(schema) ? schema.additionalProperties : null;
-  const {
-    addEnumsToDescriptions,
-    currentLocation,
-    globalDefaults,
-    hideReadOnlyProperties,
-    hideWriteOnlyProperties,
-    isPolymorphicAllOfChild,
-    prevDefaultSchemas = [],
-    prevExampleSchemas = [],
-    refLogger,
-    transformer
-  } = {
-    addEnumsToDescriptions: false,
-    currentLocation: "",
-    globalDefaults: {},
-    hideReadOnlyProperties: false,
-    hideWriteOnlyProperties: false,
-    isPolymorphicAllOfChild: false,
-    prevDefaultSchemas: [],
-    prevExampleSchemas: [],
-    refLogger: () => true,
-    transformer: (s) => s,
-    ...opts
-  };
-  if (isRef(schema)) {
-    refLogger(schema.$ref, "ref");
-    return transformer(schema);
-  }
-  if (isSchema(schema, isPolymorphicAllOfChild)) {
-    if ("allOf" in schema && Array.isArray(schema.allOf)) {
-      try {
-        schema = mergeJSONSchemaAllOf(schema, {
-          ignoreAdditionalProperties: true,
-          resolvers: {
-            // `merge-json-schema-allof` by default takes the first `description` when you're
-            // merging an `allOf` but because generally when you're merging two schemas together
-            // with an `allOf` you want data in the subsequent schemas to be applied to the first
-            // and `description` should be a part of that.
-            description: (obj) => {
-              return obj.slice(-1)[0];
-            },
-            // `merge-json-schema-allof` doesn't support merging enum arrays but since that's a
-            // safe and simple operation as enums always contain primitives we can handle it
-            // ourselves with a custom resolver.
-            //
-            // We unfortunately need to cast our return value as `any[]` because the internal types
-            // of `merge-json-schema-allof`'s `enum` resolver are not portable.
-            enum: (obj) => {
-              let arr = [];
-              obj.forEach((e) => {
-                arr = arr.concat(e);
-              });
-              return arr;
-            },
-            // for any unknown keywords (e.g., `example`, `format`, `x-readme-ref-name`),
-            // we fallback to using the title resolver (which uses the first value found).
-            // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/src/index.js#L292
-            // https://github.com/mokkabonna/json-schema-merge-allof/blob/ea2e48ee34415022de5a50c236eb4793a943ad11/README.md?plain=1#L147
-            defaultResolver: mergeJSONSchemaAllOf.options.resolvers.title
-          }
-        });
-      } catch {
-        const { ...schemaWithoutAllOf } = schema;
-        schema = schemaWithoutAllOf;
-        delete schema.allOf;
-      }
-      if (isRef(schema)) {
-        refLogger(schema.$ref, "ref");
-        return transformer(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 (!schema[polyType]?.[idx]) {
-            return;
-          }
-          const polyOptions = {
-            addEnumsToDescriptions,
-            currentLocation: `${currentLocation}/${idx}`,
-            globalDefaults,
-            hideReadOnlyProperties,
-            hideWriteOnlyProperties,
-            isPolymorphicAllOfChild: false,
-            prevDefaultSchemas,
-            prevExampleSchemas,
-            refLogger,
-            transformer
-          };
-          if ("properties" in schema) {
-            schema[polyType][idx] = toJSONSchema(
-              { required: schema.required, allOf: [item, { properties: schema.properties }] },
-              polyOptions
-            );
-          } else if ("items" in schema) {
-            schema[polyType][idx] = toJSONSchema(
-              { allOf: [item, { items: schema.items }] },
-              polyOptions
-            );
-          } else {
-            schema[polyType][idx] = toJSONSchema(item, polyOptions);
-          }
-          if (isObject(schema[polyType][idx]) && "required" in schema[polyType][idx] && typeof schema[polyType][idx].required === "boolean") {
-            delete schema[polyType][idx].required;
-          }
-          if (discriminatorPropertyName && isObject(schema[polyType][idx])) {
-            const childSchema = schema[polyType][idx];
-            if ("discriminator" in childSchema) {
-              delete childSchema.discriminator;
-            }
-            if ("oneOf" in childSchema) {
-              delete childSchema.oneOf;
-            }
-            if ("anyOf" in childSchema) {
-              delete childSchema.anyOf;
-            }
-          }
-        });
-      }
-    });
-    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 (!("type" in schema) && !isPolymorphicSchema(schema) && !isRequestBodySchema(schema)) {
-    if ("properties" in schema) {
-      schema.type = "object";
-    } else if ("items" in schema) {
-      schema.type = "array";
-    } else {
-    }
-  }
-  if ("type" in schema && schema.type !== void 0) {
-    if ("nullable" in schema) {
-      if (schema.nullable) {
-        if (Array.isArray(schema.type)) {
-          schema.type.push("null");
-        } else if (schema.type !== null && schema.type !== "null") {
-          schema.type = [schema.type, "null"];
-        }
-      }
-      delete schema.nullable;
-    }
-    if (schema.type === null) {
-      schema.type = "null";
-    } else if (Array.isArray(schema.type)) {
-      if (schema.type.includes(null)) {
-        schema.type[schema.type.indexOf(null)] = "null";
-      }
-      schema.type = Array.from(new Set(schema.type));
-      if (schema.type.length === 1) {
-        schema.type = schema.type.shift();
-      } else if (schema.type.includes("array") || schema.type.includes("boolean") || schema.type.includes("object")) {
-        const isNullable = schema.type.includes("null");
-        if (schema.type.length === 2 && isNullable) {
-        } else {
-          const nonPrimitives = [];
-          Object.entries({
-            // https://json-schema.org/understanding-json-schema/reference/array.html
-            array: [
-              "additionalItems",
-              "contains",
-              "items",
-              "maxContains",
-              "maxItems",
-              "minContains",
-              "minItems",
-              "prefixItems",
-              "uniqueItems"
-            ],
-            // https://json-schema.org/understanding-json-schema/reference/boolean.html
-            boolean: [
-              // Booleans don't have any boolean-specific properties.
-            ],
-            // https://json-schema.org/understanding-json-schema/reference/object.html
-            object: [
-              "additionalProperties",
-              "maxProperties",
-              "minProperties",
-              "nullable",
-              "patternProperties",
-              "properties",
-              "propertyNames",
-              "required"
-            ]
-          }).forEach(([typeKey, keywords]) => {
-            if (!schema.type?.includes(typeKey)) {
-              return;
-            }
-            const reducedSchema = removeUndefinedObjects({
-              type: isNullable ? [typeKey, "null"] : typeKey,
-              allowEmptyValue: schema.allowEmptyValue ?? void 0,
-              deprecated: schema.deprecated ?? void 0,
-              description: schema.description ?? void 0,
-              readOnly: schema.readOnly ?? void 0,
-              title: schema.title ?? void 0,
-              writeOnly: schema.writeOnly ?? void 0
-            });
-            keywords.forEach((keyword) => {
-              if (keyword in schema) {
-                reducedSchema[keyword] = schema[keyword];
-                delete schema[keyword];
-              }
-            });
-            nonPrimitives.push(reducedSchema);
-          });
-          schema.type = schema.type.filter((t) => t !== "array" && t !== "boolean" && t !== "object");
-          if (schema.type.length === 1) {
-            schema.type = schema.type.shift();
-          }
-          if (schema.type && schema.type.length > 1) {
-            schema = { oneOf: [schema, ...nonPrimitives] };
-          } else {
-            schema = { oneOf: nonPrimitives };
-          }
-        }
-      }
-    }
-  }
-  if (isSchema(schema, isPolymorphicAllOfChild)) {
-    if ("default" in schema && isObject(schema.default)) {
-      prevDefaultSchemas.push({ default: schema.default });
-    }
-    if ("example" in schema) {
-      if (isPrimitive(schema.example)) {
-        schema.examples = [schema.example];
-      } else if (Array.isArray(schema.example)) {
-        schema.examples = schema.example.filter((example) => isPrimitive(example));
-        if (!schema.examples.length) {
-          delete schema.examples;
-        }
-      } else {
-        prevExampleSchemas.push({ example: schema.example });
-      }
-      delete schema.example;
-    } else if ("examples" in schema) {
-      let reshapedExamples = false;
-      if (typeof schema.examples === "object" && schema.examples !== null && !Array.isArray(schema.examples)) {
-        const examples = [];
-        Object.keys(schema.examples).forEach((name) => {
-          const example = schema.examples?.[name];
-          if ("$ref" in example) {
-            refLogger(example.$ref, "ref");
-          } else if ("value" in example) {
-            if (isPrimitive(example.value)) {
-              examples.push(example.value);
-              reshapedExamples = true;
-            } else if (Array.isArray(example.value) && isPrimitive(example.value[0])) {
-              examples.push(example.value[0]);
-              reshapedExamples = true;
-            } else {
-              prevExampleSchemas.push({
-                example: example.value
-              });
-            }
-          }
-        });
-        if (examples.length) {
-          reshapedExamples = true;
-          schema.examples = examples;
-        }
-      } else if (Array.isArray(schema.examples) && isPrimitive(schema.examples[0])) {
-        reshapedExamples = true;
-      }
-      if (!reshapedExamples) {
-        delete schema.examples;
-      }
-    }
-    if (!hasSchemaType(schema, "array") && !hasSchemaType(schema, "object") && !schema.examples) {
-      const foundExample = searchForValueByPropAndPointer("example", currentLocation, prevExampleSchemas);
-      if (foundExample) {
-        if (isPrimitive(foundExample) || Array.isArray(foundExample) && isPrimitive(foundExample[0])) {
-          schema.examples = [foundExample];
-        }
-      }
-    }
-    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)) {
-          refLogger(schema.items.$ref, "ref");
-        } else if (schema.items !== true) {
-          schema.items = toJSONSchema(schema.items, {
-            addEnumsToDescriptions,
-            currentLocation: `${currentLocation}/0`,
-            globalDefaults,
-            hideReadOnlyProperties,
-            hideWriteOnlyProperties,
-            prevExampleSchemas,
-            refLogger,
-            transformer
-          });
-          if (isObject(schema.items) && "required" in schema.items && !Array.isArray(schema.items.required)) {
-            delete schema.items.required;
-          }
-        }
-      } else if ("properties" in schema || "additionalProperties" in schema) {
-        schema.type = "object";
-      } else {
-        schema.items = {};
-      }
-    } else if (hasSchemaType(schema, "object")) {
-      if ("properties" in schema && schema.properties !== void 0) {
-        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,
-              currentLocation: `${currentLocation}/${encodePointer(prop)}`,
-              globalDefaults,
-              hideReadOnlyProperties,
-              hideWriteOnlyProperties,
-              prevDefaultSchemas,
-              prevExampleSchemas,
-              refLogger,
-              transformer
-            });
-            let propShouldBeUpdated = true;
-            if ((hideReadOnlyProperties || hideWriteOnlyProperties) && !Object.keys(newPropSchema).length) {
-              if (Object.keys(schema.properties[prop]).length > 0) {
-                delete schema.properties[prop];
-                propShouldBeUpdated = false;
-              }
-            }
-            if (propShouldBeUpdated) {
-              schema.properties[prop] = newPropSchema;
-              if (isObject(newPropSchema) && "required" in newPropSchema && typeof newPropSchema.required === "boolean" && newPropSchema.required === true) {
-                if ("required" in schema && Array.isArray(schema.required)) {
-                  schema.required.push(prop);
-                } else {
-                  schema.required = [prop];
-                }
-                delete schema.properties[prop].required;
-              }
-            }
-          }
-        });
-        if (hideReadOnlyProperties || hideWriteOnlyProperties) {
-          if (!Object.keys(schema.properties).length) {
-            return transformer({});
-          }
-        }
-      }
-      if (typeof schemaAdditionalProperties === "object" && schemaAdditionalProperties !== null) {
-        if (!("type" in schemaAdditionalProperties) && !("$ref" in schemaAdditionalProperties) && // We know it will be a schema object because it's dereferenced
-        !isPolymorphicSchema(schemaAdditionalProperties)) {
-          schema.additionalProperties = true;
-        } else {
-          schema.additionalProperties = toJSONSchema(schemaAdditionalProperties, {
-            addEnumsToDescriptions,
-            currentLocation,
-            globalDefaults,
-            hideReadOnlyProperties,
-            hideWriteOnlyProperties,
-            prevDefaultSchemas,
-            prevExampleSchemas,
-            refLogger,
-            transformer
-          });
-        }
-      }
-      if (!isPolymorphicSchema(schema) && !("properties" in schema) && !("additionalProperties" in schema)) {
-        schema.additionalProperties = true;
-      }
-    }
-  }
-  if (isSchema(schema, isPolymorphicAllOfChild) && globalDefaults && Object.keys(globalDefaults).length > 0 && currentLocation) {
-    try {
-      const userJwtDefault = jsonpointer2.get(globalDefaults, currentLocation);
-      if (userJwtDefault) {
-        schema.default = userJwtDefault;
-      }
-    } catch {
-    }
-  }
-  if ("default" in schema && typeof schema.default !== "undefined") {
-    if (hasSchemaType(schema, "object")) {
-      delete schema.default;
-    } else if ("allowEmptyValue" in schema && schema.allowEmptyValue && schema.default === "" || schema.default !== "") {
-    } else {
-      delete schema.default;
-    }
-  } else if (prevDefaultSchemas.length) {
-    const foundDefault = searchForValueByPropAndPointer("default", currentLocation, prevDefaultSchemas);
-    if (isPrimitive(foundDefault) || foundDefault === null || Array.isArray(foundDefault) && hasSchemaType(schema, "array")) {
-      schema.default = foundDefault;
-    }
-  }
-  if (isSchema(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(" ");
-      if (enums.length) {
-        if ("description" in schema) {
-          schema.description += `
-
-${enums}`;
-        } else {
-          schema.description = enums;
-        }
-      }
-    }
-  }
-  if ("anyOf" in schema || "oneOf" in schema) {
-    if ("properties" in schema) {
-      delete schema.properties;
-    }
-    if ("items" in schema) {
-      delete schema.items;
-    }
-  }
-  for (let i = 0; i < UNSUPPORTED_SCHEMA_PROPS.length; i += 1) {
-    delete schema[UNSUPPORTED_SCHEMA_PROPS[i]];
-  }
-  if (hideReadOnlyProperties && "readOnly" in schema && schema.readOnly === true) {
-    return {};
-  } else if (hideWriteOnlyProperties && "writeOnly" in schema && schema.writeOnly === true) {
-    return {};
-  }
-  return transformer(schema);
-}
-
-// src/operation/lib/get-parameters-as-json-schema.ts
-var types = {
-  path: "Path Params",
-  query: "Query Params",
-  body: "Body Params",
-  cookie: "Cookie Params",
-  formData: "Form Data",
-  header: "Headers",
-  metadata: "Metadata"
-  // 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;
-    }
-    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)
-      }
-    };
-  }
-  function transformRequestBody() {
-    const requestBody = operation.getRequestBody();
-    if (!requestBody || !Array.isArray(requestBody)) return null;
-    const [mediaType, mediaTypeObject, description] = requestBody;
-    const type = mediaType === "application/x-www-form-urlencoded" ? "formData" : "body";
-    if (!mediaTypeObject.schema || !Object.keys(mediaTypeObject.schema).length) {
-      return null;
-    }
-    const prevExampleSchemas = [];
-    if ("example" in mediaTypeObject) {
-      prevExampleSchemas.push({ example: mediaTypeObject.example });
-    } else if ("examples" in mediaTypeObject) {
-      prevExampleSchemas.push({
-        examples: Object.values(mediaTypeObject.examples || {}).map((example) => {
-          if (isRef(example)) {
-            return void 0;
-          }
-          return example.value;
-        }).filter((item) => item !== void 0)
-      });
-    }
-    const requestSchema = cloneObject(mediaTypeObject.schema);
-    const cleanedSchema = toJSONSchema(requestSchema, {
-      globalDefaults: opts?.globalDefaults,
-      hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-      hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
-      prevExampleSchemas,
-      refLogger,
-      transformer: opts?.transformer
-    });
-    if (!Object.keys(cleanedSchema).length) {
-      return null;
-    }
-    return {
-      type,
-      label: types[type],
-      schema: isPrimitive(cleanedSchema) ? cleanedSchema : {
-        ...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) => {
-      const required = [];
-      const parameters = operationParams.filter((param) => param.in === type);
-      if (parameters.length === 0) {
-        return null;
-      }
-      const properties = parameters.reduce((prev, current) => {
-        let schema2 = {};
-        if ("schema" in current) {
-          const currentSchema = current.schema ? cloneObject(current.schema) : {};
-          if (current.example) {
-            currentSchema.example = current.example;
-          } else if (current.examples) {
-            currentSchema.examples = current.examples;
-          }
-          if (current.deprecated) currentSchema.deprecated = current.deprecated;
-          const interimSchema = toJSONSchema(currentSchema, {
-            currentLocation: `/${current.name}`,
-            globalDefaults: opts?.globalDefaults,
-            hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-            hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
-            refLogger,
-            transformer: opts?.transformer
-          });
-          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)
-          };
-        } else if ("content" in current && typeof current.content === "object") {
-          const contentKeys = Object.keys(current.content);
-          if (contentKeys.length) {
-            const contentType = getParameterContentType(contentKeys);
-            if (contentType && typeof current.content[contentType] === "object" && "schema" in current.content[contentType]) {
-              const currentSchema = current.content[contentType].schema ? cloneObject(current.content[contentType].schema) : {};
-              if (current.example) {
-                currentSchema.example = current.example;
-              } else if (current.examples) {
-                currentSchema.examples = current.examples;
-              }
-              if (current.deprecated) currentSchema.deprecated = current.deprecated;
-              const interimSchema = toJSONSchema(currentSchema, {
-                currentLocation: `/${current.name}`,
-                globalDefaults: opts?.globalDefaults,
-                hideReadOnlyProperties: opts?.hideReadOnlyProperties,
-                hideWriteOnlyProperties: opts?.hideWriteOnlyProperties,
-                refLogger,
-                transformer: opts?.transformer
-              });
-              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)
-              };
-            }
-          }
-        }
-        if (current.description) {
-          if (!isPrimitive(schema2)) {
-            schema2.description = current.description;
-          }
-        }
-        prev[current.name] = schema2;
-        if (current.required) {
-          required.push(current.name);
-        }
-        return prev;
-      }, {});
-      const schema = {
-        type: "object",
-        properties,
-        required
-      };
-      return {
-        type,
-        label: types[type],
-        schema,
-        deprecatedProps: getDeprecated(schema, type) ?? void 0
-      };
-    }).filter((item) => item !== null);
-    if (!opts?.mergeIntoBodyAndMetadata) {
-      return transformed;
-    } 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
-      }
-    ];
-  }
-  if (!operation.hasParameters() && !operation.hasRequestBody()) {
-    return null;
-  }
-  const typeKeys = getExtension(PARAMETER_ORDERING, api, operation).map((k) => k.toLowerCase());
-  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;
-  return jsonSchema.map((group) => {
-    if (components && shouldIncludeComponents) {
-      group.schema.components = components;
-    }
-    if (!group.deprecatedProps) delete group.deprecatedProps;
-    return group;
-  }).sort((a, b) => {
-    return typeKeys.indexOf(a.type) - typeKeys.indexOf(b.type);
-  });
-}
-
-export {
-  cloneObject,
-  decodePointer,
-  dereferenceRef,
-  getDereferencingOptions,
-  isObject,
-  isPrimitive,
-  matches_mimetype_default,
-  getParameterContentType,
-  getSchemaVersionString,
-  toJSONSchema,
-  types,
-  getParametersAsJSONSchema
-};
-//# sourceMappingURL=chunk-5EP6HY2E.js.map