@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/config/spec.d.ts

@@ -0,0 +1,3 @@
+import type { PluginStyleguideConfig } from './types';
+declare const spec: PluginStyleguideConfig<'built-in'>;
+export default spec;

package/lib/config/spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const spec = {
+    rules: {
+        struct: 'error',
+    },
+    // TODO: populate with spec-related rules similar to `arazzo1Rules`
+    oas2Rules: {},
+    oas3_0Rules: {},
+    oas3_1Rules: {},
+    async2Rules: {},
+    async3Rules: {},
+    arazzo1Rules: {
+        'sourceDescription-type': 'error',
+        'spot-supported-versions': 'off',
+        'workflowId-unique': 'error',
+        'stepId-unique': 'error',
+        'sourceDescription-name-unique': 'error',
+        'sourceDescriptions-not-empty': 'error',
+        'workflow-dependsOn': 'error',
+        'parameters-unique': 'error',
+        'step-onSuccess-unique': 'error',
+        'step-onFailure-unique': 'error',
+        'requestBody-replacements-unique': 'error',
+        'no-criteria-xpath': 'off',
+        'criteria-unique': 'error',
+    },
+};
+exports.default = spec;

package/lib/config/types.d.ts

@@ -0,0 +1,189 @@
+import type { Location } from '../ref-utils';
+import type { ProblemSeverity, UserContext } from '../walk';
+import type { Oas3PreprocessorsSet, SpecMajorVersion, Oas3DecoratorsSet, Oas2RuleSet, Oas2PreprocessorsSet, Oas2DecoratorsSet, Oas3RuleSet, SpecVersion, Async2PreprocessorsSet, Async2DecoratorsSet, Async2RuleSet, Async3PreprocessorsSet, Async3DecoratorsSet, Async3RuleSet, Arazzo1RuleSet, Arazzo1PreprocessorsSet, Arazzo1DecoratorsSet, RuleMap } from '../oas-types';
+import type { NodeType } from '../types';
+import type { SkipFunctionContext } from '../visitors';
+import type { JSONSchema } from 'json-schema-to-ts';
+export type RuleSeverity = ProblemSeverity | 'off';
+export type RuleSettings = {
+    severity: RuleSeverity;
+    message?: string;
+};
+export type PreprocessorSeverity = RuleSeverity | 'on';
+export type RuleConfig = RuleSeverity | (Partial<RuleSettings> & Record<string, any>);
+export type PreprocessorConfig = PreprocessorSeverity | ({
+    severity?: ProblemSeverity;
+} & Record<string, any>);
+export type DecoratorConfig = PreprocessorConfig;
+export type StyleguideRawConfig<T = undefined> = {
+    plugins?: (string | Plugin)[];
+    extends?: string[];
+    doNotResolveExamples?: boolean;
+    recommendedFallback?: boolean;
+    rules?: RuleMap<string, RuleConfig, T>;
+    oas2Rules?: RuleMap<string, RuleConfig, T>;
+    oas3_0Rules?: RuleMap<string, RuleConfig, T>;
+    oas3_1Rules?: RuleMap<string, RuleConfig, T>;
+    async2Rules?: RuleMap<string, RuleConfig, T>;
+    async3Rules?: RuleMap<string, RuleConfig, T>;
+    arazzo1Rules?: RuleMap<string, RuleConfig, T>;
+    preprocessors?: Record<string, PreprocessorConfig>;
+    oas2Preprocessors?: Record<string, PreprocessorConfig>;
+    oas3_0Preprocessors?: Record<string, PreprocessorConfig>;
+    oas3_1Preprocessors?: Record<string, PreprocessorConfig>;
+    async2Preprocessors?: Record<string, PreprocessorConfig>;
+    async3Preprocessors?: Record<string, PreprocessorConfig>;
+    arazzo1Preprocessors?: 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>;
+    async3Decorators?: Record<string, DecoratorConfig>;
+    arazzo1Decorators?: Record<string, DecoratorConfig>;
+};
+export type ApiStyleguideRawConfig = Omit<StyleguideRawConfig, 'plugins'>;
+export type ResolvedStyleguideConfig = PluginStyleguideConfig & {
+    plugins?: Plugin[];
+    recommendedFallback?: boolean;
+    extends?: void | never;
+    extendPaths?: string[];
+    pluginPaths?: string[];
+};
+export type PreprocessorsConfig = {
+    oas3?: Oas3PreprocessorsSet;
+    oas2?: Oas2PreprocessorsSet;
+    async2?: Async2PreprocessorsSet;
+    async3?: Async3PreprocessorsSet;
+    arazzo1?: Arazzo1PreprocessorsSet;
+};
+export type DecoratorsConfig = {
+    oas3?: Oas3DecoratorsSet;
+    oas2?: Oas2DecoratorsSet;
+    async2?: Async2DecoratorsSet;
+    async3?: Async3DecoratorsSet;
+    arazzo1?: Arazzo1DecoratorsSet;
+};
+export type TypesExtensionFn = (types: Record<string, NodeType>, oasVersion: SpecVersion) => Record<string, NodeType>;
+export type TypeExtensionsConfig = Partial<Record<SpecMajorVersion, TypesExtensionFn>>;
+export type RulesConfig<T> = {
+    oas3?: Oas3RuleSet<T>;
+    oas2?: Oas2RuleSet<T>;
+    async2?: Async2RuleSet<T>;
+    async3?: Async3RuleSet<T>;
+    arazzo1?: Arazzo1RuleSet<T>;
+};
+export type CustomRulesConfig = RulesConfig<undefined>;
+export type AssertionContext = Partial<UserContext> & SkipFunctionContext & {
+    node: any;
+};
+export type AssertResult = {
+    message?: string;
+    location?: Location;
+};
+export type CustomFunction = (value: any, options: unknown, baseLocation: Location) => AssertResult[];
+export type AssertionsConfig = Record<string, CustomFunction>;
+export type Plugin<T = undefined> = {
+    id: string;
+    configs?: Record<string, PluginStyleguideConfig>;
+    rules?: RulesConfig<T>;
+    preprocessors?: PreprocessorsConfig;
+    decorators?: DecoratorsConfig;
+    typeExtension?: TypeExtensionsConfig;
+    assertions?: AssertionsConfig;
+    path?: string;
+    absolutePath?: string;
+    processContent?: (actions: any, content: any) => Promise<void> | void;
+    afterRoutesCreated?: (actions: any, content: any) => Promise<void> | void;
+    loaders?: Record<string, (path: string, context: any, reportError: (error: Error) => void) => Promise<unknown>>;
+    requiredEntitlements?: string[];
+    ssoConfigSchema?: JSONSchema;
+    redoclyConfigSchema?: JSONSchema;
+    ejectIgnore?: string[];
+};
+type PluginCreatorOptions = {
+    contentDir: string;
+};
+export type PluginCreator = (options: PluginCreatorOptions) => Plugin | Promise<Plugin>;
+export type ImportedPlugin = {
+    default?: PluginCreator;
+} | PluginCreator | Plugin;
+export type PluginStyleguideConfig<T = undefined> = Omit<StyleguideRawConfig<T>, 'plugins' | 'extends'>;
+export type ResolveHeader = {
+    name: string;
+    envVariable?: undefined;
+    value: string;
+    matches: string;
+} | {
+    name: string;
+    value?: undefined;
+    envVariable: string;
+    matches: string;
+};
+export type RawResolveConfig = {
+    http?: Partial<HttpResolveConfig>;
+    doNotResolveExamples?: boolean;
+};
+export type HttpResolveConfig = {
+    headers: ResolveHeader[];
+    customFetch?: Function;
+};
+export type ResolveConfig = {
+    http: HttpResolveConfig;
+};
+export type Region = 'us' | 'eu';
+export type Telemetry = 'on' | 'off';
+export type AccessTokens = {
+    [region in Region]?: string;
+};
+export type DeprecatedInRawConfig = {
+    apiDefinitions?: Record<string, string>;
+    lint?: StyleguideRawConfig;
+    styleguide?: StyleguideRawConfig;
+    referenceDocs?: Record<string, any>;
+    apis?: Record<string, Api & DeprecatedInApi>;
+} & DeprecatedFeaturesConfig;
+export type Api = {
+    root: string;
+    output?: string;
+    styleguide?: ApiStyleguideRawConfig;
+} & ThemeConfig;
+export type DeprecatedInApi = {
+    lint?: ApiStyleguideRawConfig;
+} & DeprecatedFeaturesConfig;
+export type ResolvedApi = Omit<Api, 'styleguide'> & {
+    styleguide: ResolvedStyleguideConfig;
+    files?: string[];
+};
+export type RawConfig = {
+    apis?: Record<string, Api>;
+    styleguide?: StyleguideRawConfig;
+    resolve?: RawResolveConfig;
+    region?: Region;
+    organization?: string;
+    files?: string[];
+    telemetry?: Telemetry;
+} & ThemeConfig;
+export type RawUniversalConfig = Omit<RawConfig, 'styleguide'> & StyleguideRawConfig;
+export type FlatApi = Omit<Api, 'styleguide'> & Omit<ApiStyleguideRawConfig, 'doNotResolveExamples'>;
+export type FlatRawConfig = Omit<RawConfig, 'styleguide' | 'resolve' | 'apis'> & Omit<StyleguideRawConfig, 'doNotResolveExamples'> & {
+    resolve?: RawResolveConfig;
+    apis?: Record<string, FlatApi>;
+} & ThemeRawConfig;
+export type ResolvedConfig = Omit<RawConfig, 'apis' | 'styleguide'> & {
+    apis: Record<string, ResolvedApi>;
+    styleguide: ResolvedStyleguideConfig;
+};
+type DeprecatedFeaturesConfig = {
+    'features.openapi'?: Record<string, any>;
+    'features.mockServer'?: Record<string, any>;
+};
+export type ThemeConfig = {
+    theme?: ThemeRawConfig;
+};
+export type ThemeRawConfig = {
+    openapi?: Record<string, any>;
+    mockServer?: Record<string, any>;
+};
+export type RulesFields = 'rules' | 'oas2Rules' | 'oas3_0Rules' | 'oas3_1Rules' | 'async2Rules' | 'async3Rules' | 'arazzo1Rules' | 'preprocessors' | 'oas2Preprocessors' | 'oas3_0Preprocessors' | 'oas3_1Preprocessors' | 'async2Preprocessors' | 'async3Preprocessors' | 'arazzo1Preprocessors' | 'decorators' | 'oas2Decorators' | 'oas3_0Decorators' | 'oas3_1Decorators' | 'async2Decorators' | 'async3Decorators' | 'arazzo1Decorators';
+export {};

