@adinsure-ops/ops-cli 4.0.0-rc6

package/lib/commands/sql.d.ts

@@ -0,0 +1,24 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../command.base';
+export default class Sql extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        description: string;
+        options: string[];
+    }[];
+    static flags: {
+        version: flags.IOptionFlag<string | undefined>;
+        layer: flags.IOptionFlag<string | undefined>;
+    };
+    private readonly _moduleTypes;
+    private readonly _dbmsType;
+    /**
+     * Get unique scriptID by specified version
+     */
+    getScriptId(version: string): Promise<string>;
+    handleLayer(scriptDbmsFolder: string, scriptLayer: string, scriptType: string, dbmsFormat: string): Promise<string>;
+    run(): Promise<void>;
+}

package/lib/commands/sql.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const fs = require("fs-extra");
+const inquirer = require("inquirer");
+const path = require("path");
+const request = require("request-promise");
+const command_base_1 = require("../command.base");
+class Sql extends command_base_1.default {
+    constructor() {
+        super(...arguments);
+        this._moduleTypes = {
+            acc: 'Accounting',
+            claims: 'Claims',
+            core: 'Core',
+            pas: 'PAS',
+            reins: 'Reinsurance',
+            shared: 'Shared'
+        };
+        this._dbmsType = ['sql', 'oradc'];
+    }
+    /**
+     * Get unique scriptID by specified version
+     */
+    async getScriptId(version) {
+        let options = {
+            uri: `https://ops.adinsure.com/api/script/next?version=${version}`,
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken()
+            }
+        };
+        return request.get(options);
+    }
+    async handleLayer(scriptDbmsFolder, scriptLayer, scriptType, dbmsFormat) {
+        let scriptFolder = path.resolve(scriptDbmsFolder, scriptLayer, scriptType);
+        let layerFolder = path.resolve(scriptDbmsFolder, scriptLayer);
+        if (!await fs.pathExists(layerFolder)) {
+            let layers = '';
+            // printout only layer folders
+            for (let layer of fs.readdirSync(scriptDbmsFolder)) {
+                if (layer.toLowerCase() !== 'schema' && layer.toLowerCase() !== 'data') {
+                    layers = layers + '\n' + layer;
+                }
+            }
+            if (layers.length > 0) {
+                this.log(`Layer ${scriptLayer} for ${dbmsFormat} does not exist, did you mean: ${layers}`);
+            }
+            else {
+                this.log(`Layer ${scriptLayer} for ${dbmsFormat} does not exist.`);
+            }
+        }
+        return scriptFolder;
+    }
+    async run() {
+        const { args, flags } = this.parse(Sql);
+        // Validation of input parameters
+        let scriptType = args.type;
+        if (!scriptType) {
+            let responses = await inquirer.prompt([{
+                    name: 'type',
+                    message: 'select a sql type',
+                    type: 'list',
+                    choices: [{ name: 'schema' }, { name: 'data' }, { name: 'migration' }],
+                }]);
+            scriptType = responses.type;
+        }
+        let scriptModule = args.module;
+        if (!scriptModule && scriptType === 'data') {
+            let responses = await inquirer.prompt([{
+                    name: 'module',
+                    message: 'select a sql module for data type',
+                    type: 'list',
+                    choices: [{ name: 'acc' }, { name: 'claims' }, { name: 'core' }, { name: 'pas' }, { name: 'reins' }, { name: 'shared' }],
+                }]);
+            scriptModule = responses.module;
+        }
+        let scriptLayer = flags.layer;
+        this.log(`Generating on SQL script layer:'${scriptLayer}'`);
+        const fullVersion = flags.version || await this.getVersion('PLATFORM_VERSION', 'VERSION');
+        let version = fullVersion.split('-')[0];
+        let versionRegex = /\d+\.\d+\.\d+/;
+        if (!(versionRegex.test(version))) {
+            this.error(`Version in incorrect format. Got version: '${version}'`);
+        }
+        let scriptsRootFolder = path.resolve(await this.getGitRoot(), 'database');
+        if (!await fs.pathExists(scriptsRootFolder)) {
+            this.error(`Could not resolve database scripts folder: ${scriptsRootFolder}`);
+        }
+        let scriptFolderLocations = [];
+        for (let dbmsFormat of this._dbmsType) {
+            let scriptDbmsFolder = path.resolve(scriptsRootFolder, dbmsFormat);
+            if (await fs.pathExists(scriptDbmsFolder)) {
+                let scriptFolder = path.resolve(scriptDbmsFolder, scriptType);
+                if (scriptLayer !== undefined) {
+                    scriptFolder = await this.handleLayer(scriptDbmsFolder, scriptLayer, scriptType, dbmsFormat);
+                }
+                if (scriptModule !== undefined) {
+                    scriptFolder = path.resolve(scriptFolder, this._moduleTypes[scriptModule]);
+                }
+                if (!await fs.pathExists(scriptFolder)) {
+                    this.warn(`Could not resolve existing database scripts folder. Creating folder: ${scriptFolder}`);
+                    await fs.mkdir(scriptFolder);
+                }
+                scriptFolderLocations.push(scriptFolder);
+            }
+        }
+        // Validation of parameters succeed. Requesting new SQL script ID and creating file.
+        this.log(`Requesting new id for '${version}'`);
+        let scriptId = await this.getScriptId(version);
+        this.log(`Got: '${chalk_1.default.green(scriptId)}'`);
+        for (let scriptFolder of scriptFolderLocations) {
+            let scriptsFilePath = path.resolve(scriptFolder, `${scriptId}.sql`);
+            await fs.writeFile(scriptsFilePath, '');
+            this.log(`${chalk_1.default.yellow(scriptsFilePath)}`);
+        }
+    }
+}
+exports.default = Sql;
+Sql.description = 'creates a new database script';
+Sql.usage = 'sql <type> <module> [flags]';
+Sql.examples = [
+    `$ ops sql schema `,
+    `$ ops sql data shared --layer basic`
+];
+Sql.args = [
+    {
+        name: 'type',
+        description: 'Type of database scripts',
+        options: ['schema', 'data', 'migration']
+    },
+    {
+        name: 'module',
+        description: 'Module of data database scripts',
+        options: ['acc', 'claims', 'core', 'pas', 'reins', 'shared']
+    }
+];
+Sql.flags = {
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version for which you\'re generating database script'
+    }),
+    layer: command_1.flags.string({
+        char: 'l',
+        description: 'name of the configuration layer for which you are generating database script'
+    })
+};

