import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
export declare const commands: {
    generalErrors: {
        srcIsProject: (src: string, command: string) => string;
        validateConfigMiddleware: {
            missingConfigFile: string;
            configValidationFailed: (errors: string[]) => string;
        };
    };
    getStarted: {
        describe: string;
        options: {
            dest: {
                describe: string;
            };
            name: {
                describe: string;
            };
            v2: {
                describe: string;
            };
            templateSource: {
                describe: string;
            };
        };
        v2: {
            unknownError: string;
            startTitle: string;
            guideOverview: (accountName: string) => string;
            projects: string;
            runningProjectCreate: string;
            templateSourceFlag: string;
            runningInstallDeps: string;
            installingDependenciesIn: (installPath: string) => string;
            createdProjectSuccess: (projectName: string, projectDest: string) => string;
            pressEnterToContinueDeploy: (accountName: string) => string;
            uploadingProject: string;
            uploadSuccess: string;
            appDeployedReady: string;
            appConfigDetails: string;
            distribution: string;
            authType: string;
            checkOutConfig: (configPath: string) => string;
            pressEnterToInstall: (accountName: string) => string;
            pressKeyToExit: string;
            installingApp: (appName: string, accountName: string) => string;
            installInstructions: string;
            browserFailedToOpen: (url: string) => string;
            pollingTimeout: (minutes: number) => string;
            pressEnterToContinueSetup: string;
            prompts: {
                selectOptionV2: string;
                options: {
                    app: string;
                    cms: string;
                    cmsTheme: string;
                    cmsReactModule: string;
                };
            };
        };
        startTitle: string;
        verboseDescribe: string;
        startDescription: string;
        guideOverview: (accountName: string) => string;
        designManager: string;
        openDesignManager: string;
        openDesignManagerPrompt: string;
        openedDesignManager: string;
        developerOverviewBrowserOpenPrep: string;
        openInstallUrl: string;
        openedDeveloperOverview: string;
        prompts: {
            selectOption: string;
            selectOptionV2: string;
            options: {
                app: string;
                cms: string;
                cmsTheme: string;
                cmsReactModule: string;
            };
            uploadProject: (accountName: string) => string;
            projectCreated: {
                title: string;
                description: string;
            };
        };
        logs: {
            appSelected: string;
            uploadingProject: string;
            uploadSuccess: string;
            developerOverviewLink: string;
            initialUploadMessage: string;
        };
        errors: {
            uploadFailed: string;
            configFileNotFound: string;
            noAppsFound: string;
            uploadActionFailed: string;
            buildOrDeployFailed: string;
            failedToUploadAndDeploy: string;
        };
    };
    completion: {
        describe: string;
        examples: {
            default: string;
        };
    };
    account: {
        describe: string;
        subcommands: {
            auth: {
                describe: string;
                verboseDescribe: string;
                options: {
                    account: string;
                    personalAccessKey: string;
                };
                errors: {
                    invalidAccountIdProvided: string;
                    failedToUpdateConfig: string;
                    migrationNotConfirmed: string;
                    mergeNotConfirmed: string;
                };
                success: {
                    configFileCreated: (configPath: string) => string;
                    configFileUpdated: (accountId: number) => string;
                };
            };
            list: {
                accounts: string;
                allAccounts: string;
                linkedAccounts: string;
                defaultAccountTitle: string;
                linkedDefaultTitle: string;
                currentResolvedDefaultAccount: (accountId: number) => string;
                directory: (dir: string) => string;
                describe: string;
                configPath: (configPath: string) => string;
                overrideFilePathTitle: string;
                overrideFilePath: (overrideFilePath: string) => string;
                labels: {
                    accountId: string;
                    authType: string;
                    name: string;
                };
            };
            rename: {
                describe: string;
                positionals: {
                    accountName: {
                        describe: string;
                    };
                    newName: {
                        describe: string;
                    };
                };
                success: {
                    renamed: (name: string, newName: string, nameWasSanitized: boolean) => string;
                };
            };
            use: {
                describe: string;
                errors: {
                    accountNotFound: (specifiedAccount: string, configPath: string) => string;
                };
                accountOverride: (accountOverride: string) => string;
                accountOverrideCommands: string;
                examples: {
                    default: string;
                    idBased: string;
                    nameBased: string;
                };
                options: {
                    account: {
                        describe: string;
                    };
                };
                promptMessage: string;
                authenticateNewAccount: string;
                success: {
                    defaultAccountUpdated: (accountName: string) => string;
                };
                linked: {
                    editingLinkedDefault: (dir: string) => string;
                    alreadyDefault: (accountId: number) => string;
                    setLinkedDefault: (account: string) => string;
                    accountNotLinked: (account: string) => string;
                    promptToLink: (account: string) => string;
                    settingGlobalDefault: string;
                    nonInteractiveNotLinked: (account: string) => string;
                };
            };
            link: {
                describe: string;
                verboseDescribe: string;
                shared: {
                    noLinkedAccounts: string;
                    globalAccountsAvailable: (count: number) => string;
                    configurePrompt: string;
                    deprecatedConfigNotSupported: (command: string) => string;
                    writeSettingsFailed: (path: string, err: unknown) => string;
                    savedToSettings: (path: string) => string;
                    usingLinkedAccounts: (settingsPath: string) => string;
                    accountAutoLinked: (accountId: number) => string;
                    accountAutoLinkFailed: (accountId: number) => string;
                };
                linkingDirectory: (dir: string) => string;
                managingLinkedAccounts: (dir: string) => string;
                settingsInfo: (path: string) => string;
                success: {
                    created: (path: string) => string;
                };
                errors: {
                    authFailed: string;
                };
                events: {
                    accountsLinked: (count: number) => string;
                    accountsUnlinked: (count: number) => string;
                    overrideAccountDetected: (accountId: number) => string;
                    defaultAccountSet: (accountId: number) => string;
                    defaultAccountRemoved: (isSelectionRequired: boolean) => string;
                    defaultAccountRemains: (accountId: number) => string;
                    updatedLinkedAccounts: string;
                    noAccountsLinked: string;
                    overrideFileRemoved: string;
                    invalidDefaultAccount: (accountId: number) => string;
                };
                prompts: {
                    howToProceed: string;
                    whatToDo: string;
                    linkExisting: string;
                    authenticateNew: string;
                    cancel: string;
                    selectDefault: string;
                    selectToLink: string;
                    selectToUnlink: string;
                    alreadyLinked: string;
                    fromHsAccount: string;
                    newlyAuthenticated: string;
                    mustSelectOne: string;
                    keepAsDefault: string;
                };
            };
            unlink: {
                describe: string;
                verboseDescribe: string;
            };
            remove: {
                describe: string;
                logs: {
                    replaceDefaultAccount: string;
                };
                prompts: {
                    deleteOverrideFile: (overrideFilePath: string, accountName: string) => string;
                    selectAccountToRemove: string;
                };
                errors: {
                    accountNotFound: (specifiedAccount: string, configPath: string) => string;
                };
                examples: {
                    default: string;
                    byName: string;
                };
                options: {
                    account: {
                        describe: string;
                    };
                };
                promptMessage: string;
                success: {
                    accountRemoved: (accountName: string) => string;
                };
            };
            removeOverride: {
                describe: (overrideFile: string) => string;
                accountOverride: (overrideFilePath: string, accountOverride: string) => string;
                prompts: {
                    deleteOverrideFile: string;
                };
                success: string;
                noOverrideFile: string;
                errors: {
                    globalConfigNotFound: string;
                };
                options: {
                    force: {
                        describe: string;
                    };
                };
            };
            info: {
                accountId: (accountId: number) => string;
                defaultAccountTitle: string;
                configPath: (configPath: string) => string;
                defaultAccount: (accountName: string) => string;
                overrideFilePathTitle: string;
                overrideFilePath: (overrideFilePath: string) => string;
                overrideAccount: (accountName: string) => string;
                describe: string;
                errors: {
                    notUsingPersonalAccessKey: string;
                };
                options: {
                    account: {
                        describe: string;
                    };
                };
                examples: {
                    default: string;
                    idBased: string;
                    nameBased: string;
                };
                name: (name: string) => string;
                scopeGroups: string;
                linkedDefaultTitle: string;
                settingsPath: (path: string) => string;
                linkedDefault: (account: string) => string;
            };
            clean: {
                describe: string;
                noResults: string;
                loading: {
                    add: string;
                };
                inactiveAccountsFound: {
                    one: string;
                    other: (count: number) => string;
                };
                confirm: {
                    one: string;
                    other: (count: number) => string;
                };
                removeSuccess: (accountName: string) => string;
                replaceDefaultAccount: string;
                defaultAccountOverride: (overrideFilePath: string) => string;
            };
            createOverride: {
                describe: (hsAccountFileName: string) => string;
                success: (overrideFilePath: string) => string;
                accountOverride: (overrideFilePath: string, accountOverride: string) => string;
                prompts: {
                    replaceOverrideFile: string;
                };
                errors: {
                    globalConfigNotFound: string;
                    accountNotFound: (configPath: string) => string;
                };
                options: {
                    account: {
                        describe: string;
                    };
                };
                examples: {
                    default: (hsAccountFileName: string) => string;
                    idBased: (hsAccountFileName: string) => string;
                    nameBased: (hsAccountFileName: string) => string;
                };
            };
        };
    };
    auth: {
        describe: string;
        verboseDescribe: (configName: string, authMethod: string) => string;
        errors: {
            invalidAccountIdProvided: string;
            globalConfigFileExists: (accountAuthCommand: string) => string;
            noConfigFileFound: string;
            unsupportedAuthType: (type: string, supportedProtocols: string) => string;
        };
        options: {
            authType: {
                describe: string;
                defaultDescription: (authMethod: string) => string;
            };
            account: {
                describe: string;
            };
            personalAccessKey: {
                describe: string;
            };
        };
        success: {
            configFileUpdated: (accountName: string, configFilename: string, authType: string) => string;
        };
    };
    config: {
        describe: string;
        subcommands: {
            migrate: {
                describe: string;
                verboseDescribe: string;
                errors: {
                    noConfigToMigrate: string;
                    configNotFound: (configPath: string) => string;
                };
                options: {
                    force: string;
                };
                examples: {
                    default: string;
                    configFlag: string;
                };
            };
            set: {
                describe: string;
                promptMessage: string;
                examples: {
                    default: string;
                };
                options: {
                    defaultMode: {
                        describe: string;
                    };
                    allowUsageTracking: {
                        describe: string;
                    };
                    httpTimeout: {
                        describe: string;
                    };
                    allowAutoUpdates: {
                        describe: string;
                    };
                    autoOpenBrowser: {
                        describe: string;
                    };
                };
                errors: {
                    invalidBoolean: (commandName: string, value: string) => string;
                    invalidHTTPTimeout: string;
                };
            };
        };
    };
    cms: {
        describe: string;
        subcommands: {
            template: {
                describe: string;
                subcommands: {
                    create: {
                        describe: string;
                        errors: {
                            unusablePath: (path: string) => string;
                        };
                        positionals: {
                            name: string;
                            dest: string;
                        };
                        options: {
                            templateType: string;
                        };
                    };
                };
            };
            webpack: {
                describe: string;
                subcommands: {
                    create: {
                        describe: string;
                        errors: {
                            unusablePath: (path: string) => string;
                        };
                        positionals: {
                            dest: string;
                        };
                    };
                };
            };
            theme: {
                describe: string;
                subcommands: {
                    create: {
                        describe: string;
                        errors: {
                            unusablePath: (path: string) => string;
                        };
                        positionals: {
                            dest: string;
                        };
                    };
                    generateSelectors: {
                        describe: string;
                        errors: {
                            invalidPath: (themePath: string) => string;
                            fieldsNotFound: string;
                            noSelectorsFound: string;
                        };
                        success: (themePath: string, selectorsPath: string) => string;
                        positionals: {
                            path: string;
                        };
                    };
                    marketplaceValidate: {
                        describe: string;
                        errors: {
                            invalidPath: (path: string) => string;
                        };
                        logs: {
                            validatingTheme: (path: string) => string;
                        };
                        results: {
                            required: string;
                            recommended: string;
                            warnings: {
                                file: (file: string) => string;
                                lineNumber: (line: string) => string;
                            };
                            noErrors: string;
                        };
                        positionals: {
                            path: {
                                describe: string;
                            };
                        };
                    };
                    preview: {
                        describe: string;
                        errors: {
                            invalidPath: (path: string) => string;
                            noThemeComponents: string;
                            uploadFailed: (src: string, dest: string) => string;
                        };
                        positionals: {
                            src: string;
                            dest: string;
                        };
                        options: {
                            noSsl: string;
                            port: string;
                        };
                        initialUploadProgressBar: {
                            start: string;
                            uploading: string;
                            finish: string;
                        };
                        logs: {
                            processExited: string;
                        };
                    };
                };
            };
            app: {
                describe: string;
                subcommands: {
                    create: {
                        describe: string;
                        errors: {
                            unsupportedAssetType: (assetType: string, supportedAssetTypes: string) => string;
                            unusablePath: (path: string) => string;
                        };
                        positionals: {
                            type: string;
                            name: string;
                            dest: string;
                        };
                    };
                };
            };
            list: {
                describe: string;
                gettingPathContents: (path: string) => string;
                noFilesFoundAtPath: (path: string) => string;
                positionals: {
                    path: {
                        describe: string;
                    };
                };
            };
            module: {
                describe: string;
                subcommands: {
                    create: {
                        describe: string;
                        errors: {
                            unusablePath: (path: string) => string;
                        };
                        positionals: {
                            name: string;
                            dest: string;
                        };
                        options: {
                            moduleLabel: string;
                            reactType: string;
                            contentTypes: (contentTypes: readonly string[]) => string;
                            global: string;
                            availableForNewContent: string;
                        };
                    };
                    marketplaceValidate: {
                        describe: string;
                        errors: {
                            invalidPath: (path: string) => string;
                        };
                        logs: {
                            validatingModule: (path: string) => string;
                        };
                        results: {
                            required: string;
                            recommended: string;
                            warnings: {
                                file: (file: string) => string;
                                lineNumber: (line: string) => string;
                            };
                            noErrors: string;
                        };
                        positionals: {
                            src: string;
                        };
                    };
                };
            };
            upload: {
                describe: string;
                errors: {
                    destinationRequired: string;
                    fileIgnored: (path: string) => string;
                    invalidPath: (path: string) => string;
                    uploadFailed: (src: string, dest: string) => string;
                    someFilesFailed: (dest: string) => string;
                    deleteFailed: (path: string, accountId: number) => string;
                };
                options: {
                    options: string;
                    saveOutput: string;
                    convertFields: string;
                    clean: string;
                    force: string;
                };
                previewUrl: (previewUrl: string) => string;
                positionals: {
                    src: string;
                    dest: string;
                };
                success: {
                    fileUploaded: (src: string, dest: string, accountId: number) => string;
                    uploadComplete: (dest: string) => string;
                };
                uploading: (src: string, dest: string, accountId: number) => string;
                notUploaded: (src: string) => string;
                cleaning: (filePath: string, accountId: number) => string;
                confirmCleanUpload: (filePath: string, accountId: number) => string;
            };
            delete: {
                describe: string;
                deleted: (path: string, accountId: number) => string;
                errors: {
                    deleteFailed: (path: string, accountId: number) => string;
                };
                positionals: {
                    path: string;
                };
            };
            watch: {
                describe: string;
                errors: {
                    folderFailed: (src: string, dest: string, accountId: number) => string;
                    fileFailed: (file: string, dest: string, accountId: number) => string;
                    destinationRequired: string;
                    invalidPath: (path: string) => string;
                };
                options: {
                    disableInitial: string;
                    initialUpload: string;
                    notify: string;
                    remove: string;
                    convertFields: string;
                    saveOutput: string;
                    options: string;
                };
                positionals: {
                    src: string;
                    dest: string;
                };
            };
            fetch: {
                describe: string;
                errors: {
                    sourceRequired: string;
                };
                options: {
                    staging: {
                        describe: string;
                    };
                    assetVersion: {
                        describe: string;
                    };
                };
                positionals: {
                    dest: {
                        describe: string;
                    };
                    src: {
                        describe: string;
                    };
                };
            };
            lint: {
                issuesFound: (count: number) => string;
                groupName: (path: string) => string;
                positionals: {
                    path: {
                        describe: string;
                    };
                };
            };
            mv: {
                describe: string;
                errors: {
                    sourcePathExists: (srcPath: string, destPath: string) => string;
                    moveFailed: (srcPath: string, destPath: string, accountId: number) => string;
                };
                move: (srcPath: string, destPath: string, accountId: number) => string;
                positionals: {
                    srcPath: {
                        describe: string;
                    };
                    destPath: {
                        describe: string;
                    };
                };
            };
            lighthouseScore: {
                describe: string;
                examples: {
                    default: string;
                };
                info: {
                    promptMessage: string;
                    fetchingThemes: string;
                    generatingScore: (theme: string) => string;
                    targetDeviceNote: (target: string) => string;
                    verboseOptionNote: string;
                    pageTemplateScoreTitle: string;
                    lighthouseLinksTitle: string;
                    failedTemplatePathsTitle: string;
                    themeToCheckTitle: (themeToCheck: string, target: string) => string;
                    themeTitle: (themeToCheck: string) => string;
                    poweredByLink: string;
                };
                errors: {
                    targetOptionRequired: string;
                    invalidTargetOption: string;
                    themeNotFound: (theme: string) => string;
                    failedToFetchThemes: string;
                    failedToGetLighthouseScore: string;
                };
                options: {
                    theme: {
                        describe: string;
                    };
                    target: {
                        describe: string;
                    };
                    verbose: {
                        describe: string;
                    };
                };
            };
            getReactModule: {
                describe: string;
                selectModulePrompt: string;
                positionals: {
                    name: {
                        describe: string;
                    };
                    dest: {
                        describe: string;
                    };
                };
                success: {
                    moduleDownloaded: (moduleName: string, path: string) => string;
                };
                errors: {
                    pathExists: (path: string) => string;
                    invalidName: string;
                };
            };
            function: {
                describe: string;
                subcommands: {
                    create: {
                        describe: string;
                        errors: {
                            unusablePath: (path: string) => string;
                        };
                        positionals: {
                            name: string;
                            dest: string;
                        };
                        options: {
                            functionsFolder: string;
                            filename: string;
                            endpointMethod: string;
                            endpointPath: string;
                        };
                    };
                    logs: {
                        describe: string;
                        errors: {
                            noLogsFound: (functionPath: string, accountId: number) => string;
                        };
                        examples: {
                            default: string;
                            follow: string;
                            limit: string;
                        };
                        endpointPrompt: string;
                        gettingLogs: (latest: boolean | undefined, functionPath: string) => string;
                        options: {
                            compact: {
                                describe: string;
                            };
                            follow: {
                                describe: string;
                            };
                            latest: {
                                describe: string;
                            };
                            limit: {
                                describe: string;
                            };
                        };
                        positionals: {
                            endpoint: {
                                describe: string;
                            };
                        };
                        tailLogs: (functionPath: string, accountId: string) => string;
                    };
                    deploy: {
                        debug: {
                            startingBuildAndDeploy: (functionPath: string) => string;
                        };
                        errors: {
                            buildError: (details: string) => string;
                            noPackageJson: (functionPath: string) => string;
                            notFunctionsFolder: (functionPath: string) => string;
                        };
                        examples: {
                            default: string;
                        };
                        loading: (functionPath: string, account: string) => string;
                        loadingFailed: (functionPath: string, account: string) => string;
                        positionals: {
                            path: {
                                describe: string;
                            };
                        };
                        success: {
                            deployed: (functionPath: string, accountId: number, buildTimeSeconds: string | 0) => string;
                        };
                    };
                    list: {
                        debug: {
                            gettingFunctions: string;
                        };
                        describe: string;
                        info: {
                            noFunctions: string;
                        };
                        options: {
                            json: {
                                describe: string;
                            };
                        };
                    };
                    server: {
                        debug: {
                            startingServer: (functionPath: string) => string;
                        };
                        examples: {
                            default: string;
                        };
                        options: {
                            contact: {
                                describe: string;
                            };
                            logOutput: {
                                describe: string;
                            };
                            port: {
                                describe: string;
                            };
                            watch: {
                                describe: string;
                            };
                        };
                        positionals: {
                            path: {
                                describe: string;
                            };
                        };
                    };
                };
            };
        };
    };
    create: {
        describe: (supportedAssetTypes: string) => string;
        errors: {
            deprecatedAssetType: (assetType: string, newCommand: string, type: string) => string;
            unsupportedAssetType: (assetType: string, supportedAssetTypes: string) => string;
            unusablePath: (path: string) => string;
        };
        positionals: {
            dest: {
                describe: string;
            };
            name: {
                describe: string;
            };
            type: {
                describe: string;
            };
        };
        flags: {
            templateType: {
                describe: string;
            };
            moduleLabel: {
                describe: string;
            };
            reactType: {
                describe: string;
            };
            contentTypes: {
                describe: (contentTypes: readonly string[]) => string;
            };
            global: {
                describe: string;
            };
            availableForNewContent: {
                describe: string;
            };
            functionsFolder: {
                describe: string;
            };
            filename: {
                describe: string;
            };
            endpointMethod: {
                describe: string;
            };
            endpointPath: {
                describe: string;
            };
        };
        subcommands: {
            apiSample: {
                folderOverwritePrompt: (folderName: string) => string;
                errors: {
                    nameRequired: string;
                    noSamples: string;
                };
                info: {
                    sampleChosen: (sampleType: string, sampleLanguage: string) => string;
                };
                success: {
                    sampleCreated: (filePath: string) => string;
                };
            };
            module: {
                errors: {
                    nameRequired: string;
                };
            };
            template: {
                errors: {
                    nameRequired: string;
                };
            };
        };
    };
    customObject: {
        betaMessage: string;
        describe: string;
        seeMoreLink: string;
        subcommands: {
            schema: {
                describe: string;
            };
            create: {
                describe: string;
                errors: {
                    invalidObjectDefinition: string;
                    creationFailed: (definition: string) => string;
                };
                options: {
                    path: {
                        describe: string;
                    };
                };
                positionals: {
                    name: {
                        describe: string;
                    };
                };
                success: {
                    objectsCreated: string;
                };
                inputName: string;
                inputPath: string;
            };
            createSchema: {
                describe: string;
                errors: {
                    invalidSchema: string;
                    creationFailed: (definition: string) => string;
                };
                options: {
                    definition: {
                        describe: string;
                    };
                };
                success: {
                    schemaCreated: (accountId: string) => string;
                    schemaViewable: (url: string) => string;
                };
            };
            deleteSchema: {
                describe: string;
                errors: {
                    delete: (name: string) => string;
                };
                examples: {
                    default: string;
                };
                positionals: {
                    name: {
                        describe: string;
                    };
                };
                options: {
                    force: {
                        describe: string;
                    };
                };
                success: {
                    delete: (name: string) => string;
                };
                confirmDelete: (name: string) => string;
                deleteCancelled: (name: string) => string;
                selectSchema: string;
            };
            fetchAllSchemas: {
                describe: string;
                errors: {
                    fetch: string;
                };
                examples: {
                    default: string;
                    specifyPath: string;
                };
                positionals: {
                    dest: {
                        describe: string;
                    };
                };
                success: {
                    fetch: (path: string) => string;
                };
                inputDest: string;
            };
            fetchSchema: {
                describe: string;
                errors: {
                    fetch: (name: string) => string;
                };
                examples: {
                    default: string;
                    specifyPath: string;
                };
                positionals: {
                    dest: {
                        describe: string;
                    };
                    name: {
                        describe: string;
                    };
                };
                selectSchema: string;
                inputDest: string;
                success: {
                    save: (name: string, path: string) => string;
                    savedToPath: (path: string) => string;
                };
            };
            listSchemas: {
                describe: string;
                errors: {
                    list: string;
                };
            };
            updateSchema: {
                describe: string;
                errors: {
                    invalidSchema: string;
                    update: (definition: string) => string;
                };
                options: {
                    path: {
                        describe: string;
                    };
                };
                positionals: {
                    name: {
                        describe: string;
                    };
                };
                success: {
                    update: (accountId: string) => string;
                    viewAtUrl: (url: string) => string;
                };
                selectSchema: string;
            };
        };
    };
    doctor: {
        describe: string;
        options: {
            outputDir: string;
        };
        errors: {
            generatingDiagnosis: string;
            unableToWriteOutputFile: (file: string, errorMessage: string) => string;
        };
        outputWritten: (filename: string) => string;
    };
    upgrade: {
        describe: string;
        options: {
            version: string;
            force: string;
            beta: string;
        };
        alreadyLatest: (version: string, beta?: boolean) => string;
        alreadyOnVersion: (current: string) => string;
        autoUpgradeNotAvailable: (version: string) => string;
        confirmPrompt: (current: string, version: string) => string;
        cancelled: string;
        installing: (version: string) => string;
        success: (version: string) => string;
        autoUpgradeMessage: string;
        errors: {
            unableToDetermineLatestVersion: string;
            installFailed: string;
            generic: string;
        };
    };
    filemanager: {
        describe: string;
        subcommands: {
            fetch: {
                describe: string;
                errors: {
                    sourceRequired: string;
                };
                options: {
                    includeArchived: {
                        describe: string;
                    };
                };
                positionals: {
                    dest: {
                        describe: string;
                    };
                    src: {
                        describe: string;
                    };
                };
            };
            upload: {
                describe: string;
                errors: {
                    destinationRequired: string;
                    fileIgnored: (path: string) => string;
                    invalidPath: (path: string) => string;
                    upload: (src: string, dest: string) => string;
                    uploadingFailed: string;
                };
                logs: {
                    uploading: (src: string, dest: string, accountId: number) => string;
                };
                positionals: {
                    dest: {
                        describe: string;
                    };
                    src: {
                        describe: string;
                    };
                };
                success: {
                    upload: (src: string, dest: string, accountId: number) => string;
                    uploadComplete: (dest: string) => string;
                };
            };
        };
    };
    hubdb: {
        describe: string;
        subcommands: {
            clear: {
                describe: string;
                logs: {
                    removedRows: (deletedRowCount: number, tableId: number) => string;
                    rowCount: (tableId: number, rowCount: number) => string;
                    tableEmpty: (tableId: number) => string;
                };
                positionals: {
                    tableId: {
                        describe: string;
                    };
                };
            };
            create: {
                describe: string;
                enterPath: string;
                errors: {
                    create: (filePath: string) => string;
                    pathRequired: string;
                    invalidCharacters: string;
                };
                options: {
                    path: {
                        describe: string;
                    };
                };
                success: {
                    create: (tableId: string, accountId: number, rowCount: number) => string;
                };
            };
            delete: {
                describe: string;
                shouldDeleteTable: (tableId: number) => string;
                errors: {
                    delete: (tableId: number | "") => string;
                };
                positionals: {
                    tableId: {
                        describe: string;
                    };
                };
                options: {
                    force: {
                        describe: string;
                    };
                };
                success: {
                    delete: (tableId: string, accountId: number) => string;
                };
            };
            fetch: {
                describe: string;
                positionals: {
                    dest: {
                        describe: string;
                    };
                    tableId: {
                        describe: string;
                    };
                };
                success: {
                    fetch: (tableId: number, path: string) => string;
                };
            };
            list: {
                tables: string;
                describe: string;
                labels: {
                    label: string;
                    id: string;
                    name: string;
                    columns: string;
                    rows: string;
                };
                success: (accountId: number) => string;
                noTables: (accountId: number) => string;
                tablesDisplayed: (displayed: number, total: number, truncated?: number) => string;
                viewTablesLink: (baseUrl: string, accountId: number) => string;
            };
        };
    };
    init: {
        describe: string;
        verboseDescribe: (configName: string, command: string, authMethod: string) => string;
        options: {
            authType: {
                describe: string;
                defaultDescription: (authMethod: string) => string;
            };
            account: {
                describe: string;
            };
            useHiddenConfig: {
                describe: string;
            };
        };
        success: {
            configFileCreated: (configPath: string) => string;
            configFileUpdated: (authType: string, account: string | number) => string;
        };
        logs: {
            updateConfig: string;
        };
        errors: {
            invalidAccountIdProvided: string;
            configFileExists: (configPath: string) => string;
            bothConfigFilesNotAllowed: (path: string) => string;
            globalConfigFileExists: string;
        };
    };
    mcp: {
        describe: string;
        setup: {
            describe: string;
            installingDocSearch: string;
            codex: string;
            claudeCode: string;
            cursor: string;
            gemini: string;
            windsurf: string;
            vsCode: string;
            args: {
                client: string;
                docsSearch: string;
            };
            success: (derivedTargets: string[]) => string;
            errors: {
                errorParsingJsonFIle: (filename: string, errorMessage: string) => string;
            };
            spinners: {
                failedToConfigure: string;
                configuringClaudeCode: string;
                configuredClaudeCode: string;
                claudeCodeNotFound: string;
                claudeCodeInstallFailed: string;
                configuringCodex: string;
                configuredCodex: string;
                codexNotFound: string;
                codexInstallFailed: string;
                configuringCursor: string;
                cursorNotFound: string;
                failedToConfigureCursor: string;
                configuredCursor: string;
                configuringGemini: string;
                configuredGemini: string;
                geminiNotFound: string;
                geminiInstallFailed: string;
                alreadyInstalled: string;
                configuringWindsurf: string;
                windsurfNotFound: string;
                failedToConfigureWindsurf: string;
                configuredWindsurf: string;
                configuringVsCode: string;
                failedToConfigureVsCode: string;
                configuredVsCode: string;
                vsCodeNotFound: string;
            };
            prompts: {
                targets: string;
                targetsRequired: string;
                standaloneMode: string;
                cliVersion: string;
            };
        };
        start: {
            errors: {
                serverFileNotFound: (serverPath: string) => string;
                failedToStart: string;
            };
            startingServer: string;
            stopInstructions: string;
            stoppedSuccessfully: string;
            shuttingDown: string;
        };
    };
    api: {
        describe: string;
        verboseDescribe: string;
        positionals: {
            endpoint: {
                describe: string;
            };
        };
        options: {
            method: {
                describe: string;
            };
            data: {
                describe: string;
            };
        };
        requestLog: (method: string, url: string) => string;
        requestBodyLog: (body: string) => string;
        responseLog: string;
        errors: {
            invalidJson: string;
            statusLine: (status: number, statusText: string) => string;
        };
    };
    open: {
        describe: string;
        options: {
            list: {
                describe: string;
            };
        };
        positionals: {
            shortcut: {
                describe: string;
            };
        };
        selectLink: string;
    };
    project: {
        describe: string;
        profile: {
            describe: string;
            verboseDescribe: string;
            add: {
                describe: string;
                verboseDescribe: string;
                example: string;
                logs: {
                    copyExistingProfile: (profileName: string) => string;
                    copyExistingProfiles: string;
                    profileAdded: (profileName: string) => string;
                };
                prompts: {
                    namePrompt: string;
                    emptyName: string;
                    targetAccountPrompt: string;
                    copyExistingProfilePrompt: string;
                    copyExistingProfilePromptEmpty: string;
                    invalidProfileName: string;
                };
                warnings: {
                    duplicateTargetAccount: (targetAccountId: number) => string;
                };
                errors: {
                    noProjectConfig: string;
                    unsupportedPlatformVersion: string;
                    profileExists: (profileName: string) => string;
                    invalidTargetAccount: string;
                    noAccountsConfigured: string;
                    failedToLoadProfile: (profileName: string) => string;
                    failedToCreateProfile: string;
                };
                positionals: {
                    name: string;
                };
                options: {
                    targetAccount: string;
                };
            };
            delete: {
                describe: string;
                example: string;
                logs: {
                    profileDeleted: (profileName: string) => string;
                    deletedProject: (accountId: number) => string;
                    didNotDeleteProject: (accountId: number) => string;
                };
                debug: {
                    failedToLoadProfile: (profileName: string) => string;
                };
                prompts: {
                    deleteProfilePrompt: string;
                    deleteProjectPrompt: (accountId: number) => string;
                };
                errors: {
                    noProjectConfig: string;
                    unsupportedPlatformVersion: string;
                    noProfileFound: (profileName: string) => string;
                    noProfilesFound: string;
                    failedToDeleteProfile: (profileName: string) => string;
                    failedToDeleteProject: (accountId: number) => string;
                };
                positionals: {
                    name: string;
                };
            };
        };
        dev: {
            describe: string;
            logs: {
                header: string;
                placeholderAccountSelection: string;
                accountTypeInformation: string;
                learnMoreMessageV2: string;
                learnMoreMessageLegacy: string;
                profileProjectAccountExplanation: (accountId: number, profileName: string) => string;
                defaultProjectAccountExplanation: (accountId: number) => string;
                projectAccountFlagExplanation: (accountId: number) => string;
                accountFlagExplanation: (accountId: number) => string;
                defaultSandboxOrDevTestTestingAccountExplanation: (accountId: number) => string;
                testingAccountFlagExplanation: (accountId: number) => string;
            };
            errors: {
                noProjectConfig: string;
                noAccount: (accountId: number) => string;
                noAccountsInConfig: string;
                invalidProjectComponents: string;
                noRunnableComponents: string;
                accountNotCombined: string;
                unsupportedAccountFlagLegacy: string;
                unsupportedAccountFlagV2: string;
                localDevAlreadyRunning: string;
            };
            examples: {
                default: string;
            };
            prompts: {
                selectProfile: string;
            };
            options: {
                profile: string;
                projectAccount: string;
                testingAccount: string;
                account: string;
                port: string;
            };
        };
        create: {
            describe: string;
            errors: {
                failedToDownloadProject: string;
                invalidTemplateSource: string;
                failedToFetchProjectList: string;
                cannotNestProjects: (projectDir: string) => string;
            };
            warnings: {
                betaPlatformVersion: (platformVersion: string) => string;
            };
            logs: {
                success: (projectName: string, projectDest: string) => string;
            };
            creatingComponent: (isProjectEmpty: boolean, projectName: string) => string;
            success: (isProjectEmpty: boolean, projectName: string) => string;
            failure: (isProjectEmpty: boolean, projectName: string) => string;
            prompts: {
                parentComponents: string;
                emptyProject: string;
                app: string;
            };
            examples: {
                default: string;
                templateSource: string;
            };
            options: {
                dest: {
                    describe: string;
                };
                name: {
                    describe: string;
                };
                template: {
                    describe: string;
                };
                templateSource: {
                    describe: string;
                };
                platformVersion: {
                    describe: string;
                };
                projectBase: {
                    describe: string;
                };
                distribution: {
                    describe: string;
                };
                auth: {
                    describe: string;
                };
                features: {
                    describe: string;
                };
            };
        };
        migrateApp: {
            describe: string;
            examples: {
                default: string;
            };
            options: {
                appId: {
                    describe: string;
                };
                dest: {
                    describe: string;
                };
                name: {
                    describe: string;
                };
            };
            header: string;
            migrationStatus: {
                inProgress: () => string;
                success: () => string;
                done: () => string;
                failure: () => string;
            };
            warning: {
                title: string;
                projectConversion: string;
                appConfig: string;
                buildAndDeploy: string;
                existingApps: string;
                copyApp: string;
            };
            migrationInterrupted: string;
            createAppPrompt: string;
            projectDetailsLink: string;
            errors: {
                noAppsForProject: (projectName: string) => string;
                noAccountConfig: string;
                projectAlreadyExists: (projectName: string) => string;
                invalidApp: (appId: number) => string;
                migrationFailed: string;
                notAllowedWithinProject: string;
            };
        };
        migrate: {
            preamble: (platformVersion: string) => string;
            describe: string;
            errors: {
                noProjectConfig: (command: string) => string;
                noThemeMigrationAccess: (accountId?: number) => string;
            };
            examples: {
                default: string;
            };
        };
        cloneApp: {
            describe: string;
            examples: {
                default: string;
            };
            options: {
                appId: {
                    describe: string;
                };
                dest: {
                    describe: string;
                };
            };
            cloneStatus: {
                inProgress: string;
                done: string;
                success: (dest: string) => string;
                failure: string;
            };
            errors: {
                invalidAccountTypeTitle: () => string;
                invalidAccountTypeDescription: (useCommand: string, authCommand: string) => string;
                couldNotWriteConfigPath: (configPath: string) => string;
                noAccountConfig: (accountId: number) => string;
            };
        };
        add: {
            describe: string;
            options: {
                name: {
                    describe: string;
                };
                type: {
                    describe: string;
                };
                distribution: {
                    describe: string;
                };
                auth: {
                    describe: string;
                };
                features: {
                    describe: string;
                };
            };
            creatingComponent: (projectName: string) => string;
            success: (projectName: string) => string;
            failure: (projectName: string) => string;
            error: {
                failedToDownloadComponent: string;
                invalidComponentType: (componentType: string) => string;
                maxExceeded: (maxCount: number) => string;
                authTypeNotAllowed: (authType: string) => string;
                distributionNotAllowed: (dist: string) => string;
                portalDoesNotHaveAccessToThisFeature: () => string;
                locationInProject: string;
                failedToFetchComponentList: string;
                projectContainsPublicApp: string;
            };
            examples: {
                default: string;
                withFlags: string;
            };
        };
        deploy: {
            describe: string;
            deployBuildIdPrompt: string;
            profileMessage: (profileName: string, accountId: number) => string;
            debug: {
                deploying: (path: string) => string;
            };
            errors: {
                deploy: string;
                noBuilds: string;
                noBuildId: string;
                projectNotFound: (accountId: number, projectName: string) => string;
                buildIdDoesNotExist: (accountId: number, buildId: number, projectName: string) => string;
                buildAlreadyDeployed: (accountId: number, buildId: number, projectName: string) => string;
                deployContainsRemovals: (componentName: string) => string;
                deployBlockedHeader: string;
                deployWarningsHeader: string;
                deployIssueComponentGeneric: (uid: string, componentTypeName: string) => string;
                deployIssueComponentWarning: (uid: string, componentTypeName: string, message: string) => string;
            };
            examples: {
                default: string;
                withOptions: string;
                withProfile: string;
            };
            options: {
                build: string;
                project: string;
                profile: string;
                force: string;
                deployLatestBuild: string;
            };
        };
        release: {
            describe: string;
            create: {
                describe: string;
                verboseDescribe: string;
                confirmPrompt: (projectName: string, buildId: number) => string;
                success: (releaseTag: string, buildId: number) => string;
                cancelled: string;
                errors: {
                    projectNotFound: (accountId: number, projectName: string) => string;
                    noDeployedBuild: string;
                    buildNotFound: (buildId: number, projectName: string) => string;
                    buildNotDeployed: (buildId: number) => string;
                };
                options: {
                    build: string;
                    force: string;
                };
                examples: {
                    default: string;
                    withBuild: string;
                };
            };
            list: {
                describe: string;
                verboseDescribe: string;
                noReleases: string;
                showingReleases: (count: number, projectName: string) => string;
                continueOrExitPrompt: string;
                errors: {
                    projectNotFound: (accountId: number, projectName: string) => string;
                };
                options: {
                    limit: string;
                };
                examples: {
                    default: string;
                    withLimit: string;
                };
            };
            info: {
                describe: string;
                verboseDescribe: string;
                releaseDetails: (releaseTag: string, projectName: string) => string;
                components: string;
                noComponents: string;
                moreReleasesHint: string;
                selectRelease: (projectName: string) => string;
                errors: {
                    releaseNotFound: (releaseTag: string, projectName: string) => string;
                    noReleases: string;
                };
                options: {
                    tag: string;
                };
                examples: {
                    default: string;
                    json: string;
                };
            };
        };
        listBuilds: {
            describe: string;
            continueOrExitPrompt: string;
            viewAllBuildsLink: string;
            showingNextBuilds: (count: number, projectName: string) => string;
            showingRecentBuilds: (count: number, projectName: string, viewAllBuildsLink: string) => string;
            errors: {
                noBuilds: string;
                projectNotFound: (projectName: string) => string;
            };
            options: {
                project: {
                    describe: string;
                };
                limit: {
                    describe: string;
                };
            };
            examples: {
                default: string;
            };
        };
        logs: {
            describe: string;
            errors: {
                noProjectConfig: string;
                failedToFetchProjectDetails: string;
                noFunctionsLinkText: string;
                noFunctionsInProject: string;
                noFunctionWithName: (name: string) => string;
                functionNameRequired: string;
                functionNotDeployed: (name: string) => string;
                projectLogsManagerNotInitialized: string;
                noDeployedBuild: string;
                generic: string;
            };
            logs: {
                showingLogs: string;
                hubspotLogsDirectLink: (url: string) => string;
                noLogsFound: (name: string) => string;
            };
            table: {
                accountHeader: string;
                functionHeader: string;
                endpointHeader: string;
            };
            examples: {
                default: string;
                withOptions: string;
            };
            options: {
                app: {
                    describe: string;
                };
                compact: {
                    describe: string;
                };
                tail: {
                    describe: string;
                };
                latest: {
                    describe: string;
                };
                limit: {
                    describe: string;
                };
                function: {
                    describe: string;
                };
            };
        };
        upload: {
            describe: string;
            examples: {
                default: string;
                withProfile: string;
                withPreview: string;
            };
            logs: {
                buildSucceeded: (buildId: number) => string;
                readyToGoLive: string;
                runCommand: (command: string) => string;
                autoDeployDisabled: (deployCommand: string) => string;
            };
            errors: {
                noProjectConfig: string;
                projectLockedError: string;
                previewRequiresTarget: string;
                targetRequiresPreview: string;
            };
            options: {
                forceCreate: {
                    describe: string;
                };
                message: {
                    describe: string;
                };
                profile: {
                    describe: string;
                };
                skipNpmAudit: {
                    describe: string;
                };
                preview: {
                    describe: string;
                };
                target: {
                    describe: string;
                };
            };
        };
        watch: {
            describe: string;
            examples: {
                default: string;
            };
            logs: {
                processExited: string;
                watchCancelledFromUi: string;
                resuming: string;
                uploadSucceeded: (remotePath: string, filePath: string) => string;
                deleteFileSucceeded: (remotePath: string) => string;
                deleteFolderSucceeded: (remotePath: string) => string;
                watching: (projectDir: string) => string;
                previousStagingBuildCancelled: string;
            };
            options: {
                initialUpload: {
                    describe: string;
                };
            };
            debug: {
                pause: string;
                buildStarted: string;
                extensionNotAllowed: (filePath: string) => string;
                ignored: (filePath: string) => string;
                uploading: (filePath: string, remotePath: string) => string;
                attemptNewBuild: string;
                fileAlreadyQueued: (filePath: string) => string;
            };
            errors: {
                projectConfigNotFound: string;
                projectLockedError: string;
                uploadFailed: (remotePath: string, filePath: string) => string;
                deleteFileFailed: (remotePath: string) => string;
                deleteFolderFailed: (remotePath: string) => string;
                v2ApiError: (platformVersion: string) => string;
            };
        };
        download: {
            describe: string;
            examples: {
                default: string;
            };
            logs: {
                downloadCancelled: string;
                downloadSucceeded: (buildId: number, projectName: string) => string;
            };
            errors: {
                downloadFailed: string;
                projectNotFound: (projectName: string, accountId: string) => string;
                noBuildIdToDownload: string;
            };
            warnings: {
                cannotDownloadWithinProject: string;
            };
            options: {
                build: {
                    describe: string;
                };
                project: {
                    describe: string;
                };
                dest: {
                    describe: string;
                };
            };
        };
        open: {
            describe: string;
            options: {
                project: {
                    describe: string;
                };
            };
            examples: {
                default: string;
            };
            success: (projectName: string) => string;
        };
        feedback: {
            describe: string;
            openPrompt: string;
            success: (url: string) => string;
            error: (url: string) => string;
        };
        installDeps: {
            help: {
                describe: string;
                installAppDepsExample: string;
                addDepToSubComponentExample: string;
            };
            installLocationPrompt: string;
            installLocationPromptRequired: string;
            installingDependencies: (directory: string) => string;
            installationSuccessful: (directory: string) => string;
            addingDependenciesToLocation: (dependencies: string, directory: string) => string;
            installingDependenciesFailed: (directory: string) => string;
            noProjectConfig: string;
            noPackageJsonInProject: (projectName: string) => string;
            packageManagerNotInstalled: (packageManager: string) => string;
        };
        lint: {
            help: {
                describe: string;
                lintProjectExample: string;
                lintProjectWithInstallExample: string;
                lintProjectWithoutInstallExample: string;
                installMissingDeps: string;
            };
            loading: {
                checking: string;
                creatingConfig: string;
                addingLintScripts: string;
                linting: string;
            };
            noProjectConfig: string;
            failedToReadPackageJson: (packageJsonPath: string) => string;
            installLintPackagesPrompt: (directories: string[], missingPackages: string[]) => string;
            skippingDirectoriesWarning: (directories: string[]) => string;
            deprecatedEslintConfigWarning: (details: {
                path: string;
                files: string[];
            }[]) => string;
            createEslintConfigPrompt: (directories: string[]) => string;
            eslintConfigCreated: (configPath: string) => string;
            createEslintConfigRequiresV2Platform: (platformVersion?: string | null) => string;
            failedToFetchRemoteEslintConfig: (platformVersion: string) => string;
            failedToCreateEslintConfig: (configPath: string) => string;
            eslintConfigRequired: string;
            lintScriptsAdded: (scriptNames: string[], packageJsonPath: string) => string;
            failedToAddLintScripts: (packageJsonPath: string) => string;
        };
        updateDeps: {
            help: {
                describe: string;
                updateAppDepsExample: string;
                updateDepToSubComponentExample: string;
            };
            installLocationPrompt: string;
            installLocationPromptRequired: string;
            updatingDependencies: (directory: string) => string;
            updateSuccessful: (directory: string) => string;
            updatingDependenciesToLocation: (dependencies: string, directory: string) => string;
            updatingDependenciesFailed: (directory: string) => string;
            noProjectConfig: string;
            noPackageJsonInProject: (projectName: string) => string;
            packageManagerNotInstalled: (packageManager: string) => string;
        };
        validate: {
            describe: string;
            mustBeRanWithinAProject: string;
            badVersion: string;
            examples: {
                default: string;
                withProfile: string;
            };
            success: (projectName: string) => string;
            failure: (projectName: string, profileName?: string) => string;
            failureWithProfile: (profileName: string) => string;
            spinners: {
                validatingProfile: (profileName: string) => string;
                profileValidationFailed: (profileName: string) => string;
                profileValidationSucceeded: (profileName: string) => string;
                invalidWithProfile: (profileName: string) => string;
                validatingAllProfiles: string;
                allProfilesValidationSucceeded: string;
                allProfilesValidationFailed: string;
            };
            options: {
                profile: {
                    describe: string;
                };
            };
        };
        list: {
            describe: string;
            projects: string;
            labels: {
                name: string;
                platformVersion: string;
            };
            errors: {
                noProjectsFound: (accountId: number) => string;
            };
        };
        info: {
            describe: string;
            verboseDescribe: string;
            project: {
                title: (name: string) => string;
                platformVersion: (version: string) => string;
                id: (id: number) => string;
                deployedBuild: (buildId: number) => string;
                autoDeploy: (enabled: boolean) => string;
            };
            app: {
                title: string;
                name: (name: string) => string;
                id: (id: number) => string;
                uid: (uid: string) => string;
                authType: (authType: string) => string;
                distributionType: (distributionType: string) => string;
            };
            examples: {
                default: string;
                json: string;
            };
            viewProjectLink: string;
            componentsHeader: string;
            labels: {
                type: string;
                uid: string;
            };
            errors: {
                noProjectConfig: string;
                projectNotFound: (projectName: string, accountId: number) => string;
                noDeployedBuild: string;
                unsupportedPlatformVersion: (platformVersion: string) => string;
            };
        };
        delete: {
            describe: string;
            verboseDescribe: string;
            warnings: {
                irreversibleTitle: string;
                irreversible: string;
            };
            prompts: {
                selectProject: (accountId: number) => string;
                confirmDelete: (projectName: string, accountId: number) => string;
                validation: {
                    projectRequired: string;
                };
            };
            logs: {
                deleting: (projectName: string) => string;
                deleted: (projectName: string, accountId: number) => string;
                cancelled: string;
                componentsToDeleteUnified: (components: {
                    componentType: string;
                    componentId: string;
                }[]) => string;
                componentsToDeleteLegacy: (components: string[]) => string;
                deletingComponents: (projectName: string) => string;
                componentsDeleted: (projectName: string) => string;
                unableToDetermineIfComponentsWereDeleted: (projectName: string) => string;
                installWarning: (installCount: number) => string;
                installCountUnknown: string;
            };
            errors: {
                noProjectsFound: (accountId: number) => string;
                projectNotFound: (projectName: string, accountId: number) => string;
                deleteFailed: (projectName: string) => string;
                cannotDelete: (projectName: string, reason: string) => string;
                noPlatformVersion: string;
                componentDeletionFailed: (projectName: string) => string;
            };
            options: {
                project: string;
                force: string;
            };
        };
        installStatus: {
            describe: string;
            examples: {
                default: string;
                json: string;
            };
            errors: {
                noProjectConfig: string;
                unsupportedPlatformVersion: (platformVersion: string) => string;
                failedToParseProject: string;
                noAppInProject: string;
                unsupportedAuthType: (authType: string) => string;
            };
            success: {
                installed: (appName: string, accountId: number) => string;
                installedWithOutdatedScopes: (appName: string, accountId: number) => string;
            };
            notInstalled: (appName: string, accountId: number) => string;
        };
    };
    sandbox: {
        describe: string;
        subcommands: {
            create: {
                describe: string;
                failure: {
                    noAccountConfig: (accountId: number) => string;
                    invalidAccountType: (accountType: string, accountName: string) => string;
                    noSandboxAccountConfig: (accountId: number) => string;
                    optionMissing: {
                        type: string;
                        name: string;
                    };
                };
                options: {
                    force: {
                        describe: string;
                    };
                    name: {
                        describe: string;
                    };
                    type: {
                        describe: string;
                    };
                };
                examples: {
                    default: string;
                };
                developer: {
                    loading: {
                        add: (accountName: string) => string;
                        fail: (accountName: string) => string;
                        succeed: (accountName: string, accountId: string) => string;
                    };
                    success: {
                        configFileUpdated: (accountName: string, authType: string) => string;
                    };
                    failure: {
                        invalidUser: (accountName: string, parentAccountName: string) => string;
                        limit: (accountName: string, limit: string) => string;
                        alreadyInConfig: (accountName: string, limit: string) => string;
                        scopes: {
                            message: string;
                            instructions: (accountName: string, url: string) => string;
                        };
                    };
                };
                standard: {
                    loading: {
                        add: (accountName: string) => string;
                        fail: (accountName: string) => string;
                        succeed: (accountName: string, accountId: string) => string;
                    };
                    success: {
                        configFileUpdated: (accountName: string, authType: string) => string;
                    };
                    failure: {
                        invalidUser: (accountName: string, parentAccountName: string) => string;
                        limit: (accountName: string, limit: string) => string;
                        alreadyInConfig: (accountName: string, limit: string) => string;
                        scopes: {
                            message: string;
                            instructions: (accountName: string, url: string) => string;
                        };
                    };
                };
            };
            delete: {
                describe: string;
                debug: {
                    deleting: (account: number) => string;
                    error: string;
                };
                examples: {
                    default: string;
                };
                confirm: (account: number) => string;
                defaultAccountWarning: (account: number) => string;
                success: {
                    delete: (account: string, sandboxHubId: number) => string;
                    deleteDefault: (account: string, sandboxHubId: number) => string;
                    configFileUpdated: (account: string, configFilename: string) => string;
                };
                failure: {
                    invalidUser: (account: number, parentAccount: number) => string;
                    noAccount: string;
                    noSandboxAccounts: string;
                    noSandboxAccountId: string;
                    noParentAccount: string;
                    objectNotFound: (account: number) => string;
                    noParentPortalAvailable: (command: string, url: string) => string;
                    invalidKey: (account: number | null | undefined) => string;
                };
                options: {
                    force: {
                        describe: string;
                    };
                    account: {
                        describe: string;
                    };
                };
            };
        };
        sync: {
            loading: {
                add: (accountName: string) => string;
                fail: (accountName: string) => string;
                succeed: (accountName: string) => string;
            };
            success: {
                configFileUpdated: (accountName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (accountName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (accountName: string, url: string) => string;
                };
            };
            confirm: {
                syncContactRecords: {
                    standard: string;
                    developer: string;
                };
            };
        };
    };
    app: {
        describe: string;
        subcommands: {
            secret: {
                describe: string;
                subcommands: {
                    add: {
                        describe: string;
                        positionals: {
                            name: string;
                        };
                        errors: {
                            noApps: string;
                        };
                        options: {
                            app: string;
                        };
                        example: string;
                        success: (appName: string, secretName: string) => string;
                    };
                    delete: {
                        describe: string;
                        confirmDelete: (appName: string, secretName: string) => string;
                        deleteCanceled: string;
                        selectSecret: string;
                        errors: {
                            noSecrets: string;
                        };
                        positionals: {
                            name: string;
                        };
                        options: {
                            app: string;
                            force: string;
                        };
                        example: string;
                        success: (appName: string, secretName: string) => string;
                    };
                    list: {
                        describe: string;
                        example: string;
                        options: {
                            app: string;
                        };
                        errors: {
                            noSecrets: string;
                        };
                        success: (appName: string) => string;
                    };
                    update: {
                        describe: string;
                        selectSecret: string;
                        errors: {
                            noSecrets: string;
                        };
                        positionals: {
                            name: string;
                        };
                        options: {
                            app: string;
                        };
                        example: string;
                        success: (appName: string, secretName: string) => string;
                    };
                };
            };
        };
    };
    secret: {
        describe: string;
        subcommands: {
            add: {
                describe: string;
                errors: {
                    add: (secretName: string) => string;
                    alreadyExists: (secretName: string) => string;
                };
                positionals: {
                    name: {
                        describe: string;
                    };
                };
                success: {
                    add: (secretName: string, accountId: number) => string;
                };
            };
            delete: {
                describe: string;
                selectSecret: string;
                deleteCanceled: string;
                confirmDelete: (secretName: string) => string;
                errors: {
                    delete: (secretName: string) => string;
                    noSecret: (secretName: string) => string;
                };
                positionals: {
                    name: {
                        describe: string;
                    };
                };
                success: {
                    delete: (secretName: string, accountId: number) => string;
                };
            };
            list: {
                describe: string;
                errors: {
                    list: string;
                };
                groupLabel: (accountIdentifier: string) => string;
            };
            update: {
                describe: string;
                selectSecret: string;
                errors: {
                    update: (secretName: string) => string;
                    noSecret: (secretName: string) => string;
                };
                positionals: {
                    name: {
                        describe: string;
                    };
                };
                success: {
                    update: (secretName: string, accountId: number) => string;
                    updateExplanation: string;
                };
            };
        };
    };
    convertFields: {
        describe: string;
        positionals: {
            src: {
                describe: string;
            };
        };
        options: {
            options: {
                describe: string;
            };
        };
        errors: {
            invalidPath: (path: string) => string;
            missingSrc: string;
        };
    };
    testAccount: {
        describe: string;
        subcommands: {
            importData: {
                describe: string;
                options: {
                    skipConfirm: {
                        describe: string;
                    };
                    filePath: {
                        describe: string;
                    };
                };
            };
        };
        create: {
            describe: string;
            configPathPrompt: string;
            createTestAccountFromConfigPrompt: string;
            createFromConfigOption: string;
            createFromScratchOption: string;
            errors: {
                configFileNotFound: (configPath: string) => string;
                configFileParseFailed: (configPath: string) => string;
                saveAccountToConfigFailure: (accountName: string) => string;
            };
            polling: {
                start: (testAccountName: string) => string;
                syncing: string;
                success: (testAccountName: string, testAccountId: number, parentAccountId: number) => string;
                createFailure: string;
            };
            options: {
                configPath: string;
                accountName: string;
                description: string;
                marketingLevel: string;
                opsLevel: string;
                serviceLevel: string;
                salesLevel: string;
                contentLevel: string;
                commerceLevel: string;
            };
            example: (configPath: string) => string;
            examples: {
                withAllHubsEnterprise: string;
                withSpecificHubLevels: string;
            };
            savedAccountNameDiffers: (originalName: string, savedName: string) => string;
        };
        createConfig: {
            describe: string;
            pathPrompt: string;
            errors: {
                pathError: string;
                pathFormatError: string;
                failedToCreate: string;
                pathExistsError: string;
            };
            success: {
                configFileCreated: (path: string) => string;
            };
            options: {
                name: string;
                description: string;
                path: string;
            };
            example: (name: string) => string;
        };
        delete: {
            describe: string;
            pathPrompt: string;
            info: {
                deletionCanceled: string;
                accountNotFoundWithId: (id: number) => string;
                replaceDefaultAccount: (testAccountId: number, parentAccountName: string) => string;
            };
            prompts: {
                selectTestAccounts: string;
                confirmDeletion: string;
            };
            errors: {
                failedToDelete: (testAccountToDelete: number) => string;
                failedToSelectAccount: string;
                noAccountsToDelete: (accountId: number) => string;
                failedToDeleteFromConfig: (testAccountToDelete: number) => string;
                failedToFetchTestAccounts: string;
                testAccountNotFound: (nameOrId: string | number | null) => string;
                parentAccountNotFound: (testAccountId: number) => string;
            };
            success: {
                testAccountDeletedFromHubSpot: (testAccountToDelete: number) => string;
                testAccountDeletedFromConfig: (accountId: number) => string;
            };
            options: {
                name: string;
                id: string;
                force: string;
            };
            examples: {
                withPositionalID: (testAccountToDelete: number) => string;
                withPositionalName: (testAccountToDelete: string) => string;
                withID: (testAccountToDelete: number) => string;
                withName: (testAccountToDelete: string) => string;
                withoutId: string;
            };
        };
    };
    secrets: {
        add: {
            loading: {
                add: (secretName: string) => string;
                fail: (secretName: string) => string;
                succeed: (secretName: string) => string;
            };
            success: {
                configFileUpdated: (secretName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (secretName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (secretName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (secretName: string) => string;
                fail: (secretName: string) => string;
                succeed: (secretName: string) => string;
            };
            success: {
                configFileUpdated: (secretName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (secretName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (secretName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverless: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionLogs: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionMetrics: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionSettings: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionVersions: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionWebhooks: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionWebhookSubscriptions: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionWebhookSubscriptionEvents: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionWebhookSubscriptionEventTypes: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
    serverlessFunctionWebhookSubscriptionEventTypeOptions: {
        add: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        delete: {
            loading: {
                add: (functionName: string) => string;
                fail: (functionName: string) => string;
                succeed: (functionName: string) => string;
            };
            success: {
                configFileUpdated: (functionName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (functionName: string, parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (functionName: string, url: string) => string;
                };
            };
        };
        list: {
            loading: {
                add: () => string;
                fail: () => string;
                succeed: () => string;
            };
            success: {
                configFileUpdated: (authType: string) => string;
            };
            failure: {
                invalidUser: (parentAccountName: string) => string;
                scopes: {
                    message: string;
                    instructions: (url: string) => string;
                };
            };
        };
    };
};
export declare const lib: {
    linkedDirectory: {
        warning: (action: string, settingsPath: string) => string;
    };
    parsing: {
        unableToParseStringToNumber: string;
    };
    configMiddleWare: {
        invalidAccountIdEnvironmentVariable: string;
    };
    process: {
        exitDebug: (signal: string) => string;
    };
    handlerLogFile: {
        saved: (filePath: string) => string;
    };
    DevServerManager: {
        portConflict: (port: string) => string;
        notInitialized: string;
        noCompatibleComponents: (serverKey: string) => string;
    };
    LocalDevManager: {
        appNotFound: (accountId: number, appUid: string | undefined) => string;
        failedToInitialize: string;
        noDeployedBuild: (projectName: string, accountIdentifier: string, uploadCommand: string) => string;
        noComponents: string;
        headerMessage: string;
        learnMoreLocalDevServer: string;
        running: (projectName: string, accountIdentifier: string) => string;
        quitHelper: string;
        viewProjectLink: (name: string, accountId: number) => string;
        viewLocalDevUILink: (accountId: number, showWelcomeScreen: boolean) => string;
        localDevUIAutoMessage: (accountId: number, showWelcomeScreen: boolean) => string;
        viewTestAccountLink: string;
        exitingStart: string;
        exitingSucceed: string;
        exitingFail: string;
        missingUid: string;
        uploadWarning: {
            appLabel: string;
            uiExtensionLabel: string;
            missingComponents: (missingComponents: string) => string;
            defaultWarning: string;
            defaultPublicAppWarning: (installCount: number, installText: string) => string;
            header: (warning: string) => string;
            instructionsHeader: string;
            stopDev: string;
            runUpload: (command: string) => string;
            restartDev: string;
            pushToGithub: string;
            defaultMarketplaceAppWarning: (installCount: number, accountText: string) => string;
        };
        activeInstallWarning: {
            installCount: (appName: string, installCount: number) => string;
            explanation: string;
            confirmation: string;
            confirmationPrompt: string;
        };
        devServer: {
            cleanupError: (message: string) => string;
            setupError: (message: string) => string;
            startError: (message: string) => string;
            fileChangeError: (message: string) => string;
        };
        devSession: {
            registrationError: (message: string) => string;
            missingSessionIdError: string;
            heartbeatError: (message: string) => string;
            deletionError: (message: string) => string;
        };
    };
    AppDevModeInterface: {
        autoInstallStaticAuthApp: {
            installing: (appName: string, targetTestAccountId: number) => string;
            success: (appName: string, targetTestAccountId: number) => string;
            error: (appName: string, targetTestAccountId: number) => string;
        };
        defaultMarketplaceAppWarning: (installCount: number) => string;
        autoInstallDeclined: string;
        autoInstallSuccess: (appName: string, targetTestAccountId: number) => string;
        fetchAppData: {
            checking: (appName: string) => string;
            success: (appName: string, accountId: number) => string;
            notInstalled: (appName: string, accountId: number) => string;
            activeInstallations: (appName: string, installCount: number) => string;
            error: string;
        };
        distributionChanged: string;
        authTypeChanged: string;
        installationFailed: string;
        waitUntilAppIsInstalled: {
            link: (installUrl: string) => string;
            waiting: string;
            success: (appName: string, accountId: number) => string;
        };
        appDataNotFound: string;
        oauthAppRedirectUrlError: (redirectUrl: string) => string;
    };
    CLIWebsocketServer: {
        errors: {
            portManagerNotRunning: (prefix?: string) => string;
            originNotAllowed: (origin?: string) => string;
            missingTypeField: (data: string) => string;
            invalidJSON: (data: string) => string;
            unknownMessageType: (type: string) => string;
        };
        logs: {
            startup: (port: number) => string;
        };
    };
    LocalDevProcess: {
        projectConfigMismatch: string;
        uploadInitiated: string;
        deployInitiated: string;
        uploadFailed: string;
        deployFailed: string;
        uploadSuccess: string;
        uploadSuccessAutoDeployDisabled: string;
        deploySuccess: string;
        noBuildToDeploy: string;
    };
    localDevHelpers: {
        project: {
            compareLocalProjectToDeployed: {
                noDeployedBuild: (projectName: string, accountIdentifier: string) => string;
                checking: string;
                upToDate: string;
                notUpToDate: string;
                notUpToDateExplanation: (profile?: string) => string;
            };
            createNewProjectForLocalDev: {
                projectMustExistExplanation: (projectName: string, accountId: number) => string;
                publicAppProjectMustExistExplanation: (projectName: string, accountId: number) => string;
                createProject: (projectName: string, accountIdentifier: string) => string;
                choseNotToCreateProject: string;
                creatingProject: (projectName: string, accountIdentifier: string) => string;
                createdProject: (projectName: string, accountIdentifier: string) => string;
                failedToCreateProject: string;
            };
            createInitialBuildForNewProject: {
                initialUploadMessage: string;
                projectLockedError: string;
                genericError: string;
            };
            checkAndInstallDependencies: {
                checkingDependencies: string;
                dependenciesUpToDate: string;
                dependenciesFailure: string;
            };
        };
        account: {
            checkIfDefaultAccountIsSupported: {
                publicApp: string;
                privateApp: string;
            };
            validateAccountOption: {
                invalidPublicAppAccount: string;
                invalidPrivateAppAccount: string;
                nonSandboxWarning: string;
                publicAppNonDeveloperTestAccountWarning: string;
            };
            checkIfParentAccountIsAuthed: {
                notAuthedError: (parentAccountId: number | string, accountIdentifier: string) => string;
            };
            selectAccountTypePrompt: {
                message: string;
                developerTestAccountOption: string;
                sandboxAccountOption: string;
                sandboxAccountOptionDisabled: string;
                productionAccountOption: (accountId?: number) => string;
            };
            confirmDefaultAccountIsTarget: {
                configError: string;
                declineDefaultAccountExplanation: string;
            };
        };
    };
    middleware: {
        updateNotification: {
            notifyTitle: string;
            cmsUpdateNotification: (packageName: string) => string;
            cliUpdateNotification: (currentVersion: string, updateCommand: string, latestVersion: string) => string;
        };
        autoUpdateCLI: {
            updateAvailable: (latestVersion: string) => string;
            updateSucceeded: (latestVersion: string) => string;
            notInstalledGlobally: string;
            updateFailed: (latestVersion: string) => string;
            enableAutoUpdatesMessage: string;
        };
    };
    projectProfiles: {
        logs: {
            usingProfile: (profileName: string) => string;
            profileTargetAccount: (accountId: number) => string;
            profileVariables: string;
        };
        loadProfile: {
            errors: {
                noProjectConfig: string;
                profileNotFound: (profileName: string) => string;
                missingAccountId: (profileName: string) => string;
                listedAccountNotFound: (accountId: number, profileName: string) => string;
                failedToLoadProfile: (profileName: string) => string;
                profileNotValid: (profileName: string, errors: string[]) => string;
            };
        };
    };
    projects: {
        create: {
            prompt: {
                marketPlaceDistribution: string;
                privateDistribution: string;
                distribution: string;
                auth: string;
                staticAuth: string;
                oauth: string;
            };
            errors: {
                noProjectsInConfig: string;
                missingConfigFileTemplateSource: string;
                missingPropertiesInConfig: string;
                exceededMaxNumberOfApps: (max: number) => string;
                unableToParseAppConfig: (file: string) => string;
                invalidAuthDistCombo: (authType: string, distribution: string) => string;
            };
        };
        add: {
            nothingAdded: string;
        };
        updateHsMetaFilesWithAutoGeneratedFields: {
            header: string;
            applicationLog: (componentType: string, uid: string, name: string) => string;
            componentLog: (componentType: string, uid: string) => string;
            failedToUpdate: (hsMetaFile: string) => string;
        };
        generateSafeFilenameDifferentiator: {
            failedToCheckFiles: string;
        };
        validateProjectConfig: {
            configNotFound: string;
            configMissingFields: (missingFields: string[]) => string;
            srcDirNotFound: (srcDir: string, projectDir: string) => string;
            srcOutsideProjectDir: (projectConfig: string, srcDir: string) => string;
        };
        getProjectConfig: {
            error: string;
        };
        platformVersion: {
            unsupported: (currentCliVersion: string, latestSupported: string, platformVersion?: string) => string;
        };
        ensureProjectExists: {
            createPrompt: (projectName: string, accountIdentifier: string) => string;
            createPromptUpload: (projectName: string, accountIdentifier: string) => string;
            createSuccess: (projectName: string, accountIdentifier: string) => string;
            notFound: (projectName: string, accountIdentifier: string) => string;
        };
        pollFetchProject: {
            checkingProject: (accountIdentifier: string) => string;
        };
        logFeedbackMessage: {
            feedbackHeader: string;
            feedbackMessage: string;
        };
        components: {
            unableToGetUidFromHsmeta: string;
            buildSuccessMessage: {
                seeOurDocs: string;
                docsUrl: string;
                headerCreated: (projectName: string, projectDest: string) => string;
                headerAdded: (featureText: string, uid: string, plural: boolean) => string;
                docsDetails: (docsLink: string) => string;
                uploadPrompt: string;
                devPrompt: string;
            };
        };
    };
    projectBuildAndDeploy: {
        makePollTaskStatusFunc: {
            errorSummary: string;
            componentCountSingular: string;
            componentCount: (numComponents: number) => string;
            successStatusText: string;
            failedStatusText: string;
            errorFetchingTaskStatus: (taskType: string) => string;
        };
        pollBuildAutodeployStatusError: (buildId: number) => string;
        pollProjectBuildAndDeploy: {
            buildSucceededAutomaticallyDeploying: (buildId: number, accountIdentifier: string) => string;
            cleanedUpTempFile: (path: string) => string;
            viewDeploys: string;
            unableToFindAutodeployStatus: (buildId: number, viewDeploysLink: string) => string;
        };
    };
    projectUpload: {
        wrongPlatformVersionMetaFiles: string;
        uploadProjectFiles: {
            add: (projectName: string, accountIdentifier: string) => string;
            fail: (projectName: string, accountIdentifier: string) => string;
            succeed: (projectName: string, accountIdentifier: string) => string;
            buildCreated: (projectName: string, buildId: number) => string;
        };
        handleProjectUpload: {
            emptySource: (srcDir: string) => string;
            compressed: (byteCount: number) => string;
            compressing: (path: string) => string;
            fileFiltered: (filename: string) => string;
            legacyFileDetected: (filename: string, platformVersion: string) => string;
            projectDoesNotExist: (accountId: number) => string;
            workspaceIncluded: (workspaceDir: string, archivePath: string) => string;
            fileDependencyIncluded: (packageName: string, localPath: string, archivePath: string) => string;
            malformedPackageJson: (packageJsonPath: string, error: string) => string;
            workspaceCollision: (archivePath: string, workspaceDir: string, existingWorkspace: string) => string;
            fileDependencyAlreadyIncluded: (packageName: string, archivePath: string) => string;
            updatingLockfile: (lockfilePath: string) => string;
            updatingPackageJsonWorkspaces: (packageJsonPath: string) => string;
            updatedWorkspaces: (workspaces: string) => string;
            updatedFileDependency: (packageName: string, relativePath: string) => string;
            lintPackagesNotConfigured: (packageRoot: string) => string;
            lintConfigNotFound: (packageRoot: string) => string;
            lintHubSpotRulesNotActive: (packageRoot: string) => string;
            npmAuditClean: (packageRoot: string) => string;
            npmAuditIssues: (packageRoot: string, details: string) => string;
            npmAuditNpmUnavailable: (packageRoot: string) => string;
            npmAuditNonZeroExit: (packageRoot: string, exitCode: number) => string;
        };
    };
    projectPreview: {
        triggeringPreview: (buildId: number, targetPortalId: number) => string;
        pollingStatus: (releaseTag: string, targetPortalId: number) => string;
        succeeded: (releaseTag: string, targetPortalId: number) => string;
        triggerFailed: string;
        pollFailed: string;
        warning: string;
        missingProjectId: string;
    };
    importData: {
        errors: {
            incorrectAccountType: (derivedAccountId: number) => string;
            failedToImportData: string;
            notDeveloperTestAccount: string;
            noAccountConfig: (accountId: number) => string;
        };
        inProgress: (portalId: number, fileNames: string[]) => string;
        viewImportLink: (baseUrl: string, accountId: number, importId: string) => string;
    };
    ui: {
        betaTag: string;
        betaTagWithStyle: string;
        betaWarning: {
            header: string;
            footer: string;
        };
        infoTag: string;
        deprecatedTag: string;
        deprecatedTagWithStyle: string;
        errorTag: string;
        deprecatedMessage: (command: string, url: string) => string;
        deprecatedDescription: (message: string, command: string, url: string) => string;
        deprecatedUrlText: string;
        disabledMessage: (command: string, npmCommand: string, url: string) => string;
        disabledUrlText: string;
        featureHighlight: {
            defaultTitle: string;
            featureKeys: {
                accountOption: {
                    command: string;
                    message: (command: string) => string;
                };
                accountsListCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                accountsUseCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                authCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                feedbackCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                helpCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                projectCreateCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                projectDeployCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                projectHelpCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                projectUploadCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                projectDevCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                projectInstallDepsCommand: {
                    command: string;
                    message: (command: string) => string;
                };
                projectCommandTip: {
                    message: string;
                };
                sampleProjects: {
                    linkText: string;
                    url: string;
                    message: (link: string) => string;
                };
            };
        };
        git: {
            securityIssue: string;
            configFileTracked: string;
            fileName: (configPath: string) => string;
            remediate: string;
            moveConfig: (homeDir: string) => string;
            addGitignore: (configPath: string) => string;
            noRemote: string;
            checkFailed: string;
        };
        serverlessFunctionLogs: {
            unableToProcessLog: (log: string) => string;
            noLogsFound: string;
        };
    };
    buildAccount: {
        createDeveloperTestAccountV2: {
            syncFailure: string;
            pakFailure: string;
        };
    };
    usageTracking: {
        transparencyMessage: string;
    };
    configOptions: {
        enableOrDisableBooleanFieldPrompt: {
            message: (fieldName: string) => string;
            labels: {
                enabled: string;
                disabled: string;
            };
        };
        setAllowUsageTracking: {
            fieldName: string;
            success: (isEnabled: string) => string;
        };
        setAllowAutoUpdates: {
            fieldName: string;
            success: (isEnabled: string) => string;
        };
        setDefaultCmsPublishMode: {
            promptMessage: string;
            error: (validModes: string) => string;
            success: (mode: string) => string;
        };
        setHttpTimeout: {
            promptMessage: string;
            success: (timeout: string) => string;
            error: (timeout: string) => string;
        };
        setAutoOpenBrowser: {
            fieldName: string;
            enabled: string;
            disabled: string;
        };
    };
    commonOpts: {
        options: {
            account: string;
            config: string;
            overwrite: string;
            modes: {
                default: (modes: string) => string;
                read: (modes: string) => string;
                write: (modes: string) => string;
            };
            qa: string;
            useEnv: string;
            jsonOutput: string;
            debug: string;
        };
    };
    configMigrate: {
        deprecatedConfigWarning: (deprecatedConfigPath: string) => string;
        handleMigration: {
            description: (archivedConfigName: string) => string;
            confirmPrompt: string;
            success: string;
        };
        handleMergeConfigProperties: {
            mergeConflictMessage: (count: number, propertyList: string) => string;
            mergeConfigConflictPrompt: (property: string, newValue: string, oldValue: string) => string;
        };
        handleAccountNameConflicts: {
            warnings: {
                accountNameConflictMessage: (count: number) => string;
                forceFlagDetected: (count: number, renameDetails: string) => string;
            };
            prompts: {
                renameOrOmitAccountPrompt: (accountName: string, accountId: number) => string;
                newAccountNamePrompt: (accountName: string, portalId: number) => string;
            };
            errors: {
                nameRequired: string;
                sameName: string;
                nameAlreadyInConfig: (name: string) => string;
            };
        };
        handleMerge: {
            description: (archivedConfigName: string) => string;
            confirmPrompt: string;
            skippedExistingAccounts: (accountIds: (string | number)[]) => string;
            success: string;
        };
        errors: {
            archive: (deprecatedConfigPath: string) => string;
        };
    };
    prompts: {
        promptUtils: {
            errors: {
                noSelectableChoices: string;
                userCancelled: string;
            };
        };
        projectProfilePrompt: {
            message: string;
            exitMessage: string;
            noValidProfilesMessage: string;
        };
        importDataFilePathPrompt: {
            promptContext: string;
            promptMessage: string;
        };
        confirmImportDataPrompt: {
            message: (dataFileNames: string[], cliAccount: HubSpotConfigAccount | null) => string;
        };
        importDataTestAccountSelectPrompt: {
            errors: {
                noAccountsFound: string;
                noChildTestAccountsFound: (parentAccountId: number) => string;
            };
        };
        projectDevTargetAccountPrompt: {
            createNewSandboxOption: string;
            createNewDeveloperTestAccountOption: string;
            chooseDefaultAccountOption: string;
            promptMessage: (accountType: string, accountIdentifier: string) => string;
            sandboxLimit: (limit: number) => string;
            sandboxLimitWithSuggestion: (limit: number) => string;
            developerTestAccountLimit: (limit: number) => string;
            confirmDefaultAccount: (accountName: string, accountType: string) => string;
            confirmUseExistingDeveloperTestAccount: (accountName: string) => string;
            confirmLinkExistingDeveloperTestAccount: (accountName: string) => string;
            noAccountId: string;
        };
        projectLogsPrompt: {
            functionName: (projectName: string) => string;
        };
        setAsDefaultAccountPrompt: {
            setAsDefaultAccountMessage: string;
            setAsDefaultAccount: (accountName: string) => string;
            keepingCurrentDefault: (accountName: string | number) => string;
        };
        createDeveloperTestAccountConfigPrompt: {
            namePrompt: (withFlag?: boolean) => string;
            descriptionPrompt: (withFlag?: boolean) => string;
            useDefaultAccountLevelsPrompt: {
                message: string;
                default: string;
                manual: string;
            };
            tiersPrompt: string;
            hubTypes: {
                marketing: string;
                ops: string;
                service: string;
                sales: string;
                content: string;
                commerce: string;
            };
            errors: {
                allHubsRequired: string;
                tiersError: string;
                nameRequired: string;
            };
        };
        accountNamePrompt: {
            enterAccountName: string;
            enterDeveloperTestAccountName: string;
            enterStandardSandboxName: string;
            enterDevelopmentSandboxName: string;
            sandboxDefaultName: (sandboxType: string) => string;
            developerTestAccountDefaultName: (count: number) => string;
            errors: {
                invalidName: string;
                nameRequired: string;
                spacesInName: string;
                accountNameExists: (name: string) => string;
            };
        };
        personalAccessKeyPrompt: {
            enterAccountId: string;
            enterClientId: string;
            enterClientSecret: string;
            enterPersonalAccessKey: string;
            selectScopes: string;
            personalAccessKeySetupTitle: string;
            personalAccessKeyBrowserOpenPrep: string;
            personalAccessKeyPromptChoices: {
                OPEN_BROWSER: string;
                PASTE_EXISTING: string;
            };
            logs: {
                openingWebBrowser: (url: string) => string;
            };
            errors: {
                invalidAccountId: string;
                invalidOauthClientId: string;
                invalidOauthClientIdLength: string;
                invalidOauthClientSecret: string;
                invalidOauthClientSecretLength: string;
                invalidOauthClientSecretCopy: string;
                invalidPersonalAccessKey: string;
                invalidPersonalAccessKeyCopy: string;
                authCancelled: string;
            };
        };
        createTemplatePrompt: {
            selectTemplate: string;
        };
        createModulePrompt: {
            enterLabel: string;
            selectReactType: string;
            selectContentType: string;
            confirmGlobal: string;
            availableForNewContent: string;
            errors: {
                invalidLabel: string;
                labelRequired: string;
                contentTypeRequired: string;
            };
        };
        createFunctionPrompt: {
            enterFolder: string;
            enterFilename: string;
            enterEndpointPath: string;
            selectEndpointMethod: string;
            errors: {
                invalid: string;
                blank: string;
                space: string;
            };
        };
        createApiSamplePrompt: {
            selectApiSampleApp: string;
            selectLanguage: string;
            errors: {
                apiSampleAppRequired: string;
                languageRequired: string;
            };
        };
        projectNameAndDestPrompt: {
            enterName: string;
            enterDest: string;
            errors: {
                nameRequired: string;
                destRequired: string;
                invalidDest: string;
                invalidCharacters: string;
            };
        };
        selectProjectTemplatePrompt: {
            selectTemplate: string;
            features: string;
            errors: {
                invalidTemplate: (template: string) => string;
                projectTemplateRequired: string;
            };
        };
        selectAppPrompt: {
            selectAppId: string;
            errors: {
                noApps: string;
                invalidAppId: string;
            };
        };
        selectPublicAppForMigrationPrompt: {
            selectAppIdMigrate: (accountName: string) => string;
            selectAppIdClone: (accountName: string) => string;
            errors: {
                noAccountId: string;
                noAppsMigration: string;
                noAppsClone: string;
                noAppsMigrationMessage: (accountName: string) => string;
                noAppsCloneMessage: (accountName: string) => string;
                errorFetchingApps: string;
                cannotBeMigrated: string;
            };
        };
        downloadProjectPrompt: {
            selectProject: string;
            errors: {
                projectNotFound: (projectName: string, accountId: number) => string;
                accountIdRequired: string;
            };
        };
        projectAddPrompt: {
            selectType: string;
            selectFeatures: string;
            enterName: string;
            errors: {
                nameRequired: string;
                componentRequired: string;
                noSelectableChoices: string;
                invalidType: (type: string) => string;
                cannotAddFeature: (feature: string, reasons: string | boolean) => string;
            };
        };
        secretPrompt: {
            enterValue: string;
            enterName: string;
            selectSecretUpdate: string;
            selectSecretDelete: string;
            errors: {
                invalidValue: string;
            };
        };
        sandboxesPrompt: {
            selectAccountName: string;
            selectParentAccountName: string;
            type: {
                message: string;
                developer: string;
                standard: string;
            };
        };
        uploadPrompt: {
            enterDest: string;
            enterSrc: string;
            errors: {
                srcRequired: string;
                destRequired: string;
            };
            fieldsPrompt: (dir: string) => string;
        };
        projectNamePrompt: {
            enterName: string;
            errors: {
                invalidName: string;
                projectDoesNotExist: (projectName: string, accountId: number) => string;
            };
        };
        previewPrompt: {
            enterSrc: string;
            enterDest: string;
            themeProjectSelect: string;
            errors: {
                srcRequired: string;
                destRequired: string;
            };
        };
        installAppPrompt: {
            explanation: string;
            reinstallExplanation: string;
            prompt: string;
            autoPrompt: string;
            reinstallPrompt: string;
            decline: string;
        };
        selectHubDBTablePrompt: {
            selectTable: string;
            enterDest: string;
            errors: {
                noTables: (accountId: string) => string;
                errorFetchingTables: (accountId: string) => string;
                destRequired: string;
                invalidDest: string;
                invalidCharacters: string;
            };
        };
    };
    polling: {
        timeoutError: (timeoutMs: number) => string;
    };
    convertFields: {
        positionals: {
            src: {
                describe: string;
            };
        };
        options: {
            options: {
                describe: string;
            };
        };
    };
    developerTestAccount: {
        create: {
            loading: {
                add: (accountName: string) => string;
                fail: (accountName: string) => string;
                succeed: (accountName: string, accountId: string) => string;
            };
            success: {
                configFileUpdated: (accountName: string, authType: string) => string;
            };
            failure: {
                invalidUser: (accountName: string, parentAccountName: string) => string;
                limit: (accountName: string | number, limit: number) => string;
                alreadyInConfig: (accountName: string | number, limit: number) => string;
                scopes: {
                    message: string;
                    instructions: (accountName: string | number, url: string) => string;
                };
            };
        };
    };
    sandbox: {
        create: {
            developer: {
                loading: {
                    add: (accountName: string) => string;
                    fail: (accountName: string) => string;
                    succeed: (accountName: string, accountId: string) => string;
                };
                success: {
                    configFileUpdated: (accountName: string, authType: string) => string;
                };
                failure: {
                    limit: (accountId: number, limit: number, link: string) => string;
                    alreadyInConfig: (accountId: number, limit: number) => string;
                    generic: string;
                    scopes: {
                        message: string;
                        instructions: (account: string | number, url: string) => string;
                    };
                };
            };
            standard: {
                loading: {
                    add: (accountName: string) => string;
                    fail: (accountName: string) => string;
                    succeed: (accountName: string, accountId: string) => string;
                };
                success: {
                    configFileUpdated: (accountName: string, authType: string) => string;
                };
                failure: {
                    limit: (accountId: number, limit: number, link: string) => string;
                    alreadyInConfig: (accountId: number, limit: number) => string;
                    scopes: {
                        message: string;
                        instructions: (account: string | number, url: string) => string;
                    };
                };
            };
            failure: {
                usageLimitsFetch: string;
                scopes: {
                    message: string;
                    instructions: (account: string | number, url: string) => string;
                };
                invalidUser: (accountName: string, parentAccountId: number) => string;
                '403Gating': (accountName: string, parentAccountId: number) => string;
            };
        };
        sync: {
            info: {
                syncMessage: (url: string) => string;
                syncMessageDevSb: (url: string) => string;
            };
            confirm: {
                syncContactRecords: {
                    standard: string;
                };
            };
            loading: {
                add: (accountName: string) => string;
                fail: (accountId: number) => string;
                succeed: (accountId: number) => string;
                startSync: string;
                succeedDevSb: (accountId: number) => string;
                successDevSbInfo: (accountId: number, url: string) => string;
            };
            success: {
                configFileUpdated: (accountName: string, authType: string) => string;
            };
            failure: {
                syncTypeFetch: string;
                invalidUser: (accountName: string, parentAccountName: string) => string;
                syncInProgress: (url: string) => string;
                notSuperAdmin: (accountId: number) => string;
                objectNotFound: (accountId: number) => string;
                scopes: {
                    message: string;
                    instructions: (accountName: string, url: string) => string;
                };
            };
        };
    };
    errorHandlers: {
        index: {
            errorOccurred: (error: string) => string;
            errorContext: (context: string) => string;
            errorCause: (cause: string) => string;
            unknownErrorOccurred: string;
            configTimeoutErrorOccurred: (timeout: number, configSetCommand: string) => string;
            genericTimeoutErrorOccurred: string;
            additionalDebugContext: string;
        };
        suppressErrors: {
            platformVersionErrors: {
                header: string;
                unspecifiedPlatformVersion: (platformVersion: string) => string;
                platformVersionRetired: (platformVersion: string) => string;
                nonExistentPlatformVersion: (platformVersion: string) => string;
                updateProject: string;
                docsLink: string;
                betaLink: (docsLink: string) => string;
            };
            missingScopeError: (request: string, accountName: string) => string;
        };
    };
    serverless: {
        verifyAccessKeyAndUserAccess: {
            fetchScopeDataError: (scopeGroup: string) => string;
            portalMissingScope: string;
            userMissingScope: string;
            genericMissingScope: string;
        };
    };
    doctor: {
        runningDiagnostics: string;
        diagnosticsComplete: string;
        accountChecks: {
            active: string;
            inactive: string;
            inactiveSecondary: (command: string) => string;
            unableToDetermine: string;
            pak: {
                incomplete: string;
                incompleteSecondary: (link: string) => string;
                invalid: string;
                invalidSecondary: string;
                valid: (link: string) => string;
                viewScopes: string;
            };
        };
        nodeChecks: {
            unableToDetermine: string;
            minimumNotMet: (nodeVersion: string) => string;
            success: (nodeVersion: string) => string;
        };
        npmChecks: {
            notInstalled: string;
            installed: (npmVersion: string) => string;
            unableToDetermine: string;
        };
        hsChecks: {
            notLatest: (hsVersion: string) => string;
            notLatestSecondary: (command: string, hsVersion: string) => string;
            latest: (hsVersion: string) => string;
            unableToDetermine: string;
            unableToDetermineSecondary: (link: string) => string;
        };
        projectDependenciesChecks: {
            missingDependencies: (dir: string) => string;
            missingDependenciesSecondary: (command: string) => string;
            unableToDetermine: (dir: string) => string;
            success: string;
        };
        files: {
            invalidJson: (filename: string) => string;
            validJson: string;
        };
        port: {
            inUse: (port: number) => string;
            inUseSecondary: string;
            available: (port: number) => string;
        };
        projectValidation: {
            valid: string;
            configInvalid: string;
            configMissing: string;
            sourceDirectoryInvalid: string;
            translationFailed: string;
            profileValidationFailed: (profileName: string) => string;
            validationDetails: string;
        };
        diagnosis: {
            cli: {
                header: string;
            };
            cliConfig: {
                header: string;
                configFileSubHeader: (filename: string) => string;
                defaultAccountSubHeader: (accountDetails: string) => string;
                noConfigFile: string;
                noConfigFileSecondary: (command: string) => string;
                settings: {
                    httpUseLocalhost: string;
                    httpUseLocalhostSecondary: string;
                };
            };
            projectConfig: {
                header: string;
                projectDirSubHeader: (projectDir: string) => string;
                projectNameSubHeader: (projectName: string) => string;
            };
            defaultAccountOverrideFile: {
                header: string;
            };
            counts: {
                errors: (count: number) => string;
                warnings: (count: number) => string;
            };
        };
        networkChecks: {
            header: string;
            hubspotApiReachable: string;
            hubspotApiUnreachable: string;
            hubspotApiUnreachableSecondary: string;
            npmRegistryReachable: string;
            npmRegistryUnreachable: string;
            npmRegistryUnreachableSecondary: string;
        };
        webhookChecks: {
            header: string;
            endpointReachable: (url: string) => string;
            endpointUnreachable: (url: string) => string;
            endpointUnreachableSecondary: string;
            checkType: string;
        };
        appRedirectChecks: {
            redirectUrlReachable: (url: string) => string;
            redirectUrlUnreachable: (url: string) => string;
            redirectUrlUnreachableSecondary: string;
            checkType: string;
        };
        defaultAccountOverrideFileChecks: {
            overrideActive: (defaultAccountOverrideFile: string) => string;
            overrideAccountId: (overrideAccountId: number | string) => string;
        };
    };
    oauth: {
        missingClientId: string;
    };
    validation: {
        accountNotFoundInConfig: (userProvidedAccount: string) => string;
        accountRequired: string;
        userProvidedAccount: string;
        accountNotConfigured: (accountId: number) => string;
        invalidAuthType: (authType: string, accountId: number, configPath: string, validValues: string) => string;
        oauth2ConfigMissing: (accountId: number) => string;
        oauth2ConfigIncorrect: (accountId: number) => string;
        oauth2AccessTokenNotFound: (accountId: number) => string;
        personalAccessKeyMissing: (accountId: number) => string;
        personalAccessKeyTokenRetrievalFailed: (accountId: number) => string;
        authConfigurationMissing: (accountId: number) => string;
        availableCMSModes: (modes: string) => string;
        invalidCmsPublishMode: (cmsPublishMode: string, modesMessage: string) => string;
        missingCmsPublishMode: (modesMessage: string) => string;
        pathNotFile: (path: string) => string;
        fileNotJson: (path: string) => string;
        fileInvalidJson: (path: string) => string;
    };
    migrate: {
        componentsToBeMigrated: (components: string) => string;
        componentsThatWillNotBeMigrated: (components: string) => string;
        legacyCrmCardMigrationDocs: () => string;
        sourceContentsMoved: (newLocation: string) => string;
        projectMigrationWarningTitle: (platformVersion: string) => string;
        projectMigrationWarning: (platformVersion: string) => string;
        exitWithoutMigrating: string;
        success: {
            downloadedProject: (projectName: string, projectDest: string) => string;
            themesMigrationSuccess: (platformVersion: string) => string;
        };
        errors: {
            project: {
                invalidConfig: string;
                doesNotExist: (account: number) => string;
                themesAlreadyMigrated: string;
                noProjectForThemesMigration: string;
                themesAndAppsNotAllowed: string;
                multipleApps: string;
                alreadyExists: (projectName: string) => string;
                failedToMigrateThemes: string;
                failedToUpdateProjectConfig: string;
            };
            unmigratableReasons: {
                upToDate: string;
                isPrivateApp: string;
                listedInMarketplace: string;
                projectConnectedToGitHub: (projectName: string | undefined, accountId: number) => string;
                partOfProjectAlready: string;
                generic: (reasonCode: string) => string;
            };
            noAppsEligible: (accountId: string, reasons: string[]) => string;
            invalidAccountTypeTitle: string;
            invalidAccountTypeDescription: (useCommand: string) => string;
            appWithAppIdNotFound: (appId: number) => string;
            noAppsForProject: (projectName: string) => string;
            migrationFailed: string;
            notUngatedForUnifiedApps: (account: string) => string;
        };
        prompt: {
            themesMigration: (count: number) => string;
            chooseApp: string;
            inputName: string;
            inputDest: string;
            uidForComponent: (componentName: string) => string;
            proceed: string;
        };
        spinners: {
            checkingForMigratableComponents: string;
            beginningMigration: string;
            unableToStartMigration: string;
            finishingMigration: string;
            migrationComplete: string;
            migrationFailed: string;
            downloadingProjectContents: string;
            downloadingProjectContentsComplete: string;
            downloadingProjectContentsFailed: string;
            copyingProjectFiles: string;
            copyingProjectFilesComplete: string;
            copyingProjectFilesFailed: string;
        };
    };
    theme: {
        cmsDevServerProcess: {
            installStarted: (targetVersion: string) => string;
            installSucceeded: string;
            installFailed: string;
            serverStartError: (error: Error) => string;
            serverExit: (code: number) => string;
            serverKill: (signal: NodeJS.Signals) => string;
        };
    };
};