@hubspot/cli 7.5.11-experimental.0 → 7.7.0-experimental.0

package/mcp-server/tools/UploadProjectTool.js

@@ -0,0 +1,149 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+import HubSpotCLIHelper from "./HubSpotCLIHelper.js";
+class UploadProjectTool extends MCPTool {
+    name = "uploadProject";
+    description = "Uploads a developer project to HubSpot using the HubSpot CLI";
+    cliHelper = new HubSpotCLIHelper();
+    schema = {
+        projectPath: {
+            type: z.string().optional(),
+            description: "Path to the project directory. Defaults to current directory",
+        },
+        accountId: {
+            type: z.string().optional(),
+            description: "HubSpot account ID to upload to. If not provided, uses CLI default or prompts",
+        },
+        autoInstallCLI: {
+            type: z.boolean().optional(),
+            description: "Whether to automatically install HubSpot CLI if not found. Defaults to false",
+        },
+    };
+    async execute(input) {
+        const { projectPath = ".", accountId, autoInstallCLI = false } = input;
+        try {
+            // Step 1: Check if HubSpot CLI is installed
+            const cliCheckResult = await this.cliHelper.checkCLIInstallation();
+            if (!cliCheckResult.isInstalled) {
+                if (autoInstallCLI) {
+                    // Attempt to install CLI automatically
+                    const installResult = await this.cliHelper.installCLI();
+                    if (!installResult.success) {
+                        return {
+                            status: "cli-install-failed",
+                            message: "❌ Failed to install HubSpot CLI automatically",
+                            error: installResult.error,
+                            actions: [
+                                {
+                                    action: "install-cli-manually",
+                                    command: "npm install -g @hubspot/cli",
+                                    description: "Install HubSpot CLI manually",
+                                },
+                            ],
+                            troubleshooting: [
+                                "Try installing the CLI manually: npm install -g @hubspot/cli",
+                                "Ensure you have npm installed and proper permissions",
+                                "Run the upload command again after CLI installation",
+                            ],
+                        };
+                    }
+                    // Verify installation was successful
+                    const recheckResult = await this.cliHelper.checkCLIInstallation();
+                    if (!recheckResult.isInstalled) {
+                        return {
+                            status: "cli-install-verification-failed",
+                            message: "❌ CLI installation completed but verification failed",
+                            troubleshooting: [
+                                "Try running 'hs --version' manually to verify installation",
+                                "Restart your terminal/shell session",
+                                "Check if the CLI was installed to the correct PATH",
+                            ],
+                        };
+                    }
+                }
+                else {
+                    return {
+                        status: "cli-not-found",
+                        message: "HubSpot CLI not found. Install it to upload projects.",
+                        actions: [
+                            {
+                                action: "install-cli",
+                                command: "npm install -g @hubspot/cli",
+                                description: "Install HubSpot CLI globally",
+                            },
+                        ],
+                        nextSteps: [
+                            "1. Install HubSpot CLI globally",
+                            "2. Authenticate with your HubSpot account (hs auth)",
+                            "3. Run project upload again",
+                        ],
+                    };
+                }
+            }
+            // Step 2: Build the upload command
+            let uploadCommand = "hs project upload";
+            if (accountId) {
+                uploadCommand += ` --account=${accountId}`;
+            }
+            // Step 3: Run project upload
+            const uploadResult = await this.cliHelper.runProjectCommand(uploadCommand, projectPath);
+            if (uploadResult.success) {
+                // Parse successful upload output
+                const output = uploadResult.output;
+                return {
+                    status: "success",
+                    message: "✅ Project uploaded successfully to HubSpot!",
+                    cliVersion: cliCheckResult.version,
+                    uploadOutput: output,
+                    accountId: accountId,
+                    projectPath: projectPath,
+                    nextSteps: [
+                        "1. Check your HubSpot account to verify the project appears",
+                        "2. Test your components in the HubSpot environment",
+                        "3. Monitor for any runtime errors or issues",
+                        "4. Use 'hs project logs' to view application logs if needed",
+                    ],
+                };
+            }
+            else {
+                // Parse upload failure
+                const errorOutput = uploadResult.output || uploadResult.error || "Upload failed";
+                return {
+                    status: "upload-failed",
+                    message: "❌ Project upload failed",
+                    cliVersion: cliCheckResult.version,
+                    uploadOutput: errorOutput,
+                    error: uploadResult.error,
+                    troubleshooting: [
+                        "Ensure you're authenticated: run 'hs auth' to login",
+                        "Verify your account has permission to upload projects",
+                        "Check that your project is valid: run 'hs project validate' first",
+                        "Ensure you have network connectivity to HubSpot",
+                        "Try uploading to a different account if you have access to multiple",
+                    ],
+                    nextSteps: [
+                        "1. Check authentication status: hs auth info",
+                        "2. Validate project first: hs project validate",
+                        "3. Review the error output above for specific issues",
+                        "4. Try the upload command again after fixing issues",
+                    ],
+                };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                status: "error",
+                message: "An error occurred during project upload",
+                error: errorMessage,
+                troubleshooting: [
+                    "Ensure you're in a valid developer project directory",
+                    "Check that hsproject.json exists in the project root",
+                    "Verify HubSpot CLI is properly installed and accessible",
+                    "Try running 'hs project upload' manually to see detailed output",
+                ],
+            };
+        }
+    }
+}
+export default UploadProjectTool;

