@ant-design/agentic-ui 2.0.10 → 2.0.12

package/dist/Utils/proxySandbox/SecurityContextManager.js

@@ -0,0 +1,369 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/Utils/proxySandbox/SecurityContextManager.ts
+import { ProxySandbox } from "./ProxySandbox";
+var SecurityContextManager = class {
+  constructor(config = {}) {
+    this.contexts = /* @__PURE__ */ new Map();
+    this.globalMonitors = /* @__PURE__ */ new Map();
+    this.config = this.mergeDefaultConfig(config);
+    this.initializeGlobalMonitors();
+  }
+  /**
+   * 合并默认配置
+   */
+  mergeDefaultConfig(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+    return {
+      // 继承沙箱配置
+      allowedGlobals: config.allowedGlobals || [],
+      forbiddenGlobals: config.forbiddenGlobals || [],
+      allowConsole: (_a = config.allowConsole) != null ? _a : true,
+      allowTimers: (_b = config.allowTimers) != null ? _b : true,
+      timeout: config.timeout || 5e3,
+      strictMode: (_c = config.strictMode) != null ? _c : true,
+      customGlobals: config.customGlobals || {},
+      allowDOM: (_d = config.allowDOM) != null ? _d : false,
+      maxMemoryUsage: config.maxMemoryUsage || 10 * 1024 * 1024,
+      // 权限配置
+      permissions: {
+        network: (_f = (_e = config.permissions) == null ? void 0 : _e.network) != null ? _f : false,
+        fileSystem: (_h = (_g = config.permissions) == null ? void 0 : _g.fileSystem) != null ? _h : false,
+        media: (_j = (_i = config.permissions) == null ? void 0 : _i.media) != null ? _j : false,
+        geolocation: (_l = (_k = config.permissions) == null ? void 0 : _k.geolocation) != null ? _l : false,
+        notifications: (_n = (_m = config.permissions) == null ? void 0 : _m.notifications) != null ? _n : false
+      },
+      // 资源限制
+      limits: {
+        maxExecutionTime: ((_o = config.limits) == null ? void 0 : _o.maxExecutionTime) || 5e3,
+        maxMemoryUsage: ((_p = config.limits) == null ? void 0 : _p.maxMemoryUsage) || 10 * 1024 * 1024,
+        maxCallStackDepth: ((_q = config.limits) == null ? void 0 : _q.maxCallStackDepth) || 100,
+        maxLoopIterations: ((_r = config.limits) == null ? void 0 : _r.maxLoopIterations) || 1e4
+      },
+      // 监控配置
+      monitoring: {
+        enablePerformanceMonitoring: (_t = (_s = config.monitoring) == null ? void 0 : _s.enablePerformanceMonitoring) != null ? _t : true,
+        enableErrorTracking: (_v = (_u = config.monitoring) == null ? void 0 : _u.enableErrorTracking) != null ? _v : true,
+        enableResourceMonitoring: (_x = (_w = config.monitoring) == null ? void 0 : _w.enableResourceMonitoring) != null ? _x : true
+      }
+    };
+  }
+  /**
+   * 初始化全局监控器
+   */
+  initializeGlobalMonitors() {
+    if (this.config.monitoring.enablePerformanceMonitoring) {
+      this.globalMonitors.set("performance", this.createPerformanceMonitor());
+    }
+    if (this.config.monitoring.enableErrorTracking) {
+      this.globalMonitors.set("errorTracker", this.createErrorTracker());
+    }
+    if (this.config.monitoring.enableResourceMonitoring) {
+      this.globalMonitors.set("resourceMonitor", this.createResourceMonitor());
+    }
+  }
+  /**
+   * 创建性能监控器
+   */
+  createPerformanceMonitor() {
+    return {
+      mark: (name) => {
+        if (typeof performance !== "undefined" && performance.mark) {
+          performance.mark(`sandbox-${name}`);
+        }
+      },
+      measure: (name, startMark, endMark) => {
+        if (typeof performance !== "undefined" && performance.measure) {
+          try {
+            performance.measure(
+              name,
+              `sandbox-${startMark}`,
+              `sandbox-${endMark}`
+            );
+          } catch (error) {
+            console.warn("Performance measurement failed:", error);
+          }
+        }
+      }
+    };
+  }
+  /**
+   * 创建错误追踪器
+   */
+  createErrorTracker() {
+    return {
+      captureError: (error, context) => {
+        console.error(`[Sandbox Error] ${context}:`, error);
+      },
+      captureWarning: (message, context) => {
+        console.warn(`[Sandbox Warning] ${context}: ${message}`);
+      }
+    };
+  }
+  /**
+   * 创建资源监控器
+   */
+  createResourceMonitor() {
+    return {
+      checkMemoryUsage: () => {
+        if (typeof performance !== "undefined" && performance.memory) {
+          return performance.memory.usedJSHeapSize;
+        }
+        return 0;
+      },
+      checkCallStackDepth: (stack) => {
+        var _a;
+        if (stack) {
+          return stack.split("\n").length;
+        }
+        try {
+          throw new Error();
+        } catch (e) {
+          return ((_a = e.stack) == null ? void 0 : _a.split("\n").length) || 0;
+        }
+      }
+    };
+  }
+  /**
+   * 创建新的执行上下文
+   */
+  createContext(contextId) {
+    const id = contextId || this.generateContextId();
+    const context = {
+      id,
+      createdAt: Date.now(),
+      scope: {},
+      permissions: {
+        network: this.config.permissions.network,
+        fileSystem: this.config.permissions.fileSystem,
+        media: this.config.permissions.media,
+        geolocation: this.config.permissions.geolocation,
+        notifications: this.config.permissions.notifications
+      },
+      resourceUsage: {
+        memoryUsage: 0,
+        executionTime: 0,
+        callStackDepth: 0,
+        loopIterations: 0
+      }
+    };
+    this.contexts.set(id, context);
+    return id;
+  }
+  /**
+   * 生成上下文 ID
+   */
+  generateContextId() {
+    return `ctx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * 获取执行上下文
+   */
+  getContext(contextId) {
+    return this.contexts.get(contextId);
+  }
+  /**
+   * 删除执行上下文
+   */
+  deleteContext(contextId) {
+    return this.contexts.delete(contextId);
+  }
+  /**
+   * 在指定上下文中执行代码
+   */
+  executeInContext(_0, _1) {
+    return __async(this, arguments, function* (contextId, code, additionalScope = {}) {
+      const context = this.getContext(contextId);
+      if (!context) {
+        throw new Error(`Context ${contextId} not found`);
+      }
+      const mergedScope = __spreadValues(__spreadValues({}, context.scope), additionalScope);
+      const sandboxConfig = {
+        allowedGlobals: this.config.allowedGlobals,
+        forbiddenGlobals: this.config.forbiddenGlobals,
+        allowConsole: this.config.allowConsole,
+        allowTimers: this.config.allowTimers,
+        timeout: this.config.limits.maxExecutionTime,
+        strictMode: this.config.strictMode,
+        customGlobals: __spreadValues(__spreadProps(__spreadValues(__spreadValues({}, this.config.customGlobals), mergedScope), {
+          // 添加上下文相关的全局变量
+          __context: {
+            id: contextId,
+            permissions: context.permissions
+          }
+        }), this.config.monitoring.enablePerformanceMonitoring && {
+          __performance: this.globalMonitors.get("performance")
+        }),
+        allowDOM: this.config.allowDOM,
+        maxMemoryUsage: this.config.limits.maxMemoryUsage
+      };
+      const wrappedCode = this.wrapCodeWithMonitoring(code);
+      const sandbox = new ProxySandbox(sandboxConfig);
+      try {
+        const result = yield sandbox.execute(wrappedCode);
+        this.updateContextResourceUsage(context, result);
+        return result;
+      } finally {
+        sandbox.destroy();
+      }
+    });
+  }
+  /**
+   * 包装代码以添加监控
+   */
+  wrapCodeWithMonitoring(code) {
+    if (!this.config.monitoring.enableResourceMonitoring) {
+      return code;
+    }
+    return code;
+  }
+  /**
+   * 更新上下文的资源使用情况
+   */
+  updateContextResourceUsage(context, result) {
+    context.resourceUsage.executionTime = result.executionTime;
+    context.resourceUsage.memoryUsage = result.memoryUsage || 0;
+    this.checkResourceLimits(context);
+  }
+  /**
+   * 检查资源限制
+   */
+  checkResourceLimits(context) {
+    const { resourceUsage } = context;
+    const { limits } = this.config;
+    if (resourceUsage.executionTime > limits.maxExecutionTime) {
+      throw new Error(
+        `Execution time limit exceeded: ${resourceUsage.executionTime}ms > ${limits.maxExecutionTime}ms`
+      );
+    }
+    if (resourceUsage.memoryUsage > limits.maxMemoryUsage) {
+      throw new Error(
+        `Memory usage limit exceeded: ${resourceUsage.memoryUsage} > ${limits.maxMemoryUsage}`
+      );
+    }
+    if (resourceUsage.callStackDepth > limits.maxCallStackDepth) {
+      throw new Error(
+        `Call stack depth limit exceeded: ${resourceUsage.callStackDepth} > ${limits.maxCallStackDepth}`
+      );
+    }
+  }
+  /**
+   * 设置上下文变量
+   */
+  setContextVariable(contextId, name, value) {
+    const context = this.getContext(contextId);
+    if (!context) {
+      return false;
+    }
+    context.scope[name] = value;
+    return true;
+  }
+  /**
+   * 获取上下文变量
+   */
+  getContextVariable(contextId, name) {
+    const context = this.getContext(contextId);
+    return context == null ? void 0 : context.scope[name];
+  }
+  /**
+   * 清理所有上下文
+   */
+  clearAllContexts() {
+    this.contexts.clear();
+  }
+  /**
+   * 获取所有上下文的统计信息
+   */
+  getStatistics() {
+    const contexts = Array.from(this.contexts.values());
+    return {
+      totalContexts: contexts.length,
+      totalMemoryUsage: contexts.reduce(
+        (sum, ctx) => sum + ctx.resourceUsage.memoryUsage,
+        0
+      ),
+      totalExecutionTime: contexts.reduce(
+        (sum, ctx) => sum + ctx.resourceUsage.executionTime,
+        0
+      ),
+      averageExecutionTime: contexts.length > 0 ? contexts.reduce(
+        (sum, ctx) => sum + ctx.resourceUsage.executionTime,
+        0
+      ) / contexts.length : 0,
+      oldestContext: contexts.reduce(
+        (oldest, ctx) => ctx.createdAt < oldest.createdAt ? ctx : oldest,
+        contexts[0]
+      )
+    };
+  }
+  /**
+   * 获取管理器配置
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * 销毁管理器
+   */
+  destroy() {
+    this.clearAllContexts();
+    this.globalMonitors.clear();
+  }
+};
+function createSecurityContextManager(config) {
+  return new SecurityContextManager(config);
+}
+function runInSecureContext(code, config, contextScope) {
+  return __async(this, null, function* () {
+    const manager = createSecurityContextManager(config);
+    const contextId = manager.createContext();
+    try {
+      return yield manager.executeInContext(contextId, code, contextScope);
+    } finally {
+      manager.destroy();
+    }
+  });
+}
+export {
+  SecurityContextManager,
+  createSecurityContextManager,
+  runInSecureContext
+};

package/dist/Utils/proxySandbox/index.js

@@ -0,0 +1,281 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/Utils/proxySandbox/index.ts
+import { createSandbox, runInSandbox } from "./ProxySandbox";
+import { ProxySandbox as ProxySandbox2, createSandbox as createSandbox2, runInSandbox as runInSandbox2 } from "./ProxySandbox";
+import {
+  SecurityContextManager,
+  createSecurityContextManager,
+  runInSecureContext
+} from "./SecurityContextManager";
+var DEFAULT_SANDBOX_CONFIG = {
+  allowedGlobals: [
+    "console",
+    "Math",
+    "Date",
+    "JSON",
+    "parseInt",
+    "parseFloat",
+    "String",
+    "Number",
+    "Boolean",
+    "Array",
+    "Object",
+    "RegExp"
+  ],
+  forbiddenGlobals: [
+    "eval",
+    "Function",
+    "constructor",
+    "prototype",
+    "__proto__",
+    "document",
+    "window",
+    "global",
+    "globalThis",
+    "XMLHttpRequest",
+    "fetch",
+    "localStorage",
+    "sessionStorage"
+  ],
+  allowConsole: true,
+  allowTimers: false,
+  timeout: 3e3,
+  strictMode: true,
+  allowDOM: false,
+  maxMemoryUsage: 5 * 1024 * 1024
+  // 5MB
+};
+var DEFAULT_SECURITY_CONFIG = __spreadProps(__spreadValues({}, DEFAULT_SANDBOX_CONFIG), {
+  permissions: {
+    network: false,
+    fileSystem: false,
+    media: false,
+    geolocation: false,
+    notifications: false
+  },
+  limits: {
+    maxExecutionTime: 3e3,
+    maxMemoryUsage: 5 * 1024 * 1024,
+    maxCallStackDepth: 50,
+    maxLoopIterations: 1e3
+  },
+  monitoring: {
+    enablePerformanceMonitoring: true,
+    enableErrorTracking: true,
+    enableResourceMonitoring: true
+  }
+});
+function createConfiguredSandbox(type = "basic") {
+  switch (type) {
+    case "basic":
+      return createSandbox(DEFAULT_SANDBOX_CONFIG);
+    case "secure":
+      return createSandbox(__spreadProps(__spreadValues({}, DEFAULT_SANDBOX_CONFIG), {
+        allowConsole: false,
+        allowTimers: false,
+        timeout: 2e3,
+        strictMode: true
+      }));
+    case "restricted":
+      return createSandbox({
+        allowedGlobals: ["Math", "JSON", "String", "Number"],
+        forbiddenGlobals: [
+          "console",
+          "eval",
+          "Function",
+          "constructor",
+          "prototype",
+          "__proto__",
+          "document",
+          "window",
+          "global",
+          "globalThis"
+        ],
+        allowConsole: false,
+        allowTimers: false,
+        timeout: 1e3,
+        strictMode: true,
+        allowDOM: false,
+        maxMemoryUsage: 1024 * 1024
+        // 1MB
+      });
+    default:
+      return createSandbox(DEFAULT_SANDBOX_CONFIG);
+  }
+}
+function quickExecute(code, customGlobals, injectedParams) {
+  return __async(this, null, function* () {
+    const result = yield runInSandbox(
+      code,
+      __spreadProps(__spreadValues({}, DEFAULT_SANDBOX_CONFIG), {
+        customGlobals
+      }),
+      injectedParams
+    );
+    if (!result.success) {
+      throw result.error || new Error("Code execution failed");
+    }
+    return result.result;
+  });
+}
+function safeMathEval(expression) {
+  return __async(this, null, function* () {
+    const mathOnlyConfig = {
+      allowedGlobals: ["Math"],
+      forbiddenGlobals: ["console", "eval", "Function", "constructor"],
+      allowConsole: false,
+      allowTimers: false,
+      timeout: 1e3,
+      strictMode: true,
+      customGlobals: {
+        // 预定义安全的数学函数
+        abs: Math.abs,
+        ceil: Math.ceil,
+        floor: Math.floor,
+        round: Math.round,
+        max: Math.max,
+        min: Math.min,
+        pow: Math.pow,
+        sqrt: Math.sqrt,
+        sin: Math.sin,
+        cos: Math.cos,
+        tan: Math.tan,
+        PI: Math.PI,
+        E: Math.E
+      }
+    };
+    const safePattern = /^[0-9+\-*/.() \t\n,a-zA-Z_$]+$/;
+    if (!safePattern.test(expression)) {
+      throw new Error("Expression contains unsafe characters");
+    }
+    const result = yield runInSandbox(`return ${expression}`, mathOnlyConfig);
+    if (!result.success) {
+      throw result.error || new Error("Math evaluation failed");
+    }
+    const value = result.result;
+    if (typeof value !== "number" || !isFinite(value)) {
+      throw new Error("Result is not a valid number");
+    }
+    return value;
+  });
+}
+var _SandboxHealthChecker = class {
+  static getInstance() {
+    if (!_SandboxHealthChecker.instance) {
+      _SandboxHealthChecker.instance = new _SandboxHealthChecker();
+    }
+    return _SandboxHealthChecker.instance;
+  }
+  /**
+   * 检查浏览器环境是否支持沙箱功能
+   */
+  checkEnvironmentSupport() {
+    const issues = [];
+    const recommendations = [];
+    if (typeof Proxy === "undefined") {
+      issues.push("Proxy is not supported in this environment");
+      recommendations.push("Use a modern browser that supports ES6 Proxy");
+    }
+    if (typeof performance === "undefined") {
+      issues.push("Performance API is not available");
+      recommendations.push("Performance monitoring will be disabled");
+    }
+    if (typeof Worker === "undefined") {
+      recommendations.push(
+        "Web Workers not supported - consider using for heavy computations"
+      );
+    }
+    return {
+      supported: issues.length === 0,
+      issues,
+      recommendations
+    };
+  }
+  /**
+   * 测试沙箱基本功能
+   */
+  testBasicFunctionality() {
+    return __async(this, null, function* () {
+      const results = {};
+      const errors = [];
+      try {
+        const basicResult = yield quickExecute("return 1 + 1");
+        results.basicExecution = basicResult === 2;
+      } catch (error) {
+        results.basicExecution = false;
+        errors.push(`Basic execution failed: ${error}`);
+      }
+      try {
+        yield quickExecute("window = {}; return true");
+        results.globalIsolation = false;
+      } catch (error) {
+        results.globalIsolation = true;
+      }
+      try {
+        yield runInSandbox("while(true) {}", { timeout: 100 });
+        results.timeoutMechanism = false;
+      } catch (error) {
+        results.timeoutMechanism = error instanceof Error && error.message.includes("timeout");
+      }
+      const passed = Object.values(results).every(Boolean);
+      return { passed, results, errors };
+    });
+  }
+};
+var SandboxHealthChecker = _SandboxHealthChecker;
+SandboxHealthChecker.instance = null;
+var sandboxHealthChecker = SandboxHealthChecker.getInstance();
+export {
+  DEFAULT_SANDBOX_CONFIG,
+  DEFAULT_SECURITY_CONFIG,
+  ProxySandbox2 as ProxySandbox,
+  SandboxHealthChecker,
+  SecurityContextManager,
+  createConfiguredSandbox,
+  createSandbox2 as createSandbox,
+  createSecurityContextManager,
+  quickExecute,
+  runInSandbox2 as runInSandbox,
+  runInSecureContext,
+  safeMathEval,
+  sandboxHealthChecker
+};

package/dist/Utils/proxySandbox/types.js

@@ -0,0 +1,52 @@
+// src/Utils/proxySandbox/types.ts
+var SandboxErrorType = /* @__PURE__ */ ((SandboxErrorType2) => {
+  SandboxErrorType2["TIMEOUT"] = "TIMEOUT";
+  SandboxErrorType2["MEMORY_LIMIT"] = "MEMORY_LIMIT";
+  SandboxErrorType2["FORBIDDEN_ACCESS"] = "FORBIDDEN_ACCESS";
+  SandboxErrorType2["SYNTAX_ERROR"] = "SYNTAX_ERROR";
+  SandboxErrorType2["RUNTIME_ERROR"] = "RUNTIME_ERROR";
+  SandboxErrorType2["SECURITY_VIOLATION"] = "SECURITY_VIOLATION";
+  SandboxErrorType2["RESOURCE_LIMIT"] = "RESOURCE_LIMIT";
+  return SandboxErrorType2;
+})(SandboxErrorType || {});
+var SandboxError = class extends Error {
+  constructor(message, type, context) {
+    super(message);
+    this.name = "SandboxError";
+    this.type = type;
+    this.context = context;
+    this.timestamp = Date.now();
+  }
+};
+var ExecutionStatus = /* @__PURE__ */ ((ExecutionStatus2) => {
+  ExecutionStatus2["PENDING"] = "PENDING";
+  ExecutionStatus2["RUNNING"] = "RUNNING";
+  ExecutionStatus2["SUCCESS"] = "SUCCESS";
+  ExecutionStatus2["FAILED"] = "FAILED";
+  ExecutionStatus2["CANCELLED"] = "CANCELLED";
+  ExecutionStatus2["TIMEOUT"] = "TIMEOUT";
+  return ExecutionStatus2;
+})(ExecutionStatus || {});
+var PermissionLevel = /* @__PURE__ */ ((PermissionLevel2) => {
+  PermissionLevel2["NONE"] = "NONE";
+  PermissionLevel2["READ_ONLY"] = "READ_ONLY";
+  PermissionLevel2["LIMITED"] = "LIMITED";
+  PermissionLevel2["FULL"] = "FULL";
+  return PermissionLevel2;
+})(PermissionLevel || {});
+var MonitoringEventType = /* @__PURE__ */ ((MonitoringEventType2) => {
+  MonitoringEventType2["EXECUTION_START"] = "EXECUTION_START";
+  MonitoringEventType2["EXECUTION_END"] = "EXECUTION_END";
+  MonitoringEventType2["MEMORY_USAGE"] = "MEMORY_USAGE";
+  MonitoringEventType2["PERFORMANCE_WARNING"] = "PERFORMANCE_WARNING";
+  MonitoringEventType2["SECURITY_EVENT"] = "SECURITY_EVENT";
+  MonitoringEventType2["ERROR_EVENT"] = "ERROR_EVENT";
+  return MonitoringEventType2;
+})(MonitoringEventType || {});
+export {
+  ExecutionStatus,
+  MonitoringEventType,
+  PermissionLevel,
+  SandboxError,
+  SandboxErrorType
+};