@redocly/openapi-core 1.3.0 → 1.4.1

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

@@ -36,45 +36,45 @@ exports.runOnValuesSet = new Set([
 ]);
 exports.asserts = {
     pattern: (value, condition, { baseLocation, rawValue }) => {
-        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
             return []; // property doesn't exist or is an object, no need to lint it with this assert
         const values = Array.isArray(value) ? value : [value];
-        const regex = utils_2.regexFromString(condition);
+        const regex = (0, utils_2.regexFromString)(condition);
         return values
             .map((_val) => !(regex === null || regex === void 0 ? void 0 : regex.test(_val)) && {
             message: `"${_val}" should match a regex ${condition}`,
-            location: utils_1.isString(value)
+            location: (0, utils_1.isString)(value)
                 ? baseLocation
-                : utils_1.isPlainObject(rawValue)
+                : (0, utils_1.isPlainObject)(rawValue)
                     ? baseLocation.child(_val).key()
                     : baseLocation.key(),
         })
             .filter(utils_1.isTruthy);
     },
     notPattern: (value, condition, { baseLocation, rawValue }) => {
-        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
             return []; // property doesn't exist or is an object, no need to lint it with this assert
         const values = Array.isArray(value) ? value : [value];
-        const regex = utils_2.regexFromString(condition);
+        const regex = (0, utils_2.regexFromString)(condition);
         return values
             .map((_val) => (regex === null || regex === void 0 ? void 0 : regex.test(_val)) && {
             message: `"${_val}" should not match a regex ${condition}`,
-            location: utils_1.isString(value)
+            location: (0, utils_1.isString)(value)
                 ? baseLocation
-                : utils_1.isPlainObject(rawValue)
+                : (0, utils_1.isPlainObject)(rawValue)
                     ? baseLocation.child(_val).key()
                     : baseLocation.key(),
         })
             .filter(utils_1.isTruthy);
     },
     enum: (value, condition, { baseLocation }) => {
-        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
             return []; // property doesn't exist or is an object, no need to lint it with this assert
         const values = Array.isArray(value) ? value : [value];
         return values
             .map((_val) => !condition.includes(_val) && {
             message: `"${_val}" should be one of the predefined values`,
-            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+            location: (0, utils_1.isString)(value) ? baseLocation : baseLocation.child(_val).key(),
         })
             .filter(utils_1.isTruthy);
     },
@@ -99,13 +99,13 @@ exports.asserts = {
             .filter(utils_1.isTruthy);
     },
     disallowed: (value, condition, { baseLocation }) => {
-        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
             return []; // property doesn't exist or is an object, no need to lint it with this assert
         const values = Array.isArray(value) ? value : [value];
         return values
             .map((_val) => condition.includes(_val) && {
             message: `"${_val}" is disallowed`,
-            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+            location: (0, utils_1.isString)(value) ? baseLocation : baseLocation.child(_val).key(),
         })
             .filter(utils_1.isTruthy);
     },
@@ -116,7 +116,7 @@ exports.asserts = {
             return value
                 .map((_val) => condition !== _val && {
                 message: `"${_val}" should be equal ${condition} `,
-                location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+                location: (0, utils_1.isString)(value) ? baseLocation : baseLocation.child(_val).key(),
             })
                 .filter(utils_1.isTruthy);
         }
@@ -176,7 +176,7 @@ exports.asserts = {
         ];
     },
     casing: (value, condition, { baseLocation }) => {
-        if (typeof value === 'undefined' || utils_1.isPlainObject(value))
+        if (typeof value === 'undefined' || (0, utils_1.isPlainObject)(value))
             return []; // property doesn't exist or is an object, no need to lint it with this assert
         const values = Array.isArray(value) ? value : [value];
         const casingRegexes = {
@@ -191,7 +191,7 @@ exports.asserts = {
         return values
             .map((_val) => !_val.match(casingRegexes[condition]) && {
             message: `"${_val}" should use ${condition}`,
-            location: utils_1.isString(value) ? baseLocation : baseLocation.child(_val).key(),
+            location: (0, utils_1.isString)(value) ? baseLocation : baseLocation.child(_val).key(),
         })
             .filter(utils_1.isTruthy);
     },
@@ -206,7 +206,7 @@ exports.asserts = {
                 },
             ];
         }
