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

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

@@ -1,24 +0,0 @@
-import { ArgumentsCamelCase } from 'yargs';
-import { ProjectTemplateRepoConfig } from '../../../types/Projects.js';
-import { SelectProjectTemplatePromptResponse, ProjectNameAndDestPromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
-import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs.js';
-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;
-    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
-    projectNameAndDestPromptResponse: ProjectNameAndDestPromptResponse;
-}>;

package/lib/projects/create/index.js

@@ -1,33 +0,0 @@
-import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
-import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
-import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
-import { isV2Project } from '../platformVersion.js';
-import { v2ComponentFlow } from './v2.js';
-import { getProjectTemplateListFromRepo } from './legacy.js';
-import { commands } from '../../../lang/en.js';
-export async function handleProjectCreationFlow(args) {
-    const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
-    const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
-    const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
-    if (isV2Project(platformVersion)) {
-        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
-        const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
-        return {
-            authType,
-            distribution,
-            repoConfig,
-            projectContents,
-            selectProjectTemplatePromptResponse,
-            projectNameAndDestPromptResponse,
-        };
-    }
-    const projectTemplates = await getProjectTemplateListFromRepo(repo, DEFAULT_PROJECT_TEMPLATE_BRANCH);
-    if (!projectTemplates.length) {
-        throw new Error(commands.project.create.errors.failedToFetchProjectList);
-    }
-    const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, projectTemplates);
-    return {
-        selectProjectTemplatePromptResponse,
-        projectNameAndDestPromptResponse,
-    };
-}

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

@@ -1,6 +0,0 @@
-import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
-import { ProjectTemplate, ComponentTemplate, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
-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/legacy.js

@@ -1,48 +0,0 @@
-import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
-import { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
-import { debugError } from '../../errorHandlers/index.js';
-import { isV2Project } from '../platformVersion.js';
-import { lib } from '../../../lang/en.js';
-const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
-export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
-export async function getConfigForPlatformVersion(platformVersion) {
-    let path = '';
-    if (isV2Project(platformVersion)) {
-        path = `${platformVersion}/`;
-    }
-    const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, DEFAULT_PROJECT_TEMPLATE_BRANCH);
-    return data;
-}
-export async function getProjectComponentListFromRepo(platformVersion) {
-    let config;
-    try {
-        config = await getConfigForPlatformVersion(platformVersion);
-    }
-    catch (err) {
-        debugError(err);
-    }
-    if (config) {
-        return config[PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
-    }
-    return [];
-}
-export async function getProjectTemplateListFromRepo(templateSource, githubRef) {
-    let config;
-    try {
-        const { data } = await fetchRepoFile(templateSource, 'config.json', githubRef);
-        config = data;
-    }
-    catch (e) {
-        debugError(e);
-        throw new Error(lib.projects.create.errors.missingConfigFileTemplateSource);
-    }
-    if (!config || !config[PROJECT_COMPONENT_TYPES.PROJECTS]) {
-        throw new Error(lib.projects.create.errors.noProjectsInConfig);
-    }
-    const templates = config[PROJECT_COMPONENT_TYPES.PROJECTS];
-    const templatesContainAllProperties = templates.every(config => PROJECT_TEMPLATE_PROPERTIES.every(p => Object.prototype.hasOwnProperty.call(config, p)));
-    if (!templatesContainAllProperties) {
-        throw new Error(lib.projects.create.errors.missingPropertiesInConfig);
-    }
-    return templates;
-}

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

@@ -1,26 +0,0 @@
-import { Separator } from '@inquirer/prompts';
-import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
-import type { ProjectMetadata } from '@hubspot/project-parsing-lib/projects';
-import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
-export declare function createV2App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
-    authType: string;
-    distribution: string;
-}>;
-export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, accountId: number, projectMetadata?: ProjectMetadata): Promise<(ComponentTemplateChoice | Separator)[]>;
-type V2ComponentInfo = {
-    authType?: string;
-    distribution?: string;
-    repoConfig?: ProjectTemplateRepoConfig;
-    projectContents?: string;
-    componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
-};
-export declare function v2ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V2ComponentInfo>;
-export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
-    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
-    platformVersion: string;
-    repoConfig?: ProjectTemplateRepoConfig;
-    projectContents?: string;
-    authType?: string;
-    distribution?: string;
-}): string[];
-export {};