package/mcp-server/tools/ValidateProjectTool.d.ts

@@ -0,0 +1,62 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+interface ValidateProjectInput {
+    autoFix?: boolean;
+    projectPath?: string;
+}
+interface ValidationResponse {
+    status: string;
+    message: string;
+    cliVersion?: string;
+    validationOutput?: string;
+    errors?: string[];
+    errorAnalysis?: Array<{
+        category: string;
+        issue: string;
+        severity: "error" | "warning";
+        component?: string;
+        file?: string;
+    }>;
+    suggestions?: string[];
+    nextSteps?: string[];
+    autoFixActions?: Array<{
+        action: string;
+        description: string;
+        command?: string;
+        tool?: string;
+    }>;
+    actions?: Array<{
+        action: string;
+        command: string;
+        description: string;
+    }>;
+    projectStructure?: string;
+    error?: string;
+    troubleshooting?: string[];
+}
+declare class ValidateProjectTool extends MCPTool<ValidateProjectInput> {
+    name: string;
+    description: string;
+    private cliHelper;
+    schema: {
+        autoFix: {
+            type: z.ZodOptional<z.ZodBoolean>;
+            description: string;
+        };
+        projectPath: {
+            type: z.ZodOptional<z.ZodString>;
+            description: string;
+        };
+    };
+    execute(input: ValidateProjectInput): Promise<ValidationResponse>;
+    private runProjectValidation;
+    private runCommand;
+    private parseValidationErrors;
+    private analyzeValidationErrors;
+    private extractComponentFromPath;
+    private generateFixSuggestions;
+    private extractFieldFromError;
+    private generateNextSteps;
+    private generateAutoFixActions;
+}
+export default ValidateProjectTool;

package/mcp-server/tools/ValidateProjectTool.js