-        if (typeof value === 'undefined' || utils_2.isOrdered(value, condition))
+        if (typeof value === 'undefined' || (0, utils_2.isOrdered)(value, condition))
             return [];
         return [
             {
@@ -216,7 +216,7 @@ exports.asserts = {
         ];
     },
     mutuallyExclusive: (value, condition, { baseLocation }) => {
-        if (utils_2.getIntersectionLength(value, condition) < 2)
+        if ((0, utils_2.getIntersectionLength)(value, condition) < 2)
             return [];
         return [
             {
@@ -226,8 +226,8 @@ exports.asserts = {
         ];
     },
     mutuallyRequired: (value, condition, { baseLocation }) => {
-        const isValid = utils_2.getIntersectionLength(value, condition) > 0
-            ? utils_2.getIntersectionLength(value, condition) === condition.length
+        const isValid = (0, utils_2.getIntersectionLength)(value, condition) > 0
+            ? (0, utils_2.getIntersectionLength)(value, condition) === condition.length
             : true;
         return isValid
             ? []
@@ -239,7 +239,7 @@ exports.asserts = {
             ];
     },
     requireAny: (value, condition, { baseLocation }) => {
-        return utils_2.getIntersectionLength(value, condition) >= 1
+        return (0, utils_2.getIntersectionLength)(value, condition) >= 1
             ? []
             : [
                 {
@@ -263,7 +263,7 @@ exports.asserts = {
                     },
                 ];
         }
-        const regex = utils_2.regexFromString(condition);
+        const regex = (0, utils_2.regexFromString)(condition);
         const isValid = hasRef && (regex === null || regex === void 0 ? void 0 : regex.test(rawValue['$ref']));
         return isValid
             ? []

package/lib/rules/common/assertions/index.d.ts

@@ -1,12 +1,12 @@
 import { asserts, AssertionFn } from './asserts';
 import { Oas2Visitor, Oas3Visitor } from '../../../visitors';
 import { RuleSeverity } from '../../../config';
-export declare type AssertionLocators = {
+export type AssertionLocators = {
     filterInParentKeys?: (string | number)[];
     filterOutParentKeys?: (string | number)[];
     matchParentKeys?: string;
 };
-export declare type AssertionDefinition = {
+export type AssertionDefinition = {
     subject: {
         type: string;
         property?: string | string[];
@@ -15,13 +15,13 @@ export declare type AssertionDefinition = {
         [name in keyof typeof asserts]?: AssertionFn;
     };
 };
-export declare type RawAssertion = AssertionDefinition & {
+export type RawAssertion = AssertionDefinition & {
     where?: AssertionDefinition[];
     message?: string;
     suggest?: string[];
     severity?: RuleSeverity;
 };
-export declare type Assertion = RawAssertion & {
+export type Assertion = RawAssertion & {
     assertionId: string;
 };
 export declare const Assertions: (opts: Record<string, Assertion>) => (Oas3Visitor | Oas2Visitor)[];

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

@@ -12,11 +12,11 @@ const Assertions = (opts) => {
     // before - filter only object 'opts' values
     const assertions = Object.values(opts).filter((opt) => typeof opt === 'object' && opt !== null);
     for (const [_, assertion] of assertions.entries()) {
-        if (!utils_2.isString(assertion.subject.type)) {
+        if (!(0, utils_2.isString)(assertion.subject.type)) {
             throw new Error(`${assertion.assertionId}: 'type' (String) is required`);
         }
-        const subjectVisitor = utils_1.buildSubjectVisitor(assertion.assertionId, assertion);
-        const visitorObject = utils_1.buildVisitorObject(assertion, subjectVisitor);
+        const subjectVisitor = (0, utils_1.buildSubjectVisitor)(assertion.assertionId, assertion);
+        const visitorObject = (0, utils_1.buildVisitorObject)(assertion, subjectVisitor);
         visitors.push(visitorObject);
     }
     return visitors;

package/lib/rules/common/assertions/utils.d.ts

@@ -2,18 +2,18 @@ import { Asserts } from './asserts';
 import type { AssertionContext, AssertResult } from '../../../config';
 import type { Assertion, AssertionDefinition } from '.';
 import type { Oas2Visitor, Oas3Visitor, VisitFunction } from '../../../visitors';
-export declare type OrderDirection = 'asc' | 'desc';
-export declare type OrderOptions = {
+export type OrderDirection = 'asc' | 'desc';
+export type OrderOptions = {
     direction: OrderDirection;
     property: string;
 };
-export declare type AssertToApply = {
+export type AssertToApply = {
     name: keyof Asserts;
     conditions: any;
     runsOnKeys: boolean;
     runsOnValues: boolean;
 };
-declare type RunAssertionParams = {
+type RunAssertionParams = {
     ctx: AssertionContext;
     assert: AssertToApply;
     assertionProperty?: string;

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

@@ -19,7 +19,7 @@ function getPredicatesFromLocators(locators) {
     return [matchKeysPredicate, filterInPredicate, filterOutPredicate].filter(utils_1.isTruthy);
 }
 function getAssertsToApply(assertion) {
-    const assertsToApply = utils_1.keysOf(asserts_1.asserts)
+    const assertsToApply = (0, utils_1.keysOf)(asserts_1.asserts)
         .filter((assertName) => assertion.assertions[assertName] !== undefined)
         .map((assertName) => {
         return {
@@ -82,7 +82,7 @@ function buildVisitorObject(assertion, subjectVisitor) {
     const context = assertion.where;
     for (let index = 0; index < context.length; index++) {
         const assertionDefinitionNode = context[index];
-        if (!utils_1.isString((_a = assertionDefinitionNode.subject) === null || _a === void 0 ? void 0 : _a.type)) {
+        if (!(0, 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 locatorPredicates = getPredicatesFromLocators(assertionDefinitionNode.subject);
@@ -191,7 +191,7 @@ function runAssertion({ assert, ctx, assertionProperty, }) {
     var _a;
     const currentLocation = assert.name === 'ref' ? ctx.rawLocation : ctx.location;
     if (assertionProperty) {
-        const values = ref_utils_1.isRef(ctx.node[assertionProperty])
+        const values = (0, ref_utils_1.isRef)(ctx.node[assertionProperty])
             ? (_a = ctx.resolve(ctx.node[assertionProperty])) === null || _a === void 0 ? void 0 : _a.node
             : ctx.node[assertionProperty];
         const rawValues = ctx.rawNode[assertionProperty];

package/lib/rules/common/info-contact.js

@@ -7,7 +7,7 @@ const InfoContact = () => {
         Info(info, { report, location }) {
             if (!info.contact) {
                 report({
-                    message: utils_1.missingRequiredField('Info', 'contact'),
+                    message: (0, utils_1.missingRequiredField)('Info', 'contact'),
                     location: location.child('contact').key(),
                 });
             }

package/lib/rules/common/info-license-url.js

@@ -5,7 +5,7 @@ const utils_1 = require("../utils");
 const InfoLicenseUrl = () => {
     return {
         License(license, ctx) {
-            utils_1.validateDefinedAndNonEmpty('url', license, ctx);
+            (0, utils_1.validateDefinedAndNonEmpty)('url', license, ctx);
         },
     };
 };

package/lib/rules/common/info-license.js

@@ -7,7 +7,7 @@ const InfoLicense = () => {
         Info(info, { report }) {
             if (!info.license) {
                 report({
-                    message: utils_1.missingRequiredField('Info', 'license'),
+                    message: (0, utils_1.missingRequiredField)('Info', 'license'),
                     location: { reportOnKey: true },
                 });
             }

package/lib/rules/common/no-enum-type-mismatch.js

@@ -8,10 +8,10 @@ const NoEnumTypeMismatch = () => {
             if (schema.enum && !Array.isArray(schema.enum))
                 return;
             if (schema.enum && schema.type && !Array.isArray(schema.type)) {
-                const typeMismatchedValues = schema.enum.filter((item) => !utils_1.matchesJsonSchemaType(item, schema.type, schema.nullable));
+                const typeMismatchedValues = schema.enum.filter((item) => !(0, utils_1.matchesJsonSchemaType)(item, schema.type, schema.nullable));
                 for (const mismatchedValue of typeMismatchedValues) {
                     report({
-                        message: `All values of \`enum\` field must be of the same type as the \`type\` field: expected "${schema.type}" but received "${utils_1.oasTypeOf(mismatchedValue)}".`,
+                        message: `All values of \`enum\` field must be of the same type as the \`type\` field: expected "${schema.type}" but received "${(0, utils_1.oasTypeOf)(mismatchedValue)}".`,
                         location: location.child(['enum', schema.enum.indexOf(mismatchedValue)]),
                     });
                 }
@@ -21,7 +21,7 @@ const NoEnumTypeMismatch = () => {
                 for (const enumValue of schema.enum) {
                     mismatchedResults[enumValue] = [];
                     for (const type of schema.type) {
-                        const valid = utils_1.matchesJsonSchemaType(enumValue, type, schema.nullable);
+                        const valid = (0, utils_1.matchesJsonSchemaType)(enumValue, type, schema.nullable);
                         if (!valid)
                             mismatchedResults[enumValue].push(type);
                     }

package/lib/rules/common/no-http-verbs-in-paths.js

@@ -11,11 +11,11 @@ const NoHttpVerbsInPaths = ({ splitIntoWords }) => {
                 return;
             const pathSegments = pathKey.split('/');
             for (const pathSegment of pathSegments) {
-                if (!pathSegment || utils_1.isPathParameter(pathSegment))
+                if (!pathSegment || (0, utils_1.isPathParameter)(pathSegment))
                     continue;
                 const isHttpMethodIncluded = (method) => {
                     return splitIntoWords
-                        ? utils_1.splitCamelCaseIntoWords(pathSegment).has(method)
+                        ? (0, utils_1.splitCamelCaseIntoWords)(pathSegment).has(method)
                         : pathSegment.toLocaleLowerCase().includes(method);
                 };
                 for (const method of httpMethods) {

package/lib/rules/common/no-invalid-parameter-examples.js

@@ -4,17 +4,17 @@ exports.NoInvalidParameterExamples = void 0;
 const utils_1 = require("../utils");
 const NoInvalidParameterExamples = (opts) => {
     var _a;
-    const allowAdditionalProperties = (_a = utils_1.getAdditionalPropertiesOption(opts)) !== null && _a !== void 0 ? _a : false;
+    const allowAdditionalProperties = (_a = (0, utils_1.getAdditionalPropertiesOption)(opts)) !== null && _a !== void 0 ? _a : false;
     return {
         Parameter: {
             leave(parameter, ctx) {
                 if (parameter.example) {
-                    utils_1.validateExample(parameter.example, parameter.schema, ctx.location.child('example'), ctx, allowAdditionalProperties);
+                    (0, utils_1.validateExample)(parameter.example, parameter.schema, ctx.location.child('example'), ctx, allowAdditionalProperties);
                 }
                 if (parameter.examples) {
                     for (const [key, example] of Object.entries(parameter.examples)) {
                         if ('value' in example) {
-                            utils_1.validateExample(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, true);
+                            (0, utils_1.validateExample)(example.value, parameter.schema, ctx.location.child(['examples', key]), ctx, true);
                         }
                     }
                 }

package/lib/rules/common/no-invalid-schema-examples.js

@@ -4,17 +4,17 @@ exports.NoInvalidSchemaExamples = void 0;
 const utils_1 = require("../utils");
 const NoInvalidSchemaExamples = (opts) => {
     var _a;
-    const allowAdditionalProperties = (_a = utils_1.getAdditionalPropertiesOption(opts)) !== null && _a !== void 0 ? _a : false;
+    const allowAdditionalProperties = (_a = (0, utils_1.getAdditionalPropertiesOption)(opts)) !== null && _a !== void 0 ? _a : false;
     return {
         Schema: {
             leave(schema, ctx) {
                 if (schema.examples) {
                     for (const example of schema.examples) {
-                        utils_1.validateExample(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, allowAdditionalProperties);
+                        (0, utils_1.validateExample)(example, schema, ctx.location.child(['examples', schema.examples.indexOf(example)]), ctx, allowAdditionalProperties);
                     }
                 }
                 if (schema.example) {
-                    utils_1.validateExample(schema.example, schema, ctx.location.child('example'), ctx, true);
+                    (0, utils_1.validateExample)(schema.example, schema, ctx.location.child('example'), ctx, true);
                 }
             },
         },

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

@@ -7,7 +7,7 @@ const Operation2xxResponse = ({ validateWebhooks }) => {
         Paths: {
             Responses(responses, { report }) {
                 const codes = Object.keys(responses || {});
-                utils_1.validateResponseCodes(codes, '2XX', { report });
+                (0, utils_1.validateResponseCodes)(codes, '2XX', { report });
             },
         },
         WebhooksMap: {
@@ -15,7 +15,7 @@ const Operation2xxResponse = ({ validateWebhooks }) => {
                 if (!validateWebhooks)
                     return;
                 const codes = Object.keys(responses || {});
-                utils_1.validateResponseCodes(codes, '2XX', { report });
+                (0, utils_1.validateResponseCodes)(codes, '2XX', { report });
             },
         },
     };

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

@@ -7,7 +7,7 @@ const Operation4xxResponse = ({ validateWebhooks }) => {
         Paths: {
             Responses(responses, { report }) {
                 const codes = Object.keys(responses || {});
-                utils_1.validateResponseCodes(codes, '4XX', { report });
+                (0, utils_1.validateResponseCodes)(codes, '4XX', { report });
             },
         },
         WebhooksMap: {
@@ -15,7 +15,7 @@ const Operation4xxResponse = ({ validateWebhooks }) => {
                 if (!validateWebhooks)
                     return;
                 const codes = Object.keys(responses || {});
-                utils_1.validateResponseCodes(codes, '4XX', { report });
+                (0, utils_1.validateResponseCodes)(codes, '4XX', { report });
             },
         },
     };

package/lib/rules/common/operation-description.js

@@ -5,7 +5,7 @@ const utils_1 = require("../utils");
 const OperationDescription = () => {
     return {
         Operation(operation, ctx) {
-            utils_1.validateDefinedAndNonEmpty('description', operation, ctx);
+            (0, utils_1.validateDefinedAndNonEmpty)('description', operation, ctx);
         },
     };
 };

package/lib/rules/common/operation-operationId.js

@@ -7,7 +7,7 @@ const OperationOperationId = () => {
         Root: {
             PathItem: {
                 Operation(operation, ctx) {
-                    utils_1.validateDefinedAndNonEmpty('operationId', operation, ctx);
+                    (0, utils_1.validateDefinedAndNonEmpty)('operationId', operation, ctx);
                 },
             },
         },

package/lib/rules/common/operation-summary.js

@@ -5,7 +5,7 @@ const utils_1 = require("../utils");
 const OperationSummary = () => {
     return {
         Operation(operation, ctx) {
-            utils_1.validateDefinedAndNonEmpty('summary', operation, ctx);
+            (0, utils_1.validateDefinedAndNonEmpty)('summary', operation, ctx);
         },
     };
 };

package/lib/rules/common/path-segment-plural.js

@@ -17,7 +17,7 @@ const PathSegmentPlural = (opts) => {
                     for (const pathSegment of pathSegments) {
                         if (exceptions && exceptions.includes(pathSegment))
                             continue;
-                        if (!utils_1.isPathParameter(pathSegment) && utils_1.isSingular(pathSegment)) {
+                        if (!(0, utils_1.isPathParameter)(pathSegment) && (0, utils_1.isSingular)(pathSegment)) {
                             report({
                                 message: `path segment \`${pathSegment}\` should be plural.`,
                                 location: location.key(),

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

@@ -9,8 +9,8 @@ const ResponseContainsHeader = (options) => {
             Response: {
                 enter: (response, { report, location, key }) => {
                     const expectedHeaders = names[key] ||
-                        names[utils_1.getMatchingStatusCodeRange(key)] ||
-                        names[utils_1.getMatchingStatusCodeRange(key).toLowerCase()] ||
+                        names[(0, utils_1.getMatchingStatusCodeRange)(key)] ||
+                        names[(0, utils_1.getMatchingStatusCodeRange)(key).toLowerCase()] ||
                         [];
                     for (const expectedHeader of expectedHeaders) {
                         if (!(response === null || response === void 0 ? void 0 : response.headers) ||

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

@@ -18,7 +18,7 @@ const SpecStrictRefs = () => {
     return {
         any(_node, { report, rawNode, rawLocation, type }) {
             const shouldCheck = !nodesToSkip.includes(type.name);
-            if (shouldCheck && ref_utils_1.isRef(rawNode)) {
+            if (shouldCheck && (0, ref_utils_1.isRef)(rawNode)) {
                 report({
                     message: 'Field $ref is not expected here.',
                     location: rawLocation.child('$ref').key(),

package/lib/rules/common/spec.js

@@ -9,7 +9,7 @@ const Spec = () => {
     return {
         any(node, { report, type, location, rawLocation, key, resolve, ignoreNextVisitorsOnNode }) {
             var _a, _b, _c, _d, _e, _f;
-            const nodeType = utils_1.oasTypeOf(node);
+            const nodeType = (0, utils_1.oasTypeOf)(node);
             const refLocation = rawLocation !== location ? rawLocation : undefined;
             if (type.items) {
                 if (nodeType !== 'array') {
@@ -43,7 +43,7 @@ const Spec = () => {
                 }
             }
             const allowed = (_a = type.allowed) === null || _a === void 0 ? void 0 : _a.call(type, node);
-            if (allowed && utils_2.isPlainObject(node)) {
+            if (allowed && (0, utils_2.isPlainObject)(node)) {
                 for (const propName in node) {
                     if (allowed.includes(propName) ||
                         (type.extensionsPrefix && propName.startsWith(type.extensionsPrefix)) ||
@@ -80,17 +80,17 @@ const Spec = () => {
                     propType = type.additionalProperties;
                 if (typeof propType === 'function')
                     propType = propType(propValue, propName);
-                if (types_1.isNamedType(propType)) {
+                if ((0, types_1.isNamedType)(propType)) {
                     continue; // do nothing for named schema, it is executed with the next any call
                 }
                 const propSchema = propType;
-                const propValueType = utils_1.oasTypeOf(propValue);
+                const propValueType = (0, utils_1.oasTypeOf)(propValue);
                 if (propSchema === undefined) {
                     if (propName.startsWith('x-'))
                         continue;
                     report({
                         message: `Property \`${propName}\` is not expected here.`,
-                        suggest: utils_1.getSuggest(propName, Object.keys(type.properties)),
+                        suggest: (0, utils_1.getSuggest)(propName, Object.keys(type.properties)),
                         from: refLocation,
                         location: propLocation.key(),
                     });
@@ -99,24 +99,24 @@ const Spec = () => {
                 if (propSchema === null) {
                     continue; // just defined, no validation
                 }
-                if (propSchema.resolvable !== false && ref_utils_1.isRef(propValue)) {
+                if (propSchema.resolvable !== false && (0, ref_utils_1.isRef)(propValue)) {
                     propValue = resolve(propValue).node;
                 }
                 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, {
+                        (0, 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, {
+                    (0, utils_1.validateSchemaEnumType)(propSchema.enum, propValue, propName, refLocation, {
                         report,
                         location: location.child([propName]),
                     });
                 }
-                else if (propSchema.type && !utils_1.matchesJsonSchemaType(propValue, propSchema.type, false)) {
+                else if (propSchema.type && !(0, utils_1.matchesJsonSchemaType)(propValue, propSchema.type, false)) {
                     report({
                         message: `Expected type \`${propSchema.type}\` but got \`${propValueType}\`.`,
                         from: refLocation,
@@ -128,9 +128,9 @@ const Spec = () => {
                     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)) {
+                        if (!(0, utils_1.matchesJsonSchemaType)(item, itemsType, false)) {
                             report({
-                                message: `Expected type \`${itemsType}\` but got \`${utils_1.oasTypeOf(item)}\`.`,
+                                message: `Expected type \`${itemsType}\` but got \`${(0, utils_1.oasTypeOf)(item)}\`.`,
                                 from: refLocation,
                                 location: propLocation.child([i]),
                             });

package/lib/rules/common/tag-description.js

@@ -5,7 +5,7 @@ const utils_1 = require("../utils");
 const TagDescription = () => {
     return {
         Tag(tag, ctx) {
-            utils_1.validateDefinedAndNonEmpty('description', tag, ctx);
+            (0, utils_1.validateDefinedAndNonEmpty)('description', tag, ctx);
         },
     };
 };

package/lib/rules/oas2/boolean-parameter-prefixes.d.ts

@@ -1,5 +1,5 @@
 import { Oas2Rule } from '../../visitors';
-export declare type BooleanParameterPrefixesOptions = {
+export type BooleanParameterPrefixesOptions = {
     prefixes?: string[];
 };
 export declare const BooleanParameterPrefixes: Oas2Rule;

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

@@ -1,47 +1,3 @@
-import { Oas2Rule } from '../../visitors';
-export declare const rules: {
-    spec: Oas2Rule;
-    'no-invalid-schema-examples': any;
-    'no-invalid-parameter-examples': any;
-    'info-contact': Oas2Rule;
-    'info-license': Oas2Rule;
-    'info-license-url': Oas2Rule;
-    'tag-description': Oas2Rule;
-    'tags-alphabetical': Oas2Rule;
-    'paths-kebab-case': Oas2Rule;
-    'no-enum-type-mismatch': Oas2Rule;
-    'boolean-parameter-prefixes': Oas2Rule;
-    'no-path-trailing-slash': Oas2Rule;
-    'operation-2xx-response': Oas2Rule;
-    'operation-4xx-response': Oas2Rule;
-    assertions: Oas2Rule;
-    'operation-operationId-unique': Oas2Rule;
-    'operation-parameters-unique': Oas2Rule;
-    'path-parameters-defined': Oas2Rule;
-    'operation-tag-defined': Oas2Rule;
-    'path-declaration-must-exist': Oas2Rule;
-    'operation-operationId-url-safe': Oas2Rule;
-    'operation-operationId': Oas2Rule;
-    'operation-summary': Oas2Rule;
-    'operation-description': Oas2Rule;
-    'path-not-include-query': Oas2Rule;
-    'path-params-defined': Oas2Rule;
-    'parameter-description': Oas2Rule;
-    'operation-singular-tag': Oas2Rule;
-    'security-defined': Oas2Rule;
-    'no-unresolved-refs': Oas2Rule;
-    'no-identical-paths': Oas2Rule;
-    'no-ambiguous-paths': Oas2Rule;
-    'path-http-verbs-order': Oas2Rule;
-    'no-http-verbs-in-paths': Oas2Rule;
-    'path-excludes-patterns': Oas2Rule;
-    '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;
-};
+import type { Oas2RuleSet } from 'core/src/oas-types';
+export declare const rules: Oas2RuleSet<'built-in'>;
 export declare const preprocessors: {};

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

@@ -5,11 +5,11 @@ const utils_1 = require("../../utils");
 const RequestMimeType = ({ allowedValues }) => {
     return {
         Root(root, ctx) {
-            utils_1.validateMimeType({ type: 'consumes', value: root }, ctx, allowedValues);
+            (0, utils_1.validateMimeType)({ type: 'consumes', value: root }, ctx, allowedValues);
         },
         Operation: {
             leave(operation, ctx) {
-                utils_1.validateMimeType({ type: 'consumes', value: operation }, ctx, allowedValues);
+                (0, utils_1.validateMimeType)({ type: 'consumes', value: operation }, ctx, allowedValues);
             },
         },
     };

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

@@ -19,8 +19,8 @@ const ResponseContainsProperty = (options) => {
                     if (schema.type !== 'object')
                         return;
                     const expectedProperties = names[key] ||
-                        names[utils_1.getMatchingStatusCodeRange(key)] ||
-                        names[utils_1.getMatchingStatusCodeRange(key).toLowerCase()] ||
+                        names[(0, utils_1.getMatchingStatusCodeRange)(key)] ||
+                        names[(0, utils_1.getMatchingStatusCodeRange)(key).toLowerCase()] ||
                         [];
                     for (const expectedProperty of expectedProperties) {
                         if (!((_a = schema.properties) === null || _a === void 0 ? void 0 : _a[expectedProperty])) {