@redocly/cli 1.0.0-beta.100

package/README.md

@@ -0,0 +1,39 @@
+# Redocly CLI toolset
+
+Redocly CLI toolbox with rich validation and bundling features.
+
+![npm (scoped)](https://img.shields.io/npm/v/@redocly/cli)
+![NPM](https://img.shields.io/npm/l/@redocly/cli)
+
+![OpenAPI 3 CLI toolset](./media/redocly-cli.gif)
+
+## Features
+
+Currently, @redocly/cli supports these features:
+
+- [x] Multifile validation. No need to bundle your file before validation.
+- [x] Lightning-fast validation. Lint a 1 Mb file in less than one second.
+- [x] Built-in rules for common validations.
+- [x] Configurable severity levels for each rule.
+- [x] Human-readable error messages with codeframes and stylish format options.
+- [x] Intuitive suggestions for misspelled types or references.
+- [x] Easy to implement custom rules.
+- [x] Bundle a multifile definition into a single file.
+- [x] Decorators to modify a validated definition during bundling.
+- [x] Preview reference docs for local development.
+- [x] Support for OpenAPI 2 (fka Swagger) and OpenAPI 3.0.
+- [ ] Support for OpenAPI 3.1 ([coming soon](https://github.com/Redocly/redocly-cli/issues/160)).
+
+## What makes this tool different
+
+Unlike other OpenAPI linters, `@redocly/cli` defines the possible type tree of a valid OpenAPI definition and then traverses it. This approach is very similar to how linters for programming languages work and results in major performance benefits over other approaches. Extend functionality at different points in the lifecycle with preprocessors, rules, and decorators.
+
+## TLDR
+
+`npx @redocly/cli lint path-to-root-file.yaml`
+
+## [Read the docs](https://redoc.ly/docs/cli/)
+
+## Credits
+
+Thanks to [graphql-js](https://github.com/graphql/graphql-js) and [eslint](https://github.com/eslint/eslint) for inspiration of the definition traversal approach and to [Swagger](https://github.com/swagger-api/swagger-editor), [Spectral](https://github.com/stoplightio/spectral), and [OAS-Kit](https://github.com/Mermade/oas-kit) for inspiring the ruleset.

package/bin/cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../lib/index");

package/lib/__mocks__/@redocly/openapi-core.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="jest" />
+export declare const __redoclyClient: {
+    isAuthorizedWithRedocly: jest.Mock<any, any>;
+    isAuthorizedWithRedoclyByRegion: jest.Mock<any, any>;
+    login: jest.Mock<any, any>;
+    registryApi: {
+        setAccessTokens: jest.Mock<any, any>;
+        authStatus: jest.Mock<any, any>;
+        prepareFileUpload: jest.Mock<any, any>;
+        pushApi: jest.Mock<any, any>;
+    };
+};
+export declare const RedoclyClient: jest.Mock<{
+    isAuthorizedWithRedocly: jest.Mock<any, any>;
+    isAuthorizedWithRedoclyByRegion: jest.Mock<any, any>;
+    login: jest.Mock<any, any>;
+    registryApi: {
+        setAccessTokens: jest.Mock<any, any>;
+        authStatus: jest.Mock<any, any>;
+        prepareFileUpload: jest.Mock<any, any>;
+        pushApi: jest.Mock<any, any>;
+    };
+}, []>;
+export declare const loadConfig: jest.Mock<{
+    configFile: null;
+    lint: {
+        skipRules: jest.Mock<any, any>;
+        skipPreprocessors: jest.Mock<any, any>;
+        skipDecorators: jest.Mock<any, any>;
+    };
+}, []>;
+export declare const getMergedConfig: jest.Mock<any, any>;
+export declare const lint: jest.Mock<any, any>;
+export declare const bundle: jest.Mock<{
+    bundle: {
+        parsed: null;
+    };
+    problems: null;
+}, []>;
+export declare const getTotals: jest.Mock<{
+    errors: number;
+}, []>;
+export declare const formatProblems: jest.Mock<any, any>;
+export declare const slash: jest.Mock<any, any>;

package/lib/__mocks__/@redocly/openapi-core.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slash = exports.formatProblems = exports.getTotals = exports.bundle = exports.lint = exports.getMergedConfig = exports.loadConfig = exports.RedoclyClient = exports.__redoclyClient = void 0;
+exports.__redoclyClient = {
+    isAuthorizedWithRedocly: jest.fn().mockResolvedValue(true),
+    isAuthorizedWithRedoclyByRegion: jest.fn().mockResolvedValue(true),
+    login: jest.fn(),
+    registryApi: {
+        setAccessTokens: jest.fn(),
+        authStatus: jest.fn(),
+        prepareFileUpload: jest.fn().mockResolvedValue({
+            signedUploadUrl: 'signedUploadUrl',
+            filePath: 'filePath',
+        }),
+        pushApi: jest.fn(),
+    },
+};
+exports.RedoclyClient = jest.fn(() => exports.__redoclyClient);
+exports.loadConfig = jest.fn(() => ({
+    configFile: null,
+    lint: { skipRules: jest.fn(), skipPreprocessors: jest.fn(), skipDecorators: jest.fn() },
+}));
+exports.getMergedConfig = jest.fn();
+exports.lint = jest.fn();
+exports.bundle = jest.fn(() => ({ bundle: { parsed: null }, problems: null }));
+exports.getTotals = jest.fn(() => ({ errors: 0 }));
+exports.formatProblems = jest.fn();
+exports.slash = jest.fn();

package/lib/__mocks__/fs.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+export declare const existsSync: jest.Mock<any, any>;
+export declare const readFileSync: jest.Mock<string, []>;
+export declare const statSync: jest.Mock<{
+    size: number;
+}, []>;
+export declare const createReadStream: jest.Mock<any, any>;

package/lib/__mocks__/fs.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadStream = exports.statSync = exports.readFileSync = exports.existsSync = void 0;
+exports.existsSync = jest.fn();
+exports.readFileSync = jest.fn(() => '');
+exports.statSync = jest.fn(() => ({ size: 0 }));
+exports.createReadStream = jest.fn();

package/lib/__mocks__/utils.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="jest" />
+export declare const getFallbackEntryPointsOrExit: jest.Mock<any, [entrypoints: any]>;
+export declare const getTotals: jest.Mock<{
+    errors: number;
+}, []>;
+export declare const dumpBundle: jest.Mock<string, []>;
+export declare const slash: jest.Mock<any, any>;
+export declare const pluralize: jest.Mock<any, any>;
+export declare const getExecutionTime: jest.Mock<any, any>;
+export declare const printExecutionTime: jest.Mock<any, any>;
+export declare const printUnusedWarnings: jest.Mock<any, any>;
+export declare const printLintTotals: jest.Mock<any, any>;
+export declare const getOutputFileName: jest.Mock<{
+    outputFile: string;
+    ext: string;
+}, []>;
+export declare const handleError: jest.Mock<any, any>;

package/lib/__mocks__/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.getOutputFileName = exports.printLintTotals = exports.printUnusedWarnings = exports.printExecutionTime = exports.getExecutionTime = exports.pluralize = exports.slash = exports.dumpBundle = exports.getTotals = exports.getFallbackEntryPointsOrExit = void 0;
+exports.getFallbackEntryPointsOrExit = jest.fn((entrypoints) => entrypoints.map(() => ({ path: '' })));
+exports.getTotals = jest.fn(() => ({ errors: 0 }));
+exports.dumpBundle = jest.fn(() => '');
+exports.slash = jest.fn();
+exports.pluralize = jest.fn();
+exports.getExecutionTime = jest.fn();
+exports.printExecutionTime = jest.fn();
+exports.printUnusedWarnings = jest.fn();
+exports.printLintTotals = jest.fn();
+exports.getOutputFileName = jest.fn(() => ({ outputFile: 'test.yaml', ext: 'yaml' }));
+exports.handleError = jest.fn();

package/lib/__tests__/commands/bundle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/commands/bundle.test.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openapi_core_1 = require("@redocly/openapi-core");
+const bundle_1 = require("../../commands/bundle");
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils');
+openapi_core_1.getMergedConfig.mockImplementation(config => config);
+describe('bundle', () => {
+    let processExitMock;
+    let exitCb;
+    beforeEach(() => {
+        processExitMock = jest.spyOn(process, 'exit').mockImplementation();
+        jest.spyOn(process, 'once').mockImplementation((_e, cb) => {
+            exitCb = cb;
+            return process.on(_e, cb);
+        });
+        jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        openapi_core_1.lint.mockClear();
+        openapi_core_1.bundle.mockClear();
+        openapi_core_1.getTotals.mockClear();
+    });
+    it('bundles definitions w/o linting', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+        }, '1.0.0');
+        expect(openapi_core_1.lint).toBeCalledTimes(0);
+        expect(openapi_core_1.bundle).toBeCalledTimes(entrypoints.length);
+    }));
+    it('exits with code 0 when bundles definitions', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+        }, '1.0.0');
+        exitCb === null || exitCb === void 0 ? void 0 : exitCb();
+        expect(processExitMock).toHaveBeenCalledWith(0);
+    }));
+    it('bundles definitions w/ linting', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+            lint: true,
+        }, '1.0.0');
+        expect(openapi_core_1.lint).toBeCalledTimes(entrypoints.length);
+        expect(openapi_core_1.bundle).toBeCalledTimes(entrypoints.length);
+    }));
+    it('exits with code 0 when bundles definitions w/linting w/o errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+            lint: true,
+        }, '1.0.0');
+        exitCb === null || exitCb === void 0 ? void 0 : exitCb();
+        expect(processExitMock).toHaveBeenCalledWith(0);
+    }));
+    it('exits with code 1 when bundles definitions w/linting w/errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        const entrypoints = ['foo.yaml'];
+        openapi_core_1.getTotals.mockReturnValue({
+            errors: 1,
+            warnings: 0,
+            ignored: 0
+        });
+        yield bundle_1.handleBundle({
+            entrypoints,
+            ext: 'yaml',
+            format: 'codeframe',
+            lint: true,
+        }, '1.0.0');
+        expect(openapi_core_1.lint).toBeCalledTimes(entrypoints.length);
+        exitCb === null || exitCb === void 0 ? void 0 : exitCb();
+        expect(processExitMock).toHaveBeenCalledWith(1);
+    }));
+});

