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

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -1,162 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { lib } from '../../lang/en.js';
-import { promptUser } from './promptUtils.js';
-const hubs = {
-    MARKETING: 'marketingLevel',
-    OPS: 'opsLevel',
-    SERVICE: 'serviceLevel',
-    SALES: 'salesLevel',
-    CONTENT: 'contentLevel',
-    COMMERCE: 'commerceLevel',
-};
-const AccountTiers = {
-    FREE: 'FREE',
-    STARTER: 'STARTER',
-    PROFESSIONAL: 'PROFESSIONAL',
-    ENTERPRISE: 'ENTERPRISE',
-};
-const makeHubTiers = (hubKey, omitTiers) => {
-    const hubTypeKey = hubKey.toLowerCase();
-    const hubName = lib.prompts.createDeveloperTestAccountConfigPrompt.hubTypes[hubTypeKey];
-    return [
-        {
-            name: `${hubName} [${AccountTiers.FREE}]`,
-            value: { hub: hubKey, tier: AccountTiers.FREE },
-        },
-        {
-            name: `${hubName} [${AccountTiers.STARTER}]`,
-            value: { hub: hubKey, tier: AccountTiers.STARTER },
-        },
-        {
-            name: `${hubName} [${AccountTiers.PROFESSIONAL}]`,
-            value: { hub: hubKey, tier: AccountTiers.PROFESSIONAL },
-        },
-        {
-            name: `${hubName} [${AccountTiers.ENTERPRISE}]`,
-            value: { hub: hubKey, tier: AccountTiers.ENTERPRISE },
-        },
-    ].filter(tier => !omitTiers || !omitTiers.includes(tier.value.tier));
-};
-const TEST_ACCOUNT_TIERS = [
-    ...makeHubTiers('MARKETING'),
-    new Separator(),
-    ...makeHubTiers('OPS'),
-    new Separator(),
-    ...makeHubTiers('SERVICE'),
-    new Separator(),
-    ...makeHubTiers('SALES'),
-    new Separator(),
-    ...makeHubTiers('CONTENT'),
-    new Separator(),
-    ...makeHubTiers('COMMERCE', [AccountTiers.STARTER]),
-    new Separator(),
-];
-export async function createDeveloperTestAccountConfigPrompt(args = {}, supportFlags = true) {
-    const hasAnyTierLevels = !!(args.marketingLevel ||
-        args.opsLevel ||
-        args.serviceLevel ||
-        args.salesLevel ||
-        args.contentLevel ||
-        args.commerceLevel);
-    const result = await promptUser([
-        {
-            name: 'accountName',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt(supportFlags),
-            type: 'input',
-            when: !args.name,
-            validate: value => {
-                if (!value) {
-                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                        .nameRequired;
-                }
-                return true;
-            },
-        },
-        {
-            name: 'description',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt(supportFlags),
-            type: 'input',
-            when: !args.description,
-        },
-    ]);
-    const accountName = args.name || result.accountName;
-    const description = args.description || result.description;
-    let accountLevels = {};
-    if (hasAnyTierLevels) {
-        accountLevels = {
-            marketingLevel: args.marketingLevel || AccountTiers.ENTERPRISE,
-            opsLevel: args.opsLevel || AccountTiers.ENTERPRISE,
-            serviceLevel: args.serviceLevel || AccountTiers.ENTERPRISE,
-            salesLevel: args.salesLevel || AccountTiers.ENTERPRISE,
-            contentLevel: args.contentLevel || AccountTiers.ENTERPRISE,
-            commerceLevel: args.commerceLevel || AccountTiers.ENTERPRISE,
-        };
-    }
-    else {
-        const tierChoiceResult = await promptUser({
-            name: 'useDefaultAccountLevels',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt
-                .useDefaultAccountLevelsPrompt.message,
-            type: 'list',
-            choices: [
-                {
-                    name: lib.prompts.createDeveloperTestAccountConfigPrompt
-                        .useDefaultAccountLevelsPrompt.default,
-                    value: 'default',
-                },
-                {
-                    name: lib.prompts.createDeveloperTestAccountConfigPrompt
-                        .useDefaultAccountLevelsPrompt.manual,
-                    value: 'manual',
-                },
-            ],
-        });
-        if (tierChoiceResult.useDefaultAccountLevels === 'default') {
-            accountLevels = {
-                marketingLevel: AccountTiers.ENTERPRISE,
-                opsLevel: AccountTiers.ENTERPRISE,
-                serviceLevel: AccountTiers.ENTERPRISE,
-                salesLevel: AccountTiers.ENTERPRISE,
-                contentLevel: AccountTiers.ENTERPRISE,
-                commerceLevel: AccountTiers.ENTERPRISE,
-            };
-        }
-        else {
-            const tierResult = await promptUser({
-                name: 'testAccountLevels',
-                message: lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
-                type: 'checkbox',
-                pageSize: 13,
-                choices: TEST_ACCOUNT_TIERS,
-                loop: false,
-                validate: choices => {
-                    if (choices?.length < Object.keys(hubs).length) {
-                        return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                            .allHubsRequired;
-                    }
-                    const hubMap = {};
-                    for (const choice of choices) {
-                        const { hub } = choice.value;
-                        if (hubMap[hub]) {
-                            return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
-                                .tiersError;
-                        }
-                        hubMap[hub] = true;
-                    }
-                    return true;
-                },
-            });
-            accountLevels = tierResult.testAccountLevels.reduce((acc, level) => {
-                const { hub: hubName, tier: hubTier } = level;
-                const hubLevel = hubs[hubName];
-                acc[hubLevel] = hubTier;
-                return acc;
-            }, {});
-        }
-    }
-    return {
-        accountName,
-        description,
-        ...accountLevels,
-    };
-}

