@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/lib/cliUpgradeUtils.js

@@ -0,0 +1,62 @@
+import updateNotifier from 'update-notifier';
+import { pkg } from './jsonLoader.js';
+import { isGloballyInstalled, executeInstall, getLatestPackageVersion, isInstalledGloballyWithNPM, } from './npm/npmCli.js';
+// HACK: Initialize the cliUpgradeInfo with the initial notifier data before the first call to getCliUpgradeInfo()
+// This is a workaround to enable getCliUpgradeInfo() to work on the first call rather than requiring a second command execution.
+const cliUpgradeInfo = getCliUpgradeInfoFromNotifier();
+/*
+ * Check if the CLI is globally installed
+ */
+export const isCliGloballyInstalled = async () => {
+    return isGloballyInstalled('hs');
+};
+/**
+ * Check if the CLI is globally installed via npm
+ */
+export async function canCliBeAutoUpgraded() {
+    return isInstalledGloballyWithNPM(pkg.name);
+}
+export async function getLatestCliVersion() {
+    return getLatestPackageVersion(pkg.name);
+}
+/**
+ * Get the CLI upgrade information from the notifier
+ */
+function getCliUpgradeInfoFromNotifier() {
+    const notifier = updateNotifier({
+        pkg,
+        distTag: 'latest',
+        shouldNotifyInNpmScript: true,
+    });
+    const result = {};
+    if (notifier && notifier.update) {
+        result.current = notifier.update.current;
+        result.latest = notifier.update.latest;
+        result.type = notifier.update.type;
+    }
+    return result;
+}
+/**
+ * Get update information using update-notifier
+ */
+export function getCliUpgradeInfo() {
+    // Avoid excessive calls to the notifier by returning the cached data if it exists
+    if (cliUpgradeInfo.current && cliUpgradeInfo.latest && cliUpgradeInfo.type) {
+        return cliUpgradeInfo;
+    }
+    const newUpgradeInfo = getCliUpgradeInfoFromNotifier();
+    if (newUpgradeInfo?.current &&
+        newUpgradeInfo?.latest &&
+        newUpgradeInfo?.type) {
+        cliUpgradeInfo.current = newUpgradeInfo.current;
+        cliUpgradeInfo.latest = newUpgradeInfo.latest;
+        cliUpgradeInfo.type = newUpgradeInfo.type;
+    }
+    return cliUpgradeInfo;
+}
+/**
+ * Install a specific version of the CLI globally
+ */
+export async function installCliVersion(version = 'latest') {
+    await executeInstall([`${pkg.name}@${version}`], '-g');
+}

package/lib/cmsAssets/api-sample.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const apiSampleAssetType: CreatableCmsAsset;
+export default apiSampleAssetType;

package/lib/cmsAssets/api-sample.js

@@ -0,0 +1,60 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { createApiSamplePrompt } from '../../lib/prompts/createApiSamplePrompt.js';
+import { confirmPrompt } from '../../lib/prompts/promptUtils.js';
+import { debugError } from '../../lib/errorHandlers/index.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+const apiSampleAssetType = {
+    hidden: true,
+    dest: ({ dest }) => dest,
+    validate: ({ name }) => {
+        if (!name) {
+            uiLogger.error(commands.create.subcommands.apiSample.errors.nameRequired);
+            return false;
+        }
+        return true;
+    },
+    execute: async ({ dest, name, assetType, commandArgs }) => {
+        const filePath = path.join(dest, name);
+        if (fs.existsSync(filePath)) {
+            const overwrite = await confirmPrompt(commands.create.subcommands.apiSample.folderOverwritePrompt(filePath), { defaultAnswer: false });
+            if (overwrite) {
+                fs.rmdirSync(filePath, { recursive: true });
+            }
+            else {
+                return;
+            }
+        }
+        let samplesConfig;
+        try {
+            const { data } = await fetchRepoFile('HubSpot/sample-apps-list', 'samples.json', 'main');
+            samplesConfig = data;
+        }
+        catch (err) {
+            debugError(err);
+        }
+        if (!samplesConfig) {
+            throw new Error(commands.create.subcommands.apiSample.errors.noSamples);
+        }
+        const { sampleType, sampleLanguage } = await createApiSamplePrompt(samplesConfig);
+        if (!sampleType || !sampleLanguage) {
+            throw new Error(commands.create.subcommands.apiSample.errors.noSamples);
+        }
+        uiLogger.info(commands.create.subcommands.apiSample.info.sampleChosen(sampleType, sampleLanguage));
+        const created = await cloneGithubRepo(`HubSpot/${sampleType}`, filePath, {
+            ...commandArgs,
+            type: assetType,
+            sourceDir: sampleLanguage,
+        });
+        if (created) {
+            if (fs.existsSync(`${filePath}/.env.template`)) {
+                fs.copySync(`${filePath}/.env.template`, `${filePath}/.env`);
+            }
+            uiLogger.success(commands.create.subcommands.apiSample.success.sampleCreated(filePath));
+        }
+    },
+};
+export default apiSampleAssetType;