package/lib/projects/create/v2.js

@@ -1,158 +0,0 @@
-import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, FEATURES, } from '../../constants.js';
-import { commands, lib } from '../../../lang/en.js';
-import { listPrompt } from '../../prompts/promptUtils.js';
-import { APP_EVENTS_KEY as AppEventsKey, PAGES_KEY as PagesKey, } from '@hubspot/project-parsing-lib/constants';
-import { isV2Project } from '../platformVersion.js';
-import path from 'path';
-import { getConfigForPlatformVersion } from './legacy.js';
-import { hasFeature } from '../../hasFeature.js';
-export async function createV2App(providedAuth, providedDistribution) {
-    let authType;
-    if (providedAuth &&
-        providedDistribution === marketplaceDistribution &&
-        providedAuth !== oAuth) {
-        throw new Error(lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
-    }
-    const distribution = providedDistribution ||
-        (await listPrompt(lib.projects.create.prompt.distribution, {
-            choices: [
-                {
-                    name: lib.projects.create.prompt.marketPlaceDistribution,
-                    value: marketplaceDistribution,
-                },
-                {
-                    name: lib.projects.create.prompt.privateDistribution,
-                    value: privateDistribution,
-                },
-            ],
-        }));
-    if (distribution === marketplaceDistribution) {
-        // This is the only valid auth type for marketplace
-        authType = oAuth;
-    }
-    else {
-        authType =
-            providedAuth ||
-                (await listPrompt(lib.projects.create.prompt.auth, {
-                    choices: [
-                        { name: lib.projects.create.prompt.staticAuth, value: staticAuth },
-                        { name: lib.projects.create.prompt.oauth, value: oAuth },
-                    ],
-                }));
-    }
-    return {
-        distribution: distribution,
-        authType: authType,
-    };
-}
-const componentTypeToGateMap = {
-    [AppEventsKey]: FEATURES.APP_EVENTS,
-    [PagesKey]: FEATURES.APPS_HOME,
-    'workflow-action-tool': FEATURES.AGENT_TOOLS,
-};
-export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
-    const enabledComponents = [];
-    const disabledComponents = [];
-    for (const template of components) {
-        const { supportedAuthTypes, supportedDistributions } = template;
-        const disabledReasons = [];
-        if (projectMetadata) {
-            const componentMetadata = projectMetadata.components[template.type];
-            if (!componentMetadata) {
-                disabledReasons.push(commands.project.add.error.invalidComponentType(template.type));
-            }
-            else {
-                const { count, maxCount } = componentMetadata;
-                if (count >= maxCount) {
-                    disabledReasons.push(commands.project.add.error.maxExceeded(maxCount));
-                }
-            }
-        }
-        if (Array.isArray(supportedAuthTypes) &&
-            authType &&
-            !supportedAuthTypes.includes(authType.toLowerCase())) {
-            const supportedAuthTypesString = supportedAuthTypes.join(', ');
-            disabledReasons.push(commands.project.add.error.authTypeNotAllowed(supportedAuthTypesString));
-        }
-        if (Array.isArray(supportedDistributions) &&
-            distribution &&
-            !supportedDistributions.includes(distribution.toLowerCase())) {
-            const supportedDistributionsString = supportedDistributions.join(', ');
-            disabledReasons.push(commands.project.add.error.distributionNotAllowed(supportedDistributionsString));
-        }
-        const templateGate = componentTypeToGateMap[template.cliSelector || template.type];
-        if (templateGate) {
-            const isUngated = await hasFeature(accountId, templateGate);
-            if (!isUngated) {
-                disabledReasons.unshift(commands.project.add.error.portalDoesNotHaveAccessToThisFeature());
-            }
-        }
-        if (disabledReasons.length > 0) {
-            disabledComponents.push({
-                name: `${template.label} [${template.cliSelector || template.type}]`,
-                value: template,
-                disabled: `– ${disabledReasons.join(' ')}`,
-            });
-        }
-        else {
-            enabledComponents.push({
-                name: `${template.label} [${template.cliSelector || template.type}]`,
-                value: template,
-            });
-        }
-    }
-    return disabledComponents.length
-        ? [...enabledComponents, ...disabledComponents]
-        : [...enabledComponents];
-}
-export async function v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
-    let repoConfig = undefined;
-    let authType;
-    let distribution;
-    repoConfig = await getConfigForPlatformVersion(platformVersion);
-    const projectContentsChoice = projectBase ||
-        (await listPrompt(commands.project.create.prompts.parentComponents, {
-            choices: [
-                {
-                    name: commands.project.create.prompts.emptyProject,
-                    value: EMPTY_PROJECT,
-                },
-                { name: commands.project.create.prompts.app, value: PROJECT_WITH_APP },
-            ],
-        }));
-    if (projectContentsChoice === PROJECT_WITH_APP) {
-        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV2App(providedAuth, providedDistribution);
-        authType = selectedAuthType;
-        distribution = selectedDistribution;
-    }
-    const componentTemplateChoices = await calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution, accountId);
-    return {
-        componentTemplateChoices,
-        authType,
-        distribution,
-        projectContents: projectContentsChoice,
-        repoConfig,
-    };
-}
-export function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
-    if (!isV2Project(platformVersion)) {
-        return [];
-    }
-    const components = selectProjectTemplatePromptResponse.componentTemplates?.map((componentTemplate) => {
-        return path.join(platformVersion, componentTemplate.path);
-    }) || [];
-    if (projectContents && projectContents !== EMPTY_PROJECT) {
-        const parentComponent = repoConfig?.parentComponents?.find(possibleParent => {
-            return (possibleParent.type === projectContents &&
-                possibleParent.authType === authType &&
-                possibleParent.distribution === distribution);
-        });
-        if (parentComponent) {
-            components.push(path.join(platformVersion, parentComponent.path));
-        }
-    }
-    if (repoConfig?.defaultFiles) {
-        components.push(path.join(platformVersion, repoConfig?.defaultFiles));
-    }
-    return components;
-}

