@botonic/nx-plugin 2.23.0

package/src/generators/shared/bot-app-utils.js

@@ -0,0 +1,209 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bot_app_utils_exports = {};
+__export(bot_app_utils_exports, {
+  addActionImportToRoutes: () => addActionImportToRoutes,
+  addConstEntry: () => addConstEntry,
+  addExportToIndex: () => addExportToIndex,
+  insertRouteBeforeFlowBuilder: () => insertRouteBeforeFlowBuilder,
+  resolveStandardPaths: () => resolveStandardPaths,
+  validateBotAppProject: () => validateBotAppProject
+});
+module.exports = __toCommonJS(bot_app_utils_exports);
+var import_devkit = require("@nx/devkit");
+function validateBotAppProject(tree, projectName) {
+  const projects = (0, import_devkit.getProjects)(tree);
+  const project = projects.get(projectName);
+  if (!project) {
+    throw new Error(`Project "${projectName}" not found`);
+  }
+  if (!project.tags?.includes("botonic:bot-app")) {
+    throw new Error(
+      `Project "${projectName}" is not a botonic bot application. Make sure it has the "botonic:bot-app" tag.`
+    );
+  }
+  const projectConfig = (0, import_devkit.readProjectConfiguration)(tree, projectName);
+  const projectRoot = projectConfig.root;
+  const sourceRoot = projectConfig.sourceRoot || `${projectRoot}/src`;
+  return { projectRoot, sourceRoot };
+}
+function resolveStandardPaths(sourceRoot) {
+  return {
+    constantsPath: `${sourceRoot}/shared/constants.ts`,
+    actionsPath: `${sourceRoot}/server/bot/actions`,
+    routesPath: `${sourceRoot}/server/bot/routes.ts`,
+    customMessagesPath: `${sourceRoot}/client/custom-messages`,
+    webviewsPath: `${sourceRoot}/client/webviews`
+  };
+}
+function addExportToIndex(tree, indexPath, exportStatement) {
+  if (!tree.exists(indexPath)) {
+    tree.write(indexPath, `${exportStatement}
+`);
+    return;
+  }
+  const content = tree.read(indexPath, "utf-8");
+  if (!content.includes(exportStatement)) {
+    tree.write(indexPath, content.trimEnd() + "\n" + exportStatement + "\n");
+  }
+}
+function addConstEntry(tree, filePath, constName, key, value) {
+  if (!tree.exists(filePath)) {
+    return;
+  }
+  const content = tree.read(filePath, "utf-8");
+  if (content.includes(`${key}:`) || content.includes(`${key} =`)) {
+    return;
+  }
+  const lines = content.split("\n");
+  const constStartIndex = lines.findIndex(
+    (line) => line.includes(`export const ${constName}`)
+  );
+  if (constStartIndex === -1) {
+    return;
+  }
+  let closingBraceIndex = constStartIndex;
+  let braceCount = 0;
+  for (let i = constStartIndex; i < lines.length; i++) {
+    for (const char of lines[i]) {
+      if (char === "{") braceCount++;
+      if (char === "}") braceCount--;
+    }
+    if (braceCount === 0 && i > constStartIndex) {
+      closingBraceIndex = i;
+      break;
+    }
+    if (i === constStartIndex && braceCount === 0) {
+      closingBraceIndex = i;
+      break;
+    }
+  }
+  const newEntry = `  ${key}: '${value}',`;
+  if (closingBraceIndex === constStartIndex) {
+    lines[closingBraceIndex] = lines[closingBraceIndex].replace(
+      "{}",
+      `{
+${newEntry}
+}`
+    );
+  } else {
+    lines.splice(closingBraceIndex, 0, newEntry);
+  }
+  tree.write(filePath, lines.join("\n"));
+}
+function insertRouteBeforeFlowBuilder(tree, routesPath, routeLines) {
+  if (!tree.exists(routesPath)) {
+    console.warn(
+      `Routes file not found at ${routesPath}. Skipping route addition.`
+    );
+    return;
+  }
+  const content = tree.read(routesPath, "utf-8");
+  const lines = content.split("\n");
+  let insertIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes("path: 'flow-builder'") || lines[i].includes("path:") && lines[i].includes("flow-builder")) {
+      for (let j = i - 1; j >= 0; j--) {
+        if (lines[j].trim() === "{") {
+          insertIndex = j;
+          break;
+        }
+      }
+      break;
+    }
+  }
+  if (insertIndex === -1) {
+    console.warn("Could not find flow-builder route. Skipping route addition.");
+    return;
+  }
+  const routeAlreadyExists = routeLines.some(
+    (rl) => lines.some((l) => l.includes(rl.trim()) && rl.trim().length > 2)
+  );
+  if (routeAlreadyExists) {
+    return;
+  }
+  for (let i = routeLines.length - 1; i >= 0; i--) {
+    lines.splice(insertIndex, 0, routeLines[i]);
+  }
+  tree.write(routesPath, lines.join("\n"));
+}
+function addActionImportToRoutes(tree, routesPath, actionName) {
+  if (!tree.exists(routesPath)) {
+    return;
+  }
+  const content = tree.read(routesPath, "utf-8");
+  if (content.includes(actionName)) {
+    return;
+  }
+  const lines = content.split("\n");
+  let importStartIndex = -1;
+  let importEndIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes("import") && lines[i].includes("'./actions'")) {
+      importStartIndex = i;
+      importEndIndex = i;
+      break;
+    }
+    if (lines[i].includes("import {") && lines.slice(i, i + 15).some((l) => l.includes("from './actions'"))) {
+      importStartIndex = i;
+      for (let j = i; j < lines.length; j++) {
+        if (lines[j].includes("from './actions'")) {
+          importEndIndex = j;
+          break;
+        }
+      }
+      break;
+    }
+  }
+  if (importStartIndex === -1) {
+    let lastImportIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith("import ")) lastImportIndex = i;
+    }
+    const insertAt = lastImportIndex + 1;
+    lines.splice(insertAt, 0, `import { ${actionName} } from './actions'`);
+    tree.write(routesPath, lines.join("\n"));
+    return;
+  }
+  if (importStartIndex === importEndIndex) {
+    const importMatch = lines[importStartIndex].match(
+      /import\s*\{([^}]*)\}\s*from/
+    );
+    if (importMatch) {
+      const existing = importMatch[1].trim();
+      const newImports = existing ? `${existing}, ${actionName}` : actionName;
+      lines[importStartIndex] = lines[importStartIndex].replace(
+        importMatch[1],
+        ` ${newImports} `
+      );
+    }
+  } else {
+    lines.splice(importEndIndex, 0, `  ${actionName},`);
+  }
+  tree.write(routesPath, lines.join("\n"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addActionImportToRoutes,
+  addConstEntry,
+  addExportToIndex,
+  insertRouteBeforeFlowBuilder,
+  resolveStandardPaths,
+  validateBotAppProject
+});