package/lib/cmsAssets/app.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const appAssetType: CreatableCmsAsset;
+export default appAssetType;

package/lib/cmsAssets/app.js

@@ -0,0 +1,12 @@
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+const appAssetType = {
+    hidden: true,
+    dest: ({ name, assetType }) => name || assetType,
+    execute: async ({ commandArgs, dest, assetType }) => {
+        await cloneGithubRepo('HubSpot/crm-card-weather-app', dest, {
+            ...commandArgs,
+            type: assetType,
+        });
+    },
+};
+export default appAssetType;

package/lib/cmsAssets/function.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const functionAssetType: CreatableCmsAsset;
+export default functionAssetType;

package/lib/cmsAssets/function.js

@@ -0,0 +1,11 @@
+import { createFunction } from '@hubspot/local-dev-lib/cms/functions';
+import { createFunctionPrompt } from '../../lib/prompts/createFunctionPrompt.js';
+const functionAssetType = {
+    hidden: false,
+    dest: ({ name }) => name,
+    execute: async ({ dest, commandArgs }) => {
+        const functionDefinition = await createFunctionPrompt(commandArgs);
+        await createFunction(functionDefinition, dest);
+    },
+};
+export default functionAssetType;

package/lib/cmsAssets/index.d.ts

@@ -0,0 +1,5 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const assets: {
+    [key: string]: CreatableCmsAsset;
+};
+export default assets;

package/lib/cmsAssets/index.js

@@ -0,0 +1,21 @@
+import apiSampleAssetType from './api-sample.js';
+import appAssetType from './app.js';
+import functionAssetType from './function.js';
+import moduleAssetType from './module.js';
+import reactAppAssetType from './react-app.js';
+import templateAssetType from './template.js';
+import vueAppAssetType from './vue-app.js';
+import webpackServerlessAssetType from './webpack-serverless.js';
+import websiteThemeAssetType from './website-theme.js';
+const assets = {
+    'api-sample': apiSampleAssetType,
+    app: appAssetType,
+    function: functionAssetType,
+    module: moduleAssetType,
+    'react-app': reactAppAssetType,
+    template: templateAssetType,
+    'vue-app': vueAppAssetType,
+    'webpack-serverless': webpackServerlessAssetType,
+    'website-theme': websiteThemeAssetType,
+};
+export default assets;

package/lib/cmsAssets/module.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const moduleAssetType: CreatableCmsAsset;
+export default moduleAssetType;

package/lib/cmsAssets/module.js