@@ -0,0 +1,315 @@
+import { MCPTool } from "mcp-framework";
+import { z } from "zod";
+import HubSpotCLIHelper from "./HubSpotCLIHelper.js";
+class ValidateProjectTool extends MCPTool {
+    name = "validateProject";
+    description = "Validates a developer project using the HubSpot CLI and provides guidance for fixing any validation errors";
+    cliHelper = new HubSpotCLIHelper();
+    schema = {
+        autoFix: {
+            type: z.boolean().optional(),
+            description: "Whether to attempt automatic fixes for common validation errors. Defaults to false",
+        },
+        projectPath: {
+            type: z.string().optional(),
+            description: "Path to the project directory. Defaults to current directory",
+        },
+    };
+    async execute(input) {
+        const { autoFix = false, projectPath = "." } = input;
+        try {
+            // Step 1: Check if HubSpot CLI is installed
+            const cliCheckResult = await this.cliHelper.checkCLIInstallation();
+            if (!cliCheckResult.isInstalled) {
+                return {
+                    status: "cli-not-found",
+                    message: "HubSpot CLI not found. Installing...",
+                    actions: [
+                        {
+                            action: "install-cli",
+                            command: "npm install -g @hubspot/cli",
+                            description: "Installing HubSpot CLI globally",
+                        },
+                    ],
+                    nextSteps: [
+                        "1. Install HubSpot CLI globally",
+                        "2. Run project validation again",
+                        "3. Follow any additional guidance for fixing validation errors",
+                    ],
+                };
+            }
+            // Step 2: Run project validation
+            const validationResult = await this.runProjectValidation(projectPath);
+            if (validationResult.isValid) {
+                return {
+                    status: "valid",
+                    message: "✅ Project validation passed! Your developer project is properly configured.",
+                    cliVersion: cliCheckResult.version,
+                    validationOutput: validationResult.output,
+                    projectStructure: "All components and configurations follow platform conventions",
+                };
+            }
+            // Step 3: Parse validation errors and provide guidance
+            const errorAnalysis = this.analyzeValidationErrors(validationResult.errors);
+            const suggestions = this.generateFixSuggestions(errorAnalysis);
+            const response = {
+                status: "validation-failed",
+                message: "❌ Project validation failed. Here's how to fix the issues:",
+                cliVersion: cliCheckResult.version,
+                validationOutput: validationResult.output,
+                errors: validationResult.errors,
+                errorAnalysis: errorAnalysis,
+                suggestions: suggestions,
+                nextSteps: this.generateNextSteps(errorAnalysis, autoFix),
+            };
+            if (autoFix) {
+                response.autoFixActions = this.generateAutoFixActions(errorAnalysis);
+            }
+            return response;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            return {
+                status: "error",
+                message: "An error occurred during project validation",
+                error: errorMessage,
+                troubleshooting: [
+                    "Ensure you're in a valid developer project directory",
+                    "Check that hsproject.json exists in the project root",
+                    "Verify HubSpot CLI is properly installed and accessible",
+                    "Try running 'hs project validate' manually to see detailed output",
+                ],
+            };
+        }
+    }
+    async runProjectValidation(projectPath) {
+        try {
+            const result = await this.cliHelper.runProjectCommand("hs project validate", projectPath);
+            if (result.success) {
+                // Parse the validation output to determine if it passed
+                const output = result.output;
+                // Check for validation success indicators
+                const isValid = output.includes("✅") ||
+                    output.includes("Project validation passed") ||
+                    output.includes("valid") ||
+                    !output.includes("Project validation failed:");
+                // Parse structured validation errors if present
+                const errors = [];
+                if (!isValid && output.includes("Project validation failed:")) {
+                    errors.push(...this.parseValidationErrors(output));
+                }
+                return {
+                    isValid: isValid,
+                    output: output,
+                    errors: errors,
+                };
+            }
+            else {
+                // Command failed to run
+                const errorMessage = result.error || "Failed to run project validation";
+                return {
+                    isValid: false,
+                    output: result.output || "",
+                    errors: [errorMessage],
+                };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown validation error";
+            throw new Error(`Failed to run project validation: ${errorMessage}`);
+        }
+    }
+    runCommand(command) {
+        // Delegate to the CLI helper
+        return this.cliHelper.runCommand(command);
+    }
+    parseValidationErrors(output) {
+        const errors = [];
+        const lines = output.split("\n");
+        let currentFile = "";
+        let inErrorSection = false;
+        for (const line of lines) {
+            // Look for file error headers like "Encountered the following errors for src/app/file.json:"
+            const fileMatch = line.match(/Encountered the following errors for (.+?):/);
+            if (fileMatch) {
+                currentFile = fileMatch[1];
+                inErrorSection = true;
+                continue;
+            }
+            // Parse individual error lines (start with tab and dash)
+            if (inErrorSection && line.match(/^\s*-\s+/)) {
+                const errorText = line.replace(/^\s*-\s+/, "").trim();
+                if (errorText) {
+                    errors.push(`${currentFile}: ${errorText}`);
+                }
+                continue;
+            }
+            // Handle multi-line errors with additional indentation
+            if (inErrorSection && line.match(/^\s{2,}-\s+/)) {
+                const errorText = line.replace(/^\s*-\s+/, "").trim();
+                if (errorText && errors.length > 0) {
+                    // Append to the last error as additional context
+                    errors[errors.length - 1] += `\n  ${errorText}`;
+                }
+                continue;
+            }
+            // Reset when we hit an empty line or new section
+            if (line.trim() === "" ||
+                (!line.startsWith("\t") && !line.startsWith(" "))) {
+                inErrorSection = false;
+                currentFile = "";
+            }
+        }
+        return errors;
+    }
+    analyzeValidationErrors(errors) {
+        const analysis = [];
+        for (const error of errors) {
+            const filePath = error.split(":")[0];
+            const errorMessage = error.substring(error.indexOf(":") + 1).trim();
+            let category = "unknown";
+            let component = "unknown";
+            let severity = "error";
+            // Extract file information
+            if (filePath.includes("hsproject.json")) {
+                category = "project-config";
+                component = "project";
+            }
+            else if (filePath.includes("-hsmeta.json")) {
+                category = "component-config";
+                component = this.extractComponentFromPath(filePath);
+            }
+            else if (filePath.includes("package.json")) {
+                category = "dependencies";
+                component = this.extractComponentFromPath(filePath);
+                severity = "warning";
+            }
+            // Analyze error message content
+            if (errorMessage.includes("Invalid JSON")) {
+                category = "json-syntax";
+            }
+            else if (errorMessage.includes("Missing required field")) {
+                category = "required-field";
+            }
+            else if (errorMessage.includes("must NOT have additional properties")) {
+                category = "schema-validation";
+            }
+            else if (errorMessage.includes("entrypoint")) {
+                category = "entrypoint";
+            }
+            analysis.push({
+                category: category,
+                issue: errorMessage,
+                severity: severity,
+                component: component,
+                file: filePath,
+            });
+        }
+        return analysis;
+    }
+    extractComponentFromPath(filePath) {
+        // Extract component type from file path like "src/app/cards/my-card-hsmeta.json"
+        if (filePath.includes("/app/")) {
+            const pathParts = filePath.split("/app/")[1].split("/");
+            if (pathParts.length > 1) {
+                return pathParts[0]; // e.g., "cards", "functions", etc.
+            }
+            return "app";
+        }
+        // Handle top-level app component files
+        if (filePath.includes("-hsmeta.json")) {
+            return "app";
+        }
+        return "unknown";
+    }
+    generateFixSuggestions(errorAnalysis) {
+        const suggestions = [];
+        for (const error of errorAnalysis) {
+            switch (error.category) {
+                case "project-config":
+                    suggestions.push("Fix hsproject.json: Ensure it contains 'name', 'srcDir', and 'platformVersion' fields", "Use the generateProjectConfig tool to create a valid hsproject.json file");
+                    break;
+                case "component-config":
+                    suggestions.push(`Fix ${error.component} component: Check the *-hsmeta.json file structure`, "Ensure the component follows the envelope pattern: uid, type, config", `Use the appropriate generate component tool for ${error.component} type`);
+                    break;
+                case "json-syntax":
+                    suggestions.push(`Fix JSON syntax error in ${error.file}`, "Check for missing commas, brackets, or quotes in the JSON file", "Use a JSON validator to identify the specific syntax issue");
+                    break;
+                case "required-field":
+                    suggestions.push(`Add missing required field: ${this.extractFieldFromError(error.issue)}`, `Update ${error.file} to include all required fields`, "Refer to the platform documentation for required field specifications");
+                    break;
+                case "schema-validation":
+                    suggestions.push(`Fix schema validation error in ${error.file}`, "Remove additional properties that are not allowed", `Check ${error.component} component schema requirements`, "Ensure all field types match the expected schema");
+                    break;
+                case "dependencies":
+                    suggestions.push("Fix package.json: Ensure React and @hubspot/ui-extensions dependencies are present", "Run 'npm install' to install missing dependencies", "Check that package.json is in the correct component directory");
+                    break;
+                case "entrypoint":
+                    suggestions.push("Fix component entrypoint: Ensure the React file exists at the specified path", "Check that the entrypoint path in *-hsmeta.json matches the actual file location", "Verify the React component exports properly");
+                    break;
+                default:
+                    suggestions.push(`Review error in ${error.file || "project"}: ${error.issue}`);
+            }
+        }
+        return [...new Set(suggestions)]; // Remove duplicates
+    }
+    extractFieldFromError(errorMessage) {
+        // Extract field name from messages like "Missing required field: config.description"
+        const match = errorMessage.match(/Missing required field:\s*(.+)/);
+        return match ? match[1] : "unknown field";
+    }
+    generateNextSteps(errorAnalysis, autoFix) {
+        const steps = [];
+        if (autoFix) {
+            steps.push("1. Review auto-fix actions and apply them");
+        }
+        else {
+            steps.push("1. Review the validation errors and suggestions above");
+        }
+        const hasProjectConfig = errorAnalysis.some((e) => e.category === "project-config");
+        const hasComponentIssues = errorAnalysis.some((e) => e.category === "component-config");
+        const hasDependencyIssues = errorAnalysis.some((e) => e.category === "dependencies");
+        if (hasProjectConfig) {
+            steps.push("2. Fix hsproject.json configuration issues first");
+        }
+        if (hasComponentIssues) {
+            steps.push("3. Fix component configuration issues");
+        }
+        if (hasDependencyIssues) {
+            steps.push("4. Install missing dependencies");
+        }
+        steps.push("5. Run validation again to verify fixes");
+        steps.push("6. Test your components work correctly in development");
+        return steps;
+    }
+    generateAutoFixActions(errorAnalysis) {
+        const actions = [];
+        for (const error of errorAnalysis) {
+            switch (error.category) {
+                case "project-config":
+                    actions.push({
+                        action: "fix-project-config",
+                        description: "Generate valid hsproject.json configuration",
+                        tool: "generateProjectConfig",
+                    });
+                    break;
+                case "dependencies":
+                    actions.push({
+                        action: "install-dependencies",
+                        description: "Install missing npm dependencies",
+                        command: "npm install",
+                    });
+                    break;
+                case "component-config":
+                    actions.push({
+                        action: "fix-component-config",
+                        description: `Fix ${error.component} component configuration`,
+                        tool: `generate${error.component}Component`,
+                    });
+                    break;
+            }
+        }
+        return actions;
+    }
+}
+export default ValidateProjectTool;

package/package.json

@@ -1,15 +1,16 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.5.11-experimental.0",
+    "version": "7.7.0-experimental.0",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "dependencies": {
-        "@hubspot/local-dev-lib": "3.5.5",
-        "@hubspot/project-parsing-lib": "0.0.20-experimental.0",
+        "@hubspot/local-dev-lib": "3.7.0",
+        "@hubspot/project-parsing-lib": "0.2.0",
         "@hubspot/serverless-dev-runtime": "7.0.2",
         "@hubspot/theme-preview-dev-server": "0.0.10",
         "@hubspot/ui-extensions-dev-server": "0.8.52",
+        "@modelcontextprotocol/sdk": "^1.12.1",
         "archiver": "7.0.1",
         "boxen": "8.0.1",
         "chalk": "4.1.2",
@@ -21,6 +22,7 @@
         "fs-extra": "8.1.0",
         "inquirer": "8.2.0",
         "js-yaml": "4.1.0",
+        "mcp-framework": "^0.2.2",
         "moment": "2.30.1",
         "open": "7.4.2",
         "p-queue": "6.6.2",
@@ -28,6 +30,7 @@
         "table": "6.9.0",
         "tmp": "0.2.3",
         "update-notifier": "5.1.0",
+        "ws": "^8.18.2",
         "yargs": "17.7.2",
         "yargs-parser": "21.1.1"
     },
@@ -41,6 +44,7 @@
         "@types/js-yaml": "^4.0.9",
         "@types/semver": "^7.5.8",
         "@types/tmp": "^0.2.6",
+        "@types/ws": "^8.18.1",
         "@types/yargs": "^17.0.33",
         "@typescript-eslint/eslint-plugin": "^8.30.1",
         "@typescript-eslint/parser": "^8.11.0",
@@ -63,10 +67,12 @@
     },
     "scripts": {
         "build": "ts-node ./scripts/build.ts",
-        "lint": "eslint . && prettier --list-different './**/*.{ts,js,json}'",
+        "lint": "echo 'Linting is disabled for Blazar'",
+        "lint:local": "eslint . && prettier --list-different './**/*.{ts,js,json}'",
         "list-all-commands": "yarn ts-node ./scripts/get-all-commands.ts",
+        "local-link": "yarn ts-node ./scripts/linking.ts",
         "prettier:write": "prettier --write './**/*.{ts,js,json}'",
-        "test": "yarn node --experimental-vm-modules $(yarn bin jest)",
+        "test": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
         "test-cli": "yarn build && yarn --cwd 'acceptance-tests' test-ci",
         "test-cli-debug": "yarn build && yarn --cwd 'acceptance-tests' test-debug",
         "test-cli-qa": "yarn build && yarn --cwd 'acceptance-tests' test-qa",
@@ -94,7 +100,8 @@
     },
     "bin": {
         "hs": "./bin/hs",
-        "hscms": "./bin/hscms"
+        "hscms": "./bin/hscms",
+        "hsmcp": "./bin/hsmcp.js"
     },
     "publishConfig": {
         "access": "public",

package/types/Cms.d.ts

@@ -0,0 +1,30 @@
+import { CommonArgs, ConfigArgs } from './Yargs';
+export type CreateArgs = CommonArgs & ConfigArgs & {
+    branch?: string;
+    type: string;
+    dest: string;
+    name: string;
+    internal?: boolean;
+};
+export type CmsAssetOperationArgs = {
+    assetType: string;
+    name: string;
+    dest: string;
+    getInternalVersion: boolean;
+    commandArgs: CreateArgs;
+};
+export type CreatableCmsAsset = {
+    hidden: boolean;
+    dest: (args: CmsAssetOperationArgs) => string;
+    validate?: (args: CmsAssetOperationArgs) => boolean;
+    execute: (args: CmsAssetOperationArgs) => Promise<void>;
+};
+export type ApiSampleChoice = {
+    name: string;
+    description: string;
+    id: string;
+    languages: string[];
+};
+export type ApiSampleConfig = {
+    samples: ApiSampleChoice[];
+};

package/types/Cms.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/LocalDev.d.ts

@@ -0,0 +1,24 @@
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { ProjectConfig } from './Projects';
+import LocalDevState from '../lib/projects/localDev/LocalDevState';
+export type LocalDevStateConstructorOptions = {
+    targetProjectAccountId: number;
+    targetTestingAccountId: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    projectId: number;
+    debug?: boolean;
+    deployedBuild?: Build;
+    isGithubLinked: boolean;
+    initialProjectNodes: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    env: Environment;
+};
+export type LocalDevWebsocketMessage = {
+    type: string;
+    data: unknown;
+};
+export type LocalDevStateListener<K extends keyof LocalDevState> = (value: LocalDevState[K]) => void;

package/types/LocalDev.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/Prompts.d.ts

@@ -1,4 +1,3 @@
-import { DeveloperTestAccount } from '@hubspot/local-dev-lib/types/developerTestAccounts';
 export type GenericPromptResponse = {
     [key: string]: any;
 };
@@ -23,10 +22,4 @@ export type PromptConfig<T extends GenericPromptResponse> = {
     mask?: string;
     filter?: (input: string) => string;
 };
-export type ProjectDevTargetAccountPromptResponse = {
-    targetAccountId: number | null;
-    createNestedAccount: boolean;
-    parentAccountId?: number | null;
-    notInConfigAccount?: DeveloperTestAccount | null;
-};
 export {};