@hubspot/cli 7.7.0-experimental.3 → 7.7.2-experimental.0

package/lib/marketplaceValidate.js

@@ -10,8 +10,7 @@ exports.processValidationErrors = processValidationErrors;
 exports.displayValidationResults = displayValidationResults;
 const chalk_1 = __importDefault(require("chalk"));
 const marketplaceValidation_1 = require("@hubspot/local-dev-lib/api/marketplaceValidation");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const lang_1 = require("./lang");
+const logger_1 = require("./ui/logger");
 const exitCodes_1 = require("./enums/exitCodes");
 const SLEEP_TIME = 2000;
 async function kickOffValidation(accountId, assetType, src) {
@@ -25,7 +24,7 @@ async function kickOffValidation(accountId, assetType, src) {
         return requestResult;
     }
     catch (err) {
-        logger_1.logger.debug(err);
+        logger_1.uiLogger.debug(err);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
@@ -43,7 +42,7 @@ async function pollForValidationFinish(accountId, validationId) {
         await checkValidationStatus();
     }
     catch (err) {
-        logger_1.logger.debug(err);
+        logger_1.uiLogger.debug(err);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
@@ -55,69 +54,63 @@ async function fetchValidationResults(accountId, validationId) {
         return validationResults;
     }
     catch (err) {
-        logger_1.logger.debug(err);
+        logger_1.uiLogger.debug(err);
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-function processValidationErrors(i18nKey, validationResults) {
+function processValidationErrors(invalidPathError, validationResults) {
     if (validationResults.errors.length) {
         const { assetPath, errors } = validationResults;
         errors.forEach(err => {
             if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
-                logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.invalidPath`, {
-                    path: assetPath,
-                }));
+                logger_1.uiLogger.error(invalidPathError(assetPath));
             }
             else {
-                logger_1.logger.error(`${err.context}`);
+                logger_1.uiLogger.error(`${err.context}`);
             }
         });
         process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-function displayFileInfo(file, line, i18nKey) {
+function displayFileInfo(file, line, resultsCopy) {
     if (file) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.file`, {
-            file,
-        }));
+        logger_1.uiLogger.log(resultsCopy.warnings.file(file));
     }
     if (line) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.lineNumber`, {
-            line,
-        }));
+        logger_1.uiLogger.log(resultsCopy.warnings.lineNumber(line.toString()));
     }
 }
-function displayResults(checks, i18nKey) {
+function displayResults(checks, resultsCopy) {
     if (checks) {
         const { status, results } = checks;
         if (status === 'FAIL') {
             const failedValidations = results.filter(test => test.status === 'FAIL');
             const warningValidations = results.filter(test => test.status === 'WARN');
             failedValidations.forEach(val => {
-                logger_1.logger.error(`${val.message}`);
-                displayFileInfo(val.file, val.line, i18nKey);
+                logger_1.uiLogger.error(`${val.message}`);
+                displayFileInfo(val.file, val.line, resultsCopy);
             });
             warningValidations.forEach(val => {
-                logger_1.logger.warn(`${val.message}`);
-                displayFileInfo(val.file, val.line, i18nKey);
+                logger_1.uiLogger.warn(`${val.message}`);
+                displayFileInfo(val.file, val.line, resultsCopy);
             });
         }
         if (status === 'PASS') {
-            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.results.noErrors`));
+            logger_1.uiLogger.success(resultsCopy.noErrors);
             results.forEach(test => {
                 if (test.status === 'WARN') {
-                    logger_1.logger.warn(`${test.message}`);
-                    displayFileInfo(test.file, test.line, i18nKey);
+                    logger_1.uiLogger.warn(`${test.message}`);
+                    displayFileInfo(test.file, test.line, resultsCopy);
                 }
             });
         }
     }
     return;
 }
-function displayValidationResults(i18nKey, validationResults) {
+function displayValidationResults(resultsCopy, validationResults) {
     Object.keys(validationResults.results).forEach(type => {
-        logger_1.logger.log(chalk_1.default.bold((0, lang_1.i18n)(`${i18nKey}.results.${type.toLowerCase()}`)));
-        displayResults(validationResults.results[type], i18nKey);
-        logger_1.logger.log();
+        logger_1.uiLogger.log(chalk_1.default.bold(resultsCopy[type.toLowerCase()]));
+        displayResults(validationResults.results[type], resultsCopy);
+        logger_1.uiLogger.log('');
     });
 }

package/lib/middleware/configMiddleware.js

@@ -87,6 +87,7 @@ const accountsSubCommands = {
         list: { target: true },
         ls: { target: true },
         remove: { target: true },
+        use: { target: true },
     },
 };
 const sandboxesSubCommands = {

package/lib/middleware/fireAlarmMiddleware.d.ts

@@ -1,4 +1,4 @@
 import { Arguments } from 'yargs';
-export declare function checkFireAlarms(args: Arguments<{
-    derivedAccountId: number;
+export declare function checkFireAlarms(argv: Arguments<{
+    derivedAccountId?: number;
 }>): Promise<void>;

package/lib/middleware/fireAlarmMiddleware.js

@@ -112,10 +112,12 @@ async function logFireAlarms(accountId, command, version) {
         });
     }
 }
-async function checkFireAlarms(args) {
-    const { derivedAccountId } = args;
+async function checkFireAlarms(argv) {
+    const { derivedAccountId } = argv;
     try {
-        await logFireAlarms(derivedAccountId, args._.join(' '), package_json_1.default.version);
+        if (derivedAccountId) {
+            await logFireAlarms(derivedAccountId, argv._.join(' '), package_json_1.default.version);
+        }
     }
     catch (error) {
         (0, errorHandlers_1.debugError)(error);

package/lib/projects/add/legacyAddComponent.d.ts

@@ -0,0 +1,5 @@
+import { ProjectConfig } from '../../../types/Projects';
+export declare function legacyAddComponent(args: {
+    name?: string;
+    type?: string;
+}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;

package/lib/projects/add/legacyAddComponent.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyAddComponent = legacyAddComponent;
+const Projects_1 = require("../../../types/Projects");
+const structure_1 = require("../structure");
+const errorHandlers_1 = require("../../errorHandlers");
+const en_1 = require("../../../lang/en");
+const legacy_1 = require("../create/legacy");
+const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../constants");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const logger_1 = require("../../ui/logger");
+async function legacyAddComponent(args, projectDir, projectConfig) {
+    // We currently only support adding private apps to projects
+    let projectContainsPublicApp = false;
+    try {
+        const components = await (0, structure_1.findProjectComponents)(projectDir);
+        projectContainsPublicApp = components.some(c => c.type === Projects_1.ComponentTypes.PublicApp);
+    }
+    catch (err) {
+        (0, errorHandlers_1.debugError)(err);
+    }
+    if (projectContainsPublicApp) {
+        throw new Error(en_1.commands.project.add.error.projectContainsPublicApp);
+    }
+    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
+    const components = await (0, legacy_1.getProjectComponentListFromRepo)(projectConfig.platformVersion);
+    if (!components || !components.length) {
+        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+    }
+    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPrompt)(components, args);
+    try {
+        const componentPath = path_1.default.join(projectDir, projectConfig.srcDir, projectAddPromptResponse.name);
+        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {
+            sourceDir: projectAddPromptResponse.componentTemplate.path,
+            branch: 'main',
+            hideLogs: true,
+        });
+        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.name));
+    }
+    catch (error) {
+        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent);
+    }
+}

