@redocly/openapi-core 1.0.0-beta.98 → 1.0.0-rc.1

package/lib/rules/common/operation-tag-defined.js

@@ -4,7 +4,7 @@ exports.OperationTagDefined = void 0;
 const OperationTagDefined = () => {
     let definedTags;
     return {
-        DefinitionRoot(root) {
+        Root(root) {
             var _a;
             definedTags = new Set(((_a = root.tags) !== null && _a !== void 0 ? _a : []).map((t) => t.name));
         },

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 {
-        PathMap: {
+        Paths: {
             PathItem(_operation, { report, key }) {
                 if (key.toString().includes('?')) {
                     report({
@@ -12,7 +12,7 @@ const PathNotIncludeQuery = () => {
                     });
                 }
             },
-        }
+        },
     };
 };
 exports.PathNotIncludeQuery = PathNotIncludeQuery;

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/paths-kebab-case.js

@@ -4,7 +4,10 @@ exports.PathsKebabCase = void 0;
 const PathsKebabCase = () => {
     return {
         PathItem(_path, { report, key }) {
-            const segments = key.substr(1).split('/').filter(s => s !== ''); // filter out empty segments
+            const segments = key
+                .substr(1)
+                .split('/')
+                .filter((s) => s !== ''); // filter out empty segments
             if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
                 report({
                     message: `\`${key}\` does not use kebab-case.`,

package/lib/rules/common/required-string-property-missing-min-length.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule } from 'core/src/visitors';
+export declare const RequiredStringPropertyMissingMinLength: Oas3Rule;

package/lib/rules/common/required-string-property-missing-min-length.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequiredStringPropertyMissingMinLength = void 0;
+const RequiredStringPropertyMissingMinLength = () => {
+    let skipSchemaProperties;
+    let requiredPropertiesSet;
+    return {
+        Schema: {
+            enter(schema) {
+                if (!(schema === null || schema === void 0 ? void 0 : schema.required)) {
+                    skipSchemaProperties = true;
+                    return;
+                }
+                requiredPropertiesSet = new Set(schema.required);
+                skipSchemaProperties = false;
+            },
+            SchemaProperties: {
+                skip() {
+                    return skipSchemaProperties;
+                },
+                Schema: {
+                    enter(schema, { key, location, report }) {
+                        if (requiredPropertiesSet.has(key) && schema.type === 'string') {
+                            if (!(schema === null || schema === void 0 ? void 0 : schema.minLength)) {
+                                report({
+                                    message: 'Property minLength is required.',
+                                    location: location.key(),
+                                });
+                            }
+                        }
+                    },
+                },
+            },
+        },
+    };
+};
+exports.RequiredStringPropertyMissingMinLength = RequiredStringPropertyMissingMinLength;

package/lib/rules/common/response-contains-header.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+export declare const ResponseContainsHeader: Oas3Rule | Oas2Rule;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseContainsHeader = void 0;
+const utils_1 = require("../../utils");
+const ResponseContainsHeader = (options) => {
+    const names = options.names || {};
+    return {
+        Operation: {
+            Response: {
+                enter: (response, { report, location, key }) => {
+                    const expectedHeaders = names[key] ||
+                        names[utils_1.getMatchingStatusCodeRange(key)] ||
+                        names[utils_1.getMatchingStatusCodeRange(key).toLowerCase()] ||
+                        [];
+                    for (const expectedHeader of expectedHeaders) {
+                        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(),
+                            });
+                        }
+                    }
+                },
+            },
+        },
+    };
+};
+exports.ResponseContainsHeader = ResponseContainsHeader;

package/lib/rules/common/scalar-property-missing-example.d.ts

@@ -0,0 +1,2 @@
+import type { Oas2Rule, Oas3Rule } from '../../visitors';
+export declare const ScalarPropertyMissingExample: Oas3Rule | Oas2Rule;

package/lib/rules/common/scalar-property-missing-example.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalarPropertyMissingExample = void 0;
+const oas_types_1 = require("../../oas-types");
+const SCALAR_TYPES = ['string', 'integer', 'number', 'boolean', 'null'];
+const ScalarPropertyMissingExample = () => {
+    return {
+        SchemaProperties(properties, { report, location, oasVersion, resolve }) {
+            for (const propName of Object.keys(properties)) {
+                const propSchema = resolve(properties[propName]).node;
+                if (!propSchema || !isScalarSchema(propSchema)) {
+                    continue;
+                }
+                if (propSchema.example === undefined &&
+                    propSchema.examples === undefined) {
+                    report({
+                        message: `Scalar property should have "example"${oasVersion === oas_types_1.OasVersion.Version3_1 ? ' or "examples"' : ''} defined.`,
+                        location: location.child(propName).key(),
+                    });
+                }
+            }
+        },
+    };
+};
+exports.ScalarPropertyMissingExample = ScalarPropertyMissingExample;
+function isScalarSchema(schema) {
+    if (!schema.type) {
+        return false;
+    }
+    if (schema.allOf || schema.anyOf || schema.oneOf) {
+        // Skip allOf/oneOf/anyOf as it's complicated to validate it right now.
+        // We need core support for checking contrstrains through those keywords.
+        return false;
+    }
+    if (schema.format === 'binary') {
+        return false;
+    }
+    if (Array.isArray(schema.type)) {
+        return schema.type.every((t) => SCALAR_TYPES.includes(t));
+    }
+    return SCALAR_TYPES.includes(schema.type);
+}

package/lib/rules/common/security-defined.d.ts

@@ -0,0 +1,2 @@
+import { Oas3Rule, Oas2Rule } from '../../visitors';
+export declare const SecurityDefined: Oas3Rule | Oas2Rule;

package/lib/rules/common/{operation-security-defined.js → security-defined.js}

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperationSecurityDefined = void 0;
-const OperationSecurityDefined = () => {
-    let referencedSchemes = new Map();
+exports.SecurityDefined = void 0;
+const SecurityDefined = () => {
+    const referencedSchemes = new Map();
+    const operationsWithoutSecurity = [];
+    let eachOperationHasSecurity = true;
     return {
-        DefinitionRoot: {
-            leave(_, { report }) {
+        Root: {
+            leave(root, { report }) {
                 for (const [name, scheme] of referencedSchemes.entries()) {
                     if (scheme.defined)
                         continue;
@@ -16,6 +18,17 @@ const OperationSecurityDefined = () => {
                         });
                     }
                 }
+                if (root.security || eachOperationHasSecurity) {
+                    return;
+                }
+                else {
+                    for (const operationLocation of operationsWithoutSecurity) {
+                        report({
+                            message: `Every operation should have security defined on it or on the root level.`,
+                            location: operationLocation.key(),
+                        });
+                    }
+                }
             },
         },
         SecurityScheme(_securityScheme, { key }) {
@@ -33,6 +46,12 @@ const OperationSecurityDefined = () => {
                 }
             }
         },
+        Operation(operation, { location }) {
+            if (!(operation === null || operation === void 0 ? void 0 : operation.security)) {
+                eachOperationHasSecurity = false;
+                operationsWithoutSecurity.push(location);
+            }
+        },
     };
 };
-exports.OperationSecurityDefined = OperationSecurityDefined;
+exports.SecurityDefined = SecurityDefined;

package/lib/rules/common/spec-strict-refs.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule, Oas3Rule } from '../../visitors';
+export declare const SpecStrictRefs: Oas3Rule | Oas2Rule;

package/lib/rules/common/spec-strict-refs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecStrictRefs = void 0;
+const ref_utils_1 = require("../../ref-utils");
+const SpecStrictRefs = () => {
+    const nodesToSkip = [
+        'Schema',
+        'Response',
+        'Parameter',
+        'RequestBody',
+        'Example',
+        'Header',
+        'SecurityScheme',
+        'Link',
+        'Callback',
+        'PathItem',
+    ];
+    return {
+        any(_node, { report, rawNode, rawLocation, type }) {
+            const shouldCheck = !nodesToSkip.includes(type.name);
+            if (shouldCheck && ref_utils_1.isRef(rawNode)) {
+                report({
+                    message: 'Field $ref is not expected here.',
+                    location: rawLocation.child('$ref').key(),
+                });
+            }
+        },
+    };
+};
+exports.SpecStrictRefs = SpecStrictRefs;

package/lib/rules/common/spec.js

@@ -7,30 +7,37 @@ const ref_utils_1 = require("../../ref-utils");
 const utils_2 = require("../../utils");
 const OasSpec = () => {
     return {
-        any(node, { report, type, location, key, resolve, ignoreNextVisitorsOnNode }) {
-            var _a, _b, _c, _d;
+        any(node, { report, type, location, rawLocation, key, resolve, ignoreNextVisitorsOnNode }) {
+            var _a, _b, _c, _d, _e, _f;
             const nodeType = utils_1.oasTypeOf(node);
+            const refLocation = rawLocation !== location ? rawLocation : undefined;
             if (type.items) {
                 if (nodeType !== 'array') {
                     report({
                         message: `Expected type \`${type.name}\` (array) but got \`${nodeType}\``,
+                        from: refLocation,
                     });
                     ignoreNextVisitorsOnNode();
                 }
                 return;
             }
             else if (nodeType !== 'object') {
-                report({
-                    message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
-                });
+                if (type !== types_1.SpecExtension) {
+                    // do not validate unknown extensions structure
+                    report({
+                        message: `Expected type \`${type.name}\` (object) but got \`${nodeType}\``,
+                        from: refLocation,
+                    });
+                }
                 ignoreNextVisitorsOnNode();
                 return;
             }
             const required = typeof type.required === 'function' ? type.required(node, key) : type.required;
-            for (let propName of required || []) {
+            for (const propName of required || []) {
                 if (!node.hasOwnProperty(propName)) {
                     report({
                         message: `The field \`${propName}\` must be present on this level.`,
+                        from: refLocation,
                         location: [{ reportOnKey: true }],
                     });
                 }
@@ -45,14 +52,15 @@ const OasSpec = () => {
                     }
                     report({
                         message: `The field \`${propName}\` is not allowed here.`,
-                        location: location.child([propName]).key()
+                        from: refLocation,
+                        location: location.child([propName]).key(),
                     });
                 }
             }
             const requiredOneOf = type.requiredOneOf || null;
             if (requiredOneOf) {
                 let hasProperty = false;
-                for (let propName of requiredOneOf || []) {
+                for (const propName of requiredOneOf || []) {
                     if (node.hasOwnProperty(propName)) {
                         hasProperty = true;
                     }
@@ -60,6 +68,7 @@ const OasSpec = () => {
                 if (!hasProperty)
                     report({
                         message: `Must contain at least one of the following fields: ${(_b = type.requiredOneOf) === null || _b === void 0 ? void 0 : _b.join(', ')}.`,
+                        from: refLocation,
                         location: [{ reportOnKey: true }],
                     });
             }
@@ -82,6 +91,7 @@ const OasSpec = () => {
                     report({
                         message: `Property \`${propName}\` is not expected here.`,
                         suggest: utils_1.getSuggest(propName, Object.keys(type.properties)),
+                        from: refLocation,
                         location: propLocation.key(),
                     });
                     continue;
@@ -92,30 +102,36 @@ 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(', ')}.`,
-                            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}\`.`,
+                        from: refLocation,
                         location: propLocation,
                     });
+                    ignoreNextVisitorsOnNode();
                 }
-                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)) {
                             report({
                                 message: `Expected type \`${itemsType}\` but got \`${utils_1.oasTypeOf(item)}\`.`,
+                                from: refLocation,
                                 location: propLocation.child([i]),
                             });
                         }
@@ -125,10 +141,17 @@ const OasSpec = () => {
                     if (propSchema.minimum > node[propName]) {
                         report({
                             message: `The value of the ${propName} field must be greater than or equal to ${propSchema.minimum}`,
+                            from: refLocation,
                             location: location.child([propName]),
                         });
                     }
                 }
+                if (propName === 'nullable' && !node.type) {
+                    report({
+                        message: 'The `type` field must be defined when the `nullable` field is used.',
+                        location: location.child([propName]),
+                    });
+                }
             }
         },
     };

package/lib/rules/common/tags-alphabetical.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TagsAlphabetical = void 0;
 const TagsAlphabetical = () => {
     return {
-        DefinitionRoot(root, { report, location }) {
+        Root(root, { report, location }) {
             if (!root.tags)
                 return;
             for (let i = 0; i < root.tags.length - 1; i++) {

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;
@@ -29,7 +28,7 @@ export declare const rules: {
     'path-params-defined': Oas2Rule;
     'parameter-description': Oas2Rule;
     'operation-singular-tag': Oas2Rule;
-    'operation-security-defined': Oas2Rule;
+    'security-defined': Oas2Rule;
     'no-unresolved-refs': Oas2Rule;
     'no-identical-paths': Oas2Rule;
     'no-ambiguous-paths': Oas2Rule;
@@ -39,5 +38,10 @@ export declare const rules: {
     'request-mime-type': Oas2Rule;
     'response-mime-type': Oas2Rule;
     'path-segment-plural': Oas2Rule;
+    'response-contains-header': Oas2Rule;
+    'response-contains-property': Oas2Rule;
+    'scalar-property-missing-example': import("../../visitors").Oas3Rule | Oas2Rule;
+    'required-string-property-missing-min-length': import("../../visitors").Oas3Rule;
+    'spec-strict-refs': import("../../visitors").Oas3Rule | Oas2Rule;
 };
 export declare const preprocessors: {};

package/lib/rules/oas2/index.js

@@ -4,10 +4,9 @@ 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");
-const license_url_1 = require("../common/license-url");
 const boolean_parameter_prefixes_1 = require("./boolean-parameter-prefixes");
 const tag_description_1 = require("../common/tag-description");
 const tags_alphabetical_1 = require("../common/tags-alphabetical");
@@ -27,7 +26,7 @@ const operation_description_1 = require("../common/operation-description");
 const path_not_include_query_1 = require("../common/path-not-include-query");
 const parameter_description_1 = require("../common/parameter-description");
 const operation_singular_tag_1 = require("../common/operation-singular-tag");
-const operation_security_defined_1 = require("../common/operation-security-defined");
+const security_defined_1 = require("../common/security-defined");
 const no_unresolved_refs_1 = require("../no-unresolved-refs");
 const path_http_verbs_order_1 = require("../common/path-http-verbs-order");
 const no_identical_paths_1 = require("../common/no-identical-paths");
@@ -39,14 +38,18 @@ const path_excludes_patterns_1 = require("../common/path-excludes-patterns");
 const request_mime_type_1 = require("./request-mime-type");
 const response_mime_type_1 = require("./response-mime-type");
 const path_segment_plural_1 = require("../common/path-segment-plural");
+const response_contains_header_1 = require("../common/response-contains-header");
+const response_contains_property_1 = require("./response-contains-property");
+const scalar_property_missing_example_1 = require("../common/scalar-property-missing-example");
+const required_string_property_missing_min_length_1 = require("../common/required-string-property-missing-min-length");
+const spec_strict_refs_1 = require("../common/spec-strict-refs");
 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_url_1.InfoLicense,
-    'info-license-url': license_url_1.InfoLicenseUrl,
+    'info-license': info_license_1.InfoLicense,
+    'info-license-url': info_license_url_1.InfoLicenseUrl,
     'tag-description': tag_description_1.TagDescription,
     'tags-alphabetical': tags_alphabetical_1.TagsAlphabetical,
     'paths-kebab-case': paths_kebab_case_1.PathsKebabCase,
@@ -55,7 +58,7 @@ exports.rules = {
     'no-path-trailing-slash': no_path_trailing_slash_1.NoPathTrailingSlash,
     'operation-2xx-response': operation_2xx_response_1.Operation2xxResponse,
     'operation-4xx-response': operation_4xx_response_1.Operation4xxResponse,
-    'assertions': assertions_1.Assertions,
+    assertions: assertions_1.Assertions,
     'operation-operationId-unique': operation_operationId_unique_1.OperationIdUnique,
     'operation-parameters-unique': operation_parameters_unique_1.OperationParametersUnique,
     'path-parameters-defined': path_params_defined_1.PathParamsDefined,
@@ -69,7 +72,7 @@ exports.rules = {
     'path-params-defined': path_params_defined_1.PathParamsDefined,
     'parameter-description': parameter_description_1.ParameterDescription,
     'operation-singular-tag': operation_singular_tag_1.OperationSingularTag,
-    'operation-security-defined': operation_security_defined_1.OperationSecurityDefined,
+    'security-defined': security_defined_1.SecurityDefined,
     'no-unresolved-refs': no_unresolved_refs_1.NoUnresolvedRefs,
     'no-identical-paths': no_identical_paths_1.NoIdenticalPaths,
     'no-ambiguous-paths': no_ambiguous_paths_1.NoAmbiguousPaths,
@@ -79,5 +82,10 @@ exports.rules = {
     'request-mime-type': request_mime_type_1.RequestMimeType,
     'response-mime-type': response_mime_type_1.ResponseMimeType,
     'path-segment-plural': path_segment_plural_1.PathSegmentPlural,
+    'response-contains-header': response_contains_header_1.ResponseContainsHeader,
+    'response-contains-property': response_contains_property_1.ResponseContainsProperty,
+    'scalar-property-missing-example': scalar_property_missing_example_1.ScalarPropertyMissingExample,
+    'required-string-property-missing-min-length': required_string_property_missing_min_length_1.RequiredStringPropertyMissingMinLength,
+    'spec-strict-refs': spec_strict_refs_1.SpecStrictRefs,
 };
 exports.preprocessors = {};

package/lib/rules/oas2/remove-unused-components.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemoveUnusedComponents = void 0;
 const utils_1 = require("../../utils");
 const RemoveUnusedComponents = () => {
-    let components = new Map();
+    const components = new Map();
     function registerComponent(location, componentType, name) {
         var _a;
         components.set(location.absolutePointer, {
@@ -24,14 +24,14 @@ const RemoveUnusedComponents = () => {
                         name: key.toString(),
                     });
                 }
-            }
+            },
         },
-        DefinitionRoot: {
+        Root: {
             leave(root, ctx) {
                 const data = ctx.getVisitorData();
                 data.removedCount = 0;
-                let rootComponents = new Set();
-                components.forEach(usageInfo => {
+                const rootComponents = new Set();
+                components.forEach((usageInfo) => {
                     const { used, name, componentType } = usageInfo;
                     if (!used && componentType) {
                         rootComponents.add(componentType);
@@ -67,7 +67,7 @@ const RemoveUnusedComponents = () => {
             SecurityScheme(_securityScheme, { location, key }) {
                 registerComponent(location, 'securityDefinitions', key.toString());
             },
-        }
+        },
     };
 };
 exports.RemoveUnusedComponents = RemoveUnusedComponents;

package/lib/rules/oas2/request-mime-type.d.ts

@@ -1,2 +1,2 @@
-import { Oas2Rule } from '../../visitors';
+import type { Oas2Rule } from '../../visitors';
 export declare const RequestMimeType: Oas2Rule;

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

@@ -4,7 +4,7 @@ exports.RequestMimeType = void 0;
 const utils_1 = require("../../utils");
 const RequestMimeType = ({ allowedValues }) => {
     return {
-        DefinitionRoot(root, ctx) {
+        Root(root, ctx) {
             utils_1.validateMimeType({ type: 'consumes', value: root }, ctx, allowedValues);
         },
         Operation: {

package/lib/rules/oas2/response-contains-property.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule } from '../../visitors';
+export declare const ResponseContainsProperty: Oas2Rule;

package/lib/rules/oas2/response-contains-property.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseContainsProperty = void 0;
+const utils_1 = require("../../utils");
+const ResponseContainsProperty = (options) => {
+    const names = options.names || {};
+    let key;
+    return {
+        Operation: {
+            Response: {
+                skip: (_response, key) => {
+                    return `${key}` === '204';
+                },
+                enter: (_response, ctx) => {
+                    key = ctx.key;
+                },
+                Schema(schema, { report, location }) {
+                    var _a;
+                    if (schema.type !== 'object')
+                        return;
+                    const expectedProperties = names[key] ||
+                        names[utils_1.getMatchingStatusCodeRange(key)] ||
+                        names[utils_1.getMatchingStatusCodeRange(key).toLowerCase()] ||
+                        [];
+                    for (const expectedProperty of expectedProperties) {
+                        if (!((_a = schema.properties) === null || _a === void 0 ? void 0 : _a[expectedProperty])) {
+                            report({
+                                message: `Response object must contain a top-level "${expectedProperty}" property.`,
+                                location: location.child('properties').key(),
+                            });
+                        }
+                    }
+                },
+            },
+        },
+    };
+};
+exports.ResponseContainsProperty = ResponseContainsProperty;

package/lib/rules/oas2/response-mime-type.d.ts

@@ -1,2 +1,2 @@
-import { Oas2Rule } from '../../visitors';
+import type { Oas2Rule } from '../../visitors';
 export declare const ResponseMimeType: Oas2Rule;

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

@@ -4,7 +4,7 @@ exports.ResponseMimeType = void 0;
 const utils_1 = require("../../utils");
 const ResponseMimeType = ({ allowedValues }) => {
     return {
-        DefinitionRoot(root, ctx) {
+        Root(root, ctx) {
             utils_1.validateMimeType({ type: 'produces', value: root }, ctx, allowedValues);
         },
         Operation: {