@@ -0,0 +1,20 @@
+import { createModule } from '@hubspot/local-dev-lib/cms/modules';
+import { createModulePrompt } from '../../lib/prompts/createModulePrompt.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+const moduleAssetType = {
+    hidden: false,
+    dest: ({ dest }) => dest,
+    validate: ({ name }) => {
+        if (!name) {
+            uiLogger.error(commands.create.subcommands.module.errors.nameRequired);
+            return false;
+        }
+        return true;
+    },
+    execute: async ({ name, dest, getInternalVersion, commandArgs }) => {
+        const moduleDefinition = await createModulePrompt(commandArgs);
+        await createModule(moduleDefinition, name, dest, getInternalVersion);
+    },
+};
+export default moduleAssetType;

package/lib/cmsAssets/react-app.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const reactAppAssetType: CreatableCmsAsset;
+export default reactAppAssetType;

package/lib/cmsAssets/react-app.js

@@ -0,0 +1,12 @@
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+const reactAppAssetType = {
+    hidden: false,
+    dest: ({ name, assetType }) => name || assetType,
+    execute: async ({ commandArgs, dest, assetType }) => {
+        await cloneGithubRepo('HubSpot/cms-react-boilerplate', dest, {
+            ...commandArgs,
+            type: assetType,
+        });
+    },
+};
+export default reactAppAssetType;

package/lib/cmsAssets/template.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const templateAssetType: CreatableCmsAsset;
+export default templateAssetType;

package/lib/cmsAssets/template.js

@@ -0,0 +1,20 @@
+import { createTemplate } from '@hubspot/local-dev-lib/cms/templates';
+import { createTemplatePrompt } from '../../lib/prompts/createTemplatePrompt.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { commands } from '../../lang/en.js';
+const templateAssetType = {
+    dest: ({ dest }) => dest,
+    hidden: false,
+    validate: ({ name }) => {
+        if (!name) {
+            uiLogger.error(commands.create.subcommands.template.errors.nameRequired);
+            return false;
+        }
+        return true;
+    },
+    execute: async ({ name, dest, commandArgs }) => {
+        const { templateType } = await createTemplatePrompt(commandArgs);
+        await createTemplate(name, dest, templateType);
+    },
+};
+export default templateAssetType;

package/lib/cmsAssets/vue-app.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const vueAppAssetType: CreatableCmsAsset;
+export default vueAppAssetType;

package/lib/cmsAssets/vue-app.js

@@ -0,0 +1,12 @@
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+const vueAppAssetType = {
+    hidden: false,
+    dest: ({ name, assetType }) => name || assetType,
+    execute: async ({ commandArgs, dest, assetType }) => {
+        await cloneGithubRepo('HubSpot/cms-vue-boilerplate', dest, {
+            ...commandArgs,
+            type: assetType,
+        });
+    },
+};
+export default vueAppAssetType;

package/lib/cmsAssets/webpack-serverless.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const webpackServerlessAssetType: CreatableCmsAsset;
+export default webpackServerlessAssetType;

package/lib/cmsAssets/webpack-serverless.js

@@ -0,0 +1,12 @@
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+const webpackServerlessAssetType = {
+    hidden: false,
+    dest: ({ name, assetType }) => name || assetType,
+    execute: async ({ commandArgs, dest, assetType }) => {
+        await cloneGithubRepo('HubSpot/cms-webpack-serverless-boilerplate', dest, {
+            ...commandArgs,
+            type: assetType,
+        });
+    },
+};
+export default webpackServerlessAssetType;

package/lib/cmsAssets/website-theme.d.ts

@@ -0,0 +1,3 @@
+import { CreatableCmsAsset } from '../../types/Cms.js';
+declare const websiteThemeAssetType: CreatableCmsAsset;
+export default websiteThemeAssetType;

package/lib/cmsAssets/website-theme.js

@@ -0,0 +1,19 @@
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { getIsInProject } from '../../lib/projects/config.js';
+const PROJECT_BOILERPLATE_BRANCH = 'cms-boilerplate-developer-projects';
+const websiteThemeAssetType = {
+    hidden: false,
+    dest: ({ name, assetType }) => name || assetType,
+    execute: async ({ dest, assetType, commandArgs }) => {
+        const isInProject = await getIsInProject(dest);
+        if (isInProject) {
+            commandArgs.branch = PROJECT_BOILERPLATE_BRANCH;
+        }
+        await cloneGithubRepo('HubSpot/cms-theme-boilerplate', dest, {
+            ...commandArgs,
+            type: assetType,
+            sourceDir: 'src',
+        });
+    },
+};
+export default websiteThemeAssetType;