package/src/generators/webview/files/__name__.spec.tsx.template

@@ -0,0 +1,20 @@
+import { render, screen } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@botonic/webviews', () => ({
+  useWebviewRequest: () => ({ closeWebview: vi.fn() }),
+  WebviewFrame: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+  WebviewHeader: ({ title }: { title: string }) => <div>{title}</div>,
+  WebviewBody: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+}))
+
+import React from 'react'
+
+import { <%= className %> } from './<%= fileName %>'
+
+describe('<%= className %>', () => {
+  it('should render successfully', () => {
+    render(<<%= className %> />)
+    expect(screen.getByText('<%= className %>')).toBeInTheDocument()
+  })
+})

package/src/generators/webview/files/__name__.tsx.template

@@ -0,0 +1,19 @@
+import {
+  useWebviewRequest,
+  WebviewBody,
+  WebviewFrame,
+  WebviewHeader,
+} from '@botonic/webviews'
+
+export const <%= className %> = () => {
+  const { closeWebview } = useWebviewRequest()
+
+  return (
+    <WebviewFrame>
+      <WebviewHeader title='<%= className %>' />
+      <WebviewBody variant='padded'>
+        <p>TODO: Implement <%= className %> webview</p>
+      </WebviewBody>
+    </WebviewFrame>
+  )
+}

package/src/generators/webview/generator.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import type { WebviewGeneratorSchema } from './schema';
+export default function (tree: Tree, options: WebviewGeneratorSchema): Promise<void>;
+export { WebviewGeneratorSchema };