package/lib/projects/deploy.d.ts

@@ -1,13 +0,0 @@
-import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
-export declare function validateBuildIdForDeploy(buildId: number, deployedBuildId: number | undefined, latestBuildId: number, projectName: string | undefined, accountId: number): boolean | string;
-export declare function logDeployErrors(errorData: {
-    message: string;
-    errors: Array<{
-        message: string;
-        subCategory: string;
-        context: {
-            COMPONENT_NAME: string;
-        };
-    }>;
-}): void;
-export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isV2Project: boolean, force: boolean): Promise<Deploy | undefined>;

package/lib/projects/deploy.js

@@ -1,76 +0,0 @@
-import { uiLogger } from '../ui/logger.js';
-import { commands } from '../../lang/en.js';
-import { PROJECT_ERROR_TYPES } from '../constants.js';
-import { deployProjectV1, deployProjectV2, } from '@hubspot/local-dev-lib/api/projects';
-import { pollDeployStatus } from './pollProjectBuildAndDeploy.js';
-export function validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId) {
-    if (Number(buildId) > latestBuildId) {
-        return commands.project.deploy.errors.buildIdDoesNotExist(accountId, buildId, projectName);
-    }
-    if (Number(buildId) === deployedBuildId) {
-        return commands.project.deploy.errors.buildAlreadyDeployed(accountId, buildId, projectName);
-    }
-    return true;
-}
-export function logDeployErrors(errorData) {
-    uiLogger.error(errorData.message);
-    errorData.errors.forEach(err => {
-        // This is how the pre-deploy check manifests itself in < 2025.2 projects
-        if (err.subCategory === PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS) {
-            uiLogger.log(commands.project.deploy.errors.deployContainsRemovals(err.context.COMPONENT_NAME));
-        }
-        else {
-            uiLogger.log(err.message);
-        }
-    });
-}
-function handleBlockedDeploy(deployResp) {
-    const deployCanBeForced = deployResp.issues.every(issue => issue.blockingMessages.every(message => message.isWarning));
-    uiLogger.log('');
-    if (deployCanBeForced) {
-        uiLogger.warn(commands.project.deploy.errors.deployWarningsHeader);
-        uiLogger.log('');
-    }
-    else {
-        uiLogger.error(commands.project.deploy.errors.deployBlockedHeader);
-        uiLogger.log('');
-    }
-    deployResp.issues.forEach(issue => {
-        if (issue.blockingMessages.length > 0) {
-            issue.blockingMessages.forEach(message => {
-                uiLogger.log(commands.project.deploy.errors.deployIssueComponentWarning(issue.uid, issue.componentTypeName, message.message));
-            });
-        }
-        else {
-            uiLogger.log(commands.project.deploy.errors.deployIssueComponentGeneric(issue.uid, issue.componentTypeName));
-        }
-        uiLogger.log('');
-    });
-}
-export async function handleProjectDeploy(targetAccountId, projectName, buildId, isV2Project, force) {
-    let deployId;
-    if (isV2Project) {
-        const { data: deployResp } = await deployProjectV2(targetAccountId, projectName, buildId, force);
-        if (!deployResp || deployResp.buildResultType !== 'DEPLOY_QUEUED') {
-            if (deployResp?.buildResultType === 'DEPLOY_BLOCKED') {
-                handleBlockedDeploy(deployResp);
-            }
-            else {
-                uiLogger.error(commands.project.deploy.errors.deploy);
-            }
-            return;
-        }
-        deployId = deployResp.id;
-    }
-    else {
-        const response = await deployProjectV1(targetAccountId, projectName, buildId, force);
-        const { data: deployResp } = response;
-        if (!deployResp) {
-            uiLogger.error(commands.project.deploy.errors.deploy);
-            return;
-        }
-        deployId = deployResp.id;
-    }
-    const deployResult = await pollDeployStatus(targetAccountId, projectName, Number(deployId), buildId);
-    return deployResult;
-}