package/lib/prompts/createFunctionPrompt.d.ts

@@ -1,9 +0,0 @@
-import { CreateArgs } from '../../types/Cms.js';
-type CreateFunctionPromptResponse = {
-    functionsFolder: string;
-    filename: string;
-    endpointMethod: string;
-    endpointPath: string;
-};
-export declare function createFunctionPrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateFunctionPromptResponse>;
-export {};

package/lib/prompts/createFunctionPrompt.js

@@ -1,94 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-const FUNCTIONS_FOLDER_PROMPT = {
-    name: 'functionsFolder',
-    message: lib.prompts.createFunctionPrompt.enterFolder,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createFunctionPrompt.errors.invalid;
-        }
-        else if (!val.length) {
-            return lib.prompts.createFunctionPrompt.errors.blank;
-        }
-        else if (val.indexOf(' ') >= 0) {
-            return lib.prompts.createFunctionPrompt.errors.space;
-        }
-        return true;
-    },
-};
-const FUNCTION_FILENAME_PROMPT = {
-    name: 'filename',
-    message: lib.prompts.createFunctionPrompt.enterFilename,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createFunctionPrompt.errors.invalid;
-        }
-        else if (!val.length) {
-            return lib.prompts.createFunctionPrompt.errors.blank;
-        }
-        else if (val.indexOf(' ') >= 0) {
-            return lib.prompts.createFunctionPrompt.errors.space;
-        }
-        return true;
-    },
-};
-const ENDPOINT_METHOD_PROMPT = {
-    type: 'list',
-    name: 'endpointMethod',
-    message: lib.prompts.createFunctionPrompt.selectEndpointMethod,
-    default: 'GET',
-    choices: ['DELETE', 'GET', 'PATCH', 'POST', 'PUT'],
-};
-const ENDPOINT_PATH_PROMPT = {
-    name: 'endpointPath',
-    message: lib.prompts.createFunctionPrompt.enterEndpointPath,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createFunctionPrompt.errors.invalid;
-        }
-        else if (!val.length) {
-            return lib.prompts.createFunctionPrompt.errors.blank;
-        }
-        else if (val.indexOf(' ') >= 0) {
-            return lib.prompts.createFunctionPrompt.errors.space;
-        }
-        return true;
-    },
-};
-export function createFunctionPrompt(commandArgs = {}) {
-    // Check if all required parameters are provided (endpointMethod has default)
-    const hasAllRequired = commandArgs.functionsFolder &&
-        commandArgs.filename &&
-        commandArgs.endpointPath;
-    if (hasAllRequired) {
-        return Promise.resolve({
-            functionsFolder: commandArgs.functionsFolder,
-            filename: commandArgs.filename,
-            endpointMethod: commandArgs.endpointMethod || 'GET',
-            endpointPath: commandArgs.endpointPath,
-        });
-    }
-    const prompts = [];
-    // Only prompt for missing parameters
-    if (!commandArgs.functionsFolder) {
-        prompts.push(FUNCTIONS_FOLDER_PROMPT);
-    }
-    if (!commandArgs.filename) {
-        prompts.push(FUNCTION_FILENAME_PROMPT);
-    }
-    if (!commandArgs.endpointMethod) {
-        prompts.push(ENDPOINT_METHOD_PROMPT);
-    }
-    if (!commandArgs.endpointPath) {
-        prompts.push(ENDPOINT_PATH_PROMPT);
-    }
-    return promptUser(prompts).then(promptResponse => {
-        // Merge prompted values with provided commandArgs
-        return {
-            functionsFolder: commandArgs.functionsFolder || promptResponse.functionsFolder,
-            filename: commandArgs.filename || promptResponse.filename,
-            endpointMethod: commandArgs.endpointMethod || promptResponse.endpointMethod || 'GET',
-            endpointPath: commandArgs.endpointPath || promptResponse.endpointPath,
-        };
-    });
-}