package/src/generators/webview/generator.js

@@ -0,0 +1,179 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generator_exports = {};
+__export(generator_exports, {
+  default: () => generator_default
+});
+module.exports = __toCommonJS(generator_exports);
+var import_devkit = require("@nx/devkit");
+var import_bot_app_utils = require("../shared/bot-app-utils");
+const MODULE_DIR = __dirname;
+function normalizeOptions(tree, options) {
+  const { projectRoot, sourceRoot } = (0, import_bot_app_utils.validateBotAppProject)(
+    tree,
+    options.project
+  );
+  const paths = (0, import_bot_app_utils.resolveStandardPaths)(sourceRoot);
+  const name = (0, import_devkit.names)(options.name);
+  const fileName = name.fileName;
+  const className = name.className;
+  const constantName = name.constantName.toUpperCase();
+  return {
+    ...options,
+    projectName: options.project,
+    projectRoot,
+    fileName,
+    className,
+    constantName,
+    webviewsPath: paths.webviewsPath,
+    constantsPath: paths.constantsPath
+  };
+}
+function addFilesToProject(tree, options) {
+  const name = (0, import_devkit.names)(options.name);
+  const templateOptions = {
+    ...options,
+    ...name,
+    name: name.fileName
+    // __name__ in filenames must be kebab-case
+  };
+  (0, import_devkit.generateFiles)(
+    tree,
+    (0, import_devkit.joinPathFragments)(MODULE_DIR, "files"),
+    options.webviewsPath,
+    templateOptions
+  );
+  if (options.skipTests) {
+    const testFilePath = `${options.webviewsPath}/${options.fileName}.spec.tsx`;
+    if (tree.exists(testFilePath)) {
+      tree.delete(testFilePath);
+    }
+  }
+}
+function updateConstantsFile(tree, options) {
+  if (!tree.exists(options.constantsPath)) {
+    tree.write(
+      options.constantsPath,
+      `export const CUSTOM_MESSAGE_TYPES = {
+  // Add your custom message types here
+} as const
+
+export const WEBVIEWS = {
+  ${options.constantName}: '${options.fileName}',
+} as const
+
+export const PAYLOADS = {
+  // Add your payloads here
+} as const
+`
+    );
+    return;
+  }
+  (0, import_bot_app_utils.addConstEntry)(
+    tree,
+    options.constantsPath,
+    "WEBVIEWS",
+    options.constantName,
+    options.fileName
+  );
+}
+function updateWebviewsIndex(tree, options) {
+  const indexPath = `${options.webviewsPath}/index.tsx`;
+  if (!tree.exists(indexPath)) {
+    console.warn(
+      `Webviews index not found at ${indexPath}. Skipping registration.`
+    );
+    return;
+  }
+  const content = tree.read(indexPath, "utf-8");
+  const lines = content.split("\n");
+  const componentImport = `import { ${options.className} } from './${options.fileName}'`;
+  if (!content.includes(componentImport)) {
+    let lastImportIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith("import ")) lastImportIndex = i;
+    }
+    lines.splice(lastImportIndex + 1, 0, componentImport);
+  }
+  if (!content.includes("WEBVIEWS")) {
+    const sharedImport = `import { WEBVIEWS } from '../../shared/constants'`;
+    let lastImportIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].startsWith("import ")) lastImportIndex = i;
+    }
+    lines.splice(lastImportIndex, 0, sharedImport);
+  }
+  const newEntry = [
+    `  {`,
+    `    path: WEBVIEWS.${options.constantName},`,
+    `    component: ${options.className},`,
+    `    allowClose: true,`,
+    `  },`
+  ];
+  const alreadyRegistered = lines.some(
+    (l) => l.includes(`WEBVIEWS.${options.constantName}`)
+  );
+  if (!alreadyRegistered) {
+    let arrayCloseIndex = -1;
+    let inArray = false;
+    let depth = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes("WebviewDefinition[]") || lines[i].includes("const webviews")) {
+        inArray = true;
+      }
+      if (inArray) {
+        for (const char of lines[i]) {
+          if (char === "[") depth++;
+          if (char === "]") depth--;
+        }
+        if (depth === 0 && inArray && lines[i].includes("]")) {
+          arrayCloseIndex = i;
+          break;
+        }
+      }
+    }
+    if (arrayCloseIndex !== -1) {
+      for (let i = newEntry.length - 1; i >= 0; i--) {
+        lines.splice(arrayCloseIndex, 0, newEntry[i]);
+      }
+    }
+  }
+  tree.write(indexPath, lines.join("\n"));
+}
+async function generator_default(tree, options) {
+  console.log(`Creating webview: ${options.name}`);
+  const normalizedOptions = normalizeOptions(tree, options);
+  console.log(`Project: ${normalizedOptions.projectName}`);
+  console.log(`Location: ${normalizedOptions.webviewsPath}`);
+  addFilesToProject(tree, normalizedOptions);
+  updateConstantsFile(tree, normalizedOptions);
+  updateWebviewsIndex(tree, normalizedOptions);
+  await (0, import_devkit.formatFiles)(tree);
+  console.log(`
+Successfully created webview: ${normalizedOptions.className}`);
+  console.log(`Next steps:`);
+  console.log(
+    `  1. Implement the UI in: ${normalizedOptions.webviewsPath}/${normalizedOptions.fileName}.tsx`
+  );
+  if (!options.skipTests) {
+    console.log(
+      `  2. Update the tests in: ${normalizedOptions.webviewsPath}/${normalizedOptions.fileName}.spec.tsx`
+    );
+  }
+}

