@botpress/cli 0.0.2

package/build.ts

@@ -0,0 +1,12 @@
+import esbuild from 'esbuild'
+import glob from 'glob'
+
+const entryPoints = glob.sync('./src/**/*.ts')
+void esbuild.build({
+  entryPoints,
+  bundle: false,
+  platform: 'node',
+  format: 'cjs',
+  external: [],
+  outdir: './dist',
+})

package/dist/app/api-utils.js

@@ -0,0 +1,105 @@
+"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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_utils_exports = {};
+__export(api_utils_exports, {
+  ApiUtils: () => ApiUtils
+});
+module.exports = __toCommonJS(api_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+var errors = __toESM(require("./errors"));
+var import_integration_ref = require("./integration-ref");
+class ApiUtils {
+  constructor(client, host, token, workspaceId, _logger) {
+    this.client = client;
+    this.host = host;
+    this.token = token;
+    this.workspaceId = workspaceId;
+    this._logger = _logger;
+  }
+  async findIntegration(ref) {
+    const formatted = (0, import_integration_ref.formatIntegrationRef)(ref);
+    const privateIntegration = await this.findPrivateIntegration(ref);
+    if (privateIntegration) {
+      this._logger.debug(`Found integration "${formatted}" in workspace`);
+      return privateIntegration;
+    }
+    const publicIntegration = await this.findPublicIntegration(ref);
+    if (publicIntegration) {
+      this._logger.debug(`Found integration "${formatted}" in hub`);
+      return publicIntegration;
+    }
+    return;
+  }
+  async findPrivateIntegration(ref) {
+    if (ref.type === "id") {
+      return this.validateStatus(() => this.client.getIntegration(ref).then((r) => r.integration), [404, 500]);
+    }
+    return this.validateStatus(() => this.client.getIntegrationByName(ref).then((r) => r.integration), [404, 500]);
+  }
+  async findPublicIntegration(ref) {
+    if (ref.type === "id") {
+      return this.validateStatus(() => this.client.getPublicIntegrationById(ref).then((r) => r.integration), [404, 500]);
+    }
+    return this.validateStatus(() => this.client.getPublicIntegration(ref).then((r) => r.integration), [404, 500]);
+  }
+  async testLogin() {
+    try {
+      await this.client.listBots({});
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Authentication failed. Please check your credentials");
+    }
+  }
+  async listAllPages(lister, key) {
+    let nextToken;
+    const all = [];
+    do {
+      const { meta, ...r } = await lister({ nextToken });
+      all.push(r);
+      nextToken = meta.nextToken;
+    } while (nextToken);
+    if (!key) {
+      return all;
+    }
+    return all.flatMap((r) => r[key]);
+  }
+  async validateStatus(fn, allowedStatuses) {
+    try {
+      const v = await fn();
+      return v;
+    } catch (thrown) {
+      const err = errors.mapThrown(thrown);
+      const allowedStatusesArray = import_lodash.default.isArray(allowedStatuses) ? allowedStatuses : [allowedStatuses];
+      const isAllowed = err instanceof errors.HTTPError && err.status && allowedStatusesArray.includes(err.status);
+      if (isAllowed) {
+        return;
+      }
+      throw err;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiUtils
+});

package/dist/app/base.js

@@ -0,0 +1,35 @@
+"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 base_exports = {};
+__export(base_exports, {
+  BaseCommands: () => BaseCommands
+});
+module.exports = __toCommonJS(base_exports);
+class BaseCommands {
+  constructor(_logger) {
+    this._logger = _logger;
+  }
+  teardown() {
+    this._logger.cleanup();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseCommands
+});

package/dist/app/cache.js

@@ -0,0 +1,95 @@
+"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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cache_exports = {};
+__export(cache_exports, {
+  FSConfigCache: () => FSConfigCache
+});
+module.exports = __toCommonJS(cache_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+class FSConfigCache {
+  constructor(_filepath) {
+    this._filepath = _filepath;
+  }
+  static async loadFrom(filepath) {
+    const dirname = import_path.default.dirname(filepath);
+    if (!import_fs.default.existsSync(dirname)) {
+      await import_fs.default.promises.mkdir(dirname, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(filepath)) {
+      await this._writeJSON(filepath, {});
+    }
+    return new FSConfigCache(filepath);
+  }
+  static _writeJSON = (filepath, data) => {
+    const fileContent = JSON.stringify(data, null, 2);
+    return import_fs.default.promises.writeFile(filepath, fileContent);
+  };
+  static _readJSON = async (filepath) => {
+    const fileContent = await import_fs.default.promises.readFile(filepath, "utf8");
+    return JSON.parse(fileContent);
+  };
+  async sync(key, value, prompt) {
+    if (value) {
+      await this.set(key, value);
+      return value;
+    }
+    const data = await this.get(key);
+    const newValue = await prompt(data);
+    await this.set(key, newValue);
+    return newValue;
+  }
+  async has(key) {
+    const data = await FSConfigCache._readJSON(this._filepath);
+    return data[key] !== void 0;
+  }
+  async get(key) {
+    const data = await FSConfigCache._readJSON(this._filepath);
+    return data[key];
+  }
+  async set(key, value) {
+    const data = await FSConfigCache._readJSON(this._filepath);
+    data[key] = value;
+    return FSConfigCache._writeJSON(this._filepath, data);
+  }
+  async rm(key) {
+    const data = await FSConfigCache._readJSON(this._filepath);
+    delete data[key];
+    return FSConfigCache._writeJSON(this._filepath, data);
+  }
+  async clear() {
+    return FSConfigCache._writeJSON(this._filepath, {});
+  }
+  async nuke() {
+    if (!import_fs.default.existsSync(this._filepath)) {
+      return;
+    }
+    import_fs.default.unlinkSync(this._filepath);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FSConfigCache
+});

package/dist/app/errors.js

@@ -0,0 +1,145 @@
+"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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  BotpressCLIError: () => BotpressCLIError,
+  ExclusiveBotFeatureError: () => ExclusiveBotFeatureError,
+  ExclusiveIntegrationFeatureError: () => ExclusiveIntegrationFeatureError,
+  HTTPError: () => HTTPError,
+  InvalidIntegrationReferenceError: () => InvalidIntegrationReferenceError,
+  NoBotsFoundError: () => NoBotsFoundError,
+  NoBundleFoundError: () => NoBundleFoundError,
+  NotLoggedInError: () => NotLoggedInError,
+  ParamRequiredError: () => ParamRequiredError,
+  mapThrown: () => mapThrown
+});
+module.exports = __toCommonJS(errors_exports);
+var import_client = require("@botpress/client");
+var import_axios = __toESM(require("axios"));
+var import_verror = require("verror");
+var consts = __toESM(require("../const"));
+const mapThrown = (thrown) => {
+  if ((0, import_client.isApiError)(thrown)) {
+    return HTTPError.fromApi(thrown);
+  }
+  if (import_axios.default.isAxiosError(thrown)) {
+    return HTTPError.fromAxios(thrown);
+  }
+  if (thrown instanceof Error) {
+    return thrown;
+  }
+  return new BotpressCLIError(`${thrown}`);
+};
+class BotpressCLIError extends import_verror.VError {
+  static wrap(thrown, message) {
+    const err = mapThrown(thrown);
+    return new BotpressCLIError(err, message);
+  }
+}
+class ExclusiveBotFeatureError extends BotpressCLIError {
+  constructor() {
+    const message = "This feature is only available for bots. This project is an integration";
+    super(message);
+  }
+}
+class ExclusiveIntegrationFeatureError extends BotpressCLIError {
+  constructor() {
+    const message = "This feature is only available for integration. This project is a bot";
+    super(message);
+  }
+}
+class HTTPError extends BotpressCLIError {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  static fromAxios(e) {
+    const message = this._axiosMsg(e);
+    return new HTTPError(e.response?.status, message);
+  }
+  static fromApi(e) {
+    const { message, code } = e;
+    return new HTTPError(code, message);
+  }
+  static _axiosMsg(e) {
+    let message = e.message;
+    if (e.response?.statusText) {
+      message += `
+  ${e.response?.statusText}`;
+    }
+    if (e.response?.status && e.request?.method && e.request?.path) {
+      message += `
+  (${e.response?.status}) ${e.request.method} ${e.request.path}`;
+    }
+    if (e.response?.data?.message) {
+      message += `
+  ${e.response?.data?.message}`;
+    }
+    return message;
+  }
+}
+class NoBundleFoundError extends BotpressCLIError {
+  constructor() {
+    const message = "No bundle found. Please run `bp bundle` first.";
+    super(message);
+  }
+}
+class NoBotsFoundError extends BotpressCLIError {
+  constructor() {
+    const message = `No Bot found in your Workspace. Please create one first at ${consts.defaultBotpressApp}.`;
+    super(message);
+  }
+}
+class NotLoggedInError extends BotpressCLIError {
+  constructor() {
+    const message = "Not logged in. Please run `bp login` first.";
+    super(message);
+  }
+}
+class ParamRequiredError extends BotpressCLIError {
+  constructor(param) {
+    const message = `${param} is required.`;
+    super(message);
+  }
+}
+class InvalidIntegrationReferenceError extends BotpressCLIError {
+  constructor(ref) {
+    const message = `Invalid integration reference "${ref}".`;
+    super(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotpressCLIError,
+  ExclusiveBotFeatureError,
+  ExclusiveIntegrationFeatureError,
+  HTTPError,
+  InvalidIntegrationReferenceError,
+  NoBotsFoundError,
+  NoBundleFoundError,
+  NotLoggedInError,
+  ParamRequiredError,
+  mapThrown
+});

package/dist/app/esbuild.js

@@ -0,0 +1,89 @@
+"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 esbuild_exports = {};
+__export(esbuild_exports, {
+  buildCode: () => buildCode,
+  buildEntrypoint: () => buildEntrypoint
+});
+module.exports = __toCommonJS(esbuild_exports);
+var import_esbuild = require("esbuild");
+const keepNames = true;
+function buildCode({
+  cwd,
+  minify = true,
+  bundle = true,
+  sourcemap = false,
+  logLevel = "silent",
+  outfile,
+  code,
+  write
+}) {
+  return (0, import_esbuild.build)({
+    stdin: {
+      contents: code,
+      resolveDir: cwd,
+      loader: "ts"
+    },
+    logOverride: {
+      "equals-negative-zero": "silent"
+    },
+    platform: "node",
+    target: "es2020",
+    sourcemap,
+    minify,
+    bundle,
+    outfile,
+    absWorkingDir: cwd,
+    logLevel,
+    keepNames,
+    write
+  });
+}
+function buildEntrypoint({
+  cwd,
+  minify = true,
+  bundle = true,
+  sourcemap = false,
+  logLevel = "silent",
+  outfile,
+  entrypoint,
+  write
+}) {
+  return (0, import_esbuild.build)({
+    entryPoints: [entrypoint],
+    logOverride: {
+      "equals-negative-zero": "silent"
+    },
+    platform: "node",
+    target: "es2020",
+    sourcemap,
+    minify,
+    bundle,
+    outfile,
+    absWorkingDir: cwd,
+    logLevel,
+    keepNames,
+    write
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCode,
+  buildEntrypoint
+});

package/dist/app/generator/action.js

@@ -0,0 +1,76 @@
+"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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var action_exports = {};
+__export(action_exports, {
+  ActionInputModule: () => ActionInputModule,
+  ActionModule: () => ActionModule,
+  ActionOutputModule: () => ActionOutputModule
+});
+module.exports = __toCommonJS(action_exports);
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
+var import_module = require("./module");
+var strings = __toESM(require("./strings"));
+class ActionInputModule extends import_module.Module {
+  static async create(input) {
+    const schema = input.schema ?? {};
+    const filename = "input.ts";
+    const def = {
+      path: filename,
+      exportName: "Input",
+      content: await (0, import_json_schema_to_typescript.compile)(schema, filename)
+    };
+    return new ActionInputModule(def);
+  }
+}
+class ActionOutputModule extends import_module.Module {
+  static async create(output) {
+    const schema = output.schema ?? {};
+    const filename = "output.ts";
+    const def = {
+      path: filename,
+      exportName: "Output",
+      content: await (0, import_json_schema_to_typescript.compile)(schema, filename)
+    };
+    return new ActionOutputModule(def);
+  }
+}
+class ActionModule extends import_module.ReExportModule {
+  static async create(actionName, action) {
+    const inputModule = await ActionInputModule.create(action.input ?? {});
+    const outputModule = await ActionOutputModule.create(action.output ?? {});
+    const inst = new ActionModule({
+      exportName: `Action${strings.pascalCase(actionName)}`
+    });
+    inst.pushDep(inputModule);
+    inst.pushDep(outputModule);
+    return inst;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionInputModule,
+  ActionModule,
+  ActionOutputModule
+});

package/dist/app/generator/channel.js

@@ -0,0 +1,51 @@
+"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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var channel_exports = {};
+__export(channel_exports, {
+  ChannelModule: () => ChannelModule
+});
+module.exports = __toCommonJS(channel_exports);
+var import_bluebird = __toESM(require("bluebird"));
+var import_message = require("./message");
+var import_module = require("./module");
+var strings = __toESM(require("./strings"));
+class ChannelModule extends import_module.ReExportModule {
+  static async create(channelName, channel) {
+    const messages = channel.messages ?? {};
+    const messageModules = await import_bluebird.default.map(
+      Object.entries(messages),
+      ([messageName, message]) => import_message.MessageModule.create(messageName, message)
+    );
+    const inst = new ChannelModule({
+      exportName: `Channel${strings.pascalCase(channelName)}`
+    });
+    inst.pushDep(...messageModules);
+    return inst;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChannelModule
+});

package/dist/app/generator/configuration.js

@@ -0,0 +1,40 @@
+"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 configuration_exports = {};
+__export(configuration_exports, {
+  ConfigurationModule: () => ConfigurationModule
+});
+module.exports = __toCommonJS(configuration_exports);
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
+var import_module = require("./module");
+class ConfigurationModule extends import_module.Module {
+  static async create(configuration) {
+    const schema = configuration.schema ?? {};
+    const filename = "configuration";
+    return new ConfigurationModule({
+      path: `${filename}.ts`,
+      exportName: "Configuration",
+      content: await (0, import_json_schema_to_typescript.compile)(schema, filename)
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigurationModule
+});

package/dist/app/generator/const.js

@@ -0,0 +1,31 @@
+"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 const_exports = {};
+__export(const_exports, {
+  GENERATED_HEADER: () => GENERATED_HEADER,
+  INDEX_FILE: () => INDEX_FILE
+});
+module.exports = __toCommonJS(const_exports);
+const GENERATED_HEADER = "/* tslint:disable */\n// This file is generated\n// Do not edit this file\n\n";
+const INDEX_FILE = "index.ts";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GENERATED_HEADER,
+  INDEX_FILE
+});