@redocly/openapi-core 0.0.0-snapshot.1744362365 → 0.0.0-snapshot.1744801622

package/lib/config/config.js

@@ -1,25 +1,28 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { parseYaml, stringifyYaml } from '../js-yaml/index.js';
-import { slash, doesYamlFileExist, isPlainObject, showWarningForDeprecatedField, } from '../utils.js';
-import { SpecVersion, SpecMajorVersion } from '../oas-types.js';
-import { isBrowser } from '../env.js';
-import { getResolveConfig } from './utils.js';
-import { isAbsoluteUrl } from '../ref-utils.js';
-export const IGNORE_FILE = '.redocly.lint-ignore.yaml';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = exports.StyleguideConfig = exports.IGNORE_FILE = void 0;
+const fs = require("fs");
+const path = require("path");
+const js_yaml_1 = require("../js-yaml");
+const utils_1 = require("../utils");
+const oas_types_1 = require("../oas-types");
+const env_1 = require("../env");
+const utils_2 = require("./utils");
+const ref_utils_1 = require("../ref-utils");
+exports.IGNORE_FILE = '.redocly.lint-ignore.yaml';
 const IGNORE_BANNER = `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
     `# See https://redocly.com/docs/cli/ for more information.\n`;
 function getIgnoreFilePath(configFile) {
     if (configFile) {
-        return doesYamlFileExist(configFile)
-            ? path.join(path.dirname(configFile), IGNORE_FILE)
-            : path.join(configFile, IGNORE_FILE);
+        return (0, utils_1.doesYamlFileExist)(configFile)
+            ? path.join(path.dirname(configFile), exports.IGNORE_FILE)
+            : path.join(configFile, exports.IGNORE_FILE);
     }
     else {
-        return isBrowser ? undefined : path.join(process.cwd(), IGNORE_FILE);
+        return env_1.isBrowser ? undefined : path.join(process.cwd(), exports.IGNORE_FILE);
     }
 }
