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

package/lib/prompts/personalAccessKeyPrompt.js

@@ -1,134 +0,0 @@
-import open from 'open';
-import { OAUTH_SCOPES, DEFAULT_OAUTH_SCOPES, } from '@hubspot/local-dev-lib/constants/auth';
-import { deleteConfigFileIfEmpty } from '@hubspot/local-dev-lib/config';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { uiLogger } from '../ui/logger.js';
-import { promptUser } from './promptUtils.js';
-import { getCliAccountNamePromptConfig, } from './accountNamePrompt.js';
-import { uiInfoSection } from '../ui/index.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-import { lib } from '../../lang/en.js';
-/**
- * Displays notification to user that we are about to open the browser,
- * then opens their browser to the personal-access-key shortlink
- */
-export async function personalAccessKeyPrompt({ env, account, }) {
-    const websiteOrigin = getHubSpotWebsiteOrigin(env);
-    let url = `${websiteOrigin}/l/personal-access-key`;
-    if (process.env.BROWSER !== 'none') {
-        uiInfoSection(lib.prompts.personalAccessKeyPrompt.personalAccessKeySetupTitle, () => {
-            uiLogger.log(lib.prompts.personalAccessKeyPrompt.personalAccessKeyBrowserOpenPrep);
-        });
-        if (account) {
-            url = `${websiteOrigin}/personal-access-key/${account}`;
-        }
-        const { personalAccessKeyBrowserOpenPrep: choice } = await promptUser([
-            PERSONAL_ACCESS_KEY_BROWSER_OPEN_PREP,
-        ]);
-        if (!choice) {
-            deleteConfigFileIfEmpty();
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        if (choice ===
-            lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
-                .OPEN_BROWSER) {
-            open(url, { url: true });
-            uiLogger.log(lib.prompts.personalAccessKeyPrompt.logs.openingWebBrowser(url));
-        }
-    }
-    const { personalAccessKey } = await promptUser(PERSONAL_ACCESS_KEY);
-    return {
-        personalAccessKey,
-        env,
-    };
-}
-const ACCOUNT_ID = {
-    name: 'accountId',
-    message: lib.prompts.personalAccessKeyPrompt.enterAccountId,
-    type: 'number',
-    validate(val) {
-        if (!Number.isNaN(val) && val !== undefined && val > 0) {
-            return true;
-        }
-        return lib.prompts.personalAccessKeyPrompt.errors.invalidAccountId;
-    },
-};
-const CLIENT_ID = {
-    name: 'clientId',
-    message: lib.prompts.personalAccessKeyPrompt.enterClientId,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.personalAccessKeyPrompt.errors.invalidOauthClientId;
-        }
-        else if (val.length !== 36) {
-            return lib.prompts.personalAccessKeyPrompt.errors
-                .invalidOauthClientIdLength;
-        }
-        return true;
-    },
-};
-const CLIENT_SECRET = {
-    name: 'clientSecret',
-    message: lib.prompts.personalAccessKeyPrompt.enterClientSecret,
-    validate(val) {
-        if (typeof val !== 'string') {
-            return lib.prompts.personalAccessKeyPrompt.errors
-                .invalidOauthClientSecret;
-        }
-        else if (val.length !== 36) {
-            return lib.prompts.personalAccessKeyPrompt.errors
-                .invalidOauthClientSecretLength;
-        }
-        else if (val[0] === '*') {
-            return lib.prompts.personalAccessKeyPrompt.errors
-                .invalidOauthClientSecretCopy;
-        }
-        return true;
-    },
-};
-const PERSONAL_ACCESS_KEY_BROWSER_OPEN_PREP = {
-    name: 'personalAccessKeyBrowserOpenPrep',
-    type: 'list',
-    message: 'Choose your preferred method of authentication',
-    choices: Object.values(lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices),
-    default: lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices
-        .OPEN_BROWSER,
-};
-const PERSONAL_ACCESS_KEY = {
-    name: 'personalAccessKey',
-    message: lib.prompts.personalAccessKeyPrompt.enterPersonalAccessKey,
-    transformer: (val) => {
-        if (!val)
-            return val;
-        let res = '';
-        for (let i = 0; i < val.length; i++) {
-            res += '*';
-        }
-        return res;
-    },
-    validate(val) {
-        if (!val || typeof val !== 'string') {
-            return lib.prompts.personalAccessKeyPrompt.errors
-                .invalidPersonalAccessKey;
-        }
-        else if (val[0] === '•') {
-            return lib.prompts.personalAccessKeyPrompt.errors
-                .invalidPersonalAccessKeyCopy;
-        }
-        return true;
-    },
-};
-const SCOPES = {
-    type: 'checkbox',
-    name: 'scopes',
-    message: lib.prompts.personalAccessKeyPrompt.selectScopes,
-    default: [...DEFAULT_OAUTH_SCOPES],
-    choices: [...OAUTH_SCOPES],
-};
-export const OAUTH_FLOW = [
-    getCliAccountNamePromptConfig(),
-    ACCOUNT_ID,
-    CLIENT_ID,
-    CLIENT_SECRET,
-    SCOPES,
-];