package/lib/projects/add/v3AddComponent.d.ts

@@ -0,0 +1,8 @@
+import { ProjectConfig } from '../../../types/Projects';
+export declare function v3AddComponent(args: {
+    name?: string;
+    type?: string;
+    features?: string[];
+    auth?: string;
+    distribution?: string;
+}, projectDir: string, projectConfig: ProjectConfig): Promise<void>;

package/lib/projects/add/v3AddComponent.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v3AddComponent = v3AddComponent;
+const en_1 = require("../../../lang/en");
+const legacy_1 = require("../create/legacy");
+const v3_1 = require("../create/v3");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
+const constants_1 = require("../../constants");
+const components_1 = require("../components");
+const project_1 = require("@hubspot/project-parsing-lib/src/lib/project");
+const constants_2 = require("@hubspot/project-parsing-lib/src/lib/constants");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const errorHandlers_1 = require("../../errorHandlers");
+const logger_1 = require("../../ui/logger");
+async function v3AddComponent(args, projectDir, projectConfig) {
+    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
+    const config = await (0, legacy_1.getConfigForPlatformVersion)(projectConfig.platformVersion);
+    const { components, parentComponents } = config;
+    if (!components || !components.length) {
+        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+    }
+    const projectSrcDirectory = path_1.default.join(projectDir, projectConfig.srcDir);
+    const projectMetadata = await (0, project_1.getProjectMetadata)(projectSrcDirectory);
+    let derivedAuthType;
+    let derivedDistribution;
+    const appsMetadata = projectMetadata.components[constants_2.AppKey];
+    const shouldCreateApp = appsMetadata.count === 0;
+    if (shouldCreateApp) {
+        const { authType, distribution } = await (0, v3_1.createV3App)(args.auth, args.distribution);
+        derivedDistribution = distribution;
+        derivedAuthType = authType;
+    }
+    else if (appsMetadata.count > appsMetadata.maxCount) {
+        throw new Error(en_1.lib.projects.create.errors.exceededMaxNumberOfApps(appsMetadata.maxCount));
+    }
+    else {
+        const apps = appsMetadata.hsMetaFiles.map(appLoc => {
+            try {
+                return JSON.parse(fs_1.default.readFileSync(appLoc, 'utf8'));
+            }
+            catch (err) {
+                throw new Error(en_1.lib.projects.create.errors.unableToParseAppConfig(appLoc));
+            }
+        });
+        derivedDistribution = apps[0].config?.distribution;
+        derivedAuthType = apps[0].config?.auth?.type;
+    }
+    const componentTemplateChoices = (0, v3_1.calculateComponentTemplateChoices)(components, derivedAuthType, derivedDistribution, projectMetadata);
+    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPromptV3)(componentTemplateChoices, args.features);
+    try {
+        const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
+            return path_1.default.join(projectConfig.platformVersion, componentTemplate.path);
+        }) || [];
+        if (shouldCreateApp) {
+            const parentComponent = parentComponents?.find(possibleParent => {
+                return (possibleParent.type === v3_1.PROJECT_WITH_APP &&
+                    possibleParent.authType === derivedAuthType &&
+                    possibleParent.distribution === derivedDistribution);
+            });
+            if (parentComponent) {
+                components.push(path_1.default.join(projectConfig.platformVersion, parentComponent.path));
+            }
+        }
+        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDir, {
+            sourceDir: components,
+            hideLogs: true,
+            branch: 'main',
+            handleCollision: components_1.handleComponentCollision,
+        });
+        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.componentTemplate
+            .map(template => `'${template.label}'`)
+            .join(', '), projectAddPromptResponse.componentTemplate.length > 1));
+    }
+    catch (error) {
+        (0, errorHandlers_1.debugError)(error);
+        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent, {
+            cause: error,
+        });
+    }
+}