package/src/generators/webview/schema.d.ts

@@ -0,0 +1,5 @@
+export interface WebviewGeneratorSchema {
+    name: string;
+    project: string;
+    skipTests?: boolean;
+}

package/src/generators/webview/schema.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+module.exports = __toCommonJS(schema_exports);

package/src/generators/webview/schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "Webview",
+  "title": "Create a webview component for Botonic",
+  "description": "Generate a client-side webview component with automatic registration in the webviews app.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the webview component.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the webview?",
+      "pattern": "^[a-zA-Z].*$"
+    },
+    "project": {
+      "type": "string",
+      "description": "The name of the botonic project to add the webview to.",
+      "x-prompt": "Which botonic project should this webview be added to?",
+      "$default": {
+        "$source": "projectName"
+      }
+    },
+    "skipTests": {
+      "type": "boolean",
+      "description": "Skip generating test files.",
+      "default": false
+    }
+  },
+  "required": ["name", "project"]
+}

package/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from './generators/bot-app/generator';
+export * from './generators/preset/generator';
+export { default as buildNodeAppExecutor } from './executors/build-node-app/executor';
+export { default as runLambdaExecutor } from './executors/run-lambda/executor';
+export { default as serveBotExecutor } from './executors/serve-bot/executor';
+export * from './lib';
+export { BotonicPlugin, createNodesV2 } from './plugin';

package/src/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  BotonicPlugin: () => import_plugin.BotonicPlugin,
+  buildNodeAppExecutor: () => import_executor.default,
+  createNodesV2: () => import_plugin.createNodesV2,
+  runLambdaExecutor: () => import_executor2.default,
+  serveBotExecutor: () => import_executor3.default
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./generators/bot-app/generator"), module.exports);
+__reExport(src_exports, require("./generators/preset/generator"), module.exports);
+var import_executor = __toESM(require("./executors/build-node-app/executor"));
+var import_executor2 = __toESM(require("./executors/run-lambda/executor"));
+var import_executor3 = __toESM(require("./executors/serve-bot/executor"));
+__reExport(src_exports, require("./lib"), module.exports);
+var import_plugin = require("./plugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotonicPlugin,
+  buildNodeAppExecutor,
+  createNodesV2,
+  runLambdaExecutor,
+  serveBotExecutor,
+  ...require("./generators/bot-app/generator"),
+  ...require("./generators/preset/generator"),
+  ...require("./lib")
+});

package/src/lib/api-service.d.ts

