@redocly/openapi-core 1.0.0-beta.110 → 1.0.0-beta.112

package/lib/rules/common/assertions/utils.js

@@ -1,122 +1,154 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.regexFromString = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = void 0;
+exports.regexFromString = exports.isOrdered = exports.getIntersectionLength = exports.buildSubjectVisitor = exports.buildVisitorObject = exports.getAssertsToApply = void 0;
+const asserts_1 = require("./asserts");
 const logger_1 = require("../../../logger");
 const ref_utils_1 = require("../../../ref-utils");
-const asserts_1 = require("./asserts");
-function buildVisitorObject(subject, context, subjectVisitor) {
-    if (!context) {
-        return { [subject]: subjectVisitor };
+const utils_1 = require("../../../utils");
+const assertionMessageTemplates = {
+    problems: '{{problems}}',
+};
+function getPredicatesFromLocators(locators) {
+    const { filterInParentKeys, filterOutParentKeys, matchParentKeys } = locators;
+    const keyMatcher = matchParentKeys && regexFromString(matchParentKeys);
+    const matchKeysPredicate = keyMatcher && ((key) => keyMatcher.test(key.toString()));
+    const filterInPredicate = Array.isArray(filterInParentKeys) &&
+        ((key) => filterInParentKeys.includes(key.toString()));
+    const filterOutPredicate = Array.isArray(filterOutParentKeys) &&
+        ((key) => !filterOutParentKeys.includes(key.toString()));
+    return [matchKeysPredicate, filterInPredicate, filterOutPredicate].filter(utils_1.isTruthy);
+}
+function getAssertsToApply(assertion) {
+    const assertsToApply = utils_1.keysOf(asserts_1.asserts)
+        .filter((assertName) => assertion.assertions[assertName] !== undefined)
+        .map((assertName) => {
+        return {
+            name: assertName,
+            conditions: assertion.assertions[assertName],
+            runsOnKeys: asserts_1.runOnKeysSet.has(assertName),
+            runsOnValues: asserts_1.runOnValuesSet.has(assertName),
+        };
+    });
+    const shouldRunOnKeys = assertsToApply.find((assert) => assert.runsOnKeys && !assert.runsOnValues);
+    const shouldRunOnValues = assertsToApply.find((assert) => assert.runsOnValues && !assert.runsOnKeys);
+    if (shouldRunOnValues && !assertion.subject.property) {
+        throw new Error(`${shouldRunOnValues.name} can't be used on all keys. Please provide a single property`);
+    }
+    if (shouldRunOnKeys && assertion.subject.property) {
+        throw new Error(`${shouldRunOnKeys.name} can't be used on a single property. Please use 'property'.`);
+    }
+    return assertsToApply;
+}
+exports.getAssertsToApply = getAssertsToApply;
+function getAssertionProperties({ subject }) {
+    return (Array.isArray(subject.property) ? subject.property : [subject === null || subject === void 0 ? void 0 : subject.property]).filter(Boolean);
+}
+function applyAssertions(assertionDefinition, asserts, { rawLocation, rawNode, resolve, location, node }) {
+    var _a;
+    const properties = getAssertionProperties(assertionDefinition);
+    const assertResults = [];
+    for (const assert of asserts) {
+        const currentLocation = assert.name === 'ref' ? rawLocation : location;
+        if (properties.length) {
+            for (const property of properties) {
+                // we can have resolvable scalar so need to resolve value here.
+                const value = ref_utils_1.isRef(node[property]) ? (_a = resolve(node[property])) === null || _a === void 0 ? void 0 : _a.node : node[property];
+                assertResults.push(runAssertion({
+                    values: value,
+                    rawValues: rawNode[property],
+                    assert,
+                    location: currentLocation.child(property),
+                }));
+            }
+        }
+        else {
+            const value = assert.name === 'ref' ? rawNode : Object.keys(node);
+            assertResults.push(runAssertion({
+                values: Object.keys(node),
+                rawValues: value,
+                assert,
+                location: currentLocation,
+            }));
+        }
+    }
+    return assertResults.flat();
+}
+function buildVisitorObject(assertion, subjectVisitor) {
+    var _a, _b;
+    const targetVisitorLocatorPredicates = getPredicatesFromLocators(assertion.subject);
+    const targetVisitorSkipFunction = targetVisitorLocatorPredicates.length
+        ? (node, key) => !targetVisitorLocatorPredicates.every((predicate) => predicate(key))
+        : undefined;
+    const targetVisitor = {
+        [assertion.subject.type]: Object.assign({ enter: subjectVisitor }, (targetVisitorSkipFunction && { skip: targetVisitorSkipFunction })),
+    };
+    if (!Array.isArray(assertion.where)) {
+        return targetVisitor;
     }
     let currentVisitorLevel = {};
     const visitor = currentVisitorLevel;
+    const context = assertion.where;
     for (let index = 0; index < context.length; index++) {
-        const node = context[index];
-        if (context.length === index + 1 && node.type === subject) {
-            // Visitors don't work properly for the same type nested nodes, so
-            // as a workaround for that we don't create separate visitor for the last element
-            // which is the same as subject;
-            // we will check includes/excludes it in the last visitor.
-            continue;
+        const assertionDefinitionNode = context[index];
+        if (!utils_1.isString((_a = assertionDefinitionNode.subject) === null || _a === void 0 ? void 0 : _a.type)) {
+            throw new Error(`${assertion.assertionId} -> where -> [${index}]: 'type' (String) is required`);
         }
-        const matchParentKeys = node.matchParentKeys;
-        const excludeParentKeys = node.excludeParentKeys;
-        if (matchParentKeys && excludeParentKeys) {
-            throw new Error(`Both 'matchParentKeys' and 'excludeParentKeys' can't be under one context item`);
-        }
-        if (matchParentKeys || excludeParentKeys) {
-            currentVisitorLevel[node.type] = {
-                skip: (_value, key) => {
-                    if (matchParentKeys) {
-                        return !matchParentKeys.includes(key);
-                    }
-                    if (excludeParentKeys) {
-                        return excludeParentKeys.includes(key);
-                    }
-                },
-            };
+        const locatorPredicates = getPredicatesFromLocators(assertionDefinitionNode.subject);
+        const assertsToApply = getAssertsToApply(assertionDefinitionNode);
+        const skipFunction = (node, key, { location, rawLocation, resolve, rawNode }) => !locatorPredicates.every((predicate) => predicate(key)) ||
+            !!applyAssertions(assertionDefinitionNode, assertsToApply, {
+                location,
+                node,
+                rawLocation,
+                rawNode,
+                resolve,
+            }).length;
+        const nodeVisitor = Object.assign({}, ((locatorPredicates.length || assertsToApply.length) && { skip: skipFunction }));
+        if (assertionDefinitionNode.subject.type === assertion.subject.type &&
+            index === context.length - 1) {
+            // We have to merge the visitors if the last node inside the `where` is the same as the subject.
+            targetVisitor[assertion.subject.type] = Object.assign({ enter: subjectVisitor }, ((nodeVisitor.skip && { skip: nodeVisitor.skip }) ||
+                (targetVisitorSkipFunction && {
+                    skip: (node, key, ctx // We may have locators defined on assertion level and on where level for the same node type
+                    ) => { var _a; return !!(((_a = nodeVisitor.skip) === null || _a === void 0 ? void 0 : _a.call(nodeVisitor, node, key, ctx)) || (targetVisitorSkipFunction === null || targetVisitorSkipFunction === void 0 ? void 0 : targetVisitorSkipFunction(node, key))); },
+                })));
         }
         else {
-            currentVisitorLevel[node.type] = {};
+            currentVisitorLevel = currentVisitorLevel[(_b = assertionDefinitionNode.subject) === null || _b === void 0 ? void 0 : _b.type] =
+                nodeVisitor;
         }
-        currentVisitorLevel = currentVisitorLevel[node.type];
     }
-    currentVisitorLevel[subject] = subjectVisitor;
+    currentVisitorLevel[assertion.subject.type] = targetVisitor[assertion.subject.type];
     return visitor;
 }
 exports.buildVisitorObject = buildVisitorObject;
-function buildSubjectVisitor(assertId, assertion, asserts) {
-    return (node, { report, location, rawLocation, key, type, resolve, rawNode }) => {
-        var _a;
-        let properties = assertion.property;
-        // We need to check context's last node if it has the same type as subject node;
-        // if yes - that means we didn't create context's last node visitor,
-        // so we need to handle 'matchParentKeys' and 'excludeParentKeys' conditions here;
-        if (assertion.context) {
-            const lastContextNode = assertion.context[assertion.context.length - 1];
-            if (lastContextNode.type === type.name) {
-                const matchParentKeys = lastContextNode.matchParentKeys;
-                const excludeParentKeys = lastContextNode.excludeParentKeys;
-                if (matchParentKeys && !matchParentKeys.includes(key)) {
-                    return;
-                }
-                if (excludeParentKeys && excludeParentKeys.includes(key)) {
-                    return;
-                }
-            }
-        }
-        if (properties) {
-            properties = Array.isArray(properties) ? properties : [properties];
-        }
-        const defaultMessage = `${logger_1.colorize.blue(assertId)} failed because the ${logger_1.colorize.blue(assertion.subject)}${logger_1.colorize.blue(properties ? ` ${properties.join(', ')}` : '')} didn't meet the assertions: {{problems}}`;
-        const assertResults = [];
-        for (const assert of asserts) {
-            const currentLocation = assert.name === 'ref' ? rawLocation : location;
-            if (properties) {
-                for (const property of properties) {
-                    // we can have resolvable scalar so need to resolve value here.
-                    const value = ref_utils_1.isRef(node[property]) ? (_a = resolve(node[property])) === null || _a === void 0 ? void 0 : _a.node : node[property];
-                    assertResults.push(runAssertion({
-                        values: value,
-                        rawValues: rawNode[property],
-                        assert,
-                        location: currentLocation.child(property),
-                    }));
-                }
-            }
-            else {
-                const value = assert.name === 'ref' ? rawNode : Object.keys(node);
-                assertResults.push(runAssertion({
-                    values: Object.keys(node),
-                    rawValues: value,
-                    assert,
-                    location: currentLocation,
-                }));
-            }
-        }
-        const problems = assertResults.flat();
+function buildSubjectVisitor(assertId, assertion) {
+    return (node, { report, location, rawLocation, resolve, rawNode }) => {
+        const properties = getAssertionProperties(assertion);
+        const defaultMessage = `${logger_1.colorize.blue(assertId)} failed because the ${logger_1.colorize.blue(assertion.subject.type)} ${logger_1.colorize.blue(properties.join(', '))} didn't meet the assertions: ${assertionMessageTemplates.problems}`.replace(/ +/g, ' ');
+        const problems = applyAssertions(assertion, getAssertsToApply(assertion), {
+            rawLocation,
+            rawNode,
+            resolve,
+            location,
+            node,
+        });
         if (problems.length) {
             const message = assertion.message || defaultMessage;
-            report({
-                message: message.replace('{{problems}}', getProblemsMessage(problems)),
-                location: getProblemsLocation(problems) || location,
-                forceSeverity: assertion.severity || 'error',
-                suggest: assertion.suggest || [],
-                ruleId: assertId,
-            });
+            for (const problem of problems) {
+                const problemMessage = problem.message ? problem.message : defaultMessage;
+                report({
+                    message: message.replace(assertionMessageTemplates.problems, problemMessage),
+                    location: problem.location || location,
+                    forceSeverity: assertion.severity || 'error',
+                    suggest: assertion.suggest || [],
+                    ruleId: assertId,
+                });
+            }
         }
     };
 }
 exports.buildSubjectVisitor = buildSubjectVisitor;
-function getProblemsLocation(problems) {
-    return problems.length ? problems[0].location : undefined;
-}
-function getProblemsMessage(problems) {
-    var _a;
-    return problems.length === 1
-        ? (_a = problems[0].message) !== null && _a !== void 0 ? _a : ''
-        : problems.map((problem) => { var _a; return `\n- ${(_a = problem.message) !== null && _a !== void 0 ? _a : ''}`; }).join('');
-}
 function getIntersectionLength(keys, properties) {
     const props = new Set(properties);
     let count = 0;

package/lib/rules/common/no-ambiguous-paths.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoAmbiguousPaths = void 0;
 const NoAmbiguousPaths = () => {
     return {
-        PathsMap(pathMap, { report, location }) {
+        Paths(pathMap, { report, location }) {
             const seenPaths = [];
             for (const currentPath of Object.keys(pathMap)) {
                 const ambiguousPath = seenPaths.find((seenPath) => arePathsAmbiguous(seenPath, currentPath));

package/lib/rules/common/no-identical-paths.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NoIdenticalPaths = void 0;
 const NoIdenticalPaths = () => {
     return {
-        PathsMap(pathMap, { report, location }) {
-            const pathsMap = new Map();
+        Paths(pathMap, { report, location }) {
+            const Paths = new Map();
             for (const pathName of Object.keys(pathMap)) {
                 const id = pathName.replace(/{.+?}/g, '{VARIABLE}');
-                const existingSamePath = pathsMap.get(id);
+                const existingSamePath = Paths.get(id);
                 if (existingSamePath) {
                     report({
                         message: `The path already exists which differs only by path parameter name(s): \`${existingSamePath}\` and \`${pathName}\`.`,
@@ -15,7 +15,7 @@ const NoIdenticalPaths = () => {
                     });
                 }
                 else {
-                    pathsMap.set(id, pathName);
+                    Paths.set(id, pathName);
                 }
             }
         },

package/lib/rules/common/operation-2xx-response.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Operation2xxResponse = void 0;
 const Operation2xxResponse = () => {
     return {
-        ResponsesMap(responses, { report }) {
-            const codes = Object.keys(responses);
+        Responses(responses, { report }) {
+            const codes = Object.keys(responses || {});
             if (!codes.some((code) => code === 'default' || /2[Xx0-9]{2}/.test(code))) {
                 report({
                     message: 'Operation must have at least one `2XX` response.',

package/lib/rules/common/operation-4xx-response.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Operation4xxResponse = void 0;
 const Operation4xxResponse = () => {
     return {
-        ResponsesMap(responses, { report }) {
-            const codes = Object.keys(responses);
+        Responses(responses, { report }) {
+            const codes = Object.keys(responses || {});
             if (!codes.some((code) => /4[Xx0-9]{2}/.test(code))) {
                 report({
                     message: 'Operation must have at least one `4XX` response.',

package/lib/rules/common/path-not-include-query.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathNotIncludeQuery = void 0;
 const PathNotIncludeQuery = () => {
     return {
-        PathsMap: {
+        Paths: {
             PathItem(_operation, { report, key }) {
                 if (key.toString().includes('?')) {
                     report({

package/lib/rules/common/path-params-defined.js

@@ -6,6 +6,7 @@ const PathParamsDefined = () => {
     let pathTemplateParams;
     let definedPathParams;
     let currentPath;
+    let definedOperationParams;
     return {
         PathItem: {
             enter(_, { key }) {
@@ -25,9 +26,13 @@ const PathParamsDefined = () => {
                 }
             },
             Operation: {
+                enter() {
+                    definedOperationParams = new Set();
+                },
                 leave(_op, { report, location }) {
                     for (const templateParam of Array.from(pathTemplateParams.keys())) {
-                        if (!definedPathParams.has(templateParam)) {
+                        if (!definedOperationParams.has(templateParam) &&
+                            !definedPathParams.has(templateParam)) {
                             report({
                                 message: `The operation does not define the path parameter \`{${templateParam}}\` expected by path \`${currentPath}\`.`,
                                 location: location.child(['parameters']).key(), // report on operation
@@ -37,7 +42,7 @@ const PathParamsDefined = () => {
                 },
                 Parameter(parameter, { report, location }) {
                     if (parameter.in === 'path' && parameter.name) {
-                        definedPathParams.add(parameter.name);
+                        definedOperationParams.add(parameter.name);
                         if (!pathTemplateParams.has(parameter.name)) {
                             report({
                                 message: `Path parameter \`${parameter.name}\` is not used in the path \`${currentPath}\`.`,

package/lib/rules/common/response-contains-header.js

@@ -8,13 +8,13 @@ const ResponseContainsHeader = (options) => {
         Operation: {
             Response: {
                 enter: (response, { report, location, key }) => {
-                    var _a;
                     const expectedHeaders = names[key] ||
                         names[utils_1.getMatchingStatusCodeRange(key)] ||
                         names[utils_1.getMatchingStatusCodeRange(key).toLowerCase()] ||
                         [];
                     for (const expectedHeader of expectedHeaders) {
-                        if (!((_a = response.headers) === null || _a === void 0 ? void 0 : _a[expectedHeader])) {
+                        if (!(response === null || response === void 0 ? void 0 : response.headers) ||
+                            !Object.keys(response === null || response === void 0 ? void 0 : response.headers).some((header) => header.toLowerCase() === expectedHeader.toLowerCase())) {
                             report({
                                 message: `Response object must contain a "${expectedHeader}" header.`,
                                 location: location.child('headers').key(),

package/lib/rules/common/security-defined.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecurityDefined = void 0;
 const SecurityDefined = () => {
     const referencedSchemes = new Map();
+    const operationsWithoutSecurity = [];
     let eachOperationHasSecurity = true;
     return {
-        DefinitionRoot: {
+        Root: {
             leave(root, { report }) {
                 for (const [name, scheme] of referencedSchemes.entries()) {
                     if (scheme.defined)
@@ -21,9 +22,12 @@ const SecurityDefined = () => {
                     return;
                 }
                 else {
-                    report({
-                        message: `Every API should have security defined on the root level or for each operation.`,
-                    });
+                    for (const operationLocation of operationsWithoutSecurity) {
+                        report({
+                            message: `Every operation should have security defined on it or on the root level.`,
+                            location: operationLocation.key(),
+                        });
+                    }
                 }
             },
         },
@@ -42,9 +46,10 @@ const SecurityDefined = () => {
                 }
             }
         },
-        Operation(operation) {
+        Operation(operation, { location }) {
             if (!(operation === null || operation === void 0 ? void 0 : operation.security)) {
                 eachOperationHasSecurity = false;
+                operationsWithoutSecurity.push(location);
             }
         },
     };

package/lib/rules/common/spec.js

@@ -8,7 +8,7 @@ const utils_2 = require("../../utils");
 const OasSpec = () => {
     return {
         any(node, { report, type, location, rawLocation, key, resolve, ignoreNextVisitorsOnNode }) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e, _f;
             const nodeType = utils_1.oasTypeOf(node);
             const refLocation = rawLocation !== location ? rawLocation : undefined;
             if (type.items) {
@@ -99,18 +99,20 @@ const OasSpec = () => {
                 if (propSchema.resolvable !== false && ref_utils_1.isRef(propValue)) {
                     propValue = resolve(propValue).node;
                 }
-                if (propSchema.enum) {
-                    if (!propSchema.enum.includes(propValue)) {
-                        report({
-                            location: propLocation,
-                            message: `\`${propName}\` can be one of the following only: ${propSchema.enum
-                                .map((i) => `"${i}"`)
-                                .join(', ')}.`,
-                            from: refLocation,
-                            suggest: utils_1.getSuggest(propValue, propSchema.enum),
+                if (propSchema.items && ((_c = propSchema.items) === null || _c === void 0 ? void 0 : _c.enum) && Array.isArray(propValue)) {
+                    for (let i = 0; i < propValue.length; i++) {
+                        utils_1.validateSchemaEnumType((_d = propSchema.items) === null || _d === void 0 ? void 0 : _d.enum, propValue[i], propName, refLocation, {
+                            report,
+                            location: location.child([propName, i]),
                         });
                     }
                 }
+                if (propSchema.enum) {
+                    utils_1.validateSchemaEnumType(propSchema.enum, propValue, propName, refLocation, {
+                        report,
+                        location: location.child([propName]),
+                    });
+                }
                 else if (propSchema.type && !utils_1.matchesJsonSchemaType(propValue, propSchema.type, false)) {
                     report({
                         message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
@@ -118,8 +120,8 @@ const OasSpec = () => {
                         location: propLocation,
                     });
                 }
-                else if (propValueType === 'array' && ((_c = propSchema.items) === null || _c === void 0 ? void 0 : _c.type)) {
-                    const itemsType = (_d = propSchema.items) === null || _d === void 0 ? void 0 : _d.type;
+                else if (propValueType === 'array' && ((_e = propSchema.items) === null || _e === void 0 ? void 0 : _e.type)) {
+                    const itemsType = (_f = propSchema.items) === null || _f === void 0 ? void 0 : _f.type;
                     for (let i = 0; i < propValue.length; i++) {
                         const item = propValue[i];
                         if (!utils_1.matchesJsonSchemaType(item, itemsType, false)) {

package/lib/rules/oas2/index.d.ts

@@ -3,7 +3,6 @@ export declare const rules: {
     spec: Oas2Rule;
     'no-invalid-schema-examples': any;
     'no-invalid-parameter-examples': any;
-    'info-description': Oas2Rule;
     'info-contact': Oas2Rule;
     'info-license': Oas2Rule;
     'info-license-url': Oas2Rule;

package/lib/rules/oas2/index.js

@@ -4,7 +4,6 @@ exports.preprocessors = exports.rules = void 0;
 const spec_1 = require("../common/spec");
 const no_invalid_schema_examples_1 = require("../common/no-invalid-schema-examples");
 const no_invalid_parameter_examples_1 = require("../common/no-invalid-parameter-examples");
-const info_description_1 = require("../common/info-description");
 const info_contact_1 = require("../common/info-contact");
 const info_license_1 = require("../common/info-license");
 const info_license_url_1 = require("../common/info-license-url");
@@ -46,7 +45,6 @@ exports.rules = {
     spec: spec_1.OasSpec,
     'no-invalid-schema-examples': no_invalid_schema_examples_1.NoInvalidSchemaExamples,
     'no-invalid-parameter-examples': no_invalid_parameter_examples_1.NoInvalidParameterExamples,
-    'info-description': info_description_1.InfoDescription,
     'info-contact': info_contact_1.InfoContact,
     'info-license': info_license_1.InfoLicense,
     'info-license-url': info_license_url_1.InfoLicenseUrl,

package/lib/rules/oas3/index.js

@@ -17,7 +17,6 @@ const operation_operationId_url_safe_1 = require("../common/operation-operationI
 const tags_alphabetical_1 = require("../common/tags-alphabetical");
 const no_server_example_com_1 = require("./no-server-example.com");
 const no_server_trailing_slash_1 = require("./no-server-trailing-slash");
-const info_description_1 = require("../common/info-description");
 const tag_description_1 = require("../common/tag-description");
 const info_contact_1 = require("../common/info-contact");
 const info_license_1 = require("../common/info-license");
@@ -54,7 +53,6 @@ const spec_components_invalid_map_name_1 = require("./spec-components-invalid-ma
 const operation_4xx_problem_details_rfc7807_1 = require("./operation-4xx-problem-details-rfc7807");
 exports.rules = {
     spec: spec_1.OasSpec,
-    'info-description': info_description_1.InfoDescription,
     'info-contact': info_contact_1.InfoContact,
     'info-license': info_license_1.InfoLicense,
     'info-license-url': info_license_url_1.InfoLicenseUrl,

package/lib/rules/oas3/request-mime-type.js

@@ -4,7 +4,7 @@ exports.RequestMimeType = void 0;
 const utils_1 = require("../../utils");
 const RequestMimeType = ({ allowedValues }) => {
     return {
-        PathsMap: {
+        Paths: {
             RequestBody: {
                 leave(requestBody, ctx) {
                     utils_1.validateMimeTypeOAS3({ type: 'consumes', value: requestBody }, ctx, allowedValues);

package/lib/rules/oas3/response-mime-type.js

@@ -4,7 +4,7 @@ exports.ResponseMimeType = void 0;
 const utils_1 = require("../../utils");
 const ResponseMimeType = ({ allowedValues }) => {
     return {
-        PathsMap: {
+        Paths: {
             Response: {
                 leave(response, ctx) {
                     utils_1.validateMimeTypeOAS3({ type: 'produces', value: response }, ctx, allowedValues);

package/lib/rules/other/stats.d.ts

@@ -22,7 +22,7 @@ export declare const Stats: (statsAccumulator: StatsAccumulator) => {
             leave(operation: any): void;
         };
     };
-    PathsMap: {
+    Paths: {
         PathItem: {
             leave(): void;
             Operation: {

package/lib/rules/other/stats.js

@@ -40,7 +40,7 @@ const Stats = (statsAccumulator) => {
                 },
             },
         },
-        PathsMap: {
+        Paths: {
             PathItem: {
                 leave() {
                     statsAccumulator.pathItems.total++;

package/lib/rules/utils.d.ts

@@ -16,3 +16,4 @@ export declare function validateDefinedAndNonEmpty(fieldName: string, value: any
 export declare function getSuggest(given: string, variants: string[]): string[];
 export declare function validateExample(example: any, schema: Referenced<Oas3Schema>, dataLoc: Location, { resolve, location, report }: UserContext, allowAdditionalProperties: boolean): void;
 export declare function getAdditionalPropertiesOption(opts: Record<string, any>): boolean;
+export declare function validateSchemaEnumType(schemaEnum: string[], propertyValue: string, propName: string, refLocation: Location | undefined, { report, location }: UserContext): void;

package/lib/rules/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAdditionalPropertiesOption = exports.validateExample = exports.getSuggest = exports.validateDefinedAndNonEmpty = exports.fieldNonEmpty = exports.missingRequiredField = exports.matchesJsonSchemaType = exports.oasTypeOf = void 0;
+exports.validateSchemaEnumType = exports.getAdditionalPropertiesOption = exports.validateExample = exports.getSuggest = exports.validateDefinedAndNonEmpty = exports.fieldNonEmpty = exports.missingRequiredField = exports.matchesJsonSchemaType = exports.oasTypeOf = void 0;
 const levenshtein = require("js-levenshtein");
 const ref_utils_1 = require("../ref-utils");
 const ajv_1 = require("./ajv");
@@ -120,3 +120,19 @@ function getAdditionalPropertiesOption(opts) {
     return !opts.disallowAdditionalProperties;
 }
 exports.getAdditionalPropertiesOption = getAdditionalPropertiesOption;
+function validateSchemaEnumType(schemaEnum, propertyValue, propName, refLocation, { report, location }) {
+    if (!schemaEnum) {
+        return;
+    }
+    if (!schemaEnum.includes(propertyValue === null ? 'null' : propertyValue)) {
+        report({
+            location,
+            message: `\`${propName}\` can be one of the following only: ${schemaEnum
+                .map((type) => `"${type}"`)
+                .join(', ')}.`,
+            from: refLocation,
+            suggest: getSuggest(propertyValue, schemaEnum),
+        });
+    }
+}
+exports.validateSchemaEnumType = validateSchemaEnumType;

package/lib/types/oas2.js

@@ -12,7 +12,7 @@ const Root = {
         schemes: { type: 'array', items: { type: 'string' } },
         consumes: { type: 'array', items: { type: 'string' } },
         produces: { type: 'array', items: { type: 'string' } },
-        paths: 'PathsMap',
+        paths: 'Paths',
         definitions: 'NamedSchemas',
         parameters: 'NamedParameters',
         responses: 'NamedResponses',
@@ -48,7 +48,7 @@ const License = {
     },
     required: ['name'],
 };
-const PathsMap = {
+const Paths = {
     properties: {},
     additionalProperties: (_value, key) => key.startsWith('/') ? 'PathItem' : undefined,
 };
@@ -75,7 +75,7 @@ const Operation = {
         consumes: { type: 'array', items: { type: 'string' } },
         produces: { type: 'array', items: { type: 'string' } },
         parameters: _1.listOf('Parameter'),
-        responses: 'ResponsesMap',
+        responses: 'Responses',
         schemes: { type: 'array', items: { type: 'string' } },
         deprecated: { type: 'boolean' },
         security: _1.listOf('SecurityRequirement'),
@@ -171,7 +171,7 @@ const ParameterItems = {
         }
     },
 };
-const ResponsesMap = {
+const Responses = {
     properties: {
         default: 'Response',
     },
@@ -359,14 +359,14 @@ exports.Oas2Types = {
     Info,
     Contact,
     License,
-    PathsMap,
+    Paths,
     PathItem,
     Parameter,
     ParameterItems,
     Operation,
     Examples,
     Header,
-    ResponsesMap,
+    Responses,
     Response,
     Schema,
     Xml,