@redocly/openapi-core 1.0.0-beta.61 → 1.0.0-beta.65

package/lib/types/redocly-yaml.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigTypes = void 0;
 const _1 = require(".");
+const utils_1 = require("../utils");
 const ConfigRoot = {
     properties: {
         apiDefinitions: {
             type: 'object',
             properties: {},
-            additionalProperties: { properties: { type: 'string' } }
+            additionalProperties: { properties: { type: 'string' } },
         },
         lint: 'ConfigLint',
         referenceDocs: 'ConfigReferenceDocs',
@@ -87,25 +88,297 @@ const ConfigSidebarLinks = {
         target: { type: 'string' },
     },
 };
+const CommonThemeColors = {
+    properties: {
+        main: { type: 'string' },
+        light: { type: 'string' },
+        dark: { type: 'string' },
+        contrastText: { type: 'string' },
+    },
+};
+const CommonColorProps = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        borderColor: { type: 'string' },
+        color: { type: 'string' },
+        tabTextColor: { type: 'string' },
+    },
+};
+const BorderThemeColors = {
+    properties: utils_1.pickObjectProps(CommonThemeColors.properties, ['light', 'dark']),
+};
+const HttpColors = {
+    properties: {
+        basic: { type: 'string' },
+        delete: { type: 'string' },
+        get: { type: 'string' },
+        head: { type: 'string' },
+        link: { type: 'string' },
+        options: { type: 'string' },
+        patch: { type: 'string' },
+        post: { type: 'string' },
+        put: { type: 'string' },
+    },
+};
+const ResponseColors = {
+    properties: {
+        errors: 'CommonColorProps',
+        info: 'CommonColorProps',
+        redirect: 'CommonColorProps',
+        success: 'CommonColorProps',
+    },
+};
+const SecondaryColors = {
+    properties: utils_1.omitObjectProps(CommonThemeColors.properties, ['dark']),
+};
+const TextThemeColors = {
+    properties: {
+        primary: { type: 'string' },
+        secondary: { type: 'string' },
+        light: { type: 'string' },
+    },
+};
+const ThemeColors = {
+    properties: {
+        accent: 'CommonThemeColors',
+        border: 'BorderThemeColors',
+        error: 'CommonThemeColors',
+        http: 'HttpColors',
+        primary: 'CommonThemeColors',
+        responses: 'ResponseColors',
+        secondary: 'SecondaryColors',
+        success: 'CommonThemeColors',
+        text: 'TextThemeColors',
+        tonalOffset: { type: 'number' },
+        warning: 'CommonThemeColors',
+    },
+};
+const SizeProps = {
+    properties: {
+        fontSize: { type: 'string' },
+        padding: { type: 'string' },
+        minWidth: { type: 'string' },
+    },
+};
+const Sizes = {
+    properties: {
+        small: 'SizeProps',
+        medium: 'SizeProps',
+        large: 'SizeProps',
+        xlarge: 'SizeProps',
+    },
+};
+const FontConfig = {
+    properties: {
+        fontFamily: { type: 'string' },
+        fontSize: { type: 'string' },
+        fontWeight: { type: 'string' },
+        lineHeight: { type: 'string' },
+    },
+};
+const ButtonsConfig = {
+    properties: Object.assign(Object.assign({}, utils_1.omitObjectProps(FontConfig.properties, ['fontSize', 'lineHeight'])), { borderRadius: { type: 'string' }, hoverStyle: { type: 'string' }, boxShadow: { type: 'string' }, hoverBoxShadow: { type: 'string' }, sizes: 'Sizes' }),
+};
+const BadgeFontConfig = {
+    properties: utils_1.pickObjectProps(FontConfig.properties, ['fontSize', 'lineHeight']),
+};
+const BadgeSizes = {
+    properties: {
+        medium: 'BadgeFontConfig',
+        small: 'BadgeFontConfig',
+    },
+};
+const HttpBadgesConfig = {
+    properties: Object.assign(Object.assign({}, utils_1.omitObjectProps(FontConfig.properties, ['fontSize', 'lineHeight'])), { borderRadius: { type: 'string' }, color: { type: 'string' }, sizes: 'BadgeSizes' }),
+};
+const LabelControls = {
+    properties: {
+        top: { type: 'string' },
+    },
+};
+const Panels = {
+    properties: {
+        borderRadius: { type: 'string' },
+    },
+};
+const TryItButton = {
+    properties: {
+        fullWidth: { type: 'boolean' },
+    },
+};
+const Components = {
+    properties: {
+        buttons: 'ButtonsConfig',
+        httpBadges: 'HttpBadgesConfig',
+        layoutControls: 'LabelControls',
+        panels: 'Panels',
+        tryItButton: 'TryItButton',
+        tryItSendButton: 'TryItButton',
+    },
+};
+const Breakpoints = {
+    properties: {
+        small: { type: 'string' },
+        medium: { type: 'string' },
+        large: { type: 'string' },
+    },
+};
+const StackedConfig = {
+    properties: {
+        maxWidth: 'Breakpoints',
+    },
+};
+const ThreePanelConfig = {
+    properties: {
+        maxWidth: 'Breakpoints',
+    },
+};
+const Layout = {
+    properties: {
+        showDarkRightPanel: { type: 'boolean' },
+        stacked: 'StackedConfig',
+        'three-panel': 'ThreePanelConfig',
+    },
+};
+const SchemaColorsConfig = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        border: { type: 'string' },
+    },
+};
+const Schema = {
+    properties: {
+        breakFieldNames: { type: 'boolean' },
+        caretColor: { type: 'string' },
+        caretSize: { type: 'string' },
+        constraints: 'SchemaColorsConfig',
+        defaultDetailsWidth: { type: 'string' },
+        examples: 'SchemaColorsConfig',
+        labelsTextSize: { type: 'string' },
+        linesColor: { type: 'string' },
+        nestedBackground: { type: 'string' },
+        nestingSpacing: { type: 'string' },
+        requireLabelColor: { type: 'string' },
+        typeNameColor: { type: 'string' },
+        typeTitleColor: { type: 'string' },
+    },
+};
+const GroupItemsConfig = {
+    properties: {
+        subItemsColor: { type: 'string' },
+        textTransform: { type: 'string' },
+        fontWeight: { type: 'string' },
+    },
+};
+const Level1Items = {
+    properties: utils_1.pickObjectProps(GroupItemsConfig.properties, ['textTransform']),
+};
+const SpacingConfig = {
+    properties: {
+        unit: { type: 'number' },
+        paddingHorizontal: { type: 'string' },
+        paddingVertical: { type: 'string' },
+        offsetTop: { type: 'string' },
+        offsetLeft: { type: 'string' },
+        offsetNesting: { type: 'string' },
+    },
+};
+const Sidebar = {
+    properties: Object.assign(Object.assign({}, utils_1.omitObjectProps(FontConfig.properties, ['fontWeight', 'lineHeight'])), { activeBgColor: { type: 'string' }, activeTextColor: { type: 'string' }, backgroundColor: { type: 'string' }, borderRadius: { type: 'string' }, breakPath: { type: 'boolean' }, caretColor: { type: 'string' }, caretSize: { type: 'string' }, groupItems: 'GroupItemsConfig', level1items: 'Level1Items', rightLineColor: { type: 'string' }, separatorLabelColor: { type: 'string' }, showAtBreakpoint: { type: 'string' }, spacing: 'SpacingConfig', textColor: { type: 'string' }, width: { type: 'string' } }),
+};
+const Heading = {
+    properties: Object.assign(Object.assign({}, FontConfig.properties), { color: { type: 'string' }, transform: { type: 'string' } }),
+};
+const CodeConfig = {
+    properties: Object.assign(Object.assign({}, FontConfig.properties), { backgroundColor: { type: 'string' }, color: { type: 'string' }, wordBreak: { type: 'string' }, wrap: { type: 'boolean' } }),
+};
+const HeadingsConfig = {
+    properties: utils_1.omitObjectProps(FontConfig.properties, ['fontSize']),
+};
+const LinksConfig = {
+    properties: {
+        color: { type: 'string' },
+        hover: { type: 'string' },
+        textDecoration: { type: 'string' },
+        visited: { type: 'string' },
+    },
+};
+const Typography = {
+    properties: Object.assign(Object.assign({ code: 'CodeConfig', fieldName: 'FontConfig' }, utils_1.pickObjectProps(FontConfig.properties, ['fontSize', 'fontFamily'])), { fontWeightBold: { type: 'string' }, fontWeightLight: { type: 'string' }, fontWeightRegular: { type: 'string' }, heading1: 'Heading', heading2: 'Heading', heading3: 'Heading', headings: 'HeadingsConfig', lineHeight: { type: 'string' }, links: 'LinksConfig', optimizeSpeed: { type: 'boolean' }, rightPanelHeading: 'Heading', smoothing: { type: 'string' } }),
+};
+const TokenProps = {
+    properties: Object.assign({ color: { type: 'string' } }, utils_1.omitObjectProps(FontConfig.properties, ['fontWeight'])),
+};
+const CodeBlock = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        borderRadius: { type: 'string' },
+        tokens: 'TokenProps',
+    },
+};
+const Logo = {
+    properties: {
+        gutter: { type: 'string' },
+        maxHeight: { type: 'string' },
+        maxWidth: { type: 'string' },
+    },
+};
+const ButtonOverrides = {
+    properties: {
+        custom: { type: 'string' },
+    },
+};
+const Overrides = {
+    properties: {
+        DownloadButton: 'ButtonOverrides',
+        NextSectionButton: 'ButtonOverrides',
+    },
+};
+const RightPanel = {
+    properties: {
+        backgroundColor: { type: 'string' },
+        panelBackgroundColor: { type: 'string' },
+        panelControlsBackgroundColor: { type: 'string' },
+        showAtBreakpoint: { type: 'string' },
+        textColor: { type: 'string' },
+        width: { type: 'string' },
+    },
+};
+const Shape = {
+    properties: { borderRadius: { type: 'string' } },
+};
+const ThemeSpacing = {
+    properties: {
+        sectionHorizontal: { type: 'number' },
+        sectionVertical: { type: 'number' },
+        unit: { type: 'number' },
+    },
+};
 const ConfigTheme = {
     properties: {
-        breakpoints: { type: 'object', additionalProperties: { type: 'string' } },
-        codeBlock: { type: 'object', additionalProperties: { type: 'string' } },
-        colors: { type: 'object', additionalProperties: { type: 'string' } },
-        components: { type: 'object', additionalProperties: { type: 'string' } },
-        layout: { type: 'object', additionalProperties: { type: 'string' } },
-        logo: { type: 'object', additionalProperties: { type: 'string' } },
-        overrides: { type: 'object', additionalProperties: { type: 'string' } },
-        rightPanel: { type: 'object', additionalProperties: { type: 'string' } },
-        schema: { type: 'object', additionalProperties: { type: 'string' } },
-        shape: { type: 'object', additionalProperties: { type: 'string' } },
-        sidebar: { type: 'object', additionalProperties: { type: 'string' } },
-        spacing: { type: 'object', additionalProperties: { type: 'string' } },
-        typography: { type: 'object', additionalProperties: { type: 'string' } },
+        breakpoints: 'Breakpoints',
+        codeBlock: 'CodeBlock',
+        colors: 'ThemeColors',
+        components: 'Components',
+        layout: 'Layout',
+        logo: 'Logo',
+        overrides: 'Overrides',
+        rightPanel: 'RightPanel',
+        schema: 'Schema',
+        shape: 'Shape',
+        sidebar: 'Sidebar',
+        spacing: 'ThemeSpacing',
+        typography: 'Typography',
         links: { properties: { color: { type: 'string' } } },
         codeSample: { properties: { backgroundColor: { type: 'string' } } },
     },
 };
