@redocly/openapi-core 1.3.0 → 1.4.0

package/lib/lint.js

@@ -30,48 +30,48 @@ exports.lint = lint;
 function lintFromString(opts) {
     return __awaiter(this, void 0, void 0, function* () {
         const { source, absoluteRef, externalRefResolver = new resolve_1.BaseResolver(opts.config.resolve) } = opts;
-        const document = resolve_1.makeDocumentFromString(source, absoluteRef || '/');
+        const document = (0, resolve_1.makeDocumentFromString)(source, absoluteRef || '/');
         return lintDocument(Object.assign(Object.assign({ document }, opts), { externalRefResolver, config: opts.config.styleguide }));
     });
 }
 exports.lintFromString = lintFromString;
 function lintDocument(opts) {
     return __awaiter(this, void 0, void 0, function* () {
-        ajv_1.releaseAjvInstance(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
+        (0, ajv_1.releaseAjvInstance)(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
         const { document, customTypes, externalRefResolver, config } = opts;
-        const specVersion = oas_types_1.detectSpec(document.parsed);
-        const specMajorVersion = oas_types_1.getMajorSpecVersion(specVersion);
+        const specVersion = (0, oas_types_1.detectSpec)(document.parsed);
+        const specMajorVersion = (0, oas_types_1.getMajorSpecVersion)(specVersion);
         const rules = config.getRulesForOasVersion(specMajorVersion);
-        const types = types_1.normalizeTypes(config.extendTypes(customTypes !== null && customTypes !== void 0 ? customTypes : oas_types_1.getTypes(specVersion), specVersion), config);
+        const types = (0, types_1.normalizeTypes)(config.extendTypes(customTypes !== null && customTypes !== void 0 ? customTypes : (0, oas_types_1.getTypes)(specVersion), specVersion), config);
         const ctx = {
             problems: [],
             oasVersion: specVersion,
             visitorsData: {},
         };
-        const preprocessors = config_1.initRules(rules, config, 'preprocessors', specVersion);
-        const regularRules = config_1.initRules(rules, config, 'rules', specVersion);
-        let resolvedRefMap = yield resolve_1.resolveDocument({
+        const preprocessors = (0, config_1.initRules)(rules, config, 'preprocessors', specVersion);
+        const regularRules = (0, config_1.initRules)(rules, config, 'rules', specVersion);
+        let resolvedRefMap = yield (0, resolve_1.resolveDocument)({
             rootDocument: document,
             rootType: types.Root,
             externalRefResolver,
         });
         if (preprocessors.length > 0) {
             // Make additional pass to resolve refs defined in preprocessors.
-            walk_1.walkDocument({
+            (0, walk_1.walkDocument)({
                 document,
                 rootType: types.Root,
-                normalizedVisitors: visitors_1.normalizeVisitors(preprocessors, types),
+                normalizedVisitors: (0, visitors_1.normalizeVisitors)(preprocessors, types),
                 resolvedRefMap,
                 ctx,
             });
-            resolvedRefMap = yield resolve_1.resolveDocument({
+            resolvedRefMap = yield (0, resolve_1.resolveDocument)({
                 rootDocument: document,
                 rootType: types.Root,
                 externalRefResolver,
             });
         }
-        const normalizedVisitors = visitors_1.normalizeVisitors(regularRules, types);
-        walk_1.walkDocument({
+        const normalizedVisitors = (0, visitors_1.normalizeVisitors)(regularRules, types);
+        (0, walk_1.walkDocument)({
             document,
             rootType: types.Root,
             normalizedVisitors,
@@ -90,22 +90,22 @@ function lintConfig(opts) {
             oasVersion: oas_types_1.SpecVersion.OAS3_0,
             visitorsData: {},
         };
-        const plugins = config_1.resolvePlugins([config_1.defaultPlugin]);
+        const plugins = (0, config_1.resolvePlugins)([config_1.defaultPlugin]);
         const config = new config_1.StyleguideConfig({
             plugins,
             rules: { spec: 'error' },
         });
-        const types = types_1.normalizeTypes(redocly_yaml_1.ConfigTypes, config);
+        const types = (0, types_1.normalizeTypes)(redocly_yaml_1.ConfigTypes, config);
         const rules = [
             {
                 severity: severity || 'error',
                 ruleId: 'configuration spec',
-                visitor: spec_1.Spec({ severity: 'error' }),
+                visitor: (0, spec_1.Spec)({ severity: 'error' }),
             },
         ];
         // TODO: check why any is needed
-        const normalizedVisitors = visitors_1.normalizeVisitors(rules, types);
-        walk_1.walkDocument({
+        const normalizedVisitors = (0, visitors_1.normalizeVisitors)(rules, types);
+        (0, walk_1.walkDocument)({
             document,
             rootType: types.ConfigRoot,
             normalizedVisitors,

package/lib/oas-types.d.ts

@@ -1,5 +1,6 @@
 import { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor, Async2Preprocessor, Async2Rule } from './visitors';
-export declare type RuleSet<T> = Record<string, T>;
+import { BuiltInAsync2RuleId, BuiltInCommonOASRuleId, BuiltInCommonRuleId, BuiltInOAS2RuleId, BuiltInOAS3RuleId } from './types/redocly-yaml';
+export type RuleSet<T> = Record<string, T>;
 export declare enum SpecVersion {
     OAS2 = "oas2",
     OAS3_0 = "oas3_0",
@@ -11,15 +12,16 @@ export declare enum SpecMajorVersion {
     OAS3 = "oas3",
     Async2 = "async2"
 }
-export declare type Oas3RuleSet = Record<string, Oas3Rule>;
-export declare type Oas2RuleSet = Record<string, Oas2Rule>;
-export declare type Async2RuleSet = Record<string, Async2Rule>;
-export declare type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
-export declare type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
-export declare type Async2PreprocessorsSet = Record<string, Async2Preprocessor>;
-export declare type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
-export declare type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
-export declare type Async2DecoratorsSet = Record<string, Async2Preprocessor>;
+export type RuleMap<Key extends string, RuleConfig, T> = Record<T extends 'built-in' ? Key : string, RuleConfig>;
+export type Oas3RuleSet<T = undefined> = RuleMap<BuiltInCommonRuleId | BuiltInCommonOASRuleId | BuiltInOAS3RuleId | 'assertions', Oas3Rule, T>;
+export type Oas2RuleSet<T = undefined> = RuleMap<BuiltInCommonRuleId | BuiltInCommonOASRuleId | BuiltInOAS2RuleId | 'assertions', Oas2Rule, T>;
+export type Async2RuleSet<T = undefined> = RuleMap<BuiltInCommonRuleId | BuiltInAsync2RuleId | 'assertions', Async2Rule, T>;
+export type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
+export type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
+export type Async2PreprocessorsSet = Record<string, Async2Preprocessor>;
+export type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
+export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
+export type Async2DecoratorsSet = Record<string, Async2Preprocessor>;
 export declare function detectSpec(root: any): SpecVersion;
 export declare function getMajorSpecVersion(version: SpecVersion): SpecMajorVersion;
 export declare function getTypes(spec: SpecVersion): Record<string, import("./types").NodeType>;

package/lib/oas-types.js

@@ -11,13 +11,13 @@ var SpecVersion;
     SpecVersion["OAS3_0"] = "oas3_0";
     SpecVersion["OAS3_1"] = "oas3_1";
     SpecVersion["Async2"] = "async2";
-})(SpecVersion = exports.SpecVersion || (exports.SpecVersion = {}));
+})(SpecVersion || (exports.SpecVersion = SpecVersion = {}));
 var SpecMajorVersion;
 (function (SpecMajorVersion) {
     SpecMajorVersion["OAS2"] = "oas2";
     SpecMajorVersion["OAS3"] = "oas3";
     SpecMajorVersion["Async2"] = "async2";
-})(SpecMajorVersion = exports.SpecMajorVersion || (exports.SpecMajorVersion = {}));
+})(SpecMajorVersion || (exports.SpecMajorVersion = SpecMajorVersion = {}));
 const typesMap = {
     [SpecVersion.OAS2]: oas2_1.Oas2Types,
     [SpecVersion.OAS3_0]: oas3_1.Oas3Types,

package/lib/redocly/index.js

@@ -41,7 +41,7 @@ class RedoclyClient {
         return this.region;
     }
     hasTokens() {
-        return utils_1.isNotEmptyObject(this.accessTokens);
+        return (0, utils_1.isNotEmptyObject)(this.accessTokens);
     }
     // <backward compatibility: old versions of portal>
     hasToken() {
@@ -57,9 +57,9 @@ class RedoclyClient {
         this.accessTokens = accessTokens;
     }
     loadTokens() {
-        const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), TOKEN_FILENAME);
         const credentials = this.readCredentialsFile(credentialsPath);
-        if (utils_1.isNotEmptyObject(credentials)) {
+        if ((0, utils_1.isNotEmptyObject)(credentials)) {
             this.setAccessTokens(Object.assign(Object.assign({}, credentials), (credentials.token &&
                 !credentials[this.region] && {
                 [this.region]: credentials.token,
@@ -108,11 +108,11 @@ class RedoclyClient {
     }
     isAuthorizedWithRedocly() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.hasTokens() && utils_1.isNotEmptyObject(yield this.getValidTokens());
+            return this.hasTokens() && (0, utils_1.isNotEmptyObject)(yield this.getValidTokens());
         });
     }
     readCredentialsFile(credentialsPath) {
-        return fs_1.existsSync(credentialsPath) ? JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8')) : {};
+        return (0, fs_1.existsSync)(credentialsPath) ? JSON.parse((0, fs_1.readFileSync)(credentialsPath, 'utf-8')) : {};
     }
     verifyToken(accessToken, region, verbose = false) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -121,7 +121,7 @@ class RedoclyClient {
     }
     login(accessToken, verbose = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
+            const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), TOKEN_FILENAME);
             try {
                 yield this.verifyToken(accessToken, this.region, verbose);
             }
@@ -131,13 +131,13 @@ class RedoclyClient {
             const credentials = Object.assign(Object.assign({}, this.readCredentialsFile(credentialsPath)), { [this.region]: accessToken, token: accessToken });
             this.accessTokens = credentials;
             this.registryApi.setAccessTokens(credentials);
-            fs_1.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
+            (0, fs_1.writeFileSync)(credentialsPath, JSON.stringify(credentials, null, 2));
         });
     }
     logout() {
-        const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
-        if (fs_1.existsSync(credentialsPath)) {
-            fs_1.unlinkSync(credentialsPath);
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), TOKEN_FILENAME);
+        if ((0, fs_1.existsSync)(credentialsPath)) {
+            (0, fs_1.unlinkSync)(credentialsPath);
         }
     }
 }

package/lib/redocly/registry-api.js

@@ -20,7 +20,7 @@ class RegistryApi {
         this.region = region;
     }
     get accessToken() {
-        return utils_1.isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
+        return (0, utils_1.isNotEmptyObject)(this.accessTokens) && this.accessTokens[this.region];
     }
     getBaseUrl(region = config_1.DEFAULT_REGION) {
         return `https://api.${config_1.DOMAINS[region]}/registry`;
@@ -41,7 +41,7 @@ class RegistryApi {
             if (!headers.hasOwnProperty('authorization')) {
                 throw new Error('Unauthorized');
             }
-            const response = yield node_fetch_1.default(`${this.getBaseUrl(region)}${path}`, Object.assign({}, options, { headers }));
+            const response = yield (0, node_fetch_1.default)(`${this.getBaseUrl(region)}${path}`, Object.assign({}, options, { headers }));
             if (response.status === 401) {
                 throw new Error('Unauthorized');
             }

package/lib/resolve.d.ts

@@ -1,7 +1,7 @@
 import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
 import { NormalizedNodeType } from './types';
 import { ResolveConfig } from './config/types';
-export declare type CollectedRefs = Map<string, Document>;
+export type CollectedRefs = Map<string, Document>;
 export declare class Source {
     absoluteRef: string;
     body: string;
@@ -23,7 +23,7 @@ export declare class YamlParseError extends Error {
     line: number;
     constructor(originalError: Error, source: Source);
 }
-export declare type Document = {
+export type Document = {
     source: Source;
     parsed: any;
 };
@@ -42,7 +42,7 @@ export declare class BaseResolver {
     parseDocument(source: Source, isRoot?: boolean): Document;
     resolveDocument(base: string | null, ref: string, isRoot?: boolean): Promise<Document | ResolveError | YamlParseError>;
 }
-export declare type ResolvedRef = {
+export type ResolvedRef = {
     resolved: false;
     isRemote: boolean;
     nodePointer?: string;
@@ -58,7 +58,7 @@ export declare type ResolvedRef = {
     isRemote: boolean;
     error?: undefined;
 };
-export declare type ResolvedRefMap = Map<string, ResolvedRef>;
+export type ResolvedRefMap = Map<string, ResolvedRef>;
 export declare function resolveDocument(opts: {
     rootDocument: Document;
     externalRefResolver: BaseResolver;

package/lib/resolve.js

@@ -77,7 +77,7 @@ function makeDocumentFromString(sourceString, absoluteRef) {
     try {
         return {
             source,
-            parsed: utils_1.parseYaml(sourceString, { filename: absoluteRef }),
+            parsed: (0, utils_1.parseYaml)(sourceString, { filename: absoluteRef }),
         };
     }
     catch (e) {
@@ -94,10 +94,10 @@ class BaseResolver {
         return new Set(Array.from(this.cache.keys()));
     }
     resolveExternalRef(base, ref) {
-        if (ref_utils_1.isAbsoluteUrl(ref)) {
+        if ((0, ref_utils_1.isAbsoluteUrl)(ref)) {
             return ref;
         }
-        if (base && ref_utils_1.isAbsoluteUrl(base)) {
+        if (base && (0, ref_utils_1.isAbsoluteUrl)(base)) {
             return new URL(ref, base).href;
         }
         return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
@@ -105,8 +105,8 @@ class BaseResolver {
     loadExternalRef(absoluteRef) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (ref_utils_1.isAbsoluteUrl(absoluteRef)) {
-                    const { body, mimeType } = yield utils_1.readFileFromUrl(absoluteRef, this.config.http);
+                if ((0, ref_utils_1.isAbsoluteUrl)(absoluteRef)) {
+                    const { body, mimeType } = yield (0, utils_1.readFileFromUrl)(absoluteRef, this.config.http);
                     return new Source(absoluteRef, body, mimeType);
                 }
                 else {
@@ -136,7 +136,7 @@ class BaseResolver {
         try {
             return {
                 source,
-                parsed: utils_1.parseYaml(source.body, { filename: source.absoluteRef }),
+                parsed: (0, utils_1.parseYaml)(source.body, { filename: source.absoluteRef }),
             };
         }
         catch (e) {
@@ -212,7 +212,7 @@ function resolveDocument(opts) {
                         return;
                     }
                     for (let i = 0; i < node.length; i++) {
-                        walk(node[i], itemsType || unknownType, ref_utils_1.joinPointer(nodeAbsoluteRef, i));
+                        walk(node[i], itemsType || unknownType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i));
                     }
                     return;
                 }
@@ -230,19 +230,19 @@ function resolveDocument(opts) {
                         propType === unknownType) {
                         propType = types_1.SpecExtension;
                     }
-                    if (!types_1.isNamedType(propType) && (propType === null || propType === void 0 ? void 0 : propType.directResolveAs)) {
+                    if (!(0, types_1.isNamedType)(propType) && (propType === null || propType === void 0 ? void 0 : propType.directResolveAs)) {
                         propType = propType.directResolveAs;
                         propValue = { $ref: propValue };
                     }
                     if (propType && propType.name === undefined && propType.resolvable !== false) {
                         propType = resolvableScalarType;
                     }
-                    if (!types_1.isNamedType(propType) || typeof propValue !== 'object') {
+                    if (!(0, types_1.isNamedType)(propType) || typeof propValue !== 'object') {
                         continue;
                     }
-                    walk(propValue, propType, ref_utils_1.joinPointer(nodeAbsoluteRef, ref_utils_1.escapePointer(propName)));
+                    walk(propValue, propType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, (0, ref_utils_1.escapePointer)(propName)));
                 }
-                if (ref_utils_1.isRef(node)) {
+                if ((0, ref_utils_1.isRef)(node)) {
                     const promise = followRef(rootNodeDocument, node, {
                         prev: null,
                         node,
@@ -259,9 +259,9 @@ function resolveDocument(opts) {
                     if (hasRef(refStack.prev, ref)) {
                         throw new Error('Self-referencing circular pointer');
                     }
-                    if (ref_utils_1.isAnchor(ref.$ref)) {
+                    if ((0, ref_utils_1.isAnchor)(ref.$ref)) {
                         // Wait for all anchors in the document to be collected firstly.
-                        yield utils_1.nextTick();
+                        yield (0, utils_1.nextTick)();
                         const resolvedRef = {
                             resolved: true,
                             isRemote: false,
@@ -273,7 +273,7 @@ function resolveDocument(opts) {
                         resolvedRefMap.set(refId, resolvedRef);
                         return resolvedRef;
                     }
-                    const { uri, pointer } = ref_utils_1.parseRef(ref.$ref);
+                    const { uri, pointer } = (0, ref_utils_1.parseRef)(ref.$ref);
                     const isRemote = uri !== null;
                     let targetDoc;
                     try {
@@ -308,9 +308,9 @@ function resolveDocument(opts) {
                         }
                         else if (target[segment] !== undefined) {
                             target = target[segment];
-                            resolvedRef.nodePointer = ref_utils_1.joinPointer(resolvedRef.nodePointer, ref_utils_1.escapePointer(segment));
+                            resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
                         }
-                        else if (ref_utils_1.isRef(target)) {
+                        else if ((0, ref_utils_1.isRef)(target)) {
                             resolvedRef = yield followRef(targetDoc, target, pushRef(refStack, target));
                             targetDoc = resolvedRef.document || targetDoc;
                             if (typeof resolvedRef.node !== 'object') {
@@ -318,7 +318,7 @@ function resolveDocument(opts) {
                                 break;
                             }
                             target = resolvedRef.node[segment];
-                            resolvedRef.nodePointer = ref_utils_1.joinPointer(resolvedRef.nodePointer, ref_utils_1.escapePointer(segment));
+                            resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
                         }
                         else {
                             target = undefined;
@@ -328,7 +328,7 @@ function resolveDocument(opts) {
                     resolvedRef.node = target;
                     resolvedRef.document = targetDoc;
                     const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-                    if (resolvedRef.document && ref_utils_1.isRef(target)) {
+                    if (resolvedRef.document && (0, ref_utils_1.isRef)(target)) {
                         resolvedRef = yield followRef(resolvedRef.document, target, pushRef(refStack, target));
                     }
                     resolvedRefMap.set(refId, resolvedRef);

package/lib/rules/ajv.js

@@ -71,7 +71,7 @@ function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, allo
         if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
             const property = error.params.additionalProperty || error.params.unevaluatedProperty;
             message = `${message} \`${property}\``;
-            error.instancePath += '/' + ref_utils_1.escapePointer(property);
+            error.instancePath += '/' + (0, ref_utils_1.escapePointer)(property);
         }
         return Object.assign(Object.assign({}, error), { message,
             suggest });

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

@@ -1,12 +1,3 @@
-import { Async2Rule } from '../../visitors';
-export declare const rules: {
-    spec: Async2Rule;
-    assertions: (opts: Record<string, import("../common/assertions").Assertion>) => (import("../../visitors").Oas3Visitor | import("../../visitors").Oas2Visitor)[];
-    'info-contact': import("../../visitors").Oas3Rule | import("../../visitors").Oas2Rule;
-    'operation-operationId': import("../../visitors").Oas3Rule | import("../../visitors").Oas2Rule;
-    'channels-kebab-case': Async2Rule;
-    'no-channel-trailing-slash': Async2Rule;
-    'tag-description': import("../../visitors").Oas3Rule | import("../../visitors").Oas2Rule;
-    'tags-alphabetical': import("../../visitors").Oas3Rule | import("../../visitors").Oas2Rule;
-};
+import type { Async2RuleSet } from '../../oas-types';
+export declare const rules: Async2RuleSet<'built-in'>;
 export declare const preprocessors: {};

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

@@ -1,11 +1,11 @@
 import { AssertionContext, AssertResult, CustomFunction } from 'core/src/config/types';
 import { Location } from '../../../ref-utils';
-export declare type AssertionFnContext = AssertionContext & {
+export type AssertionFnContext = AssertionContext & {
     baseLocation: Location;
     rawValue?: any;
 };
-export declare type AssertionFn = (value: any, condition: any, ctx: AssertionFnContext) => AssertResult[];
-export declare type Asserts = {
+export type AssertionFn = (value: any, condition: any, ctx: AssertionFnContext) => AssertResult[];
+export type Asserts = {
     pattern: AssertionFn;
     notPattern: AssertionFn;
     enum: AssertionFn;

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;