@redocly/openapi-core 1.0.2 → 1.2.0

package/src/bundle.ts

@@ -1,12 +1,9 @@
 import isEqual = require('lodash.isequal');
 import { BaseResolver, resolveDocument, Document, ResolvedRefMap, makeRefId } from './resolve';
 import { Oas3Rule, normalizeVisitors, Oas3Visitor, Oas2Visitor } from './visitors';
-import { Oas3Types } from './types/oas3';
-import { Oas2Types } from './types/oas2';
-import { Oas3_1Types } from './types/oas3_1';
 import { NormalizedNodeType, normalizeTypes, NodeType } from './types';
 import { WalkContext, walkDocument, UserContext, ResolveResult, NormalizedProblem } from './walk';
-import { detectOpenAPI, openAPIMajor, OasMajorVersion } from './oas-types';
+import { detectSpec, getTypes, getMajorSpecVersion, SpecMajorVersion } from './oas-types';
 import { isAbsoluteUrl, isRef, Location, refBaseName } from './ref-utils';
 import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
@@ -93,27 +90,20 @@ export async function bundleDocument(opts: {
     removeUnusedComponents = false,
     keepUrlRefs = false,
   } = opts;
-  const oasVersion = detectOpenAPI(document.parsed);
-  const oasMajorVersion = openAPIMajor(oasVersion);
-  const rules = config.getRulesForOasVersion(oasMajorVersion);
+  const specVersion = detectSpec(document.parsed);
+  const specMajorVersion = getMajorSpecVersion(specVersion);
+  const rules = config.getRulesForOasVersion(specMajorVersion);
   const types = normalizeTypes(
-    config.extendTypes(
-      customTypes ?? oasMajorVersion === OasMajorVersion.Version3
-        ? oasVersion === OasVersion.Version3_1
-          ? Oas3_1Types
-          : Oas3Types
-        : Oas2Types,
-      oasVersion
-    ),
+    config.extendTypes(customTypes ?? getTypes(specVersion), specVersion),
     config
   );
 
-  const preprocessors = initRules(rules as any, config, 'preprocessors', oasVersion);
-  const decorators = initRules(rules as any, config, 'decorators', oasVersion);
+  const preprocessors = initRules(rules as any, config, 'preprocessors', specVersion);
+  const decorators = initRules(rules as any, config, 'decorators', specVersion);
 
   const ctx: BundleContext = {
     problems: [],
-    oasVersion: oasVersion,
+    oasVersion: specVersion,
     refTypes: new Map<string, NormalizedNodeType>(),
     visitorsData: {},
   };
@@ -123,7 +113,7 @@ export async function bundleDocument(opts: {
       severity: 'error',
       ruleId: 'remove-unused-components',
       visitor:
-        oasMajorVersion === OasMajorVersion.Version2
+        specMajorVersion === SpecMajorVersion.OAS2
           ? RemoveUnusedComponentsOas2({})
           : RemoveUnusedComponentsOas3({}),
     });
@@ -157,7 +147,7 @@ export async function bundleDocument(opts: {
         severity: 'error',
         ruleId: 'bundler',
         visitor: makeBundleVisitor(
-          oasMajorVersion,
+          specMajorVersion,
           dereference,
           skipRedoclyRegistryRefs,
           document,
@@ -188,9 +178,9 @@ export async function bundleDocument(opts: {
   };
 }
 
-export function mapTypeToComponent(typeName: string, version: OasMajorVersion) {
+export function mapTypeToComponent(typeName: string, version: SpecMajorVersion) {
   switch (version) {
-    case OasMajorVersion.Version3:
+    case SpecMajorVersion.OAS3:
       switch (typeName) {
         case 'Schema':
           return 'schemas';
@@ -213,7 +203,7 @@ export function mapTypeToComponent(typeName: string, version: OasMajorVersion) {
         default:
           return null;
       }
-    case OasMajorVersion.Version2:
+    case SpecMajorVersion.OAS2:
       switch (typeName) {
         case 'Schema':
           return 'definitions';
@@ -224,13 +214,22 @@ export function mapTypeToComponent(typeName: string, version: OasMajorVersion) {
         default:
           return null;
       }
+    case SpecMajorVersion.Async2:
+      switch (typeName) {
+        case 'Schema':
+          return 'schemas';
+        case 'Parameter':
+          return 'parameters';
+        default:
+          return null;
+      }
   }
 }
 
 // function oas3Move
 
 function makeBundleVisitor(
-  version: OasMajorVersion,
+  version: SpecMajorVersion,
   dereference: boolean,
   skipRedoclyRegistryRefs: boolean,
   rootDocument: Document,
@@ -282,16 +281,16 @@ function makeBundleVisitor(
     Root: {
       enter(root: any, ctx: any) {
         rootLocation = ctx.location;
-        if (version === OasMajorVersion.Version3) {
+        if (version === SpecMajorVersion.OAS3) {
           components = root.components = root.components || {};
-        } else if (version === OasMajorVersion.Version2) {
+        } else if (version === SpecMajorVersion.OAS2) {
           components = root;
         }
       },
     },
   };
 
-  if (version === OasMajorVersion.Version3) {
+  if (version === SpecMajorVersion.OAS3) {
     visitor.DiscriminatorMapping = {
       leave(mapping: Record<string, string>, ctx: any) {
         for (const name of Object.keys(mapping)) {
@@ -345,7 +344,7 @@ function makeBundleVisitor(
     components[componentType] = components[componentType] || {};
     const name = getComponentName(target, componentType, ctx);
     components[componentType][name] = target.node;
-    if (version === OasMajorVersion.Version3) {
+    if (version === SpecMajorVersion.OAS3) {
       return `#/components/${componentType}/${name}`;
     } else {
       return `#/${componentType}/${name}`;

package/src/config/__tests__/__snapshots__/config.test.ts.snap

@@ -6,6 +6,11 @@ StyleguideConfig {
   "_usedVersions": Set {},
   "configFile": undefined,
   "decorators": Object {
+    "async2": Object {
+      "oas2": Object {},
+      "oas3_0": Object {},
+      "oas3_1": Object {},
+    },
     "oas2": Object {
       "oas2": Object {},
       "oas3_0": Object {},
@@ -39,6 +44,11 @@ StyleguideConfig {
   "pluginPaths": Array [],
   "plugins": Array [],
   "preprocessors": Object {
+    "async2": Object {
+      "oas2": Object {},
+      "oas3_0": Object {},
+      "oas3_1": Object {},
+    },
     "oas2": Object {
       "oas2": Object {},
       "oas3_0": Object {},
@@ -97,6 +107,20 @@ StyleguideConfig {
   },
   "recommendedFallback": false,
   "rules": Object {
+    "async2": Object {
+      "oas2": Object {
+        "no-empty-servers": "error",
+        "operation-summary": "error",
+      },
+      "oas3_0": Object {
+        "no-empty-servers": "error",
+        "operation-summary": "error",
+      },
+      "oas3_1": Object {
+        "no-empty-servers": "error",
+        "operation-summary": "error",
+      },
+    },
     "oas2": Object {
       "oas2": Object {
         "no-empty-servers": "error",

package/src/config/__tests__/config.test.ts

@@ -1,4 +1,4 @@
-import { OasVersion } from '../../oas-types';
+import { SpecVersion } from '../../oas-types';
 import { Config, StyleguideConfig } from '../config';
 import { getMergedConfig } from '../utils';
 import { doesYamlFileExist } from '../../utils';
@@ -117,6 +117,7 @@ describe('getMergedConfig', () => {
           "_usedVersions": Set {},
           "configFile": "redocly.yaml",
           "decorators": Object {
+            "async2": Object {},
             "oas2": Object {},
             "oas3_0": Object {},
             "oas3_1": Object {},
@@ -127,6 +128,7 @@ describe('getMergedConfig', () => {
           "pluginPaths": Array [],
           "plugins": Array [],
           "preprocessors": Object {
+            "async2": Object {},
             "oas2": Object {},
             "oas3_0": Object {},
             "oas3_1": Object {},
@@ -140,6 +142,9 @@ describe('getMergedConfig', () => {
           },
           "recommendedFallback": false,
           "rules": Object {
+            "async2": Object {
+              "operation-summary": "warn",
+            },
             "oas2": Object {
               "operation-summary": "warn",
             },
@@ -217,6 +222,7 @@ describe('getMergedConfig', () => {
           "_usedVersions": Set {},
           "configFile": "redocly.yaml",
           "decorators": Object {
+            "async2": Object {},
             "oas2": Object {},
             "oas3_0": Object {},
             "oas3_1": Object {},
@@ -227,6 +233,7 @@ describe('getMergedConfig', () => {
           "pluginPaths": Array [],
           "plugins": Array [],
           "preprocessors": Object {
+            "async2": Object {},
             "oas2": Object {},
             "oas3_0": Object {},
             "oas3_1": Object {},
@@ -242,6 +249,10 @@ describe('getMergedConfig', () => {
           },
           "recommendedFallback": false,
           "rules": Object {
+            "async2": Object {
+              "no-empty-servers": "error",
+              "operation-summary": "error",
+            },
             "oas2": Object {
               "no-empty-servers": "error",
               "operation-summary": "error",
@@ -279,19 +290,19 @@ describe('StyleguideConfig.extendTypes', () => {
   };
   it('should call only oas3 types extension', () => {
     const styleguideConfig = new StyleguideConfig(testRawConfigStyleguide);
-    styleguideConfig.extendTypes({}, OasVersion.Version3_0);
+    styleguideConfig.extendTypes({}, SpecVersion.OAS3_0);
     expect(oas3).toHaveBeenCalledTimes(1);
     expect(oas2).toHaveBeenCalledTimes(0);
   });
   it('should call only oas2 types extension', () => {
     const styleguideConfig = new StyleguideConfig(testRawConfigStyleguide);
-    styleguideConfig.extendTypes({}, OasVersion.Version2);
+    styleguideConfig.extendTypes({}, SpecVersion.OAS2);
     expect(oas3).toHaveBeenCalledTimes(0);
     expect(oas2).toHaveBeenCalledTimes(1);
   });
   it('should throw error if for oas version different from 2 and 3', () => {
     const styleguideConfig = new StyleguideConfig(testRawConfigStyleguide);
-    expect(() => styleguideConfig.extendTypes({}, 'something else' as OasVersion)).toThrowError(
+    expect(() => styleguideConfig.extendTypes({}, 'something else' as SpecVersion)).toThrowError(
       'Not implemented'
     );
   });

package/src/config/builtIn.ts

@@ -3,6 +3,7 @@ import all from './all';
 import minimal from './minimal';
 import { rules as oas3Rules } from '../rules/oas3';
 import { rules as oas2Rules } from '../rules/oas2';
+import { rules as async2Rules } from '../rules/async2';
 import { preprocessors as oas3Preprocessors } from '../rules/oas3';
 import { preprocessors as oas2Preprocessors } from '../rules/oas2';
 import { decorators as oas3Decorators } from '../decorators/oas3';
@@ -24,14 +25,17 @@ export const defaultPlugin: Plugin = {
   rules: {
     oas3: oas3Rules,
     oas2: oas2Rules,
+    async2: async2Rules,
   } as CustomRulesConfig,
   preprocessors: {
     oas3: oas3Preprocessors,
     oas2: oas2Preprocessors,
+    async2: {},
   },
   decorators: {
     oas3: oas3Decorators,
     oas2: oas2Decorators,
+    async2: {},
   },
   configs: builtInConfigs,
 };

package/src/config/config-resolvers.ts

@@ -141,8 +141,8 @@ export function resolvePlugins(
       };
 
       if (pluginModule.rules) {
-        if (!pluginModule.rules.oas3 && !pluginModule.rules.oas2) {
-          throw new Error(`Plugin rules must have \`oas3\` or \`oas2\` rules "${p}.`);
+        if (!pluginModule.rules.oas3 && !pluginModule.rules.oas2 && !pluginModule.rules.async2) {
+          throw new Error(`Plugin rules must have \`oas3\`, \`oas2\` or \`async2\` rules "${p}.`);
         }
         plugin.rules = {};
         if (pluginModule.rules.oas3) {
@@ -151,11 +151,18 @@ export function resolvePlugins(
         if (pluginModule.rules.oas2) {
           plugin.rules.oas2 = prefixRules(pluginModule.rules.oas2, id);
         }
+        if (pluginModule.rules.async2) {
+          plugin.rules.async2 = prefixRules(pluginModule.rules.async2, id);
+        }
       }
       if (pluginModule.preprocessors) {
-        if (!pluginModule.preprocessors.oas3 && !pluginModule.preprocessors.oas2) {
+        if (
+          !pluginModule.preprocessors.oas3 &&
+          !pluginModule.preprocessors.oas2 &&
+          !pluginModule.preprocessors.async2
+        ) {
           throw new Error(
-            `Plugin \`preprocessors\` must have \`oas3\` or \`oas2\` preprocessors "${p}.`
+            `Plugin \`preprocessors\` must have \`oas3\`, \`oas2\` or \`async2\` preprocessors "${p}.`
           );
         }
         plugin.preprocessors = {};
@@ -165,11 +172,20 @@ export function resolvePlugins(
         if (pluginModule.preprocessors.oas2) {
           plugin.preprocessors.oas2 = prefixRules(pluginModule.preprocessors.oas2, id);
         }
+        if (pluginModule.preprocessors.async2) {
+          plugin.preprocessors.async2 = prefixRules(pluginModule.preprocessors.async2, id);
+        }
       }
 
       if (pluginModule.decorators) {
-        if (!pluginModule.decorators.oas3 && !pluginModule.decorators.oas2) {
-          throw new Error(`Plugin \`decorators\` must have \`oas3\` or \`oas2\` decorators "${p}.`);
+        if (
+          !pluginModule.decorators.oas3 &&
+          !pluginModule.decorators.oas2 &&
+          !pluginModule.decorators.async2
+        ) {
+          throw new Error(
+            `Plugin \`decorators\` must have \`oas3\`, \`oas2\` or \`async2\` decorators "${p}.`
+          );
         }
         plugin.decorators = {};
         if (pluginModule.decorators.oas3) {
@@ -178,6 +194,9 @@ export function resolvePlugins(
         if (pluginModule.decorators.oas2) {
           plugin.decorators.oas2 = prefixRules(pluginModule.decorators.oas2, id);
         }
+        if (pluginModule.decorators.async2) {
+          plugin.decorators.async2 = prefixRules(pluginModule.decorators.async2, id);
+        }
       }
 
       if (pluginModule.assertions) {

package/src/config/config.ts

@@ -3,7 +3,13 @@ import * as path from 'path';
 import { parseYaml, stringifyYaml } from '../js-yaml';
 import { slash, doesYamlFileExist } from '../utils';
 import { NormalizedProblem } from '../walk';
-import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
+import {
+  SpecVersion,
+  SpecMajorVersion,
+  Oas2RuleSet,
+  Oas3RuleSet,
+  Async2RuleSet,
+} from '../oas-types';
 import { isBrowser, env } from '../env';
 
 import type { NodeType } from '../types';
@@ -65,12 +71,12 @@ export class StyleguideConfig {
   plugins: Plugin[];
   ignore: Record<string, Record<string, Set<string>>> = {};
   doNotResolveExamples: boolean;
-  rules: Record<OasVersion, Record<string, RuleConfig>>;
-  preprocessors: Record<OasVersion, Record<string, PreprocessorConfig>>;
-  decorators: Record<OasVersion, Record<string, DecoratorConfig>>;
+  rules: Record<SpecVersion, Record<string, RuleConfig>>;
+  preprocessors: Record<SpecVersion, Record<string, PreprocessorConfig>>;
+  decorators: Record<SpecVersion, Record<string, DecoratorConfig>>;
 
   private _usedRules: Set<string> = new Set();
-  private _usedVersions: Set<OasVersion> = new Set();
+  private _usedVersions: Set<SpecVersion> = new Set();
 
   recommendedFallback: boolean;
 
@@ -83,21 +89,24 @@ export class StyleguideConfig {
     this.recommendedFallback = rawConfig.recommendedFallback || false;
 
     this.rules = {
-      [OasVersion.Version2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
-      [OasVersion.Version3_0]: { ...rawConfig.rules, ...rawConfig.oas3_0Rules },
-      [OasVersion.Version3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
+      [SpecVersion.OAS2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
+      [SpecVersion.OAS3_0]: { ...rawConfig.rules, ...rawConfig.oas3_0Rules },
+      [SpecVersion.OAS3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
+      [SpecVersion.Async2]: { ...rawConfig.rules, ...rawConfig.async2Rules },
     };
 
     this.preprocessors = {
-      [OasVersion.Version2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },
-      [OasVersion.Version3_0]: { ...rawConfig.preprocessors, ...rawConfig.oas3_0Preprocessors },
-      [OasVersion.Version3_1]: { ...rawConfig.preprocessors, ...rawConfig.oas3_1Preprocessors },
+      [SpecVersion.OAS2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },
+      [SpecVersion.OAS3_0]: { ...rawConfig.preprocessors, ...rawConfig.oas3_0Preprocessors },
+      [SpecVersion.OAS3_1]: { ...rawConfig.preprocessors, ...rawConfig.oas3_1Preprocessors },
+      [SpecVersion.Async2]: { ...rawConfig.preprocessors, ...rawConfig.async2Preprocessors },
     };
 
     this.decorators = {
-      [OasVersion.Version2]: { ...rawConfig.decorators, ...rawConfig.oas2Decorators },
-      [OasVersion.Version3_0]: { ...rawConfig.decorators, ...rawConfig.oas3_0Decorators },
-      [OasVersion.Version3_1]: { ...rawConfig.decorators, ...rawConfig.oas3_1Decorators },
+      [SpecVersion.OAS2]: { ...rawConfig.decorators, ...rawConfig.oas2Decorators },
+      [SpecVersion.OAS3_0]: { ...rawConfig.decorators, ...rawConfig.oas3_0Decorators },
+      [SpecVersion.OAS3_1]: { ...rawConfig.decorators, ...rawConfig.oas3_1Decorators },
+      [SpecVersion.Async2]: { ...rawConfig.decorators, ...rawConfig.async2Decorators },
     };
 
     this.extendPaths = rawConfig.extendPaths || [];
@@ -173,20 +182,24 @@ export class StyleguideConfig {
       : problem;
   }
 
-  extendTypes(types: Record<string, NodeType>, version: OasVersion) {
+  extendTypes(types: Record<string, NodeType>, version: SpecVersion) {
     let extendedTypes = types;
     for (const plugin of this.plugins) {
       if (plugin.typeExtension !== undefined) {
         switch (version) {
-          case OasVersion.Version3_0:
-          case OasVersion.Version3_1:
+          case SpecVersion.OAS3_0:
+          case SpecVersion.OAS3_1:
             if (!plugin.typeExtension.oas3) continue;
             extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
             break;
-          case OasVersion.Version2:
+          case SpecVersion.OAS2:
             if (!plugin.typeExtension.oas2) continue;
             extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
             break;
+          case SpecVersion.Async2:
+            if (!plugin.typeExtension.async2) continue;
+            extendedTypes = plugin.typeExtension.async2(extendedTypes, version);
+            break;
           default:
             throw new Error('Not implemented');
         }
@@ -195,7 +208,7 @@ export class StyleguideConfig {
     return extendedTypes;
   }
 
-  getRuleSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
+  getRuleSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
     const settings = this.rules[oasVersion][ruleId] || 'off';
@@ -208,7 +221,7 @@ export class StyleguideConfig {
     }
   }
 
-  getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
+  getPreprocessorSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
 
@@ -222,7 +235,7 @@ export class StyleguideConfig {
     }
   }
 
-  getDecoratorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings {
+  getDecoratorSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings {
     this._usedRules.add(ruleId);
     this._usedVersions.add(oasVersion);
     const settings = this.decorators[oasVersion][ruleId] || 'off';
@@ -259,28 +272,39 @@ export class StyleguideConfig {
     };
   }
 
-  getRulesForOasVersion(version: OasMajorVersion) {
+  getRulesForOasVersion(version: SpecMajorVersion) {
     switch (version) {
-      case OasMajorVersion.Version3:
+      case SpecMajorVersion.OAS3:
         // eslint-disable-next-line no-case-declarations
         const oas3Rules: Oas3RuleSet[] = []; // default ruleset
         this.plugins.forEach((p) => p.preprocessors?.oas3 && oas3Rules.push(p.preprocessors.oas3));
         this.plugins.forEach((p) => p.rules?.oas3 && oas3Rules.push(p.rules.oas3));
         this.plugins.forEach((p) => p.decorators?.oas3 && oas3Rules.push(p.decorators.oas3));
         return oas3Rules;
-      case OasMajorVersion.Version2:
+      case SpecMajorVersion.OAS2:
         // eslint-disable-next-line no-case-declarations
         const oas2Rules: Oas2RuleSet[] = []; // default ruleset
         this.plugins.forEach((p) => p.preprocessors?.oas2 && oas2Rules.push(p.preprocessors.oas2));
         this.plugins.forEach((p) => p.rules?.oas2 && oas2Rules.push(p.rules.oas2));
         this.plugins.forEach((p) => p.decorators?.oas2 && oas2Rules.push(p.decorators.oas2));
         return oas2Rules;
+      case SpecMajorVersion.Async2:
+        // eslint-disable-next-line no-case-declarations
+        const asyncApiRules: Async2RuleSet[] = []; // default ruleset
+        this.plugins.forEach(
+          (p) => p.preprocessors?.async2 && asyncApiRules.push(p.preprocessors.async2)
+        );
+        this.plugins.forEach((p) => p.rules?.async2 && asyncApiRules.push(p.rules.async2));
+        this.plugins.forEach(
+          (p) => p.decorators?.async2 && asyncApiRules.push(p.decorators.async2)
+        );
+        return asyncApiRules;
     }
   }
 
   skipRules(rules?: string[]) {
     for (const ruleId of rules || []) {
-      for (const version of Object.values(OasVersion)) {
+      for (const version of Object.values(SpecVersion)) {
         if (this.rules[version][ruleId]) {
           this.rules[version][ruleId] = 'off';
         }
@@ -290,7 +314,7 @@ export class StyleguideConfig {
 
   skipPreprocessors(preprocessors?: string[]) {
     for (const preprocessorId of preprocessors || []) {
-      for (const version of Object.values(OasVersion)) {
+      for (const version of Object.values(SpecVersion)) {
         if (this.preprocessors[version][preprocessorId]) {
           this.preprocessors[version][preprocessorId] = 'off';
         }
@@ -300,7 +324,7 @@ export class StyleguideConfig {
 
   skipDecorators(decorators?: string[]) {
     for (const decoratorId of decorators || []) {
-      for (const version of Object.values(OasVersion)) {
+      for (const version of Object.values(SpecVersion)) {
         if (this.decorators[version][decoratorId]) {
           this.decorators[version][decoratorId] = 'off';
         }

package/src/config/rules.ts

@@ -1,4 +1,4 @@
-import { RuleSet, OasVersion } from '../oas-types';
+import { RuleSet, SpecVersion } from '../oas-types';
 import { StyleguideConfig } from './config';
 import { isDefined } from '../utils';
 import type { ProblemSeverity } from '../walk';
@@ -13,7 +13,7 @@ export function initRules<T extends Function, P extends RuleSet<T>>(
   rules: P[],
   config: StyleguideConfig,
   type: 'rules' | 'preprocessors' | 'decorators',
-  oasVersion: OasVersion
+  oasVersion: SpecVersion
 ): InitializedRule[] {
   return rules
     .flatMap((ruleset) =>

package/src/config/types.ts

@@ -1,14 +1,18 @@
 import type { ProblemSeverity, UserContext } from '../walk';
 import type {
   Oas3PreprocessorsSet,
-  OasMajorVersion,
+  SpecMajorVersion,
   Oas3DecoratorsSet,
   Oas2RuleSet,
   Oas2PreprocessorsSet,
   Oas2DecoratorsSet,
   Oas3RuleSet,
-  OasVersion,
+  SpecVersion,
+  Async2PreprocessorsSet,
+  Async2DecoratorsSet,
+  Async2RuleSet,
 } from '../oas-types';
+
 import type { NodeType } from '../types';
 import { Location } from '../ref-utils';
 import type { SkipFunctionContext } from '../visitors';
@@ -43,16 +47,19 @@ export type StyleguideRawConfig = {
   oas2Rules?: Record<string, RuleConfig>;
   oas3_0Rules?: Record<string, RuleConfig>;
   oas3_1Rules?: Record<string, RuleConfig>;
+  async2Rules?: Record<string, RuleConfig>;
 
   preprocessors?: Record<string, PreprocessorConfig>;
   oas2Preprocessors?: Record<string, PreprocessorConfig>;
   oas3_0Preprocessors?: Record<string, PreprocessorConfig>;
   oas3_1Preprocessors?: Record<string, PreprocessorConfig>;
+  async2Preprocessors?: Record<string, PreprocessorConfig>;
 
   decorators?: Record<string, DecoratorConfig>;
   oas2Decorators?: Record<string, DecoratorConfig>;
   oas3_0Decorators?: Record<string, DecoratorConfig>;
   oas3_1Decorators?: Record<string, DecoratorConfig>;
+  async2Decorators?: Record<string, DecoratorConfig>;
 };
 
 export type ApiStyleguideRawConfig = Omit<StyleguideRawConfig, 'plugins'>;
@@ -68,23 +75,26 @@ export type ResolvedStyleguideConfig = PluginStyleguideConfig & {
 export type PreprocessorsConfig = {
   oas3?: Oas3PreprocessorsSet;
   oas2?: Oas2PreprocessorsSet;
+  async2?: Async2PreprocessorsSet;
 };
 
 export type DecoratorsConfig = {
   oas3?: Oas3DecoratorsSet;
   oas2?: Oas2DecoratorsSet;
+  async2?: Async2DecoratorsSet;
 };
 
 export type TypesExtensionFn = (
   types: Record<string, NodeType>,
-  oasVersion: OasVersion
+  oasVersion: SpecVersion
 ) => Record<string, NodeType>;
 
-export type TypeExtensionsConfig = Partial<Record<OasMajorVersion, TypesExtensionFn>>;
+export type TypeExtensionsConfig = Partial<Record<SpecMajorVersion, TypesExtensionFn>>;
 
 export type CustomRulesConfig = {
   oas3?: Oas3RuleSet;
   oas2?: Oas2RuleSet;
+  async2?: Async2RuleSet;
 };
 
 export type AssertionContext = Partial<UserContext> & SkipFunctionContext & { node: any };

package/src/index.ts

@@ -52,7 +52,13 @@ export {
 } from './resolve';
 export { parseYaml, stringifyYaml } from './js-yaml';
 export { unescapePointer, isRef, isAbsoluteUrl } from './ref-utils';
-export { detectOpenAPI, OasMajorVersion, openAPIMajor, OasVersion } from './oas-types';
+export {
+  SpecMajorVersion,
+  getMajorSpecVersion,
+  SpecVersion,
+  detectSpec,
+  getTypes,
+} from './oas-types';
 export { normalizeVisitors } from './visitors';
 
 export {