package/lib/prompts/createModulePrompt.d.ts

@@ -1,10 +0,0 @@
-import { CreateArgs } from '../../types/Cms.js';
-type CreateModulePromptResponse = {
-    moduleLabel: string;
-    reactType: boolean;
-    contentTypes: string[];
-    global: boolean;
-    availableForNewContent: boolean;
-};
-export declare function createModulePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateModulePromptResponse>;
-export {};

package/lib/prompts/createModulePrompt.js

@@ -1,116 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-const MODULE_LABEL_PROMPT = {
-    name: 'moduleLabel',
-    message: lib.prompts.createModulePrompt.enterLabel,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.createModulePrompt.errors.invalidLabel;
-        }
-        else if (!val.length) {
-            return lib.prompts.createModulePrompt.errors.labelRequired;
-        }
-        return true;
-    },
-};
-const REACT_TYPE_PROMPT = {
-    type: 'confirm',
-    name: 'reactType',
-    message: lib.prompts.createModulePrompt.selectReactType,
-    default: false,
-};
-const CONTENT_TYPES_PROMPT = {
-    type: 'checkbox',
-    name: 'contentTypes',
-    message: lib.prompts.createModulePrompt.selectContentType,
-    choices: [
-        { name: 'Any', value: 'ANY', checked: true },
-        { name: 'Landing page', value: 'LANDING_PAGE' },
-        { name: 'Site page', value: 'SITE_PAGE' },
-        { name: 'Blog post', value: 'BLOG_POST' },
-        { name: 'Blog listing', value: 'BLOG_LISTING' },
-        { name: 'Email', value: 'EMAIL' },
-        { name: 'Knowledge base', value: 'KNOWLEDGE_BASE' },
-        { name: 'Quote template', value: 'QUOTE_TEMPLATE' },
-        { name: 'Customer portal', value: 'CUSTOMER_PORTAL' },
-        { name: 'Web interactive', value: 'WEB_INTERACTIVE' },
-        { name: 'Subscription', value: 'SUBSCRIPTION' },
-        { name: 'Membership', value: 'MEMBERSHIP' },
-    ],
-    validate: (input) => {
-        return new Promise(function (resolve, reject) {
-            if (input.length > 0) {
-                resolve(true);
-            }
-            reject(lib.prompts.createModulePrompt.errors.contentTypeRequired);
-        });
-    },
-};
-const GLOBAL_PROMPT = {
-    type: 'confirm',
-    name: 'global',
-    message: lib.prompts.createModulePrompt.confirmGlobal,
-    default: false,
-};
-const AVAILABLE_FOR_NEW_CONTENT = {
-    type: 'confirm',
-    name: 'availableForNewContent',
-    message: lib.prompts.createModulePrompt.availableForNewContent,
-    default: true,
-};
-export function createModulePrompt(commandArgs = {}) {
-    // Check if moduleLabel is provided (main requirement to skip full prompting)
-    // but still allow individual parameter prompting for enhanced UX
-    if (commandArgs.moduleLabel) {
-        const prompts = [];
-        // Only prompt for parameters not explicitly provided
-        if (commandArgs.reactType === undefined) {
-            prompts.push(REACT_TYPE_PROMPT);
-        }
-        if (!commandArgs.contentTypes) {
-            prompts.push(CONTENT_TYPES_PROMPT);
-        }
-        if (commandArgs.global === undefined) {
-            prompts.push(GLOBAL_PROMPT);
-        }
-        if (commandArgs.availableForNewContent === undefined) {
-            prompts.push(AVAILABLE_FOR_NEW_CONTENT);
-        }
-        // If no additional prompts needed, return with defaults
-        if (prompts.length === 0) {
-            const contentTypesArray = commandArgs.contentTypes
-                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
-                : ['ANY'];
-            return Promise.resolve({
-                moduleLabel: commandArgs.moduleLabel,
-                reactType: commandArgs.reactType ?? false,
-                contentTypes: contentTypesArray,
-                global: commandArgs.global ?? false,
-                availableForNewContent: commandArgs.availableForNewContent ?? true,
-            });
-        }
-        // Prompt only for missing optional parameters
-        return promptUser(prompts).then(promptResponse => {
-            const contentTypesArray = commandArgs.contentTypes
-                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
-                : promptResponse.contentTypes || ['ANY'];
-            return {
-                moduleLabel: commandArgs.moduleLabel,
-                reactType: commandArgs.reactType ?? promptResponse.reactType ?? false,
-                contentTypes: contentTypesArray,
-                global: commandArgs.global ?? promptResponse.global ?? false,
-                availableForNewContent: commandArgs.availableForNewContent ??
-                    promptResponse.availableForNewContent ??
-                    true,
-            };
-        });
-    }
-    // No moduleLabel provided, prompt for everything (original behavior)
-    return promptUser([
-        MODULE_LABEL_PROMPT,
-        REACT_TYPE_PROMPT,
-        CONTENT_TYPES_PROMPT,
-        GLOBAL_PROMPT,
-        AVAILABLE_FOR_NEW_CONTENT,
-    ]);
-}

