@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/format/codeframes.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodeframe = getCodeframe;
+exports.getLineColLocation = getLineColLocation;
+exports.getAstNodeByPointer = getAstNodeByPointer;
+const yamlAst = require("yaml-ast-parser");
+const ref_utils_1 = require("../ref-utils");
+const logger_1 = require("../logger");
+const MAX_LINE_LENGTH = 150;
+const MAX_CODEFRAME_LINES = 3;
+// TODO: temporary
+function parsePointer(pointer) {
+    return pointer.substr(2).split('/').map(ref_utils_1.unescapePointer);
+}
+function getCodeframe(location, color) {
+    logger_1.colorOptions.enabled = color;
+    const { start, end = { line: start.line, col: start.col + 1 }, source } = location;
+    const lines = source.getLines();
+    const startLineNum = start.line;
+    const endLineNum = Math.max(Math.min(end.line, lines.length), start.line);
+    let skipLines = Math.max(endLineNum - startLineNum - MAX_CODEFRAME_LINES + 1, 0);
+    if (skipLines < 2)
+        skipLines = 0; // do not skip one line
+    // Lines specified like this: ["prefix", "string"],
+    const prefixedLines = [];
+    let currentPad = 0;
+    for (let i = startLineNum; i <= endLineNum; i++) {
+        if (skipLines > 0 && i >= endLineNum - skipLines)
+            break;
+        const line = lines[i - 1] || '';
+        if (line !== '')
+            currentPad = padSize(line);
+        const startIdx = i === startLineNum ? start.col - 1 : currentPad;
+        const endIdx = i === endLineNum ? end.col - 1 : line.length;
+        prefixedLines.push([`${i}`, markLine(line, startIdx, endIdx, logger_1.colorize.red)]);
+        if (!color)
+            prefixedLines.push(['', underlineLine(line, startIdx, endIdx)]);
+    }
+    if (skipLines > 0) {
+        prefixedLines.push([
+            `…`,
+            `${whitespace(currentPad)}${logger_1.colorize.gray(`< ${skipLines} more lines >`)}`,
+        ]);
+        // print last line
+        prefixedLines.push([
+            `${endLineNum}`,
+            markLine(lines[endLineNum - 1], -1, end.col - 1, logger_1.colorize.red),
+        ]);
+        if (!color)
+            prefixedLines.push(['', underlineLine(lines[endLineNum - 1], -1, end.col - 1)]);
+    }
+    return printPrefixedLines([
+        [`${startLineNum - 2}`, markLine(lines[startLineNum - 1 - 2])],
+        [`${startLineNum - 1}`, markLine(lines[startLineNum - 1 - 1])],
+        ...prefixedLines,
+        [`${endLineNum + 1}`, markLine(lines[endLineNum - 1 + 1])],
+        [`${endLineNum + 2}`, markLine(lines[endLineNum - 1 + 2])],
+    ]);
+    function markLine(line, startIdx = -1, endIdx = +Infinity, variant = logger_1.colorize.gray) {
+        if (!color)
+            return line;
+        if (!line)
+            return line;
+        if (startIdx === -1) {
+            startIdx = padSize(line);
+        }
+        endIdx = Math.min(endIdx, line.length);
+        return (line.substr(0, startIdx) + variant(line.substring(startIdx, endIdx)) + line.substr(endIdx));
+    }
+}
+function printPrefixedLines(lines) {
+    const existingLines = lines.filter(([_, line]) => line !== undefined);
+    const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
+    const dedentLen = Math.min(...existingLines.map(([_, line]) => (line === '' ? Infinity : padSize(line))));
+    return existingLines
+        .map(([prefix, line]) => logger_1.colorize.gray(leftPad(padLen, prefix) + ' |') +
+        (line ? ' ' + limitLineLength(line.substring(dedentLen)) : ''))
+        .join('\n');
+}
+function limitLineLength(line, maxLen = MAX_LINE_LENGTH) {
+    const overflowLen = line.length - maxLen;
+    if (overflowLen > 0) {
+        const charsMoreText = logger_1.colorize.gray(`...<${overflowLen} chars>`);
+        return line.substring(0, maxLen - charsMoreText.length) + charsMoreText;
+    }
+    else {
+        return line;
+    }
+}
+function underlineLine(line, startIdx = -1, endIdx = +Infinity) {
+    if (startIdx === -1) {
+        startIdx = padSize(line);
+    }
+    endIdx = Math.min(endIdx, line.length);
+    return whitespace(startIdx) + '^'.repeat(Math.max(endIdx - startIdx, 1));
+}
+function whitespace(len) {
+    return ' '.repeat(len);
+}
+function leftPad(len, str) {
+    return whitespace(len - str.length) + str;
+}
+function padSize(line) {
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] !== ' ')
+            return i;
+    }
+    return line.length;
+}
+function getLineColLocation(location) {
+    if (location.pointer === undefined)
+        return location;
+    const { source, pointer, reportOnKey } = location;
+    const ast = source.getAst(yamlAst.safeLoad);
+    const astNode = getAstNodeByPointer(ast, pointer, !!reportOnKey);
+    return {
+        ...location,
+        pointer: undefined,
+        ...positionsToLoc(source.body, astNode?.startPosition ?? 1, astNode?.endPosition ?? 1),
+    };
+}
+function positionsToLoc(source, startPos, endPos) {
+    let currentLine = 1;
+    let currentCol = 1;
+    let start = { line: 1, col: 1 };
+    for (let i = 0; i < endPos - 1; i++) {
+        if (i === startPos - 1) {
+            start = { line: currentLine, col: currentCol + 1 };
+        }
+        if (source[i] === '\n') {
+            currentLine++;
+            currentCol = 1;
+            if (i === startPos - 1) {
+                start = { line: currentLine, col: currentCol };
+            }
+            if (source[i + 1] === '\r')
+                i++; // TODO: test it
+            continue;
+        }
+        currentCol++;
+    }
+    const end = startPos === endPos ? { ...start } : { line: currentLine, col: currentCol + 1 };
+    return { start, end };
+}
+function getAstNodeByPointer(root, pointer, reportOnKey) {
+    const pointerSegments = parsePointer(pointer);
+    if (root === undefined) {
+        return undefined;
+    }
+    let currentNode = root;
+    for (const key of pointerSegments) {
+        if (currentNode.kind === yamlAst.Kind.MAP) {
+            const mapping = currentNode.mappings.find((m) => m.key.value === key);
+            if (!mapping)
+                break;
+            currentNode = mapping;
+            if (!mapping?.value)
+                break; // If node has value - return value, if not - return node itself
+            currentNode = mapping.value;
+        }
+        else if (currentNode.kind === yamlAst.Kind.SEQ) {
+            const elem = currentNode.items[parseInt(key, 10)];
+            if (!elem)
+                break;
+            currentNode = elem;
+        }
+    }
+    if (!reportOnKey) {
+        return currentNode;
+    }
+    else {
+        const parent = currentNode.parent;
+        if (!parent)
+            return currentNode;
+        if (parent.kind === yamlAst.Kind.SEQ) {
+            return currentNode;
+        }
+        else if (parent.kind === yamlAst.Kind.MAPPING) {
+            return parent.key;
+        }
+        else {
+            return currentNode;
+        }
+    }
+}