package/lib/commandSuggestion.d.ts

@@ -0,0 +1,3 @@
+import { Argv } from 'yargs';
+export declare const commandSuggestionMappings: Record<string, string>;
+export declare function addCommandSuggestions(yargsInstance: Argv): Argv;

package/lib/commandSuggestion.js

@@ -0,0 +1,39 @@
+import { uiLogger } from './ui/logger.js';
+import { uiCommandReference } from './ui/index.js';
+import { EXIT_CODES } from './enums/exitCodes.js';
+export const commandSuggestionMappings = {
+    create: 'hs cms app|theme|module|webpack|function|template create',
+    fetch: 'hs cms fetch',
+    lint: 'hs cms lint',
+    list: 'hs cms list',
+    mv: 'hs cms mv',
+    remove: 'hs cms delete',
+    upload: 'hs cms upload',
+    watch: 'hs cms watch',
+    'function deploy': 'hs cms function deploy',
+    'function list': 'hs cms function list',
+    'function server': 'hs cms function server',
+    logs: 'hs cms function logs',
+    'module marketplace-validate': 'hs cms module marketplace-validate',
+    'theme generate-selectors': 'hs cms theme generate-selectors',
+    'theme marketplace-validate': 'hs cms theme marketplace-validate',
+    'theme preview': 'hs cms theme preview',
+};
+function createCommandSuggestionHandler(newCommand) {
+    return () => {
+        uiLogger.error(`Did you mean ${uiCommandReference(newCommand)}?`);
+        process.exit(EXIT_CODES.ERROR);
+    };
+}
+function createCommandSuggestion(oldCommand, newCommand) {
+    return {
+        command: oldCommand,
+        builder: async (yargs) => {
+            return yargs.strict(false).help(false).version(false);
+        },
+        handler: createCommandSuggestionHandler(newCommand),
+    };
+}
+export function addCommandSuggestions(yargsInstance) {
+    return Object.entries(commandSuggestionMappings).reduce((yargs, [oldCommand, newCommand]) => yargs.command(createCommandSuggestion(oldCommand, newCommand)), yargsInstance);
+}

package/lib/commonOpts.d.ts

@@ -0,0 +1,25 @@
+import { Argv, Arguments } from 'yargs';
+import { CmsPublishMode } from '@hubspot/local-dev-lib/types/Files';
+import { ConfigArgs } from '../types/Yargs.js';
+export declare function addGlobalOptions(yargs: Argv): Argv<{}>;
+export declare function addAccountOptions(yargs: Argv): Argv;
+export declare function addConfigOptions(yargs: Argv): Argv<ConfigArgs>;
+export declare function addOverwriteOptions(yargs: Argv): Argv;
+export declare function addCmsPublishModeOptions(yargs: Argv, { read, write }: {
+    read?: boolean;
+    write?: boolean;
+}): Argv;
+export declare function addTestingOptions(yargs: Argv): Argv;
+export declare function addUseEnvironmentOptions(yargs: Argv): Argv;
+export declare function addJSONOutputOptions(yargs: Argv): Argv;
+export declare function addCustomHelpOutput(yargs: Argv, command: string | string[], describe?: string): Promise<void>;
+export declare function setCLILogLevel(options: Arguments<{
+    debug?: boolean;
+    networkDebug?: boolean;
+    json?: boolean;
+}>): void;
+export declare function getCommandName(argv: Arguments): string;
+export declare function getCmsPublishMode(options: Arguments<{
+    cmsPublishMode?: CmsPublishMode;
+    derivedAccountId?: number;
+}>): CmsPublishMode;