package/lib/prompts/previewPrompt.d.ts

@@ -1,15 +0,0 @@
-type PreviewPromptResponse = {
-    src: string;
-    dest: string;
-};
-type PreviewProjectPromptResponse = {
-    themeComponentPath: string;
-};
-export declare function previewPrompt(promptOptions?: {
-    src?: string;
-    dest?: string;
-}): Promise<PreviewPromptResponse>;
-export declare function previewProjectPrompt(themeComponents: {
-    path: string;
-}[]): Promise<PreviewProjectPromptResponse>;
-export {};

package/lib/prompts/previewPrompt.js

@@ -1,48 +0,0 @@
-import path from 'path';
-import { getCwd } from '@hubspot/local-dev-lib/path';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-export async function previewPrompt(promptOptions = {}) {
-    return promptUser([
-        {
-            name: 'src',
-            message: lib.prompts.previewPrompt.enterSrc,
-            when: !promptOptions.src,
-            default: '.',
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.previewPrompt.errors.srcRequired;
-                }
-                return true;
-            },
-        },
-        {
-            name: 'dest',
-            message: lib.prompts.previewPrompt.enterDest,
-            when: !promptOptions.dest,
-            default: path.basename(getCwd()),
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.previewPrompt.errors.destRequired;
-                }
-                return true;
-            },
-        },
-    ]);
-}
-export async function previewProjectPrompt(themeComponents) {
-    return promptUser([
-        {
-            name: 'themeComponentPath',
-            message: lib.prompts.previewPrompt.themeProjectSelect,
-            type: 'list',
-            choices: themeComponents.map(t => {
-                const themeName = path.basename(t.path);
-                return {
-                    name: themeName,
-                    value: t.path,
-                };
-            }),
-        },
-    ]);
-}

package/lib/prompts/projectAddPrompt.d.ts

@@ -1,15 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { ComponentTemplate, ComponentTemplateChoice } from '../../types/Projects.js';
-type ProjectAddPromptResponse = {
-    componentTemplate: ComponentTemplate;
-    name: string;
-};
-type ProjectAddPromptResponseV2 = {
-    componentTemplate: ComponentTemplate[];
-};
-export declare function projectAddPrompt(components: ComponentTemplate[], promptOptions?: {
-    name?: string;
-    type?: string;
-}): Promise<ProjectAddPromptResponse>;
-export declare function projectAddPromptV2(components: (ComponentTemplateChoice | Separator)[], selectedFeatures: string[] | undefined): Promise<ProjectAddPromptResponseV2>;
-export {};

package/lib/prompts/projectAddPrompt.js

