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

package/lib/config/config-resolvers.js

@@ -1,21 +1,28 @@
-import * as path from 'node:path';
-import * as url from 'node:url';
-import * as fs from 'node:fs';
-import module from 'node:module';
-import { isAbsoluteUrl } from '../ref-utils.js';
-import { pickDefined, isNotString, isString, isDefined, keysOf } from '../utils.js';
-import { resolveDocument, BaseResolver } from '../resolve.js';
-import { defaultPlugin } from './builtIn.js';
-import { getResolveConfig, getUniquePlugins, isCommonJsPlugin, isDeprecatedPluginFormat, mergeExtends, parsePresetName, prefixRules, transformConfig, } from './utils.js';
-import { isBrowser } from '../env.js';
-import { Config } from './config.js';
-import { colorize, logger } from '../logger.js';
-import { asserts, buildAssertCustomFunction } from '../rules/common/assertions/asserts.js';
-import { NormalizedConfigTypes } from '../types/redocly-yaml.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigFileAndRefs = resolveConfigFileAndRefs;
+exports.resolveConfig = resolveConfig;
+exports.resolvePlugins = resolvePlugins;
+exports.resolveApis = resolveApis;
+exports.resolveStyleguideConfig = resolveStyleguideConfig;
+exports.resolvePreset = resolvePreset;
+const path = require("path");
+const url_1 = require("url");
+const fs_1 = require("fs");
+const ref_utils_1 = require("../ref-utils");
+const utils_1 = require("../utils");
+const resolve_1 = require("../resolve");
+const builtIn_1 = require("./builtIn");
+const utils_2 = require("./utils");
+const env_1 = require("../env");
+const config_1 = require("./config");
+const logger_1 = require("../logger");
+const asserts_1 = require("../rules/common/assertions/asserts");
+const redocly_yaml_1 = require("../types/redocly-yaml");
 const DEFAULT_PROJECT_PLUGIN_PATHS = ['@theme/plugin.js', '@theme/plugin.cjs', '@theme/plugin.mjs'];
 // Cache instantiated plugins during a single execution
 const pluginsCache = new Map();