package/lib/prompts/createTemplatePrompt.d.ts

@@ -1,6 +0,0 @@
-import { CreateArgs, TemplateType } from '../../types/Cms.js';
-interface CreateTemplatePromptResponse {
-    templateType: TemplateType;
-}
-export declare function createTemplatePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateTemplatePromptResponse>;
-export {};

package/lib/prompts/createTemplatePrompt.js

@@ -1,29 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-const templateTypeChoices = [
-    { name: 'page', value: 'page-template' },
-    { name: 'email', value: 'email-template' },
-    { name: 'partial', value: 'partial' },
-    { name: 'global partial', value: 'global-partial' },
-    { name: 'blog listing', value: 'blog-listing-template' },
-    { name: 'blog post', value: 'blog-post-template' },
-    { name: 'search results', value: 'search-template' },
-    { name: 'section', value: 'section' },
-];
-const TEMPLATE_TYPE_PROMPT = {
-    type: 'list',
-    name: 'templateType',
-    message: lib.prompts.createTemplatePrompt.selectTemplate,
-    default: 'page',
-    choices: templateTypeChoices,
-};
-export function createTemplatePrompt(commandArgs = {}) {
-    // If templateType is provided, return it directly
-    if (commandArgs.templateType) {
-        return Promise.resolve({
-            templateType: commandArgs.templateType,
-        });
-    }
-    // No templateType provided, prompt for it (original behavior)
-    return promptUser([TEMPLATE_TYPE_PROMPT]);
-}