package/lib/__tests__/commands/push-region.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/commands/push-region.test.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openapi_core_1 = require("@redocly/openapi-core");
+const push_1 = require("../../commands/push");
+const login_1 = require("../../commands/login");
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+    default: jest.fn(() => ({
+        ok: true,
+        json: jest.fn().mockResolvedValue({}),
+    })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../commands/login');
+jest.mock('../../utils');
+openapi_core_1.getMergedConfig.mockImplementation((config) => config);
+const mockPromptClientToken = login_1.promptClientToken;
+describe('push-with-region', () => {
+    const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+    redoclyClient.isAuthorizedWithRedoclyByRegion = jest.fn().mockResolvedValue(false);
+    beforeAll(() => {
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    it('should call login with default domain when region is US', () => __awaiter(void 0, void 0, void 0, function* () {
+        redoclyClient.domain = 'redoc.ly';
+        yield push_1.handlePush({
+            upsert: true,
+            entrypoint: 'spec.json',
+            destination: '@org/my-api@1.0.0',
+            branchName: 'test',
+        });
+        expect(mockPromptClientToken).toBeCalledTimes(1);
+        expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+    }));
+    it('should call login with EU domain when region is EU', () => __awaiter(void 0, void 0, void 0, function* () {
+        redoclyClient.domain = 'eu.redocly.com';
+        yield push_1.handlePush({
+            upsert: true,
+            entrypoint: 'spec.json',
+            destination: '@org/my-api@1.0.0',
+            branchName: 'test',
+        });
+        expect(mockPromptClientToken).toBeCalledTimes(1);
+        expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+    }));
+});

package/lib/__tests__/commands/push.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/commands/push.test.js

@@ -0,0 +1,155 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openapi_core_1 = require("@redocly/openapi-core");
+const push_1 = require("../../commands/push");
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+    default: jest.fn(() => ({
+        ok: true,
+        json: jest.fn().mockResolvedValue({}),
+    })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils');
+openapi_core_1.getMergedConfig.mockImplementation((config) => config);
+describe('push', () => {
+    const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+    beforeEach(() => {
+        jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    it('pushes definition', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield push_1.handlePush({
+            upsert: true,
+            entrypoint: 'spec.json',
+            destination: '@org/my-api@1.0.0',
+            branchName: 'test',
+            'public': true
+        });
+        expect(redoclyClient.registryApi.prepareFileUpload).toBeCalledTimes(1);
+        expect(redoclyClient.registryApi.pushApi).toBeCalledTimes(1);
+        expect(redoclyClient.registryApi.pushApi).toHaveBeenLastCalledWith({
+            branch: 'test',
+            filePaths: ['filePath'],
+            isUpsert: true,
+            isPublic: true,
+            name: 'my-api',
+            organizationId: 'org',
+            rootFilePath: 'filePath',
+            version: '1.0.0',
+        });
+    }));
+});
+describe('transformPush', () => {
+    it('should adapt the existing syntax', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+            maybeDestination: '@testing_org/main@v1',
+        });
+        expect(cb).toBeCalledWith({
+            entrypoint: 'openapi.yaml',
+            destination: '@testing_org/main@v1',
+        });
+    });
+    it('should adapt the existing syntax (including branchName)', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+            maybeDestination: '@testing_org/main@v1',
+            maybeBranchName: 'other',
+        });
+        expect(cb).toBeCalledWith({
+            entrypoint: 'openapi.yaml',
+            destination: '@testing_org/main@v1',
+            branchName: 'other',
+        });
+    });
+    it('should use --branch option firstly', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+            maybeDestination: '@testing_org/main@v1',
+            maybeBranchName: 'other',
+            branch: 'priority-branch',
+        });
+        expect(cb).toBeCalledWith({
+            entrypoint: 'openapi.yaml',
+            destination: '@testing_org/main@v1',
+            branchName: 'priority-branch',
+        });
+    });
+    it('should work for a destination only', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: '@testing_org/main@v1',
+        });
+        expect(cb).toBeCalledWith({
+            destination: '@testing_org/main@v1',
+        });
+    });
+    it('should accept aliases for the old syntax', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({
+            maybeEntrypointOrAliasOrDestination: 'alias',
+            maybeDestination: '@testing_org/main@v1',
+        });
+        expect(cb).toBeCalledWith({
+            destination: '@testing_org/main@v1',
+            entrypoint: 'alias',
+        });
+    });
+    it('should accept no arguments at all', () => {
+        const cb = jest.fn();
+        push_1.transformPush(cb)({});
+        expect(cb).toBeCalledWith({});
+    });
+});
+describe('getDestinationProps', () => {
+    it('should get valid destination props for the full destination syntax', () => {
+        expect(push_1.getDestinationProps('@testing_org/main@v1', 'org-from-config')).toEqual([
+            'testing_org',
+            'main',
+            'v1',
+        ]);
+    });
+    it('should fallback the organizationId from a config for the short destination syntax', () => {
+        expect(push_1.getDestinationProps('main@v1', 'org-from-config')).toEqual([
+            'org-from-config',
+            'main',
+            'v1',
+        ]);
+    });
+    it('should fallback the organizationId from a config if no destination provided', () => {
+        expect(push_1.getDestinationProps(undefined, 'org-from-config')).toEqual(['org-from-config']);
+    });
+    it('should return empty organizationId if there is no one found', () => {
+        expect(push_1.getDestinationProps('main@v1', undefined)).toEqual([, 'main', 'v1']);
+    });
+});
+describe('getApiEntrypoint', () => {
+    let config = {
+        apis: {
+            'main@v1': {
+                root: 'openapi.yaml',
+            },
+            main: {
+                root: 'latest.yaml',
+            },
+        },
+    };
+    it('should resolve the correct api for a valid name & version', () => {
+        expect(push_1.getApiEntrypoint({ name: 'main', version: 'v1', config })).toEqual('openapi.yaml');
+    });
+    it('should resolve the latest version of api if there is no matching version', () => {
+        expect(push_1.getApiEntrypoint({ name: 'main', version: 'latest', config })).toEqual('latest.yaml');
+    });
+});