-export async function resolveConfigFileAndRefs({ configPath, externalRefResolver = new BaseResolver(), base = null, }) {
+async function resolveConfigFileAndRefs({ configPath, externalRefResolver = new resolve_1.BaseResolver(), base = null, }) {
     if (!configPath) {
         throw new Error('Reference to a config is required.\n');
     }
@@ -23,18 +30,18 @@ export async function resolveConfigFileAndRefs({ configPath, externalRefResolver
     if (document instanceof Error) {
         throw document;
     }
-    const resolvedRefMap = await resolveDocument({
+    const resolvedRefMap = await (0, resolve_1.resolveDocument)({
         rootDocument: document,
-        rootType: NormalizedConfigTypes.ConfigRoot,
+        rootType: redocly_yaml_1.NormalizedConfigTypes.ConfigRoot,
         externalRefResolver,
     });
     return { document, resolvedRefMap };
 }
-export async function resolveConfig({ rawConfig, configPath, externalRefResolver, }) {
-    if (rawConfig.styleguide?.extends?.some(isNotString)) {
+async function resolveConfig({ rawConfig, configPath, externalRefResolver, }) {
+    if (rawConfig.styleguide?.extends?.some(utils_1.isNotString)) {
         throw new Error(`Error configuration format not detected in extends value must contain strings`);
     }
-    const resolver = externalRefResolver ?? new BaseResolver(getResolveConfig(rawConfig.resolve));
+    const resolver = externalRefResolver ?? new resolve_1.BaseResolver((0, utils_2.getResolveConfig)(rawConfig.resolve));
     const apis = await resolveApis({
         rawConfig,
         configPath,
@@ -45,7 +52,7 @@ export async function resolveConfig({ rawConfig, configPath, externalRefResolver
         configPath,
         resolver,
     });
-    return new Config({
+    return new config_1.Config({
         ...rawConfig,
         apis,
         styleguide,
@@ -54,52 +61,55 @@ export async function resolveConfig({ rawConfig, configPath, externalRefResolver
 function getDefaultPluginPath(configDir) {
     for (const pluginPath of DEFAULT_PROJECT_PLUGIN_PATHS) {
         const absolutePluginPath = path.resolve(configDir, pluginPath);
-        if (fs.existsSync(absolutePluginPath)) {
+        if ((0, fs_1.existsSync)(absolutePluginPath)) {
             return pluginPath;
         }
     }
     return;
 }
-export async function resolvePlugins(plugins, configDir = '') {
+async function resolvePlugins(plugins, configDir = '') {
     if (!plugins)
         return [];
     // TODO: implement or reuse Resolver approach so it will work in node and browser envs
     const requireFunc = async (plugin) => {
-        if (isString(plugin)) {
+        if ((0, utils_1.isString)(plugin)) {
             try {
                 const maybeAbsolutePluginPath = path.resolve(configDir, plugin);
-                const absolutePluginPath = fs.existsSync(maybeAbsolutePluginPath)
+                const absolutePluginPath = (0, fs_1.existsSync)(maybeAbsolutePluginPath)
                     ? maybeAbsolutePluginPath
                     : // For plugins imported from packages specifically
-                        module.createRequire(import.meta.url ?? __dirname).resolve(plugin, {
+                        require.resolve(plugin, {
                             paths: [
                                 // Plugins imported from the node_modules in the project directory
                                 configDir,
                                 // Plugins imported from the node_modules in the package install directory (for example, npx cache directory)
-                                import.meta.url ? path.dirname(url.fileURLToPath(import.meta.url)) : __dirname,
+                                __dirname,
                             ],
                         });
                 if (!pluginsCache.has(absolutePluginPath)) {
                     let requiredPlugin;
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore FIXME: investigate if we still need this (2.0)
+                    // @ts-ignore
                     if (typeof __webpack_require__ === 'function') {
                         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                        // @ts-ignore FIXME: investigate if we still need this (2.0)
+                        // @ts-ignore
                         requiredPlugin = __non_webpack_require__(absolutePluginPath);
                     }
                     else {
-                        const mod = await import(url.pathToFileURL(absolutePluginPath).pathname);
+                        // Workaround for dynamic imports being transpiled to require by Typescript: https://github.com/microsoft/TypeScript/issues/43329#issuecomment-811606238
+                        const _importDynamic = new Function('modulePath', 'return import(modulePath)');
+                        // you can import both cjs and mjs
+                        const mod = await _importDynamic((0, url_1.pathToFileURL)(absolutePluginPath).href);
                         requiredPlugin = mod.default || mod;
                     }
                     const pluginCreatorOptions = { contentDir: configDir };
-                    const pluginModule = isDeprecatedPluginFormat(requiredPlugin)
+                    const pluginModule = (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)
                         ? requiredPlugin
-                        : isCommonJsPlugin(requiredPlugin)
+                        : (0, utils_2.isCommonJsPlugin)(requiredPlugin)
                             ? await requiredPlugin(pluginCreatorOptions)
                             : await requiredPlugin?.default?.(pluginCreatorOptions);
-                    if (pluginModule?.id && isDeprecatedPluginFormat(requiredPlugin)) {
-                        logger.info(`Deprecated plugin format detected: ${pluginModule.id}\n`);
+                    if (pluginModule?.id && (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)) {
+                        logger_1.logger.info(`Deprecated plugin format detected: ${pluginModule.id}\n`);
                     }
                     if (pluginModule) {
                         pluginsCache.set(absolutePluginPath, {
@@ -127,9 +137,9 @@ export async function resolvePlugins(plugins, configDir = '') {
     }
     const resolvedPlugins = new Set();
     const instances = await Promise.all(plugins.map(async (p) => {
-        if (isString(p)) {
-            if (isAbsoluteUrl(p)) {
-                throw new Error(colorize.red(`We don't support remote plugins yet.`));
+        if ((0, utils_1.isString)(p)) {
+            if ((0, ref_utils_1.isAbsoluteUrl)(p)) {
+                throw new Error(logger_1.colorize.red(`We don't support remote plugins yet.`));
             }
             if (resolvedPlugins.has(p)) {
                 return;
@@ -142,11 +152,11 @@ export async function resolvePlugins(plugins, configDir = '') {
         }
         const id = pluginModule.id;
         if (typeof id !== 'string') {
-            throw new Error(colorize.red(`Plugin must define \`id\` property in ${colorize.blue(p.toString())}.`));
+            throw new Error(logger_1.colorize.red(`Plugin must define \`id\` property in ${logger_1.colorize.blue(p.toString())}.`));
         }
         if (seenPluginIds.has(id)) {
             const pluginPath = seenPluginIds.get(id);
-            throw new Error(colorize.red(`Plugin "id" must be unique. Plugin ${colorize.blue(p.toString())} uses id "${colorize.blue(id)}" already seen in ${colorize.blue(pluginPath)}`));
+            throw new Error(logger_1.colorize.red(`Plugin "id" must be unique. Plugin ${logger_1.colorize.blue(p.toString())} uses id "${logger_1.colorize.blue(id)}" already seen in ${logger_1.colorize.blue(pluginPath)}`));
         }
         seenPluginIds.set(id, p.toString());
         const plugin = {
@@ -165,22 +175,22 @@ export async function resolvePlugins(plugins, configDir = '') {
             }
             plugin.rules = {};
             if (pluginModule.rules.oas3) {
-                plugin.rules.oas3 = prefixRules(pluginModule.rules.oas3, id);
+                plugin.rules.oas3 = (0, utils_2.prefixRules)(pluginModule.rules.oas3, id);
             }
             if (pluginModule.rules.oas2) {
-                plugin.rules.oas2 = prefixRules(pluginModule.rules.oas2, id);
+                plugin.rules.oas2 = (0, utils_2.prefixRules)(pluginModule.rules.oas2, id);
             }
             if (pluginModule.rules.async2) {
-                plugin.rules.async2 = prefixRules(pluginModule.rules.async2, id);
+                plugin.rules.async2 = (0, utils_2.prefixRules)(pluginModule.rules.async2, id);
             }
             if (pluginModule.rules.async3) {
-                plugin.rules.async3 = prefixRules(pluginModule.rules.async3, id);
+                plugin.rules.async3 = (0, utils_2.prefixRules)(pluginModule.rules.async3, id);
             }
             if (pluginModule.rules.arazzo1) {
-                plugin.rules.arazzo1 = prefixRules(pluginModule.rules.arazzo1, id);
+                plugin.rules.arazzo1 = (0, utils_2.prefixRules)(pluginModule.rules.arazzo1, id);
             }
             if (pluginModule.rules.overlay1) {
-                plugin.rules.overlay1 = prefixRules(pluginModule.rules.overlay1, id);
+                plugin.rules.overlay1 = (0, utils_2.prefixRules)(pluginModule.rules.overlay1, id);
             }
         }
         if (pluginModule.preprocessors) {
@@ -194,22 +204,22 @@ export async function resolvePlugins(plugins, configDir = '') {
             }
             plugin.preprocessors = {};
             if (pluginModule.preprocessors.oas3) {
-                plugin.preprocessors.oas3 = prefixRules(pluginModule.preprocessors.oas3, id);
+                plugin.preprocessors.oas3 = (0, utils_2.prefixRules)(pluginModule.preprocessors.oas3, id);
             }
             if (pluginModule.preprocessors.oas2) {
-                plugin.preprocessors.oas2 = prefixRules(pluginModule.preprocessors.oas2, id);
+                plugin.preprocessors.oas2 = (0, utils_2.prefixRules)(pluginModule.preprocessors.oas2, id);
             }
             if (pluginModule.preprocessors.async2) {
-                plugin.preprocessors.async2 = prefixRules(pluginModule.preprocessors.async2, id);
+                plugin.preprocessors.async2 = (0, utils_2.prefixRules)(pluginModule.preprocessors.async2, id);
             }
             if (pluginModule.preprocessors.async3) {
-                plugin.preprocessors.async3 = prefixRules(pluginModule.preprocessors.async3, id);
+                plugin.preprocessors.async3 = (0, utils_2.prefixRules)(pluginModule.preprocessors.async3, id);
             }
             if (pluginModule.preprocessors.arazzo1) {
-                plugin.preprocessors.arazzo1 = prefixRules(pluginModule.preprocessors.arazzo1, id);
+                plugin.preprocessors.arazzo1 = (0, utils_2.prefixRules)(pluginModule.preprocessors.arazzo1, id);
             }
             if (pluginModule.preprocessors.overlay1) {
-                plugin.preprocessors.overlay1 = prefixRules(pluginModule.preprocessors.overlay1, id);
+                plugin.preprocessors.overlay1 = (0, utils_2.prefixRules)(pluginModule.preprocessors.overlay1, id);
             }
         }
         if (pluginModule.decorators) {
@@ -223,22 +233,22 @@ export async function resolvePlugins(plugins, configDir = '') {
             }
             plugin.decorators = {};
             if (pluginModule.decorators.oas3) {
-                plugin.decorators.oas3 = prefixRules(pluginModule.decorators.oas3, id);
+                plugin.decorators.oas3 = (0, utils_2.prefixRules)(pluginModule.decorators.oas3, id);
             }
             if (pluginModule.decorators.oas2) {
-                plugin.decorators.oas2 = prefixRules(pluginModule.decorators.oas2, id);
+                plugin.decorators.oas2 = (0, utils_2.prefixRules)(pluginModule.decorators.oas2, id);
             }
             if (pluginModule.decorators.async2) {
-                plugin.decorators.async2 = prefixRules(pluginModule.decorators.async2, id);
+                plugin.decorators.async2 = (0, utils_2.prefixRules)(pluginModule.decorators.async2, id);
             }
             if (pluginModule.decorators.async3) {
-                plugin.decorators.async3 = prefixRules(pluginModule.decorators.async3, id);
+                plugin.decorators.async3 = (0, utils_2.prefixRules)(pluginModule.decorators.async3, id);
             }
             if (pluginModule.decorators.arazzo1) {
-                plugin.decorators.arazzo1 = prefixRules(pluginModule.decorators.arazzo1, id);
+                plugin.decorators.arazzo1 = (0, utils_2.prefixRules)(pluginModule.decorators.arazzo1, id);
             }
             if (pluginModule.decorators.overlay1) {
-                plugin.decorators.overlay1 = prefixRules(pluginModule.decorators.overlay1, id);
+                plugin.decorators.overlay1 = (0, utils_2.prefixRules)(pluginModule.decorators.overlay1, id);
             }
         }
         if (pluginModule.assertions) {
@@ -249,13 +259,13 @@ export async function resolvePlugins(plugins, configDir = '') {
             ...plugin,
         };
     }));
-    return instances.filter(isDefined);
+    return instances.filter(utils_1.isDefined);
 }
-export async function resolveApis({ rawConfig, configPath = '', resolver, }) {
+async function resolveApis({ rawConfig, configPath = '', resolver, }) {
     const { apis = {}, styleguide: styleguideConfig = {} } = rawConfig;
     const resolvedApis = {};
     for (const [apiName, apiContent] of Object.entries(apis || {})) {
-        if (apiContent.styleguide?.extends?.some(isNotString)) {
+        if (apiContent.styleguide?.extends?.some(utils_1.isNotString)) {
             throw new Error(`Error configuration format not detected in extends value must contain strings`);
         }
         const rawStyleguideConfig = getMergedRawStyleguideConfig(styleguideConfig, apiContent.styleguide);
@@ -268,27 +278,27 @@ export async function resolveApis({ rawConfig, configPath = '', resolver, }) {
     }
     return resolvedApis;
 }
-async function resolveAndMergeNestedStyleguideConfig({ styleguideConfig, configPath = '', resolver = new BaseResolver(), parentConfigPaths = [], extendPaths = [], }) {
+async function resolveAndMergeNestedStyleguideConfig({ styleguideConfig, configPath = '', resolver = new resolve_1.BaseResolver(), parentConfigPaths = [], extendPaths = [], }) {
     if (parentConfigPaths.includes(configPath)) {
         throw new Error(`Circular dependency in config file: "${configPath}"`);
     }
-    const plugins = isBrowser
+    const plugins = env_1.isBrowser
         ? // In browser, we don't support plugins from config file yet
-            [defaultPlugin]
-        : getUniquePlugins(await resolvePlugins([...(styleguideConfig?.plugins || []), defaultPlugin], path.dirname(configPath)));
+            [builtIn_1.defaultPlugin]
+        : (0, utils_2.getUniquePlugins)(await resolvePlugins([...(styleguideConfig?.plugins || []), builtIn_1.defaultPlugin], path.dirname(configPath)));
     const pluginPaths = styleguideConfig?.plugins
-        ?.filter(isString)
+        ?.filter(utils_1.isString)
         .map((p) => path.resolve(path.dirname(configPath), p));
-    const resolvedConfigPath = isAbsoluteUrl(configPath)
+    const resolvedConfigPath = (0, ref_utils_1.isAbsoluteUrl)(configPath)
         ? configPath
         : configPath && path.resolve(configPath);
     const extendConfigs = await Promise.all(styleguideConfig?.extends?.map(async (presetItem) => {
-        if (!isAbsoluteUrl(presetItem) && !path.extname(presetItem)) {
+        if (!(0, ref_utils_1.isAbsoluteUrl)(presetItem) && !path.extname(presetItem)) {
             return resolvePreset(presetItem, plugins);
         }
-        const pathItem = isAbsoluteUrl(presetItem)
+        const pathItem = (0, ref_utils_1.isAbsoluteUrl)(presetItem)
             ? presetItem
-            : isAbsoluteUrl(configPath)
+            : (0, ref_utils_1.isAbsoluteUrl)(configPath)
                 ? new URL(presetItem, configPath).href
                 : path.resolve(path.dirname(configPath), presetItem);
         const extendedStyleguideConfig = await loadExtendStyleguideConfig(pathItem, resolver);
@@ -300,7 +310,7 @@ async function resolveAndMergeNestedStyleguideConfig({ styleguideConfig, configP
             extendPaths,
         });
     }) || []);
-    const { plugins: mergedPlugins = [], ...styleguide } = mergeExtends([
+    const { plugins: mergedPlugins = [], ...styleguide } = (0, utils_2.mergeExtends)([
         ...extendConfigs,
         {
             ...styleguideConfig,
@@ -312,37 +322,37 @@ async function resolveAndMergeNestedStyleguideConfig({ styleguideConfig, configP
     ]);
     return {
         ...styleguide,
-        extendPaths: styleguide.extendPaths?.filter((path) => path && !isAbsoluteUrl(path)),
-        plugins: getUniquePlugins(mergedPlugins),
+        extendPaths: styleguide.extendPaths?.filter((path) => path && !(0, ref_utils_1.isAbsoluteUrl)(path)),
+        plugins: (0, utils_2.getUniquePlugins)(mergedPlugins),
         recommendedFallback: styleguideConfig?.recommendedFallback,
         doNotResolveExamples: styleguideConfig?.doNotResolveExamples,
     };
 }
-export async function resolveStyleguideConfig(opts) {
+async function resolveStyleguideConfig(opts) {
     const resolvedStyleguideConfig = await resolveAndMergeNestedStyleguideConfig(opts);
     return {
         ...resolvedStyleguideConfig,
         rules: resolvedStyleguideConfig.rules && groupStyleguideAssertionRules(resolvedStyleguideConfig),
     };
 }
-export function resolvePreset(presetName, plugins) {
-    const { pluginId, configName } = parsePresetName(presetName);
+function resolvePreset(presetName, plugins) {
+    const { pluginId, configName } = (0, utils_2.parsePresetName)(presetName);
     const plugin = plugins.find((p) => p.id === pluginId);
     if (!plugin) {
-        throw new Error(`Invalid config ${colorize.red(presetName)}: plugin ${pluginId} is not included.`);
+        throw new Error(`Invalid config ${logger_1.colorize.red(presetName)}: plugin ${pluginId} is not included.`);
     }
     const preset = plugin.configs?.[configName];
     if (!preset) {
         throw new Error(pluginId
-            ? `Invalid config ${colorize.red(presetName)}: plugin ${pluginId} doesn't export config with name ${configName}.`
-            : `Invalid config ${colorize.red(presetName)}: there is no such built-in config.`);
+            ? `Invalid config ${logger_1.colorize.red(presetName)}: plugin ${pluginId} doesn't export config with name ${configName}.`
+            : `Invalid config ${logger_1.colorize.red(presetName)}: there is no such built-in config.`);
     }
     return preset;
 }
 async function loadExtendStyleguideConfig(filePath, resolver) {
     try {
         const { parsed } = (await resolver.resolveDocument(null, filePath));
-        const rawConfig = transformConfig(parsed);
+        const rawConfig = (0, utils_2.transformConfig)(parsed);
         if (!rawConfig.styleguide) {
             throw new Error(`Styleguide configuration format not detected: "${filePath}"`);
         }
@@ -355,7 +365,7 @@ async function loadExtendStyleguideConfig(filePath, resolver) {
 function getMergedRawStyleguideConfig(rootStyleguideConfig, apiStyleguideConfig) {
     const resultLint = {
         ...rootStyleguideConfig,
-        ...pickDefined(apiStyleguideConfig),
+        ...(0, utils_1.pickDefined)(apiStyleguideConfig),
         rules: { ...rootStyleguideConfig?.rules, ...apiStyleguideConfig?.rules },
         oas2Rules: { ...rootStyleguideConfig?.oas2Rules, ...apiStyleguideConfig?.oas2Rules },
         oas3_0Rules: { ...rootStyleguideConfig?.oas3_0Rules, ...apiStyleguideConfig?.oas3_0Rules },
@@ -447,18 +457,17 @@ function groupStyleguideAssertionRules({ rules, plugins, }) {
     return transformedRules;
 }
 function registerCustomAssertions(plugins, assertion) {
-    for (const field of keysOf(assertion.assertions)) {
+    for (const field of (0, utils_1.keysOf)(assertion.assertions)) {
         const [pluginId, fn] = field.split('/');
         if (!pluginId || !fn)
             continue;
         const plugin = plugins.find((plugin) => plugin.id === pluginId);
         if (!plugin) {
-            throw Error(colorize.red(`Plugin ${colorize.blue(pluginId)} isn't found.`));
+            throw Error(logger_1.colorize.red(`Plugin ${logger_1.colorize.blue(pluginId)} isn't found.`));
         }
         if (!plugin.assertions || !plugin.assertions[fn]) {
-            throw Error(`Plugin ${colorize.red(pluginId)} doesn't export assertions function with name ${colorize.red(fn)}.`);
+            throw Error(`Plugin ${logger_1.colorize.red(pluginId)} doesn't export assertions function with name ${logger_1.colorize.red(fn)}.`);
         }
-        asserts[field] = buildAssertCustomFunction(plugin.assertions[fn]);
+        asserts_1.asserts[field] = (0, asserts_1.buildAssertCustomFunction)(plugin.assertions[fn]);
     }
 }
-//# sourceMappingURL=config-resolvers.js.map

package/lib/config/config.d.ts

@@ -1,8 +1,8 @@
-import { SpecVersion, SpecMajorVersion } from '../oas-types.js';
-import type { NormalizedProblem } from '../walk.js';
-import type { Oas2RuleSet, Oas3RuleSet, Async3RuleSet, Arazzo1RuleSet, Overlay1RuleSet } from '../oas-types.js';
-import type { NodeType } from '../types/index.js';
-import type { DecoratorConfig, Plugin, PreprocessorConfig, ResolveConfig, ResolvedApi, ResolvedConfig, ResolvedStyleguideConfig, RuleConfig, RuleSettings, Telemetry, ThemeRawConfig } from './types.js';
+import { SpecVersion, SpecMajorVersion } from '../oas-types';
+import type { NormalizedProblem } from '../walk';
+import type { Oas2RuleSet, Oas3RuleSet, Async3RuleSet, Arazzo1RuleSet, Overlay1RuleSet } 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";
 export declare class StyleguideConfig {
     rawConfig: ResolvedStyleguideConfig;
@@ -44,8 +44,10 @@ export declare class Config {
     styleguide: StyleguideConfig;
     resolve: ResolveConfig;
     licenseKey?: string;
+    region?: Region;
     theme: ThemeRawConfig;
+    organization?: string;
+    files: string[];
     telemetry?: Telemetry;
     constructor(rawConfig: ResolvedConfig, configFile?: string | undefined);
 }
-//# sourceMappingURL=config.d.ts.map