+const GenerateCodeSamples = {
+    properties: {
+        skipOptionalParameters: { type: 'boolean' },
+        languages: _1.listOf('ConfigLanguage'),
+    },
+};
 const ConfigReferenceDocs = {
     properties: {
         theme: 'ConfigTheme',
@@ -119,12 +392,7 @@ const ConfigReferenceDocs = {
         expandDefaultServerVariables: { type: 'boolean' },
         expandResponses: { type: 'string' },
         expandSingleSchemaField: { type: 'boolean' },
-        generateCodeSamples: {
-            properties: {
-                skipOptionalParameters: { type: 'boolean' },
-                languages: _1.listOf('ConfigLanguage'),
-            },
-        },
+        generateCodeSamples: 'GenerateCodeSamples',
         generatedPayloadSamplesMaxDepth: { type: 'number' },
         hideDownloadButton: { type: 'boolean' },
         hideHostname: { type: 'boolean' },
@@ -138,7 +406,7 @@ const ConfigReferenceDocs = {
         htmlTemplate: { type: 'string' },
         jsonSampleExpandLevel: { type: 'string' },
         labels: 'ConfigLabels',
-        layout: { type: 'object' },
+        layout: { type: 'string' },
         maxDisplayedEnumValues: { type: 'number' },
         menuToggle: { type: 'boolean' },
         nativeScrollbars: { type: 'boolean' },
@@ -186,4 +454,47 @@ exports.ConfigTypes = {
     ConfigLabels,
     ConfigSidebarLinks,
     ConfigTheme,
+    ThemeColors,
+    CommonThemeColors,
+    BorderThemeColors,
+    HttpColors,
+    ResponseColors,
+    SecondaryColors,
+    TextThemeColors,
+    Sizes,
+    ButtonsConfig,
+    CommonColorProps,
+    BadgeFontConfig,
+    BadgeSizes,
+    HttpBadgesConfig,
+    LabelControls,
+    Panels,
+    TryItButton,
+    Breakpoints,
+    StackedConfig,
+    ThreePanelConfig,
+    SchemaColorsConfig,
+    SizeProps,
+    Level1Items,
+    SpacingConfig,
+    FontConfig,
+    CodeConfig,
+    HeadingsConfig,
+    LinksConfig,
+    TokenProps,
+    CodeBlock,
+    Logo,
+    ButtonOverrides,
+    Overrides,
+    RightPanel,
+    Shape,
+    ThemeSpacing,
+    GenerateCodeSamples,
+    GroupItemsConfig,
+    Components,
+    Layout,
+    Schema,
+    Sidebar,
+    Heading,
+    Typography,
 };

package/lib/utils.d.ts

@@ -1,4 +1,5 @@
 import { HttpResolveConfig } from './config/config';
+export { parseYaml, stringifyYaml } from './js-yaml';
 export declare type StackFrame<T> = {
     prev: StackFrame<T> | null;
     value: T;
@@ -11,7 +12,7 @@ export declare function pushStack<T, P extends Stack<T> = Stack<T>>(head: P, val
 };
 export declare function popStack<T, P extends Stack<T>>(head: P): StackFrame<T> | null;
 export declare type BundleOutputFormat = 'json' | 'yml' | 'yaml';
-export declare function loadYaml(filename: string): Promise<string | object | undefined>;
+export declare function loadYaml(filename: string): Promise<unknown>;
 export declare function notUndefined<T>(x: T | undefined): x is T;
 export declare function isPlainObject(value: any): value is object;
 export declare function readFileFromUrl(url: string, config: HttpResolveConfig): Promise<{
@@ -19,3 +20,6 @@ export declare function readFileFromUrl(url: string, config: HttpResolveConfig):
     mimeType: any;
 }>;
 export declare function match(url: string, pattern: string): boolean;
+export declare function pickObjectProps<T extends Record<string, unknown>>(object: T, keys: Array<string>): T;
+export declare function omitObjectProps<T extends Record<string, unknown>>(object: T, keys: Array<string>): T;
+export declare function readFileAsStringSync(filePath: string): string;

package/lib/utils.js

@@ -9,11 +9,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = void 0;
-const yaml = require("js-yaml");
+exports.readFileAsStringSync = exports.omitObjectProps = exports.pickObjectProps = exports.match = exports.readFileFromUrl = exports.isPlainObject = exports.notUndefined = exports.loadYaml = exports.popStack = exports.pushStack = exports.stringifyYaml = exports.parseYaml = void 0;
 const fs = require("fs");
 const minimatch = require("minimatch");
 const node_fetch_1 = require("node-fetch");
+const js_yaml_1 = require("./js-yaml");
+var js_yaml_2 = require("./js-yaml");
+Object.defineProperty(exports, "parseYaml", { enumerable: true, get: function () { return js_yaml_2.parseYaml; } });
+Object.defineProperty(exports, "stringifyYaml", { enumerable: true, get: function () { return js_yaml_2.stringifyYaml; } });
 function pushStack(head, value) {
     return { prev: head, value };
 }
@@ -26,7 +29,7 @@ exports.popStack = popStack;
 function loadYaml(filename) {
     return __awaiter(this, void 0, void 0, function* () {
         const contents = yield fs.promises.readFile(filename, 'utf-8');
-        return yaml.safeLoad(contents);
+        return js_yaml_1.parseYaml(contents);
     });
 }
 exports.loadYaml = loadYaml;
@@ -65,3 +68,15 @@ function match(url, pattern) {
     return minimatch(url, pattern);
 }
 exports.match = match;
+function pickObjectProps(object, keys) {
+    return Object.fromEntries(keys.filter((key) => key in object).map((key) => [key, object[key]]));
+}
+exports.pickObjectProps = pickObjectProps;
+function omitObjectProps(object, keys) {
+    return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
+}
+exports.omitObjectProps = omitObjectProps;
+function readFileAsStringSync(filePath) {
+    return fs.readFileSync(filePath, 'utf-8');
+}
+exports.readFileAsStringSync = readFileAsStringSync;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.61",
+  "version": "1.0.0-beta.65",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -34,7 +34,7 @@
     "@types/node": "^14.11.8",
     "colorette": "^1.2.0",
     "js-levenshtein": "^1.1.6",
-    "js-yaml": "^3.14.1",
+    "js-yaml": "^4.1.0",
     "lodash.isequal": "^4.5.0",
     "minimatch": "^3.0.4",
     "node-fetch": "^2.6.1",
@@ -42,7 +42,7 @@
   },
   "devDependencies": {
     "@types/js-levenshtein": "^1.1.0",
-    "@types/js-yaml": "^3.12.4",
+    "@types/js-yaml": "^4.0.3",
     "@types/lodash.isequal": "^4.5.5",
     "@types/minimatch": "^3.0.3",
     "@types/node-fetch": "^2.5.7",

package/src/__tests__/js-yaml.test.ts

@@ -0,0 +1,47 @@
+import { parseYaml, stringifyYaml } from '../js-yaml';
+
+const yaml = `
+  emptyValue:
+  spaces in keys: spaces in keys
+  numberString: '0123456789'
+  number: 1000
+  decimal: 12.34
+  boolean: true
+  date: 2020-01-01
+  array:
+    - 1
+    - 2
+  object:
+    key1: 1
+    key2: 2
+`;
+
+const jsObject = {
+  emptyValue: null,
+  'spaces in keys': 'spaces in keys',
+  numberString: '0123456789',
+  number: 1000,
+  decimal: 12.34,
+  boolean: true,
+  date: '2020-01-01',
+  array: [1, 2],
+  object: { key1: 1, key2: 2 },
+};
+
+describe('js-yaml', () => {
+  test('parseYaml', () => {
+    expect(parseYaml(yaml)).toEqual(jsObject);
+  });
+
+  test('parse and stringify', () => {
+    expect(parseYaml(stringifyYaml(jsObject))).toEqual(jsObject);
+  });
+
+  test('should throw an error for unsupported types', () => {
+    expect(() => stringifyYaml({ date: new Date() }))
+      .toThrow('unacceptable kind of an object to dump [object Date]');
+
+    expect(() => stringifyYaml({ foo: () => {} }))
+      .toThrow('unacceptable kind of an object to dump [object Function]');
+  });
+});

package/src/__tests__/lint.test.ts

@@ -87,6 +87,19 @@ describe('lint', () => {
           "severity": "error",
           "suggest": Array [],
         },
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/referenceDocs/layout",
+              "reportOnKey": false,
+              "source": "",
+            },
+          ],
+          "message": "Expected type \`string\` but got \`object\`.",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
       ]
     `);
   });

package/src/__tests__/utils.test.ts

@@ -0,0 +1,56 @@
+import { pickObjectProps, omitObjectProps } from '../utils';
+
+describe('utils', () => {
+  const testObject = {
+    a: 'value a',
+    b: 'value b',
+    c: 'value c',
+    d: 'value d',
+    e: 'value e',
+  };
+
+  describe('pickObjectProps', () => {
+    it('returns correct object result', () => {
+      expect(pickObjectProps(testObject, ['a', 'b'])).toStrictEqual({ a: 'value a', b: 'value b' });
+    });
+
+    it('returns correct object if passed non existing key', () => {
+      expect(pickObjectProps(testObject, ['a', 'b', 'nonExisting'])).toStrictEqual({
+        a: 'value a',
+        b: 'value b',
+      });
+    });
+
+    it('returns an empty object if no keys are passed', () => {
+      expect(pickObjectProps(testObject, [])).toStrictEqual({});
+    });
+
+    it('returns an empty object if empty target obj passed', () => {
+      expect(pickObjectProps({}, ['d', 'e'])).toStrictEqual({});
+    });
+  });
+
+  describe('omitObjectProps', () => {
+    it('returns correct object result', () => {
+      expect(omitObjectProps(testObject, ['a', 'b', 'c'])).toStrictEqual({
+        d: 'value d',
+        e: 'value e',
+      });
+    });
+
+    it('returns correct object if passed non existing key', () => {
+      expect(omitObjectProps(testObject, ['a', 'b', 'c', 'nonExisting'])).toStrictEqual({
+        d: 'value d',
+        e: 'value e',
+      });
+    });
+
+    it('returns full object if no keys are passed', () => {
+      expect(omitObjectProps(testObject, [])).toStrictEqual(testObject);
+    });
+
+    it('returns an empty object if empty target obj passed', () => {
+      expect(omitObjectProps({}, ['d', 'e'])).toStrictEqual({});
+    });
+  });
+});

package/src/benchmark/utils.ts

@@ -1,4 +1,4 @@
-import * as yaml from 'js-yaml';
+import { parseYaml } from '../js-yaml';
 import { Document, Source } from '../resolve';
 import { Oas3RuleSet } from '../oas-types';
 import { RuleConfig, LintConfig, Plugin } from '../config/config';
@@ -6,7 +6,7 @@ import { RuleConfig, LintConfig, Plugin } from '../config/config';
 export function parseYamlToDocument(body: string, absoluteRef: string = ''): Document {
   return {
     source: new Source(absoluteRef, body),
-    parsed: yaml.safeLoad(body, { filename: absoluteRef }),
+    parsed: parseYaml(body, { filename: absoluteRef }),
   };
 }
 

package/src/config/config.ts

@@ -1,9 +1,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import * as yaml from 'js-yaml';
 import { dirname } from 'path';
 import { red, blue } from 'colorette';
 
+import { parseYaml, stringifyYaml } from '../js-yaml';
 import { notUndefined } from '../utils';
 
 import {
@@ -190,7 +190,7 @@ export class LintConfig {
     if (fs.hasOwnProperty('existsSync') && fs.existsSync(ignoreFile)) {
       // TODO: parse errors
       this.ignore =
-        (yaml.safeLoad(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
+        (parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
           string,
           Record<string, Set<string>>
         >) || {};
@@ -216,7 +216,7 @@ export class LintConfig {
         ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]) as any;
       }
     }
-    fs.writeFileSync(ignoreFile, IGNORE_BANNER + yaml.safeDump(mapped));
+    fs.writeFileSync(ignoreFile, IGNORE_BANNER + stringifyYaml(mapped));
   }
 
   addIgnore(problem: NormalizedProblem) {
@@ -384,6 +384,7 @@ export class Config {
   apiDefinitions: Record<string, string>;
   lint: LintConfig;
   resolve: ResolveConfig;
+  licenseKey?: string;
   constructor(public rawConfig: RawConfig, public configFile?: string) {
     this.apiDefinitions = rawConfig.apiDefinitions || {};
     this.lint = new LintConfig(rawConfig.lint || {}, configFile);

package/src/index.ts

@@ -29,9 +29,11 @@ export {
   YamlParseError,
   makeDocumentFromString,
 } from './resolve';
+export { parseYaml, stringifyYaml } from './js-yaml';
 export { unescapePointer } from './ref-utils';
 export { detectOpenAPI, OasMajorVersion, openAPIMajor, OasVersion } from './oas-types';
 export { normalizeVisitors } from './visitors';
+
 export {
   WalkContext,
   walkDocument,