@@ -0,0 +1,110 @@
+import { AxiosHeaders, AxiosInstance, AxiosResponse } from 'axios';
+import { BotConfigJSON } from './bot-config';
+import { BotCredentialsHandler, GlobalCredentialsHandler } from './credentials-handler';
+import type { BotDetail, Me, OAuth } from './interfaces';
+interface IntegrationResponse {
+    detail: string;
+    provider_account: {
+        id: string;
+        bot_id: string;
+        provider: string;
+        name: string;
+        username: string;
+        phone_number: string | null;
+        credentials: string | null;
+        credentials_json: any;
+        netlify_url: string;
+        is_playground: boolean;
+        is_whatsapp_cloud: boolean;
+        created_by_id: string;
+        chat_count: number;
+        is_active: boolean;
+        is_test: boolean;
+        imp_id: string;
+        is_preview: boolean;
+    };
+    netlify_url: string | null;
+}
+interface BotonicAPIServiceConfig {
+    isLocalRuntimeDeployment?: boolean;
+    projectRoot?: string;
+    /** Monorepo/workspace root. When set, global credentials are stored at workspaceRoot/.botonic/credentials.json (source of truth). */
+    workspaceRoot?: string;
+    environmentVariables?: Record<string, string>;
+    targetEnvironment?: string;
+}
+export declare class BotonicAPIService {
+    clientId: string;
+    baseUrl: string;
+    loginUrl: string;
+    botCredentialsHandler: InstanceType<typeof BotCredentialsHandler>;
+    globalCredentialsHandler: InstanceType<typeof GlobalCredentialsHandler>;
+    oauth?: OAuth;
+    me?: Me;
+    /** Cached from credentials for display when me is not loaded yet. */
+    loggedUserName?: string;
+    loggedEnvironmentUrl?: string;
+    bot: BotDetail | null;
+    localRuntimeBot: BotDetail | null;
+    headers: AxiosHeaders;
+    apiClient: AxiosInstance;
+    isLocalRuntimeDeployment?: boolean;
+    projectRoot?: string;
+    targetEnvironment?: string;
+    constructor(config?: BotonicAPIServiceConfig);
+    saveAllCredentials(): void;
+    botInfo(): BotDetail;
+    getOauth(): OAuth;
+    isAuthenticated(): boolean;
+    /** True when in local runtime mode and a bot was loaded (e.g. from app .botonic.json). */
+    hasLocalRuntimeBot(): boolean;
+    ensureAuthenticated(): Promise<void>;
+    setCurrentBot(bot: any): void;
+    setLocalRuntimeBot(bot: any): void;
+    private loadGlobalCredentials;
+    /**
+     * Returns store as env -> credentials. Migrates old single-credential format to { local: creds }.
+     */
+    private normalizeCredentialsStore;
+    private loadBotCredentials;
+    private setHeaders;
+    private saveGlobalCredentials;
+    private saveBotCredentials;
+    private refreshToken;
+    login(email: string, password: string): Promise<void>;
+    logout(): Promise<void>;
+    /**
+     * Ensures me is loaded (for display). Call before showing "Working as ...".
+     */
+    ensureMeLoaded(): Promise<void>;
+    /**
+     * Display name for the logged-in user (for "Working as X in environment ...").
+     */
+    getDisplayName(): string;
+    createWebchatIntegration(botId: string, integrationName: string): Promise<AxiosResponse<IntegrationResponse>>;
+    signup(email: string, password: string, orgName: string, campaign: any): Promise<any>;
+    createBot(botName: string): Promise<AxiosResponse>;
+    getBots(): Promise<AxiosResponse>;
+    deleteBot(botId: string): Promise<AxiosResponse>;
+    getProviders(botId?: string): Promise<AxiosResponse>;
+    deployBot(bundlePath: string, botConfigJson: any): Promise<any>;
+    deployStatus(deployId: string): Promise<AxiosResponse>;
+    deployLocalRuntime({ botConfigJson, lambdaFunctionName, lambdaEndpoint, }: {
+        botConfigJson: BotConfigJSON;
+        lambdaFunctionName: string;
+        lambdaEndpoint: string;
+    }): Promise<AxiosResponse<unknown, any, {}>>;
+    build({ projectRoot, projectName, }: {
+        projectRoot: string;
+        projectName: string;
+    }): Promise<boolean>;
+    private prepareLambda;
+    private apiPost;
+    private apiGet;
+    private apiDelete;
+    private getMe;
+    private validateToken;
+    private isTokenExpired;
+    private getHeaders;
+}
+export {};