-export class StyleguideConfig {
+class StyleguideConfig {
     constructor(rawConfig, configFile) {
         this.rawConfig = rawConfig;
         this.configFile = configFile;
@@ -41,67 +44,67 @@ export class StyleguideConfig {
         ];
         replaceSpecWithStruct(ruleGroups, rawConfig);
         this.rules = {
-            [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 },
-            [SpecVersion.Async3]: { ...rawConfig.rules, ...rawConfig.async3Rules },
-            [SpecVersion.Arazzo1]: { ...rawConfig.rules, ...rawConfig.arazzo1Rules },
-            [SpecVersion.Overlay1]: { ...rawConfig.rules, ...rawConfig.overlay1Rules },
+            [oas_types_1.SpecVersion.OAS2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
+            [oas_types_1.SpecVersion.OAS3_0]: { ...rawConfig.rules, ...rawConfig.oas3_0Rules },
+            [oas_types_1.SpecVersion.OAS3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
+            [oas_types_1.SpecVersion.Async2]: { ...rawConfig.rules, ...rawConfig.async2Rules },
+            [oas_types_1.SpecVersion.Async3]: { ...rawConfig.rules, ...rawConfig.async3Rules },
+            [oas_types_1.SpecVersion.Arazzo1]: { ...rawConfig.rules, ...rawConfig.arazzo1Rules },
+            [oas_types_1.SpecVersion.Overlay1]: { ...rawConfig.rules, ...rawConfig.overlay1Rules },
         };
         this.preprocessors = {
-            [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 },
-            [SpecVersion.Async3]: { ...rawConfig.preprocessors, ...rawConfig.async3Preprocessors },
-            [SpecVersion.Arazzo1]: { ...rawConfig.arazzo1Preprocessors },
-            [SpecVersion.Overlay1]: { ...rawConfig.preprocessors, ...rawConfig.overlay1Preprocessors },
+            [oas_types_1.SpecVersion.OAS2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },
+            [oas_types_1.SpecVersion.OAS3_0]: { ...rawConfig.preprocessors, ...rawConfig.oas3_0Preprocessors },
+            [oas_types_1.SpecVersion.OAS3_1]: { ...rawConfig.preprocessors, ...rawConfig.oas3_1Preprocessors },
+            [oas_types_1.SpecVersion.Async2]: { ...rawConfig.preprocessors, ...rawConfig.async2Preprocessors },
+            [oas_types_1.SpecVersion.Async3]: { ...rawConfig.preprocessors, ...rawConfig.async3Preprocessors },
+            [oas_types_1.SpecVersion.Arazzo1]: { ...rawConfig.arazzo1Preprocessors },
+            [oas_types_1.SpecVersion.Overlay1]: { ...rawConfig.preprocessors, ...rawConfig.overlay1Preprocessors },
         };
         this.decorators = {
-            [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 },
-            [SpecVersion.Async3]: { ...rawConfig.decorators, ...rawConfig.async3Decorators },
-            [SpecVersion.Arazzo1]: { ...rawConfig.arazzo1Decorators },
-            [SpecVersion.Overlay1]: { ...rawConfig.decorators, ...rawConfig.overlay1Decorators },
+            [oas_types_1.SpecVersion.OAS2]: { ...rawConfig.decorators, ...rawConfig.oas2Decorators },
+            [oas_types_1.SpecVersion.OAS3_0]: { ...rawConfig.decorators, ...rawConfig.oas3_0Decorators },
+            [oas_types_1.SpecVersion.OAS3_1]: { ...rawConfig.decorators, ...rawConfig.oas3_1Decorators },
+            [oas_types_1.SpecVersion.Async2]: { ...rawConfig.decorators, ...rawConfig.async2Decorators },
+            [oas_types_1.SpecVersion.Async3]: { ...rawConfig.decorators, ...rawConfig.async3Decorators },
+            [oas_types_1.SpecVersion.Arazzo1]: { ...rawConfig.arazzo1Decorators },
+            [oas_types_1.SpecVersion.Overlay1]: { ...rawConfig.decorators, ...rawConfig.overlay1Decorators },
         };
         this.extendPaths = rawConfig.extendPaths || [];
         this.pluginPaths = rawConfig.pluginPaths || [];
         this.resolveIgnore(getIgnoreFilePath(configFile));
     }
     resolveIgnore(ignoreFile) {
-        if (!ignoreFile || !doesYamlFileExist(ignoreFile))
+        if (!ignoreFile || !(0, utils_1.doesYamlFileExist)(ignoreFile))
             return;
         this.ignore =
-            parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) || {};
-        replaceSpecWithStruct(Object.keys(this.ignore), this.ignore); // FIXME: remove this (2.0)
+            (0, js_yaml_1.parseYaml)(fs.readFileSync(ignoreFile, 'utf-8')) || {};
+        replaceSpecWithStruct(Object.keys(this.ignore), this.ignore);
         // resolve ignore paths
         for (const fileName of Object.keys(this.ignore)) {
-            this.ignore[isAbsoluteUrl(fileName) ? fileName : path.resolve(path.dirname(ignoreFile), fileName)] = this.ignore[fileName];
+            this.ignore[(0, ref_utils_1.isAbsoluteUrl)(fileName) ? fileName : path.resolve(path.dirname(ignoreFile), fileName)] = this.ignore[fileName];
             for (const ruleId of Object.keys(this.ignore[fileName])) {
                 this.ignore[fileName][ruleId] = new Set(this.ignore[fileName][ruleId]);
             }
-            if (!isAbsoluteUrl(fileName)) {
+            if (!(0, ref_utils_1.isAbsoluteUrl)(fileName)) {
                 delete this.ignore[fileName];
             }
         }
     }
     saveIgnore() {
         const dir = this.configFile ? path.dirname(this.configFile) : process.cwd();
-        const ignoreFile = path.join(dir, IGNORE_FILE);
+        const ignoreFile = path.join(dir, exports.IGNORE_FILE);
         const mapped = {};
         for (const absFileName of Object.keys(this.ignore)) {
-            const mappedDefinitionName = isAbsoluteUrl(absFileName)
+            const mappedDefinitionName = (0, ref_utils_1.isAbsoluteUrl)(absFileName)
                 ? absFileName
-                : slash(path.relative(dir, absFileName));
+                : (0, utils_1.slash)(path.relative(dir, absFileName));
             const ignoredRules = (mapped[mappedDefinitionName] = this.ignore[absFileName]);
             for (const ruleId of Object.keys(ignoredRules)) {
                 ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]);
             }
         }
-        fs.writeFileSync(ignoreFile, IGNORE_BANNER + stringifyYaml(mapped));
+        fs.writeFileSync(ignoreFile, IGNORE_BANNER + (0, js_yaml_1.stringifyYaml)(mapped));
     }
     addIgnore(problem) {
         const ignore = this.ignore;
@@ -131,33 +134,33 @@ export class StyleguideConfig {
         for (const plugin of this.plugins) {
             if (plugin.typeExtension !== undefined) {
                 switch (version) {
-                    case SpecVersion.OAS3_0:
-                    case SpecVersion.OAS3_1:
+                    case oas_types_1.SpecVersion.OAS3_0:
+                    case oas_types_1.SpecVersion.OAS3_1:
                         if (!plugin.typeExtension.oas3)
                             continue;
                         extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
                         break;
-                    case SpecVersion.OAS2:
+                    case oas_types_1.SpecVersion.OAS2:
                         if (!plugin.typeExtension.oas2)
                             continue;
                         extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
                         break;
-                    case SpecVersion.Async2:
+                    case oas_types_1.SpecVersion.Async2:
                         if (!plugin.typeExtension.async2)
                             continue;
                         extendedTypes = plugin.typeExtension.async2(extendedTypes, version);
                         break;
-                    case SpecVersion.Async3:
+                    case oas_types_1.SpecVersion.Async3:
                         if (!plugin.typeExtension.async3)
                             continue;
                         extendedTypes = plugin.typeExtension.async3(extendedTypes, version);
                         break;
-                    case SpecVersion.Arazzo1:
+                    case oas_types_1.SpecVersion.Arazzo1:
                         if (!plugin.typeExtension.arazzo1)
                             continue;
                         extendedTypes = plugin.typeExtension.arazzo1(extendedTypes, version);
                         break;
-                    case SpecVersion.Overlay1:
+                    case oas_types_1.SpecVersion.Overlay1:
                         if (!plugin.typeExtension.overlay1)
                             continue;
                         extendedTypes = plugin.typeExtension.overlay1(extendedTypes, version);
@@ -225,42 +228,42 @@ export class StyleguideConfig {
     }
     getRulesForSpecVersion(version) {
         switch (version) {
-            case SpecMajorVersion.OAS3:
+            case oas_types_1.SpecMajorVersion.OAS3:
                 // eslint-disable-next-line no-case-declarations
                 const oas3Rules = [];
                 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 SpecMajorVersion.OAS2:
+            case oas_types_1.SpecMajorVersion.OAS2:
                 // eslint-disable-next-line no-case-declarations
                 const oas2Rules = [];
                 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:
+            case oas_types_1.SpecMajorVersion.Async2:
                 // eslint-disable-next-line no-case-declarations
                 const asyncApi2Rules = [];
                 this.plugins.forEach((p) => p.preprocessors?.async2 && asyncApi2Rules.push(p.preprocessors.async2));
                 this.plugins.forEach((p) => p.rules?.async2 && asyncApi2Rules.push(p.rules.async2));
                 this.plugins.forEach((p) => p.decorators?.async2 && asyncApi2Rules.push(p.decorators.async2));
                 return asyncApi2Rules;
-            case SpecMajorVersion.Async3:
+            case oas_types_1.SpecMajorVersion.Async3:
                 // eslint-disable-next-line no-case-declarations
                 const asyncApi3Rules = [];
                 this.plugins.forEach((p) => p.preprocessors?.async3 && asyncApi3Rules.push(p.preprocessors.async3));
                 this.plugins.forEach((p) => p.rules?.async3 && asyncApi3Rules.push(p.rules.async3));
                 this.plugins.forEach((p) => p.decorators?.async3 && asyncApi3Rules.push(p.decorators.async3));
                 return asyncApi3Rules;
-            case SpecMajorVersion.Arazzo1:
+            case oas_types_1.SpecMajorVersion.Arazzo1:
                 // eslint-disable-next-line no-case-declarations
                 const arazzo1Rules = [];
                 this.plugins.forEach((p) => p.preprocessors?.arazzo1 && arazzo1Rules.push(p.preprocessors.arazzo1));
                 this.plugins.forEach((p) => p.rules?.arazzo1 && arazzo1Rules.push(p.rules.arazzo1));
                 this.plugins.forEach((p) => p.decorators?.arazzo1 && arazzo1Rules.push(p.decorators.arazzo1));
                 return arazzo1Rules;
-            case SpecMajorVersion.Overlay1:
+            case oas_types_1.SpecMajorVersion.Overlay1:
                 // eslint-disable-next-line no-case-declarations
                 const overlay1Rules = [];
                 this.plugins.forEach((p) => p.preprocessors?.overlay1 && overlay1Rules.push(p.preprocessors.overlay1));
@@ -271,7 +274,7 @@ export class StyleguideConfig {
     }
     skipRules(rules) {
         for (const ruleId of rules || []) {
-            for (const version of Object.values(SpecVersion)) {
+            for (const version of Object.values(oas_types_1.SpecVersion)) {
                 if (this.rules[version][ruleId]) {
                     this.rules[version][ruleId] = 'off';
                 }
@@ -288,7 +291,7 @@ export class StyleguideConfig {
     }
     skipPreprocessors(preprocessors) {
         for (const preprocessorId of preprocessors || []) {
-            for (const version of Object.values(SpecVersion)) {
+            for (const version of Object.values(oas_types_1.SpecVersion)) {
                 if (this.preprocessors[version][preprocessorId]) {
                     this.preprocessors[version][preprocessorId] = 'off';
                 }
@@ -297,7 +300,7 @@ export class StyleguideConfig {
     }
     skipDecorators(decorators) {
         for (const decoratorId of decorators || []) {
-            for (const version of Object.values(SpecVersion)) {
+            for (const version of Object.values(oas_types_1.SpecVersion)) {
                 if (this.decorators[version][decoratorId]) {
                     this.decorators[version][decoratorId] = 'off';
                 }
@@ -305,25 +308,29 @@ export class StyleguideConfig {
         }
     }
 }
+exports.StyleguideConfig = StyleguideConfig;
 // To support backwards compatibility with the old `spec` key we rename it to `struct`.
 function replaceSpecWithStruct(ruleGroups, config) {
     for (const ruleGroup of ruleGroups) {
-        if (config[ruleGroup] && isPlainObject(config[ruleGroup]) && 'spec' in config[ruleGroup]) {
-            showWarningForDeprecatedField('spec', 'struct');
+        if (config[ruleGroup] && (0, utils_1.isPlainObject)(config[ruleGroup]) && 'spec' in config[ruleGroup]) {
+            (0, utils_1.showWarningForDeprecatedField)('spec', 'struct');
             config[ruleGroup].struct = config[ruleGroup].spec;
             delete config[ruleGroup].spec;
         }
     }
 }
-export class Config {
+class Config {
     constructor(rawConfig, configFile) {
         this.rawConfig = rawConfig;
         this.configFile = configFile;
         this.apis = rawConfig.apis || {};
         this.styleguide = new StyleguideConfig(rawConfig.styleguide || {}, configFile);
-        this.theme = rawConfig.theme || {}; // FIXME: theme is deprecated (2.0)
-        this.resolve = getResolveConfig(rawConfig?.resolve);
+        this.theme = rawConfig.theme || {};
+        this.resolve = (0, utils_2.getResolveConfig)(rawConfig?.resolve);
+        this.region = rawConfig.region;
+        this.organization = rawConfig.organization;
+        this.files = rawConfig.files || [];
         this.telemetry = rawConfig.telemetry;
     }
 }
-//# sourceMappingURL=config.js.map
+exports.Config = Config;

package/lib/config/index.d.ts

@@ -1,8 +1,7 @@
-export * from './config.js';
-export * from './types.js';
-export * from './rules.js';
-export * from './builtIn.js';
-export * from './load.js';
-export * from './utils.js';
-export * from './config-resolvers.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './config';
+export * from './types';
+export * from './rules';
+export * from './builtIn';
+export * from './load';
+export * from './utils';
+export * from './config-resolvers';

package/lib/config/index.js

@@ -1,8 +1,23 @@
-export * from './config.js';
-export * from './types.js';
-export * from './rules.js';
-export * from './builtIn.js';
-export * from './load.js';
-export * from './utils.js';
-export * from './config-resolvers.js';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./rules"), exports);
+__exportStar(require("./builtIn"), exports);
+__exportStar(require("./load"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./config-resolvers"), exports);

package/lib/config/load.d.ts

@@ -1,7 +1,8 @@
-import { BaseResolver } from '../resolve.js';
-import type { Config } from './config.js';
-import type { Document, ResolvedRefMap } from '../resolve.js';
-import type { RawConfig, RawUniversalConfig } from './types.js';
+import { BaseResolver } from '../resolve';
+import type { Config } from './config';
+import type { Document, ResolvedRefMap } from '../resolve';
+import type { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
+import type { RawConfig, RawUniversalConfig, Region } from './types';
 export type RawConfigProcessor = (params: {
     document: Document;
     resolvedRefMap: ResolvedRefMap;
@@ -13,6 +14,8 @@ export declare function loadConfig(options?: {
     customExtends?: string[];
     processRawConfig?: RawConfigProcessor;
     externalRefResolver?: BaseResolver;
+    files?: string[];
+    region?: Region;
 }): Promise<Config>;
 export declare const CONFIG_FILE_NAMES: string[];
 export declare function findConfig(dir?: string): string | undefined;
@@ -27,9 +30,9 @@ export declare function getConfig(options?: {
 }>;
 type CreateConfigOptions = {
     extends?: string[];
+    tokens?: RegionalTokenWithValidity[];
     configPath?: string;
     externalRefResolver?: BaseResolver;
 };
 export declare function createConfig(config: string | RawUniversalConfig, options?: CreateConfigOptions): Promise<Config>;
 export {};
-//# sourceMappingURL=load.d.ts.map

package/lib/config/load.js

@@ -1,35 +1,81 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { isEmptyObject } from '../utils.js';
-import { parseYaml } from '../js-yaml/index.js';
-import { ConfigValidationError, transformConfig, deepCloneMapWithJSON } from './utils.js';
-import { resolveConfig, resolveConfigFileAndRefs } from './config-resolvers.js';
-import { bundleConfig } from '../bundle.js';
-import { BaseResolver } from '../resolve.js';
-async function addConfigMetadata({ rawConfig, customExtends, configPath, externalRefResolver, }) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_FILE_NAMES = void 0;
+exports.loadConfig = loadConfig;
+exports.findConfig = findConfig;
+exports.getConfig = getConfig;
+exports.createConfig = createConfig;
+const fs = require("fs");
+const path = require("path");
+const redocly_1 = require("../redocly");
+const utils_1 = require("../utils");
+const js_yaml_1 = require("../js-yaml");
+const utils_2 = require("./utils");
+const config_resolvers_1 = require("./config-resolvers");
+const bundle_1 = require("../bundle");
+const resolve_1 = require("../resolve");
+const env_1 = require("../env");
+const domains_1 = require("../redocly/domains");
+async function addConfigMetadata({ rawConfig, customExtends, configPath, tokens, files, region, externalRefResolver, }) {
     if (customExtends !== undefined) {
         rawConfig.styleguide = rawConfig.styleguide || {};
         rawConfig.styleguide.extends = customExtends;
     }
-    else if (isEmptyObject(rawConfig)) {
+    else if ((0, utils_1.isEmptyObject)(rawConfig)) {
         rawConfig.styleguide = { extends: ['recommended'], recommendedFallback: true };
     }
-    return resolveConfig({
-        rawConfig,
+    if (tokens?.length) {
+        if (!rawConfig.resolve)
+            rawConfig.resolve = {};
+        if (!rawConfig.resolve.http)
+            rawConfig.resolve.http = {};
+        rawConfig.resolve.http.headers = [...(rawConfig.resolve.http.headers ?? [])];
+        for (const item of tokens) {
+            const domain = domains_1.DOMAINS[item.region];
+            rawConfig.resolve.http.headers.push({
+                matches: `https://api.${domain}/registry/**`,
+                name: 'Authorization',
+                envVariable: undefined,
+                value: item.token,
+            }, 
+            //support redocly.com domain for future compatibility
+            ...(item.region === 'us'
+                ? [
+                    {
+                        matches: `https://api.redoc.ly/registry/**`,
+                        name: 'Authorization',
+                        envVariable: undefined,
+                        value: item.token,
+                    },
+                ]
+                : []));
+        }
+    }
+    return (0, config_resolvers_1.resolveConfig)({
+        rawConfig: {
+            ...rawConfig,
+            files: files ?? rawConfig.files,
+            region: region ?? rawConfig.region,
+        },
         configPath,
         externalRefResolver,
     });
 }
-export async function loadConfig(options = {}) {
-    const { configPath = findConfig(), customExtends, processRawConfig, externalRefResolver, } = options;
+async function loadConfig(options = {}) {
+    const { configPath = findConfig(), customExtends, processRawConfig, files, region, externalRefResolver, } = options;
     const { rawConfig, document, parsed, resolvedRefMap } = await getConfig({
         configPath,
         externalRefResolver,
     });
+    const redoclyClient = env_1.isBrowser ? undefined : new redocly_1.RedoclyClient();
+    const tokens = redoclyClient && redoclyClient.hasTokens() ? redoclyClient.getAllTokens() : [];
     const config = await addConfigMetadata({
         rawConfig,
         customExtends,
         configPath,
+        tokens,
+        files,
+        region,
         externalRefResolver,
     });
     if (document && parsed && resolvedRefMap && typeof processRawConfig === 'function') {
@@ -42,7 +88,7 @@ export async function loadConfig(options = {}) {
             });
         }
         catch (e) {
-            if (e instanceof ConfigValidationError) {
+            if (e instanceof utils_2.ConfigValidationError) {
                 throw e;
             }
             throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
@@ -50,11 +96,11 @@ export async function loadConfig(options = {}) {
     }
     return config;
 }
-export const CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
-export function findConfig(dir) {
-    if (!fs?.existsSync)
+exports.CONFIG_FILE_NAMES = ['redocly.yaml', 'redocly.yml', '.redocly.yaml', '.redocly.yml'];
+function findConfig(dir) {
+    if (!fs?.hasOwnProperty?.('existsSync'))
         return;
-    const existingConfigFiles = CONFIG_FILE_NAMES.map((name) => dir ? path.resolve(dir, name) : name).filter(fs.existsSync);
+    const existingConfigFiles = exports.CONFIG_FILE_NAMES.map((name) => dir ? path.resolve(dir, name) : name).filter(fs.existsSync);
     if (existingConfigFiles.length > 1) {
         throw new Error(`
       Multiple configuration files are not allowed.
@@ -64,19 +110,19 @@ export function findConfig(dir) {
     }
     return existingConfigFiles[0];
 }
-export async function getConfig(options = {}) {
-    const { configPath = findConfig(), externalRefResolver = new BaseResolver() } = options;
+async function getConfig(options = {}) {
+    const { configPath = findConfig(), externalRefResolver = new resolve_1.BaseResolver() } = options;
     if (!configPath)
         return { rawConfig: {} };
     try {
-        const { document, resolvedRefMap } = await resolveConfigFileAndRefs({
+        const { document, resolvedRefMap } = await (0, config_resolvers_1.resolveConfigFileAndRefs)({
             configPath,
             externalRefResolver,
         });
-        const bundledRefMap = deepCloneMapWithJSON(resolvedRefMap);
-        const parsed = await bundleConfig(JSON.parse(JSON.stringify(document)), bundledRefMap);
+        const bundledRefMap = (0, utils_2.deepCloneMapWithJSON)(resolvedRefMap);
+        const parsed = await (0, bundle_1.bundleConfig)(JSON.parse(JSON.stringify(document)), bundledRefMap);
         return {
-            rawConfig: transformConfig(parsed),
+            rawConfig: (0, utils_2.transformConfig)(parsed),
             document,
             parsed,
             resolvedRefMap,
@@ -86,10 +132,9 @@ export async function getConfig(options = {}) {
         throw new Error(`Error parsing config file at '${configPath}': ${e.message}`);
     }
 }
-export async function createConfig(config, options) {
+async function createConfig(config, options) {
     return addConfigMetadata({
-        rawConfig: transformConfig(typeof config === 'string' ? parseYaml(config) : config),
+        rawConfig: (0, utils_2.transformConfig)(typeof config === 'string' ? (0, js_yaml_1.parseYaml)(config) : config),
         ...options,
     });
 }
-//# sourceMappingURL=load.js.map

package/lib/config/minimal.d.ts

@@ -1,4 +1,3 @@
-import type { PluginStyleguideConfig } from './types.js';
+import type { PluginStyleguideConfig } from './types';
 declare const minimal: PluginStyleguideConfig<'built-in'>;
 export default minimal;
-//# sourceMappingURL=minimal.d.ts.map

package/lib/config/minimal.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const minimal = {
     rules: {
         struct: 'error',
@@ -204,5 +206,4 @@ const minimal = {
         'info-contact': 'off',
     },
 };
-export default minimal;
-//# sourceMappingURL=minimal.js.map
+exports.default = minimal;

package/lib/config/recommended-strict.d.ts

@@ -1,4 +1,3 @@
-import type { PluginStyleguideConfig } from './types.js';
+import type { PluginStyleguideConfig } from './types';
 declare const recommendedStrict: PluginStyleguideConfig<'built-in'>;
 export default recommendedStrict;
-//# sourceMappingURL=recommended-strict.d.ts.map

package/lib/config/recommended-strict.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const recommendedStrict = {
     rules: {
         struct: 'error',
@@ -204,5 +206,4 @@ const recommendedStrict = {
         'info-contact': 'off',
     },
 };
-export default recommendedStrict;
-//# sourceMappingURL=recommended-strict.js.map
+exports.default = recommendedStrict;

package/lib/config/recommended.d.ts

@@ -1,4 +1,3 @@
-import type { PluginStyleguideConfig } from './types.js';
+import type { PluginStyleguideConfig } from './types';
 declare const recommended: PluginStyleguideConfig<'built-in'>;
 export default recommended;
-//# sourceMappingURL=recommended.d.ts.map

package/lib/config/recommended.js

@@ -1,3 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const recommended = {
     rules: {
         struct: 'error',
@@ -204,5 +206,4 @@ const recommended = {
         'info-contact': 'off',
     },
 };
-export default recommended;
-//# sourceMappingURL=recommended.js.map
+exports.default = recommended;

package/lib/config/rules.d.ts

@@ -1,6 +1,6 @@
-import type { Arazzo1RuleSet, Async2RuleSet, Async3RuleSet, Oas2RuleSet, Oas3RuleSet, Overlay1RuleSet, SpecVersion } from '../oas-types.js';
-import type { StyleguideConfig } from './config.js';
-import type { ProblemSeverity } from '../walk.js';
+import type { Arazzo1RuleSet, Async2RuleSet, Async3RuleSet, Oas2RuleSet, Oas3RuleSet, Overlay1RuleSet, SpecVersion } from '../oas-types';
+import type { StyleguideConfig } from './config';
+import type { ProblemSeverity } from '../walk';
 type InitializedRule = {
     severity: ProblemSeverity;
     ruleId: string;
@@ -8,4 +8,3 @@ type InitializedRule = {
 };
 export declare function initRules(rules: (Oas3RuleSet | Oas2RuleSet | Async2RuleSet | Async3RuleSet | Arazzo1RuleSet | Overlay1RuleSet)[], config: StyleguideConfig, type: 'rules' | 'preprocessors' | 'decorators', oasVersion: SpecVersion): InitializedRule[];
 export {};
-//# sourceMappingURL=rules.d.ts.map

package/lib/config/rules.js

@@ -1,5 +1,8 @@
-import { isDefined } from '../utils.js';
-export function initRules(rules, config, type, oasVersion) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRules = initRules;
+const utils_1 = require("../utils");
+function initRules(rules, config, type, oasVersion) {
     return rules
         .flatMap((ruleset) => Object.keys(ruleset).map((ruleId) => {
         const rule = ruleset[ruleId];
@@ -30,6 +33,5 @@ export function initRules(rules, config, type, oasVersion) {
         };
     }))
         .flatMap((visitor) => visitor)
-        .filter(isDefined);
+        .filter(utils_1.isDefined);
 }
-//# sourceMappingURL=rules.js.map

package/lib/config/spec.d.ts

@@ -1,4 +1,3 @@
-import type { PluginStyleguideConfig } from './types.js';
+import type { PluginStyleguideConfig } from './types';
 declare const spec: PluginStyleguideConfig<'built-in'>;
 export default spec;
-//# sourceMappingURL=spec.d.ts.map