@mintlify/validation 0.1.67 → 0.1.68

package/dist/openapi/convertSchema.js

@@ -1,28 +1,8 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import lcm from 'lcm';
 import _ from 'lodash';
 import { ConversionError, ImpossibleSchemaError, InvalidSchemaError } from './convertOpenApi.js';
 import { typeList, } from './types/endpoint.js';
-export var convertSchema = function (path, schema, required) {
+export const convertSchema = (path, schema, required) => {
     if (schema === undefined) {
         throw new InvalidSchemaError(path, 'schema undefined');
     }
@@ -37,11 +17,11 @@ export var convertSchema = function (path, schema, required) {
  * @param schemaArray `schema.allOf` or `schema.oneOf`
  * @returns a schema array equivalent to the `schemaArray` argument, but in reduced form
  */
-var evaluateOptionsCompositions = function (path, schemaArray) {
-    var evaluatedArray = schemaArray.flatMap(function (subschema, i) {
+const evaluateOptionsCompositions = (path, schemaArray) => {
+    const evaluatedArray = schemaArray.flatMap((subschema, i) => {
         var _a;
         try {
-            return (_a = evaluateCompositionsRecursive(__spreadArray(__spreadArray([], path, true), [i.toString()], false), subschema).oneOf) !== null && _a !== void 0 ? _a : [];
+            return (_a = evaluateCompositionsRecursive([...path, i.toString()], subschema).oneOf) !== null && _a !== void 0 ? _a : [];
         }
         catch (error) {
             if (error instanceof ImpossibleSchemaError) {
@@ -57,41 +37,37 @@ var evaluateOptionsCompositions = function (path, schemaArray) {
     }
     return evaluatedArray;
 };
-var evaluateCompositionsRecursive = function (path, schema) {
+const evaluateCompositionsRecursive = (path, schema) => {
     // evaluate compositions first; we are currently ignoring `not`
     if (schema.oneOf && schema.oneOf.length > 0) {
-        schema.oneOf = evaluateOptionsCompositions(__spreadArray(__spreadArray([], path, true), ['oneOf'], false), schema.oneOf);
+        schema.oneOf = evaluateOptionsCompositions([...path, 'oneOf'], schema.oneOf);
     }
     else {
         schema.oneOf = [];
     }
     if (schema.anyOf && schema.anyOf.length > 0) {
-        schema.anyOf = evaluateOptionsCompositions(__spreadArray(__spreadArray([], path, true), ['anyOf'], false), schema.anyOf);
+        schema.anyOf = evaluateOptionsCompositions([...path, 'anyOf'], schema.anyOf);
     }
     if (schema.allOf && schema.allOf.length > 0) {
-        var totalAllOfObj = schema.allOf
-            .map(function (subschema, i) {
-            return evaluateCompositionsRecursive(__spreadArray(__spreadArray([], path, true), ['allOf', i.toString()], false), subschema);
-        })
-            .reduce(function (schema1, schema2, i) {
-            return combineReducedSchemas(__spreadArray(__spreadArray([], path, true), ['allOf', i.toString()], false), schema1, schema2);
-        }, {
+        const totalAllOfObj = schema.allOf
+            .map((subschema, i) => evaluateCompositionsRecursive([...path, 'allOf', i.toString()], subschema))
+            .reduce((schema1, schema2, i) => combineReducedSchemas([...path, 'allOf', i.toString()], schema1, schema2), {
             oneOf: [],
         });
         schema.oneOf = multiplySchemaArrays(path, schema.oneOf, totalAllOfObj.oneOf);
     }
     // evaluate subschemas, if present
     if (schema.properties) {
-        for (var key in schema.properties) {
-            schema.properties[key] = evaluateCompositionsRecursive(__spreadArray(__spreadArray([], path, true), ['properties', key], false), schema.properties[key]);
+        for (const key in schema.properties) {
+            schema.properties[key] = evaluateCompositionsRecursive([...path, 'properties', key], schema.properties[key]);
         }
     }
     if (schema.items) {
-        schema.items = evaluateCompositionsRecursive(__spreadArray(__spreadArray([], path, true), ['items'], false), schema.items);
+        schema.items = evaluateCompositionsRecursive([...path, 'items'], schema.items);
     }
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
         try {
-            schema.additionalProperties = evaluateCompositionsRecursive(__spreadArray(__spreadArray([], path, true), ['additionalProperties'], false), schema.additionalProperties);
+            schema.additionalProperties = evaluateCompositionsRecursive([...path, 'additionalProperties'], schema.additionalProperties);
         }
         catch (error) {
             if (error instanceof ImpossibleSchemaError) {
@@ -106,15 +82,15 @@ var evaluateCompositionsRecursive = function (path, schema) {
     if (schema.anyOf && schema.anyOf.length > 0) {
         schema.oneOf = multiplySchemaArrays(path, schema.oneOf, schema.anyOf);
     }
-    var topLevelSchemaArray = generateTopLevelSchemaArray(schema);
+    const topLevelSchemaArray = generateTopLevelSchemaArray(schema);
     return { oneOf: multiplySchemaArrays(path, schema.oneOf, topLevelSchemaArray) };
 };
-var generateTopLevelSchemaArray = function (schema) {
+const generateTopLevelSchemaArray = (schema) => {
     if (schema.nullable) {
-        var typedSchema = __assign({}, schema);
+        const typedSchema = Object.assign({}, schema);
         delete typedSchema.oneOf;
         delete typedSchema.nullable;
-        var nullSchema = __assign({}, schema);
+        const nullSchema = Object.assign({}, schema);
         delete nullSchema.oneOf;
         delete nullSchema.nullable;
         nullSchema.type = 'null';
@@ -122,19 +98,19 @@ var generateTopLevelSchemaArray = function (schema) {
     }
     if (Array.isArray(schema.type)) {
         if (schema.type.length === 0) {
-            var topLevelSchema_1 = __assign({}, schema);
-            delete topLevelSchema_1.oneOf;
-            delete topLevelSchema_1.type;
-            return [topLevelSchema_1];
+            const topLevelSchema = Object.assign({}, schema);
+            delete topLevelSchema.oneOf;
+            delete topLevelSchema.type;
+            return [topLevelSchema];
         }
-        return schema.type.map(function (typeString) {
-            var topLevelSchema = __assign({}, schema);
+        return schema.type.map((typeString) => {
+            const topLevelSchema = Object.assign({}, schema);
             delete topLevelSchema.oneOf;
             topLevelSchema.type = typeString;
             return topLevelSchema;
         });
     }
-    var topLevelSchema = __assign({}, schema);
+    const topLevelSchema = Object.assign({}, schema);
     delete topLevelSchema.oneOf;
     return [topLevelSchema];
 };
@@ -148,7 +124,7 @@ var generateTopLevelSchemaArray = function (schema) {
  * @param b second array of schema options
  * @returns array of schemas that satisfy both arrays
  */
-var multiplySchemaArrays = function (path, a, b) {
+const multiplySchemaArrays = (path, a, b) => {
     if (a.length === 0 && b.length === 0) {
         return [{}];
     }
@@ -158,10 +134,10 @@ var multiplySchemaArrays = function (path, a, b) {
     if (b.length === 0) {
         return a;
     }
-    var product = a.flatMap(function (schema1) {
-        return b.flatMap(function (schema2) {
+    const product = a.flatMap((schema1) => {
+        return b.flatMap((schema2) => {
             try {
-                var combinedSchema = combineTopLevelSchemas(path, schema1, schema2);
+                const combinedSchema = combineTopLevelSchemas(path, schema1, schema2);
                 return [combinedSchema];
             }
             catch (error) {
@@ -179,16 +155,16 @@ var multiplySchemaArrays = function (path, a, b) {
     }
     return product;
 };
-var combineReducedSchemas = function (path, schema1, schema2) {
+const combineReducedSchemas = (path, schema1, schema2) => {
     var _a, _b;
     return {
         oneOf: multiplySchemaArrays(path, ((_a = schema1.oneOf) !== null && _a !== void 0 ? _a : []), ((_b = schema2.oneOf) !== null && _b !== void 0 ? _b : [])),
     };
 };
-export var combineTopLevelSchemas = function (path, schema1, schema2) {
+export const combineTopLevelSchemas = (path, schema1, schema2) => {
     var _a, _b;
-    var type1 = schema1.type;
-    var type2 = schema2.type;
+    let type1 = schema1.type;
+    let type2 = schema2.type;
     // don't throw an error if number type is being constricted
     if (type1 === 'integer' && type2 === 'number') {
         type2 = 'integer';
@@ -197,10 +173,9 @@ export var combineTopLevelSchemas = function (path, schema1, schema2) {
         type1 = 'integer';
     }
     if (type1 && type2 && type1 !== type2) {
-        throw new ImpossibleSchemaError(path, "mismatched type in composition: \"".concat(type1, "\" \"").concat(type2, "\""));
+        throw new ImpossibleSchemaError(path, `mismatched type in composition: "${type1}" "${type2}"`);
     }
-    for (var _i = 0, _c = [schema1, schema2]; _i < _c.length; _i++) {
-        var schema = _c[_i];
+    for (const schema of [schema1, schema2]) {
         if (typeof schema.exclusiveMaximum === 'number') {
             if (schema.maximum === undefined || schema.maximum >= schema.exclusiveMaximum) {
                 schema.maximum = schema.exclusiveMaximum;
@@ -220,7 +195,7 @@ export var combineTopLevelSchemas = function (path, schema1, schema2) {
             }
         }
     }
-    var combinedSchema = {
+    const combinedSchema = {
         title: takeLast(schema1, schema2, 'title'),
         description: takeLast(schema1, schema2, 'description'),
         format: takeLast(schema1, schema2, 'format'),
@@ -233,10 +208,8 @@ export var combineTopLevelSchemas = function (path, schema1, schema2) {
         minItems: combine(schema1, schema2, 'minItems', Math.max),
         maxProperties: combine(schema1, schema2, 'maxProperties', Math.min),
         minProperties: combine(schema1, schema2, 'minProperties', Math.max),
-        required: combine(schema1, schema2, 'required', function (a, b) {
-            return b.concat(a.filter(function (value) { return !b.includes(value); }));
-        }),
-        enum: combine(schema1, schema2, 'enum', function (a, b) { return b.filter(function (value) { return a.includes(value); }); }),
+        required: combine(schema1, schema2, 'required', (a, b) => b.concat(a.filter((value) => !b.includes(value)))),
+        enum: combine(schema1, schema2, 'enum', (a, b) => b.filter((value) => a.includes(value))),
         readOnly: schema1.readOnly && schema2.readOnly,
         writeOnly: schema1.writeOnly && schema2.writeOnly,
         deprecated: schema1.deprecated && schema2.deprecated,
@@ -250,30 +223,29 @@ export var combineTopLevelSchemas = function (path, schema1, schema2) {
     if (typeof schema1.example === 'object' &&
         typeof schema2.example === 'object' &&
         (schema1.example != null || schema2.example != null)) {
-        combinedSchema.example = __assign(__assign({}, schema1.example), schema2.example);
+        combinedSchema.example = Object.assign(Object.assign({}, schema1.example), schema2.example);
     }
     else {
         combinedSchema.example = takeLast(schema1, schema2, 'example');
     }
-    var type = type1 !== null && type1 !== void 0 ? type1 : type2;
+    const type = type1 !== null && type1 !== void 0 ? type1 : type2;
     if (type === 'array') {
-        return __assign({ type: type, items: combineReducedSchemas(__spreadArray(__spreadArray([], path, true), ['items'], false), (_a = schema1.items) !== null && _a !== void 0 ? _a : {}, (_b = schema2.items) !== null && _b !== void 0 ? _b : {}) }, combinedSchema);
+        return Object.assign({ type, items: combineReducedSchemas([...path, 'items'], (_a = schema1.items) !== null && _a !== void 0 ? _a : {}, (_b = schema2.items) !== null && _b !== void 0 ? _b : {}) }, combinedSchema);
     }
     if (schema1.properties && schema2.properties) {
-        var combinedProperties_1 = __assign({}, schema1.properties);
-        Object.entries(schema2.properties).forEach(function (_a) {
-            var property = _a[0], schema = _a[1];
-            if (property in combinedProperties_1) {
-                combinedProperties_1[property] = combineReducedSchemas(__spreadArray(__spreadArray([], path, true), ['properties', property], false), combinedProperties_1[property], schema);
+        const combinedProperties = Object.assign({}, schema1.properties);
+        Object.entries(schema2.properties).forEach(([property, schema]) => {
+            if (property in combinedProperties) {
+                combinedProperties[property] = combineReducedSchemas([...path, 'properties', property], combinedProperties[property], schema);
             }
             else {
-                combinedProperties_1[property] = schema;
+                combinedProperties[property] = schema;
             }
         });
-        combinedSchema.properties = combinedProperties_1;
+        combinedSchema.properties = combinedProperties;
     }
     else if (schema1.properties || schema2.properties) {
-        combinedSchema.properties = __assign(__assign({}, schema1.properties), schema2.properties);
+        combinedSchema.properties = Object.assign(Object.assign({}, schema1.properties), schema2.properties);
     }
     if (schema1.additionalProperties === false || schema2.additionalProperties === false) {
         combinedSchema.additionalProperties = false;
@@ -282,7 +254,7 @@ export var combineTopLevelSchemas = function (path, schema1, schema2) {
         typeof schema1.additionalProperties === 'object' &&
         schema2.additionalProperties &&
         typeof schema2.additionalProperties === 'object') {
-        combinedSchema.additionalProperties = combineReducedSchemas(__spreadArray(__spreadArray([], path, true), ['additionalProperties'], false), schema1.additionalProperties, schema2.additionalProperties);
+        combinedSchema.additionalProperties = combineReducedSchemas([...path, 'additionalProperties'], schema1.additionalProperties, schema2.additionalProperties);
     }
     else if (schema1.additionalProperties && typeof schema1.additionalProperties === 'object') {
         combinedSchema.additionalProperties = schema1.additionalProperties;
@@ -290,34 +262,34 @@ export var combineTopLevelSchemas = function (path, schema1, schema2) {
     else if (schema2.additionalProperties && typeof schema2.additionalProperties === 'object') {
         combinedSchema.additionalProperties = schema2.additionalProperties;
     }
-    return __assign({ type: type }, combinedSchema);
+    return Object.assign({ type }, combinedSchema);
 };
-export var addKeyIfDefined = function (key, value, destination) {
+export const addKeyIfDefined = (key, value, destination) => {
     if (value !== undefined) {
         destination[key] = value;
     }
 };
-export var copyKeyIfDefined = function (key, source, destination) {
+export const copyKeyIfDefined = (key, source, destination) => {
     if (source[key] !== undefined) {
         destination[key] = source[key];
     }
 };
-var takeLast = function (schema1, schema2, key) {
+const takeLast = (schema1, schema2, key) => {
     var _a;
     return (_a = schema2[key]) !== null && _a !== void 0 ? _a : schema1[key];
 };
-var combine = function (schema1, schema2, key, transform) {
+const combine = (schema1, schema2, key, transform) => {
     var _a;
     return schema1[key] !== undefined && schema2[key] !== undefined
         ? transform(schema1[key], schema2[key])
         : (_a = schema1[key]) !== null && _a !== void 0 ? _a : schema2[key];
 };
-var convertSchemaRecursive = function (path, schema, required) {
+const convertSchemaRecursive = (path, schema, required) => {
     if (schema.oneOf === undefined || schema.oneOf.length === 0) {
         throw new ConversionError(path, 'missing schema definition');
     }
-    var schemaArray = schema.oneOf.map(function (schema) {
-        var sharedProps = {};
+    const schemaArray = schema.oneOf.map((schema) => {
+        const sharedProps = {};
         addKeyIfDefined('required', required, sharedProps);
         copyKeyIfDefined('title', schema, sharedProps);
         copyKeyIfDefined('description', schema, sharedProps);
@@ -325,31 +297,31 @@ var convertSchemaRecursive = function (path, schema, required) {
         copyKeyIfDefined('writeOnly', schema, sharedProps);
         copyKeyIfDefined('deprecated', schema, sharedProps);
         if (schema.type === undefined) {
-            var inferredType = inferType(schema);
+            const inferredType = inferType(schema);
             if (inferredType === undefined) {
-                return __assign({ type: 'any' }, sharedProps);
+                return Object.assign({ type: 'any' }, sharedProps);
             }
             schema.type = inferredType;
         }
-        var type = schema.type;
+        const type = schema.type;
         if (!typeList.includes(type)) {
-            throw new InvalidSchemaError(path, "invalid schema type: ".concat(schema.type));
+            throw new InvalidSchemaError(path, `invalid schema type: ${schema.type}`);
         }
         switch (schema.type) {
             case 'boolean':
-                var booleanProps = sharedProps;
+                const booleanProps = sharedProps;
                 copyKeyIfDefined('default', schema, booleanProps);
                 copyKeyIfDefined('example', schema, booleanProps);
-                return __assign({ type: schema.type }, booleanProps);
+                return Object.assign({ type: schema.type }, booleanProps);
             case 'number':
             case 'integer':
                 if (schema.enum) {
-                    var numberEnumProps = sharedProps;
+                    const numberEnumProps = sharedProps;
                     copyKeyIfDefined('default', schema, numberEnumProps);
                     copyKeyIfDefined('example', schema, numberEnumProps);
-                    return __assign({ type: schema.type === 'number' ? 'numberEnum' : 'integerEnum', enum: schema.enum }, numberEnumProps);
+                    return Object.assign({ type: schema.type === 'number' ? 'numberEnum' : 'integerEnum', enum: schema.enum }, numberEnumProps);
                 }
-                var numberProps = sharedProps;
+                const numberProps = sharedProps;
                 copyKeyIfDefined('multipleOf', schema, numberProps);
                 copyKeyIfDefined('maximum', schema, numberProps);
                 copyKeyIfDefined('exclusiveMaximum', schema, numberProps);
@@ -357,63 +329,62 @@ var convertSchemaRecursive = function (path, schema, required) {
                 copyKeyIfDefined('exclusiveMinimum', schema, numberProps);
                 copyKeyIfDefined('default', schema, numberProps);
                 copyKeyIfDefined('example', schema, numberProps);
-                return __assign({ type: schema.type }, numberProps);
+                return Object.assign({ type: schema.type }, numberProps);
             case 'string':
                 if (schema.enum) {
-                    var stringEnumProps = sharedProps;
+                    const stringEnumProps = sharedProps;
                     copyKeyIfDefined('default', schema, stringEnumProps);
                     copyKeyIfDefined('example', schema, stringEnumProps);
-                    return __assign({ type: 'stringEnum', enum: schema.enum }, stringEnumProps);
+                    return Object.assign({ type: 'stringEnum', enum: schema.enum }, stringEnumProps);
                 }
-                var stringProps = sharedProps;
+                const stringProps = sharedProps;
                 copyKeyIfDefined('format', schema, stringProps);
                 copyKeyIfDefined('pattern', schema, stringProps);
                 copyKeyIfDefined('maxLength', schema, stringProps);
                 copyKeyIfDefined('minLength', schema, stringProps);
                 copyKeyIfDefined('default', schema, stringProps);
                 copyKeyIfDefined('example', schema, stringProps);
-                return __assign({ type: schema.type }, stringProps);
+                return Object.assign({ type: schema.type }, stringProps);
             case 'array':
-                var arrayProps = sharedProps;
+                const arrayProps = sharedProps;
                 copyKeyIfDefined('maxItems', schema, arrayProps);
                 copyKeyIfDefined('minItems', schema, arrayProps);
                 copyKeyIfDefined('uniqueItems', schema, arrayProps);
                 copyKeyIfDefined('default', schema, arrayProps);
                 copyKeyIfDefined('example', schema, arrayProps);
-                return __assign({ type: schema.type, items: convertSchemaRecursive(__spreadArray(__spreadArray([], path, true), ['items'], false), schema.items) }, arrayProps);
+                return Object.assign({ type: schema.type, items: convertSchemaRecursive([...path, 'items'], schema.items) }, arrayProps);
             case 'object':
-                var properties = convertProperties(__spreadArray(__spreadArray([], path, true), ['properties'], false), schema.properties, schema.required);
-                var additionalProperties = typeof schema.additionalProperties === 'object' && schema.additionalProperties != null
-                    ? convertSchemaRecursive(__spreadArray(__spreadArray([], path, true), ['additionalProperties'], false), schema.additionalProperties)
+                const properties = convertProperties([...path, 'properties'], schema.properties, schema.required);
+                const additionalProperties = typeof schema.additionalProperties === 'object' && schema.additionalProperties != null
+                    ? convertSchemaRecursive([...path, 'additionalProperties'], schema.additionalProperties)
                     : schema.additionalProperties;
-                var objectProperties = sharedProps;
+                const objectProperties = sharedProps;
                 addKeyIfDefined('additionalProperties', additionalProperties, objectProperties);
                 copyKeyIfDefined('maxProperties', schema, objectProperties);
                 copyKeyIfDefined('minProperties', schema, objectProperties);
                 copyKeyIfDefined('default', schema, objectProperties);
                 copyKeyIfDefined('example', schema, objectProperties);
-                return __assign({ type: schema.type, properties: properties }, objectProperties);
+                return Object.assign({ type: schema.type, properties }, objectProperties);
             case 'null':
-                var nullProps = sharedProps;
+                const nullProps = sharedProps;
                 copyKeyIfDefined('default', schema, nullProps);
                 copyKeyIfDefined('example', schema, nullProps);
-                return __assign({ type: schema.type }, nullProps);
+                return Object.assign({ type: schema.type }, nullProps);
             default:
-                throw new ImpossibleSchemaError(path, "impossible type reached: ".concat(schema.type));
+                throw new ImpossibleSchemaError(path, `impossible type reached: ${schema.type}`);
         }
     });
     // must unpack first element to satisfy type
-    return __spreadArray([schemaArray[0]], schemaArray.slice(1), true);
+    return [schemaArray[0], ...schemaArray.slice(1)];
 };
-export var convertProperties = function (path, properties, required) {
+export const convertProperties = (path, properties, required) => {
     if (properties === undefined) {
         return {};
     }
-    var newEntries = Object.entries(properties).map(function (_a) {
-        var name = _a[0], schema = _a[1];
+    const newEntries = Object.entries(properties).map(([name, schema]) => {
         return [
             name,
-            convertSchemaRecursive(__spreadArray(__spreadArray([], path, true), [name], false), schema, (required === null || required === void 0 ? void 0 : required.includes(name)) ? true : undefined),
+            convertSchemaRecursive([...path, name], schema, (required === null || required === void 0 ? void 0 : required.includes(name)) ? true : undefined),
         ];
     });
     return Object.fromEntries(newEntries);
@@ -429,14 +400,14 @@ export var convertProperties = function (path, properties, required) {
  * @param schema
  * @returns if exactly one type can be inferred, the string corresponding to that type; otherwise `undefined`
  */
-var inferType = function (schema) {
+const inferType = (schema) => {
     var _a, _b;
-    var type = undefined;
+    let type = undefined;
     if (schema.format !== undefined ||
         schema.pattern !== undefined ||
         schema.minLength !== undefined ||
         schema.maxLength !== undefined ||
-        ((_a = schema.enum) === null || _a === void 0 ? void 0 : _a.every(function (option) { return typeof option === 'string'; }))) {
+        ((_a = schema.enum) === null || _a === void 0 ? void 0 : _a.every((option) => typeof option === 'string'))) {
         if (type !== undefined) {
             return undefined;
         }
@@ -447,7 +418,7 @@ var inferType = function (schema) {
         schema.maximum !== undefined ||
         schema.exclusiveMinimum !== undefined ||
         schema.exclusiveMaximum !== undefined ||
-        ((_b = schema.enum) === null || _b === void 0 ? void 0 : _b.every(function (option) { return typeof option === 'number'; }))) {
+        ((_b = schema.enum) === null || _b === void 0 ? void 0 : _b.every((option) => typeof option === 'number'))) {
         if (type !== undefined) {
             return undefined;
         }

package/dist/openapi/convertSecurity.js

@@ -1,6 +1,5 @@
 import { InvalidSchemaError } from './convertOpenApi.js';
-export var convertSecurity = function (_a) {
-    var securityRequirements = _a.securityRequirements, securitySchemes = _a.securitySchemes;
+export const convertSecurity = ({ securityRequirements, securitySchemes, }) => {
     if (securityRequirements === undefined || securityRequirements.length === 0) {
         return [];
     }
@@ -8,39 +7,38 @@ export var convertSecurity = function (_a) {
         throw new InvalidSchemaError(['#', 'components'], 'securitySchemes not defined');
     }
     // TODO(ronan): make this work for camel-case as well
-    return securityRequirements.map(function (security) {
-        var title = Object.keys(security)
-            .map(function (securityName) { return securityName.replace(/[_-]/g, ' '); })
+    return securityRequirements.map((security) => {
+        const title = Object.keys(security)
+            .map((securityName) => securityName.replace(/[_-]/g, ' '))
             .join(' & ');
-        var parameterSections = {
-            title: title,
+        const parameterSections = {
+            title,
             query: {},
             header: {},
             cookie: {},
         };
-        Object.keys(security).forEach(function (securityName) {
-            var securityScheme = securitySchemes === null || securitySchemes === void 0 ? void 0 : securitySchemes[securityName];
+        Object.keys(security).forEach((securityName) => {
+            const securityScheme = securitySchemes === null || securitySchemes === void 0 ? void 0 : securitySchemes[securityName];
             if (securityScheme === undefined) {
-                throw new InvalidSchemaError(['#', 'components', 'securitySchemes'], "security scheme not defined: '".concat(securityName, "'"));
+                throw new InvalidSchemaError(['#', 'components', 'securitySchemes'], `security scheme not defined: '${securityName}'`);
             }
             addSecurityParameters({
-                securityName: securityName,
-                securityScheme: securityScheme,
-                parameterSections: parameterSections,
+                securityName,
+                securityScheme,
+                parameterSections,
             });
         });
         return parameterSections;
     });
 };
-export var addSecurityParameters = function (_a) {
-    var _b, _c;
-    var securityName = _a.securityName, securityScheme = _a.securityScheme, parameterSections = _a.parameterSections;
+export const addSecurityParameters = ({ securityName, securityScheme, parameterSections, }) => {
+    var _a, _b;
     switch (securityScheme.type) {
         case 'apiKey':
             if (!['header', 'query', 'cookie'].includes(securityScheme.in)) {
-                throw new InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], "invalid security scheme location provided: '".concat(securityScheme.in, "'"));
+                throw new InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], `invalid security scheme location provided: '${securityScheme.in}'`);
             }
-            var paramGroup = securityScheme.in;
+            const paramGroup = securityScheme.in;
             parameterSections[paramGroup][securityScheme.name] = {
                 description: securityScheme.description,
                 required: true,
@@ -57,7 +55,7 @@ export var addSecurityParameters = function (_a) {
         case 'http':
             if (securityScheme.scheme === 'basic') {
                 parameterSections.header['Authentication'] = {
-                    description: (_b = securityScheme.description) !== null && _b !== void 0 ? _b : 'Basic authentication header of the form `Basic <encoded-value>`, where `<encoded-value>` is the base64-encoded string `username:password`.',
+                    description: (_a = securityScheme.description) !== null && _a !== void 0 ? _a : 'Basic authentication header of the form `Basic <encoded-value>`, where `<encoded-value>` is the base64-encoded string `username:password`.',
                     required: true,
                     schema: 'basic',
                     deprecated: false,
@@ -65,14 +63,14 @@ export var addSecurityParameters = function (_a) {
             }
             else if (securityScheme.scheme === 'bearer') {
                 parameterSections.header['Authorization'] = {
-                    description: (_c = securityScheme.description) !== null && _c !== void 0 ? _c : 'Bearer authentication header of the form `Bearer <token>`, where `<token>` is your auth token.',
+                    description: (_b = securityScheme.description) !== null && _b !== void 0 ? _b : 'Bearer authentication header of the form `Bearer <token>`, where `<token>` is your auth token.',
                     required: true,
                     schema: 'bearer',
                     deprecated: false,
                 };
             }
             else {
-                throw new InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], "encountered unknown HTTP security scheme: '".concat(securityScheme.scheme, "'"));
+                throw new InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], `encountered unknown HTTP security scheme: '${securityScheme.scheme}'`);
             }
             return;
         case 'oauth2':

package/dist/openapi/convertServers.js

@@ -1,24 +1,20 @@
-export var convertServers = function (_a) {
-    var servers = _a.servers;
+export const convertServers = ({ servers }) => {
     if (servers === undefined || servers.length === 0) {
         return undefined;
     }
-    return servers.map(function (_a) {
-        var url = _a.url, description = _a.description, variables = _a.variables;
+    return servers.map(({ url, description, variables }) => {
         return {
-            url: url,
-            description: description,
-            variables: convertVariables({ variables: variables }),
+            url,
+            description,
+            variables: convertVariables({ variables }),
         };
     });
 };
-var convertVariables = function (_a) {
-    var variables = _a.variables;
+const convertVariables = ({ variables }) => {
     if (variables === undefined || Object.keys(variables).length === 0) {
         return undefined;
     }
-    var newEntries = Object.entries(variables).map(function (_a) {
-        var name = _a[0], variable = _a[1];
+    const newEntries = Object.entries(variables).map(([name, variable]) => {
         if (variable.enum) {
             return [
                 name,

package/dist/openapi/types/endpoint.js

@@ -1,4 +1,4 @@
-export var typeList = [
+export const typeList = [
     'boolean',
     'string',
     'number',