package/lib/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/config/utils.d.ts

@@ -0,0 +1,19 @@
+import { Config } from './config';
+import type { Api, DeprecatedInRawConfig, ImportedPlugin, FlatRawConfig, RawConfig, RawResolveConfig, ResolveConfig, ResolvedStyleguideConfig, RulesFields, Plugin, PluginCreator } from './types';
+export declare function parsePresetName(presetName: string): {
+    pluginId: string;
+    configName: string;
+};
+export declare function transformApiDefinitionsToApis(apiDefinitions?: DeprecatedInRawConfig['apiDefinitions']): Record<string, Api> | undefined;
+export declare function prefixRules<T extends Record<string, any>>(rules: T, prefix: string): any;
+export declare function mergeExtends(rulesConfList: ResolvedStyleguideConfig[]): Omit<ResolvedStyleguideConfig, RulesFields> & Required<Pick<ResolvedStyleguideConfig, RulesFields>>;
+export declare function getMergedConfig(config: Config, apiName?: string): Config;
+export declare function checkForDeprecatedFields(deprecatedField: keyof (DeprecatedInRawConfig & RawConfig), updatedField: keyof FlatRawConfig | undefined, rawConfig: DeprecatedInRawConfig & RawConfig & FlatRawConfig, updatedObject: keyof FlatRawConfig | undefined, link?: string | undefined): void;
+export declare function transformConfig(rawConfig: DeprecatedInRawConfig & RawConfig & FlatRawConfig): RawConfig;
+export declare function getResolveConfig(resolve?: RawResolveConfig): ResolveConfig;
+export declare function getUniquePlugins(plugins: Plugin[]): Plugin[];
+export declare class ConfigValidationError extends Error {
+}
+export declare function deepCloneMapWithJSON<K, V>(originalMap: Map<K, V>): Map<K, V>;
+export declare function isDeprecatedPluginFormat(plugin: ImportedPlugin | undefined): plugin is Plugin;
+export declare function isCommonJsPlugin(plugin: ImportedPlugin | undefined): plugin is PluginCreator;

