@mintlify/validation 0.1.59 → 0.1.61

package/dist/openapi/convertSchema.js

@@ -1,4 +1,3 @@
-"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -19,25 +18,19 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertProperties = exports.copyKeyIfDefined = exports.addKeyIfDefined = exports.combineTopLevelSchemas = exports.convertSchema = void 0;
-var lcm_1 = __importDefault(require("lcm"));
-var lodash_1 = __importDefault(require("lodash"));
-var convertOpenApi_1 = require("./convertOpenApi");
-var endpoint_1 = require("./types/endpoint");
-var convertSchema = function (path, schema, required) {
+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) {
     if (schema === undefined) {
-        throw new convertOpenApi_1.InvalidSchemaError(path, 'schema undefined');
+        throw new InvalidSchemaError(path, 'schema undefined');
     }
     // TODO(ronan): remove when fully migrated to endpoint type, or don't modify schema in evaluateCompositionsRecursive
-    schema = lodash_1.default.cloneDeep(schema);
+    schema = _.cloneDeep(schema);
     schema = evaluateCompositionsRecursive(path, schema);
     return convertSchemaRecursive(path, schema, required);
 };
-exports.convertSchema = convertSchema;
 /**
  * This function should be used to reduce strictly `oneOf` and `anyOf` compositions.
  *
@@ -51,7 +44,7 @@ var evaluateOptionsCompositions = function (path, schemaArray) {
             return (_a = evaluateCompositionsRecursive(__spreadArray(__spreadArray([], path, true), [i.toString()], false), subschema).oneOf) !== null && _a !== void 0 ? _a : [];
         }
         catch (error) {
-            if (error instanceof convertOpenApi_1.ImpossibleSchemaError) {
+            if (error instanceof ImpossibleSchemaError) {
                 return [];
             }
             else {
@@ -60,7 +53,7 @@ var evaluateOptionsCompositions = function (path, schemaArray) {
         }
     });
     if (evaluatedArray.length === 0) {
-        throw new convertOpenApi_1.ImpossibleSchemaError(path, 'no valid options in schema:', JSON.stringify(schemaArray, undefined, 2));
+        throw new ImpossibleSchemaError(path, 'no valid options in schema:', JSON.stringify(schemaArray, undefined, 2));
     }
     return evaluatedArray;
 };
@@ -101,7 +94,7 @@ var evaluateCompositionsRecursive = function (path, schema) {
             schema.additionalProperties = evaluateCompositionsRecursive(__spreadArray(__spreadArray([], path, true), ['additionalProperties'], false), schema.additionalProperties);
         }
         catch (error) {
-            if (error instanceof convertOpenApi_1.ImpossibleSchemaError) {
+            if (error instanceof ImpossibleSchemaError) {
                 // if additionalProperties schema is impossible, rather than error, just disallow additionalProperties
                 schema.additionalProperties = false;
             }
@@ -168,11 +161,11 @@ var multiplySchemaArrays = function (path, a, b) {
     var product = a.flatMap(function (schema1) {
         return b.flatMap(function (schema2) {
             try {
-                var combinedSchema = (0, exports.combineTopLevelSchemas)(path, schema1, schema2);
+                var combinedSchema = combineTopLevelSchemas(path, schema1, schema2);
                 return [combinedSchema];
             }
             catch (error) {
-                if (error instanceof convertOpenApi_1.ImpossibleSchemaError) {
+                if (error instanceof ImpossibleSchemaError) {
                     return [];
                 }
                 else {
@@ -182,7 +175,7 @@ var multiplySchemaArrays = function (path, a, b) {
         });
     });
     if (product.length === 0) {
-        throw new convertOpenApi_1.ImpossibleSchemaError(path, 'impossible schema combination:', 'schema array 1:', JSON.stringify(a, undefined, 2), 'schema array 2:', JSON.stringify(b, undefined, 2));
+        throw new ImpossibleSchemaError(path, 'impossible schema combination:', 'schema array 1:', JSON.stringify(a, undefined, 2), 'schema array 2:', JSON.stringify(b, undefined, 2));
     }
     return product;
 };
@@ -192,7 +185,7 @@ var combineReducedSchemas = function (path, schema1, schema2) {
         oneOf: multiplySchemaArrays(path, ((_a = schema1.oneOf) !== null && _a !== void 0 ? _a : []), ((_b = schema2.oneOf) !== null && _b !== void 0 ? _b : [])),
     };
 };
-var combineTopLevelSchemas = function (path, schema1, schema2) {
+export var combineTopLevelSchemas = function (path, schema1, schema2) {
     var _a, _b;
     var type1 = schema1.type;
     var type2 = schema2.type;
@@ -204,7 +197,7 @@ var combineTopLevelSchemas = function (path, schema1, schema2) {
         type1 = 'integer';
     }
     if (type1 && type2 && type1 !== type2) {
-        throw new convertOpenApi_1.ImpossibleSchemaError(path, "mismatched type in composition: \"".concat(type1, "\" \"").concat(type2, "\""));
+        throw new ImpossibleSchemaError(path, "mismatched type in composition: \"".concat(type1, "\" \"").concat(type2, "\""));
     }
     for (var _i = 0, _c = [schema1, schema2]; _i < _c.length; _i++) {
         var schema = _c[_i];
@@ -231,7 +224,7 @@ var combineTopLevelSchemas = function (path, schema1, schema2) {
         title: takeLast(schema1, schema2, 'title'),
         description: takeLast(schema1, schema2, 'description'),
         format: takeLast(schema1, schema2, 'format'),
-        multipleOf: combine(schema1, schema2, 'multipleOf', lcm_1.default),
+        multipleOf: combine(schema1, schema2, 'multipleOf', lcm),
         maximum: combine(schema1, schema2, 'maximum', Math.min),
         minimum: combine(schema1, schema2, 'minimum', Math.max),
         maxLength: combine(schema1, schema2, 'maxLength', Math.min),
@@ -299,19 +292,16 @@ var combineTopLevelSchemas = function (path, schema1, schema2) {
     }
     return __assign({ type: type }, combinedSchema);
 };
-exports.combineTopLevelSchemas = combineTopLevelSchemas;
-var addKeyIfDefined = function (key, value, destination) {
+export var addKeyIfDefined = function (key, value, destination) {
     if (value !== undefined) {
         destination[key] = value;
     }
 };
-exports.addKeyIfDefined = addKeyIfDefined;
-var copyKeyIfDefined = function (key, source, destination) {
+export var copyKeyIfDefined = function (key, source, destination) {
     if (source[key] !== undefined) {
         destination[key] = source[key];
     }
 };
-exports.copyKeyIfDefined = copyKeyIfDefined;
 var takeLast = function (schema1, schema2, key) {
     var _a;
     return (_a = schema2[key]) !== null && _a !== void 0 ? _a : schema1[key];
@@ -324,16 +314,16 @@ var combine = function (schema1, schema2, key, transform) {
 };
 var convertSchemaRecursive = function (path, schema, required) {
     if (schema.oneOf === undefined || schema.oneOf.length === 0) {
-        throw new convertOpenApi_1.ConversionError(path, 'missing schema definition');
+        throw new ConversionError(path, 'missing schema definition');
     }
     var schemaArray = schema.oneOf.map(function (schema) {
         var sharedProps = {};
-        (0, exports.addKeyIfDefined)('required', required, sharedProps);
-        (0, exports.copyKeyIfDefined)('title', schema, sharedProps);
-        (0, exports.copyKeyIfDefined)('description', schema, sharedProps);
-        (0, exports.copyKeyIfDefined)('readOnly', schema, sharedProps);
-        (0, exports.copyKeyIfDefined)('writeOnly', schema, sharedProps);
-        (0, exports.copyKeyIfDefined)('deprecated', schema, sharedProps);
+        addKeyIfDefined('required', required, sharedProps);
+        copyKeyIfDefined('title', schema, sharedProps);
+        copyKeyIfDefined('description', schema, sharedProps);
+        copyKeyIfDefined('readOnly', schema, sharedProps);
+        copyKeyIfDefined('writeOnly', schema, sharedProps);
+        copyKeyIfDefined('deprecated', schema, sharedProps);
         if (schema.type === undefined) {
             var inferredType = inferType(schema);
             if (inferredType === undefined) {
@@ -342,80 +332,80 @@ var convertSchemaRecursive = function (path, schema, required) {
             schema.type = inferredType;
         }
         var type = schema.type;
-        if (!endpoint_1.typeList.includes(type)) {
-            throw new convertOpenApi_1.InvalidSchemaError(path, "invalid schema type: ".concat(schema.type));
+        if (!typeList.includes(type)) {
+            throw new InvalidSchemaError(path, "invalid schema type: ".concat(schema.type));
         }
         switch (schema.type) {
             case 'boolean':
                 var booleanProps = sharedProps;
-                (0, exports.copyKeyIfDefined)('default', schema, booleanProps);
-                (0, exports.copyKeyIfDefined)('example', schema, booleanProps);
+                copyKeyIfDefined('default', schema, booleanProps);
+                copyKeyIfDefined('example', schema, booleanProps);
                 return __assign({ type: schema.type }, booleanProps);
             case 'number':
             case 'integer':
                 if (schema.enum) {
                     var numberEnumProps = sharedProps;
-                    (0, exports.copyKeyIfDefined)('default', schema, numberEnumProps);
-                    (0, exports.copyKeyIfDefined)('example', schema, numberEnumProps);
+                    copyKeyIfDefined('default', schema, numberEnumProps);
+                    copyKeyIfDefined('example', schema, numberEnumProps);
                     return __assign({ type: schema.type === 'number' ? 'numberEnum' : 'integerEnum', enum: schema.enum }, numberEnumProps);
                 }
                 var numberProps = sharedProps;
-                (0, exports.copyKeyIfDefined)('multipleOf', schema, numberProps);
-                (0, exports.copyKeyIfDefined)('maximum', schema, numberProps);
-                (0, exports.copyKeyIfDefined)('exclusiveMaximum', schema, numberProps);
-                (0, exports.copyKeyIfDefined)('minimum', schema, numberProps);
-                (0, exports.copyKeyIfDefined)('exclusiveMinimum', schema, numberProps);
-                (0, exports.copyKeyIfDefined)('default', schema, numberProps);
-                (0, exports.copyKeyIfDefined)('example', schema, numberProps);
+                copyKeyIfDefined('multipleOf', schema, numberProps);
+                copyKeyIfDefined('maximum', schema, numberProps);
+                copyKeyIfDefined('exclusiveMaximum', schema, numberProps);
+                copyKeyIfDefined('minimum', schema, numberProps);
+                copyKeyIfDefined('exclusiveMinimum', schema, numberProps);
+                copyKeyIfDefined('default', schema, numberProps);
+                copyKeyIfDefined('example', schema, numberProps);
                 return __assign({ type: schema.type }, numberProps);
             case 'string':
                 if (schema.enum) {
                     var stringEnumProps = sharedProps;
-                    (0, exports.copyKeyIfDefined)('default', schema, stringEnumProps);
-                    (0, exports.copyKeyIfDefined)('example', schema, stringEnumProps);
+                    copyKeyIfDefined('default', schema, stringEnumProps);
+                    copyKeyIfDefined('example', schema, stringEnumProps);
                     return __assign({ type: 'stringEnum', enum: schema.enum }, stringEnumProps);
                 }
                 var stringProps = sharedProps;
-                (0, exports.copyKeyIfDefined)('format', schema, stringProps);
-                (0, exports.copyKeyIfDefined)('pattern', schema, stringProps);
-                (0, exports.copyKeyIfDefined)('maxLength', schema, stringProps);
-                (0, exports.copyKeyIfDefined)('minLength', schema, stringProps);
-                (0, exports.copyKeyIfDefined)('default', schema, stringProps);
-                (0, exports.copyKeyIfDefined)('example', schema, stringProps);
+                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);
             case 'array':
                 var arrayProps = sharedProps;
-                (0, exports.copyKeyIfDefined)('maxItems', schema, arrayProps);
-                (0, exports.copyKeyIfDefined)('minItems', schema, arrayProps);
-                (0, exports.copyKeyIfDefined)('uniqueItems', schema, arrayProps);
-                (0, exports.copyKeyIfDefined)('default', schema, arrayProps);
-                (0, exports.copyKeyIfDefined)('example', schema, arrayProps);
+                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);
             case 'object':
-                var properties = (0, exports.convertProperties)(__spreadArray(__spreadArray([], path, true), ['properties'], false), schema.properties, schema.required);
+                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)
                     : schema.additionalProperties;
                 var objectProperties = sharedProps;
-                (0, exports.addKeyIfDefined)('additionalProperties', additionalProperties, objectProperties);
-                (0, exports.copyKeyIfDefined)('maxProperties', schema, objectProperties);
-                (0, exports.copyKeyIfDefined)('minProperties', schema, objectProperties);
-                (0, exports.copyKeyIfDefined)('default', schema, objectProperties);
-                (0, exports.copyKeyIfDefined)('example', schema, objectProperties);
+                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);
             case 'null':
                 var nullProps = sharedProps;
-                (0, exports.copyKeyIfDefined)('default', schema, nullProps);
-                (0, exports.copyKeyIfDefined)('example', schema, nullProps);
+                copyKeyIfDefined('default', schema, nullProps);
+                copyKeyIfDefined('example', schema, nullProps);
                 return __assign({ type: schema.type }, nullProps);
             default:
-                throw new convertOpenApi_1.ImpossibleSchemaError(path, "impossible type reached: ".concat(schema.type));
+                throw new ImpossibleSchemaError(path, "impossible type reached: ".concat(schema.type));
         }
     });
     // must unpack first element to satisfy type
     return __spreadArray([schemaArray[0]], schemaArray.slice(1), true);
 };
-var convertProperties = function (path, properties, required) {
+export var convertProperties = function (path, properties, required) {
     if (properties === undefined) {
         return {};
     }
@@ -428,7 +418,6 @@ var convertProperties = function (path, properties, required) {
     });
     return Object.fromEntries(newEntries);
 };
-exports.convertProperties = convertProperties;
 /**
  * Given an OpenAPI 3.1 schema, this function will attempt to determine the schema type
  * based on the properties present in the schema. This is useful for assigning types to

package/dist/openapi/convertSecurity.d.ts

@@ -1,5 +1,5 @@
 import { OpenAPIV3_1 } from 'openapi-types';
-import { SecurityOption } from './types/endpoint';
+import { SecurityOption } from './types/endpoint.js';
 type ConvertSecurityParams = {
     securityRequirements?: OpenAPIV3_1.SecurityRequirementObject[];
     securitySchemes: OpenAPIV3_1.ComponentsObject['securitySchemes'];

package/dist/openapi/convertSecurity.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addSecurityParameters = exports.convertSecurity = void 0;
-var convertOpenApi_1 = require("./convertOpenApi");
-var convertSecurity = function (_a) {
+import { InvalidSchemaError } from './convertOpenApi.js';
+export var convertSecurity = function (_a) {
     var securityRequirements = _a.securityRequirements, securitySchemes = _a.securitySchemes;
     if (securityRequirements === undefined || securityRequirements.length === 0) {
         return [];
     }
     if (securitySchemes === undefined) {
-        throw new convertOpenApi_1.InvalidSchemaError(['#', 'components'], 'securitySchemes not defined');
+        throw new InvalidSchemaError(['#', 'components'], 'securitySchemes not defined');
     }
     // TODO(ronan): make this work for camel-case as well
     return securityRequirements.map(function (security) {
@@ -24,9 +21,9 @@ var convertSecurity = function (_a) {
         Object.keys(security).forEach(function (securityName) {
             var securityScheme = securitySchemes === null || securitySchemes === void 0 ? void 0 : securitySchemes[securityName];
             if (securityScheme === undefined) {
-                throw new convertOpenApi_1.InvalidSchemaError(['#', 'components', 'securitySchemes'], "security scheme not defined: '".concat(securityName, "'"));
+                throw new InvalidSchemaError(['#', 'components', 'securitySchemes'], "security scheme not defined: '".concat(securityName, "'"));
             }
-            (0, exports.addSecurityParameters)({
+            addSecurityParameters({
                 securityName: securityName,
                 securityScheme: securityScheme,
                 parameterSections: parameterSections,
@@ -35,14 +32,13 @@ var convertSecurity = function (_a) {
         return parameterSections;
     });
 };
-exports.convertSecurity = convertSecurity;
-var addSecurityParameters = function (_a) {
+export var addSecurityParameters = function (_a) {
     var _b, _c;
     var securityName = _a.securityName, securityScheme = _a.securityScheme, parameterSections = _a.parameterSections;
     switch (securityScheme.type) {
         case 'apiKey':
             if (!['header', 'query', 'cookie'].includes(securityScheme.in)) {
-                throw new convertOpenApi_1.InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], "invalid security scheme location provided: '".concat(securityScheme.in, "'"));
+                throw new InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], "invalid security scheme location provided: '".concat(securityScheme.in, "'"));
             }
             var paramGroup = securityScheme.in;
             parameterSections[paramGroup][securityScheme.name] = {
@@ -76,7 +72,7 @@ var addSecurityParameters = function (_a) {
                 };
             }
             else {
-                throw new convertOpenApi_1.InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], "encountered unknown HTTP security scheme: '".concat(securityScheme.scheme, "'"));
+                throw new InvalidSchemaError(['#', 'components', 'securitySchemes', securityName], "encountered unknown HTTP security scheme: '".concat(securityScheme.scheme, "'"));
             }
             return;
         case 'oauth2':
@@ -84,4 +80,3 @@ var addSecurityParameters = function (_a) {
             return;
     }
 };
-exports.addSecurityParameters = addSecurityParameters;

package/dist/openapi/convertServers.d.ts

@@ -1,5 +1,5 @@
 import { OpenAPIV3_1 } from 'openapi-types';
-import { Server } from './types/endpoint';
+import { Server } from './types/endpoint.js';
 type ConvertServersParams = {
     servers?: OpenAPIV3_1.ServerObject[];
 };

package/dist/openapi/convertServers.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertServers = void 0;
-var convertServers = function (_a) {
+export var convertServers = function (_a) {
     var servers = _a.servers;
     if (servers === undefined || servers.length === 0) {
         return undefined;
@@ -15,7 +12,6 @@ var convertServers = function (_a) {
         };
     });
 };
-exports.convertServers = convertServers;
 var convertVariables = function (_a) {
     var variables = _a.variables;
     if (variables === undefined || Object.keys(variables).length === 0) {

package/dist/openapi/types/endpoint.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeList = void 0;
-exports.typeList = [
+export var typeList = [
     'boolean',
     'string',
     'number',