@grupodiariodaregiao/bunstone 0.0.27

package/dist/index.js

@@ -0,0 +1,4316 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = import.meta.require;
+
+// node_modules/reflect-metadata/Reflect.js
+var require_Reflect = __commonJS(() => {
+  /*! *****************************************************************************
+  Copyright (C) Microsoft. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+  
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+  
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** */
+  var Reflect2;
+  (function(Reflect3) {
+    (function(factory) {
+      var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
+      var exporter = makeExporter(Reflect3);
+      if (typeof root.Reflect !== "undefined") {
+        exporter = makeExporter(root.Reflect, exporter);
+      }
+      factory(exporter, root);
+      if (typeof root.Reflect === "undefined") {
+        root.Reflect = Reflect3;
+      }
+      function makeExporter(target, previous) {
+        return function(key, value) {
+          Object.defineProperty(target, key, { configurable: true, writable: true, value });
+          if (previous)
+            previous(key, value);
+        };
+      }
+      function functionThis() {
+        try {
+          return Function("return this;")();
+        } catch (_) {}
+      }
+      function indirectEvalThis() {
+        try {
+          return (undefined, eval)("(function() { return this; })()");
+        } catch (_) {}
+      }
+      function sloppyModeThis() {
+        return functionThis() || indirectEvalThis();
+      }
+    })(function(exporter, root) {
+      var hasOwn = Object.prototype.hasOwnProperty;
+      var supportsSymbol = typeof Symbol === "function";
+      var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
+      var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
+      var supportsCreate = typeof Object.create === "function";
+      var supportsProto = { __proto__: [] } instanceof Array;
+      var downLevel = !supportsCreate && !supportsProto;
+      var HashMap = {
+        create: supportsCreate ? function() {
+          return MakeDictionary(Object.create(null));
+        } : supportsProto ? function() {
+          return MakeDictionary({ __proto__: null });
+        } : function() {
+          return MakeDictionary({});
+        },
+        has: downLevel ? function(map, key) {
+          return hasOwn.call(map, key);
+        } : function(map, key) {
+          return key in map;
+        },
+        get: downLevel ? function(map, key) {
+          return hasOwn.call(map, key) ? map[key] : undefined;
+        } : function(map, key) {
+          return map[key];
+        }
+      };
+      var functionPrototype = Object.getPrototypeOf(Function);
+      var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
+      var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
+      var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
+      var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : undefined;
+      var metadataRegistry = GetOrCreateMetadataRegistry();
+      var metadataProvider = CreateMetadataProvider(metadataRegistry);
+      function decorate(decorators, target, propertyKey, attributes) {
+        if (!IsUndefined(propertyKey)) {
+          if (!IsArray(decorators))
+            throw new TypeError;
+          if (!IsObject(target))
+            throw new TypeError;
+          if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
+            throw new TypeError;
+          if (IsNull(attributes))
+            attributes = undefined;
+          propertyKey = ToPropertyKey(propertyKey);
+          return DecorateProperty(decorators, target, propertyKey, attributes);
+        } else {
+          if (!IsArray(decorators))
+            throw new TypeError;
+          if (!IsConstructor(target))
+            throw new TypeError;
+          return DecorateConstructor(decorators, target);
+        }
+      }
+      exporter("decorate", decorate);
+      function metadata(metadataKey, metadataValue) {
+        function decorator(target, propertyKey) {
+          if (!IsObject(target))
+            throw new TypeError;
+          if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
+            throw new TypeError;
+          OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+        }
+        return decorator;
+      }
+      exporter("metadata", metadata);
+      function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
+      }
+      exporter("defineMetadata", defineMetadata);
+      function hasMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasMetadata", hasMetadata);
+      function hasOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("hasOwnMetadata", hasOwnMetadata);
+      function getMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getMetadata", getMetadata);
+      function getOwnMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("getOwnMetadata", getOwnMetadata);
+      function getMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryMetadataKeys(target, propertyKey);
+      }
+      exporter("getMetadataKeys", getMetadataKeys);
+      function getOwnMetadataKeys(target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        return OrdinaryOwnMetadataKeys(target, propertyKey);
+      }
+      exporter("getOwnMetadataKeys", getOwnMetadataKeys);
+      function deleteMetadata(metadataKey, target, propertyKey) {
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        if (!IsObject(target))
+          throw new TypeError;
+        if (!IsUndefined(propertyKey))
+          propertyKey = ToPropertyKey(propertyKey);
+        var provider = GetMetadataProvider(target, propertyKey, false);
+        if (IsUndefined(provider))
+          return false;
+        return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
+      }
+      exporter("deleteMetadata", deleteMetadata);
+      function DecorateConstructor(decorators, target) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsConstructor(decorated))
+              throw new TypeError;
+            target = decorated;
+          }
+        }
+        return target;
+      }
+      function DecorateProperty(decorators, target, propertyKey, descriptor) {
+        for (var i = decorators.length - 1;i >= 0; --i) {
+          var decorator = decorators[i];
+          var decorated = decorator(target, propertyKey, descriptor);
+          if (!IsUndefined(decorated) && !IsNull(decorated)) {
+            if (!IsObject(decorated))
+              throw new TypeError;
+            descriptor = decorated;
+          }
+        }
+        return descriptor;
+      }
+      function OrdinaryHasMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return true;
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryHasMetadata(MetadataKey, parent, P);
+        return false;
+      }
+      function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined(provider))
+          return false;
+        return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
+      }
+      function OrdinaryGetMetadata(MetadataKey, O, P) {
+        var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
+        if (hasOwn2)
+          return OrdinaryGetOwnMetadata(MetadataKey, O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (!IsNull(parent))
+          return OrdinaryGetMetadata(MetadataKey, parent, P);
+        return;
+      }
+      function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (IsUndefined(provider))
+          return;
+        return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
+      }
+      function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
+        var provider = GetMetadataProvider(O, P, true);
+        provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
+      }
+      function OrdinaryMetadataKeys(O, P) {
+        var ownKeys = OrdinaryOwnMetadataKeys(O, P);
+        var parent = OrdinaryGetPrototypeOf(O);
+        if (parent === null)
+          return ownKeys;
+        var parentKeys = OrdinaryMetadataKeys(parent, P);
+        if (parentKeys.length <= 0)
+          return ownKeys;
+        if (ownKeys.length <= 0)
+          return parentKeys;
+        var set = new _Set;
+        var keys = [];
+        for (var _i = 0, ownKeys_1 = ownKeys;_i < ownKeys_1.length; _i++) {
+          var key = ownKeys_1[_i];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        for (var _a = 0, parentKeys_1 = parentKeys;_a < parentKeys_1.length; _a++) {
+          var key = parentKeys_1[_a];
+          var hasKey = set.has(key);
+          if (!hasKey) {
+            set.add(key);
+            keys.push(key);
+          }
+        }
+        return keys;
+      }
+      function OrdinaryOwnMetadataKeys(O, P) {
+        var provider = GetMetadataProvider(O, P, false);
+        if (!provider) {
+          return [];
+        }
+        return provider.OrdinaryOwnMetadataKeys(O, P);
+      }
+      function Type(x) {
+        if (x === null)
+          return 1;
+        switch (typeof x) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return x === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function IsUndefined(x) {
+        return x === undefined;
+      }
+      function IsNull(x) {
+        return x === null;
+      }
+      function IsSymbol(x) {
+        return typeof x === "symbol";
+      }
+      function IsObject(x) {
+        return typeof x === "object" ? x !== null : typeof x === "function";
+      }
+      function ToPrimitive(input, PreferredType) {
+        switch (Type(input)) {
+          case 0:
+            return input;
+          case 1:
+            return input;
+          case 2:
+            return input;
+          case 3:
+            return input;
+          case 4:
+            return input;
+          case 5:
+            return input;
+        }
+        var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
+        var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
+        if (exoticToPrim !== undefined) {
+          var result = exoticToPrim.call(input, hint);
+          if (IsObject(result))
+            throw new TypeError;
+          return result;
+        }
+        return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
+      }
+      function OrdinaryToPrimitive(O, hint) {
+        if (hint === "string") {
+          var toString_1 = O.toString;
+          if (IsCallable(toString_1)) {
+            var result = toString_1.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        } else {
+          var valueOf = O.valueOf;
+          if (IsCallable(valueOf)) {
+            var result = valueOf.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+          var toString_2 = O.toString;
+          if (IsCallable(toString_2)) {
+            var result = toString_2.call(O);
+            if (!IsObject(result))
+              return result;
+          }
+        }
+        throw new TypeError;
+      }
+      function ToBoolean(argument) {
+        return !!argument;
+      }
+      function ToString(argument) {
+        return "" + argument;
+      }
+      function ToPropertyKey(argument) {
+        var key = ToPrimitive(argument, 3);
+        if (IsSymbol(key))
+          return key;
+        return ToString(key);
+      }
+      function IsArray(argument) {
+        return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
+      }
+      function IsCallable(argument) {
+        return typeof argument === "function";
+      }
+      function IsConstructor(argument) {
+        return typeof argument === "function";
+      }
+      function IsPropertyKey(argument) {
+        switch (Type(argument)) {
+          case 3:
+            return true;
+          case 4:
+            return true;
+          default:
+            return false;
+        }
+      }
+      function SameValueZero(x, y) {
+        return x === y || x !== x && y !== y;
+      }
+      function GetMethod(V, P) {
+        var func = V[P];
+        if (func === undefined || func === null)
+          return;
+        if (!IsCallable(func))
+          throw new TypeError;
+        return func;
+      }
+      function GetIterator(obj) {
+        var method = GetMethod(obj, iteratorSymbol);
+        if (!IsCallable(method))
+          throw new TypeError;
+        var iterator = method.call(obj);
+        if (!IsObject(iterator))
+          throw new TypeError;
+        return iterator;
+      }
+      function IteratorValue(iterResult) {
+        return iterResult.value;
+      }
+      function IteratorStep(iterator) {
+        var result = iterator.next();
+        return result.done ? false : result;
+      }
+      function IteratorClose(iterator) {
+        var f = iterator["return"];
+        if (f)
+          f.call(iterator);
+      }
+      function OrdinaryGetPrototypeOf(O) {
+        var proto = Object.getPrototypeOf(O);
+        if (typeof O !== "function" || O === functionPrototype)
+          return proto;
+        if (proto !== functionPrototype)
+          return proto;
+        var prototype = O.prototype;
+        var prototypeProto = prototype && Object.getPrototypeOf(prototype);
+        if (prototypeProto == null || prototypeProto === Object.prototype)
+          return proto;
+        var constructor = prototypeProto.constructor;
+        if (typeof constructor !== "function")
+          return proto;
+        if (constructor === O)
+          return proto;
+        return constructor;
+      }
+      function CreateMetadataRegistry() {
+        var fallback;
+        if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
+          fallback = CreateFallbackProvider(root.Reflect);
+        }
+        var first;
+        var second;
+        var rest;
+        var targetProviderMap = new _WeakMap;
+        var registry = {
+          registerProvider,
+          getProvider,
+          setProvider
+        };
+        return registry;
+        function registerProvider(provider) {
+          if (!Object.isExtensible(registry)) {
+            throw new Error("Cannot add provider to a frozen registry.");
+          }
+          switch (true) {
+            case fallback === provider:
+              break;
+            case IsUndefined(first):
+              first = provider;
+              break;
+            case first === provider:
+              break;
+            case IsUndefined(second):
+              second = provider;
+              break;
+            case second === provider:
+              break;
+            default:
+              if (rest === undefined)
+                rest = new _Set;
+              rest.add(provider);
+              break;
+          }
+        }
+        function getProviderNoCache(O, P) {
+          if (!IsUndefined(first)) {
+            if (first.isProviderFor(O, P))
+              return first;
+            if (!IsUndefined(second)) {
+              if (second.isProviderFor(O, P))
+                return first;
+              if (!IsUndefined(rest)) {
+                var iterator = GetIterator(rest);
+                while (true) {
+                  var next = IteratorStep(iterator);
+                  if (!next) {
+                    return;
+                  }
+                  var provider = IteratorValue(next);
+                  if (provider.isProviderFor(O, P)) {
+                    IteratorClose(iterator);
+                    return provider;
+                  }
+                }
+              }
+            }
+          }
+          if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
+            return fallback;
+          }
+          return;
+        }
+        function getProvider(O, P) {
+          var providerMap = targetProviderMap.get(O);
+          var provider;
+          if (!IsUndefined(providerMap)) {
+            provider = providerMap.get(P);
+          }
+          if (!IsUndefined(provider)) {
+            return provider;
+          }
+          provider = getProviderNoCache(O, P);
+          if (!IsUndefined(provider)) {
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return provider;
+        }
+        function hasProvider(provider) {
+          if (IsUndefined(provider))
+            throw new TypeError;
+          return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
+        }
+        function setProvider(O, P, provider) {
+          if (!hasProvider(provider)) {
+            throw new Error("Metadata provider not registered.");
+          }
+          var existingProvider = getProvider(O, P);
+          if (existingProvider !== provider) {
+            if (!IsUndefined(existingProvider)) {
+              return false;
+            }
+            var providerMap = targetProviderMap.get(O);
+            if (IsUndefined(providerMap)) {
+              providerMap = new _Map;
+              targetProviderMap.set(O, providerMap);
+            }
+            providerMap.set(P, provider);
+          }
+          return true;
+        }
+      }
+      function GetOrCreateMetadataRegistry() {
+        var metadataRegistry2;
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          metadataRegistry2 = root.Reflect[registrySymbol];
+        }
+        if (IsUndefined(metadataRegistry2)) {
+          metadataRegistry2 = CreateMetadataRegistry();
+        }
+        if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
+          Object.defineProperty(root.Reflect, registrySymbol, {
+            enumerable: false,
+            configurable: false,
+            writable: false,
+            value: metadataRegistry2
+          });
+        }
+        return metadataRegistry2;
+      }
+      function CreateMetadataProvider(registry) {
+        var metadata2 = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var targetMetadata = metadata2.get(O);
+            if (IsUndefined(targetMetadata))
+              return false;
+            return targetMetadata.has(P);
+          },
+          OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
+          OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
+          OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
+          OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
+          OrdinaryDeleteMetadata
+        };
+        metadataRegistry.registerProvider(provider);
+        return provider;
+        function GetOrCreateMetadataMap(O, P, Create) {
+          var targetMetadata = metadata2.get(O);
+          var createdTargetMetadata = false;
+          if (IsUndefined(targetMetadata)) {
+            if (!Create)
+              return;
+            targetMetadata = new _Map;
+            metadata2.set(O, targetMetadata);
+            createdTargetMetadata = true;
+          }
+          var metadataMap = targetMetadata.get(P);
+          if (IsUndefined(metadataMap)) {
+            if (!Create)
+              return;
+            metadataMap = new _Map;
+            targetMetadata.set(P, metadataMap);
+            if (!registry.setProvider(O, P, provider)) {
+              targetMetadata.delete(P);
+              if (createdTargetMetadata) {
+                metadata2.delete(O);
+              }
+              throw new Error("Wrong provider for target.");
+            }
+          }
+          return metadataMap;
+        }
+        function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return false;
+          return ToBoolean(metadataMap.has(MetadataKey));
+        }
+        function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return;
+          return metadataMap.get(MetadataKey);
+        }
+        function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, true);
+          metadataMap.set(MetadataKey, MetadataValue);
+        }
+        function OrdinaryOwnMetadataKeys2(O, P) {
+          var keys = [];
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return keys;
+          var keysObj = metadataMap.keys();
+          var iterator = GetIterator(keysObj);
+          var k = 0;
+          while (true) {
+            var next = IteratorStep(iterator);
+            if (!next) {
+              keys.length = k;
+              return keys;
+            }
+            var nextValue = IteratorValue(next);
+            try {
+              keys[k] = nextValue;
+            } catch (e) {
+              try {
+                IteratorClose(iterator);
+              } finally {
+                throw e;
+              }
+            }
+            k++;
+          }
+        }
+        function OrdinaryDeleteMetadata(MetadataKey, O, P) {
+          var metadataMap = GetOrCreateMetadataMap(O, P, false);
+          if (IsUndefined(metadataMap))
+            return false;
+          if (!metadataMap.delete(MetadataKey))
+            return false;
+          if (metadataMap.size === 0) {
+            var targetMetadata = metadata2.get(O);
+            if (!IsUndefined(targetMetadata)) {
+              targetMetadata.delete(P);
+              if (targetMetadata.size === 0) {
+                metadata2.delete(targetMetadata);
+              }
+            }
+          }
+          return true;
+        }
+      }
+      function CreateFallbackProvider(reflect) {
+        var { defineMetadata: defineMetadata2, hasOwnMetadata: hasOwnMetadata2, getOwnMetadata: getOwnMetadata2, getOwnMetadataKeys: getOwnMetadataKeys2, deleteMetadata: deleteMetadata2 } = reflect;
+        var metadataOwner = new _WeakMap;
+        var provider = {
+          isProviderFor: function(O, P) {
+            var metadataPropertySet = metadataOwner.get(O);
+            if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
+              return true;
+            }
+            if (getOwnMetadataKeys2(O, P).length) {
+              if (IsUndefined(metadataPropertySet)) {
+                metadataPropertySet = new _Set;
+                metadataOwner.set(O, metadataPropertySet);
+              }
+              metadataPropertySet.add(P);
+              return true;
+            }
+            return false;
+          },
+          OrdinaryDefineOwnMetadata: defineMetadata2,
+          OrdinaryHasOwnMetadata: hasOwnMetadata2,
+          OrdinaryGetOwnMetadata: getOwnMetadata2,
+          OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
+          OrdinaryDeleteMetadata: deleteMetadata2
+        };
+        return provider;
+      }
+      function GetMetadataProvider(O, P, Create) {
+        var registeredProvider = metadataRegistry.getProvider(O, P);
+        if (!IsUndefined(registeredProvider)) {
+          return registeredProvider;
+        }
+        if (Create) {
+          if (metadataRegistry.setProvider(O, P, metadataProvider)) {
+            return metadataProvider;
+          }
+          throw new Error("Illegal state.");
+        }
+        return;
+      }
+      function CreateMapPolyfill() {
+        var cacheSentinel = {};
+        var arraySentinel = [];
+        var MapIterator = function() {
+          function MapIterator2(keys, values, selector) {
+            this._index = 0;
+            this._keys = keys;
+            this._values = values;
+            this._selector = selector;
+          }
+          MapIterator2.prototype["@@iterator"] = function() {
+            return this;
+          };
+          MapIterator2.prototype[iteratorSymbol] = function() {
+            return this;
+          };
+          MapIterator2.prototype.next = function() {
+            var index = this._index;
+            if (index >= 0 && index < this._keys.length) {
+              var result = this._selector(this._keys[index], this._values[index]);
+              if (index + 1 >= this._keys.length) {
+                this._index = -1;
+                this._keys = arraySentinel;
+                this._values = arraySentinel;
+              } else {
+                this._index++;
+              }
+              return { value: result, done: false };
+            }
+            return { value: undefined, done: true };
+          };
+          MapIterator2.prototype.throw = function(error) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            throw error;
+          };
+          MapIterator2.prototype.return = function(value) {
+            if (this._index >= 0) {
+              this._index = -1;
+              this._keys = arraySentinel;
+              this._values = arraySentinel;
+            }
+            return { value, done: true };
+          };
+          return MapIterator2;
+        }();
+        var Map2 = function() {
+          function Map3() {
+            this._keys = [];
+            this._values = [];
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          }
+          Object.defineProperty(Map3.prototype, "size", {
+            get: function() {
+              return this._keys.length;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Map3.prototype.has = function(key) {
+            return this._find(key, false) >= 0;
+          };
+          Map3.prototype.get = function(key) {
+            var index = this._find(key, false);
+            return index >= 0 ? this._values[index] : undefined;
+          };
+          Map3.prototype.set = function(key, value) {
+            var index = this._find(key, true);
+            this._values[index] = value;
+            return this;
+          };
+          Map3.prototype.delete = function(key) {
+            var index = this._find(key, false);
+            if (index >= 0) {
+              var size = this._keys.length;
+              for (var i = index + 1;i < size; i++) {
+                this._keys[i - 1] = this._keys[i];
+                this._values[i - 1] = this._values[i];
+              }
+              this._keys.length--;
+              this._values.length--;
+              if (SameValueZero(key, this._cacheKey)) {
+                this._cacheKey = cacheSentinel;
+                this._cacheIndex = -2;
+              }
+              return true;
+            }
+            return false;
+          };
+          Map3.prototype.clear = function() {
+            this._keys.length = 0;
+            this._values.length = 0;
+            this._cacheKey = cacheSentinel;
+            this._cacheIndex = -2;
+          };
+          Map3.prototype.keys = function() {
+            return new MapIterator(this._keys, this._values, getKey);
+          };
+          Map3.prototype.values = function() {
+            return new MapIterator(this._keys, this._values, getValue);
+          };
+          Map3.prototype.entries = function() {
+            return new MapIterator(this._keys, this._values, getEntry);
+          };
+          Map3.prototype["@@iterator"] = function() {
+            return this.entries();
+          };
+          Map3.prototype[iteratorSymbol] = function() {
+            return this.entries();
+          };
+          Map3.prototype._find = function(key, insert) {
+            if (!SameValueZero(this._cacheKey, key)) {
+              this._cacheIndex = -1;
+              for (var i = 0;i < this._keys.length; i++) {
+                if (SameValueZero(this._keys[i], key)) {
+                  this._cacheIndex = i;
+                  break;
+                }
+              }
+            }
+            if (this._cacheIndex < 0 && insert) {
+              this._cacheIndex = this._keys.length;
+              this._keys.push(key);
+              this._values.push(undefined);
+            }
+            return this._cacheIndex;
+          };
+          return Map3;
+        }();
+        return Map2;
+        function getKey(key, _) {
+          return key;
+        }
+        function getValue(_, value) {
+          return value;
+        }
+        function getEntry(key, value) {
+          return [key, value];
+        }
+      }
+      function CreateSetPolyfill() {
+        var Set2 = function() {
+          function Set3() {
+            this._map = new _Map;
+          }
+          Object.defineProperty(Set3.prototype, "size", {
+            get: function() {
+              return this._map.size;
+            },
+            enumerable: true,
+            configurable: true
+          });
+          Set3.prototype.has = function(value) {
+            return this._map.has(value);
+          };
+          Set3.prototype.add = function(value) {
+            return this._map.set(value, value), this;
+          };
+          Set3.prototype.delete = function(value) {
+            return this._map.delete(value);
+          };
+          Set3.prototype.clear = function() {
+            this._map.clear();
+          };
+          Set3.prototype.keys = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.values = function() {
+            return this._map.keys();
+          };
+          Set3.prototype.entries = function() {
+            return this._map.entries();
+          };
+          Set3.prototype["@@iterator"] = function() {
+            return this.keys();
+          };
+          Set3.prototype[iteratorSymbol] = function() {
+            return this.keys();
+          };
+          return Set3;
+        }();
+        return Set2;
+      }
+      function CreateWeakMapPolyfill() {
+        var UUID_SIZE = 16;
+        var keys = HashMap.create();
+        var rootKey = CreateUniqueKey();
+        return function() {
+          function WeakMap2() {
+            this._key = CreateUniqueKey();
+          }
+          WeakMap2.prototype.has = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.has(table, this._key) : false;
+          };
+          WeakMap2.prototype.get = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? HashMap.get(table, this._key) : undefined;
+          };
+          WeakMap2.prototype.set = function(target, value) {
+            var table = GetOrCreateWeakMapTable(target, true);
+            table[this._key] = value;
+            return this;
+          };
+          WeakMap2.prototype.delete = function(target) {
+            var table = GetOrCreateWeakMapTable(target, false);
+            return table !== undefined ? delete table[this._key] : false;
+          };
+          WeakMap2.prototype.clear = function() {
+            this._key = CreateUniqueKey();
+          };
+          return WeakMap2;
+        }();
+        function CreateUniqueKey() {
+          var key;
+          do
+            key = "@@WeakMap@@" + CreateUUID();
+          while (HashMap.has(keys, key));
+          keys[key] = true;
+          return key;
+        }
+        function GetOrCreateWeakMapTable(target, create) {
+          if (!hasOwn.call(target, rootKey)) {
+            if (!create)
+              return;
+            Object.defineProperty(target, rootKey, { value: HashMap.create() });
+          }
+          return target[rootKey];
+        }
+        function FillRandomBytes(buffer, size) {
+          for (var i = 0;i < size; ++i)
+            buffer[i] = Math.random() * 255 | 0;
+          return buffer;
+        }
+        function GenRandomBytes(size) {
+          if (typeof Uint8Array === "function") {
+            var array = new Uint8Array(size);
+            if (typeof crypto !== "undefined") {
+              crypto.getRandomValues(array);
+            } else if (typeof msCrypto !== "undefined") {
+              msCrypto.getRandomValues(array);
+            } else {
+              FillRandomBytes(array, size);
+            }
+            return array;
+          }
+          return FillRandomBytes(new Array(size), size);
+        }
+        function CreateUUID() {
+          var data = GenRandomBytes(UUID_SIZE);
+          data[6] = data[6] & 79 | 64;
+          data[8] = data[8] & 191 | 128;
+          var result = "";
+          for (var offset = 0;offset < UUID_SIZE; ++offset) {
+            var byte = data[offset];
+            if (offset === 4 || offset === 6 || offset === 8)
+              result += "-";
+            if (byte < 16)
+              result += "0";
+            result += byte.toString(16).toLowerCase();
+          }
+          return result;
+        }
+      }
+      function MakeDictionary(obj) {
+        obj.__ = undefined;
+        delete obj.__;
+        return obj;
+      }
+    });
+  })(Reflect2 || (Reflect2 = {}));
+});
+
+// node_modules/node-cron/dist/esm/create-id.js
+var require_create_id = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.createID = createID;
+  var node_crypto_1 = __importDefault(__require("crypto"));
+  function createID(prefix = "", length = 16) {
+    const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const values = node_crypto_1.default.randomBytes(length);
+    const id = Array.from(values, (v) => charset[v % charset.length]).join("");
+    return prefix ? `${prefix}-${id}` : id;
+  }
+});
+
+// node_modules/node-cron/dist/esm/logger.js
+var require_logger = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var levelColors = {
+    INFO: "\x1B[36m",
+    WARN: "\x1B[33m",
+    ERROR: "\x1B[31m",
+    DEBUG: "\x1B[35m"
+  };
+  var GREEN = "\x1B[32m";
+  var RESET = "\x1B[0m";
+  function log(level, message, extra) {
+    const timestamp = new Date().toISOString();
+    const color = levelColors[level] ?? "";
+    const prefix = `[${timestamp}] [PID: ${process.pid}] ${GREEN}[NODE-CRON]${GREEN} ${color}[${level}]${RESET}`;
+    const output = `${prefix} ${message}`;
+    switch (level) {
+      case "ERROR":
+        console.error(output, extra ?? "");
+        break;
+      case "DEBUG":
+        console.debug(output, extra ?? "");
+        break;
+      case "WARN":
+        console.warn(output);
+        break;
+      case "INFO":
+      default:
+        console.info(output);
+        break;
+    }
+  }
+  var logger = {
+    info(message) {
+      log("INFO", message);
+    },
+    warn(message) {
+      log("WARN", message);
+    },
+    error(message, err) {
+      if (message instanceof Error) {
+        log("ERROR", message.message, message);
+      } else {
+        log("ERROR", message, err);
+      }
+    },
+    debug(message, err) {
+      if (message instanceof Error) {
+        log("DEBUG", message.message, message);
+      } else {
+        log("DEBUG", message, err);
+      }
+    }
+  };
+  exports.default = logger;
+});
+
+// node_modules/node-cron/dist/esm/promise/tracked-promise.js
+var require_tracked_promise = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.TrackedPromise = undefined;
+
+  class TrackedPromise {
+    promise;
+    error;
+    state;
+    value;
+    constructor(executor) {
+      this.state = "pending";
+      this.promise = new Promise((resolve, reject) => {
+        executor((value) => {
+          this.state = "fulfilled";
+          this.value = value;
+          resolve(value);
+        }, (error) => {
+          this.state = "rejected";
+          this.error = error;
+          reject(error);
+        });
+      });
+    }
+    getPromise() {
+      return this.promise;
+    }
+    getState() {
+      return this.state;
+    }
+    isPending() {
+      return this.state === "pending";
+    }
+    isFulfilled() {
+      return this.state === "fulfilled";
+    }
+    isRejected() {
+      return this.state === "rejected";
+    }
+    getValue() {
+      return this.value;
+    }
+    getError() {
+      return this.error;
+    }
+    then(onfulfilled, onrejected) {
+      return this.promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+      return this.promise.catch(onrejected);
+    }
+    finally(onfinally) {
+      return this.promise.finally(onfinally);
+    }
+  }
+  exports.TrackedPromise = TrackedPromise;
+});
+
+// node_modules/node-cron/dist/esm/scheduler/runner.js
+var require_runner = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Runner = undefined;
+  var create_id_1 = require_create_id();
+  var logger_1 = __importDefault(require_logger());
+  var tracked_promise_1 = require_tracked_promise();
+  function emptyOnFn() {}
+  function emptyHookFn() {
+    return true;
+  }
+  function defaultOnError(date, error) {
+    logger_1.default.error("Task failed with error!", error);
+  }
+
+  class Runner {
+    timeMatcher;
+    onMatch;
+    noOverlap;
+    maxExecutions;
+    maxRandomDelay;
+    runCount;
+    running;
+    heartBeatTimeout;
+    onMissedExecution;
+    onOverlap;
+    onError;
+    beforeRun;
+    onFinished;
+    onMaxExecutions;
+    constructor(timeMatcher, onMatch, options) {
+      this.timeMatcher = timeMatcher;
+      this.onMatch = onMatch;
+      this.noOverlap = options == undefined || options.noOverlap === undefined ? false : options.noOverlap;
+      this.maxExecutions = options?.maxExecutions;
+      this.maxRandomDelay = options?.maxRandomDelay || 0;
+      this.onMissedExecution = options?.onMissedExecution || emptyOnFn;
+      this.onOverlap = options?.onOverlap || emptyOnFn;
+      this.onError = options?.onError || defaultOnError;
+      this.onFinished = options?.onFinished || emptyHookFn;
+      this.beforeRun = options?.beforeRun || emptyHookFn;
+      this.onMaxExecutions = options?.onMaxExecutions || emptyOnFn;
+      this.runCount = 0;
+      this.running = false;
+    }
+    start() {
+      this.running = true;
+      let lastExecution;
+      let expectedNextExecution;
+      const scheduleNextHeartBeat = (currentDate) => {
+        if (this.running) {
+          clearTimeout(this.heartBeatTimeout);
+          this.heartBeatTimeout = setTimeout(heartBeat, getDelay(this.timeMatcher, currentDate));
+        }
+      };
+      const runTask = (date) => {
+        return new Promise(async (resolve) => {
+          const execution = {
+            id: (0, create_id_1.createID)("exec"),
+            reason: "scheduled"
+          };
+          const shouldExecute = await this.beforeRun(date, execution);
+          const randomDelay = Math.floor(Math.random() * this.maxRandomDelay);
+          if (shouldExecute) {
+            setTimeout(async () => {
+              try {
+                this.runCount++;
+                execution.startedAt = new Date;
+                const result = await this.onMatch(date, execution);
+                execution.finishedAt = new Date;
+                execution.result = result;
+                this.onFinished(date, execution);
+                if (this.maxExecutions && this.runCount >= this.maxExecutions) {
+                  this.onMaxExecutions(date);
+                  this.stop();
+                }
+              } catch (error) {
+                execution.finishedAt = new Date;
+                execution.error = error;
+                this.onError(date, error, execution);
+              }
+              resolve(true);
+            }, randomDelay);
+          }
+        });
+      };
+      const checkAndRun = (date) => {
+        return new tracked_promise_1.TrackedPromise(async (resolve, reject) => {
+          try {
+            if (this.timeMatcher.match(date)) {
+              await runTask(date);
+            }
+            resolve(true);
+          } catch (err) {
+            reject(err);
+          }
+        });
+      };
+      const heartBeat = async () => {
+        const currentDate = nowWithoutMs();
+        if (expectedNextExecution && expectedNextExecution.getTime() < currentDate.getTime()) {
+          while (expectedNextExecution.getTime() < currentDate.getTime()) {
+            logger_1.default.warn(`missed execution at ${expectedNextExecution}! Possible blocking IO or high CPU user at the same process used by node-cron.`);
+            expectedNextExecution = this.timeMatcher.getNextMatch(expectedNextExecution);
+            runAsync(this.onMissedExecution, expectedNextExecution, defaultOnError);
+          }
+        }
+        if (lastExecution && lastExecution.getState() === "pending") {
+          runAsync(this.onOverlap, currentDate, defaultOnError);
+          if (this.noOverlap) {
+            logger_1.default.warn("task still running, new execution blocked by overlap prevention!");
+            expectedNextExecution = this.timeMatcher.getNextMatch(currentDate);
+            scheduleNextHeartBeat(currentDate);
+            return;
+          }
+        }
+        lastExecution = checkAndRun(currentDate);
+        expectedNextExecution = this.timeMatcher.getNextMatch(currentDate);
+        scheduleNextHeartBeat(currentDate);
+      };
+      this.heartBeatTimeout = setTimeout(() => {
+        heartBeat();
+      }, getDelay(this.timeMatcher, nowWithoutMs()));
+    }
+    nextRun() {
+      return this.timeMatcher.getNextMatch(new Date);
+    }
+    stop() {
+      this.running = false;
+      if (this.heartBeatTimeout) {
+        clearTimeout(this.heartBeatTimeout);
+        this.heartBeatTimeout = undefined;
+      }
+    }
+    isStarted() {
+      return !!this.heartBeatTimeout && this.running;
+    }
+    isStopped() {
+      return !this.isStarted();
+    }
+    async execute() {
+      const date = new Date;
+      const execution = {
+        id: (0, create_id_1.createID)("exec"),
+        reason: "invoked"
+      };
+      try {
+        const shouldExecute = await this.beforeRun(date, execution);
+        if (shouldExecute) {
+          this.runCount++;
+          execution.startedAt = new Date;
+          const result = await this.onMatch(date, execution);
+          execution.finishedAt = new Date;
+          execution.result = result;
+          this.onFinished(date, execution);
+        }
+      } catch (error) {
+        execution.finishedAt = new Date;
+        execution.error = error;
+        this.onError(date, error, execution);
+      }
+    }
+  }
+  exports.Runner = Runner;
+  async function runAsync(fn, date, onError) {
+    try {
+      await fn(date);
+    } catch (error) {
+      onError(date, error);
+    }
+  }
+  function getDelay(timeMatcher, currentDate) {
+    const maxDelay = 86400000;
+    const nextRun = timeMatcher.getNextMatch(currentDate);
+    const now = new Date;
+    const delay = nextRun.getTime() - now.getTime();
+    if (delay > maxDelay) {
+      return maxDelay;
+    }
+    return Math.max(0, delay);
+  }
+  function nowWithoutMs() {
+    const date = new Date;
+    date.setMilliseconds(0);
+    return date;
+  }
+});
+
+// node_modules/node-cron/dist/esm/pattern/convertion/month-names-conversion.js
+var require_month_names_conversion = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.default = (() => {
+    const months = [
+      "january",
+      "february",
+      "march",
+      "april",
+      "may",
+      "june",
+      "july",
+      "august",
+      "september",
+      "october",
+      "november",
+      "december"
+    ];
+    const shortMonths = [
+      "jan",
+      "feb",
+      "mar",
+      "apr",
+      "may",
+      "jun",
+      "jul",
+      "aug",
+      "sep",
+      "oct",
+      "nov",
+      "dec"
+    ];
+    function convertMonthName(expression, items) {
+      for (let i = 0;i < items.length; i++) {
+        expression = expression.replace(new RegExp(items[i], "gi"), i + 1);
+      }
+      return expression;
+    }
+    function interprete(monthExpression) {
+      monthExpression = convertMonthName(monthExpression, months);
+      monthExpression = convertMonthName(monthExpression, shortMonths);
+      return monthExpression;
+    }
+    return interprete;
+  })();
+});
+
+// node_modules/node-cron/dist/esm/pattern/convertion/week-day-names-conversion.js
+var require_week_day_names_conversion = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.default = (() => {
+    const weekDays = [
+      "sunday",
+      "monday",
+      "tuesday",
+      "wednesday",
+      "thursday",
+      "friday",
+      "saturday"
+    ];
+    const shortWeekDays = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+    function convertWeekDayName(expression, items) {
+      for (let i = 0;i < items.length; i++) {
+        expression = expression.replace(new RegExp(items[i], "gi"), i);
+      }
+      return expression;
+    }
+    function convertWeekDays(expression) {
+      expression = expression.replace("7", "0");
+      expression = convertWeekDayName(expression, weekDays);
+      return convertWeekDayName(expression, shortWeekDays);
+    }
+    return convertWeekDays;
+  })();
+});
+
+// node_modules/node-cron/dist/esm/pattern/convertion/asterisk-to-range-conversion.js
+var require_asterisk_to_range_conversion = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.default = (() => {
+    function convertAsterisk(expression, replecement) {
+      if (expression.indexOf("*") !== -1) {
+        return expression.replace("*", replecement);
+      }
+      return expression;
+    }
+    function convertAsterisksToRanges(expressions) {
+      expressions[0] = convertAsterisk(expressions[0], "0-59");
+      expressions[1] = convertAsterisk(expressions[1], "0-59");
+      expressions[2] = convertAsterisk(expressions[2], "0-23");
+      expressions[3] = convertAsterisk(expressions[3], "1-31");
+      expressions[4] = convertAsterisk(expressions[4], "1-12");
+      expressions[5] = convertAsterisk(expressions[5], "0-6");
+      return expressions;
+    }
+    return convertAsterisksToRanges;
+  })();
+});
+
+// node_modules/node-cron/dist/esm/pattern/convertion/range-conversion.js
+var require_range_conversion = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.default = (() => {
+    function replaceWithRange(expression, text, init, end, stepTxt) {
+      const step = parseInt(stepTxt);
+      const numbers = [];
+      let last = parseInt(end);
+      let first = parseInt(init);
+      if (first > last) {
+        last = parseInt(init);
+        first = parseInt(end);
+      }
+      for (let i = first;i <= last; i += step) {
+        numbers.push(i);
+      }
+      return expression.replace(new RegExp(text, "i"), numbers.join());
+    }
+    function convertRange(expression) {
+      const rangeRegEx = /(\d+)-(\d+)(\/(\d+)|)/;
+      let match = rangeRegEx.exec(expression);
+      while (match !== null && match.length > 0) {
+        expression = replaceWithRange(expression, match[0], match[1], match[2], match[4] || "1");
+        match = rangeRegEx.exec(expression);
+      }
+      return expression;
+    }
+    function convertAllRanges(expressions) {
+      for (let i = 0;i < expressions.length; i++) {
+        expressions[i] = convertRange(expressions[i]);
+      }
+      return expressions;
+    }
+    return convertAllRanges;
+  })();
+});
+
+// node_modules/node-cron/dist/esm/pattern/convertion/index.js
+var require_convertion = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var month_names_conversion_1 = __importDefault(require_month_names_conversion());
+  var week_day_names_conversion_1 = __importDefault(require_week_day_names_conversion());
+  var asterisk_to_range_conversion_1 = __importDefault(require_asterisk_to_range_conversion());
+  var range_conversion_1 = __importDefault(require_range_conversion());
+  exports.default = (() => {
+    function appendSeccondExpression(expressions) {
+      if (expressions.length === 5) {
+        return ["0"].concat(expressions);
+      }
+      return expressions;
+    }
+    function removeSpaces(str) {
+      return str.replace(/\s{2,}/g, " ").trim();
+    }
+    function normalizeIntegers(expressions) {
+      for (let i = 0;i < expressions.length; i++) {
+        const numbers = expressions[i].split(",");
+        for (let j = 0;j < numbers.length; j++) {
+          numbers[j] = parseInt(numbers[j]);
+        }
+        expressions[i] = numbers;
+      }
+      return expressions;
+    }
+    function interprete(expression) {
+      let expressions = removeSpaces(`${expression}`).split(" ");
+      expressions = appendSeccondExpression(expressions);
+      expressions[4] = (0, month_names_conversion_1.default)(expressions[4]);
+      expressions[5] = (0, week_day_names_conversion_1.default)(expressions[5]);
+      expressions = (0, asterisk_to_range_conversion_1.default)(expressions);
+      expressions = (0, range_conversion_1.default)(expressions);
+      expressions = normalizeIntegers(expressions);
+      return expressions;
+    }
+    return interprete;
+  })();
+});
+
+// node_modules/node-cron/dist/esm/time/localized-time.js
+var require_localized_time = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LocalizedTime = undefined;
+
+  class LocalizedTime {
+    timestamp;
+    parts;
+    timezone;
+    constructor(date, timezone) {
+      this.timestamp = date.getTime();
+      this.timezone = timezone;
+      this.parts = buildDateParts(date, timezone);
+    }
+    toDate() {
+      return new Date(this.timestamp);
+    }
+    toISO() {
+      const gmt = this.parts.gmt.replace(/^GMT/, "");
+      const offset = gmt ? gmt : "Z";
+      const pad = (n) => String(n).padStart(2, "0");
+      return `${this.parts.year}-${pad(this.parts.month)}-${pad(this.parts.day)}` + `T${pad(this.parts.hour)}:${pad(this.parts.minute)}:${pad(this.parts.second)}` + `.${String(this.parts.milisecond).padStart(3, "0")}` + offset;
+    }
+    getParts() {
+      return this.parts;
+    }
+    set(field, value) {
+      this.parts[field] = value;
+      const newDate = new Date(this.toISO());
+      this.timestamp = newDate.getTime();
+      this.parts = buildDateParts(newDate, this.timezone);
+    }
+  }
+  exports.LocalizedTime = LocalizedTime;
+  function buildDateParts(date, timezone) {
+    const dftOptions = {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      weekday: "short",
+      hour12: false
+    };
+    if (timezone) {
+      dftOptions.timeZone = timezone;
+    }
+    const dateFormat = new Intl.DateTimeFormat("en-US", dftOptions);
+    const parts = dateFormat.formatToParts(date).filter((part) => {
+      return part.type !== "literal";
+    }).reduce((acc, part) => {
+      acc[part.type] = part.value;
+      return acc;
+    }, {});
+    return {
+      day: parseInt(parts.day),
+      month: parseInt(parts.month),
+      year: parseInt(parts.year),
+      hour: parts.hour === "24" ? 0 : parseInt(parts.hour),
+      minute: parseInt(parts.minute),
+      second: parseInt(parts.second),
+      milisecond: date.getMilliseconds(),
+      weekday: parts.weekday,
+      gmt: getTimezoneGMT(date, timezone)
+    };
+  }
+  function getTimezoneGMT(date, timezone) {
+    const utcDate = new Date(date.toLocaleString("en-US", { timeZone: "UTC" }));
+    const tzDate = new Date(date.toLocaleString("en-US", { timeZone: timezone }));
+    let offsetInMinutes = (utcDate.getTime() - tzDate.getTime()) / 60000;
+    const sign = offsetInMinutes <= 0 ? "+" : "-";
+    offsetInMinutes = Math.abs(offsetInMinutes);
+    if (offsetInMinutes === 0)
+      return "Z";
+    const hours = Math.floor(offsetInMinutes / 60).toString().padStart(2, "0");
+    const minutes = Math.floor(offsetInMinutes % 60).toString().padStart(2, "0");
+    return `GMT${sign}${hours}:${minutes}`;
+  }
+});
+
+// node_modules/node-cron/dist/esm/time/matcher-walker.js
+var require_matcher_walker = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.MatcherWalker = undefined;
+  var convertion_1 = __importDefault(require_convertion());
+  var localized_time_1 = require_localized_time();
+  var time_matcher_1 = require_time_matcher();
+  var week_day_names_conversion_1 = __importDefault(require_week_day_names_conversion());
+
+  class MatcherWalker {
+    cronExpression;
+    baseDate;
+    pattern;
+    expressions;
+    timeMatcher;
+    timezone;
+    constructor(cronExpression, baseDate, timezone) {
+      this.cronExpression = cronExpression;
+      this.baseDate = baseDate;
+      this.timeMatcher = new time_matcher_1.TimeMatcher(cronExpression, timezone);
+      this.timezone = timezone;
+      this.expressions = (0, convertion_1.default)(cronExpression);
+    }
+    isMatching() {
+      return this.timeMatcher.match(this.baseDate);
+    }
+    matchNext() {
+      const findNextDateIgnoringWeekday = () => {
+        const baseDate = new Date(this.baseDate.getTime());
+        baseDate.setMilliseconds(0);
+        const localTime = new localized_time_1.LocalizedTime(baseDate, this.timezone);
+        const dateParts = localTime.getParts();
+        const date2 = new localized_time_1.LocalizedTime(localTime.toDate(), this.timezone);
+        const seconds = this.expressions[0];
+        const nextSecond = availableValue(seconds, dateParts.second);
+        if (nextSecond) {
+          date2.set("second", nextSecond);
+          if (this.timeMatcher.match(date2.toDate())) {
+            return date2;
+          }
+        }
+        date2.set("second", seconds[0]);
+        const minutes = this.expressions[1];
+        const nextMinute = availableValue(minutes, dateParts.minute);
+        if (nextMinute) {
+          date2.set("minute", nextMinute);
+          if (this.timeMatcher.match(date2.toDate())) {
+            return date2;
+          }
+        }
+        date2.set("minute", minutes[0]);
+        const hours = this.expressions[2];
+        const nextHour = availableValue(hours, dateParts.hour);
+        if (nextHour) {
+          date2.set("hour", nextHour);
+          if (this.timeMatcher.match(date2.toDate())) {
+            return date2;
+          }
+        }
+        date2.set("hour", hours[0]);
+        const days = this.expressions[3];
+        const nextDay = availableValue(days, dateParts.day);
+        if (nextDay) {
+          date2.set("day", nextDay);
+          if (this.timeMatcher.match(date2.toDate())) {
+            return date2;
+          }
+        }
+        date2.set("day", days[0]);
+        const months = this.expressions[4];
+        const nextMonth = availableValue(months, dateParts.month);
+        if (nextMonth) {
+          date2.set("month", nextMonth);
+          if (this.timeMatcher.match(date2.toDate())) {
+            return date2;
+          }
+        }
+        date2.set("year", date2.getParts().year + 1);
+        date2.set("month", months[0]);
+        return date2;
+      };
+      const date = findNextDateIgnoringWeekday();
+      const weekdays = this.expressions[5];
+      let currentWeekday = parseInt((0, week_day_names_conversion_1.default)(date.getParts().weekday));
+      while (!(weekdays.indexOf(currentWeekday) > -1)) {
+        date.set("year", date.getParts().year + 1);
+        currentWeekday = parseInt((0, week_day_names_conversion_1.default)(date.getParts().weekday));
+      }
+      return date;
+    }
+  }
+  exports.MatcherWalker = MatcherWalker;
+  function availableValue(values, currentValue) {
+    const availableValues = values.sort((a, b) => a - b).filter((s) => s > currentValue);
+    if (availableValues.length > 0)
+      return availableValues[0];
+    return false;
+  }
+});
+
+// node_modules/node-cron/dist/esm/time/time-matcher.js
+var require_time_matcher = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.TimeMatcher = undefined;
+  var index_1 = __importDefault(require_convertion());
+  var week_day_names_conversion_1 = __importDefault(require_week_day_names_conversion());
+  var localized_time_1 = require_localized_time();
+  var matcher_walker_1 = require_matcher_walker();
+  function matchValue(allowedValues, value) {
+    return allowedValues.indexOf(value) !== -1;
+  }
+
+  class TimeMatcher {
+    timezone;
+    pattern;
+    expressions;
+    constructor(pattern, timezone) {
+      this.timezone = timezone;
+      this.pattern = pattern;
+      this.expressions = (0, index_1.default)(pattern);
+    }
+    match(date) {
+      const localizedTime = new localized_time_1.LocalizedTime(date, this.timezone);
+      const parts = localizedTime.getParts();
+      const runOnSecond = matchValue(this.expressions[0], parts.second);
+      const runOnMinute = matchValue(this.expressions[1], parts.minute);
+      const runOnHour = matchValue(this.expressions[2], parts.hour);
+      const runOnDay = matchValue(this.expressions[3], parts.day);
+      const runOnMonth = matchValue(this.expressions[4], parts.month);
+      const runOnWeekDay = matchValue(this.expressions[5], parseInt((0, week_day_names_conversion_1.default)(parts.weekday)));
+      return runOnSecond && runOnMinute && runOnHour && runOnDay && runOnMonth && runOnWeekDay;
+    }
+    getNextMatch(date) {
+      const walker = new matcher_walker_1.MatcherWalker(this.pattern, date, this.timezone);
+      const next = walker.matchNext();
+      return next.toDate();
+    }
+  }
+  exports.TimeMatcher = TimeMatcher;
+});
+
+// node_modules/node-cron/dist/esm/tasks/state-machine.js
+var require_state_machine = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.StateMachine = undefined;
+  var allowedTransitions = {
+    stopped: ["stopped", "idle", "destroyed"],
+    idle: ["idle", "running", "stopped", "destroyed"],
+    running: ["running", "idle", "stopped", "destroyed"],
+    destroyed: ["destroyed"]
+  };
+
+  class StateMachine {
+    state;
+    constructor(initial = "stopped") {
+      this.state = initial;
+    }
+    changeState(state) {
+      if (allowedTransitions[this.state].includes(state)) {
+        this.state = state;
+      } else {
+        throw new Error(`invalid transition from ${this.state} to ${state}`);
+      }
+    }
+  }
+  exports.StateMachine = StateMachine;
+});
+
+// node_modules/node-cron/dist/esm/tasks/inline-scheduled-task.js
+var require_inline_scheduled_task = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.InlineScheduledTask = undefined;
+  var events_1 = __importDefault(__require("events"));
+  var runner_1 = require_runner();
+  var time_matcher_1 = require_time_matcher();
+  var create_id_1 = require_create_id();
+  var state_machine_1 = require_state_machine();
+  var logger_1 = __importDefault(require_logger());
+  var localized_time_1 = require_localized_time();
+
+  class TaskEmitter extends events_1.default {
+  }
+
+  class InlineScheduledTask {
+    emitter;
+    cronExpression;
+    timeMatcher;
+    runner;
+    id;
+    name;
+    stateMachine;
+    timezone;
+    constructor(cronExpression, taskFn, options) {
+      this.emitter = new TaskEmitter;
+      this.cronExpression = cronExpression;
+      this.id = (0, create_id_1.createID)("task", 12);
+      this.name = options?.name || this.id;
+      this.timezone = options?.timezone;
+      this.timeMatcher = new time_matcher_1.TimeMatcher(cronExpression, options?.timezone);
+      this.stateMachine = new state_machine_1.StateMachine;
+      const runnerOptions = {
+        timezone: options?.timezone,
+        noOverlap: options?.noOverlap,
+        maxExecutions: options?.maxExecutions,
+        maxRandomDelay: options?.maxRandomDelay,
+        beforeRun: (date, execution) => {
+          if (execution.reason === "scheduled") {
+            this.changeState("running");
+          }
+          this.emitter.emit("execution:started", this.createContext(date, execution));
+          return true;
+        },
+        onFinished: (date, execution) => {
+          if (execution.reason === "scheduled") {
+            this.changeState("idle");
+          }
+          this.emitter.emit("execution:finished", this.createContext(date, execution));
+          return true;
+        },
+        onError: (date, error, execution) => {
+          logger_1.default.error(error);
+          this.emitter.emit("execution:failed", this.createContext(date, execution));
+          this.changeState("idle");
+        },
+        onOverlap: (date) => {
+          this.emitter.emit("execution:overlap", this.createContext(date));
+        },
+        onMissedExecution: (date) => {
+          this.emitter.emit("execution:missed", this.createContext(date));
+        },
+        onMaxExecutions: (date) => {
+          this.emitter.emit("execution:maxReached", this.createContext(date));
+          this.destroy();
+        }
+      };
+      this.runner = new runner_1.Runner(this.timeMatcher, (date, execution) => {
+        return taskFn(this.createContext(date, execution));
+      }, runnerOptions);
+    }
+    getNextRun() {
+      if (this.stateMachine.state !== "stopped") {
+        return this.runner.nextRun();
+      }
+      return null;
+    }
+    changeState(state) {
+      if (this.runner.isStarted()) {
+        this.stateMachine.changeState(state);
+      }
+    }
+    start() {
+      if (this.runner.isStopped()) {
+        this.runner.start();
+        this.stateMachine.changeState("idle");
+        this.emitter.emit("task:started", this.createContext(new Date));
+      }
+    }
+    stop() {
+      if (this.runner.isStarted()) {
+        this.runner.stop();
+        this.stateMachine.changeState("stopped");
+        this.emitter.emit("task:stopped", this.createContext(new Date));
+      }
+    }
+    getStatus() {
+      return this.stateMachine.state;
+    }
+    destroy() {
+      if (this.stateMachine.state === "destroyed")
+        return;
+      this.stop();
+      this.stateMachine.changeState("destroyed");
+      this.emitter.emit("task:destroyed", this.createContext(new Date));
+    }
+    execute() {
+      return new Promise((resolve, reject) => {
+        const onFail = (context) => {
+          this.off("execution:finished", onFail);
+          reject(context.execution?.error);
+        };
+        const onFinished = (context) => {
+          this.off("execution:failed", onFail);
+          resolve(context.execution?.result);
+        };
+        this.once("execution:finished", onFinished);
+        this.once("execution:failed", onFail);
+        this.runner.execute();
+      });
+    }
+    on(event, fun) {
+      this.emitter.on(event, fun);
+    }
+    off(event, fun) {
+      this.emitter.off(event, fun);
+    }
+    once(event, fun) {
+      this.emitter.once(event, fun);
+    }
+    createContext(executionDate, execution) {
+      const localTime = new localized_time_1.LocalizedTime(executionDate, this.timezone);
+      const ctx = {
+        date: localTime.toDate(),
+        dateLocalIso: localTime.toISO(),
+        triggeredAt: new Date,
+        task: this,
+        execution
+      };
+      return ctx;
+    }
+  }
+  exports.InlineScheduledTask = InlineScheduledTask;
+});
+
+// node_modules/node-cron/dist/esm/task-registry.js
+var require_task_registry = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.TaskRegistry = undefined;
+  var tasks = new Map;
+
+  class TaskRegistry {
+    add(task) {
+      if (this.has(task.id)) {
+        throw Error(`task ${task.id} already registred!`);
+      }
+      tasks.set(task.id, task);
+      task.on("task:destroyed", () => {
+        this.remove(task);
+      });
+    }
+    get(taskId) {
+      return tasks.get(taskId);
+    }
+    remove(task) {
+      if (this.has(task.id)) {
+        task?.destroy();
+        tasks.delete(task.id);
+      }
+    }
+    all() {
+      return tasks;
+    }
+    has(taskId) {
+      return tasks.has(taskId);
+    }
+    killAll() {
+      tasks.forEach((id) => this.remove(id));
+    }
+  }
+  exports.TaskRegistry = TaskRegistry;
+});
+
+// node_modules/node-cron/dist/esm/pattern/validation/pattern-validation.js
+var require_pattern_validation = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var index_1 = __importDefault(require_convertion());
+  var validationRegex = /^(?:\d+|\*|\*\/\d+)$/;
+  function isValidExpression(expression, min, max) {
+    const options = expression;
+    for (const option of options) {
+      const optionAsInt = parseInt(option, 10);
+      if (!Number.isNaN(optionAsInt) && (optionAsInt < min || optionAsInt > max) || !validationRegex.test(option))
+        return false;
+    }
+    return true;
+  }
+  function isInvalidSecond(expression) {
+    return !isValidExpression(expression, 0, 59);
+  }
+  function isInvalidMinute(expression) {
+    return !isValidExpression(expression, 0, 59);
+  }
+  function isInvalidHour(expression) {
+    return !isValidExpression(expression, 0, 23);
+  }
+  function isInvalidDayOfMonth(expression) {
+    return !isValidExpression(expression, 1, 31);
+  }
+  function isInvalidMonth(expression) {
+    return !isValidExpression(expression, 1, 12);
+  }
+  function isInvalidWeekDay(expression) {
+    return !isValidExpression(expression, 0, 7);
+  }
+  function validateFields(patterns, executablePatterns) {
+    if (isInvalidSecond(executablePatterns[0]))
+      throw new Error(`${patterns[0]} is a invalid expression for second`);
+    if (isInvalidMinute(executablePatterns[1]))
+      throw new Error(`${patterns[1]} is a invalid expression for minute`);
+    if (isInvalidHour(executablePatterns[2]))
+      throw new Error(`${patterns[2]} is a invalid expression for hour`);
+    if (isInvalidDayOfMonth(executablePatterns[3]))
+      throw new Error(`${patterns[3]} is a invalid expression for day of month`);
+    if (isInvalidMonth(executablePatterns[4]))
+      throw new Error(`${patterns[4]} is a invalid expression for month`);
+    if (isInvalidWeekDay(executablePatterns[5]))
+      throw new Error(`${patterns[5]} is a invalid expression for week day`);
+  }
+  function validate(pattern) {
+    if (typeof pattern !== "string")
+      throw new TypeError("pattern must be a string!");
+    const patterns = pattern.split(" ");
+    const executablePatterns = (0, index_1.default)(pattern);
+    if (patterns.length === 5)
+      patterns.unshift("0");
+    validateFields(patterns, executablePatterns);
+  }
+  exports.default = validate;
+});
+
+// node_modules/node-cron/dist/esm/tasks/background-scheduled-task/background-scheduled-task.js
+var require_background_scheduled_task = __commonJS((exports) => {
+  var __dirname = "/home/filipi.oliveira@gdc.local/poc/diario-dip/node_modules/node-cron/dist/esm/tasks/background-scheduled-task";
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var path_1 = __require("path");
+  var child_process_1 = __require("child_process");
+  var create_id_1 = require_create_id();
+  var stream_1 = __require("stream");
+  var state_machine_1 = require_state_machine();
+  var localized_time_1 = require_localized_time();
+  var logger_1 = __importDefault(require_logger());
+  var time_matcher_1 = require_time_matcher();
+  var daemonPath = (0, path_1.resolve)(__dirname, "daemon.js");
+
+  class TaskEmitter extends stream_1.EventEmitter {
+  }
+
+  class BackgroundScheduledTask {
+    emitter;
+    id;
+    name;
+    cronExpression;
+    taskPath;
+    options;
+    forkProcess;
+    stateMachine;
+    constructor(cronExpression, taskPath, options) {
+      this.cronExpression = cronExpression;
+      this.taskPath = taskPath;
+      this.options = options;
+      this.id = (0, create_id_1.createID)("task");
+      this.name = options?.name || this.id;
+      this.emitter = new TaskEmitter;
+      this.stateMachine = new state_machine_1.StateMachine("stopped");
+      this.on("task:stopped", () => {
+        this.forkProcess?.kill();
+        this.forkProcess = undefined;
+        this.stateMachine.changeState("stopped");
+      });
+      this.on("task:destroyed", () => {
+        this.forkProcess?.kill();
+        this.forkProcess = undefined;
+        this.stateMachine.changeState("destroyed");
+      });
+    }
+    getNextRun() {
+      if (this.stateMachine.state !== "stopped") {
+        const timeMatcher = new time_matcher_1.TimeMatcher(this.cronExpression, this.options?.timezone);
+        return timeMatcher.getNextMatch(new Date);
+      }
+      return null;
+    }
+    start() {
+      return new Promise((resolve, reject) => {
+        if (this.forkProcess) {
+          return resolve(undefined);
+        }
+        const timeout = setTimeout(() => {
+          reject(new Error("Start operation timed out"));
+        }, 5000);
+        try {
+          this.forkProcess = (0, child_process_1.fork)(daemonPath);
+          this.forkProcess.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(new Error(`Error on daemon: ${err.message}`));
+          });
+          this.forkProcess.on("exit", (code, signal) => {
+            if (code !== 0 && signal !== "SIGTERM") {
+              const erro = new Error(`node-cron daemon exited with code ${code || signal}`);
+              logger_1.default.error(erro);
+              clearTimeout(timeout);
+              reject(erro);
+            }
+          });
+          this.forkProcess.on("message", (message) => {
+            if (message.jsonError) {
+              if (message.context?.execution) {
+                message.context.execution.error = deserializeError(message.jsonError);
+                delete message.jsonError;
+              }
+            }
+            if (message.context?.task?.state) {
+              this.stateMachine.changeState(message.context?.task?.state);
+            }
+            if (message.context) {
+              const execution = message.context?.execution;
+              delete execution?.hasError;
+              const context = this.createContext(new Date(message.context.date), execution);
+              this.emitter.emit(message.event, context);
+            }
+          });
+          this.once("task:started", () => {
+            this.stateMachine.changeState("idle");
+            clearTimeout(timeout);
+            resolve(undefined);
+          });
+          this.forkProcess.send({
+            command: "task:start",
+            path: this.taskPath,
+            cron: this.cronExpression,
+            options: this.options
+          });
+        } catch (error) {
+          reject(error);
+        }
+      });
+    }
+    stop() {
+      return new Promise((resolve, reject) => {
+        if (!this.forkProcess) {
+          return resolve(undefined);
+        }
+        const timeoutId = setTimeout(() => {
+          clearTimeout(timeoutId);
+          reject(new Error("Stop operation timed out"));
+        }, 5000);
+        const cleanupAndResolve = () => {
+          clearTimeout(timeoutId);
+          this.off("task:stopped", onStopped);
+          this.forkProcess = undefined;
+          resolve(undefined);
+        };
+        const onStopped = () => {
+          cleanupAndResolve();
+        };
+        this.once("task:stopped", onStopped);
+        this.forkProcess.send({
+          command: "task:stop"
+        });
+      });
+    }
+    getStatus() {
+      return this.stateMachine.state;
+    }
+    destroy() {
+      return new Promise((resolve, reject) => {
+        if (!this.forkProcess) {
+          return resolve(undefined);
+        }
+        const timeoutId = setTimeout(() => {
+          clearTimeout(timeoutId);
+          reject(new Error("Destroy operation timed out"));
+        }, 5000);
+        const onDestroy = () => {
+          clearTimeout(timeoutId);
+          this.off("task:destroyed", onDestroy);
+          resolve(undefined);
+        };
+        this.once("task:destroyed", onDestroy);
+        this.forkProcess.send({
+          command: "task:destroy"
+        });
+      });
+    }
+    execute() {
+      return new Promise((resolve, reject) => {
+        if (!this.forkProcess) {
+          return reject(new Error("Cannot execute background task because it hasn't been started yet. Please initialize the task using the start() method before attempting to execute it."));
+        }
+        const timeoutId = setTimeout(() => {
+          cleanupListeners();
+          reject(new Error("Execution timeout exceeded"));
+        }, 5000);
+        const cleanupListeners = () => {
+          clearTimeout(timeoutId);
+          this.off("execution:finished", onFinished);
+          this.off("execution:failed", onFail);
+        };
+        const onFinished = (context) => {
+          cleanupListeners();
+          resolve(context.execution?.result);
+        };
+        const onFail = (context) => {
+          cleanupListeners();
+          reject(context.execution?.error || new Error("Execution failed without specific error"));
+        };
+        this.once("execution:finished", onFinished);
+        this.once("execution:failed", onFail);
+        this.forkProcess.send({
+          command: "task:execute"
+        });
+      });
+    }
+    on(event, fun) {
+      this.emitter.on(event, fun);
+    }
+    off(event, fun) {
+      this.emitter.off(event, fun);
+    }
+    once(event, fun) {
+      this.emitter.once(event, fun);
+    }
+    createContext(executionDate, execution) {
+      const localTime = new localized_time_1.LocalizedTime(executionDate, this.options?.timezone);
+      const ctx = {
+        date: localTime.toDate(),
+        dateLocalIso: localTime.toISO(),
+        triggeredAt: new Date,
+        task: this,
+        execution
+      };
+      return ctx;
+    }
+  }
+  function deserializeError(str) {
+    const data = JSON.parse(str);
+    const Err = globalThis[data.name] || Error;
+    const err = new Err(data.message);
+    if (data.stack) {
+      err.stack = data.stack;
+    }
+    Object.keys(data).forEach((key) => {
+      if (!["name", "message", "stack"].includes(key)) {
+        err[key] = data[key];
+      }
+    });
+    return err;
+  }
+  exports.default = BackgroundScheduledTask;
+});
+
+// node_modules/node-cron/dist/esm/node-cron.js
+var require_node_cron = __commonJS((exports) => {
+  var __filename = "/home/filipi.oliveira@gdc.local/poc/diario-dip/node_modules/node-cron/dist/esm/node-cron.js";
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.nodeCron = exports.getTask = exports.getTasks = undefined;
+  exports.schedule = schedule;
+  exports.createTask = createTask;
+  exports.solvePath = solvePath;
+  exports.validate = validate;
+  var inline_scheduled_task_1 = require_inline_scheduled_task();
+  var task_registry_1 = require_task_registry();
+  var pattern_validation_1 = __importDefault(require_pattern_validation());
+  var background_scheduled_task_1 = __importDefault(require_background_scheduled_task());
+  var path_1 = __importDefault(__require("path"));
+  var url_1 = __require("url");
+  var registry = new task_registry_1.TaskRegistry;
+  function schedule(expression, func, options) {
+    const task = createTask(expression, func, options);
+    task.start();
+    return task;
+  }
+  function createTask(expression, func, options) {
+    let task;
+    if (func instanceof Function) {
+      task = new inline_scheduled_task_1.InlineScheduledTask(expression, func, options);
+    } else {
+      const taskPath = solvePath(func);
+      task = new background_scheduled_task_1.default(expression, taskPath, options);
+    }
+    registry.add(task);
+    return task;
+  }
+  function solvePath(filePath) {
+    if (path_1.default.isAbsolute(filePath))
+      return (0, url_1.pathToFileURL)(filePath).href;
+    if (filePath.startsWith("file://"))
+      return filePath;
+    const stackLines = new Error().stack?.split(`
+`);
+    if (stackLines) {
+      stackLines?.shift();
+      const callerLine = stackLines?.find((line) => {
+        return line.indexOf(__filename) === -1;
+      });
+      const match = callerLine?.match(/(file:\/\/)?(((\/?)(\w:))?([/\\].+)):\d+:\d+/);
+      if (match) {
+        const dir = `${match[5] ?? ""}${path_1.default.dirname(match[6])}`;
+        return (0, url_1.pathToFileURL)(path_1.default.resolve(dir, filePath)).href;
+      }
+    }
+    throw new Error(`Could not locate task file ${filePath}`);
+  }
+  function validate(expression) {
+    try {
+      (0, pattern_validation_1.default)(expression);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  exports.getTasks = registry.all;
+  exports.getTask = registry.get;
+  exports.nodeCron = {
+    schedule,
+    createTask,
+    validate,
+    getTasks: exports.getTasks,
+    getTask: exports.getTask
+  };
+  exports.default = exports.nodeCron;
+});
+
+// index.ts
+var import_reflect_metadata21 = __toESM(require_Reflect(), 1);
+
+// lib/adapters/cache-adapter.ts
+var {redis, RedisClient } = globalThis.Bun;
+
+// lib/injectable.ts
+var import_reflect_metadata = __toESM(require_Reflect(), 1);
+function Injectable() {
+  return function(target, context) {
+    Reflect.defineMetadata("injectable", true, target);
+  };
+}
+
+// lib/adapters/cache-adapter.ts
+class CacheAdapter {
+  client;
+  constructor(config) {
+    this.client = config ? new RedisClient(config.url) : redis;
+  }
+  async set(key, value, options) {
+    assertValidKey(key);
+    const payload = JSON.stringify(value);
+    await this.client.set(key, payload);
+    if (!options || "permanent" in options)
+      return;
+    const ttlSeconds = "ttlSeconds" in options ? options.ttlSeconds : options.ttl;
+    if (ttlSeconds > 0) {
+      await this.client.expire(key, ttlSeconds);
+    }
+  }
+  async get(key) {
+    assertValidKey(key);
+    const raw = await this.client.get(key);
+    if (raw === null)
+      return {};
+    const parsed = safeJsonParse(raw);
+    if (!isRecord(parsed)) {
+      throw new Error(`Cache key "${key}" does not contain a JSON object.`);
+    }
+    return parsed;
+  }
+  async exists(key) {
+    assertValidKey(key);
+    const result = await this.client.exists(key);
+    return typeof result === "boolean" ? result : Boolean(result);
+  }
+  async remove(key) {
+    assertValidKey(key);
+    await this.client.del(key);
+  }
+}
+CacheAdapter = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof CacheAdapterConfig === "undefined" ? Object : CacheAdapterConfig
+  ])
+], CacheAdapter);
+function assertValidKey(key) {
+  const normalized = key.trim();
+  if (normalized.length === 0) {
+    throw new Error("Cache key cannot be empty.");
+  }
+}
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error("Failed to parse cached value as JSON.");
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// lib/constants/index.ts
+var PARAM_METADATA_KEY = Symbol("paramMetadata");
+
+// lib/http-params.ts
+var import_reflect_metadata2 = __toESM(require_Reflect(), 1);
+
+// node_modules/zod/v4/core/core.js
+var NEVER = Object.freeze({
+  status: "aborted"
+});
+function $constructor(name, initializer, params) {
+  function init(inst, def) {
+    if (!inst._zod) {
+      Object.defineProperty(inst, "_zod", {
+        value: {
+          def,
+          constr: _,
+          traits: new Set
+        },
+        enumerable: false
+      });
+    }
+    if (inst._zod.traits.has(name)) {
+      return;
+    }
+    inst._zod.traits.add(name);
+    initializer(inst, def);
+    const proto = _.prototype;
+    const keys = Object.keys(proto);
+    for (let i = 0;i < keys.length; i++) {
+      const k = keys[i];
+      if (!(k in inst)) {
+        inst[k] = proto[k].bind(inst);
+      }
+    }
+  }
+  const Parent = params?.Parent ?? Object;
+
+  class Definition extends Parent {
+  }
+  Object.defineProperty(Definition, "name", { value: name });
+  function _(def) {
+    var _a;
+    const inst = params?.Parent ? new Definition : this;
+    init(inst, def);
+    (_a = inst._zod).deferred ?? (_a.deferred = []);
+    for (const fn of inst._zod.deferred) {
+      fn();
+    }
+    return inst;
+  }
+  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_, "name", { value: name });
+  return _;
+}
+var $brand = Symbol("zod_brand");
+
+// node_modules/zod/v4/core/util.js
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
+}
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+var EVALUATING = Symbol("evaluating");
+var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+var allowsEval = cached(() => {
+  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+    return false;
+  }
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+var propertyKeyTypes = new Set(["string", "number", "symbol"]);
+var primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+var NUMBER_FORMAT_RANGES = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+
+// node_modules/zod/v4/core/errors.js
+var initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  Object.defineProperty(inst, "_zod", {
+    value: inst._zod,
+    enumerable: false
+  });
+  Object.defineProperty(inst, "issues", {
+    value: def,
+    enumerable: false
+  });
+  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
+  Object.defineProperty(inst, "toString", {
+    value: () => inst.message,
+    enumerable: false
+  });
+};
+var $ZodError = $constructor("$ZodError", initializer);
+var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
+function flattenError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = {};
+  const formErrors = [];
+  for (const sub of error.issues) {
+    if (sub.path.length > 0) {
+      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+      fieldErrors[sub.path[0]].push(mapper(sub));
+    } else {
+      formErrors.push(mapper(sub));
+    }
+  }
+  return { formErrors, fieldErrors };
+}
+function formatError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = { _errors: [] };
+  const processError = (error2) => {
+    for (const issue of error2.issues) {
+      if (issue.code === "invalid_union" && issue.errors.length) {
+        issue.errors.map((issues) => processError({ issues }));
+      } else if (issue.code === "invalid_key") {
+        processError({ issues: issue.issues });
+      } else if (issue.code === "invalid_element") {
+        processError({ issues: issue.issues });
+      } else if (issue.path.length === 0) {
+        fieldErrors._errors.push(mapper(issue));
+      } else {
+        let curr = fieldErrors;
+        let i = 0;
+        while (i < issue.path.length) {
+          const el = issue.path[i];
+          const terminal = i === issue.path.length - 1;
+          if (!terminal) {
+            curr[el] = curr[el] || { _errors: [] };
+          } else {
+            curr[el] = curr[el] || { _errors: [] };
+            curr[el]._errors.push(mapper(issue));
+          }
+          curr = curr[el];
+          i++;
+        }
+      }
+    }
+  };
+  processError(error);
+  return fieldErrors;
+}
+
+// node_modules/zod/v4/classic/errors.js
+var initializer2 = (inst, issues) => {
+  $ZodError.init(inst, issues);
+  inst.name = "ZodError";
+  Object.defineProperties(inst, {
+    format: {
+      value: (mapper) => formatError(inst, mapper)
+    },
+    flatten: {
+      value: (mapper) => flattenError(inst, mapper)
+    },
+    addIssue: {
+      value: (issue) => {
+        inst.issues.push(issue);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+    },
+    addIssues: {
+      value: (issues2) => {
+        inst.issues.push(...issues2);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+    },
+    isEmpty: {
+      get() {
+        return inst.issues.length === 0;
+      }
+    }
+  });
+};
+var ZodError = $constructor("ZodError", initializer2);
+var ZodRealError = $constructor("ZodError", initializer2, {
+  Parent: Error
+});
+
+// lib/utils/is-zod-schema.ts
+var isZodSchema = (obj) => {
+  return obj && typeof obj === "object" && typeof obj.parse === "function";
+};
+
+// lib/http-params.ts
+var ParamType;
+((ParamType2) => {
+  ParamType2["BODY"] = "body";
+  ParamType2["QUERY"] = "query";
+  ParamType2["PARAM"] = "param";
+  ParamType2["HEADER"] = "header";
+  ParamType2["REQUEST"] = "request";
+  ParamType2["FORM_DATA"] = "form-data";
+})(ParamType ||= {});
+function setParamMetadata(target, propertyKey, parameterIndex, type, key, options) {
+  const existingParams = Reflect.getOwnMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
+  existingParams.push({ index: parameterIndex, type, key, options });
+  Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, propertyKey);
+}
+function Body() {
+  if (arguments.length === 1) {
+    const arg = arguments[0];
+    if (isZodSchema(arg)) {
+      return function(target, propertyKey, parameterIndex) {
+        setParamMetadata(target, propertyKey, parameterIndex, "body" /* BODY */, undefined, { zodSchema: arg });
+      };
+    }
+  }
+  return function(target, propertyKey, parameterIndex) {
+    setParamMetadata(target, propertyKey, parameterIndex, "body" /* BODY */);
+  };
+}
+function Param() {
+  let key;
+  if (arguments.length === 1) {
+    if (isZodSchema(arguments[0])) {
+      return function(target, propertyKey, parameterIndex) {
+        setParamMetadata(target, propertyKey, parameterIndex, "param" /* PARAM */, undefined, {
+          zodSchema: arguments[0]
+        });
+      };
+    }
+    key = arguments[0];
+  }
+  return function(target, propertyKey, parameterIndex) {
+    setParamMetadata(target, propertyKey, parameterIndex, "param" /* PARAM */, key);
+  };
+}
+function Query() {
+  let key;
+  if (arguments.length === 1) {
+    if (isZodSchema(arguments[0])) {
+      return function(target, propertyKey, parameterIndex) {
+        setParamMetadata(target, propertyKey, parameterIndex, "query" /* QUERY */, undefined, {
+          zodSchema: arguments[0]
+        });
+      };
+    }
+    key = arguments[0];
+  }
+  return function(target, propertyKey, parameterIndex) {
+    setParamMetadata(target, propertyKey, parameterIndex, "query" /* QUERY */, key);
+  };
+}
+function Header(key) {
+  return function(target, propertyKey, parameterIndex) {
+    setParamMetadata(target, propertyKey, parameterIndex, "header" /* HEADER */, key);
+  };
+}
+function Request() {
+  return function(target, propertyKey, parameterIndex) {
+    setParamMetadata(target, propertyKey, parameterIndex, "request" /* REQUEST */);
+  };
+}
+async function processParameters(request, target, propertyKey) {
+  const paramMetadata = Reflect.getOwnMetadata(PARAM_METADATA_KEY, Object.getPrototypeOf(target), propertyKey) || [];
+  const paramTypes = Reflect.getMetadata("design:paramtypes", target, propertyKey) || [];
+  const args = new Array(paramTypes.length);
+  let cachedFormData = null;
+  for (const metadata of paramMetadata) {
+    const { index, type, key } = metadata;
+    switch (type) {
+      case "body" /* BODY */:
+        try {
+          args[index] = request.body;
+        } catch (e) {
+          args[index] = null;
+        }
+        break;
+      case "query" /* QUERY */:
+        if (key) {
+          args[index] = request.query?.[key];
+        } else {
+          args[index] = request.query;
+        }
+        break;
+      case "param" /* PARAM */:
+        if (key === undefined) {
+          args[index] = request.params;
+        } else {
+          args[index] = request.params?.[key];
+        }
+        break;
+      case "header" /* HEADER */:
+        args[index] = request.headers?.[key];
+        break;
+      case "request" /* REQUEST */:
+        args[index] = request;
+        break;
+      case "form-data" /* FORM_DATA */:
+        cachedFormData = cachedFormData || await readFormData(request);
+        args[index] = extractFormDataPayload(cachedFormData, metadata.options);
+        break;
+    }
+    try {
+      if (metadata.options?.zodSchema) {
+        const zodSchema = metadata.options.zodSchema;
+        if (isZodSchema(zodSchema)) {
+          args[index] = zodSchema.parse(args[index]);
+        }
+      }
+    } catch (e) {
+      if (e instanceof ZodError) {
+        badRequest(e.issues.map((issue) => issue.message).join(", "));
+      }
+    }
+  }
+  return args;
+}
+var FORM_DATA_CACHE = Symbol.for("dip:form-data-cache");
+async function readFormData(request) {
+  if (request?.[FORM_DATA_CACHE]) {
+    return request[FORM_DATA_CACHE];
+  }
+  const existingBody = request?.body;
+  const bodyAsFormData = tryResolveFromBody(existingBody);
+  if (bodyAsFormData) {
+    request[FORM_DATA_CACHE] = bodyAsFormData;
+    return bodyAsFormData;
+  }
+  const requestLike = request?.request || request?.raw || request;
+  if (!requestLike || typeof requestLike.formData !== "function") {
+    throw new Error("FormData is not available on this request.");
+  }
+  let formData;
+  try {
+    formData = typeof requestLike.clone === "function" ? await requestLike.clone().formData() : await requestLike.formData();
+  } catch (err) {
+    const fallback = tryResolveFromBody(existingBody);
+    if (fallback) {
+      request[FORM_DATA_CACHE] = fallback;
+      return fallback;
+    }
+    const reason = err instanceof Error ? err.message : "Body already consumed or unreadable";
+    throw new Error(`Could not read multipart form data from the request. ${reason}`);
+  }
+  if (!(formData instanceof FormData)) {
+    throw new Error("Could not read multipart form data from the request.");
+  }
+  request[FORM_DATA_CACHE] = formData;
+  return formData;
+}
+function extractFormDataPayload(formData, options = {}) {
+  const { fileField, allowedTypes, jsonField } = options;
+  const files = [];
+  const allowed = (allowedTypes || []).map((item) => item.toLowerCase());
+  const getFiles = fileField ? formData.getAll(fileField) : Array.from(formData.values());
+  for (const value of getFiles) {
+    if (value instanceof File) {
+      if (allowed.length > 0 && !isAllowedFileType(value, allowed)) {
+        badRequest(`File type for "${value.name}" is not allowed. Allowed: ${allowed.join(", ")}`);
+      }
+      files.push(value);
+    }
+  }
+  let parsedJson;
+  if (jsonField) {
+    const rawJson = formData.get(jsonField);
+    if (typeof rawJson === "string") {
+      try {
+        parsedJson = JSON.parse(rawJson);
+      } catch {
+        badRequest(`Failed to parse JSON field "${jsonField}".`);
+      }
+    } else if (rawJson !== null) {
+      badRequest(`JSON field "${jsonField}" must be a string value.`);
+    }
+  }
+  return {
+    files,
+    json: parsedJson
+  };
+}
+function isAllowedFileType(file, allowedTypes) {
+  const mime = file.type?.toLowerCase?.() || "";
+  const extension = file.name.split(".").pop()?.toLowerCase();
+  if (mime && allowedTypes.includes(mime))
+    return true;
+  if (extension && allowedTypes.includes(extension))
+    return true;
+  return allowedTypes.length === 0;
+}
+function isFormDataLike(value) {
+  return typeof value === "object" && value !== null && typeof value.get === "function" && typeof value.entries === "function";
+}
+function tryResolveFromBody(body) {
+  if (!body)
+    return null;
+  if (isFormDataLike(body))
+    return body;
+  if (typeof body !== "object")
+    return null;
+  const formData = new globalThis.FormData;
+  for (const [key, value] of Object.entries(body)) {
+    if (value === undefined || value === null)
+      continue;
+    if (Array.isArray(value)) {
+      value.forEach((item) => appendValue(formData, key, item));
+      continue;
+    }
+    appendValue(formData, key, value);
+  }
+  return formData;
+}
+function appendValue(formData, key, value) {
+  if (value instanceof File || value instanceof Blob) {
+    formData.append(key, value);
+  } else if (typeof value === "object") {
+    formData.append(key, JSON.stringify(value));
+  } else {
+    formData.append(key, String(value));
+  }
+}
+function badRequest(message) {
+  throw new Response(JSON.stringify({ error: message }), {
+    status: 400,
+    headers: { "content-type": "application/json" }
+  });
+}
+
+// lib/adapters/form-data.ts
+var import_reflect_metadata3 = __toESM(require_Reflect(), 1);
+function FormData2(options = {}) {
+  return function(target, propertyKey, parameterIndex) {
+    const existingParams = (propertyKey === undefined ? Reflect.getOwnMetadata(PARAM_METADATA_KEY, target) : Reflect.getOwnMetadata(PARAM_METADATA_KEY, target, propertyKey)) || [];
+    existingParams.push({
+      index: parameterIndex,
+      type: "form-data" /* FORM_DATA */,
+      options
+    });
+    if (propertyKey === undefined) {
+      Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target);
+    } else {
+      Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, propertyKey);
+    }
+  };
+}
+// lib/adapters/upload-adapter.ts
+var {s3, S3Client } = globalThis.Bun;
+var import_reflect_metadata4 = __toESM(require_Reflect(), 1);
+class UploadAdatper {
+  client;
+  constructor(config) {
+    this.client = config ? new S3Client({
+      endpoint: config.endpoint,
+      bucket: config.bucket,
+      accessKeyId: config.accessKey,
+      secretAccessKey: config.secretKey
+    }) : s3;
+  }
+  async upload(params) {
+    const key = normalizeS3Key(params.path);
+    await this.client.write(key, params.body, {
+      type: params.contentType,
+      acl: params.acl
+    });
+    return toPublicBucketPath(key);
+  }
+  async exists(path) {
+    const key = normalizeS3Key(path);
+    return this.client.exists(key);
+  }
+  async remove(path) {
+    const key = normalizeS3Key(path);
+    await this.client.delete(key);
+  }
+}
+UploadAdatper = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof MinioConfig === "undefined" ? Object : MinioConfig
+  ])
+], UploadAdatper);
+function normalizeS3Key(path) {
+  const normalized = path.replaceAll("\\", "/").replace(/^\/+/, "");
+  if (normalized.length === 0) {
+    throw new Error("S3 object path cannot be empty.");
+  }
+  return normalized.replace(/\/{2,}/g, "/");
+}
+function toPublicBucketPath(key) {
+  return `/${normalizeS3Key(key)}`;
+}
+// lib/app-startup.ts
+import { cors } from "@elysiajs/cors";
+import { html } from "@elysiajs/html";
+import { staticPlugin } from "@elysiajs/static";
+import jwt from "@elysiajs/jwt";
+import { swagger } from "@elysiajs/swagger";
+import Elysia from "elysia";
+import React from "react";
+import { renderToReadableStream } from "react-dom/server";
+
+// lib/components/layout.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+var Layout = ({
+  title,
+  children,
+  data,
+  bundle
+}) => {
+  return /* @__PURE__ */ jsxDEV("html", {
+    lang: "en",
+    children: [
+      /* @__PURE__ */ jsxDEV("head", {
+        children: [
+          /* @__PURE__ */ jsxDEV("meta", {
+            charSet: "UTF-8"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("meta", {
+            name: "viewport",
+            content: "width=device-width, initial-scale=1.0"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("title", {
+            children: title || "Bunstone App"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("meta", {
+            name: "bunstone-version",
+            content: "fix-hydration-v1"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("script", {
+            src: "https://cdn.tailwindcss.com"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("script", {
+            type: "importmap",
+            dangerouslySetInnerHTML: {
+              __html: JSON.stringify({
+                imports: {
+                  react: "https://esm.sh/react@19",
+                  "react-dom": "https://esm.sh/react-dom@19",
+                  "react-dom/client": "https://esm.sh/react-dom@19/client",
+                  "react/jsx-runtime": "https://esm.sh/react@19/jsx-runtime",
+                  "react/jsx-dev-runtime": "https://esm.sh/react@19/jsx-dev-runtime"
+                }
+              })
+            }
+          }, undefined, false, undefined, this),
+          bundle && /* @__PURE__ */ jsxDEV("script", {
+            type: "module",
+            src: `/public/${bundle}`
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV("body", {
+        className: "bg-gray-100 text-gray-900 font-sans",
+        children: [
+          /* @__PURE__ */ jsxDEV("main", {
+            id: "root",
+            className: "container mx-auto p-4",
+            children
+          }, undefined, false, undefined, this),
+          data && /* @__PURE__ */ jsxDEV("script", {
+            id: "__BUNSTONE_DATA__",
+            type: "application/json",
+            dangerouslySetInnerHTML: { __html: JSON.stringify(data) }
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+};
+
+// lib/app-startup.ts
+var import_node_cron = __toESM(require_node_cron(), 1);
+var import_reflect_metadata12 = __toESM(require_Reflect(), 1);
+import {
+  readdirSync,
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  statSync
+} from "fs";
+import { join, basename, extname, resolve } from "path";
+
+// lib/http-exceptions.ts
+class HttpException extends Error {
+  response;
+  status;
+  constructor(response, status) {
+    super(typeof response === "string" ? response : JSON.stringify(response));
+    this.response = response;
+    this.status = status;
+    Object.setPrototypeOf(this, HttpException.prototype);
+  }
+  getResponse() {
+    return this.response;
+  }
+  getStatus() {
+    return this.status;
+  }
+}
+
+class BadRequestException extends HttpException {
+  constructor(response = "Bad Request") {
+    super(response, 400);
+  }
+}
+
+class UnauthorizedException extends HttpException {
+  constructor(response = "Unauthorized") {
+    super(response, 401);
+  }
+}
+
+class ForbiddenException extends HttpException {
+  constructor(response = "Forbidden") {
+    super(response, 403);
+  }
+}
+
+class NotFoundException extends HttpException {
+  constructor(response = "Not Found") {
+    super(response, 404);
+  }
+}
+
+class ConflictException extends HttpException {
+  constructor(response = "Conflict") {
+    super(response, 409);
+  }
+}
+
+class UnprocessableEntityException extends HttpException {
+  constructor(response = "Unprocessable Entity") {
+    super(response, 422);
+  }
+}
+
+class InternalServerErrorException extends HttpException {
+  constructor(response = "Internal Server Error") {
+    super(response, 500);
+  }
+}
+
+class OkResponse extends HttpException {
+  constructor(response = "OK") {
+    super(response, 200);
+  }
+}
+
+class CreatedResponse extends HttpException {
+  constructor(response = "Created") {
+    super(response, 201);
+  }
+}
+
+class NoContentResponse extends HttpException {
+  constructor() {
+    super("", 204);
+  }
+}
+
+// lib/cqrs/decorators/command-handler.decorator.ts
+var import_reflect_metadata5 = __toESM(require_Reflect(), 1);
+var COMMAND_HANDLER_METADATA = "dip:cqrs:command-handler";
+var CommandHandler = (command) => {
+  return (target, context) => {
+    Reflect.defineMetadata(COMMAND_HANDLER_METADATA, command, target);
+  };
+};
+
+// lib/cqrs/command-bus.ts
+class CommandBus {
+  handlers = new Map;
+  register(handlers) {
+    handlers.forEach((handler) => {
+      const command = Reflect.getMetadata(COMMAND_HANDLER_METADATA, handler.constructor);
+      if (command) {
+        this.handlers.set(command, handler);
+      }
+    });
+  }
+  async execute(command) {
+    const commandType = command.constructor;
+    const handler = this.handlers.get(commandType);
+    if (!handler) {
+      throw new Error(`No handler found for command: ${commandType.name}`);
+    }
+    return handler.execute(command);
+  }
+}
+CommandBus = __legacyDecorateClassTS([
+  Injectable()
+], CommandBus);
+
+// lib/cqrs/decorators/query-handler.decorator.ts
+var import_reflect_metadata6 = __toESM(require_Reflect(), 1);
+var QUERY_HANDLER_METADATA = "dip:cqrs:query-handler";
+var QueryHandler = (query) => {
+  return (target, context) => {
+    Reflect.defineMetadata(QUERY_HANDLER_METADATA, query, target);
+  };
+};
+
+// lib/cqrs/query-bus.ts
+class QueryBus {
+  handlers = new Map;
+  register(handlers) {
+    handlers.forEach((handler) => {
+      const query = Reflect.getMetadata(QUERY_HANDLER_METADATA, handler.constructor);
+      if (query) {
+        this.handlers.set(query, handler);
+      }
+    });
+  }
+  async execute(query) {
+    const queryType = query.constructor;
+    const handler = this.handlers.get(queryType);
+    if (!handler) {
+      throw new Error(`No handler found for query: ${queryType.name}`);
+    }
+    return handler.execute(query);
+  }
+}
+QueryBus = __legacyDecorateClassTS([
+  Injectable()
+], QueryBus);
+
+// lib/cqrs/decorators/event-handler.decorator.ts
+var import_reflect_metadata7 = __toESM(require_Reflect(), 1);
+var EVENT_HANDLER_METADATA = "dip:cqrs:event-handler";
+var EventsHandler = (...events) => {
+  return (target, context) => {
+    Reflect.defineMetadata(EVENT_HANDLER_METADATA, events, target);
+  };
+};
+
+// lib/cqrs/event-bus.ts
+class EventStream {
+  source;
+  constructor(source) {
+    this.source = source;
+  }
+  pipe(...operators) {
+    let currentSource = this.source;
+    operators.forEach((operator) => {
+      const prevSource = currentSource;
+      currentSource = (callback) => {
+        prevSource((event) => {
+          operator(event, callback);
+        });
+      };
+    });
+    return new EventStream(currentSource);
+  }
+  subscribe(callback) {
+    this.source(callback);
+  }
+}
+
+class EventBus {
+  handlers = new Map;
+  listeners = [];
+  register(handlers) {
+    handlers.forEach((handler) => {
+      const events = Reflect.getMetadata(EVENT_HANDLER_METADATA, handler.constructor);
+      if (Array.isArray(events)) {
+        events.forEach((event) => {
+          if (!this.handlers.has(event)) {
+            this.handlers.set(event, []);
+          }
+          const handlersForEvent = this.handlers.get(event);
+          if (!handlersForEvent.includes(handler)) {
+            handlersForEvent.push(handler);
+          }
+        });
+      }
+    });
+  }
+  publish(event) {
+    const eventType = event.constructor;
+    const handlers = this.handlers.get(eventType) || [];
+    handlers.forEach((handler) => handler.handle(event));
+    this.listeners.forEach((listener) => listener(event));
+  }
+  get stream() {
+    return new EventStream((callback) => {
+      this.listeners.push(callback);
+    });
+  }
+}
+EventBus = __legacyDecorateClassTS([
+  Injectable()
+], EventBus);
+var ofType = (...types) => {
+  return (event, next) => {
+    if (types.some((type) => event instanceof type)) {
+      next(event);
+    }
+  };
+};
+var map = (fn) => {
+  return (event, next) => {
+    const result = fn(event);
+    if (result) {
+      next(result);
+    }
+  };
+};
+
+// lib/cqrs/decorators/saga.decorator.ts
+var import_reflect_metadata8 = __toESM(require_Reflect(), 1);
+var SAGA_METADATA = "dip:cqrs:saga";
+var Saga = () => {
+  return (target, propertyKey, context) => {
+    if (typeof propertyKey === "object" && propertyKey !== null && "kind" in propertyKey) {
+      return;
+    }
+    const properties = Reflect.getMetadata(SAGA_METADATA, target.constructor) || [];
+    Reflect.defineMetadata(SAGA_METADATA, [...properties, propertyKey], target.constructor);
+  };
+};
+
+// lib/render.ts
+var import_reflect_metadata9 = __toESM(require_Reflect(), 1);
+var RENDER_METADATA = "dip:render:component";
+function Render(component) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(RENDER_METADATA, component, target, propertyKey);
+    return descriptor;
+  };
+}
+
+// lib/openapi.ts
+var import_reflect_metadata10 = __toESM(require_Reflect(), 1);
+var API_TAGS_METADATA = "dip:openapi:tags";
+var API_OPERATION_METADATA = "dip:openapi:operation";
+var API_RESPONSE_METADATA = "dip:openapi:responses";
+var API_HEADERS_METADATA = "dip:openapi:headers";
+function ApiTags(...tags) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey && typeof propertyKey === "object" && "kind" in propertyKey) {
+      const context = propertyKey;
+      if (context.kind === "class") {
+        Reflect.defineMetadata(API_TAGS_METADATA, tags, target);
+      } else if (context.kind === "method") {
+        Reflect.defineMetadata(API_TAGS_METADATA, tags, target);
+      }
+      return;
+    }
+    if (propertyKey) {
+      Reflect.defineMetadata(API_TAGS_METADATA, tags, target, propertyKey);
+    } else {
+      Reflect.defineMetadata(API_TAGS_METADATA, tags, target);
+    }
+  };
+}
+function ApiOperation(options) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey && typeof propertyKey === "object" && "kind" in propertyKey) {
+      Reflect.defineMetadata(API_OPERATION_METADATA, options, target);
+      return;
+    }
+    Reflect.defineMetadata(API_OPERATION_METADATA, options, target, propertyKey);
+  };
+}
+function ApiResponse(options) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey && typeof propertyKey === "object" && "kind" in propertyKey) {
+      const responses2 = Reflect.getMetadata(API_RESPONSE_METADATA, target) || [];
+      responses2.push(options);
+      Reflect.defineMetadata(API_RESPONSE_METADATA, responses2, target);
+      return;
+    }
+    const responses = Reflect.getMetadata(API_RESPONSE_METADATA, target, propertyKey) || [];
+    responses.push(options);
+    Reflect.defineMetadata(API_RESPONSE_METADATA, responses, target, propertyKey);
+  };
+}
+function ApiHeader(options) {
+  return (target, propertyKey, descriptor) => {
+    if (propertyKey && typeof propertyKey === "object" && "kind" in propertyKey) {
+      const context = propertyKey;
+      const headers2 = Reflect.getMetadata(API_HEADERS_METADATA, target) || [];
+      headers2.push(options);
+      Reflect.defineMetadata(API_HEADERS_METADATA, headers2, target);
+      return;
+    }
+    const headers = (propertyKey ? Reflect.getMetadata(API_HEADERS_METADATA, target, propertyKey) : Reflect.getMetadata(API_HEADERS_METADATA, target)) || [];
+    headers.push(options);
+    if (propertyKey) {
+      Reflect.defineMetadata(API_HEADERS_METADATA, headers, target, propertyKey);
+    } else {
+      Reflect.defineMetadata(API_HEADERS_METADATA, headers, target);
+    }
+  };
+}
+function ApiHeaders(headers) {
+  return (target, propertyKey) => {
+    headers.forEach((header) => {
+      ApiHeader(header)(target, propertyKey);
+    });
+  };
+}
+
+// lib/utils/dependency-injection.ts
+var import_reflect_metadata11 = __toESM(require_Reflect(), 1);
+
+class GlobalRegistry {
+  static globalDeps = new Map;
+  static register(type, instance) {
+    this.globalDeps.set(type, instance);
+  }
+  static get(type) {
+    return this.globalDeps.get(type);
+  }
+  static has(type) {
+    return this.globalDeps.has(type);
+  }
+  static getAll() {
+    return this.globalDeps;
+  }
+}
+function resolveDependencies(paramTypes, deps) {
+  return paramTypes.map((paramType) => {
+    return resolveType(paramType, deps);
+  });
+}
+function resolveType(type, deps) {
+  if (!type) {
+    throw new Error("Cannot resolve dependency: type is undefined. This often happens due to circular dependencies or using 'import type' for a class that needs to be injected.");
+  }
+  if (type === Object) {
+    throw new Error("Cannot resolve dependency: type is 'Object'. This usually happens when 'emitDecoratorMetadata' is enabled but the class is imported as a type or there is a circular dependency.");
+  }
+  if (deps.has(type)) {
+    return deps.get(type);
+  }
+  if (GlobalRegistry.has(type)) {
+    return GlobalRegistry.get(type);
+  }
+  if (typeof type === "function" && type.name) {
+    for (const [key, value] of deps.entries()) {
+      if (typeof key === "function" && key.name === type.name) {
+        return value;
+      }
+    }
+    for (const [key, value] of GlobalRegistry.getAll().entries()) {
+      if (typeof key === "function" && key.name === type.name) {
+        return value;
+      }
+    }
+  }
+  const isInjectable = Reflect.getMetadata("injectable", type);
+  if (!isInjectable) {}
+  const paramTypes = Reflect.getMetadata("design:paramtypes", type) || [];
+  const childrenDep = resolveDependencies(paramTypes, deps);
+  const instance = new type(...childrenDep);
+  deps.set(type, instance);
+  return instance;
+}
+
+// lib/utils/colors.ts
+var colors = {
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  blue: "\x1B[34m",
+  purple: "\x1B[35m",
+  reset: "\x1B[0m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m",
+  brightRed: "\x1B[91m",
+  brightGreen: "\x1B[92m",
+  brightYellow: "\x1B[93m",
+  brightBlue: "\x1B[94m",
+  brightMagenta: "\x1B[95m",
+  brightCyan: "\x1B[96m",
+  brightWhite: "\x1B[97m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m",
+  bgWhite: "\x1B[47m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  blink: "\x1B[5m",
+  reverse: "\x1B[7m",
+  hidden: "\x1B[8m",
+  strikethrough: "\x1B[9m"
+};
+
+// lib/utils/logger.ts
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["FATAL"] = 4] = "FATAL";
+})(LogLevel ||= {});
+
+class Logger {
+  name;
+  level;
+  showTimestamp;
+  pretty;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.level = options.level ?? 1 /* INFO */;
+    this.showTimestamp = options.timestamp ?? true;
+    this.pretty = options.pretty ?? true;
+  }
+  getTimestamp() {
+    const now = new Date;
+    return now.toISOString();
+  }
+  formatMessage(level, color, ...args) {
+    if (!this.pretty) {
+      console.log(JSON.stringify({
+        timestamp: this.getTimestamp(),
+        level,
+        name: this.name,
+        message: args.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a)).join(" ")
+      }));
+      return;
+    }
+    let message = "";
+    if (this.showTimestamp) {
+      message += `${colors.gray}${this.getTimestamp()}${colors.reset} `;
+    }
+    message += `${color}[${level}]${colors.reset} `;
+    message += `${colors.cyan}[${this.name}]${colors.reset} `;
+    console.log(message, ...args);
+  }
+  shouldLog(level) {
+    return level >= this.level;
+  }
+  debug(...args) {
+    if (this.shouldLog(0 /* DEBUG */)) {
+      this.formatMessage("DEBUG", colors.blue, ...args);
+    }
+  }
+  info(...args) {
+    if (this.shouldLog(1 /* INFO */)) {
+      this.formatMessage("INFO", colors.green, ...args);
+    }
+  }
+  log(...args) {
+    this.info(...args);
+  }
+  warn(...args) {
+    if (this.shouldLog(2 /* WARN */)) {
+      this.formatMessage("WARN", colors.yellow, ...args);
+    }
+  }
+  error(...args) {
+    if (this.shouldLog(3 /* ERROR */)) {
+      this.formatMessage("ERROR", colors.red, ...args);
+    }
+  }
+  fatal(...args) {
+    if (this.shouldLog(4 /* FATAL */)) {
+      this.formatMessage("FATAL", colors.magenta, ...args);
+    }
+  }
+  child(childName) {
+    return new Logger(`${this.name}:${childName}`, {
+      level: this.level,
+      timestamp: this.showTimestamp,
+      pretty: this.pretty
+    });
+  }
+  setLevel(level) {
+    this.level = level;
+  }
+  group(label, callback) {
+    console.group(`${colors.cyan}${label}${colors.reset}`);
+    callback();
+    console.groupEnd();
+  }
+  async time(label, callback) {
+    const start = performance.now();
+    this.debug(`\u23F1\uFE0F  Starting: ${label}`);
+    try {
+      const result = await callback();
+      const duration = (performance.now() - start).toFixed(2);
+      this.debug(`\u2705 Completed: ${label} (${duration}ms)`);
+      return result;
+    } catch (error) {
+      const duration = (performance.now() - start).toFixed(2);
+      this.error(`\u274C Failed: ${label} (${duration}ms)`, error);
+      throw error;
+    }
+  }
+}
+
+// lib/app-startup.ts
+console.log("APP STARTUP LOADED FROM:", import.meta.url);
+
+class AppStartup {
+  static elysia = new Elysia;
+  static logger = new Logger(AppStartup.name);
+  static registeredSagas = new WeakSet;
+  static viewBundles = new Map;
+  static create(module, options) {
+    this.elysia = new Elysia;
+    if (!existsSync("./public"))
+      mkdirSync("./public", { recursive: true });
+    this.elysia.use(html());
+    this.elysia.use(staticPlugin({
+      assets: "public",
+      prefix: "/public"
+    }));
+    if (options?.viewsDir) {
+      this.autoBundle(options.viewsDir).catch((err) => {
+        this.logger.error(`Failed to auto-bundle views: ${err.message}`);
+      });
+    }
+    this.elysia.error({
+      HttpException
+    });
+    this.elysia.onError(({ code, error, set }) => {
+      if (error instanceof HttpException) {
+        set.status = error.getStatus();
+        return error.getResponse();
+      }
+      return error;
+    });
+    if (options?.cors) {
+      AppStartup.elysia.use(cors(options.cors));
+    }
+    if (options?.swagger) {
+      AppStartup.elysia.use(swagger({
+        path: options.swagger.path || "/swagger",
+        documentation: options.swagger.documentation
+      }));
+    }
+    AppStartup.registerModules(module);
+    return {
+      listen: this.listen,
+      getElysia: () => this.elysia
+    };
+  }
+  static async bundle(entryPath, outputName) {
+    try {
+      const result = await Bun.build({
+        entrypoints: [entryPath],
+        outdir: "./public",
+        naming: outputName,
+        minify: true,
+        external: [
+          "react",
+          "react-dom",
+          "react-dom/client",
+          "react/jsx-runtime",
+          "react/jsx-dev-runtime"
+        ]
+      });
+      if (!result.success) {
+        this.logger.error(`Bundle failed for ${outputName}: ${result.logs.map((l) => l.message).join(`
+`)}`);
+      } else {
+        this.logger.log(`Bundle created successfully: public/${outputName}`);
+      }
+    } catch (error) {
+      this.logger.error(`Error during bundling ${outputName}: ${error.message}`);
+    }
+  }
+  static async autoBundle(viewsDir) {
+    if (!existsSync(viewsDir))
+      return;
+    if (!existsSync("./.bunstone"))
+      mkdirSync("./.bunstone", { recursive: true });
+    const getFilesRecursively = (dir) => {
+      let results = [];
+      const list = readdirSync(dir);
+      for (const file of list) {
+        const fullPath = join(dir, file);
+        const stat = statSync(fullPath);
+        if (stat && stat.isDirectory()) {
+          results = results.concat(getFilesRecursively(fullPath));
+        } else {
+          results.push(resolve(fullPath));
+        }
+      }
+      return results;
+    };
+    const viewsDirAbs = resolve(viewsDir);
+    const files = getFilesRecursively(viewsDirAbs);
+    this.logger.log(`Auto-bundling views from ${viewsDirAbs} (${files.length} views found)`);
+    for (const absolutePath of files) {
+      const file = basename(absolutePath);
+      if (file.endsWith(".tsx") || file.endsWith(".jsx")) {
+        const componentName = basename(file, extname(file));
+        const entryPath = join(process.cwd(), ".bunstone", `${componentName}.client.tsx`);
+        const entryContent = `
+import React from 'react';
+import { hydrateRoot } from 'react-dom/client';
+import * as Mod from '${absolutePath}';
+
+const Component = Mod['${componentName}'] || Mod.default;
+
+const dataElement = document.getElementById("__BUNSTONE_DATA__");
+const data = dataElement ? JSON.parse(dataElement.textContent || "{}") : {};
+
+if (typeof document !== 'undefined' && Component) {
+  const root = document.getElementById("root");
+  if (root) {
+    try {
+      hydrateRoot(root, React.createElement(Component, data));
+      console.log('[Bunstone] Hydration successful for component: ${componentName}');
+    } catch (e) {
+      console.error('[Bunstone] Hydration failed for component: ${componentName}', e);
+    }
+  } else {
+    console.error('[Bunstone] Root element "root" not found for hydration.');
+  }
+} else {
+  console.error('[Bunstone] Component ${componentName} not found in bundle.');
+}
+        `;
+        writeFileSync(entryPath, entryContent);
+        const bundleName = `${componentName.toLowerCase()}.bundle.js`;
+        await this.bundle(entryPath, bundleName);
+        this.viewBundles.set(componentName, bundleName);
+        this.viewBundles.set(componentName.toLowerCase(), bundleName);
+      }
+    }
+  }
+  static listen(port) {
+    AppStartup.logger.log(`App is running at http://localhost:${port}`);
+    AppStartup.elysia.listen(port);
+  }
+  static async executeControllerMethod(context, controller, method) {
+    const args = await processParameters(context, controller, method);
+    const result = await controller[method](...args);
+    const component = Reflect.getMetadata(RENDER_METADATA, controller, method);
+    if (component) {
+      context.set.headers["Content-Type"] = "text/html; charset=utf8";
+      const componentName = component.name || component.displayName;
+      const bundle = result?.bundle || this.viewBundles.get(componentName) || this.viewBundles.get(componentName.toLowerCase());
+      this.logger.log(`Rendering component: ${componentName}, bundle found: ${bundle || "none"}`);
+      if (!bundle) {
+        this.logger.warn(`No client bundle found for component: ${componentName}. useEffect and other hooks will not work on the client.`);
+      }
+      const title = result?.title || "Bunstone App";
+      const stream = await renderToReadableStream(React.createElement(Layout, { title, data: result, bundle }, React.createElement(component, result)));
+      return new Response(stream, {
+        headers: { "Content-Type": "text/html; charset=utf8" }
+      });
+    }
+    if (React.isValidElement(result)) {
+      const stream = await renderToReadableStream(result);
+      return new Response(stream, {
+        headers: { "Content-Type": "text/html; charset=utf8" }
+      });
+    }
+    return result;
+  }
+  static registerModules(module) {
+    const isGlobal = Reflect.getMetadata("dip:module:global", module);
+    if (isGlobal) {
+      const injectables = Reflect.getMetadata("dip:injectables", module);
+      if (injectables) {
+        for (const [key, value] of injectables.entries()) {
+          GlobalRegistry.register(key, value);
+        }
+      }
+    }
+    AppStartup.startWithJWT(module);
+    AppStartup.registerRoutes(module);
+    AppStartup.registerTimeouts(module);
+    AppStartup.registerCronJobs(module);
+    AppStartup.registerCqrsHandlers(module);
+    const modules = Reflect.getMetadata("dip:modules", module) || [];
+    for (const mod of modules) {
+      AppStartup.registerModules(mod);
+    }
+  }
+  static registerRoutes(module) {
+    const controllers = Reflect.getMetadata("dip:module:routes", module);
+    if (!controllers) {
+      return;
+    }
+    const injectables = Reflect.getMetadata("dip:injectables", module);
+    for (const item of controllers.entries()) {
+      const [controllerInstance, methods] = item;
+      const paramsTypes = Reflect.getMetadata("design:paramtypes", controllerInstance) || [];
+      const dependencies = resolveDependencies(paramsTypes, injectables);
+      let controller = new controllerInstance(...dependencies);
+      controller = Object.assign(controller, AppStartup.getControllerHandler(module, controllerInstance));
+      for (const method of methods) {
+        AppStartup.logger.log(`Registering ${method.httpMethod} route: ${method.pathname}`);
+        const httpMethod = method.httpMethod.toLowerCase();
+        if (!(httpMethod in AppStartup.elysia)) {
+          throw new Error(`HTTP method ${method.httpMethod} is not supported.`);
+        }
+        const controllerTags = Reflect.getMetadata(API_TAGS_METADATA, controllerInstance) || [];
+        const methodTags = Reflect.getMetadata(API_TAGS_METADATA, controllerInstance.prototype, method.methodName) || [];
+        const operation = Reflect.getMetadata(API_OPERATION_METADATA, controllerInstance.prototype, method.methodName);
+        const responsesMetadata = Reflect.getMetadata(API_RESPONSE_METADATA, controllerInstance.prototype, method.methodName) || [];
+        const tags = [...new Set([...controllerTags, ...methodTags])];
+        const responses = {};
+        responsesMetadata.forEach((res) => {
+          responses[res.status.toString()] = {
+            description: res.description,
+            content: res.type ? {
+              "application/json": {
+                schema: res.type
+              }
+            } : undefined
+          };
+        });
+        const controllerHeaders = Reflect.getMetadata(API_HEADERS_METADATA, controllerInstance) || [];
+        const methodHeaders = Reflect.getMetadata(API_HEADERS_METADATA, controllerInstance.prototype, method.methodName) || [];
+        const allHeaders = [...controllerHeaders, ...methodHeaders];
+        const parameters = allHeaders.map((h) => ({
+          name: h.name,
+          in: "header",
+          description: h.description,
+          required: h.required,
+          schema: h.schema || { type: "string" }
+        }));
+        const paramsMetadata = Reflect.getMetadata(PARAM_METADATA_KEY, controllerInstance.prototype, method.methodName) || [];
+        const bodySchema = paramsMetadata.find((p) => p.type === "body" /* BODY */)?.options?.zodSchema;
+        const querySchema = paramsMetadata.find((p) => p.type === "query" /* QUERY */)?.options?.zodSchema;
+        const paramsSchema = paramsMetadata.find((p) => p.type === "param" /* PARAM */)?.options?.zodSchema;
+        AppStartup.elysia[httpMethod](method.pathname, (req) => AppStartup.executeControllerMethod(req, controller, method.methodName), {
+          body: bodySchema,
+          query: querySchema,
+          params: paramsSchema,
+          detail: {
+            tags,
+            summary: operation?.summary,
+            description: operation?.description,
+            responses,
+            parameters
+          },
+          beforeHandle(req) {
+            if (!method.guard)
+              return;
+            const guardInstance = new method.guard;
+            const isValid = guardInstance.validate(req);
+            if (isValid instanceof Promise) {
+              return isValid.then((valid) => {
+                if (!valid) {
+                  throw new Error("Unauthorized");
+                }
+              });
+            } else {
+              if (!isValid) {
+                throw new Error("Unauthorized");
+              }
+            }
+          }
+        });
+      }
+    }
+  }
+  static registerTimeouts(module) {
+    const providersTimeouts = Reflect.getMetadata("dip:timeouts", module);
+    if (!providersTimeouts) {
+      return;
+    }
+    for (const item of providersTimeouts.entries()) {
+      const [providerInstance, timeouts] = item;
+      const provider = new providerInstance;
+      for (const timeout of timeouts) {
+        AppStartup.logger.log(`Scheduling timeout for method: ${timeout.methodName} with delay: ${timeout.delay}ms`);
+        setTimeout(() => {
+          provider[timeout.methodName]();
+        }, timeout.delay);
+      }
+    }
+  }
+  static registerCronJobs(module) {
+    const providersCron = Reflect.getMetadata("dip:crons", module);
+    if (!providersCron) {
+      return;
+    }
+    for (const item of providersCron.entries()) {
+      const [providerInstance, crons] = item;
+      const provider = new providerInstance;
+      for (const cron of crons) {
+        AppStartup.logger.log(`Scheduling cron for method: ${cron.methodName}`);
+        import_node_cron.default.schedule(cron.expression, () => {
+          provider[cron.methodName]();
+        });
+      }
+    }
+  }
+  static registerCqrsHandlers(module) {
+    const injectables = Reflect.getMetadata("dip:injectables", module);
+    if (!injectables)
+      return;
+    const commandBus = injectables.get(CommandBus);
+    const queryBus = injectables.get(QueryBus);
+    const eventBus = injectables.get(EventBus);
+    const commandHandlers = [];
+    const queryHandlers = [];
+    const eventHandlers = [];
+    const sagas = [];
+    for (const instance of injectables.values()) {
+      if (Reflect.hasMetadata(COMMAND_HANDLER_METADATA, instance.constructor)) {
+        commandHandlers.push(instance);
+      }
+      if (Reflect.hasMetadata(QUERY_HANDLER_METADATA, instance.constructor)) {
+        queryHandlers.push(instance);
+      }
+      if (Reflect.hasMetadata(EVENT_HANDLER_METADATA, instance.constructor)) {
+        eventHandlers.push(instance);
+      }
+      if (Reflect.hasMetadata(SAGA_METADATA, instance.constructor)) {
+        sagas.push(instance);
+      }
+    }
+    if (commandBus && commandHandlers.length > 0) {
+      commandBus.register(commandHandlers);
+    }
+    if (queryBus && queryHandlers.length > 0) {
+      queryBus.register(queryHandlers);
+    }
+    if (eventBus && eventHandlers.length > 0) {
+      eventBus.register(eventHandlers);
+    }
+    if (eventBus && commandBus && sagas.length > 0) {
+      sagas.forEach((sagaInstance) => {
+        if (AppStartup.registeredSagas.has(sagaInstance)) {
+          return;
+        }
+        AppStartup.registeredSagas.add(sagaInstance);
+        const sagaMethods = Reflect.getMetadata(SAGA_METADATA, sagaInstance.constructor);
+        sagaMethods.forEach((methodName) => {
+          const sagaFn = sagaInstance[methodName];
+          if (typeof sagaFn === "function") {
+            const stream = sagaFn.call(sagaInstance, eventBus.stream);
+            if (stream && typeof stream.subscribe === "function") {
+              stream.subscribe((command) => {
+                if (command) {
+                  commandBus.execute(command).catch((err) => {
+                    AppStartup.logger.error(`Error executing command from Saga ${sagaInstance.constructor.name}.${methodName}:`, err);
+                  });
+                }
+              });
+            }
+          }
+        });
+      });
+    }
+  }
+  static startWithJWT(module) {
+    const modules = Reflect.getMetadata("dip:modules", module) || [];
+    for (const mod of modules) {
+      const hasJWT = Reflect.getMetadata("dip:module:jwt", mod);
+      if (hasJWT) {
+        const jwtOptions = Reflect.getMetadata("dip:module:jwt:options", mod);
+        AppStartup.elysia.use(jwt(jwtOptions));
+      }
+    }
+  }
+  static getControllerHandler(module, controller) {
+    const injectables = Reflect.getMetadata("dip:injectables", module);
+    if (!injectables) {
+      return [];
+    }
+    return injectables.get(controller);
+  }
+}
+// lib/controller.ts
+var import_reflect_metadata13 = __toESM(require_Reflect(), 1);
+function Controller(pathname = "/") {
+  if (!pathname.startsWith("/")) {
+    pathname = `/${pathname}`;
+  }
+  return function(target) {
+    Injectable()(target);
+    const controllerMethods = Object.getOwnPropertyNames(target.prototype).filter((method) => method !== "constructor");
+    const controllerHttpMethods = Symbol.for("dip:controller:http-methods");
+    for (const controllerMethod of controllerMethods) {
+      if (!target[controllerHttpMethods] || target[controllerHttpMethods].length === 0) {
+        target[controllerHttpMethods] = [];
+      }
+      const metadata = Reflect.getMetadata("dip:http-method", target.prototype[controllerMethod]);
+      if (metadata) {
+        const [httpMethod, pathname2] = metadata.split(" ");
+        target[controllerHttpMethods].push({
+          httpMethod,
+          pathname: pathname2,
+          methodName: controllerMethod
+        });
+      }
+    }
+    Reflect.defineMetadata("dip:controller", "is_controller", target);
+    Reflect.defineMetadata("dip:controller:pathname", pathname, target);
+  };
+}
+// lib/module.ts
+var import_reflect_metadata15 = __toESM(require_Reflect(), 1);
+
+// lib/utils/map-providers.ts
+function mapProvidersWithType(providers = [], type) {
+  const result = new Map;
+  for (const provider of providers) {
+    for (const providerSymbol of Object.getOwnPropertySymbols(provider.prototype)) {
+      const methods = provider.prototype[providerSymbol];
+      for (const method of methods) {
+        if (method.type === type) {
+          if (!result.has(provider)) {
+            result.set(provider, []);
+          }
+          result.get(provider)?.push({
+            expression: method.expression,
+            delay: method.delay,
+            methodName: method.methodName
+          });
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// lib/schedule/cron/mappers/map-providers-with-cron.ts
+class MapProvidersWithCron {
+  static execute(providers = []) {
+    return mapProvidersWithType(providers, "cron");
+  }
+}
+
+// lib/schedule/timeout/mappers/map-providers-with-timeouts.ts
+var import_reflect_metadata14 = __toESM(require_Reflect(), 1);
+class MapProvidersWithTimeout {
+  static execute(providers = []) {
+    return mapProvidersWithType(providers, "timeout");
+  }
+}
+
+// lib/module.ts
+function Module(moduleConfig = {}) {
+  moduleConfig.controllers = moduleConfig.controllers || [];
+  moduleConfig.providers = moduleConfig.providers || [];
+  moduleConfig.imports = moduleConfig.imports || [];
+  moduleConfig.exports = moduleConfig.exports || [];
+  const modules = moduleConfig.imports;
+  const controllers = mapControllers(moduleConfig.controllers);
+  const providersTimeouts = MapProvidersWithTimeout.execute(moduleConfig.providers);
+  const providersCrons = MapProvidersWithCron.execute(moduleConfig.providers);
+  const injectableProviders = mapInjectableProviders(moduleConfig);
+  return function(target, context) {
+    Reflect.defineMetadata("dip:module", "is_module", target);
+    Reflect.defineMetadata("dip:module:global", !!moduleConfig.global, target);
+    Reflect.defineMetadata("dip:module:routes", controllers, target);
+    Reflect.defineMetadata("dip:timeouts", providersTimeouts, target);
+    Reflect.defineMetadata("dip:modules", modules, target);
+    Reflect.defineMetadata("dip:crons", providersCrons, target);
+    Reflect.defineMetadata("dip:injectables", injectableProviders, target);
+  };
+}
+function mapControllers(controllers = []) {
+  const controllersMap = new Map;
+  for (const controller of controllers) {
+    controllersMap.set(controller, []);
+    for (const controllerSymbol of Object.getOwnPropertySymbols(controller)) {
+      const controllerPathname = Reflect.getOwnMetadata("dip:controller:pathname", controller);
+      const controllerGuard = Reflect.getMetadata("dip:guard", controller);
+      const controllerMethods = controller[controllerSymbol];
+      controllerMethods.forEach((cm) => {
+        const pathname = `${controllerPathname === "/" ? "" : controllerPathname}${cm.pathname}`;
+        const methodGuard = Reflect.getMetadata("dip:guard", controller.prototype, cm.methodName);
+        controllersMap.get(controller)?.push({
+          httpMethod: cm.httpMethod,
+          pathname,
+          methodName: cm.methodName,
+          guard: methodGuard || controllerGuard
+        });
+      });
+    }
+  }
+  return controllersMap;
+}
+function mapInjectableProviders(moduleConfig) {
+  const deps = new Map;
+  (moduleConfig.imports || []).forEach((mod) => {
+    const importedInjectables = Reflect.getMetadata("dip:injectables", mod);
+    if (importedInjectables instanceof Map) {
+      for (const [key, value] of importedInjectables.entries()) {
+        deps.set(key, value);
+      }
+    }
+  });
+  (moduleConfig.providers || []).forEach((provider) => {
+    resolveType(provider, deps);
+  });
+  return deps;
+}
+
+// lib/cqrs/cqrs-module.ts
+class CqrsModule {
+}
+CqrsModule = __legacyDecorateClassTS([
+  Module({
+    providers: [CommandBus, QueryBus, EventBus],
+    exports: [CommandBus, QueryBus, EventBus],
+    global: true
+  })
+], CqrsModule);
+// lib/database/sql-module.ts
+var {SQL } = globalThis.Bun;
+class SqlService {
+  async query(query, params) {
+    const sql = this.getSqlInstance();
+    return await sql.unsafe(query, params);
+  }
+  async transaction(queries) {
+    const sql = this.getSqlInstance();
+    await sql.begin(async (trx) => {
+      for (const { query, params } of queries) {
+        await trx.unsafe(query, params);
+      }
+    });
+  }
+  async bulkInsert(table, values) {
+    const sql = this.getSqlInstance();
+    await sql`INSERT INTO ${sql(table)} ${sql(values)}`;
+  }
+  getSqlInstance() {
+    const sql = SqlModule.getSqlInstance();
+    if (!sql) {
+      throw new Error("SQL instance not initialized. Call SqlModule.register() first.");
+    }
+    return sql;
+  }
+}
+SqlService = __legacyDecorateClassTS([
+  Injectable()
+], SqlService);
+
+class SqlModule {
+  static sqlInstance;
+  static register(connection) {
+    this.sqlInstance = new SQL({
+      url: typeof connection === "string" ? connection : `${connection.provider}://${connection.username}:${connection.password}@${connection.host}:${connection.port}/${connection.database}`
+    });
+    return this;
+  }
+  static getSqlInstance() {
+    return this.sqlInstance;
+  }
+}
+SqlModule = __legacyDecorateClassTS([
+  Module({
+    providers: [SqlService],
+    global: true
+  })
+], SqlModule);
+// lib/guard.ts
+var import_reflect_metadata16 = __toESM(require_Reflect(), 1);
+
+// lib/utils/is-class.ts
+function isClass(fn) {
+  return typeof fn === "function" && Object.getOwnPropertyDescriptor(fn, "prototype")?.writable === false;
+}
+
+// lib/guard.ts
+function Guard(guard) {
+  return function(target, propertyKey, descriptor) {
+    if (!("validate" in guard.prototype)) {
+      throw new Error(`Guard class must implement 'validate' method.`);
+    }
+    if (propertyKey && typeof propertyKey === "object" && "kind" in propertyKey) {
+      const context = propertyKey;
+      if (context.kind === "class") {
+        Reflect.defineMetadata("dip:guard", guard, target);
+      } else if (context.kind === "method") {
+        Reflect.defineMetadata("dip:guard", guard, target);
+      }
+      return;
+    }
+    if (isClass(target)) {
+      Reflect.defineMetadata("dip:guard", guard, target);
+    }
+    if (propertyKey && descriptor) {
+      Reflect.defineMetadata("dip:guard", guard, target, propertyKey);
+    }
+  };
+}
+// lib/http-methods.ts
+var import_reflect_metadata17 = __toESM(require_Reflect(), 1);
+function HttpMethodDecorator(httpMethod, pathname = "") {
+  if (!pathname.startsWith("/")) {
+    pathname = `/${pathname}`;
+  }
+  return function(target, propertyKey, descriptor) {
+    Reflect.defineMetadata("dip:http-method", `${httpMethod} ${pathname}`, descriptor.value);
+    return descriptor;
+  };
+}
+function Get(pathname = "") {
+  return HttpMethodDecorator("GET", pathname);
+}
+function Post(pathname = "") {
+  return HttpMethodDecorator("POST", pathname);
+}
+function Put(pathname = "") {
+  return HttpMethodDecorator("PUT", pathname);
+}
+function Delete(pathname = "") {
+  return HttpMethodDecorator("DELETE", pathname);
+}
+function Patch(pathname = "") {
+  return HttpMethodDecorator("PATCH", pathname);
+}
+function Options(pathname = "") {
+  return HttpMethodDecorator("OPTIONS", pathname);
+}
+function Head(pathname = "") {
+  return HttpMethodDecorator("HEAD", pathname);
+}
+// lib/jwt.ts
+async function validateTokenFromRequest(req) {
+  if (!req.jwt)
+    throw new Error("JWT middleware is not configured.");
+  if (!req.headers)
+    return false;
+  const [_, token] = req.headers.authorization?.split(" ") ?? [];
+  if (!token) {
+    return false;
+  }
+  const result = await req.jwt.verify(token);
+  return result !== false;
+}
+
+class JwtGuard {
+  async validate(req) {
+    return await validateTokenFromRequest(req);
+  }
+}
+function Jwt() {
+  return function(target, propertyKey, descriptor) {
+    if (propertyKey && typeof propertyKey === "object" && "kind" in propertyKey) {
+      const context = propertyKey;
+      if (context.kind === "class") {
+        Guard(JwtGuard)(target, context);
+      } else if (context.kind === "method") {
+        Guard(JwtGuard)(target, context);
+      }
+      return;
+    }
+    if (isClass(target)) {
+      Guard(JwtGuard)(target);
+      return;
+    }
+    Guard(JwtGuard)(target, propertyKey, descriptor);
+  };
+}
+// lib/jwt/jwt-module.ts
+var import_reflect_metadata18 = __toESM(require_Reflect(), 1);
+
+class JwtModule {
+  static options;
+  static register(options) {
+    this.options = {
+      ...options,
+      alg: options.alg || "HS256",
+      exp: options.exp || "7d"
+    };
+    Reflect.defineMetadata("dip:module:jwt", true, JwtModule);
+    Reflect.defineMetadata("dip:module:jwt:options", this.options, JwtModule);
+    return this;
+  }
+}
+// lib/schedule/cron/cron.ts
+var import_reflect_metadata19 = __toESM(require_Reflect(), 1);
+function Cron(expression) {
+  if (!expression) {
+    throw new Error("Invalid cron expression.");
+  }
+  return function(target, propertyKey, descriptor) {
+    if (typeof propertyKey === "object" && propertyKey !== null && "kind" in propertyKey) {
+      const context = propertyKey;
+      const methodName = context.name;
+      const sym2 = Symbol.for("dip:providers:crons");
+      return;
+    }
+    const sym = Symbol.for("dip:providers:crons");
+    target[sym] = target[sym] || [];
+    target[sym].push({
+      expression,
+      methodName: propertyKey,
+      type: "cron"
+    });
+    Reflect.defineMetadata("dip:cron", "is_cron", target, propertyKey);
+  };
+}
+// lib/schedule/timeout/timeout.ts
+var import_reflect_metadata20 = __toESM(require_Reflect(), 1);
+function Timeout(delay) {
+  if (!delay || delay < 0) {
+    throw new Error("Delay must be a positive number.");
+  }
+  return function(target, propertyKey, descriptor) {
+    if (typeof propertyKey === "object" && propertyKey !== null && "kind" in propertyKey) {
+      return;
+    }
+    const sym = Symbol.for("dip:providers:timeouts");
+    target[sym] = target[sym] || [];
+    target[sym].push({
+      delay,
+      methodName: propertyKey,
+      type: "timeout"
+    });
+    Reflect.defineMetadata("dip:timeout", "is_timeout", target, propertyKey);
+  };
+}
+export {
+  processParameters,
+  ofType,
+  map,
+  UploadAdatper,
+  UnprocessableEntityException,
+  UnauthorizedException,
+  Timeout,
+  SqlService,
+  SqlModule,
+  Saga,
+  SAGA_METADATA,
+  Request,
+  Render,
+  RENDER_METADATA,
+  QueryHandler,
+  QueryBus,
+  Query,
+  QUERY_HANDLER_METADATA,
+  Put,
+  Post,
+  Patch,
+  ParamType,
+  Param,
+  Options,
+  OkResponse,
+  NotFoundException,
+  NoContentResponse,
+  Module,
+  Logger,
+  LogLevel,
+  Layout,
+  JwtModule,
+  Jwt,
+  InternalServerErrorException,
+  Injectable,
+  HttpException,
+  Header,
+  Head,
+  Guard,
+  Get,
+  FormData2 as FormData,
+  ForbiddenException,
+  EventsHandler,
+  EventBus,
+  EVENT_HANDLER_METADATA,
+  Delete,
+  Cron,
+  CreatedResponse,
+  CqrsModule,
+  Controller,
+  ConflictException,
+  CommandHandler,
+  CommandBus,
+  CacheAdapter,
+  COMMAND_HANDLER_METADATA,
+  Body,
+  BadRequestException,
+  AppStartup,
+  ApiTags,
+  ApiResponse,
+  ApiOperation,
+  ApiHeaders,
+  ApiHeader,
+  API_TAGS_METADATA,
+  API_RESPONSE_METADATA,
+  API_OPERATION_METADATA,
+  API_HEADERS_METADATA
+};