package/lib/config/utils.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidationError = void 0;
+exports.parsePresetName = parsePresetName;
+exports.transformApiDefinitionsToApis = transformApiDefinitionsToApis;
+exports.prefixRules = prefixRules;
+exports.mergeExtends = mergeExtends;
+exports.getMergedConfig = getMergedConfig;
+exports.checkForDeprecatedFields = checkForDeprecatedFields;
+exports.transformConfig = transformConfig;
+exports.getResolveConfig = getResolveConfig;
+exports.getUniquePlugins = getUniquePlugins;
+exports.deepCloneMapWithJSON = deepCloneMapWithJSON;
+exports.isDeprecatedPluginFormat = isDeprecatedPluginFormat;
+exports.isCommonJsPlugin = isCommonJsPlugin;
+const utils_1 = require("../utils");
+const config_1 = require("./config");
+const logger_1 = require("../logger");
+function parsePresetName(presetName) {
+    if (presetName.indexOf('/') > -1) {
+        const [pluginId, configName] = presetName.split('/');
+        return { pluginId, configName };
+    }
+    else {
+        return { pluginId: '', configName: presetName };
+    }
+}
+function transformApiDefinitionsToApis(apiDefinitions) {
+    if (!apiDefinitions)
+        return undefined;
+    const apis = {};
+    for (const [apiName, apiPath] of Object.entries(apiDefinitions)) {
+        apis[apiName] = { root: apiPath };
+    }
+    return apis;
+}
+function extractFlatConfig({ plugins, extends: _extends, rules, oas2Rules, oas3_0Rules, oas3_1Rules, async2Rules, async3Rules, arazzo1Rules, preprocessors, oas2Preprocessors, oas3_0Preprocessors, oas3_1Preprocessors, async2Preprocessors, async3Preprocessors, arazzo1Preprocessors, decorators, oas2Decorators, oas3_0Decorators, oas3_1Decorators, async2Decorators, async3Decorators, arazzo1Decorators, ...rawConfigRest }) {
+    const styleguideConfig = {
+        plugins,
+        extends: _extends,
+        rules,
+        oas2Rules,
+        oas3_0Rules,
+        oas3_1Rules,
+        async2Rules,
+        async3Rules,
+        arazzo1Rules,
+        preprocessors,
+        oas2Preprocessors,
+        oas3_0Preprocessors,
+        oas3_1Preprocessors,
+        async2Preprocessors,
+        async3Preprocessors,
+        arazzo1Preprocessors,
+        decorators,
+        oas2Decorators,
+        oas3_0Decorators,
+        oas3_1Decorators,
+        async2Decorators,
+        async3Decorators,
+        arazzo1Decorators,
+        doNotResolveExamples: rawConfigRest.resolve?.doNotResolveExamples,
+    };
+    if ((rawConfigRest.lint && rawConfigRest.styleguide) ||
+        (Object.values(styleguideConfig).some(utils_1.isDefined) &&
+            (rawConfigRest.lint || rawConfigRest.styleguide))) {
+        throw new Error(`Do not use 'lint', 'styleguide' and flat syntax together. \nSee more about the configuration in the docs: https://redocly.com/docs/cli/configuration/ \n`);
+    }
+    return {
+        styleguideConfig: Object.values(styleguideConfig).some(utils_1.isDefined)
+            ? styleguideConfig
+            : undefined,
+        rawConfigRest,
+    };
+}
+function transformApis(legacyApis) {
+    if (!legacyApis)
+        return undefined;
+    const apis = {};
+    for (const [apiName, { lint, ...apiContent }] of Object.entries(legacyApis)) {
+        const { styleguideConfig, rawConfigRest } = extractFlatConfig(apiContent);
+        apis[apiName] = {
+            styleguide: styleguideConfig || lint,
+            ...rawConfigRest,
+        };
+    }
+    return apis;
+}
+function prefixRules(rules, prefix) {
+    if (!prefix)
+        return rules;
+    const res = {};
+    for (const name of Object.keys(rules)) {
+        res[`${prefix}/${name}`] = rules[name];
+    }
+    return res;
+}
+function mergeExtends(rulesConfList) {
+    const result = {
+        rules: {},
+        oas2Rules: {},
+        oas3_0Rules: {},
+        oas3_1Rules: {},
+        async2Rules: {},
+        async3Rules: {},
+        arazzo1Rules: {},
+        preprocessors: {},
+        oas2Preprocessors: {},
+        oas3_0Preprocessors: {},
+        oas3_1Preprocessors: {},
+        async2Preprocessors: {},
+        async3Preprocessors: {},
+        arazzo1Preprocessors: {},
+        decorators: {},
+        oas2Decorators: {},
+        oas3_0Decorators: {},
+        oas3_1Decorators: {},
+        async2Decorators: {},
+        async3Decorators: {},
+        arazzo1Decorators: {},
+        plugins: [],
+        pluginPaths: [],
+        extendPaths: [],
+    };
+    for (const rulesConf of rulesConfList) {
+        if (rulesConf.extends) {
+            throw new Error(`'extends' is not supported in shared configs yet:\n${JSON.stringify(rulesConf, null, 2)}`);
+        }
+        (0, utils_1.assignConfig)(result.rules, rulesConf.rules);
+        (0, utils_1.assignConfig)(result.oas2Rules, rulesConf.oas2Rules);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas2Rules, rulesConf.rules);
+        (0, utils_1.assignConfig)(result.oas3_0Rules, rulesConf.oas3_0Rules);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas3_0Rules, rulesConf.rules);
+        (0, utils_1.assignConfig)(result.oas3_1Rules, rulesConf.oas3_1Rules);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas3_1Rules, rulesConf.rules);
+        (0, utils_1.assignConfig)(result.async2Rules, rulesConf.async2Rules);
+        (0, utils_1.assignOnlyExistingConfig)(result.async2Rules, rulesConf.rules);
+        (0, utils_1.assignConfig)(result.async3Rules, rulesConf.async3Rules);
+        (0, utils_1.assignOnlyExistingConfig)(result.async3Rules, rulesConf.rules);
+        (0, utils_1.assignConfig)(result.arazzo1Rules, rulesConf.arazzo1Rules);
+        (0, utils_1.assignOnlyExistingConfig)(result.arazzo1Rules, rulesConf.rules);
+        (0, utils_1.assignConfig)(result.preprocessors, rulesConf.preprocessors);
+        (0, utils_1.assignConfig)(result.oas2Preprocessors, rulesConf.oas2Preprocessors);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas2Preprocessors, rulesConf.preprocessors);
+        (0, utils_1.assignConfig)(result.oas3_0Preprocessors, rulesConf.oas3_0Preprocessors);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas3_0Preprocessors, rulesConf.preprocessors);
+        (0, utils_1.assignConfig)(result.oas3_1Preprocessors, rulesConf.oas3_1Preprocessors);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas3_1Preprocessors, rulesConf.preprocessors);
+        (0, utils_1.assignConfig)(result.async2Preprocessors, rulesConf.async2Preprocessors);
+        (0, utils_1.assignOnlyExistingConfig)(result.async2Preprocessors, rulesConf.preprocessors);
+        (0, utils_1.assignConfig)(result.async3Preprocessors, rulesConf.async3Preprocessors);
+        (0, utils_1.assignOnlyExistingConfig)(result.async3Preprocessors, rulesConf.preprocessors);
+        (0, utils_1.assignConfig)(result.arazzo1Preprocessors, rulesConf.arazzo1Preprocessors);
+        (0, utils_1.assignOnlyExistingConfig)(result.arazzo1Preprocessors, rulesConf.preprocessors);
+        (0, utils_1.assignConfig)(result.decorators, rulesConf.decorators);
+        (0, utils_1.assignConfig)(result.oas2Decorators, rulesConf.oas2Decorators);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas2Decorators, rulesConf.decorators);
+        (0, utils_1.assignConfig)(result.oas3_0Decorators, rulesConf.oas3_0Decorators);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas3_0Decorators, rulesConf.decorators);
+        (0, utils_1.assignConfig)(result.oas3_1Decorators, rulesConf.oas3_1Decorators);
+        (0, utils_1.assignOnlyExistingConfig)(result.oas3_1Decorators, rulesConf.decorators);
+        (0, utils_1.assignConfig)(result.async2Decorators, rulesConf.async2Decorators);
+        (0, utils_1.assignOnlyExistingConfig)(result.async2Decorators, rulesConf.decorators);
+        (0, utils_1.assignConfig)(result.async3Decorators, rulesConf.async3Decorators);
+        (0, utils_1.assignOnlyExistingConfig)(result.async3Decorators, rulesConf.decorators);
+        (0, utils_1.assignConfig)(result.arazzo1Decorators, rulesConf.arazzo1Decorators);
+        (0, utils_1.assignOnlyExistingConfig)(result.arazzo1Decorators, rulesConf.decorators);
+        result.plugins.push(...(rulesConf.plugins || []));
+        result.pluginPaths.push(...(rulesConf.pluginPaths || []));
+        result.extendPaths.push(...new Set(rulesConf.extendPaths));
+    }
+    return result;
+}
+function getMergedConfig(config, apiName) {
+    const extendPaths = [
+        ...Object.values(config.apis).map((api) => api?.styleguide?.extendPaths),
+        config.rawConfig?.styleguide?.extendPaths,
+    ]
+        .flat()
+        .filter(utils_1.isTruthy);
+    const pluginPaths = [
+        ...Object.values(config.apis).map((api) => api?.styleguide?.pluginPaths),
+        config.rawConfig?.styleguide?.pluginPaths,
+    ]
+        .flat()
+        .filter(utils_1.isTruthy);
+    return apiName
+        ? new config_1.Config({
+            ...config.rawConfig,
+            styleguide: {
+                ...(config.apis[apiName]
+                    ? config.apis[apiName].styleguide
+                    : config.rawConfig.styleguide),
+                extendPaths,
+                pluginPaths,
+            },
+            theme: {
+                ...config.rawConfig.theme,
+                ...config.apis[apiName]?.theme,
+            },
+            files: [...config.files, ...(config.apis?.[apiName]?.files ?? [])],
+            // TODO: merge everything else here
+        }, config.configFile)
+        : config;
+}
+function checkForDeprecatedFields(deprecatedField, updatedField, rawConfig, updatedObject, link) {
+    const isDeprecatedFieldInApis = rawConfig.apis &&
+        Object.values(rawConfig.apis).some((api) => api[deprecatedField]);
+    if (rawConfig[deprecatedField] && updatedField === null) {
+        (0, utils_1.showWarningForDeprecatedField)(deprecatedField, undefined, updatedObject, link);
+    }
+    if (rawConfig[deprecatedField] && updatedField && rawConfig[updatedField]) {
+        (0, utils_1.showErrorForDeprecatedField)(deprecatedField, updatedField);
+    }
+    if (rawConfig[deprecatedField] && updatedObject && rawConfig[updatedObject]) {
+        (0, utils_1.showErrorForDeprecatedField)(deprecatedField, updatedField, updatedObject);
+    }
+    if (rawConfig[deprecatedField] || isDeprecatedFieldInApis) {
+        (0, utils_1.showWarningForDeprecatedField)(deprecatedField, updatedField, updatedObject, link);
+    }
+}
+function transformConfig(rawConfig) {
+    const migratedFields = [
+        ['apiDefinitions', 'apis', undefined, undefined],
+        ['referenceDocs', 'openapi', 'theme', undefined],
+        [
+            'lint',
+            undefined,
+            undefined,
+            'https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties',
+        ],
+        [
+            'styleguide',
+            undefined,
+            undefined,
+            'https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties',
+        ],
+        ['features.openapi', 'openapi', 'theme', undefined],
+    ];
+    for (const [deprecatedField, updatedField, updatedObject, link] of migratedFields) {
+        checkForDeprecatedFields(deprecatedField, updatedField, rawConfig, updatedObject, link);
+    }
+    const { apis, apiDefinitions, referenceDocs, lint, ...rest } = rawConfig;
+    const { styleguideConfig, rawConfigRest } = extractFlatConfig(rest);
+    const transformedConfig = {
+        theme: {
+            openapi: {
+                ...referenceDocs,
+                ...rawConfig['features.openapi'],
+                ...rawConfig.theme?.openapi,
+            },
+            mockServer: {
+                ...rawConfig['features.mockServer'],
+                ...rawConfig.theme?.mockServer,
+            },
+        },
+        apis: transformApis(apis) || transformApiDefinitionsToApis(apiDefinitions),
+        styleguide: styleguideConfig || lint,
+        ...rawConfigRest,
+    };
+    showDeprecationMessages(transformedConfig);
+    return transformedConfig;
+}
+function showDeprecationMessages(config) {
+    let allRules = { ...config.styleguide?.rules };
+    for (const api of Object.values(config.apis || {})) {
+        allRules = { ...allRules, ...api?.styleguide?.rules };
+    }
+    for (const ruleKey of Object.keys(allRules)) {
+        if (ruleKey.startsWith('assert/')) {
+            logger_1.logger.warn(`\nThe 'assert/' syntax in ${ruleKey} is deprecated. Update your configuration to use 'rule/' instead. Examples and more information: https://redocly.com/docs/cli/rules/configurable-rules/\n`);
+        }
+    }
+}
+function getResolveConfig(resolve) {
+    return {
+        http: {
+            headers: resolve?.http?.headers ?? [],
+            customFetch: undefined,
+        },
+    };
+}
+function getUniquePlugins(plugins) {
+    const seen = new Set();
+    const results = [];
+    for (const p of plugins) {
+        if (!seen.has(p.id)) {
+            results.push(p);
+            seen.add(p.id);
+        }
+        else if (p.id) {
+            logger_1.logger.warn(`Duplicate plugin id "${logger_1.colorize.red(p.id)}".\n`);
+        }
+    }
+    return results;
+}
+class ConfigValidationError extends Error {
+}
+exports.ConfigValidationError = ConfigValidationError;
+function deepCloneMapWithJSON(originalMap) {
+    return new Map(JSON.parse(JSON.stringify([...originalMap])));
+}
+function isDeprecatedPluginFormat(plugin) {
+    return plugin !== undefined && typeof plugin === 'object' && 'id' in plugin;
+}
+function isCommonJsPlugin(plugin) {
+    return typeof plugin === 'function';
+}

