@hubspot/cli 7.2.1-experimental.0 → 7.2.2-experimental.0

package/commands/project/dev.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } = require('../../lib/commonOpts');
+const { trackCommandUsage } = require('../../lib/usageTracking');
+const { handleExit } = require('../../lib/process');
+const { i18n } = require('../../lib/lang');
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const { getConfigAccounts, getAccountConfig, getEnv, } = require('@hubspot/local-dev-lib/config');
+const { getProjectConfig, ensureProjectExists, validateProjectConfig, } = require('../../lib/projects');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+const { uiBetaTag, uiCommandReference, uiLink } = require('../../lib/ui');
+const SpinniesManager = require('../../lib/ui/SpinniesManager');
+const LocalDevManager = require('../../lib/LocalDevManager');
+const { isSandbox, isDeveloperTestAccount, isStandardAccount, isAppDeveloperAccount, } = require('../../lib/accountTypes');
+const { getValidEnv } = require('@hubspot/local-dev-lib/environment');
+const { ComponentTypes } = require('../../types/Projects');
+const { findProjectComponents, getProjectComponentTypes, } = require('../../lib/projects/structure');
+const { confirmDefaultAccountIsTarget, suggestRecommendedNestedAccount, checkIfDefaultAccountIsSupported, createSandboxForLocalDev, createDeveloperTestAccountForLocalDev, createNewProjectForLocalDev, createInitialBuildForNewProject, useExistingDevTestAccount, checkIfAccountFlagIsSupported, checkIfParentAccountIsAuthed, } = require('../../lib/localDev');
+const i18nKey = 'commands.project.subcommands.dev';
+exports.command = 'dev';
+exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
+exports.handler = async (options) => {
+    const { derivedAccountId, providedAccountId } = options;
+    const accountConfig = getAccountConfig(derivedAccountId);
+    const env = getValidEnv(getEnv(derivedAccountId));
+    trackCommandUsage('project-dev', null, derivedAccountId);
+    const { projectConfig, projectDir } = await getProjectConfig();
+    uiBetaTag(i18n(`${i18nKey}.logs.betaMessage`));
+    logger.log(uiLink(i18n(`${i18nKey}.logs.learnMoreLocalDevServer`), 'https://developers.hubspot.com/docs/platform/project-cli-commands#start-a-local-development-server'));
+    if (!projectConfig) {
+        logger.error(i18n(`${i18nKey}.errors.noProjectConfig`));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    validateProjectConfig(projectConfig, projectDir);
+    const components = await findProjectComponents(projectDir);
+    const runnableComponents = components.filter(component => component.runnable);
+    const componentTypes = getProjectComponentTypes(runnableComponents);
+    const hasPrivateApps = !!componentTypes[ComponentTypes.PrivateApp];
+    const hasPublicApps = !!componentTypes[ComponentTypes.PublicApp];
+    if (runnableComponents.length === 0) {
+        logger.error(i18n(`${i18nKey}.errors.noRunnableComponents`, {
+            projectDir,
+            command: uiCommandReference('hs project add'),
+        }));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    else if (hasPrivateApps && hasPublicApps) {
+        logger.error(i18n(`${i18nKey}.errors.invalidProjectComponents`));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const accounts = getConfigAccounts();
+    const defaultAccountIsRecommendedType = isDeveloperTestAccount(accountConfig) ||
+        (!hasPublicApps && isSandbox(accountConfig));
+    // targetProjectAccountId and targetTestingAccountId are set to null if --account flag is not provided.
+    // By setting them to null, we can later check if they need to be assigned based on the default account configuration and the type of app.
+    let targetProjectAccountId = providedAccountId ? derivedAccountId : null;
+    // The account that we are locally testing against
+    let targetTestingAccountId = providedAccountId ? derivedAccountId : null;
+    // Check that the default account or flag option is valid for the type of app in this project
+    if (providedAccountId) {
+        checkIfAccountFlagIsSupported(accountConfig, hasPublicApps);
+        if (hasPublicApps) {
+            targetProjectAccountId = accountConfig.parentAccountId;
+        }
+    }
+    else {
+        checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps);
+    }
+    // The user is targeting an account type that we recommend developing on
+    if (!targetProjectAccountId && defaultAccountIsRecommendedType) {
+        targetTestingAccountId = derivedAccountId;
+        await confirmDefaultAccountIsTarget(accountConfig, hasPublicApps);
+        if (hasPublicApps) {
+            checkIfParentAccountIsAuthed(accountConfig);
+            targetProjectAccountId = accountConfig.parentAccountId;
+        }
+        else {
+            targetProjectAccountId = derivedAccountId;
+        }
+    }
+    let createNewSandbox = false;
+    let createNewDeveloperTestAccount = false;
+    if (!targetProjectAccountId) {
+        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps);
+        targetProjectAccountId = hasPublicApps ? parentAccountId : targetAccountId;
+        targetTestingAccountId = targetAccountId;
+        // Only used for developer test accounts that are not yet in the config
+        if (notInConfigAccount) {
+            await useExistingDevTestAccount(env, notInConfigAccount);
+        }
+        createNewSandbox = isStandardAccount(accountConfig) && createNestedAccount;
+        createNewDeveloperTestAccount =
+            isAppDeveloperAccount(accountConfig) && createNestedAccount;
+    }
+    if (createNewSandbox) {
+        targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
+        // We will be running our tests against this new sandbox account
+        targetTestingAccountId = targetProjectAccountId;
+    }
+    if (createNewDeveloperTestAccount) {
+        targetTestingAccountId = await createDeveloperTestAccountForLocalDev(derivedAccountId, accountConfig, env);
+        targetProjectAccountId = derivedAccountId;
+    }
+    // eslint-disable-next-line prefer-const
+    let { projectExists, project } = await ensureProjectExists(targetProjectAccountId, projectConfig.name, {
+        allowCreate: false,
+        noLogs: true,
+        withPolling: createNewSandbox,
+    });
+    let deployedBuild;
+    let isGithubLinked;
+    SpinniesManager.init();
+    if (projectExists) {
+        deployedBuild = project.deployedBuild;
+        isGithubLinked =
+            project.sourceIntegration &&
+                project.sourceIntegration.source === 'GITHUB';
+    }
+    else {
+        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps);
+        deployedBuild = await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId);
+    }
+    const LocalDev = new LocalDevManager({
+        runnableComponents,
+        debug: options.debug,
+        deployedBuild,
+        isGithubLinked,
+        parentAccountId: targetProjectAccountId,
+        projectConfig,
+        projectDir,
+        projectId: project.id,
+        targetAccountId: targetTestingAccountId,
+        env,
+    });
+    await LocalDev.start();
+    handleExit(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
+};
+exports.builder = yargs => {
+    addConfigOptions(yargs);
+    addAccountOptions(yargs);
+    addUseEnvironmentOptions(yargs);
+    addTestingOptions(yargs);
+    yargs.example([['$0 project dev', i18n(`${i18nKey}.examples.default`)]]);
+    return yargs;
+};

