@modern-js/bff-core 2.35.0 → 2.36.0

package/dist/cjs/router/constants.js

@@ -1,39 +1,34 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  APIMode: function() {
-    return APIMode;
-  },
-  AllHttpMethods: function() {
-    return AllHttpMethods;
-  },
-  FRAMEWORK_MODE_LAMBDA_DIR: function() {
-    return FRAMEWORK_MODE_LAMBDA_DIR;
-  },
-  FRAMEWORK_MODE_APP_DIR: function() {
-    return FRAMEWORK_MODE_APP_DIR;
-  },
-  INDEX_SUFFIX: function() {
-    return INDEX_SUFFIX;
-  },
-  API_DIR: function() {
-    return API_DIR;
-  },
-  API_FILE_RULES: function() {
-    return API_FILE_RULES;
+    __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 constants_exports = {};
+__export(constants_exports, {
+  APIMode: () => APIMode,
+  API_DIR: () => API_DIR,
+  API_FILE_RULES: () => API_FILE_RULES,
+  AllHttpMethods: () => AllHttpMethods,
+  FRAMEWORK_MODE_APP_DIR: () => FRAMEWORK_MODE_APP_DIR,
+  FRAMEWORK_MODE_LAMBDA_DIR: () => FRAMEWORK_MODE_LAMBDA_DIR,
+  INDEX_SUFFIX: () => INDEX_SUFFIX
 });
-const _types = require("../types");
-const AllHttpMethods = Object.values(_types.HttpMethod);
+module.exports = __toCommonJS(constants_exports);
+var import_types = require("../types");
+const AllHttpMethods = Object.values(import_types.HttpMethod);
 var APIMode;
 (function(APIMode2) {
   APIMode2[
@@ -65,3 +60,13 @@ const API_FILE_RULES = [
   "!node_modules/**",
   "!bootstrap.jsx"
 ];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIMode,
+  API_DIR,
+  API_FILE_RULES,
+  AllHttpMethods,
+  FRAMEWORK_MODE_APP_DIR,
+  FRAMEWORK_MODE_LAMBDA_DIR,
+  INDEX_SUFFIX
+});

package/dist/cjs/router/index.js

@@ -1,24 +1,47 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "ApiRouter", {
-  enumerable: true,
-  get: function() {
-    return ApiRouter;
+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 router_exports = {};
+__export(router_exports, {
+  ApiRouter: () => ApiRouter
 });
-const _define_property = require("@swc/helpers/_/_define_property");
-const _export_star = require("@swc/helpers/_/_export_star");
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-require("reflect-metadata");
-const _types = require("../types");
-const _utils1 = require("../utils");
-const _constants = _export_star._(require("./constants"), exports);
-const _utils2 = require("./utils");
-_export_star._(require("./types"), exports);
+module.exports = __toCommonJS(router_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_reflect_metadata = require("reflect-metadata");
+var import_types = require("../types");
+var import_utils2 = require("../utils");
+var import_constants = require("./constants");
+var import_utils3 = require("./utils");
+__reExport(router_exports, require("./types"), module.exports);
+__reExport(router_exports, require("./constants"), module.exports);
 class ApiRouter {
   enableRegister() {
     const existTsLoader = Boolean(require.extensions[".ts"]);
@@ -94,30 +117,28 @@ class ApiRouter {
   }
   getRouteName(filename, handler) {
     if (handler) {
-      const trigger = Reflect.getMetadata(_types.OperatorType.Trigger, handler);
-      if (trigger && trigger.type === _types.TriggerType.Http) {
+      const trigger = Reflect.getMetadata(import_types.OperatorType.Trigger, handler);
+      if (trigger && trigger.type === import_types.TriggerType.Http) {
         if (!trigger.path) {
           throw new Error(`The http trigger ${trigger.name} needs to specify a path`);
         }
         return trigger.path;
       }
     }
-    let routePath = (0, _utils2.getPathFromFilename)(this.lambdaDir, filename);
+    let routePath = (0, import_utils3.getPathFromFilename)(this.lambdaDir, filename);
     if (this.httpMethodDecider === "inputParams") {
       if (routePath.endsWith("/")) {
-        var _handler;
-        routePath += `${(_handler = handler) === null || _handler === void 0 ? void 0 : _handler.name}`;
+        routePath += `${handler === null || handler === void 0 ? void 0 : handler.name}`;
       } else {
-        var _handler1;
-        routePath += `/${(_handler1 = handler) === null || _handler1 === void 0 ? void 0 : _handler1.name}`;
+        routePath += `/${handler === null || handler === void 0 ? void 0 : handler.name}`;
       }
     }
     return routePath;
   }
   getHttpMethod(originHandlerName, handler) {
     if (handler) {
-      const trigger = Reflect.getMetadata(_types.OperatorType.Trigger, handler);
-      if (trigger && _types.httpMethods.includes(trigger.method)) {
+      const trigger = Reflect.getMetadata(import_types.OperatorType.Trigger, handler);
+      if (trigger && import_types.httpMethods.includes(trigger.method)) {
         return trigger.method;
       }
     }
@@ -125,28 +146,28 @@ class ApiRouter {
       const upperName = originHandlerName.toUpperCase();
       switch (upperName) {
         case "GET":
-          return _types.HttpMethod.Get;
+          return import_types.HttpMethod.Get;
         case "POST":
-          return _types.HttpMethod.Post;
+          return import_types.HttpMethod.Post;
         case "PUT":
-          return _types.HttpMethod.Put;
+          return import_types.HttpMethod.Put;
         case "DELETE":
         case "DEL":
-          return _types.HttpMethod.Delete;
+          return import_types.HttpMethod.Delete;
         case "CONNECT":
-          return _types.HttpMethod.Connect;
+          return import_types.HttpMethod.Connect;
         case "TRACE":
-          return _types.HttpMethod.Trace;
+          return import_types.HttpMethod.Trace;
         case "PATCH":
-          return _types.HttpMethod.Patch;
+          return import_types.HttpMethod.Patch;
         case "OPTIONS":
-          return _types.HttpMethod.Options;
+          return import_types.HttpMethod.Options;
         case "DEFAULT": {
-          return _types.HttpMethod.Get;
+          return import_types.HttpMethod.Get;
         }
         default:
           if (process.env.NODE_ENV !== "test") {
-            _utils.logger.warn(`Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`);
+            import_utils.logger.warn(`Only api handlers are allowd to be exported, please remove the function ${originHandlerName} from exports`);
           }
           return null;
       }
@@ -155,16 +176,16 @@ class ApiRouter {
         return null;
       }
       if (typeof handler === "function" && handler.length > 0) {
-        return _types.HttpMethod.Post;
+        return import_types.HttpMethod.Post;
       }
-      return _types.HttpMethod.Get;
+      return import_types.HttpMethod.Get;
     }
   }
   loadApiFiles() {
     if (!this.existLambdaDir) {
       return [];
     }
-    const apiFiles = this.apiFiles = (0, _utils2.getFiles)(this.lambdaDir, _constants.API_FILE_RULES);
+    const apiFiles = this.apiFiles = (0, import_utils3.getFiles)(this.lambdaDir, import_constants.API_FILE_RULES);
     return apiFiles;
   }
   getApiFiles() {
@@ -180,7 +201,7 @@ class ApiRouter {
     const filenames = this.getApiFiles();
     const moduleInfos = this.getModuleInfos(filenames);
     const apiHandlers = this.getHandlerInfos(moduleInfos);
-    (0, _utils1.debug)("apiHandlers", apiHandlers.length, apiHandlers);
+    (0, import_utils2.debug)("apiHandlers", apiHandlers.length, apiHandlers);
     return apiHandlers;
   }
   /**
@@ -194,7 +215,7 @@ class ApiRouter {
     return prefix || "/api";
   }
   validateAbsolute(filename, paramsName) {
-    if (typeof filename === "string" && !_path.default.isAbsolute(filename)) {
+    if (typeof filename === "string" && !import_path.default.isAbsolute(filename)) {
       throw new Error(`The ${paramsName} ${filename} is not a abolute path`);
     }
   }
@@ -203,10 +224,10 @@ class ApiRouter {
   }
   getModuleInfo(filename) {
     try {
-      const module = (0, _utils2.requireHandlerModule)(filename);
+      const module2 = (0, import_utils3.requireHandlerModule)(filename);
       return {
         filename,
-        module
+        module: module2
       };
     } catch (err) {
       if (process.env.NODE_ENV === "production") {
@@ -225,17 +246,17 @@ class ApiRouter {
         apiHandlers = apiHandlers.concat(handlerInfos);
       }
     });
-    const sortedHandlers = (0, _utils2.sortRoutes)(apiHandlers);
+    const sortedHandlers = (0, import_utils3.sortRoutes)(apiHandlers);
     return sortedHandlers;
   }
   getModuleHandlerInfos(moduleInfo) {
-    const { module, filename } = moduleInfo;
+    const { module: module2, filename } = moduleInfo;
     const { httpMethodDecider } = this;
-    return Object.entries(module).filter(([, handler]) => typeof handler === "function").map(([key]) => {
-      const handler = module[key];
+    return Object.entries(module2).filter(([, handler]) => typeof handler === "function").map(([key]) => {
+      const handler = module2[key];
       if (httpMethodDecider === "inputParams") {
         Object.assign(handler, {
-          [_utils1.INPUT_PARAMS_DECIDER]: true
+          [import_utils2.INPUT_PARAMS_DECIDER]: true
         });
       }
       const handlerInfo = this.getHandlerInfo(filename, key, handler);
@@ -255,31 +276,31 @@ class ApiRouter {
     return `${prefix}${finalRouteName}`;
   }
   constructor({ appDir, apiDir, lambdaDir, prefix, isBuild, httpMethodDecider = "functionName" }) {
-    _define_property._(this, "apiMode", void 0);
-    _define_property._(this, "appDir", void 0);
-    _define_property._(this, "apiDir", void 0);
-    _define_property._(this, "existLambdaDir", void 0);
-    _define_property._(this, "httpMethodDecider", void 0);
-    _define_property._(this, "lambdaDir", void 0);
-    _define_property._(this, "prefix", void 0);
-    _define_property._(this, "apiFiles", []);
-    _define_property._(this, "isBuild", void 0);
-    _define_property._(this, "getExactApiMode", (apiDir2, lambdaDir2) => {
+    (0, import_define_property._)(this, "apiMode", void 0);
+    (0, import_define_property._)(this, "appDir", void 0);
+    (0, import_define_property._)(this, "apiDir", void 0);
+    (0, import_define_property._)(this, "existLambdaDir", void 0);
+    (0, import_define_property._)(this, "httpMethodDecider", void 0);
+    (0, import_define_property._)(this, "lambdaDir", void 0);
+    (0, import_define_property._)(this, "prefix", void 0);
+    (0, import_define_property._)(this, "apiFiles", []);
+    (0, import_define_property._)(this, "isBuild", void 0);
+    (0, import_define_property._)(this, "getExactApiMode", (apiDir2, lambdaDir2) => {
       const exist = this.createExistChecker(apiDir2);
-      const existLambdaDir = lambdaDir2 && _utils.fs.pathExistsSync(lambdaDir2) || exist(_constants.FRAMEWORK_MODE_LAMBDA_DIR);
-      const existAppDir = exist(_constants.FRAMEWORK_MODE_APP_DIR);
+      const existLambdaDir = lambdaDir2 && import_utils.fs.pathExistsSync(lambdaDir2) || exist(import_constants.FRAMEWORK_MODE_LAMBDA_DIR);
+      const existAppDir = exist(import_constants.FRAMEWORK_MODE_APP_DIR);
       const existAppFile = exist("app.ts") || exist("app.js");
       if (existLambdaDir || existAppDir || existAppFile) {
-        return _constants.APIMode.FARMEWORK;
+        return import_constants.APIMode.FARMEWORK;
       }
-      return _constants.APIMode.FUNCTION;
+      return import_constants.APIMode.FUNCTION;
     });
-    _define_property._(this, "createExistChecker", (base) => (target) => _utils.fs.pathExistsSync(_path.default.resolve(base, target)));
-    _define_property._(this, "getExactLambdaDir", (apiDir2, originLambdaDir) => {
-      if (this.apiMode === _constants.APIMode.FUNCTION) {
+    (0, import_define_property._)(this, "createExistChecker", (base) => (target) => import_utils.fs.pathExistsSync(import_path.default.resolve(base, target)));
+    (0, import_define_property._)(this, "getExactLambdaDir", (apiDir2, originLambdaDir) => {
+      if (this.apiMode === import_constants.APIMode.FUNCTION) {
         return apiDir2;
       }
-      return originLambdaDir || _path.default.join(apiDir2, _constants.FRAMEWORK_MODE_LAMBDA_DIR);
+      return originLambdaDir || import_path.default.join(apiDir2, import_constants.FRAMEWORK_MODE_LAMBDA_DIR);
     });
     this.validateAbsolute(apiDir, "apiDir");
     this.validateAbsolute(lambdaDir, "lambdaDir");
@@ -290,8 +311,14 @@ class ApiRouter {
     this.isBuild = isBuild;
     this.apiMode = this.getExactApiMode(apiDir, lambdaDir);
     this.lambdaDir = this.getExactLambdaDir(this.apiDir, lambdaDir);
-    this.existLambdaDir = _utils.fs.existsSync(this.lambdaDir);
-    (0, _utils1.debug)(`apiDir:`, this.apiDir, `lambdaDir:`, this.lambdaDir);
+    this.existLambdaDir = import_utils.fs.existsSync(this.lambdaDir);
+    (0, import_utils2.debug)(`apiDir:`, this.apiDir, `lambdaDir:`, this.lambdaDir);
     this.enableRegister();
   }
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiRouter,
+  ...require("./types"),
+  ...require("./constants")
+});

package/dist/cjs/router/types.js

@@ -1,4 +1,16 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/router/utils.js

@@ -1,43 +1,51 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  getFiles: function() {
-    return getFiles;
-  },
-  getPathFromFilename: function() {
-    return getPathFromFilename;
-  },
-  isHandler: function() {
-    return isHandler;
-  },
-  requireHandlerModule: function() {
-    return requireHandlerModule;
-  },
-  sortRoutes: function() {
-    return sortRoutes;
+    __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(
+  // 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 utils_exports = {};
+__export(utils_exports, {
+  getFiles: () => getFiles,
+  getPathFromFilename: () => getPathFromFilename,
+  isHandler: () => isHandler,
+  requireHandlerModule: () => requireHandlerModule,
+  sortRoutes: () => sortRoutes
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _path = /* @__PURE__ */ _interop_require_default._(require("path"));
-const _utils = require("@modern-js/utils");
-const _constants = require("./constants");
-const getFiles = (lambdaDir, rules) => _utils.globby.sync(rules, {
+module.exports = __toCommonJS(utils_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("./constants");
+const getFiles = (lambdaDir, rules) => import_utils.globby.sync(rules, {
   cwd: lambdaDir,
   gitignore: true
-}).map((file) => _path.default.resolve(lambdaDir, file));
+}).map((file) => import_path.default.resolve(lambdaDir, file));
 const getPathFromFilename = (baseDir, filename) => {
   const relativeName = filename.substring(baseDir.length);
   const relativePath = relativeName.split(".").slice(0, -1).join(".");
-  const nameSplit = relativePath.split(_path.default.sep).map((item) => {
+  const nameSplit = relativePath.split(import_path.default.sep).map((item) => {
     if (item.length > 2) {
       if (item.startsWith("[") && item.endsWith("]")) {
         return `:${item.substring(1, item.length - 1)}`;
@@ -46,7 +54,7 @@ const getPathFromFilename = (baseDir, filename) => {
     return item;
   });
   const name = nameSplit.join("/");
-  const finalName = name.endsWith(_constants.INDEX_SUFFIX) ? name.substring(0, name.length - _constants.INDEX_SUFFIX.length) : name;
+  const finalName = name.endsWith(import_constants.INDEX_SUFFIX) ? name.substring(0, name.length - import_constants.INDEX_SUFFIX.length) : name;
   return clearRouteName(finalName);
 };
 const clearRouteName = (routeName) => {
@@ -63,13 +71,13 @@ const isHandler = (input) => input && typeof input === "function";
 const isFunction = (input) => input && {}.toString.call(input) === "[object Function]";
 const requireHandlerModule = (modulePath) => {
   const originRequire = process.env.NODE_ENV === "test" ? jest.requireActual : require;
-  const module = originRequire(modulePath);
-  if (isFunction(module)) {
+  const module2 = originRequire(modulePath);
+  if (isFunction(module2)) {
     return {
-      default: module
+      default: module2
     };
   }
-  return module;
+  return module2;
 };
 const routeValue = (routePath) => {
   if (routePath.includes(":")) {
@@ -82,3 +90,11 @@ const sortRoutes = (apiHandlers) => {
     return routeValue(handlerA.routeName) - routeValue(handlerB.routeName);
   });
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFiles,
+  getPathFromFilename,
+  isHandler,
+  requireHandlerModule,
+  sortRoutes
+});

package/dist/cjs/types.js

@@ -1,34 +1,31 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  OperatorType: function() {
-    return OperatorType;
-  },
-  TriggerType: function() {
-    return TriggerType;
-  },
-  HttpMetadata: function() {
-    return HttpMetadata;
-  },
-  ResponseMetaType: function() {
-    return ResponseMetaType;
-  },
-  HttpMethod: function() {
-    return HttpMethod;
-  },
-  httpMethods: function() {
-    return httpMethods;
+    __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 types_exports = {};
+__export(types_exports, {
+  HttpMetadata: () => HttpMetadata,
+  HttpMethod: () => HttpMethod,
+  OperatorType: () => OperatorType,
+  ResponseMetaType: () => ResponseMetaType,
+  TriggerType: () => TriggerType,
+  httpMethods: () => httpMethods
 });
+module.exports = __toCommonJS(types_exports);
 var OperatorType;
 (function(OperatorType2) {
   OperatorType2[OperatorType2["Trigger"] = 0] = "Trigger";
@@ -66,3 +63,12 @@ var HttpMethod;
   HttpMethod2["Head"] = "HEAD";
 })(HttpMethod || (HttpMethod = {}));
 const httpMethods = Object.values(HttpMethod);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HttpMetadata,
+  HttpMethod,
+  OperatorType,
+  ResponseMetaType,
+  TriggerType,
+  httpMethods
+});