package/lib/projects/ensureProjectExists.d.ts

@@ -1,11 +0,0 @@
-import { Project } from '@hubspot/local-dev-lib/types/Project';
-export declare function ensureProjectExists(accountId: number, projectName: string, { forceCreate, allowCreate, noLogs, withPolling, uploadCommand, }?: {
-    forceCreate?: boolean | undefined;
-    allowCreate?: boolean | undefined;
-    noLogs?: boolean | undefined;
-    withPolling?: boolean | undefined;
-    uploadCommand?: boolean | undefined;
-}): Promise<{
-    projectExists: boolean;
-    project?: Project;
-}>;

package/lib/projects/ensureProjectExists.js

@@ -1,89 +0,0 @@
-import { createProject, fetchProject, } from '@hubspot/local-dev-lib/api/projects';
-import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
-import { DEFAULT_POLLING_DELAY } from '../constants.js';
-import { promptUser } from '../prompts/promptUtils.js';
-import { uiAccountDescription } from '../ui/index.js';
-import SpinniesManager from '../ui/SpinniesManager.js';
-import { logError, ApiErrorContext } from '../errorHandlers/index.js';
-import { lib } from '../../lang/en.js';
-import { uiLogger } from '../ui/logger.js';
-async function pollFetchProject(accountId, projectName) {
-    // Temporary solution for gating slowness. Retry on 403 statusCode
-    return new Promise((resolve, reject) => {
-        let pollCount = 0;
-        SpinniesManager.add('pollFetchProject', {
-            text: lib.projects.pollFetchProject.checkingProject(uiAccountDescription(accountId)),
-        });
-        const pollInterval = setInterval(async () => {
-            try {
-                const response = await fetchProject(accountId, projectName);
-                if (response && response.data) {
-                    SpinniesManager.remove('pollFetchProject');
-                    clearInterval(pollInterval);
-                    resolve(response);
-                }
-            }
-            catch (err) {
-                if (isSpecifiedError(err, {
-                    statusCode: 403,
-                    category: 'GATED',
-                    subCategory: 'BuildPipelineErrorType.PORTAL_GATED',
-                }) &&
-                    pollCount < 15) {
-                    pollCount += 1;
-                }
-                else {
-                    SpinniesManager.remove('pollFetchProject');
-                    clearInterval(pollInterval);
-                    reject(err);
-                }
-            }
-        }, DEFAULT_POLLING_DELAY);
-    });
-}
-export async function ensureProjectExists(accountId, projectName, { forceCreate = false, allowCreate = true, noLogs = false, withPolling = false, uploadCommand = false, } = {}) {
-    const accountIdentifier = uiAccountDescription(accountId);
-    try {
-        const { data: project } = withPolling
-            ? await pollFetchProject(accountId, projectName)
-            : await fetchProject(accountId, projectName);
-        return { projectExists: !!project, project };
-    }
-    catch (err) {
-        if (isSpecifiedError(err, { statusCode: 404 })) {
-            let shouldCreateProject = forceCreate;
-            if (allowCreate && !shouldCreateProject) {
-                const promptLangFunction = uploadCommand
-                    ? lib.projects.ensureProjectExists.createPromptUpload
-                    : lib.projects.ensureProjectExists.createPrompt;
-                const promptResult = await promptUser([
-                    {
-                        name: 'shouldCreateProject',
-                        message: promptLangFunction(projectName, accountIdentifier),
-                        type: 'confirm',
-                    },
-                ]);
-                shouldCreateProject = promptResult.shouldCreateProject;
-            }
-            if (shouldCreateProject) {
-                try {
-                    const { data: project } = await createProject(accountId, projectName);
-                    uiLogger.success(lib.projects.ensureProjectExists.createSuccess(projectName, accountIdentifier));
-                    return { projectExists: true, project };
-                }
-                catch (err) {
-                    logError(err, new ApiErrorContext({ accountId }));
-                    return { projectExists: false };
-                }
-            }
-            else {
-                if (!noLogs) {
-                    uiLogger.log(lib.projects.ensureProjectExists.notFound(projectName, accountIdentifier));
-                }
-                return { projectExists: false };
-            }
-        }
-        logError(err, new ApiErrorContext({ accountId }));
-        return { projectExists: false };
-    }
-}