package/lib/prompts/downloadProjectPrompt.d.ts

@@ -1,10 +0,0 @@
-type DownloadProjectPromptResponse = {
-    project: string;
-};
-export declare function downloadProjectPrompt(promptOptions: {
-    account?: string;
-    derivedAccountId?: number;
-    project?: string;
-    name?: string;
-}): Promise<DownloadProjectPromptResponse>;
-export {};

package/lib/prompts/downloadProjectPrompt.js

@@ -1,52 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
-import { logError, ApiErrorContext } from '../errorHandlers/index.js';
-import { uiLogger } from '../ui/logger.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-import { lib } from '../../lang/en.js';
-async function createProjectsList(accountId) {
-    try {
-        if (accountId) {
-            const { data: projects } = await fetchProjects(accountId);
-            return projects.results;
-        }
-        uiLogger.error(lib.prompts.downloadProjectPrompt.errors.accountIdRequired);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    catch (e) {
-        logError(e, accountId ? new ApiErrorContext({ accountId }) : undefined);
-        process.exit(EXIT_CODES.ERROR);
-    }
-}
-export async function downloadProjectPrompt(promptOptions) {
-    const account = promptOptions.account
-        ? getConfigAccountIfExists(promptOptions.account)
-        : undefined;
-    const accountId = account?.accountId || promptOptions.derivedAccountId || null;
-    const projectsList = await createProjectsList(accountId);
-    const response = await promptUser([
-        {
-            name: 'project',
-            message: () => {
-                return promptOptions.project &&
-                    !projectsList.find(p => p.name === promptOptions.name)
-                    ? lib.prompts.downloadProjectPrompt.errors.projectNotFound(promptOptions.project, accountId || 0)
-                    : lib.prompts.downloadProjectPrompt.selectProject;
-            },
-            when: !promptOptions.project ||
-                !projectsList.find(p => p.name === promptOptions.project),
-            type: 'list',
-            choices: projectsList.map(project => {
-                return {
-                    name: project.name,
-                    value: project.name,
-                };
-            }),
-        },
-    ]);
-    if (!response.project) {
-        response.project = promptOptions.project;
-    }
-    return response;
-}

package/lib/prompts/importDataFilePathPrompt.d.ts

@@ -1 +0,0 @@
-export declare function importDataFilePathPrompt(): Promise<string>;

package/lib/prompts/importDataFilePathPrompt.js

@@ -1,26 +0,0 @@
-import { validateImportRequestFile } from '@hubspot/local-dev-lib/crm';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-import { isErrorWithMessageOrReason } from '../errorHandlers/index.js';
-export async function importDataFilePathPrompt() {
-    uiLogger.log(lib.prompts.importDataFilePathPrompt.promptContext);
-    const { filePath } = await promptUser({
-        type: 'input',
-        name: 'filePath',
-        message: lib.prompts.importDataFilePathPrompt.promptMessage,
-        validate: (filePath) => {
-            try {
-                validateImportRequestFile(filePath);
-                return true;
-            }
-            catch (error) {
-                if (isErrorWithMessageOrReason(error) && error.message) {
-                    return error.message;
-                }
-                return false;
-            }
-        },
-    });
-    return filePath;
-}

package/lib/prompts/importDataTestAccountSelectPrompt.d.ts

@@ -1,3 +0,0 @@
-export declare function importDataTestAccountSelectPrompt(parentAccountId: number): Promise<{
-    selectedAccountId: number;
-}>;

package/lib/prompts/importDataTestAccountSelectPrompt.js

@@ -1,28 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
-import { uiAccountDescription } from '../ui/index.js';
-import { lib } from '../../lang/en.js';
-export async function importDataTestAccountSelectPrompt(parentAccountId) {
-    const accounts = getAllConfigAccounts();
-    if (!accounts) {
-        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noAccountsFound);
-    }
-    const childAccounts = accounts
-        .filter(account => account.parentAccountId === parentAccountId)
-        .map(account => {
-        return {
-            name: uiAccountDescription(account.accountId),
-            value: account.accountId,
-        };
-    })
-        .filter(account => account.value !== undefined && account.name !== undefined);
-    if (childAccounts.length === 0) {
-        throw new Error(lib.prompts.importDataTestAccountSelectPrompt.errors.noChildTestAccountsFound(parentAccountId));
-    }
-    return promptUser({
-        type: 'list',
-        name: 'selectedAccountId',
-        message: '[--account] Select a developer test account:',
-        choices: childAccounts,
-    });
-}