package/lib/commands/translate.d.ts

@@ -0,0 +1,37 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../command.base';
+export default class Translate extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+    }[];
+    static flags: {
+        format: flags.IOptionFlag<string>;
+        module: flags.IOptionFlag<string | undefined>;
+        output: flags.IOptionFlag<string>;
+        filename: flags.IOptionFlag<string | undefined>;
+        respectServerFilename: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    getFormat(format: string): string;
+    /**
+     * Gets resources, checks a response and returns a response stream.
+     * @param languages list of translations to download
+     * @param format format of translations
+     * @param modules list of modules to download
+     * @returns arhive as an byte array response stream
+     */
+    getTranslations(languages: string, format: string, modules: string | undefined): Promise<any>;
+    /**
+     * Read from response stream and extract files into output directory.
+     * @param content zip file or a stream
+     * @param dest final destination to extract files
+     * @returns void
+     * @throws error message
+     */
+    extractFiles(content: any, destinationDir: string, xmlFilename?: string): Promise<any>;
+    run(): Promise<void>;
+}

package/lib/commands/translate.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const JSZip = require("jszip");
+const path = require("path");
+const request = require("request-promise");
+const command_base_1 = require("../command.base");
+class Translate extends command_base_1.default {
+    getFormat(format) {
+        if (format === 'json') {
+            return 'text/json';
+        }
+        if (format === 'xml') {
+            return 'text/xml';
+        }
+        return this.error(`Format ${format} not supported.`);
+    }
+    /**
+     * Gets resources, checks a response and returns a response stream.
+     * @param languages list of translations to download
+     * @param format format of translations
+     * @param modules list of modules to download
+     * @returns arhive as an byte array response stream
+     */
+    async getTranslations(languages, format, modules) {
+        let requestOptions = {
+            uri: `https://dictionary.adinsure.com/api/Translations?languages=${languages}`,
+            headers: {
+                Authorization: 'Bearer ' + await this.security.getToken(),
+                'Content-Type': this.getFormat(format),
+            },
+            encoding: null
+        };
+        if (modules) {
+            requestOptions.uri += `&modules=${modules}`;
+        }
+        try {
+            let response = await request.get(requestOptions);
+            return response;
+        }
+        catch (error) {
+            const errorJson = JSON.parse(error.error);
+            const errorMessage = `An error has occurred: ${errorJson.ExceptionMessage}`;
+            this.log(chalk_1.default.red(errorMessage));
+            throw errorJson;
+        }
+    }
+    /**
+     * Read from response stream and extract files into output directory.
+     * @param content zip file or a stream
+     * @param dest final destination to extract files
+     * @returns void
+     * @throws error message
+     */
+    async extractFiles(content, destinationDir, xmlFilename = '') {
+        const zip = await JSZip.loadAsync(content);
+        for (const fileName of Object.keys(zip.files)) {
+            const buffer = await zip.files[fileName].async('nodebuffer');
+            //  Rename from translations..Xml to Translations..xml to respect naming in mono
+            if (fileName.includes('Xml')) {
+                let finalFileName = fileName;
+                if (xmlFilename !== '') {
+                    finalFileName = xmlFilename;
+                }
+                const dest = destinationDir + '/' + finalFileName;
+                await fs.writeFile(dest, buffer);
+            }
+            else {
+                const dest = destinationDir + '/' + zip.files[fileName].name;
+                await fs.writeFile(dest, buffer);
+            }
+        }
+    }
+    async run() {
+        const { args, flags } = this.parse(Translate);
+        let destination = flags.output;
+        if (flags.format === 'json' && flags.module === undefined) {
+            this.error('You need to specify `\'module\' when choosing client `\'json\' format.');
+        }
+        try {
+            // Get translations
+            cli_ux_1.default.action.start('Fetching translations from AdDictionary', undefined, { stdout: true });
+            let response = await this.getTranslations(args.language, flags.format, flags.module);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            if (!await fs.pathExists(destination)) {
+                await fs.mkdirp(destination);
+            }
+            // Extract files
+            cli_ux_1.default.action.start('Extracting translation zip files', undefined, { stdout: true });
+            let finalFileName = 'Translations..xml';
+            if (flags.filename) {
+                finalFileName = flags.filename;
+            }
+            // set finalFileName to empty string to indicate filename needs to be taken from server response
+            if (flags.respectServerFilename) {
+                finalFileName = '';
+            }
+            await this.extractFiles(response, destination, finalFileName);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        }
+        catch (error) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('error')}`);
+            this.error(error.message);
+        }
+        this.log(`Translations extracted into ${chalk_1.default.cyan(path.resolve(destination))}`);
+        this.log(`${chalk_1.default.green('Done.')}`);
+    }
+}
+exports.default = Translate;
+Translate.description = 'downloads translate from AdDictionary service';
+Translate.usage = 'translate <language> [flags]';
+Translate.examples = [
+    `$ ops translate "en-US=en-US;ru-Ru=ru-RU" -f json -m "Client business accounting;Client business base;"`,
+    `$ ops translate "en-US=en-US;ru-Ru=ru-RU" -f xml -o translationDestination`
+];
+Translate.args = [
+    {
+        name: 'language',
+        required: true,
+        description: 'language id you want to download. Values must be semi-colon (;) separated.'
+    }
+];
+Translate.flags = {
+    format: command_1.flags.string({
+        char: 'f',
+        description: 'translations format [xml - server translations, json - client translations]',
+        options: ['json', 'xml'],
+        required: true
+    }),
+    module: command_1.flags.string({
+        char: 'm',
+        description: 'module name you want to download. Values must be semi-colon (;) separated.'
+    }),
+    output: command_1.flags.string({
+        char: 'o',
+        default: '.',
+        description: 'absolute or relative destination path to a folder where translations are extracted.'
+    }),
+    filename: command_1.flags.string({
+        description: 'specify filename of output (XML only).'
+    }),
+    respectServerFilename: command_1.flags.boolean({
+        default: false,
+        description: 'respect filename that is returned from AdDictionary server (XML only).'
+    })
+};

package/lib/commands/version.d.ts

@@ -0,0 +1,48 @@
+import { flags } from '@oclif/command';
+import * as semver from 'semver';
+import CommandBase from '../command.base';
+declare type ReleaseType = semver.ReleaseType | 'new';
+export default class Version extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static args: {
+        name: string;
+        required: boolean;
+        description: string;
+        options: string[];
+    }[];
+    static flags: {
+        independent: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        version: flags.IOptionFlag<string | undefined>;
+        'script-prefix': flags.IOptionFlag<string>;
+        'no-deps': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'no-script': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'only-npm-packages': flags.IOptionFlag<string>;
+        'exclude-dir': flags.IOptionFlag<string[]>;
+    };
+    /**
+     * Update NPM packages with wsrun
+     */
+    bumpNpm(type: ReleaseType, version: string, filter: string, excludeDirs: string[]): Promise<string[]>;
+    /**
+     * Validate args and flags
+     */
+    validateOptions(args: any, flags: any): boolean;
+    /**
+     * Update dependencies in package.json files for @adinsure packages
+     */
+    updateDependencies(version: string, updatedPackages: Array<string>): Promise<void>;
+    insertScriptRequest(token: string, version: string, prefix: string): Promise<string>;
+    insertScript(token: string, version: string, prefix: string, skip?: boolean): Promise<void>;
+    /**
+     * Check if version has valid prerelease as 'rc' or '201910' (year month)
+     */
+    checkPrerelease(version: string, month: string): boolean;
+    /**
+     * Write new version in VERSION file
+     */
+    setVersion(version: string): Promise<void>;
+    run(): Promise<undefined>;
+}
+export {};

package/lib/commands/version.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const fs = require("fs-extra");
+const globby = require("globby");
+const moment = require("moment");
+const path = require("path");
+const request = require("request-promise");
+const semver = require("semver");
+const replaceInFile = require('replace-in-file');
+const command_base_1 = require("../command.base");
+class Version extends command_base_1.default {
+    /**
+     * Update NPM packages with wsrun
+     */
+    async bumpNpm(type, version, filter, excludeDirs) {
+        const currentPrereleaseDate = moment().format('YYYYMM');
+        let bumpedPackageName = [];
+        // Find all package.json files that are not in node modules
+        let searchPattern = ['**/package.json', '!**/node_modules'];
+        if (excludeDirs) {
+            for (const exclude of excludeDirs) {
+                searchPattern.push(`!${exclude}`);
+            }
+        }
+        const paths = await globby(searchPattern);
+        for (const path of paths) {
+            try {
+                // Read the data from it
+                let data = await fs.readJSON(path);
+                // Check if version exists
+                if (!data.version || !data.name) {
+                    continue;
+                }
+                let regexp = new RegExp(filter);
+                if (!regexp.test(data.name)) {
+                    continue;
+                }
+                // Increment the package version depending on the increment type
+                if (type === 'new') {
+                    data.version = version;
+                }
+                else if (type === 'prerelease' && this.checkPrerelease(data.version, currentPrereleaseDate)) {
+                    data.version = semver.inc(data.version, type, true);
+                }
+                else {
+                    data.version = semver.inc(data.version, type, false, currentPrereleaseDate);
+                }
+                bumpedPackageName.push(data.name);
+                // Save file
+                await fs.writeJSON(path, data, { spaces: 4, EOL: '\r\n' });
+            }
+            catch (err) {
+                if (err instanceof SyntaxError) {
+                    this.warn(`Error reading package.json: ${chalk_1.default.yellow(err.message)}. Consider using '--exclude-dir'.`);
+                }
+                else {
+                    return this.error(`Unknown error: ${chalk_1.default.red(err)}`);
+                }
+            }
+        }
+        return bumpedPackageName;
+    }
+    /**
+     * Validate args and flags
+     */
+    validateOptions(args, flags) {
+        if (args.type !== 'new' && flags.version) {
+            this.error(`${chalk_1.default.red('Version flag can only be used with new type')}`);
+            return false;
+        }
+        else if (args.type === 'new' && !flags.version) {
+            this.error(`${chalk_1.default.red('Version flag is required with new type')}`);
+            return false;
+        }
+        else if (args.type === 'new' && flags.increment) {
+            this.error(`${chalk_1.default.red('Increment flag not supported with new type')}`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Update dependencies in package.json files for @adinsure packages
+     */
+    async updateDependencies(version, updatedPackages) {
+        // Find all package.json files that are not in node modules
+        const paths = await globby(['**/package.json', '!**/node_modules']);
+        for (const path of paths) {
+            for (const packageName of updatedPackages) {
+                let re = new RegExp('"' + packageName + '": "\\d+\\.\\d+\\..*"', 'g');
+                await replaceInFile({
+                    files: path,
+                    from: re,
+                    to: `"${packageName}": "${version}"`
+                });
+            }
+        }
+    }
+    async insertScriptRequest(token, version, prefix) {
+        let options = {
+            uri: `https://ops.adinsure.com/api/script`,
+            headers: {
+                Authorization: 'Bearer ' + token
+            },
+            body: {
+                version,
+                prefix
+            },
+            json: true
+        };
+        return request.post(options);
+    }
+    async insertScript(token, version, prefix, skip = false) {
+        cli_ux_1.default.action.start('Inserting new script version', undefined, { stdout: true });
+        if (skip) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.blue('skip')}`);
+        }
+        else if (token) {
+            try {
+                await this.insertScriptRequest(token, version, prefix);
+            }
+            catch (err) {
+                switch (err.statusCode) {
+                    case 401: {
+                        this.error(`${chalk_1.default.red('You don\'t have permissions. If this was intentional command, please contact Operations for permissions, do git reset and rerun command.')}`);
+                        break;
+                    }
+                    default: {
+                        this.error(`${chalk_1.default.red(err)}`);
+                    }
+                }
+            }
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        }
+        else {
+            cli_ux_1.default.action.stop(`${chalk_1.default.red('error')}`);
+        }
+    }
+    /**
+     * Check if version has valid prerelease as 'rc' or '201910' (year month)
+     */
+    checkPrerelease(version, month) {
+        const prereleaseVersion = semver.prerelease(version, true);
+        if (!prereleaseVersion)
+            return false;
+        if (prereleaseVersion[0].toString() === month)
+            return true;
+        if (prereleaseVersion[0].toString() === 'rc')
+            return true;
+        return false;
+    }
+    /**
+     * Write new version in VERSION file
+     */
+    async setVersion(version) {
+        const versionPath = path.resolve(await this.getGitRoot(), 'VERSION');
+        if (!await fs.pathExists(versionPath)) {
+            throw new Error('VERSION file not found. File will not be updated.');
+        }
+        return fs.writeFileSync(versionPath, version, 'utf-8');
+    }
+    async run() {
+        const { args, flags } = this.parse(Version);
+        const currentPrereleaseDate = moment().format('YYYYMM');
+        // Check if token is correct and save it for later use
+        let token = '';
+        if (!flags['no-script']) {
+            token = await this.security.getToken();
+        }
+        // exit if validation fails
+        if (!this.validateOptions(args, flags)) {
+            return;
+        }
+        let newVersion = null;
+        if (args.type === 'new' && flags.version) {
+            this.log(`Using 'new' command. VERSION file ignored.`);
+            newVersion = semver.valid(flags.version);
+        }
+        else {
+            // Get current version
+            const fullVersion = await this.getVersion();
+            this.log(`Current version is ${chalk_1.default.green(fullVersion)}`);
+            // Calculate new version
+            newVersion = semver.inc(fullVersion, args.type, true, currentPrereleaseDate);
+            // Force prerelease if prerelease is in same month and increment RC correctly
+            if (args.type === 'prerelease' && this.checkPrerelease(fullVersion, currentPrereleaseDate)) {
+                newVersion = semver.inc(fullVersion, args.type, true);
+            }
+            // Allow npm packages to be versioned seperately. Ultimately we want to force npm package to have same verion as VERSION file.
+            if (!flags.independent) {
+                args.type = 'new';
+            }
+        }
+        // Stop if version invalid
+        if (!newVersion) {
+            return this.error(`${chalk_1.default.red('Version in incorrect format')}`);
+        }
+        this.log(`Setting new version to ${chalk_1.default.green(newVersion)}`);
+        try {
+            await this.setVersion(newVersion);
+        }
+        catch (err) {
+            this.warn(`${chalk_1.default.yellow(err.message)}`);
+        }
+        cli_ux_1.default.action.start('Bumping NPM packages', undefined, { stdout: true });
+        let packages = await this.bumpNpm(args.type, newVersion, flags['only-npm-packages'], flags['exclude-dir']);
+        cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        cli_ux_1.default.action.start('Updating NPM dependencies in package.json files', undefined, { stdout: true });
+        if (flags['no-deps']) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.blue('skip')}`);
+        }
+        else {
+            await this.updateDependencies(newVersion, packages);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+        }
+        await this.insertScript(token, newVersion, flags['script-prefix'], flags['no-script']);
+    }
+}
+exports.default = Version;
+Version.description = 'release new version';
+Version.usage = 'version <type> [flags]';
+Version.examples = [
+    `$ ops version patch`,
+    `$ ops version prerelease -i`,
+    `$ ops version new -v 3.4.3`
+];
+Version.args = [
+    {
+        name: 'type',
+        required: true,
+        description: 'Type of release',
+        options: ['patch', 'minor', 'major', 'prerelease', 'preminor', 'premajor', 'new']
+    },
+];
+Version.flags = {
+    independent: command_1.flags.boolean({
+        char: 'i',
+        description: 'increment npm packages independent of VERSION file',
+        default: false
+    }),
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'force version'
+    }),
+    'script-prefix': command_1.flags.string({
+        description: 'prefix for db script version creation. (default: 7.10)',
+        default: '7.10'
+    }),
+    'no-deps': command_1.flags.boolean({
+        description: 'skip dependency update',
+        default: false
+    }),
+    'no-script': command_1.flags.boolean({
+        description: 'skip creation of script',
+        default: false
+    }),
+    'only-npm-packages': command_1.flags.string({
+        description: 'regular expression for which NPM packages to include',
+        default: '.*'
+    }),
+    'exclude-dir': command_1.flags.string({
+        description: 'exclude directories where to search for package.json',
+        multiple: true
+    })
+};

package/lib/config.d.ts

@@ -0,0 +1,7 @@
+export interface Config {
+    changelogs: {
+        file: string;
+        unreleasedFolder: string;
+    };
+}
+export declare const DefaultConfig: Config;