package/lib/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/__tests__/utils.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+jest.mock("os");
+describe('isSubdir', () => {
+    it('can correctly determine if subdir', () => {
+        [
+            ['/foo', '/foo', false],
+            ['/foo', '/bar', false],
+            ['/foo', '/foobar', false],
+            ['/foo', '/foo/bar', true],
+            ['/foo', '/foo/../bar', false],
+            ['/foo', '/foo/./bar', true],
+            ['/bar/../foo', '/foo/bar', true],
+            ['/foo', './bar', false],
+            ['/foo', '/foo/..bar', true],
+        ].forEach(([parent, child, expectRes]) => {
+            expect(utils_1.isSubdir(parent, child)).toBe(expectRes);
+        });
+    });
+    it('can correctly determine if subdir for windows-based paths', () => {
+        const os = require('os');
+        os.platform.mockImplementation(() => 'win32');
+        [
+            ['C:/Foo', 'C:/Foo/Bar', true],
+            ['C:\\Foo', 'C:\\Bar', false],
+            ['C:\\Foo', 'D:\\Foo\\Bar', false],
+        ].forEach(([parent, child, expectRes]) => {
+            expect(utils_1.isSubdir(parent, child)).toBe(expectRes);
+        });
+    });
+    afterEach(() => {
+        jest.resetModules();
+    });
+});
+describe('pathToFilename', () => {
+    it('should use correct path separator', () => {
+        const processedPath = utils_1.pathToFilename('/user/createWithList', '_');
+        expect(processedPath).toEqual('user_createWithList');
+    });
+});

package/lib/assert-node-version.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/assert-node-version.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const utils_1 = require("./utils");
+try {
+    require('assert-node-version')(path.join(__dirname, '../'));
+}
+catch (err) {
+    utils_1.exitWithError(err.message);
+}

package/lib/commands/bundle.d.ts

@@ -0,0 +1,20 @@
+import { OutputFormat } from '@redocly/openapi-core';
+import { OutputExtensions } from '../types';
+export declare function handleBundle(argv: {
+    entrypoints: string[];
+    output?: string;
+    ext: OutputExtensions;
+    'max-problems'?: number;
+    'skip-rule'?: string[];
+    'skip-preprocessor'?: string[];
+    'skip-decorator'?: string[];
+    dereferenced?: boolean;
+    force?: boolean;
+    config?: string;
+    lint?: boolean;
+    format: OutputFormat;
+    metafile?: string;
+    extends?: string[];
+    'remove-unused-components'?: boolean;
+    'keep-url-references'?: boolean;
+}, version: string): Promise<void>;