package/lib/prompts/installAppPrompt.d.ts

@@ -1,2 +0,0 @@
-export declare function installAppBrowserPrompt(installUrl: string, isReinstall?: boolean): Promise<void>;
-export declare function installAppAutoPrompt(): Promise<boolean>;

package/lib/prompts/installAppPrompt.js

@@ -1,38 +0,0 @@
-import open from 'open';
-import { promptUser } from './promptUtils.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-import { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
-    uiLogger.log('');
-    if (isReinstall) {
-        uiLogger.log(lib.prompts.installAppPrompt.reinstallExplanation);
-    }
-    else {
-        uiLogger.log(lib.prompts.installAppPrompt.explanation);
-    }
-    const { shouldOpenBrowser } = await promptUser({
-        name: 'shouldOpenBrowser',
-        type: 'confirm',
-        message: isReinstall
-            ? lib.prompts.installAppPrompt.reinstallPrompt
-            : lib.prompts.installAppPrompt.prompt,
-    });
-    if (!isReinstall && !shouldOpenBrowser) {
-        uiLogger.log(lib.prompts.installAppPrompt.decline);
-        process.exit(EXIT_CODES.SUCCESS);
-    }
-    else if (!shouldOpenBrowser) {
-        return;
-    }
-    open(installUrl);
-}
-export async function installAppAutoPrompt() {
-    uiLogger.log('');
-    const { shouldInstall } = await promptUser({
-        name: 'shouldInstall',
-        type: 'confirm',
-        message: lib.prompts.installAppPrompt.autoPrompt,
-    });
-    return shouldInstall;
-}

package/lib/prompts/personalAccessKeyPrompt.d.ts

@@ -1,29 +0,0 @@
-import { AccountNamePromptResponse } from './accountNamePrompt.js';
-import { PromptConfig } from '../../types/Prompts.js';
-export type PersonalAccessKeyPromptResponse = {
-    personalAccessKey: string;
-    env: string;
-};
-type AccountIdPromptResponse = {
-    accountId: number;
-};
-type ClientIdPromptResponse = {
-    clientId: string;
-};
-type ClientSecretPromptResponse = {
-    clientSecret: string;
-};
-type ScopesPromptResponse = {
-    scopes: string[];
-};
-export type OauthPromptResponse = AccountNamePromptResponse & AccountIdPromptResponse & ClientIdPromptResponse & ClientSecretPromptResponse & ScopesPromptResponse;
-/**
- * Displays notification to user that we are about to open the browser,
- * then opens their browser to the personal-access-key shortlink
- */
-export declare function personalAccessKeyPrompt({ env, account, }: {
-    env: string;
-    account?: number;
-}): Promise<PersonalAccessKeyPromptResponse>;
-export declare const OAUTH_FLOW: (PromptConfig<AccountNamePromptResponse> | PromptConfig<AccountIdPromptResponse> | PromptConfig<ClientIdPromptResponse> | PromptConfig<ClientSecretPromptResponse> | PromptConfig<ScopesPromptResponse>)[];
-export {};