package/commands/project/migrateApp.js

@@ -71,9 +71,9 @@ exports.handler = async (options) => {
     let projectName;
     let projectDest;
     try {
-        const createProjectPromptResponse = await createProjectPrompt(options);
-        projectName = createProjectPromptResponse.name;
-        projectDest = createProjectPromptResponse.dest;
+        const { name, dest } = await createProjectPrompt('', options, true);
+        projectName = options.name || name;
+        projectDest = options.dest || dest;
         const { projectExists } = await ensureProjectExists(derivedAccountId, projectName, {
             allowCreate: false,
             noLogs: true,

package/commands/project/upload.js

@@ -20,7 +20,7 @@ const i18nKey = 'commands.project.subcommands.upload';
 exports.command = 'upload';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
-    const { forceCreate, message, derivedAccountId, skipValidation } = options;
+    const { forceCreate, message, derivedAccountId } = options;
     const accountConfig = getAccountConfig(derivedAccountId);
     const accountType = accountConfig && accountConfig.accountType;
     const { projectConfig, projectDir } = await getProjectConfig();
@@ -31,7 +31,7 @@ exports.handler = async (options) => {
         uploadCommand: true,
     });
     try {
-        const { result, uploadError } = await handleProjectUpload(derivedAccountId, projectConfig, projectDir, pollProjectBuildAndDeploy, message, useV3Api(projectConfig?.platformVersion), skipValidation);
+        const { result, uploadError } = await handleProjectUpload(derivedAccountId, projectConfig, projectDir, pollProjectBuildAndDeploy, message, useV3Api(projectConfig?.platformVersion));
         if (uploadError) {
             if (isSpecifiedError(uploadError, {
                 subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
@@ -81,11 +81,6 @@ exports.builder = yargs => {
             type: 'string',
             default: '',
         },
-        'skip-validation': {
-            type: 'boolean',
-            hidden: true,
-            default: false,
-        },
     });
     yargs.example([['$0 project upload', i18n(`${i18nKey}.examples.default`)]]);
     addConfigOptions(yargs);

package/commands/sandbox/create.d.ts

@@ -1,13 +1 @@
-import { Argv, ArgumentsCamelCase } from 'yargs';
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, TestingArgs } from '../../types/Yargs';
-export declare const command = "create";
-export declare const describe: string | undefined;
-type CombinedArgs = ConfigArgs & AccountArgs & EnvironmentArgs & TestingArgs;
-type SandboxCreateArgs = CommonArgs & CombinedArgs & {
-    name?: string;
-    force?: boolean;
-    type?: string;
-};
-export declare function handler(args: ArgumentsCamelCase<SandboxCreateArgs>): Promise<void>;
-export declare function builder(yargs: Argv): Argv<SandboxCreateArgs>;
 export {};

package/commands/sandbox/create.js

@@ -1,175 +1,157 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.describe = exports.command = void 0;
-exports.handler = handler;
-exports.builder = builder;
-const config_1 = require("@hubspot/local-dev-lib/config");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const index_1 = require("@hubspot/local-dev-lib/errors/index");
-const urls_1 = require("@hubspot/local-dev-lib/urls");
-const config_2 = require("@hubspot/local-dev-lib/constants/config");
-const environment_1 = require("@hubspot/local-dev-lib/environment");
-const commonOpts_1 = require("../../lib/commonOpts");
-const lang_1 = require("../../lib/lang");
-const exitCodes_1 = require("../../lib/enums/exitCodes");
-const ui_1 = require("../../lib/ui");
-const sandboxes_1 = require("../../lib/sandboxes");
-const usageTracking_1 = require("../../lib/usageTracking");
-const sandboxesPrompt_1 = require("../../lib/prompts/sandboxesPrompt");
-const promptUtils_1 = require("../../lib/prompts/promptUtils");
-const sandboxSync_1 = require("../../lib/sandboxSync");
-const index_2 = require("../../lib/errorHandlers/index");
-const buildAccount_1 = require("../../lib/buildAccount");
-const accountNamePrompt_1 = require("../../lib/prompts/accountNamePrompt");
+// @ts-nocheck
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } = require('../../lib/commonOpts');
+const { i18n } = require('../../lib/lang');
+const { EXIT_CODES } = require('../../lib/enums/exitCodes');
+const { getAccountConfig, getEnv } = require('@hubspot/local-dev-lib/config');
+const { uiFeatureHighlight, uiBetaTag } = require('../../lib/ui');
+const { SANDBOX_TYPE_MAP, getAvailableSyncTypes, SYNC_TYPES, validateSandboxUsageLimits, } = require('../../lib/sandboxes');
+const { getValidEnv } = require('@hubspot/local-dev-lib/environment');
+const { logger } = require('@hubspot/local-dev-lib/logger');
+const { trackCommandUsage } = require('../../lib/usageTracking');
+const { sandboxTypePrompt } = require('../../lib/prompts/sandboxesPrompt');
+const { promptUser } = require('../../lib/prompts/promptUtils');
+const { syncSandbox } = require('../../lib/sandboxSync');
+const { logError } = require('../../lib/errorHandlers/index');
+const { isMissingScopeError } = require('@hubspot/local-dev-lib/errors/index');
+const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
+const { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } = require('@hubspot/local-dev-lib/constants/config');
+const { buildSandbox } = require('../../lib/buildAccount');
+const { hubspotAccountNamePrompt, } = require('../../lib/prompts/accountNamePrompt');
 const i18nKey = 'commands.sandbox.subcommands.create';
 exports.command = 'create';
-exports.describe = (0, ui_1.uiBetaTag)((0, lang_1.i18n)(`${i18nKey}.describe`), false);
-async function handler(args) {
-    const { name, type, force, derivedAccountId } = args;
-    const accountConfig = (0, config_1.getAccountConfig)(derivedAccountId);
-    const env = (0, environment_1.getValidEnv)((0, config_1.getEnv)(derivedAccountId));
-    (0, usageTracking_1.trackCommandUsage)('sandbox-create', {}, derivedAccountId);
-    // Check if account config exists
-    if (!accountConfig) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.failure.noAccountConfig`, {
-            accountId: derivedAccountId,
-            authCommand: (0, ui_1.uiCommandReference)('hs auth'),
-        }));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
-    }
+exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
+exports.handler = async (options) => {
+    const { name, type, force, derivedAccountId } = options;
+    const accountConfig = getAccountConfig(derivedAccountId);
+    const env = getValidEnv(getEnv(derivedAccountId));
+    trackCommandUsage('sandbox-create', null, derivedAccountId);
     // Default account is not a production portal
     if (accountConfig.accountType &&
-        accountConfig.accountType !== config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD) {
-        logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.failure.invalidAccountType`, {
-            accountType: config_2.HUBSPOT_ACCOUNT_TYPE_STRINGS[config_2.HUBSPOT_ACCOUNT_TYPES[accountConfig.accountType]],
-            accountName: accountConfig.name || '',
+        accountConfig.accountType !== HUBSPOT_ACCOUNT_TYPES.STANDARD) {
+        logger.error(i18n(`${i18nKey}.failure.invalidAccountType`, {
+            accountType: HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES[accountConfig.accountType]],
+            accountName: accountConfig.name,
         }));
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        process.exit(EXIT_CODES.ERROR);
     }
     let typePrompt;
     let namePrompt;
-    if ((type && !(type.toLowerCase() in sandboxes_1.SANDBOX_TYPE_MAP)) || !type) {
+    if ((type && !SANDBOX_TYPE_MAP[type.toLowerCase()]) || !type) {
         if (!force) {
-            typePrompt = await (0, sandboxesPrompt_1.sandboxTypePrompt)();
+            typePrompt = await sandboxTypePrompt();
         }
         else {
-            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.failure.optionMissing.type`));
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            logger.error(i18n(`${i18nKey}.failure.optionMissing.type`));
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     const sandboxType = type
-        ? sandboxes_1.SANDBOX_TYPE_MAP[type.toLowerCase()]
+        ? SANDBOX_TYPE_MAP[type.toLowerCase()]
         : typePrompt.type;
     // Check usage limits and exit if parent portal has no available sandboxes for the selected type
     try {
-        await (0, sandboxes_1.validateSandboxUsageLimits)(accountConfig, sandboxType, env);
+        await validateSandboxUsageLimits(accountConfig, sandboxType, env);
     }
     catch (err) {
-        if ((0, index_1.isMissingScopeError)(err)) {
-            logger_1.logger.error((0, lang_1.i18n)('lib.sandbox.create.failure.scopes.message', {
+        if (isMissingScopeError(err)) {
+            logger.error(i18n('lib.sandbox.create.failure.scopes.message', {
                 accountName: accountConfig.name || derivedAccountId,
             }));
-            const websiteOrigin = (0, urls_1.getHubSpotWebsiteOrigin)(env);
+            const websiteOrigin = getHubSpotWebsiteOrigin(env);
             const url = `${websiteOrigin}/personal-access-key/${derivedAccountId}`;
-            logger_1.logger.info((0, lang_1.i18n)('lib.sandbox.create.failure.scopes.instructions', {
+            logger.info(i18n('lib.sandbox.create.failure.scopes.instructions', {
                 accountName: accountConfig.name || derivedAccountId,
                 url,
             }));
         }
         else {
-            (0, index_2.logError)(err);
+            logError(err);
         }
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        process.exit(EXIT_CODES.ERROR);
     }
     if (!name) {
         if (!force) {
-            namePrompt = await (0, accountNamePrompt_1.hubspotAccountNamePrompt)({ accountType: sandboxType });
+            namePrompt = await hubspotAccountNamePrompt({ accountType: sandboxType });
         }
         else {
-            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.failure.optionMissing.name`));
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            logger.error(i18n(`${i18nKey}.failure.optionMissing.name`));
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     const sandboxName = name || namePrompt.name;
     let contactRecordsSyncPromptResult = false;
     if (!force) {
-        const isStandardSandbox = sandboxType === config_2.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX;
+        const isStandardSandbox = sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX;
         // Prompt to sync contact records for standard sandboxes only
         if (isStandardSandbox) {
-            const { contactRecordsSyncPrompt } = await (0, promptUtils_1.promptUser)([
+            const { contactRecordsSyncPrompt } = await promptUser([
                 {
                     name: 'contactRecordsSyncPrompt',
                     type: 'confirm',
-                    message: (0, lang_1.i18n)('lib.sandbox.sync.confirm.syncContactRecords.standard'),
+                    message: i18n('lib.sandbox.sync.confirm.syncContactRecords.standard'),
                 },
             ]);
             contactRecordsSyncPromptResult = contactRecordsSyncPrompt;
         }
     }
     try {
-        const result = await (0, buildAccount_1.buildSandbox)(sandboxName, accountConfig, sandboxType, env, force);
-        const sandboxAccountConfig = (0, config_1.getAccountConfig)(result.sandbox.sandboxHubId);
-        // Check if sandbox account config exists
-        if (!sandboxAccountConfig) {
-            logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.failure.noSandboxAccountConfig`, {
-                accountId: result.sandbox.sandboxHubId,
-                authCommand: (0, ui_1.uiCommandReference)('hs auth'),
-            }));
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
-        }
+        const result = await buildSandbox(sandboxName, accountConfig, sandboxType, env, force);
+        const sandboxAccountConfig = getAccountConfig(result.sandbox.sandboxHubId);
         // For v1 sandboxes, keep sync here. Once we migrate to v2, this will be handled by BE automatically
-        async function handleSyncSandbox(syncTasks) {
-            await (0, sandboxSync_1.syncSandbox)(sandboxAccountConfig, accountConfig, env, syncTasks);
-        }
+        const handleSyncSandbox = async (syncTasks) => {
+            await syncSandbox(sandboxAccountConfig, accountConfig, env, syncTasks);
+        };
         try {
-            let availableSyncTasks = await (0, sandboxes_1.getAvailableSyncTypes)(accountConfig, sandboxAccountConfig);
+            let availableSyncTasks = await getAvailableSyncTypes(accountConfig, sandboxAccountConfig);
             if (!contactRecordsSyncPromptResult) {
-                availableSyncTasks = availableSyncTasks.filter(t => t.type !== sandboxes_1.SYNC_TYPES.OBJECT_RECORDS);
+                availableSyncTasks = availableSyncTasks.filter(t => t.type !== SYNC_TYPES.OBJECT_RECORDS);
             }
             await handleSyncSandbox(availableSyncTasks);
         }
         catch (err) {
-            (0, index_2.logError)(err);
+            logError(err);
             throw err;
         }
         const highlightItems = ['accountsUseCommand', 'projectCreateCommand'];
-        if (sandboxType === config_2.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+        if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
             highlightItems.push('projectDevCommand');
         }
         else {
             highlightItems.push('projectUploadCommand');
         }
-        (0, ui_1.uiFeatureHighlight)(highlightItems);
-        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        uiFeatureHighlight(highlightItems);
+        process.exit(EXIT_CODES.SUCCESS);
     }
     catch (error) {
         // Errors are logged in util functions
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        process.exit(EXIT_CODES.ERROR);
     }
-}
-function builder(yargs) {
+};
+exports.builder = yargs => {
     yargs.option('force', {
         type: 'boolean',
         alias: 'f',
-        describe: (0, lang_1.i18n)(`${i18nKey}.options.force.describe`),
+        describe: i18n(`${i18nKey}.options.force.describe`),
     });
     yargs.option('name', {
-        describe: (0, lang_1.i18n)(`${i18nKey}.options.name.describe`),
+        describe: i18n(`${i18nKey}.options.name.describe`),
         type: 'string',
     });
     yargs.option('type', {
-        describe: (0, lang_1.i18n)(`${i18nKey}.options.type.describe`),
-        choices: Object.keys(sandboxes_1.SANDBOX_TYPE_MAP),
+        describe: i18n(`${i18nKey}.options.type.describe`),
+        type: 'string',
     });
     yargs.example([
         [
             '$0 sandbox create --name=MySandboxAccount --type=STANDARD',
-            (0, lang_1.i18n)(`${i18nKey}.examples.default`),
+            i18n(`${i18nKey}.examples.default`),
         ],
     ]);
-    (0, commonOpts_1.addConfigOptions)(yargs);
-    (0, commonOpts_1.addAccountOptions)(yargs);
-    (0, commonOpts_1.addUseEnvironmentOptions)(yargs);
-    (0, commonOpts_1.addTestingOptions)(yargs);
+    addConfigOptions(yargs);
+    addAccountOptions(yargs);
+    addUseEnvironmentOptions(yargs);
+    addTestingOptions(yargs);
     return yargs;
-}
+};

package/commands/sandbox/delete.d.ts

@@ -1,12 +1 @@
-import { Argv, ArgumentsCamelCase } from 'yargs';
-import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, TestingArgs } from '../../types/Yargs';
-export declare const command = "delete";
-export declare const describe: string | undefined;
-type CombinedArgs = ConfigArgs & AccountArgs & EnvironmentArgs & TestingArgs;
-type SandboxDeleteArgs = CommonArgs & CombinedArgs & {
-    account?: string;
-    force?: boolean;
-};
-export declare function handler(args: ArgumentsCamelCase<SandboxDeleteArgs>): Promise<void>;
-export declare function builder(yargs: Argv): Argv<SandboxDeleteArgs>;
 export {};