@redocly/openapi-core 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @redocly/openapi-core
 
+## 1.2.1
+
+### Patch Changes
+
+- Fixed an issue with nested refs in the `join` command.
+- Fixed pattern for no-server-example.com rule to improve detection accuracy.
+- Changed the report location for `pattern` and `notPattern` assertions to be more precise.
+- Updated `unevaluatedItems` type definition to resolve either boolean or object schema per JSON Schema 2019-09 specification.
+- Enhanced public API by small typescript typing fix and exporting new function `bundleFromString`.
+
+## 1.2.0
+
+### Minor Changes
+
+- Added support for linting AsyncAPI v2 files, so that a wider range of API descriptions can use the Redocly linting workflow.
+
+### Patch Changes
+
+- Renamed API definition to API description for consistency.
+
 ## 1.1.0
 
 ### Minor Changes

package/README.md

@@ -2,24 +2,267 @@
 
 See https://github.com/Redocly/redocly-cli
 
+> [!IMPORTANT]
+The `openapi-core package` is designed for our internal use; the interfaces that are considered safe to use are documented below.
+Some of the function arguments are not documented below because they are not intended for public use.
+Avoid using any functions or features that are not documented below.
+If your use case is not documented below, please open an issue.
+
 ## Basic usage
 
-### Lint
+### Lint from file system
+
+[Lint](https://redocly.com/docs/cli/commands/lint/) a file, optionally with a [config file](https://redocly.com/docs/cli/configuration/).
 
 ```js
-import { formatProblems, lint, loadConfig } from '@redocly/openapi-core';
+import { lint, loadConfig } from '@redocly/openapi-core';
 
 const pathToApi = 'openapi.yaml';
-const config = loadConfig({ configPath: 'optional/path/to/.redocly.yaml' });
+const config = await loadConfig({ configPath: 'optional/path/to/redocly.yaml' });
 const lintResults = await lint({ ref: pathToApi, config });
 ```
 
-### Bundle
+The content of `lintResults` describes any errors or warnings found during linting; an empty array means no problems were found.
+For each problem, the rule, severity, feedback message and a location object are provided.
+To learn more, [check the `lint` function section](#lint).
+
+### Bundle from file system
+
+[Bundle](https://redocly.com/docs/cli/commands/bundle/) an API description into a single structure, optionally with a [config file](https://redocly.com/docs/cli/configuration/).
 
 ```js
-import { formatProblems, bundle, loadConfig } from '@redocly/openapi-core';
+import { bundle, loadConfig } from '@redocly/openapi-core';
 
 const pathToApi = 'openapi.yaml';
-const config = loadConfig({ configPath: 'optional/path/to/.redocly.yaml' });
-const { bundle, problems } = await bundle({ ref: pathToApi, config });
+const config = await loadConfig({ configPath: 'optional/path/to/redocly.yaml' });
+const bundleResults = await bundle({ ref: pathToApi, config });
+```
+
+In `bundleResults`, the `bundle.parsed` field has the bundled API description.
+For more information, [check the `bundle` function section](#bundle).
+
+### Lint from memory with config
+
+[Lint](https://redocly.com/docs/cli/commands/lint/) an API description, with configuration defined. This is useful if the API description you're working with isn't a file on disk.
+
+```js
+import { lintFromString, createConfig, stringifyYaml } from '@redocly/openapi-core';
+
+const config = await createConfig(
+  {
+    extends: ['minimal'],
+    rules: {
+      'operation-description': 'error',
+    },
+  },
+  {
+    // optionally provide config path for resolving $refs and proper error locations
+    configPath: 'optional/path/to/redocly.yaml',
+  }
+);
+const source = stringifyYaml({ openapi: '3.0.1' /* ... */ }); // you can also use JSON.stringify
+const lintResults = await lintFromString({
+  source,
+  // optionally pass path to the file for resolving $refs and proper error locations
+  absoluteRef: 'optional/path/to/openapi.yaml',
+  config,
+});
+```
+
+### Lint from memory with a custom plugin
+
+[Lint](https://redocly.com/docs/cli/commands/lint/) an API description, with configuration including a [custom plugin](https://redocly.com/docs/cli/custom-plugins/) to define a rule.
+
+```js
+import { lintFromString, createConfig, stringifyYaml } from '@redocly/openapi-core';
+
+const CustomRule = (ruleOptions) => {
+  return {
+    Operation() {
+      // some rule logic
+    },
+  };
+};
+
+const config = await createConfig({
+  extends: ['recommended'],
+  plugins: [
+    {
+      id: 'pluginId',
+      rules: {
+        oas3: {
+          customRule1: CustomRule,
+        },
+        oas2: {
+          customRule1: CustomRule, // if the same rule can handle both oas3 and oas2
+        },
+      },
+      decorators: {
+        // ...
+      },
+    },
+  ],
+  // enable rule
+  rules: {
+    'pluginId/customRule1': 'error',
+  },
+  decorators: {
+    // ...
+  },
+});
+
+const source = stringifyYaml({ openapi: '3.0.1' /* ... */ }); // you can also use JSON.stringify
+const lintResults = await lintFromString({
+  source,
+  // optionally pass path to the file for resolving $refs and proper error locations
+  absoluteRef: 'optional/path/to/openapi.yaml',
+  config,
+});
+```
+
+### Bundle from memory
+
+[Bundle](https://redocly.com/docs/cli/commands/bundle/) an API description into a single structure, using default configuration.
+
+```js
+import { bundleFromString, createConfig } from '@redocly/openapi-core';
+
+const config = await createConfig({}); // create empty config
+const source = stringifyYaml({ openapi: '3.0.1' /* ... */ }); // you can also use JSON.stringify
+const bundleResults = await bundleFromString({
+  source,
+  // optionally pass path to the file for resolving $refs and proper error locations
+  absoluteRef: 'optional/path/to/openapi.yaml',
+  config,
+});
 ```
+
+## API
+
+### `createConfig`
+
+Creates a config object from a JSON or YAML string or JS object.
+Resolves remote config from `extends` (if there are URLs or local fs paths).
+
+```ts
+async function createConfig(
+  // JSON or YAML string or object with Redocly config
+  config: string | RawUniversalConfig,
+  options?: {
+    // optional path to the config file for resolving $refs and proper error locations
+    configPath?: string;
+  }
+): Promise<Config>;
+```
+
+### `loadConfig`
+
+Loads a config object from a file system. If `configPath` is not provided,
+it tries to find `redocly.yaml` in the current working directory.
+
+```ts
+async function loadConfig(options?: {
+  // optional path to the config file for resolving $refs and proper error locations
+  configPath?: string;
+  // allows to add custom `extends` additionally to one from the config file
+  customExtends?: string[];
+}): Promise<Config>;
+```
+
+### `lint`
+
+Lint an OpenAPI document from the file system.
+
+```ts
+async function lint(options: {
+  // path to the OpenAPI document root
+  ref: string;
+  // config object
+  config: Config;
+}): Promise<NormalizedProblem[]>;
+```
+
+### `lintFromString`
+
+Lint an OpenAPI document from a string.
+
+```ts
+async function lintFromString(options: {
+  // OpenAPI document string
+  source: string;
+  // optional path to the OpenAPI document for resolving $refs and proper error locations
+  absoluteRef?: string;
+  // config object
+  config: Config;
+}): Promise<NormalizedProblem[]>;
+```
+
+### `bundle`
+
+Bundle an OpenAPI document from the file system.
+
+```ts
+async function bundle(options: {
+  // path to the OpenAPI document root
+  ref: string;
+  // config object
+  config: Config;
+  // whether to fully dereference $refs, resulting document won't have any $ref
+  // warning: this can produce circular objects
+  dereference?: boolean;
+  // whether to remove unused components (schemas, parameters, responses, etc)
+  removeUnusedComponents?: boolean;
+  // whether to keep $ref pointers to the http URLs and resolve only local fs $refs
+  keepUrlRefs?: boolean;
+}): Promise<{
+    bundle: {
+      parsed: object; // OpenAPI document object as js object
+    };
+    problems: NormalizedProblem[]
+    fileDependencies
+    rootType
+    refTypes
+    visitorsData
+
+  }>;
+```
+
+### `bundleFromString`
+
+Bundle an OpenAPI document from a string.
+
+```ts
+async function bundleFromString(options: {
+  // OpenAPI document string
+  source: string;
+  // optional path to the OpenAPI document for resolving $refs and proper error locations
+  absoluteRef?: string;
+  // config object
+  config: Config;
+  // whether to fully dereference $refs, resulting document won't have any $ref
+  // warning: this can produce circular objects
+  dereference?: boolean;
+  // whether to remove unused components (schemas, parameters, responses, etc)
+  removeUnusedComponents?: boolean;
+  // whether to keep $ref pointers to the http URLs and resolve only local fs $refs
+  keepUrlRefs?: boolean;
+}): Promise<{
+    bundle: {
+      parsed: object; // OpenAPI document object as js object
+    };
+    problems: NormalizedProblem[]
+    fileDependencies
+    rootType
+    refTypes
+    visitorsData
+
+  }>;
+```
+
+### `stringifyYaml`
+
+Helper function to stringify a javascript object to YAML.
+
+```ts
+function stringifyYaml(obj: object): string;
+```

package/lib/bundle.d.ts

@@ -2,7 +2,7 @@ import { BaseResolver, Document } from './resolve';
 import { Oas3Rule } from './visitors';
 import { NormalizedNodeType, NodeType } from './types';
 import { NormalizedProblem } from './walk';
-import { OasMajorVersion } from './oas-types';
+import { SpecMajorVersion } from './oas-types';
 import type { Config, StyleguideConfig } from './config';
 export declare type Oas3RuleSet = Record<string, Oas3Rule>;
 export declare enum OasVersion {
@@ -10,9 +10,7 @@ export declare enum OasVersion {
     Version3_0 = "oas3_0",
     Version3_1 = "oas3_1"
 }
-export declare function bundle(opts: {
-    ref?: string;
-    doc?: Document;
+export declare type BundleOptions = {
     externalRefResolver?: BaseResolver;
     config: Config;
     dereference?: boolean;
@@ -20,7 +18,15 @@ export declare function bundle(opts: {
     skipRedoclyRegistryRefs?: boolean;
     removeUnusedComponents?: boolean;
     keepUrlRefs?: boolean;
-}): Promise<BundleResult>;
+};
+export declare function bundle(opts: {
+    ref?: string;
+    doc?: Document;
+} & BundleOptions): Promise<BundleResult>;
+export declare function bundleFromString(opts: {
+    source: string;
+    absoluteRef?: string;
+} & BundleOptions): Promise<BundleResult>;
 export declare type BundleResult = {
     bundle: Document;
     problems: NormalizedProblem[];
@@ -39,4 +45,4 @@ export declare function bundleDocument(opts: {
     removeUnusedComponents?: boolean;
     keepUrlRefs?: boolean;
 }): Promise<BundleResult>;
-export declare function mapTypeToComponent(typeName: string, version: OasMajorVersion): "parameters" | "examples" | "headers" | "schemas" | "responses" | "requestBodies" | "securitySchemes" | "links" | "callbacks" | "definitions" | null;
+export declare function mapTypeToComponent(typeName: string, version: SpecMajorVersion): "responses" | "parameters" | "examples" | "headers" | "schemas" | "requestBodies" | "securitySchemes" | "links" | "callbacks" | "definitions" | null;

package/lib/bundle.js

@@ -9,13 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapTypeToComponent = exports.bundleDocument = exports.bundle = exports.OasVersion = void 0;
+exports.mapTypeToComponent = exports.bundleDocument = exports.bundleFromString = exports.bundle = exports.OasVersion = void 0;
 const isEqual = require("lodash.isequal");
 const resolve_1 = require("./resolve");
 const visitors_1 = require("./visitors");
-const oas3_1 = require("./types/oas3");
-const oas2_1 = require("./types/oas2");
-const oas3_1_1 = require("./types/oas3_1");
 const types_1 = require("./types");
 const walk_1 = require("./walk");
 const oas_types_1 = require("./oas-types");
@@ -38,7 +35,7 @@ function bundle(opts) {
         if (!(ref || doc)) {
             throw new Error('Document or reference is required.\n');
         }
-        const document = doc !== undefined ? doc : yield externalRefResolver.resolveDocument(base, ref, true);
+        const document = doc === undefined ? yield externalRefResolver.resolveDocument(base, ref, true) : doc;
         if (document instanceof Error) {
             throw document;
         }
@@ -46,22 +43,26 @@ function bundle(opts) {
     });
 }
 exports.bundle = bundle;
+function bundleFromString(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 || '/');
+        return bundleDocument(Object.assign(Object.assign({ document }, opts), { externalRefResolver, config: opts.config.styleguide }));
+    });
+}
+exports.bundleFromString = bundleFromString;
 function bundleDocument(opts) {
     return __awaiter(this, void 0, void 0, function* () {
         const { document, config, customTypes, externalRefResolver, dereference = false, skipRedoclyRegistryRefs = false, removeUnusedComponents = false, keepUrlRefs = false, } = opts;
-        const oasVersion = oas_types_1.detectOpenAPI(document.parsed);
-        const oasMajorVersion = oas_types_1.openAPIMajor(oasVersion);
-        const rules = config.getRulesForOasVersion(oasMajorVersion);
-        const types = types_1.normalizeTypes(config.extendTypes((customTypes !== null && customTypes !== void 0 ? customTypes : oasMajorVersion === oas_types_1.OasMajorVersion.Version3)
-            ? oasVersion === OasVersion.Version3_1
-                ? oas3_1_1.Oas3_1Types
-                : oas3_1.Oas3Types
-            : oas2_1.Oas2Types, oasVersion), config);
-        const preprocessors = rules_1.initRules(rules, config, 'preprocessors', oasVersion);
-        const decorators = rules_1.initRules(rules, config, 'decorators', oasVersion);
+        const specVersion = oas_types_1.detectSpec(document.parsed);
+        const specMajorVersion = 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 preprocessors = rules_1.initRules(rules, config, 'preprocessors', specVersion);
+        const decorators = rules_1.initRules(rules, config, 'decorators', specVersion);
         const ctx = {
             problems: [],
-            oasVersion: oasVersion,
+            oasVersion: specVersion,
             refTypes: new Map(),
             visitorsData: {},
         };
@@ -69,7 +70,7 @@ function bundleDocument(opts) {
             decorators.push({
                 severity: 'error',
                 ruleId: 'remove-unused-components',
-                visitor: oasMajorVersion === oas_types_1.OasMajorVersion.Version2
+                visitor: specMajorVersion === oas_types_1.SpecMajorVersion.OAS2
                     ? remove_unused_components_1.RemoveUnusedComponents({})
                     : remove_unused_components_2.RemoveUnusedComponents({}),
             });
@@ -98,7 +99,7 @@ function bundleDocument(opts) {
             {
                 severity: 'error',
                 ruleId: 'bundler',
-                visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document, resolvedRefMap, keepUrlRefs),
+                visitor: makeBundleVisitor(specMajorVersion, dereference, skipRedoclyRegistryRefs, document, resolvedRefMap, keepUrlRefs),
             },
             ...decorators,
         ], types);
@@ -122,7 +123,7 @@ function bundleDocument(opts) {
 exports.bundleDocument = bundleDocument;
 function mapTypeToComponent(typeName, version) {
     switch (version) {
-        case oas_types_1.OasMajorVersion.Version3:
+        case oas_types_1.SpecMajorVersion.OAS3:
             switch (typeName) {
                 case 'Schema':
                     return 'schemas';
@@ -145,7 +146,7 @@ function mapTypeToComponent(typeName, version) {
                 default:
                     return null;
             }
-        case oas_types_1.OasMajorVersion.Version2:
+        case oas_types_1.SpecMajorVersion.OAS2:
             switch (typeName) {
                 case 'Schema':
                     return 'definitions';
@@ -156,6 +157,15 @@ function mapTypeToComponent(typeName, version) {
                 default:
                     return null;
             }
+        case oas_types_1.SpecMajorVersion.Async2:
+            switch (typeName) {
+                case 'Schema':
+                    return 'schemas';
+                case 'Parameter':
+                    return 'parameters';
+                default:
+                    return null;
+            }
     }
 }
 exports.mapTypeToComponent = mapTypeToComponent;
@@ -202,16 +212,16 @@ function makeBundleVisitor(version, dereference, skipRedoclyRegistryRefs, rootDo
         Root: {
             enter(root, ctx) {
                 rootLocation = ctx.location;
-                if (version === oas_types_1.OasMajorVersion.Version3) {
+                if (version === oas_types_1.SpecMajorVersion.OAS3) {
                     components = root.components = root.components || {};
                 }
-                else if (version === oas_types_1.OasMajorVersion.Version2) {
+                else if (version === oas_types_1.SpecMajorVersion.OAS2) {
                     components = root;
                 }
             },
         },
     };
-    if (version === oas_types_1.OasMajorVersion.Version3) {
+    if (version === oas_types_1.SpecMajorVersion.OAS3) {
         visitor.DiscriminatorMapping = {
             leave(mapping, ctx) {
                 for (const name of Object.keys(mapping)) {
@@ -259,7 +269,7 @@ function makeBundleVisitor(version, dereference, skipRedoclyRegistryRefs, rootDo
         components[componentType] = components[componentType] || {};
         const name = getComponentName(target, componentType, ctx);
         components[componentType][name] = target.node;
-        if (version === oas_types_1.OasMajorVersion.Version3) {
+        if (version === oas_types_1.SpecMajorVersion.OAS3) {
             return `#/components/${componentType}/${name}`;
         }
         else {

package/lib/config/builtIn.js

@@ -6,6 +6,7 @@ const all_1 = require("./all");
 const minimal_1 = require("./minimal");
 const oas3_1 = require("../rules/oas3");
 const oas2_1 = require("../rules/oas2");
+const async2_1 = require("../rules/async2");
 const oas3_2 = require("../rules/oas3");
 const oas2_2 = require("../rules/oas2");
 const oas3_3 = require("../decorators/oas3");
@@ -23,14 +24,17 @@ exports.defaultPlugin = {
     rules: {
         oas3: oas3_1.rules,
         oas2: oas2_1.rules,
+        async2: async2_1.rules,
     },
     preprocessors: {
         oas3: oas3_2.preprocessors,
         oas2: oas2_2.preprocessors,
+        async2: {},
     },
     decorators: {
         oas3: oas3_3.decorators,
         oas2: oas2_3.decorators,
+        async2: {},
     },
     configs: exports.builtInConfigs,
 };

package/lib/config/config-resolvers.js

@@ -105,8 +105,8 @@ function resolvePlugins(plugins, configPath = '') {
         seenPluginIds.set(id, p.toString());
         const plugin = Object.assign(Object.assign({ id }, (pluginModule.configs ? { configs: pluginModule.configs } : {})), (pluginModule.typeExtension ? { typeExtension: pluginModule.typeExtension } : {}));
         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) {
@@ -115,10 +115,15 @@ function resolvePlugins(plugins, configPath = '') {
             if (pluginModule.rules.oas2) {
                 plugin.rules.oas2 = utils_2.prefixRules(pluginModule.rules.oas2, id);
             }
+            if (pluginModule.rules.async2) {
+                plugin.rules.async2 = utils_2.prefixRules(pluginModule.rules.async2, id);
+            }
         }
         if (pluginModule.preprocessors) {
-            if (!pluginModule.preprocessors.oas3 && !pluginModule.preprocessors.oas2) {
-                throw new Error(`Plugin \`preprocessors\` must have \`oas3\` or \`oas2\` preprocessors "${p}.`);
+            if (!pluginModule.preprocessors.oas3 &&
+                !pluginModule.preprocessors.oas2 &&
+                !pluginModule.preprocessors.async2) {
+                throw new Error(`Plugin \`preprocessors\` must have \`oas3\`, \`oas2\` or \`async2\` preprocessors "${p}.`);
             }
             plugin.preprocessors = {};
             if (pluginModule.preprocessors.oas3) {
@@ -127,10 +132,15 @@ function resolvePlugins(plugins, configPath = '') {
             if (pluginModule.preprocessors.oas2) {
                 plugin.preprocessors.oas2 = utils_2.prefixRules(pluginModule.preprocessors.oas2, id);
             }
+            if (pluginModule.preprocessors.async2) {
+                plugin.preprocessors.async2 = utils_2.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) {
@@ -139,6 +149,9 @@ function resolvePlugins(plugins, configPath = '') {
             if (pluginModule.decorators.oas2) {
                 plugin.decorators.oas2 = utils_2.prefixRules(pluginModule.decorators.oas2, id);
             }
+            if (pluginModule.decorators.async2) {
+                plugin.decorators.async2 = utils_2.prefixRules(pluginModule.decorators.async2, id);
+            }
         }
         if (pluginModule.assertions) {
             plugin.assertions = pluginModule.assertions;

package/lib/config/config.d.ts

@@ -1,5 +1,5 @@
 import { NormalizedProblem } from '../walk';
-import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
+import { SpecVersion, SpecMajorVersion, Oas2RuleSet, Oas3RuleSet, Async2RuleSet } from '../oas-types';
 import type { NodeType } from '../types';
 import type { DecoratorConfig, Plugin, PreprocessorConfig, Region, ResolveConfig, ResolvedApi, ResolvedConfig, ResolvedStyleguideConfig, RuleConfig, RuleSettings, Telemetry, ThemeRawConfig } from './types';
 export declare const IGNORE_FILE = ".redocly.lint-ignore.yaml";
@@ -15,9 +15,9 @@ export declare 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;
     private _usedVersions;
     recommendedFallback: boolean;
@@ -28,16 +28,16 @@ export declare class StyleguideConfig {
     saveIgnore(): void;
     addIgnore(problem: NormalizedProblem): void;
     addProblemToIgnore(problem: NormalizedProblem): NormalizedProblem;
-    extendTypes(types: Record<string, NodeType>, version: OasVersion): Record<string, NodeType>;
-    getRuleSettings(ruleId: string, oasVersion: OasVersion): RuleSettings;
-    getPreprocessorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings;
-    getDecoratorSettings(ruleId: string, oasVersion: OasVersion): RuleSettings;
+    extendTypes(types: Record<string, NodeType>, version: SpecVersion): Record<string, NodeType>;
+    getRuleSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings;
+    getPreprocessorSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings;
+    getDecoratorSettings(ruleId: string, oasVersion: SpecVersion): RuleSettings;
     getUnusedRules(): {
         rules: string[];
         preprocessors: string[];
         decorators: string[];
     };
-    getRulesForOasVersion(version: OasMajorVersion): Oas3RuleSet[] | Oas2RuleSet[];
+    getRulesForOasVersion(version: SpecMajorVersion): Oas3RuleSet[] | Oas2RuleSet[] | Async2RuleSet[];
     skipRules(rules?: string[]): void;
     skipPreprocessors(preprocessors?: string[]): void;
     skipDecorators(decorators?: string[]): void;