package/lib/projects/localDev/AppDevModeInterface.d.ts

@@ -1,41 +0,0 @@
-import { AppIRNode } from '../../../types/ProjectComponents.js';
-import LocalDevState from './LocalDevState.js';
-import LocalDevLogger from './LocalDevLogger.js';
-type AppDevModeInterfaceConstructorOptions = {
-    localDevState: LocalDevState;
-    localDevLogger: LocalDevLogger;
-};
-declare class AppDevModeInterface {
-    localDevState: LocalDevState;
-    localDevLogger: LocalDevLogger;
-    _appNode?: AppIRNode | null;
-    marketplaceAppInstalls?: number;
-    private appInstallResolve?;
-    constructor(options: AppDevModeInterfaceConstructorOptions);
-    private getAppNodeFromProjectNodes;
-    private get appNode();
-    private get appData();
-    private set appData(value);
-    private isStaticAuthApp;
-    private isOAuthApp;
-    private isAutomaticallyInstallable;
-    private getAppInstallUrl;
-    private fetchAppData;
-    private checkMarketplaceAppInstalls;
-    private waitUntilAppIsInstalled;
-    private autoInstallStaticAuthApp;
-    private installAppOrOpenInstallUrl;
-    private checkTestAccountAppInstallation;
-    private validateOauthAppRedirectUrl;
-    private resolveAppInstallPromise;
-    private handleAppInstallSuccessDevServerMessage;
-    private handleAppInstallInitiatedDevServerMessage;
-    private handleAppInstallFailureDevServerMessage;
-    private onDevServerMessage;
-    private onChangeProjectNodes;
-    private removeStateListeners;
-    setup(): Promise<void>;
-    start(): Promise<void>;
-    cleanup(): Promise<void>;
-}
-export default AppDevModeInterface;