package/lib/commonOpts.js

@@ -0,0 +1,181 @@
+import chalk from 'chalk';
+import yargsParser from 'yargs-parser';
+import { LOG_LEVEL, setLogLevel } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
+import { DEFAULT_CMS_PUBLISH_MODE, CMS_PUBLISH_MODE, } from '@hubspot/local-dev-lib/constants/files';
+import { getConfigAccountById, getConfig } from '@hubspot/local-dev-lib/config';
+import { debugError } from './errorHandlers/index.js';
+import { EXIT_CODES } from './enums/exitCodes.js';
+import { uiCommandReference } from './ui/index.js';
+import { lib } from '../lang/en.js';
+import { getTerminalUISupport, UI_COLORS } from './ui/index.js';
+import SpinniesManager from './ui/SpinniesManager.js';
+export function addGlobalOptions(yargs) {
+    yargs.version(false);
+    yargs.option('debug', {
+        alias: 'd',
+        default: false,
+        describe: lib.commonOpts.options.debug,
+        type: 'boolean',
+    });
+    yargs.option('network-debug', {
+        default: false,
+        type: 'boolean',
+        hidden: true,
+    });
+    return yargs;
+}
+export function addAccountOptions(yargs) {
+    return yargs.option('account', {
+        alias: 'a',
+        describe: lib.commonOpts.options.account,
+        type: 'string',
+    });
+}
+export function addConfigOptions(yargs) {
+    return yargs.option('config', {
+        alias: 'c',
+        describe: lib.commonOpts.options.config,
+        type: 'string',
+    });
+}
+export function addOverwriteOptions(yargs) {
+    return yargs.option('overwrite', {
+        alias: 'o',
+        describe: lib.commonOpts.options.overwrite,
+        type: 'boolean',
+        default: false,
+    });
+}
+export function addCmsPublishModeOptions(yargs, { read, write }) {
+    const cmsPublishModes = `<${Object.values(CMS_PUBLISH_MODE).join(' | ')}>`;
+    return yargs.option('cms-publish-mode', {
+        alias: 'm',
+        describe: lib.commonOpts.options.modes[read ? 'read' : write ? 'write' : 'default'](cmsPublishModes),
+        type: 'string',
+    });
+}
+export function addTestingOptions(yargs) {
+    return yargs.option('qa', {
+        describe: lib.commonOpts.options.qa,
+        type: 'boolean',
+        default: false,
+        hidden: true,
+    });
+}
+export function addUseEnvironmentOptions(yargs) {
+    yargs.option('use-env', {
+        describe: lib.commonOpts.options.useEnv,
+        type: 'boolean',
+    });
+    yargs.conflicts('use-env', 'account');
+    return yargs;
+}
+export function addJSONOutputOptions(yargs) {
+    return yargs.option('json', {
+        alias: 'format-output-as-json',
+        describe: lib.commonOpts.options.jsonOutput,
+        type: 'boolean',
+        hidden: true,
+    });
+}
+// Remove this once we've upgraded to yargs 18.0.0
+function uiBetaTagWithColor(message) {
+    const terminalUISupport = getTerminalUISupport();
+    const tag = lib.ui.betaTagWithStyle;
+    const result = `${terminalUISupport.color ? chalk.hex(UI_COLORS.SORBET)(tag) : tag} ${message}`;
+    return result;
+}
+// Remove this once we've upgraded to yargs 18.0.0
+function uiDeprecatedTagWithColor(message) {
+    const terminalUISupport = getTerminalUISupport();
+    const tag = lib.ui.deprecatedTagWithStyle;
+    const result = `${terminalUISupport.color ? chalk.yellow(tag) : tag} ${message}`;
+    return result;
+}
+export async function addCustomHelpOutput(yargs, command, describe) {
+    try {
+        // Remove this once we've upgraded to yargs 18.0.0
+        if (describe && describe.includes(lib.ui.betaTag)) {
+            describe = describe.replace(lib.ui.betaTag + ' ', '');
+            describe = uiBetaTagWithColor(describe);
+        }
+        // Remove this once we've upgraded to yargs 18.0.0
+        if (describe && describe.includes(lib.ui.deprecatedTag)) {
+            describe = describe.replace(lib.ui.deprecatedTag + ' ', '');
+            describe = uiDeprecatedTagWithColor(describe);
+        }
+        const parsedArgv = yargsParser(process.argv.slice(2));
+        if (parsedArgv && parsedArgv.help) {
+            const commandBase = `hs ${parsedArgv._.slice(0, -1).join(' ')}`;
+            // Make sure we are targeting the correct command by confirming that
+            // "command" matches the last part of the user's input command
+            const checkIsTargetCommand = (command) => {
+                const targetBaseCommand = command.split(' ')[0];
+                return targetBaseCommand === parsedArgv._[parsedArgv._.length - 1];
+            };
+            const isTargetedCommand = Array.isArray(command)
+                ? command.some(checkIsTargetCommand)
+                : checkIsTargetCommand(command);
+            if (!isTargetedCommand) {
+                return;
+            }
+            // Construct the full command, including positional arguments
+            const commandString = Array.isArray(command) ? command[0] : command;
+            const fullCommand = `${commandBase.trim()} ${commandString}`;
+            // Format the original help output to be more readable
+            let commandHelp = await yargs.getHelp();
+            ['Options:', 'Commands:', 'Examples:', 'Positionals:'].forEach(header => {
+                commandHelp = commandHelp.replace(header, chalk.bold(header));
+            });
+            // Remove "hs <command>" from the help output (this shows up for command buckets)
+            commandHelp = commandHelp.replace('hs <command>\n', '');
+            // Remove the first line of the help output if it's empty
+            if (commandHelp.startsWith('\n')) {
+                commandHelp = commandHelp.slice(1);
+            }
+            uiLogger.log(`${uiCommandReference(fullCommand, false)}\n\n${describe ? `${describe}\n\n` : ''}${commandHelp}`);
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+    }
+    catch (e) {
+        // Ignore error to allow yargs to show the default help output using the command description
+        debugError(e);
+    }
+}
+export function setCLILogLevel(options) {
+    const { debug, networkDebug, json } = options;
+    if (json) {
+        setLogLevel(LOG_LEVEL.ERROR);
+        SpinniesManager.setDisableOutput(true);
+    }
+    else if (debug || networkDebug) {
+        setLogLevel(LOG_LEVEL.DEBUG);
+        process.env.HUBSPOT_NETWORK_LOGGING = 'true';
+    }
+    else {
+        setLogLevel(LOG_LEVEL.LOG);
+    }
+}
+export function getCommandName(argv) {
+    return String(argv && argv._ && argv._[0]) || '';
+}
+export function getCmsPublishMode(options) {
+    // 1. --cmsPublishMode
+    const { cmsPublishMode } = options;
+    if (cmsPublishMode && typeof cmsPublishMode === 'string') {
+        return cmsPublishMode.toLowerCase();
+    }
+    // 2. config[account].defaultCmsPublishMode
+    if (options.derivedAccountId) {
+        const accountConfig = getConfigAccountById(options.derivedAccountId);
+        if (accountConfig && accountConfig.defaultCmsPublishMode) {
+            return accountConfig.defaultCmsPublishMode;
+        }
+    }
+    // 3. config.defaultCmsPublishMode
+    // 4. DEFAULT_CMS_PUBLISH_MODE
+    const config = getConfig();
+    return ((config && config.defaultCmsPublishMode) ||
+        DEFAULT_CMS_PUBLISH_MODE);
+}

package/lib/configMigrate.d.ts

@@ -0,0 +1,2 @@
+export declare function handleMigration(hideWarning?: boolean): Promise<boolean>;
+export declare function handleMerge(force?: boolean, hideWarning?: boolean): Promise<boolean>;