package/lib/decorators/arazzo/index.d.ts

@@ -0,0 +1 @@
+export declare const decorators: {};

package/lib/decorators/arazzo/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorators = void 0;
+exports.decorators = {};

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

@@ -0,0 +1 @@
+export declare const decorators: {};

package/lib/decorators/async2/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorators = void 0;
+exports.decorators = {};

package/lib/decorators/async3/index.d.ts

@@ -0,0 +1 @@
+export declare const decorators: {};

package/lib/decorators/async3/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorators = void 0;
+exports.decorators = {};

package/lib/decorators/common/filters/filter-helper.d.ts

@@ -0,0 +1,3 @@
+import type { UserContext } from '../../../walk';
+export declare function filter(node: any, ctx: UserContext, criteria: (item: any) => boolean): void;
+export declare function checkIfMatchByStrategy(nodeValue: any, decoratorValue: any, strategy: 'all' | 'any'): boolean;

package/lib/decorators/common/filters/filter-helper.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filter = filter;
+exports.checkIfMatchByStrategy = checkIfMatchByStrategy;
+const ref_utils_1 = require("../../../ref-utils");
+const utils_1 = require("../../../utils");
+function filter(node, ctx, criteria) {
+    const { parent, key } = ctx;
+    let didDelete = false;
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            if ((0, ref_utils_1.isRef)(node[i])) {
+                const resolved = ctx.resolve(node[i]);
+                if (criteria(resolved.node)) {
+                    node.splice(i, 1);
+                    didDelete = true;
+                    i--;
+                }
+            }
+            if (criteria(node[i])) {
+                node.splice(i, 1);
+                didDelete = true;
+                i--;
+            }
+        }
+    }
+    else if ((0, utils_1.isPlainObject)(node)) {
+        for (const key of Object.keys(node)) {
+            node = node;
+            if ((0, ref_utils_1.isRef)(node[key])) {
+                const resolved = ctx.resolve(node[key]);
+                if (criteria(resolved.node)) {
+                    delete node[key];
+                    didDelete = true;
+                }
+            }
+            if (criteria(node[key])) {
+                delete node[key];
+                didDelete = true;
+            }
+        }
+    }
+    if (didDelete && ((0, utils_1.isEmptyObject)(node) || (0, utils_1.isEmptyArray)(node))) {
+        delete parent[key];
+    }
+}
+function checkIfMatchByStrategy(nodeValue, decoratorValue, strategy) {
+    if (nodeValue === undefined || decoratorValue === undefined) {
+        return false;
+    }
+    if (!Array.isArray(decoratorValue) && !Array.isArray(nodeValue)) {
+        return nodeValue === decoratorValue;
+    }
+    decoratorValue = toArrayIfNeeded(decoratorValue);
+    nodeValue = toArrayIfNeeded(nodeValue);
+    if (strategy === 'any') {
+        return decoratorValue.some((item) => nodeValue.includes(item));
+    }
+    if (strategy === 'all') {
+        return decoratorValue.every((item) => nodeValue.includes(item));
+    }
+    return false;
+}
+function toArrayIfNeeded(value) {
+    return Array.isArray(value) ? value : [value];
+}

package/lib/decorators/common/filters/filter-in.d.ts

@@ -0,0 +1,2 @@
+import type { Oas2Decorator, Oas3Decorator } from '../../../visitors';
+export declare const FilterIn: Oas3Decorator | Oas2Decorator;

package/lib/decorators/common/filters/filter-in.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterIn = void 0;
+const filter_helper_1 = require("./filter-helper");
+const DEFAULT_STRATEGY = 'any';
+const FilterIn = ({ property, value, matchStrategy }) => {
+    const strategy = matchStrategy || DEFAULT_STRATEGY;
+    const filterInCriteria = (item) => item?.[property] && !(0, filter_helper_1.checkIfMatchByStrategy)(item?.[property], value, strategy);
+    return {
+        any: {
+            enter: (node, ctx) => {
+                (0, filter_helper_1.filter)(node, ctx, filterInCriteria);
+            },
+        },
+    };
+};
+exports.FilterIn = FilterIn;