package/lib/format/format.d.ts

@@ -0,0 +1,20 @@
+import type { NormalizedProblem } from '../walk';
+export type Totals = {
+    errors: number;
+    warnings: number;
+    ignored: number;
+};
+export type OutputFormat = 'codeframe' | 'stylish' | 'json' | 'checkstyle' | 'codeclimate' | 'summary' | 'github-actions' | 'markdown';
+export declare function getTotals(problems: (NormalizedProblem & {
+    ignored?: boolean;
+})[]): Totals;
+export declare function formatProblems(problems: (NormalizedProblem & {
+    ignored?: boolean;
+})[], opts: {
+    maxProblems?: number;
+    cwd?: string;
+    format?: OutputFormat;
+    color?: boolean;
+    totals: Totals;
+    version: string;
+}): void;

package/lib/format/format.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotals = getTotals;
+exports.formatProblems = formatProblems;
+const path = require("path");
+const logger_1 = require("../logger");
+const output_1 = require("../output");
+const codeframes_1 = require("./codeframes");
+const env_1 = require("../env");
+const ref_utils_1 = require("../ref-utils");
+const coreVersion = require('../../package.json').version;
+const ERROR_MESSAGE = {
+    INVALID_SEVERITY_LEVEL: 'Invalid severity level; accepted values: error or warn',
+};
+const BG_COLORS = {
+    warn: (str) => logger_1.colorize.bgYellow(logger_1.colorize.black(str)),
+    error: logger_1.colorize.bgRed,
+};
+const COLORS = {
+    warn: logger_1.colorize.yellow,
+    error: logger_1.colorize.red,
+};
+const SEVERITY_NAMES = {
+    warn: 'Warning',
+    error: 'Error',
+};
+const CODECLIMATE_SEVERITY_MAPPING = {
+    error: 'critical',
+    warn: 'minor',
+};
+const MAX_SUGGEST = 5;
+function severityToNumber(severity) {
+    return severity === 'error' ? 1 : 2;
+}
+function getTotals(problems) {
+    let errors = 0;
+    let warnings = 0;
+    let ignored = 0;
+    for (const m of problems) {
+        if (m.ignored) {
+            ignored++;
+            continue;
+        }
+        if (m.severity === 'error')
+            errors++;
+        if (m.severity === 'warn')
+            warnings++;
+    }
+    return {
+        errors,
+        warnings,
+        ignored,
+    };
+}
+function formatProblems(problems, opts) {
+    const { maxProblems = 100, cwd = env_1.isBrowser ? '' : process.cwd(), format = 'codeframe', color = logger_1.colorOptions.enabled, totals = getTotals(problems), version = coreVersion, } = opts;
+    logger_1.colorOptions.enabled = color; // force colors if specified
+    const totalProblems = problems.length;
+    problems = problems.filter((m) => !m.ignored);
+    const ignoredProblems = totalProblems - problems.length;
+    problems = problems
+        .sort((a, b) => severityToNumber(a.severity) - severityToNumber(b.severity))
+        .slice(0, maxProblems);
+    if (!totalProblems && format !== 'json')
+        return;
+    switch (format) {
+        case 'json':
+            outputJSON();
+            break;
+        case 'codeframe':
+            for (let i = 0; i < problems.length; i++) {
+                const problem = problems[i];
+                logger_1.logger.info(`${formatCodeframe(problem, i)}\n`);
+            }
+            break;
+        case 'stylish': {
+            const groupedByFile = groupByFiles(problems);
+            for (const [file, { ruleIdPad, locationPad: positionPad, fileProblems }] of Object.entries(groupedByFile)) {
+                logger_1.logger.info(`${logger_1.colorize.blue((0, ref_utils_1.isAbsoluteUrl)(file) ? file : path.relative(cwd, file))}:\n`);
+                for (let i = 0; i < fileProblems.length; i++) {
+                    const problem = fileProblems[i];
+                    logger_1.logger.info(`${formatStylish(problem, positionPad, ruleIdPad)}\n`);
+                }
+                logger_1.logger.info('\n');
+            }
+            break;
+        }
+        case 'markdown': {
+            const groupedByFile = groupByFiles(problems);
+            for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
+                output_1.output.write(`## Lint: ${(0, ref_utils_1.isAbsoluteUrl)(file) ? file : path.relative(cwd, file)}\n\n`);
+                output_1.output.write(`| Severity | Location | Problem | Message |\n`);
+                output_1.output.write(`|---|---|---|---|\n`);
+                for (let i = 0; i < fileProblems.length; i++) {
+                    const problem = fileProblems[i];
+                    output_1.output.write(`${formatMarkdown(problem)}\n`);
+                }
+                output_1.output.write('\n');
+                if (totals.errors > 0) {
+                    output_1.output.write(`Validation failed\nErrors: ${totals.errors}\n`);
+                }
+                else {
+                    output_1.output.write('Validation successful\n');
+                }
+                if (totals.warnings > 0) {
+                    output_1.output.write(`Warnings: ${totals.warnings}\n`);
+                }
+                output_1.output.write('\n');
+            }
+            break;
+        }
+        case 'checkstyle': {
+            const groupedByFile = groupByFiles(problems);
+            output_1.output.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+            output_1.output.write('<checkstyle version="4.3">\n');
+            for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
+                output_1.output.write(`<file name="${xmlEscape((0, ref_utils_1.isAbsoluteUrl)(file) ? file : path.relative(cwd, file))}">\n`);
+                fileProblems.forEach(formatCheckstyle);
+                output_1.output.write(`</file>\n`);
+            }
+            output_1.output.write(`</checkstyle>\n`);
+            break;
+        }
+        case 'codeclimate':
+            outputForCodeClimate();
+            break;
+        case 'summary':
+            formatSummary(problems);
+            break;
+        case 'github-actions':
+            outputForGithubActions(problems, cwd);
+    }
+    if (totalProblems - ignoredProblems > maxProblems) {
+        logger_1.logger.info(`< ... ${totalProblems - maxProblems} more problems hidden > ${logger_1.colorize.gray('increase with `--max-problems N`')}\n`);
+    }
+    function outputForCodeClimate() {
+        const issues = problems.map((p) => {
+            const location = p.location[0]; // TODO: support multiple location
+            const lineCol = (0, codeframes_1.getLineColLocation)(location);
+            return {
+                description: p.message,
+                location: {
+                    path: (0, ref_utils_1.isAbsoluteUrl)(location.source.absoluteRef)
+                        ? location.source.absoluteRef
+                        : path.relative(cwd, location.source.absoluteRef),
+                    lines: {
+                        begin: lineCol.start.line,
+                    },
+                },
+                severity: CODECLIMATE_SEVERITY_MAPPING[p.severity],
+                fingerprint: `${p.ruleId}${p.location.length > 0 ? '-' + p.location[0].pointer : ''}`,
+            };
+        });
+        output_1.output.write(JSON.stringify(issues, null, 2));
+    }
+    function outputJSON() {
+        const resultObject = {
+            totals,
+            version,
+            problems: problems.map((p) => {
+                const problem = {
+                    ...p,
+                    location: p.location.map((location) => ({
+                        ...location,
+                        source: {
+                            ref: (0, ref_utils_1.isAbsoluteUrl)(location.source.absoluteRef)
+                                ? location.source.absoluteRef
+                                : path.relative(cwd, location.source.absoluteRef),
+                        },
+                    })),
+                    from: p.from
+                        ? {
+                            ...p.from,
+                            source: {
+                                ref: (0, ref_utils_1.isAbsoluteUrl)(p.from?.source.absoluteRef)
+                                    ? p.from?.source.absoluteRef
+                                    : path.relative(cwd, p.from?.source.absoluteRef || cwd),
+                            },
+                        }
+                        : undefined,
+                };
+                if (env_1.env.FORMAT_JSON_WITH_CODEFRAMES) {
+                    const location = p.location[0]; // TODO: support multiple locations
+                    const loc = (0, codeframes_1.getLineColLocation)(location);
+                    problem.codeframe = (0, codeframes_1.getCodeframe)(loc, color);
+                }
+                return problem;
+            }),
+        };
+        output_1.output.write(JSON.stringify(resultObject, null, 2));
+    }
+    function getBgColor(problem) {
+        const { severity } = problem;
+        if (!BG_COLORS[severity]) {
+            throw new Error(ERROR_MESSAGE.INVALID_SEVERITY_LEVEL);
+        }
+        return BG_COLORS[severity];
+    }
+    function formatCodeframe(problem, idx) {
+        const bgColor = getBgColor(problem);
+        const location = problem.location[0]; // TODO: support multiple locations
+        const relativePath = (0, ref_utils_1.isAbsoluteUrl)(location.source.absoluteRef)
+            ? location.source.absoluteRef
+            : path.relative(cwd, location.source.absoluteRef);
+        const loc = (0, codeframes_1.getLineColLocation)(location);
+        const atPointer = location.pointer ? logger_1.colorize.gray(`at ${location.pointer}`) : '';
+        const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
+        return (`[${idx + 1}] ${bgColor(fileWithLoc)} ${atPointer}\n\n` +
+            `${problem.message}\n\n` +
+            formatDidYouMean(problem) +
+            (0, codeframes_1.getCodeframe)(loc, color) +
+            '\n\n' +
+            formatFrom(cwd, problem.from) +
+            `${SEVERITY_NAMES[problem.severity]} was generated by the ${logger_1.colorize.blue(problem.ruleId)} rule.\n\n`);
+    }
+    function formatStylish(problem, locationPad, ruleIdPad) {
+        const color = COLORS[problem.severity];
+        if (!SEVERITY_NAMES[problem.severity]) {
+            return 'Error not found severity. Please check your config file. Allowed values: `warn,error,off`';
+        }
+        const severityName = color(SEVERITY_NAMES[problem.severity].toLowerCase().padEnd(7));
+        const { start } = problem.location[0];
+        return `  ${`${start.line}:${start.col}`.padEnd(locationPad)}  ${severityName}  ${problem.ruleId.padEnd(ruleIdPad)}  ${problem.message}`;
+    }
+    function formatMarkdown(problem) {
+        if (!SEVERITY_NAMES[problem.severity]) {
+            return 'Error not found severity. Please check your config file. Allowed values: `warn,error,off`';
+        }
+        const severityName = SEVERITY_NAMES[problem.severity].toLowerCase();
+        const { start } = problem.location[0];
+        return `| ${severityName} | line ${`${start.line}:${start.col}`} | [${problem.ruleId}](https://redocly.com/docs/cli/rules/${problem.ruleId}/) | ${problem.message} |`;
+    }
+    function formatCheckstyle(problem) {
+        const { line, col } = problem.location[0].start;
+        const severity = problem.severity == 'warn' ? 'warning' : 'error';
+        const message = xmlEscape(problem.message);
+        const source = xmlEscape(problem.ruleId);
+        output_1.output.write(`<error line="${line}" column="${col}" severity="${severity}" message="${message}" source="${source}" />\n`);
+    }
+}
+function formatSummary(problems) {
+    const counts = {};
+    for (const problem of problems) {
+        counts[problem.ruleId] = counts[problem.ruleId] || { count: 0, severity: problem.severity };
+        counts[problem.ruleId].count++;
+    }
+    const sorted = Object.entries(counts).sort(([, a], [, b]) => {
+        const severityDiff = severityToNumber(a.severity) - severityToNumber(b.severity);
+        return severityDiff || b.count - a.count;
+    });
+    for (const [ruleId, info] of sorted) {
+        const color = COLORS[info.severity];
+        const severityName = color(SEVERITY_NAMES[info.severity].toLowerCase().padEnd(7));
+        logger_1.logger.info(`${severityName} ${ruleId}: ${info.count}\n`);
+    }
+    logger_1.logger.info('\n');
+}
+function formatFrom(cwd, location) {
+    if (!location)
+        return '';
+    const relativePath = path.relative(cwd, location.source.absoluteRef);
+    const loc = (0, codeframes_1.getLineColLocation)(location);
+    const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
+    const atPointer = location.pointer ? logger_1.colorize.gray(`at ${location.pointer}`) : '';
+    return `referenced from ${logger_1.colorize.blue(fileWithLoc)} ${atPointer} \n\n`;
+}
+function formatDidYouMean(problem) {
+    if (problem.suggest.length === 0)
+        return '';
+    if (problem.suggest.length === 1) {
+        return `Did you mean: ${problem.suggest[0]} ?\n\n`;
+    }
+    else {
+        return `Did you mean:\n  - ${problem.suggest.slice(0, MAX_SUGGEST).join('\n  - ')}\n\n`;
+    }
+}
+const groupByFiles = (problems) => {
+    const fileGroups = {};
+    for (const problem of problems) {
+        const absoluteRef = problem.location[0].source.absoluteRef; // TODO: multiple errors
+        fileGroups[absoluteRef] = fileGroups[absoluteRef] || {
+            fileProblems: [],
+            ruleIdPad: 0,
+            locationPad: 0,
+        };
+        const mappedProblem = { ...problem, location: problem.location.map(codeframes_1.getLineColLocation) };
+        fileGroups[absoluteRef].fileProblems.push(mappedProblem);
+        fileGroups[absoluteRef].ruleIdPad = Math.max(problem.ruleId.length, fileGroups[absoluteRef].ruleIdPad);
+        fileGroups[absoluteRef].locationPad = Math.max(Math.max(...mappedProblem.location.map((loc) => `${loc.start.line}:${loc.start.col}`.length)), fileGroups[absoluteRef].locationPad);
+    }
+    return fileGroups;
+};
+function xmlEscape(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, (char) => {
+        switch (char) {
+            case '<':
+                return '&lt;';
+            case '>':
+                return '&gt;';
+            case '&':
+                return '&amp;';
+            case '"':
+                return '&quot;';
+            case "'":
+                return '&apos;';
+            default:
+                return `&#${char.charCodeAt(0)};`;
+        }
+    });
+}
+function outputForGithubActions(problems, cwd) {
+    for (const problem of problems) {
+        for (const location of problem.location.map(codeframes_1.getLineColLocation)) {
+            let command;
+            switch (problem.severity) {
+                case 'error':
+                    command = 'error';
+                    break;
+                case 'warn':
+                    command = 'warning';
+                    break;
+            }
+            const suggest = formatDidYouMean(problem);
+            const message = suggest !== '' ? problem.message + '\n\n' + suggest : problem.message;
+            const properties = {
+                title: problem.ruleId,
+                file: (0, ref_utils_1.isAbsoluteUrl)(location.source.absoluteRef)
+                    ? location.source.absoluteRef
+                    : path.relative(cwd, location.source.absoluteRef),
+                line: location.start.line,
+                col: location.start.col,
+                endLine: location.end?.line,
+                endColumn: location.end?.col,
+            };
+            output_1.output.write(`::${command} ${formatProperties(properties)}::${escapeMessage(message)}\n`);
+        }
+    }
+    function formatProperties(props) {
+        return Object.entries(props)
+            .filter(([, v]) => v !== null && v !== undefined)
+            .map(([k, v]) => `${k}=${escapeProperty(v)}`)
+            .join(',');
+    }
+    function toString(v) {
+        if (v === null || v === undefined) {
+            return '';
+        }
+        else if (typeof v === 'string' || v instanceof String) {
+            return v;
+        }
+        return JSON.stringify(v);
+    }
+    function escapeMessage(v) {
+        return toString(v).replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+    }
+    function escapeProperty(v) {
+        return toString(v)
+            .replace(/%/g, '%25')
+            .replace(/\r/g, '%0D')
+            .replace(/\n/g, '%0A')
+            .replace(/:/g, '%3A')
+            .replace(/,/g, '%2C');
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+export { BundleOutputFormat, readFileFromUrl, slash, doesYamlFileExist, isTruthy, getProxyAgent, pause, } from './utils';
+export { Oas3_1Types } from './types/oas3_1';
+export { Arazzo1Types } from './types/arazzo';
+export { Oas3Types } from './types/oas3';
+export { Oas2Types } from './types/oas2';
+export { AsyncApi2Types } from './types/asyncapi2';
+export { AsyncApi3Types } from './types/asyncapi3';
+export { ConfigTypes } from './types/redocly-yaml';
+export type { Oas3Definition, Oas3_1Definition, Oas3Components, Oas3_1Components, Oas3PathItem, Oas3Paths, Oas3ComponentName, Oas3Schema, Oas3_1Schema, Oas3Tag, Referenced, OasRef, } from './typings/openapi';
+export type { Oas2Definition } from './typings/swagger';
+export type { StatsAccumulator, StatsName } from './typings/common';
+export { normalizeTypes } from './types';
+export { Stats } from './rules/other/stats';
+export { Config, StyleguideConfig, RawConfig, RawUniversalConfig, IGNORE_FILE, Region, getMergedConfig, transformConfig, loadConfig, getConfig, findConfig, CONFIG_FILE_NAMES, RuleSeverity, createConfig, ResolvedApi, } from './config';
+export { RedoclyClient } from './redocly';
+export * from './redocly/domains';
+export { Source, BaseResolver, Document, resolveDocument, ResolveError, YamlParseError, makeDocumentFromString, } from './resolve';
+export { parseYaml, stringifyYaml } from './js-yaml';
+export { unescapePointer, isRef, isAbsoluteUrl } from './ref-utils';
+export { SpecMajorVersion, getMajorSpecVersion, SpecVersion, detectSpec, getTypes, } from './oas-types';
+export { normalizeVisitors } from './visitors';
+export { WalkContext, walkDocument, NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObject, Loc, } from './walk';
+export { getAstNodeByPointer, getLineColLocation } from './format/codeframes';
+export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
+export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint';
+export { bundle, bundleDocument, mapTypeToComponent, bundleFromString } from './bundle';