package/lib/projects/components.d.ts

@@ -0,0 +1,2 @@
+import { Collision } from '@hubspot/local-dev-lib/types/Archive';
+export declare function handleComponentCollision({ dest, src, collisions }: Collision): void;

package/lib/projects/components.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleComponentCollision = handleComponentCollision;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+// Handles a collision between component source files
+function handleComponentCollision({ dest, src, collisions }) {
+    const hsMetaFiles = [];
+    const packageJsonFiles = [];
+    const sourceFiles = [];
+    collisions.forEach(collision => {
+        if (collision.endsWith(project_parsing_lib_1.metafileExtension)) {
+            hsMetaFiles.push(collision);
+        }
+        else if (path_1.default.parse(collision).base === 'package.json') {
+            packageJsonFiles.push(collision);
+        }
+        else {
+            sourceFiles.push(collision);
+        }
+    });
+    const sourceFilenameMapping = sourceFiles.reduce((acc, filename) => {
+        const { name, ext, dir } = path_1.default.parse(filename);
+        return {
+            ...acc,
+            [filename]: path_1.default.join(dir, `${name}-${Date.now()}${ext}`),
+        };
+    }, {});
+    const metafileExtensionPrefix = path_1.default.parse(project_parsing_lib_1.metafileExtension).name;
+    const metaFilenameMapping = hsMetaFiles.reduce((acc, filename) => {
+        const { name, dir } = path_1.default.parse(filename);
+        return {
+            ...acc,
+            [filename]: path_1.default.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${Date.now()}${project_parsing_lib_1.metafileExtension}`),
+        };
+    }, {});
+    // Update the metafiles that might contain references to the old filenames
+    hsMetaFiles.forEach(file => {
+        updateMetaFile({
+            dest,
+            src,
+            file,
+            sourceFilenameMapping,
+            metaFilenameMapping,
+        });
+    });
+    // Copy the renamed files into their new destination location
+    Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
+        fs_1.default.copyFileSync(path_1.default.join(src, key), path_1.default.join(dest, value));
+    });
+    if (packageJsonFiles.length) {
+        handlePackageJsonCollisions(dest, src, packageJsonFiles);
+    }
+}
+function updateMetaFile({ dest, src, file, sourceFilenameMapping, metaFilenameMapping, }) {
+    let text = fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8');
+    Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
+        const { base: oldFileName } = path_1.default.parse(key);
+        const { base: newFileName } = path_1.default.parse(value);
+        text = text.replace(oldFileName, newFileName);
+    });
+    fs_1.default.writeFileSync(path_1.default.join(dest, metaFilenameMapping[file]), text);
+}
+function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
+    packageJsonFiles.forEach(file => {
+        const existingPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dest, file), 'utf-8'));
+        const newPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8'));
+        existingPackageJsonContents.dependencies = {
+            ...newPackageJsonContents.dependencies,
+            ...existingPackageJsonContents.dependencies,
+        };
+        existingPackageJsonContents.devDependencies = {
+            ...newPackageJsonContents.devDependencies,
+            ...existingPackageJsonContents.devDependencies,
+        };
+        fs_1.default.writeFileSync(path_1.default.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
+    });
+}

package/lib/projects/create/index.d.ts

@@ -0,0 +1,23 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs';
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+export type ProjectCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    name?: string;
+    dest?: string;
+    templateSource?: RepoPath;
+    template?: string;
+    features?: string[];
+    platformVersion: string;
+    projectBase?: string;
+    auth?: string;
+    distribution?: string;
+};
+export declare function handleProjectCreationFlow(args: ArgumentsCamelCase<ProjectCreateArgs>): Promise<{
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    createProjectPromptResponse: CreateProjectPromptResponse;
+}>;

package/lib/projects/create/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProjectCreationFlow = handleProjectCreationFlow;
+const createProjectPrompt_1 = require("../../prompts/createProjectPrompt");
+const constants_1 = require("../../constants");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const v3_1 = require("./v3");
+const legacy_1 = require("./legacy");
+const logger_1 = require("../../ui/logger");
+const en_1 = require("../../../lang/en");
+const exitCodes_1 = require("../../enums/exitCodes");
+async function handleProjectCreationFlow(args) {
+    const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
+    const repo = templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await (0, v3_1.v3ComponentFlow)(platformVersion, projectBase, providedAuth, providedDistribution);
+        const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, undefined, projectContents !== v3_1.EMPTY_PROJECT ? componentTemplateChoices : undefined);
+        return {
+            authType,
+            distribution,
+            repoConfig,
+            projectContents,
+            createProjectPromptResponse,
+        };
+    }
+    const projectTemplates = await (0, legacy_1.getProjectTemplateListFromRepo)(repo, 'main');
+    if (!projectTemplates.length) {
+        logger_1.uiLogger.error(en_1.commands.project.create.errors.failedToFetchProjectList);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    }
+    const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, projectTemplates);
+    return { createProjectPromptResponse };
+}

package/lib/projects/create/legacy.d.ts

@@ -0,0 +1,6 @@
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+import { ProjectTemplate, ComponentTemplate, ProjectTemplateRepoConfig } from '../../../types/Projects';
+export declare const EMPTY_PROJECT_TEMPLATE_NAME = "no-template";
+export declare function getConfigForPlatformVersion(platformVersion: string): Promise<ProjectTemplateRepoConfig> | never;
+export declare function getProjectComponentListFromRepo(platformVersion: string): Promise<ComponentTemplate[]>;
+export declare function getProjectTemplateListFromRepo(templateSource: RepoPath, githubRef: string): Promise<ProjectTemplate[]>;

package/lib/projects/{create.js → create/legacy.js}

@@ -1,24 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMPTY_PROJECT_TEMPLATE_NAME = void 0;
+exports.getConfigForPlatformVersion = getConfigForPlatformVersion;
 exports.getProjectComponentListFromRepo = getProjectComponentListFromRepo;
 exports.getProjectTemplateListFromRepo = getProjectTemplateListFromRepo;
 const github_1 = require("@hubspot/local-dev-lib/api/github");
-const constants_1 = require("../constants");
-const exitCodes_1 = require("../enums/exitCodes");
-const index_1 = require("../errorHandlers/index");
-const en_1 = require("../../lang/en");
-const logger_1 = require("../ui/logger");
+const constants_1 = require("../../constants");
+const exitCodes_1 = require("../../enums/exitCodes");
+const errorHandlers_1 = require("../../errorHandlers");
+const logger_1 = require("../../ui/logger");
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const en_1 = require("../../../lang/en");
+const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
 exports.EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
-const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path', 'insertPath'];
-async function getProjectComponentListFromRepo(githubRef) {
+async function getConfigForPlatformVersion(platformVersion) {
+    let path = '';
+    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        path = `${platformVersion}/`;
+    }
+    const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, 'main');
+    return data;
+}
+async function getProjectComponentListFromRepo(platformVersion) {
     let config;
     try {
-        const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'config.json', githubRef);
-        config = data;
+        config = await getConfigForPlatformVersion(platformVersion);
     }
     catch (err) {
-        (0, index_1.debugError)(err);
+        (0, errorHandlers_1.debugError)(err);
     }
     if (config) {
         return config[constants_1.PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
@@ -32,7 +41,7 @@ async function getProjectTemplateListFromRepo(templateSource, githubRef) {
         config = data;
     }
     catch (e) {
-        (0, index_1.debugError)(e);
+        (0, errorHandlers_1.debugError)(e);
         logger_1.uiLogger.error(en_1.lib.projects.create.errors.missingConfigFileTemplateSource);
         return process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }

package/lib/projects/create/v3.d.ts

@@ -0,0 +1,27 @@
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project';
+import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
+export declare const EMPTY_PROJECT = "empty";
+export declare const PROJECT_WITH_APP = "app";
+export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
+    authType: string;
+    distribution: string;
+}>;
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, projectMetadata?: ProjectMetadata): ComponentTemplateChoice[];
+type V3ComponentInfo = {
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    componentTemplateChoices?: ComponentTemplateChoice[];
+};
+export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined): Promise<V3ComponentInfo>;
+export declare function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
+    createProjectPromptResponse: CreateProjectPromptResponse;
+    platformVersion: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    authType?: string;
+    distribution?: string;
+}): string[];
+export {};