@@ -1,82 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-function findComponentByPathOrLabel(components, componentPathOrLabel) {
-    return components.find(c => c.path === componentPathOrLabel || c.label === componentPathOrLabel);
-}
-export async function projectAddPrompt(components, promptOptions = {}) {
-    const providedTypeIsValid = !!promptOptions.type &&
-        !!findComponentByPathOrLabel(components, promptOptions.type);
-    const result = await promptUser([
-        {
-            name: 'componentTemplate',
-            message: () => {
-                return promptOptions.type && !providedTypeIsValid
-                    ? lib.prompts.projectAddPrompt.errors.invalidType(promptOptions.type)
-                    : lib.prompts.projectAddPrompt.selectType;
-            },
-            when: !providedTypeIsValid,
-            type: 'list',
-            choices: components.map(type => {
-                return {
-                    name: type.label,
-                    value: type,
-                };
-            }),
-        },
-        {
-            name: 'name',
-            message: lib.prompts.projectAddPrompt.enterName,
-            when: !promptOptions.name,
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.projectAddPrompt.errors.nameRequired;
-                }
-                return true;
-            },
-        },
-    ]);
-    if (!result.name) {
-        result.name = promptOptions.name;
-    }
-    if (providedTypeIsValid) {
-        result.componentTemplate = findComponentByPathOrLabel(components, promptOptions.type);
-    }
-    return result;
-}
-export async function projectAddPromptV2(components, selectedFeatures) {
-    const selectedComponents = [];
-    if (selectedFeatures) {
-        components.forEach(template => {
-            if (template instanceof Separator || !template.value) {
-                return;
-            }
-            if (selectedFeatures?.includes(template.value.cliSelector || template.value.type)) {
-                if (template.disabled) {
-                    throw new Error(lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
-                }
-                selectedComponents.push(template.value);
-            }
-        });
-    }
-    if (!components?.length) {
-        uiLogger.error(lib.prompts.projectAddPrompt.errors.noSelectableChoices);
-        uiLogger.log('');
-        return { componentTemplate: [] };
-    }
-    const result = await promptUser([
-        {
-            name: 'componentTemplate',
-            message: lib.prompts.projectAddPrompt.selectFeatures,
-            when: !selectedFeatures && selectedComponents.length === 0,
-            type: 'checkbox',
-            choices: components,
-            pageSize: components.length,
-        },
-    ]);
-    if (!result.componentTemplate) {
-        result.componentTemplate = selectedComponents;
-    }
-    return result;
-}

package/lib/prompts/projectDevTargetAccountPrompt.d.ts

@@ -1,12 +0,0 @@
-import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
-export type ProjectDevTargetAccountPromptResponse = {
-    targetAccountId: number | null;
-    createNestedAccount: boolean;
-    parentAccountId?: number | null;
-    notInConfigAccount?: DeveloperTestAccount | null;
-};
-export declare function selectSandboxTargetAccountPrompt(accounts: HubSpotConfigAccount[], defaultAccountConfig: HubSpotConfigAccount): Promise<ProjectDevTargetAccountPromptResponse>;
-export declare function selectDeveloperTestTargetAccountPrompt(accounts: HubSpotConfigAccount[], defaultAccountConfig: HubSpotConfigAccount): Promise<ProjectDevTargetAccountPromptResponse>;
-export declare function confirmDefaultAccountPrompt(accountName: string, accountType: string): Promise<boolean>;
-export declare function confirmUseExistingDeveloperTestAccountPrompt(account: DeveloperTestAccount): Promise<boolean>;

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -1,169 +0,0 @@
-import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
-import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-import { uiAccountDescription } from '../ui/index.js';
-import { isSandbox } from '../accountTypes.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
-function mapNestedAccount(accountConfig) {
-    const parentAccountId = accountConfig.parentAccountId ?? null;
-    return {
-        name: uiAccountDescription(accountConfig.accountId, false),
-        value: {
-            targetAccountId: accountConfig.accountId,
-            createNestedAccount: false,
-            parentAccountId,
-        },
-    };
-}
-function getNonConfigDeveloperTestAccountName(account) {
-    return `${account.accountName} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]}] (${account.id})`;
-}
-export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
-    const defaultAccountId = defaultAccountConfig.accountId;
-    let choices = [];
-    let sandboxUsage = {
-        STANDARD: { used: 0, available: 0, limit: 0 },
-        DEVELOPER: { used: 0, available: 0, limit: 0 },
-    };
-    try {
-        if (defaultAccountId) {
-            const { data } = await getSandboxUsageLimits(defaultAccountId);
-            sandboxUsage = data.usage;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    catch (err) {
-        uiLogger.debug('Unable to fetch sandbox usage limits: ', err);
-    }
-    const sandboxAccounts = accounts
-        .reverse()
-        .filter(config => isSandbox(config) && config.parentAccountId === defaultAccountId);
-    let disabledMessage = false;
-    if (sandboxUsage['DEVELOPER'] && sandboxUsage['DEVELOPER'].available === 0) {
-        if (sandboxAccounts.length < sandboxUsage['DEVELOPER'].limit) {
-            disabledMessage =
-                lib.prompts.projectDevTargetAccountPrompt.sandboxLimitWithSuggestion(sandboxUsage['DEVELOPER'].limit);
-        }
-        else {
-            disabledMessage = lib.prompts.projectDevTargetAccountPrompt.sandboxLimit(sandboxUsage['DEVELOPER'].limit);
-        }
-    }
-    // Order choices by Developer Sandbox -> Standard Sandbox
-    choices = [
-        ...sandboxAccounts
-            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX)
-            .map(mapNestedAccount),
-        ...sandboxAccounts
-            .filter(a => a.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX)
-            .map(mapNestedAccount),
-        {
-            name: lib.prompts.projectDevTargetAccountPrompt.createNewSandboxOption,
-            value: {
-                targetAccountId: null,
-                createNestedAccount: true,
-            },
-            disabled: disabledMessage,
-        },
-        {
-            name: lib.prompts.projectDevTargetAccountPrompt
-                .chooseDefaultAccountOption,
-            value: {
-                targetAccountId: defaultAccountId,
-                createNestedAccount: false,
-            },
-        },
-    ];
-    return selectTargetAccountPrompt(defaultAccountId, 'sandbox account', choices);
-}
-export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
-    const defaultAccountId = defaultAccountConfig.accountId;
-    let devTestAccountsResponse;
-    try {
-        if (defaultAccountId) {
-            const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
-            devTestAccountsResponse = data;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    catch (err) {
-        uiLogger.debug('Unable to fetch developer test account usage limits: ', err);
-    }
-    let disabledMessage = false;
-    if (devTestAccountsResponse &&
-        devTestAccountsResponse.results.length >=
-            devTestAccountsResponse.maxTestPortals) {
-        disabledMessage =
-            lib.prompts.projectDevTargetAccountPrompt.developerTestAccountLimit(devTestAccountsResponse.maxTestPortals);
-    }
-    const devTestAccounts = [];
-    if (devTestAccountsResponse && devTestAccountsResponse.results) {
-        const accountIds = accounts.map(account => account.accountId);
-        devTestAccountsResponse.results.forEach(acct => {
-            const inConfig = accountIds.includes(acct.id);
-            devTestAccounts.push({
-                name: getNonConfigDeveloperTestAccountName(acct),
-                value: {
-                    targetAccountId: acct.id,
-                    createNestedAccount: false,
-                    parentAccountId: defaultAccountId ?? null,
-                    notInConfigAccount: inConfig ? null : acct,
-                },
-            });
-        });
-    }
-    const choices = [
-        ...devTestAccounts,
-        {
-            name: lib.prompts.projectDevTargetAccountPrompt
-                .createNewDeveloperTestAccountOption,
-            value: {
-                targetAccountId: null,
-                createNestedAccount: true,
-            },
-            disabled: disabledMessage,
-        },
-    ];
-    return selectTargetAccountPrompt(defaultAccountId, HUBSPOT_ACCOUNT_TYPE_STRINGS[HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST], choices);
-}
-async function selectTargetAccountPrompt(defaultAccountId, accountType, choices) {
-    const accountId = defaultAccountId;
-    const { targetAccountInfo } = await promptUser([
-        {
-            name: 'targetAccountInfo',
-            type: 'list',
-            message: lib.prompts.projectDevTargetAccountPrompt.promptMessage(accountType, uiAccountDescription(accountId)),
-            choices,
-            loop: false,
-        },
-    ]);
-    return targetAccountInfo;
-}
-export async function confirmDefaultAccountPrompt(accountName, accountType) {
-    const { useDefaultAccount } = await promptUser([
-        {
-            name: 'useDefaultAccount',
-            type: 'confirm',
-            message: lib.prompts.projectDevTargetAccountPrompt.confirmDefaultAccount(accountName, accountType),
-        },
-    ]);
-    return useDefaultAccount;
-}
-export async function confirmUseExistingDeveloperTestAccountPrompt(account) {
-    const { confirmUseExistingDeveloperTestAccount } = await promptUser([
-        {
-            name: 'confirmUseExistingDeveloperTestAccount',
-            type: 'confirm',
-            message: lib.prompts.projectDevTargetAccountPrompt.confirmUseExistingDeveloperTestAccount(getNonConfigDeveloperTestAccountName(account)),
-        },
-    ]);
-    return confirmUseExistingDeveloperTestAccount;
-}

package/lib/prompts/projectNameAndDestPrompt.d.ts

@@ -1,3 +0,0 @@
-import { PromptOptionsArg, ProjectNameAndDestPromptResponse } from './selectProjectTemplatePrompt.js';
-export declare function projectNameAndDestPrompt(promptOptions: PromptOptionsArg): Promise<ProjectNameAndDestPromptResponse>;
-export declare function validateProjectDirectory(input?: string): string | boolean;

package/lib/prompts/projectNameAndDestPrompt.js

@@ -1,53 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { sanitizeFileName, getCwd, untildify, isValidPath, } from '@hubspot/local-dev-lib/path';
-import { lib } from '../../lang/en.js';
-import { promptUser } from './promptUtils.js';
-import { PROJECT_CONFIG_FILE } from '../constants.js';
-export async function projectNameAndDestPrompt(promptOptions) {
-    const result = await promptUser([
-        {
-            name: 'name',
-            message: lib.prompts.projectNameAndDestPrompt.enterName,
-            when: !promptOptions.name,
-            validate: (input) => {
-                if (!input) {
-                    return lib.prompts.projectNameAndDestPrompt.errors.nameRequired;
-                }
-                return true;
-            },
-        },
-        {
-            name: 'dest',
-            message: lib.prompts.projectNameAndDestPrompt.enterDest,
-            when: !promptOptions.dest,
-            default: (answers) => {
-                const projectName = sanitizeFileName(promptOptions.name || answers.name);
-                return path.resolve(getCwd(), projectName);
-            },
-            validate: validateProjectDirectory,
-            filter: (input) => {
-                return untildify(input);
-            },
-        },
-    ]);
-    if (!result.name) {
-        result.name = promptOptions.name;
-    }
-    if (!result.dest) {
-        result.dest = promptOptions.dest;
-    }
-    return result;
-}
-export function validateProjectDirectory(input) {
-    if (!input) {
-        return lib.prompts.projectNameAndDestPrompt.errors.destRequired;
-    }
-    if (fs.existsSync(path.resolve(getCwd(), path.join(input, PROJECT_CONFIG_FILE)))) {
-        return lib.prompts.projectNameAndDestPrompt.errors.invalidDest;
-    }
-    if (!isValidPath(input)) {
-        return lib.prompts.projectNameAndDestPrompt.errors.invalidCharacters;
-    }
-    return true;
-}

package/lib/prompts/projectNamePrompt.d.ts

@@ -1,6 +0,0 @@
-export type ProjectNamePromptResponse = {
-    projectName: string;
-};
-export declare function projectNamePrompt(accountId: number, options?: {
-    project?: string;
-}): Promise<ProjectNamePromptResponse>;

package/lib/prompts/projectNamePrompt.js

@@ -1,27 +0,0 @@
-import { promptUser } from './promptUtils.js';
-import { lib } from '../../lang/en.js';
-import { ensureProjectExists } from '../projects/ensureProjectExists.js';
-export async function projectNamePrompt(accountId, options = {}) {
-    const result = await promptUser({
-        name: 'projectName',
-        message: lib.prompts.projectNamePrompt.enterName,
-        when: !options.project,
-        validate: async (val) => {
-            if (typeof val !== 'string' || !val) {
-                return lib.prompts.projectNamePrompt.errors.invalidName;
-            }
-            const { projectExists } = await ensureProjectExists(accountId, val, {
-                allowCreate: false,
-                noLogs: true,
-            });
-            if (!projectExists) {
-                return lib.prompts.projectNamePrompt.errors.projectDoesNotExist(val, accountId);
-            }
-            return true;
-        },
-    });
-    if (!result.projectName && options.project) {
-        result.projectName = options.project;
-    }
-    return result;
-}

package/lib/prompts/projectsLogsPrompt.d.ts

@@ -1,12 +0,0 @@
-type ProjectLogsPromptOptions = {
-    functionChoices?: string[];
-    promptOptions?: {
-        function?: string;
-    };
-    projectName?: string;
-};
-type ProjectLogsPromptResponse = {
-    functionName?: string;
-};
-export declare function projectLogsPrompt({ functionChoices, promptOptions, projectName, }: ProjectLogsPromptOptions): Promise<ProjectLogsPromptResponse>;
-export {};

package/lib/prompts/projectsLogsPrompt.js

@@ -1,20 +0,0 @@
-import { lib } from '../../lang/en.js';
-import { promptUser } from './promptUtils.js';
-export async function projectLogsPrompt({ functionChoices, promptOptions, projectName = '', }) {
-    if (!functionChoices) {
-        return {};
-    }
-    if (functionChoices.length === 1) {
-        return { functionName: functionChoices[0] };
-    }
-    return promptUser([
-        {
-            name: 'functionName',
-            type: 'list',
-            message: lib.prompts.projectLogsPrompt.functionName(projectName),
-            when: () => (!promptOptions || !promptOptions.function) &&
-                functionChoices.length > 0,
-            choices: functionChoices,
-        },
-    ]);
-}

package/lib/prompts/promptUtils.d.ts

@@ -1,32 +0,0 @@
-import { Separator as _Separator } from '@inquirer/prompts';
-import { PromptConfig, GenericPromptResponse, PromptWhen, PromptChoices } from '../../types/Prompts.js';
-export declare const Separator: _Separator;
-export declare const PROMPT_THEME: {
-    prefix: {
-        idle: string;
-    };
-};
-export declare const CHECKBOX_PROMPT_THEME: {
-    prefix: {
-        idle: string;
-    };
-    style: {
-        disabledChoice: (text: string) => string;
-    };
-};
-export declare function promptUser<T extends GenericPromptResponse>(config: PromptConfig<T> | PromptConfig<T>[]): Promise<T>;
-export declare function confirmPrompt(message: string, options?: {
-    defaultAnswer?: boolean;
-}): Promise<boolean>;
-export declare function listPrompt<T = string>(message: string, { choices, when, defaultAnswer, validate, loop, }: {
-    choices: PromptChoices<T>;
-    when?: PromptWhen;
-    defaultAnswer?: string | number | boolean;
-    validate?: (input: T[]) => (boolean | string) | Promise<boolean | string>;
-    loop?: boolean;
-}): Promise<T>;
-export declare function inputPrompt(message: string, { when, validate, defaultAnswer, }?: {
-    when?: boolean | (() => boolean);
-    validate?: (input: string) => (boolean | string) | Promise<boolean | string>;
-    defaultAnswer?: string;
-}): Promise<string>;