@forgedevstack/harbor 1.0.0 → 1.5.0

package/dist/index.es.js

@@ -1,83 +1,34 @@
-var ee = Object.defineProperty;
-var te = (r, e, t) => e in r ? ee(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
-var c = (r, e, t) => te(r, typeof e != "symbol" ? e + "" : e, t);
-import q, { Router as ne } from "express";
-import { createServer as re } from "http";
-import { readFileSync as X, existsSync as I, writeFileSync as se } from "fs";
-import { resolve as R } from "path";
-import { c as A } from "./logger-D7aJSi62.mjs";
-import { s as kt } from "./logger-D7aJSi62.mjs";
-import { validateRequest as F } from "./validation/index.js";
-import { MongoValidator as Ht, createMongoSchema as Nt, createParamValidator as It, validateField as xt, validators as Dt } from "./validation/index.js";
-import { EventEmitter as oe } from "events";
-import { ObjectId as v } from "mongodb";
-import { D as jt, c as Lt } from "./manager-B6vqJgEn.mjs";
-const ie = [
+import F, { Router as D } from "express";
+import { createServer as j } from "http";
+import { readFileSync as V, existsSync as L, writeFileSync as W } from "fs";
+import { resolve as _ } from "path";
+import { c as w } from "./logger-CZn7QxCl.mjs";
+import { s as qe } from "./logger-CZn7QxCl.mjs";
+import { validateRequest as I } from "./validation/index.js";
+import { MongoValidator as tt, createMongoSchema as rt, createParamValidator as st, validateField as ot, validators as nt } from "./validation/index.js";
+import { H as T, a as J } from "./http.const-BKHG1Lsj.mjs";
+import { C as it, c as ct, b as ut } from "./http.const-BKHG1Lsj.mjs";
+import { t as y } from "./index-DIVHd6rO.mjs";
+import { H as lt, M as ht, Q as ft, S as pt, T as mt, e as gt, a as Tt, c as Et, d as St, b as vt, g as $t, m as Ot, r as yt, s as At } from "./index-DIVHd6rO.mjs";
+import { R as Rt, c as Ct, e as _t, d as Pt, h as Lt, b as Ht, l as xt, k as It, n as Mt, m as Nt, r as bt, a as Ft, s as Dt, u as Ut, v as jt } from "./upload-DUjQiuq7.mjs";
+import { WebSocketManager as kt, createWebSocketServer as Gt } from "./websocket/index.js";
+import { Scheduler as zt, createScheduler as Qt } from "./scheduler/index.js";
+import { CacheManager as Wt, MemoryCache as Jt, RedisCache as Yt, cache as Zt, cacheResponse as Xt, cached as qt, createCache as er } from "./cache/index.js";
+import { J as rr, a as sr, c as or, g as nr, h as ar, j as ir, b as cr, r as ur, d as dr, v as lr } from "./password-y4m307oa.mjs";
+import { D as fr, c as pr } from "./manager-CjcKb4P9.mjs";
+const Y = [
   "./harbor.config.json",
   "./config/harbor.config.json",
   "./.harbor/config.json"
-], x = {
+], H = {
   PORT: "HARBOR_PORT",
   HOST: "HARBOR_HOST",
   LOG_LEVEL: "HARBOR_LOG_LEVEL",
   CONFIG_PATH: "HARBOR_CONFIG_PATH"
-}, Xe = {
-  GET: "GET",
-  POST: "POST",
-  PUT: "PUT",
-  PATCH: "PATCH",
-  DELETE: "DELETE",
-  OPTIONS: "OPTIONS",
-  HEAD: "HEAD"
-}, p = {
-  OK: 200,
-  CREATED: 201,
-  NO_CONTENT: 204,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  CONFLICT: 409,
-  UNPROCESSABLE_ENTITY: 422,
-  TOO_MANY_REQUESTS: 429,
-  INTERNAL_SERVER_ERROR: 500,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504
-}, ae = {
-  200: "OK",
-  201: "Created",
-  204: "No Content",
-  400: "Bad Request",
-  401: "Unauthorized",
-  403: "Forbidden",
-  404: "Not Found",
-  405: "Method Not Allowed",
-  409: "Conflict",
-  422: "Unprocessable Entity",
-  429: "Too Many Requests",
-  500: "Internal Server Error",
-  502: "Bad Gateway",
-  503: "Service Unavailable",
-  504: "Gateway Timeout"
-}, Je = {
-  JSON: "application/json",
-  HTML: "text/html",
-  TEXT: "text/plain",
-  FORM: "application/x-www-form-urlencoded",
-  MULTIPART: "multipart/form-data"
-}, Ze = {
-  CONTENT_TYPE: "Content-Type",
-  AUTHORIZATION: "Authorization",
-  ACCEPT: "Accept",
-  CACHE_CONTROL: "Cache-Control",
-  X_REQUEST_ID: "X-Request-ID",
-  X_RESPONSE_TIME: "X-Response-Time"
-}, ce = 3e3, de = "localhost", le = 3e4, ue = "10mb", D = {
+}, Z = 3e3, X = "localhost", q = 3e4, ee = "10mb", x = {
   server: {
-    port: ce,
-    host: de,
+    port: Z,
+    host: X,
     cors: {
       enabled: !0,
       origin: "*",
@@ -87,13 +38,13 @@ const ie = [
     bodyParser: {
       json: !0,
       urlencoded: !0,
-      limit: ue
+      limit: ee
     },
     trustProxy: !1
   },
   routes: {
     prefix: "",
-    timeout: le,
+    timeout: q,
     defaultMiddleware: []
   },
   validation: {
@@ -139,440 +90,260 @@ const ie = [
     format: "text",
     output: "console"
   }
-}, he = 1e4, B = A("config");
-function me(r) {
-  const e = fe(r);
-  if (!e)
-    return B.info("No config file found, using defaults"), V(D);
+}, te = 1e4, M = w("config");
+function re(e) {
+  const t = se(e);
+  if (!t)
+    return M.info("No config file found, using defaults"), N(x);
   try {
-    const t = X(e, "utf-8"), n = JSON.parse(t), s = z(
-      D,
-      n
-    );
-    return B.info("Config loaded", { path: e }), V(s);
-  } catch (t) {
-    return B.error("Failed to load config", t), V(D);
+    const r = V(t, "utf-8"), s = JSON.parse(r), o = U(x, s);
+    return M.info("Config loaded", { path: t }), N(o);
+  } catch (r) {
+    return M.error("Failed to load config", r), N(x);
   }
 }
-function et(r) {
-  return z(
-    D,
-    r
-  );
+function Ie(e) {
+  return U(x, e);
 }
-function fe(r) {
-  if (r) {
-    const t = R(process.cwd(), r);
-    return I(t) ? t : null;
-  }
-  const e = process.env[x.CONFIG_PATH];
+function se(e) {
   if (e) {
-    const t = R(process.cwd(), e);
-    if (I(t))
-      return t;
+    const r = _(process.cwd(), e);
+    return L(r) ? r : null;
   }
-  for (const t of ie) {
-    const n = R(process.cwd(), t);
-    if (I(n))
-      return n;
+  const t = process.env[H.CONFIG_PATH];
+  if (t) {
+    const r = _(process.cwd(), t);
+    if (L(r))
+      return r;
+  }
+  for (const r of Y) {
+    const s = _(process.cwd(), r);
+    if (L(s))
+      return s;
   }
   return null;
 }
-function V(r) {
-  const e = process.env[x.PORT], t = process.env[x.HOST], n = process.env[x.LOG_LEVEL];
-  return e && (r.server.port = parseInt(e, 10)), t && (r.server.host = t), n && (r.logger.level = n), r;
+function N(e) {
+  const t = process.env[H.PORT], r = process.env[H.HOST], s = process.env[H.LOG_LEVEL];
+  return t && (e.server.port = parseInt(t, 10)), r && (e.server.host = r), s && (e.logger.level = s), e;
 }
-function z(r, e) {
-  const t = { ...r };
-  for (const n in e)
-    if (Object.prototype.hasOwnProperty.call(e, n)) {
-      const s = e[n], o = r[n];
-      s !== null && typeof s == "object" && !Array.isArray(s) && o !== null && typeof o == "object" && !Array.isArray(o) ? t[n] = z(
-        o,
-        s
-      ) : s !== void 0 && (t[n] = s);
+function U(e, t) {
+  const r = { ...e };
+  for (const s in t)
+    if (Object.prototype.hasOwnProperty.call(t, s)) {
+      const o = t[s], n = e[s];
+      o !== null && typeof o == "object" && !Array.isArray(o) && n !== null && typeof n == "object" && !Array.isArray(n) ? r[s] = U(
+        n,
+        o
+      ) : o !== void 0 && (r[s] = o);
     }
-  return t;
-}
-const ge = {
-  // Server
-  "server.starting": "Server starting...",
-  "server.started": "Server started on http://{host}:{port}",
-  "server.stopping": "Server stopping...",
-  "server.stopped": "Server stopped",
-  "server.alreadyRunning": "Server is already running",
-  "server.error": "Server error",
-  "server.gracefulShutdown": "Received {signal}, shutting down gracefully",
-  // Router
-  "router.registered": "Registered route: {method} {path}",
-  "router.missingRequired": "Route must have path, method, and handler",
-  // Validation
-  "validation.failed": "Validation failed",
-  "validation.required": "{field} is required",
-  "validation.typeMismatch": "{field} must be of type {type}",
-  "validation.minValue": "{field} must be at least {min}",
-  "validation.maxValue": "{field} must be at most {max}",
-  "validation.minLength": "{field} must be at least {min} characters",
-  "validation.maxLength": "{field} must be at most {max} characters",
-  "validation.pattern": "{field} does not match the required pattern",
-  "validation.enum": "{field} must be one of: {values}",
-  "validation.invalidObjectId": "{field} is not a valid ObjectId",
-  "validation.invalidEmail": "{field} is not a valid email address",
-  "validation.invalidUrl": "{field} is not a valid URL",
-  "validation.invalidDate": "{field} is not a valid date",
-  "validation.customFailed": "{field} failed custom validation",
-  // Errors
-  "errors.badRequest": "Bad Request",
-  "errors.unauthorized": "Unauthorized",
-  "errors.forbidden": "Forbidden",
-  "errors.notFound": "Not Found",
-  "errors.conflict": "Conflict",
-  "errors.tooManyRequests": "Too Many Requests",
-  "errors.internal": "Internal Server Error",
-  "errors.timeout": "Request timeout",
-  "errors.default": "An error occurred",
-  // Config
-  "config.notFound": "No config file found, using defaults",
-  "config.loaded": "Config loaded from {path}",
-  "config.loadFailed": "Failed to load config",
-  // Docker
-  "docker.containerStarted": "Container started: {name}",
-  "docker.containerStopped": "Container stopped: {name}",
-  "docker.containerRestarted": "Container restarted: {name}",
-  "docker.containerRemoved": "Container removed: {name}",
-  "docker.imageBuilt": "Image built: {name}:{tag}",
-  "docker.imagePushed": "Image pushed: {name}",
-  "docker.imagePulled": "Image pulled: {name}:{tag}",
-  "docker.composeUp": "Docker Compose up completed",
-  "docker.composeDown": "Docker Compose down completed",
-  "docker.commandFailed": "Docker command failed: {command}",
-  // Changelog
-  "changelog.loaded": "Changelog loaded with {count} entries",
-  "changelog.saved": "Changelog saved to {path}",
-  "changelog.released": "Released version {version}",
-  "changelog.notFound": "No changelog file found, starting fresh",
-  // Portal
-  "portal.generated": "Portal generated at {path}",
-  "portal.generating": "Generating documentation portal...",
-  // Logger
-  "logger.levelChanged": "Log level changed to {level}",
-  // HTTP Logger (Morgan-like)
-  "http.request": "{method} {url} {status} {duration}ms",
-  "http.requestStart": "Incoming request: {method} {url}",
-  "http.requestEnd": "Request completed: {method} {url} - {status} in {duration}ms",
-  // CLI
-  "cli.init.success": "Harbor project initialized!",
-  "cli.init.configExists": "harbor.config.json already exists",
-  "cli.init.created": "Created {file}",
-  "cli.docs.generating": "Generating API documentation...",
-  "cli.docs.success": "Documentation generated successfully",
-  "cli.version": "Harbor v{version}",
-  "cli.unknownCommand": "Unknown command: {command}",
-  // Database
-  "database.connected": "Connected to MongoDB at {uri}",
-  "database.disconnected": "Disconnected from MongoDB",
-  "database.connecting": "Connecting to MongoDB...",
-  "database.connectionFailed": "Failed to connect to MongoDB: {error}",
-  "database.notConnected": "Not connected to database. Call harbor.connect() first.",
-  "database.modelCreated": "Model created: {name}",
-  "database.documentSaved": "Document saved: {id}",
-  "database.documentDeleted": "Document deleted: {id}",
-  "database.validationFailed": "Validation failed: {errors}",
-  "database.queryExecuted": "Query executed: {operation} on {collection}",
-  "database.indexCreated": "Index created: {name}",
-  "database.transactionStarted": "Transaction started",
-  "database.transactionCommitted": "Transaction committed",
-  "database.transactionAborted": "Transaction aborted"
-}, pe = {
-  // Server
-  "server.starting": "השרת מופעל...",
-  "server.started": "השרת פועל בכתובת http://{host}:{port}",
-  "server.stopping": "השרת נעצר...",
-  "server.stopped": "השרת נעצר",
-  "server.alreadyRunning": "השרת כבר פועל",
-  "server.error": "שגיאת שרת",
-  "server.gracefulShutdown": "התקבל {signal}, מכבה בצורה מסודרת",
-  // Router
-  "router.registered": "נרשם נתיב: {method} {path}",
-  "router.missingRequired": "נתיב חייב לכלול path, method ו-handler",
-  // Validation
-  "validation.failed": "האימות נכשל",
-  "validation.required": "{field} הוא שדה חובה",
-  "validation.typeMismatch": "{field} חייב להיות מסוג {type}",
-  "validation.minValue": "{field} חייב להיות לפחות {min}",
-  "validation.maxValue": "{field} חייב להיות לכל היותר {max}",
-  "validation.minLength": "{field} חייב להכיל לפחות {min} תווים",
-  "validation.maxLength": "{field} חייב להכיל לכל היותר {max} תווים",
-  "validation.pattern": "{field} לא תואם לתבנית הנדרשת",
-  "validation.enum": "{field} חייב להיות אחד מ: {values}",
-  "validation.invalidObjectId": "{field} אינו ObjectId תקין",
-  "validation.invalidEmail": "{field} אינה כתובת אימייל תקינה",
-  "validation.invalidUrl": "{field} אינו URL תקין",
-  "validation.invalidDate": "{field} אינו תאריך תקין",
-  "validation.customFailed": "{field} נכשל באימות מותאם אישית",
-  // Errors
-  "errors.badRequest": "בקשה שגויה",
-  "errors.unauthorized": "לא מורשה",
-  "errors.forbidden": "גישה נדחתה",
-  "errors.notFound": "לא נמצא",
-  "errors.conflict": "התנגשות",
-  "errors.tooManyRequests": "יותר מדי בקשות",
-  "errors.internal": "שגיאת שרת פנימית",
-  "errors.timeout": "הבקשה פגה",
-  "errors.default": "אירעה שגיאה",
-  // Config
-  "config.notFound": "קובץ הגדרות לא נמצא, משתמש בברירת מחדל",
-  "config.loaded": "הגדרות נטענו מ-{path}",
-  "config.loadFailed": "נכשל בטעינת הגדרות",
-  // Docker
-  "docker.containerStarted": "קונטיינר הופעל: {name}",
-  "docker.containerStopped": "קונטיינר נעצר: {name}",
-  "docker.containerRestarted": "קונטיינר הופעל מחדש: {name}",
-  "docker.containerRemoved": "קונטיינר הוסר: {name}",
-  "docker.imageBuilt": "תמונה נבנתה: {name}:{tag}",
-  "docker.imagePushed": "תמונה הועלתה: {name}",
-  "docker.imagePulled": "תמונה הורדה: {name}:{tag}",
-  "docker.composeUp": "Docker Compose הופעל בהצלחה",
-  "docker.composeDown": "Docker Compose נעצר בהצלחה",
-  "docker.commandFailed": "פקודת Docker נכשלה: {command}",
-  // Changelog
-  "changelog.loaded": "יומן שינויים נטען עם {count} רשומות",
-  "changelog.saved": "יומן שינויים נשמר ב-{path}",
-  "changelog.released": "שוחררה גרסה {version}",
-  "changelog.notFound": "קובץ יומן שינויים לא נמצא, מתחיל מחדש",
-  // Portal
-  "portal.generated": "פורטל נוצר ב-{path}",
-  "portal.generating": "מייצר פורטל תיעוד...",
-  // Logger
-  "logger.levelChanged": "רמת הלוג שונתה ל-{level}",
-  // HTTP Logger
-  "http.request": "{method} {url} {status} {duration}ms",
-  "http.requestStart": "בקשה נכנסת: {method} {url}",
-  "http.requestEnd": "בקשה הושלמה: {method} {url} - {status} תוך {duration}ms",
-  // CLI
-  "cli.init.success": "פרויקט Harbor אותחל בהצלחה!",
-  "cli.init.configExists": "harbor.config.json כבר קיים",
-  "cli.init.created": "נוצר {file}",
-  "cli.docs.generating": "מייצר תיעוד API...",
-  "cli.docs.success": "התיעוד נוצר בהצלחה",
-  "cli.version": "Harbor גרסה {version}",
-  "cli.unknownCommand": "פקודה לא מוכרת: {command}",
-  // Database
-  "database.connected": "מחובר ל-MongoDB ב-{uri}",
-  "database.disconnected": "נותק מ-MongoDB",
-  "database.connecting": "מתחבר ל-MongoDB...",
-  "database.connectionFailed": "החיבור ל-MongoDB נכשל: {error}",
-  "database.notConnected": "לא מחובר למסד נתונים. קרא ל-harbor.connect() קודם.",
-  "database.modelCreated": "מודל נוצר: {name}",
-  "database.documentSaved": "מסמך נשמר: {id}",
-  "database.documentDeleted": "מסמך נמחק: {id}",
-  "database.validationFailed": "האימות נכשל: {errors}",
-  "database.queryExecuted": "שאילתה בוצעה: {operation} על {collection}",
-  "database.indexCreated": "אינדקס נוצר: {name}",
-  "database.transactionStarted": "טרנזקציה התחילה",
-  "database.transactionCommitted": "טרנזקציה אושרה",
-  "database.transactionAborted": "טרנזקציה בוטלה"
-}, E = {
-  en: ge,
-  he: pe
-};
-let M = "en";
-function tt(r) {
-  if (!E[r]) {
-    console.warn(`Locale "${r}" not found, falling back to "en"`), M = "en";
-    return;
-  }
-  M = r;
-}
-function nt() {
-  return M;
-}
-function rt() {
-  return Object.keys(E);
-}
-function C(r, e) {
-  let n = (E[M] ?? E.en)[r] ?? E.en[r] ?? r;
-  if (e)
-    for (const [s, o] of Object.entries(e))
-      n = n.replace(new RegExp(`{${s}}`, "g"), String(o ?? ""));
-  return n;
-}
-function st(r, e) {
-  E[r] || (E[r] = {}), Object.assign(E[r], e);
-}
-function ot(r, e) {
-  E[r] = e;
+  return r;
 }
-const _e = A("router");
-function K(r, e) {
-  const t = ne();
-  return r.middleware && r.middleware.forEach((n) => t.use(n)), r.routes && r.routes.forEach((n) => {
-    ye(t, n, e);
-  }), t;
+const z = w("router");
+function B(e, t) {
+  const r = D();
+  return e.middleware && e.middleware.forEach((s) => r.use(s)), e.routes && e.routes.forEach((s) => {
+    oe(r, s, t);
+  }), r;
 }
-function ye(r, e, t) {
-  const n = e.method.toLowerCase(), s = we(e, t);
-  r[n](e.path, ...s), _e.debug(C("router.registered", { method: e.method, path: e.path }));
+function oe(e, t, r) {
+  const s = t.method.toLowerCase(), o = ne(t, r);
+  e[s](t.path, ...o), z.debug(y("router.registered", { method: t.method, path: t.path }));
 }
-function we(r, e) {
-  const t = [], n = r.options ?? {};
-  return n.pre && n.pre.forEach((s) => {
-    t.push(ve(s));
-  }), n.validation && t.push(Ce(n.validation, e)), n.timeout && t.push(Te(n.timeout)), t.push(be(r.handler, n)), t;
+function ne(e, t) {
+  const r = [], s = e.options ?? {};
+  return s.pre && s.pre.forEach((o) => {
+    r.push(Q(o));
+  }), s.validation && r.push(ie(s.validation, t)), s.timeout && r.push(ce(s.timeout)), r.push(ae(e.handler, s)), r;
 }
-function ve(r) {
-  return async (e, t, n) => {
+function Q(e) {
+  return async (t, r, s) => {
     try {
-      await r(e, t, n);
-    } catch (s) {
-      n(s);
+      await e(t, r, s);
+    } catch (o) {
+      s(o);
     }
   };
 }
-function be(r, e) {
-  return async (t, n, s) => {
+function ae(e, t) {
+  return async (r, s, o) => {
     try {
-      const o = await r(t, n);
-      if (e.post && e.post.length > 0)
-        for (const i of e.post)
-          await i(t, n, o);
-      !n.headersSent && o !== void 0 && n.json({
+      const n = await e(r, s);
+      if (t.post && t.post.length > 0)
+        for (const c of t.post)
+          await c(r, s, n);
+      !s.headersSent && n !== void 0 && s.json({
         success: !0,
-        data: o
+        data: n
       });
-    } catch (o) {
-      s(o);
+    } catch (n) {
+      o(n);
     }
   };
 }
-function Ce(r, e) {
-  return async (t, n, s) => {
+function ie(e, t) {
+  return async (r, s, o) => {
     try {
-      const o = {};
-      if (r.params) {
-        const i = await F(r.params, t.params, e.validation);
-        if (!i.valid) {
-          n.status(p.BAD_REQUEST).json({
+      const n = {};
+      if (e.params) {
+        const c = await I(e.params, r.params, t.validation);
+        if (!c.valid) {
+          s.status(T.BAD_REQUEST).json({
             success: !1,
             error: {
-              message: C("validation.failed"),
-              details: i.errors
+              message: y("validation.failed"),
+              details: c.errors
             }
           });
           return;
         }
-        o.params = i.data;
+        n.params = c.data;
       }
-      if (r.query) {
-        const i = await F(r.query, t.query, e.validation);
-        if (!i.valid) {
-          n.status(p.BAD_REQUEST).json({
+      if (e.query) {
+        const c = await I(e.query, r.query, t.validation);
+        if (!c.valid) {
+          s.status(T.BAD_REQUEST).json({
             success: !1,
             error: {
-              message: C("validation.failed"),
-              details: i.errors
+              message: y("validation.failed"),
+              details: c.errors
             }
           });
           return;
         }
-        o.query = i.data;
+        n.query = c.data;
       }
-      if (r.body) {
-        const i = await F(r.body, t.body, e.validation);
-        if (!i.valid) {
-          n.status(p.BAD_REQUEST).json({
+      if (e.body) {
+        const c = await I(e.body, r.body, t.validation);
+        if (!c.valid) {
+          s.status(T.BAD_REQUEST).json({
             success: !1,
             error: {
-              message: C("validation.failed"),
-              details: i.errors
+              message: y("validation.failed"),
+              details: c.errors
             }
           });
           return;
         }
-        o.body = i.data;
+        n.body = c.data;
       }
-      t.validated = o, s();
-    } catch (o) {
-      s(o);
+      r.validated = n, o();
+    } catch (n) {
+      o(n);
     }
   };
 }
-function Te(r) {
-  return (e, t, n) => {
-    const s = setTimeout(() => {
-      t.headersSent || t.status(p.GATEWAY_TIMEOUT).json({
+function ce(e) {
+  return (t, r, s) => {
+    const o = setTimeout(() => {
+      r.headersSent || r.status(T.GATEWAY_TIMEOUT).json({
         success: !1,
         error: {
-          message: C("errors.timeout")
+          message: y("errors.timeout")
         }
       });
-    }, r);
-    t.on("finish", () => clearTimeout(s)), t.on("close", () => clearTimeout(s)), n();
+    }, e);
+    r.on("finish", () => clearTimeout(o)), r.on("close", () => clearTimeout(o)), s();
   };
 }
-function it(r, e, t) {
-  return P("GET", r, e, t);
-}
-function at(r, e, t) {
-  return P("POST", r, e, t);
-}
-function ct(r, e, t) {
-  return P("PUT", r, e, t);
-}
-function dt(r, e, t) {
-  return P("PATCH", r, e, t);
+function Me(e, t, r) {
+  const s = D();
+  r?.middleware && r.middleware.forEach((n) => s.use(n)), t.forEach((n) => {
+    const c = n.path === "/" ? "" : n.path, l = n.method.toLowerCase(), i = ue(n);
+    s[l](c, ...i), z.debug(y("router.registered", { method: n.method, path: `${e}${c}` }));
+  });
+  const o = D();
+  return o.use(e, s), o;
 }
-function lt(r, e, t) {
-  return P("DELETE", r, e, t);
+function ue(e) {
+  const t = [], r = e.options ?? {};
+  return r.pre && r.pre.forEach((s) => {
+    t.push(Q(s));
+  }), t.push(de(e.handler, r)), t;
 }
-function ut(r, e, t, n) {
-  return P(r, e, t, n);
+function de(e, t) {
+  return async (r, s, o) => {
+    try {
+      const n = await e(r, s);
+      if (t.post && t.post.length > 0)
+        for (const c of t.post)
+          await c(r, s, n);
+      !s.headersSent && n !== void 0 && s.json({
+        success: !0,
+        data: n
+      });
+    } catch (n) {
+      o(n);
+    }
+  };
 }
-function P(r, e, t, n) {
+function v(e, t, r, s) {
   return {
-    path: e,
-    method: r,
-    handler: t,
-    options: n ? {
-      pre: n.pre,
-      post: n.post,
-      validation: n.validation,
-      timeout: n.timeout
+    path: t,
+    method: e,
+    handler: r,
+    options: s ? {
+      pre: s.pre,
+      post: s.post,
+      validation: s.validation,
+      timeout: s.timeout
     } : void 0
   };
 }
-class J {
-  constructor() {
-    c(this, "_route", {});
-    c(this, "_options", {});
-  }
+function Ne(e, t, r) {
+  return v("GET", e, t, r);
+}
+function be(e, t, r) {
+  return v("POST", e, t, r);
+}
+function Fe(e, t, r) {
+  return v("PUT", e, t, r);
+}
+function De(e, t, r) {
+  return v("PATCH", e, t, r);
+}
+function Ue(e, t, r) {
+  return v("DELETE", e, t, r);
+}
+const je = {
+  get: (e, t, r) => v("GET", e, t, r),
+  post: (e, t, r) => v("POST", e, t, r),
+  put: (e, t, r) => v("PUT", e, t, r),
+  patch: (e, t, r) => v("PATCH", e, t, r),
+  delete: (e, t, r) => v("DELETE", e, t, r),
+  options: (e, t, r) => v("OPTIONS", e, t, r),
+  head: (e, t, r) => v("HEAD", e, t, r)
+};
+class K {
+  _route = {};
+  _options = {};
   static create() {
-    return new J();
+    return new K();
   }
-  path(e) {
-    return this._route.path = e, this;
+  path(t) {
+    return this._route.path = t, this;
   }
-  method(e) {
-    return this._route.method = e, this;
+  method(t) {
+    return this._route.method = t, this;
   }
-  get(e) {
-    return this.method("GET").path(e);
+  get(t) {
+    return this.method("GET").path(t);
   }
-  post(e) {
-    return this.method("POST").path(e);
+  post(t) {
+    return this.method("POST").path(t);
   }
-  put(e) {
-    return this.method("PUT").path(e);
+  put(t) {
+    return this.method("PUT").path(t);
   }
-  patch(e) {
-    return this.method("PATCH").path(e);
+  patch(t) {
+    return this.method("PATCH").path(t);
   }
-  delete(e) {
-    return this.method("DELETE").path(e);
+  delete(t) {
+    return this.method("DELETE").path(t);
   }
-  handler(e) {
-    if (this._route.handler = e, !this._route.path || !this._route.method || !this._route.handler)
-      throw new Error(C("router.missingRequired"));
+  handler(t) {
+    if (this._route.handler = t, !this._route.path || !this._route.method || !this._route.handler)
+      throw new Error(y("router.missingRequired"));
     return {
       path: this._route.path,
       method: this._route.method,
@@ -580,31 +351,30 @@ class J {
       options: Object.keys(this._options).length > 0 ? this._options : void 0
     };
   }
-  pre(...e) {
-    return this._options.pre = [...this._options.pre ?? [], ...e], this;
+  pre(...t) {
+    return this._options.pre = [...this._options.pre ?? [], ...t], this;
   }
-  postFn(...e) {
-    return this._options.post = [...this._options.post ?? [], ...e], this;
+  postFn(...t) {
+    return this._options.post = [...this._options.post ?? [], ...t], this;
   }
-  validate(e) {
-    return this._options.validation = e, this;
+  validate(t) {
+    return this._options.validation = t, this;
   }
-  timeout(e) {
-    return this._options.timeout = e, this;
+  timeout(t) {
+    return this._options.timeout = t, this;
   }
-  rateLimit(e) {
-    return this._options.rateLimit = e, this;
+  rateLimit(t) {
+    return this._options.rateLimit = t, this;
   }
-  auth(e) {
-    return this._options.auth = e, this;
+  auth(t) {
+    return this._options.auth = t, this;
   }
-  cache(e) {
-    return this._options.cache = e, this;
+  cache(t) {
+    return this._options.cache = t, this;
   }
-  // Legacy .build() still works for backwards compatibility
   build() {
     if (!this._route.path || !this._route.method || !this._route.handler)
-      throw new Error(C("router.missingRequired"));
+      throw new Error(y("router.missingRequired"));
     return {
       path: this._route.path,
       method: this._route.method,
@@ -613,62 +383,61 @@ class J {
     };
   }
 }
-const Oe = A("error");
+const le = w("error");
 class O extends Error {
-  constructor(t, n = p.INTERNAL_SERVER_ERROR, s) {
-    super(t);
-    c(this, "statusCode");
-    c(this, "code");
-    c(this, "details");
-    c(this, "isOperational");
-    this.name = "HarborError", this.statusCode = n, this.code = s == null ? void 0 : s.code, this.details = s == null ? void 0 : s.details, this.isOperational = (s == null ? void 0 : s.isOperational) ?? !0, Error.captureStackTrace(this, this.constructor);
-  }
-  static badRequest(t, n) {
+  statusCode;
+  code;
+  details;
+  isOperational;
+  constructor(t, r = T.INTERNAL_SERVER_ERROR, s) {
+    super(t), this.name = "HarborError", this.statusCode = r, this.code = s?.code, this.details = s?.details, this.isOperational = s?.isOperational ?? !0, Error.captureStackTrace(this, this.constructor);
+  }
+  static badRequest(t, r) {
     return new O(
       t ?? "Bad Request",
-      p.BAD_REQUEST,
-      { code: "BAD_REQUEST", details: n }
+      T.BAD_REQUEST,
+      { code: "BAD_REQUEST", details: r }
     );
   }
   static unauthorized(t) {
     return new O(
       t ?? "Unauthorized",
-      p.UNAUTHORIZED,
+      T.UNAUTHORIZED,
       { code: "UNAUTHORIZED" }
     );
   }
   static forbidden(t) {
     return new O(
       t ?? "Forbidden",
-      p.FORBIDDEN,
+      T.FORBIDDEN,
       { code: "FORBIDDEN" }
     );
   }
   static notFound(t) {
     return new O(
       t ?? "Not Found",
-      p.NOT_FOUND,
+      T.NOT_FOUND,
       { code: "NOT_FOUND" }
     );
   }
-  static conflict(t, n) {
+  static conflict(t, r) {
     return new O(
       t ?? "Conflict",
-      p.CONFLICT,
-      { code: "CONFLICT", details: n }
+      T.CONFLICT,
+      { code: "CONFLICT", details: r }
     );
   }
   static internal(t) {
     return new O(
       t ?? "Internal Server Error",
-      p.INTERNAL_SERVER_ERROR,
+      T.INTERNAL_SERVER_ERROR,
       { code: "INTERNAL_ERROR", isOperational: !1 }
     );
   }
   static tooManyRequests(t) {
     return new O(
       t ?? "Too Many Requests",
-      p.TOO_MANY_REQUESTS,
+      T.TOO_MANY_REQUESTS,
       { code: "RATE_LIMIT_EXCEEDED" }
     );
   }
@@ -684,1103 +453,304 @@ class O extends Error {
     };
   }
 }
-function Ee(r) {
-  const e = r.errors;
-  return (t, n, s, o) => {
-    const i = t.statusCode ?? p.INTERNAL_SERVER_ERROR, a = Se(i, e);
-    if ((a == null ? void 0 : a.log) !== !1 && r.logger.enabled && Oe.error(`${n.method} ${n.path} - ${t.message}`, t), s.headersSent)
+function he(e) {
+  const t = e.errors;
+  return (r, s, o, n) => {
+    const c = r.statusCode ?? T.INTERNAL_SERVER_ERROR, l = fe(c, t);
+    if (l?.log !== !1 && e.logger.enabled && le.error(`${s.method} ${s.path} - ${r.message}`, r), o.headersSent)
       return;
-    if (a != null && a.redirect) {
-      s.redirect(a.redirect);
+    if (l?.redirect) {
+      o.redirect(l.redirect);
       return;
     }
-    const h = Ae(t, i, a);
-    (a == null ? void 0 : a.json) !== !1 ? s.status(i).json(h) : s.status(i).send(h.error.message);
+    const i = pe(r, c, l);
+    l?.json !== !1 ? o.status(c).json(i) : o.status(c).send(i.error.message);
   };
 }
-function Se(r, e) {
-  const t = r.toString();
-  return e[t] ?? e.default;
+function fe(e, t) {
+  const r = e.toString();
+  return t[r] ?? t.default;
 }
-function Ae(r, e, t) {
-  return r instanceof O ? r.toJSON() : {
+function pe(e, t, r) {
+  return e instanceof O ? e.toJSON() : {
     success: !1,
     error: {
-      message: (t == null ? void 0 : t.message) ?? r.message ?? ae[e] ?? "An error occurred",
-      statusCode: e
+      message: r?.message ?? e.message ?? J[t] ?? "An error occurred",
+      statusCode: t
     }
   };
 }
-const S = A("server");
-function ht(r = {}) {
-  const e = me(r.configPath), t = q();
-  let n = null, s = "stopped", o = null;
-  const i = [];
-  Pe(t, e);
-  const a = {
-    app: t,
-    server: n,
-    config: e,
+const A = w("server");
+function Be(e = {}) {
+  const t = re(e.configPath), r = F();
+  let s = null, o = "stopped", n = null;
+  const c = [];
+  me(r, t);
+  const l = {
+    app: r,
+    server: s,
+    config: t,
     async start() {
-      if (s === "running")
-        return S.warn("Server is already running"), a.getInfo();
-      s = "starting";
-      const h = r.port ?? e.server.port, g = r.host ?? e.server.host ?? "localhost";
-      return new Promise((w, b) => {
+      if (o === "running")
+        return A.warn("Server is already running"), l.getInfo();
+      o = "starting";
+      const i = e.port ?? t.server.port, f = e.host ?? t.server.host ?? "localhost";
+      return new Promise((p, g) => {
         try {
-          n = re(t), a.server = n, n.listen(h, g, () => {
-            var l;
-            s = "running", o = /* @__PURE__ */ new Date();
-            const d = a.getInfo();
-            S.info(`Server started on http://${g}:${h}`), (l = r.onReady) == null || l.call(r, d), w(d);
-          }), n.on("error", (d) => {
-            var l;
-            s = "error", S.error("Server error", d), (l = r.onError) == null || l.call(r, d), b(d);
-          }), Re(a);
-        } catch (d) {
-          s = "error", b(d);
+          s = j(r), l.server = s, s.listen(i, f, () => {
+            o = "running", n = /* @__PURE__ */ new Date();
+            const a = l.getInfo();
+            A.info(`Server started on http://${f}:${i}`), e.onReady?.(a), p(a);
+          }), s.on("error", (a) => {
+            o = "error", A.error("Server error", a), e.onError?.(a), g(a);
+          }), k(l);
+        } catch (a) {
+          o = "error", g(a);
         }
       });
     },
     async stop() {
-      if (!(!n || s === "stopped"))
-        return s = "stopping", new Promise((h, g) => {
-          const w = setTimeout(() => {
-            n == null || n.close(), h();
-          }, he);
-          n.close((b) => {
-            clearTimeout(w), b ? (S.error("Error stopping server", b), g(b)) : (s = "stopped", o = null, S.info("Server stopped"), h());
+      if (!(!s || o === "stopped"))
+        return o = "stopping", new Promise((i, f) => {
+          const p = setTimeout(() => {
+            s?.close(), i();
+          }, te);
+          s.close((g) => {
+            clearTimeout(p), g ? (A.error("Error stopping server", g), f(g)) : (o = "stopped", n = null, A.info("Server stopped"), i());
           });
         });
     },
     async restart() {
-      return await a.stop(), a.start();
+      return await l.stop(), l.start();
+    },
+    addRoute(i) {
+      c.push(i);
+      const f = B({ routes: [i] }, t);
+      r.use(f);
+    },
+    addRouteGroup(i) {
+      c.push(...i.routes);
+      const f = B({
+        prefix: i.prefix,
+        routes: i.routes,
+        middleware: i.middleware
+      }, t);
+      r.use(i.prefix, f);
     },
-    addRoute(h) {
-      i.push(h);
-      const g = K({ routes: [h] }, e);
-      t.use(g);
+    addMiddleware(i) {
+      r.use(i);
     },
-    addRouteGroup(h) {
-      i.push(...h.routes);
-      const g = K({
-        prefix: h.prefix,
-        routes: h.routes,
-        middleware: h.middleware
-      }, e);
-      t.use(h.prefix, g);
+    // Convenience methods - works like Express!
+    use(...i) {
+      r.use(...i);
     },
-    addMiddleware(h) {
-      t.use(h);
+    get(i, ...f) {
+      r.get(i, ...f);
+    },
+    post(i, ...f) {
+      r.post(i, ...f);
+    },
+    put(i, ...f) {
+      r.put(i, ...f);
+    },
+    patch(i, ...f) {
+      r.patch(i, ...f);
+    },
+    delete(i, ...f) {
+      r.delete(i, ...f);
+    },
+    listen(i, f) {
+      const p = i ?? e.port ?? t.server.port, g = e.host ?? t.server.host ?? "localhost";
+      s = j(r), l.server = s, s.listen(p, g, () => {
+        o = "running", n = /* @__PURE__ */ new Date(), A.info(`Server started on http://${g}:${p}`), f?.();
+      }), k(l);
     },
     getInfo() {
-      const h = r.port ?? e.server.port, g = r.host ?? e.server.host ?? "localhost";
+      const i = e.port ?? t.server.port, f = e.host ?? t.server.host ?? "localhost";
       return {
-        port: h,
-        host: g,
-        uptime: o ? Date.now() - o.getTime() : 0,
-        startedAt: o,
-        routes: i.map((w) => ({
-          path: w.path,
-          method: w.method,
+        port: i,
+        host: f,
+        uptime: n ? Date.now() - n.getTime() : 0,
+        startedAt: n,
+        routes: c.map((p) => ({
+          path: p.path,
+          method: p.method,
           middleware: []
         })),
-        status: s
+        status: o
       };
     }
   };
-  return r.autoStart !== !1 && a.start().catch((h) => {
-    S.error("Failed to auto-start server", h);
-  }), a;
+  return e.autoStart === !0 && l.start().catch((i) => {
+    A.error("Failed to auto-start server", i);
+  }), l;
 }
-function Pe(r, e) {
-  var n, s, o;
-  (n = e.server.bodyParser) != null && n.json && r.use(q.json({ limit: e.server.bodyParser.limit })), (s = e.server.bodyParser) != null && s.urlencoded && r.use(q.urlencoded({
+function me(e, t) {
+  t.server.bodyParser?.json && e.use(F.json({ limit: t.server.bodyParser.limit })), t.server.bodyParser?.urlencoded && e.use(F.urlencoded({
     extended: !0,
-    limit: e.server.bodyParser.limit
-  })), (o = e.server.cors) != null && o.enabled && r.use($e(e.server.cors)), r.use(ke());
-  const t = Ee(e);
-  r.use(t);
+    limit: t.server.bodyParser.limit
+  })), t.server.cors?.enabled && e.use(ge(t.server.cors)), e.use(Te());
+  const r = he(t);
+  e.use(r);
 }
-function $e(r) {
-  return (e, t, n) => {
-    var o;
-    const s = r.origin;
-    if (s === !0 || s === "*")
-      t.setHeader("Access-Control-Allow-Origin", "*");
-    else if (typeof s == "string")
-      t.setHeader("Access-Control-Allow-Origin", s);
-    else if (Array.isArray(s)) {
-      const i = e.headers.origin;
-      i && s.includes(i) && t.setHeader("Access-Control-Allow-Origin", i);
+function ge(e) {
+  return (t, r, s) => {
+    const o = e.origin;
+    if (o === !0 || o === "*")
+      r.setHeader("Access-Control-Allow-Origin", "*");
+    else if (typeof o == "string")
+      r.setHeader("Access-Control-Allow-Origin", o);
+    else if (Array.isArray(o)) {
+      const n = t.headers.origin;
+      n && o.includes(n) && r.setHeader("Access-Control-Allow-Origin", n);
     }
-    if (t.setHeader(
+    if (r.setHeader(
       "Access-Control-Allow-Methods",
-      ((o = r.methods) == null ? void 0 : o.join(", ")) ?? "GET,POST,PUT,PATCH,DELETE,OPTIONS"
-    ), r.allowedHeaders ? t.setHeader("Access-Control-Allow-Headers", r.allowedHeaders.join(", ")) : t.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization"), r.credentials && t.setHeader("Access-Control-Allow-Credentials", "true"), e.method === "OPTIONS") {
-      t.status(204).end();
+      e.methods?.join(", ") ?? "GET,POST,PUT,PATCH,DELETE,OPTIONS"
+    ), e.allowedHeaders ? r.setHeader("Access-Control-Allow-Headers", e.allowedHeaders.join(", ")) : r.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization"), e.credentials && r.setHeader("Access-Control-Allow-Credentials", "true"), t.method === "OPTIONS") {
+      r.status(204).end();
       return;
     }
-    n();
+    s();
   };
 }
-function ke() {
-  return (r, e, t) => {
-    r.startTime = Date.now(), r.harborContext = {}, e.success = function(n, s = 200) {
-      e.status(s).json({
+function Te() {
+  return (e, t, r) => {
+    e.startTime = Date.now(), e.harborContext = {}, t.success = function(s, o = 200) {
+      t.status(o).json({
         success: !0,
-        data: n
+        data: s
       });
-    }, e.error = function(n, s = 500, o) {
-      e.status(s).json({
+    }, t.error = function(s, o = 500, n) {
+      t.status(o).json({
         success: !1,
         error: {
-          message: n,
-          details: o
+          message: s,
+          details: n
         }
       });
-    }, t();
+    }, r();
   };
 }
-function Re(r) {
-  ["SIGTERM", "SIGINT"].forEach((t) => {
-    process.on(t, async () => {
-      S.info(`Received ${t}, shutting down gracefully`), await r.stop(), process.exit(0);
+function k(e) {
+  ["SIGTERM", "SIGINT"].forEach((r) => {
+    process.on(r, async () => {
+      A.info(`Received ${r}, shutting down gracefully`), await e.stop(), process.exit(0);
     });
   });
 }
-class Z {
-  constructor(e, t) {
-    c(this, "_definition");
-    c(this, "_options");
-    c(this, "_paths", /* @__PURE__ */ new Map());
-    c(this, "_virtuals", /* @__PURE__ */ new Map());
-    c(this, "_methods", /* @__PURE__ */ new Map());
-    c(this, "_statics", /* @__PURE__ */ new Map());
-    c(this, "_preHooks", /* @__PURE__ */ new Map());
-    c(this, "_postHooks", /* @__PURE__ */ new Map());
-    c(this, "_indexes", []);
-    c(this, "_plugins", []);
-    // Public accessors for methods and statics
-    c(this, "methods", {});
-    c(this, "statics", {});
-    c(this, "virtuals", {});
-    if (this._definition = e, this._options = {
-      timestamps: !1,
-      strict: !0,
-      strictQuery: !1,
-      _id: !0,
-      id: !0,
-      versionKey: "__v",
-      autoIndex: !0,
-      autoCreate: !0,
-      minimize: !0,
-      ...t
-    }, this._parseDefinition(e), this._options._id && this._paths.set("_id", { type: "ObjectId", required: !1 }), this._options.timestamps) {
-      const n = typeof this._options.timestamps == "object" ? this._options.timestamps.createdAt === !1 ? null : this._options.timestamps.createdAt || "createdAt" : "createdAt", s = typeof this._options.timestamps == "object" ? this._options.timestamps.updatedAt === !1 ? null : this._options.timestamps.updatedAt || "updatedAt" : "updatedAt";
-      n && this._paths.set(n, { type: "Date", required: !1 }), s && this._paths.set(s, { type: "Date", required: !1 });
-    }
-    if (this._options.versionKey) {
-      const n = typeof this._options.versionKey == "string" ? this._options.versionKey : "__v";
-      this._paths.set(n, { type: "Number", default: 0 });
-    }
-    this.methods = new Proxy({}, {
-      set: (n, s, o) => (this._methods.set(s, o), !0),
-      get: (n, s) => this._methods.get(s)
-    }), this.statics = new Proxy({}, {
-      set: (n, s, o) => (this._statics.set(s, o), !0),
-      get: (n, s) => this._statics.get(s)
-    });
-  }
-  _parseDefinition(e, t = "") {
-    for (const [n, s] of Object.entries(e)) {
-      const o = t ? `${t}.${n}` : n;
-      if (typeof s == "string")
-        this._paths.set(o, { type: s });
-      else if (typeof s == "object" && s !== null) {
-        const i = s;
-        "type" in i ? typeof i.type == "string" ? this._paths.set(o, i) : Array.isArray(i.type) ? this._paths.set(o, { ...i, type: "Array" }) : typeof i.type == "object" && (this._paths.set(o, { type: "Object" }), this._parseDefinition(i.type, o)) : (this._paths.set(o, { type: "Object" }), this._parseDefinition(s, o));
-      }
-    }
-  }
-  // Add additional fields to schema
-  add(e, t) {
-    return this._parseDefinition(e, t), this;
-  }
-  // Get path definition
-  path(e) {
-    return this._paths.get(e);
-  }
-  // Get all paths
-  paths() {
-    return this._paths;
-  }
-  // Define virtual field
-  virtual(e) {
-    return new He(this, e);
-  }
-  // Define instance method
-  method(e, t) {
-    return this._methods.set(e, t), this;
-  }
-  // Define static method
-  static(e, t) {
-    return this._statics.set(e, t), this;
-  }
-  // Pre hook
-  pre(e, t) {
-    const n = Array.isArray(e) ? e : [e];
-    for (const s of n) {
-      const o = this._preHooks.get(s) || [];
-      o.push(t), this._preHooks.set(s, o);
-    }
-    return this;
-  }
-  // Post hook
-  post(e, t) {
-    const n = Array.isArray(e) ? e : [e];
-    for (const s of n) {
-      const o = this._postHooks.get(s) || [];
-      o.push(t), this._postHooks.set(s, o);
-    }
-    return this;
-  }
-  // Define index
-  index(e, t) {
-    return this._indexes.push({ fields: e, options: t }), this;
-  }
-  // Plugin support
-  plugin(e, t) {
-    return this._plugins.push({ fn: e, options: t }), e(this, t), this;
-  }
-  // Load class methods as schema methods
-  loadClass(e) {
-    const t = e.prototype;
-    for (const n of Object.getOwnPropertyNames(t)) {
-      if (n === "constructor") continue;
-      const s = Object.getOwnPropertyDescriptor(t, n);
-      if (s != null && s.get)
-        this._virtuals.set(n, { get: s.get });
-      else if (s != null && s.set) {
-        const o = this._virtuals.get(n) || {};
-        this._virtuals.set(n, { ...o, set: s.set });
-      } else typeof (s == null ? void 0 : s.value) == "function" && this._methods.set(n, s.value);
-    }
-    for (const n of Object.getOwnPropertyNames(e)) {
-      if (["length", "prototype", "name"].includes(n)) continue;
-      const s = e[n];
-      typeof s == "function" && this._statics.set(n, s);
-    }
-    return this;
-  }
-  // Clone schema
-  clone() {
-    const e = new Z({}, this._options);
-    return e._paths = new Map(this._paths), e._virtuals = new Map(this._virtuals), e._methods = new Map(this._methods), e._statics = new Map(this._statics), e._preHooks = new Map(this._preHooks), e._postHooks = new Map(this._postHooks), e._indexes = [...this._indexes], e;
-  }
-  // Getters
-  get options() {
-    return this._options;
-  }
-  get definition() {
-    return this._definition;
-  }
-  getMethods() {
-    return this._methods;
-  }
-  getStatics() {
-    return this._statics;
-  }
-  getVirtuals() {
-    return this._virtuals;
-  }
-  getPreHooks() {
-    return this._preHooks;
-  }
-  getPostHooks() {
-    return this._postHooks;
-  }
-  getIndexes() {
-    return this._indexes;
-  }
-  // Validate document against schema
-  async validate(e) {
-    const t = [];
-    for (const [n, s] of this._paths) {
-      const o = this._getNestedValue(e, n), i = await this._validateField(n, o, s);
-      t.push(...i);
-    }
-    return t.length > 0 ? { valid: !1, errors: t } : { valid: !0 };
-  }
-  _getNestedValue(e, t) {
-    return t.split(".").reduce((n, s) => n == null ? void 0 : n[s], e);
-  }
-  async _validateField(e, t, n) {
-    const s = [];
-    return n.required && t == null ? (s.push({ path: e, message: `${e} is required` }), s) : t == null ? s : this._validateType(t, n.type) ? (n.type === "String" && typeof t == "string" && (n.minLength && t.length < n.minLength && s.push({ path: e, message: `${e} must be at least ${n.minLength} characters` }), n.maxLength && t.length > n.maxLength && s.push({ path: e, message: `${e} must be at most ${n.maxLength} characters` }), n.match && !n.match.test(t) && s.push({ path: e, message: `${e} does not match required pattern` }), n.enum && !n.enum.includes(t) && s.push({ path: e, message: `${e} must be one of: ${n.enum.join(", ")}` })), n.type === "Number" && typeof t == "number" && (n.min !== void 0 && t < n.min && s.push({ path: e, message: `${e} must be at least ${n.min}` }), n.max !== void 0 && t > n.max && s.push({ path: e, message: `${e} must be at most ${n.max}` })), n.validate && (await n.validate.validator(t) || s.push({ path: e, message: n.validate.message || `${e} failed validation` })), s) : (s.push({ path: e, message: `${e} must be of type ${n.type}` }), s);
-  }
-  _validateType(e, t) {
-    switch (t) {
-      case "String":
-        return typeof e == "string";
-      case "Number":
-        return typeof e == "number" && !isNaN(e);
-      case "Boolean":
-        return typeof e == "boolean";
-      case "Date":
-        return e instanceof Date || typeof e == "string" && !isNaN(Date.parse(e));
-      case "ObjectId":
-        return typeof e == "string" && /^[0-9a-fA-F]{24}$/.test(e);
-      case "Array":
-        return Array.isArray(e);
-      case "Object":
-      case "Mixed":
-        return typeof e == "object" && e !== null;
-      case "Buffer":
-        return Buffer.isBuffer(e);
-      default:
-        return !0;
-    }
-  }
-  // Apply transformations (lowercase, uppercase, trim)
-  transformValue(e, t) {
-    const n = this._paths.get(e);
-    if (!n || typeof t != "string") return t;
-    let s = t;
-    return n.lowercase && (s = s.toLowerCase()), n.uppercase && (s = s.toUpperCase()), n.trim && (s = s.trim()), s;
-  }
-  // Get default value for a field
-  getDefault(e) {
-    const t = this._paths.get(e);
-    if (!(!t || t.default === void 0))
-      return typeof t.default == "function" ? t.default() : t.default;
-  }
-}
-class He {
-  constructor(e, t) {
-    c(this, "schema");
-    c(this, "name");
-    this.schema = e, this.name = t;
-  }
-  get(e) {
-    const t = this.schema.getVirtuals(), n = t.get(this.name) || {};
-    return t.set(this.name, { ...n, get: e }), this;
-  }
-  set(e) {
-    const t = this.schema.getVirtuals(), n = t.get(this.name) || {};
-    return t.set(this.name, { ...n, set: e }), this;
-  }
-}
-class Ne extends oe {
-  constructor() {
-    super(...arguments);
-    c(this, "_state", {
-      connected: !1,
-      readyState: 0
-    });
-    c(this, "_options", {});
-    c(this, "_connectionUri", "");
-    c(this, "_mongoClient", null);
-    c(this, "_db", null);
-    c(this, "_models", /* @__PURE__ */ new Map());
-  }
-  get readyState() {
-    return this._state.readyState;
-  }
-  get host() {
-    return this._state.host;
-  }
-  get port() {
-    return this._state.port;
-  }
-  get name() {
-    return this._state.name;
-  }
-  get db() {
-    return this._db;
-  }
-  get client() {
-    return this._mongoClient;
-  }
-  get models() {
-    return this._models;
-  }
-  get uri() {
-    return this._connectionUri;
-  }
-  async connect(t, n) {
-    if (this._state.readyState === 1)
-      return console.warn("[Harbor] Already connected to MongoDB"), this;
-    this._connectionUri = t, this._options = {
-      maxPoolSize: 10,
-      minPoolSize: 1,
-      serverSelectionTimeoutMS: 3e4,
-      socketTimeoutMS: 45e3,
-      retryWrites: !0,
-      w: "majority",
-      ...n
-    }, this._state.readyState = 2, this.emit("connecting");
-    try {
-      const { MongoClient: s } = await import("mongodb");
-      this._mongoClient = new s(t, this._options), await this._mongoClient.connect();
-      const o = new URL(t), i = o.pathname.slice(1) || "test";
-      return this._db = this._mongoClient.db(i), this._state = {
-        connected: !0,
-        readyState: 1,
-        host: o.hostname,
-        port: parseInt(o.port) || 27017,
-        name: i
-      }, this.emit("connected"), this.emit("open"), console.log(`[Harbor] ${C("database.connected", { uri: `${o.hostname}:${o.port}/${i}` })}`), this;
-    } catch (s) {
-      throw this._state.readyState = 0, this.emit("error", s), s;
-    }
-  }
-  async disconnect() {
-    if (this._state.readyState === 0) {
-      console.warn("[Harbor] Already disconnected from MongoDB");
-      return;
-    }
-    this._state.readyState = 3, this.emit("disconnecting");
-    try {
-      this._mongoClient && await this._mongoClient.close(), this._state = {
-        connected: !1,
-        readyState: 0
-      }, this._mongoClient = null, this._db = null, this.emit("disconnected"), this.emit("close"), console.log(`[Harbor] ${C("database.disconnected")}`);
-    } catch (t) {
-      throw this.emit("error", t), t;
-    }
-  }
-  async close() {
-    return this.disconnect();
-  }
-  async ping() {
-    if (!this._db)
-      return !1;
-    try {
-      return await this._db.command({ ping: 1 }), !0;
-    } catch {
-      return !1;
-    }
-  }
-  collection(t) {
-    if (!this._db)
-      throw new Error("[Harbor] Not connected to database");
-    return this._db.collection(t);
-  }
-  async createCollection(t, n) {
-    if (!this._db)
-      throw new Error("[Harbor] Not connected to database");
-    return this._db.createCollection(t, n);
-  }
-  async dropCollection(t) {
-    if (!this._db)
-      throw new Error("[Harbor] Not connected to database");
-    return this._db.dropCollection(t);
-  }
-  async listCollections() {
-    if (!this._db)
-      throw new Error("[Harbor] Not connected to database");
-    return (await this._db.listCollections().toArray()).map((n) => n.name);
-  }
-  async dropDatabase() {
-    if (!this._db)
-      throw new Error("[Harbor] Not connected to database");
-    return this._db.dropDatabase();
-  }
-  // Transaction support
-  async startSession() {
-    if (!this._mongoClient)
-      throw new Error("[Harbor] Not connected to database");
-    return this._mongoClient.startSession();
-  }
-  async withTransaction(t, n) {
-    const s = await this.startSession();
-    try {
-      let o;
-      return await s.withTransaction(async () => {
-        o = await t(s);
-      }, n), o;
-    } finally {
-      await s.endSession();
-    }
-  }
-  // Event handlers with proper typing
-  on(t, n) {
-    return super.on(t, n);
-  }
-  once(t, n) {
-    return super.once(t, n);
-  }
-}
-const j = new Ne();
-async function mt(r, e) {
-  return j.connect(r, e);
-}
-async function ft() {
-  return j.disconnect();
-}
-var Y;
-Y = Symbol.toStringTag;
-class H {
-  constructor(e, t, n, s) {
-    c(this, "_model");
-    c(this, "_operation");
-    c(this, "_filter", {});
-    c(this, "_projection", null);
-    c(this, "_options", {});
-    c(this, "_update", null);
-    c(this, "_currentPath", null);
-    c(this, Y, "Query");
-    this._model = e, this._operation = t, this._filter = n || {}, this._update = s || null;
-  }
-  select(e) {
-    if (typeof e == "string") {
-      this._projection = {};
-      for (const t of e.split(" "))
-        t.startsWith("-") ? this._projection[t.slice(1)] = 0 : t && (this._projection[t] = 1);
-    } else
-      this._projection = e;
-    return this;
-  }
-  sort(e) {
-    if (typeof e == "string") {
-      const t = {};
-      for (const n of e.split(" "))
-        n.startsWith("-") ? t[n.slice(1)] = -1 : n && (t[n] = 1);
-      this._options.sort = t;
-    } else
-      this._options.sort = e;
-    return this;
-  }
-  limit(e) {
-    return this._options.limit = e, this;
-  }
-  skip(e) {
-    return this._options.skip = e, this;
-  }
-  lean() {
-    return this._options.lean = !0, this;
-  }
-  populate(e) {
-    return this._options.populate = e, this;
-  }
-  where(e, t) {
-    return this._currentPath = e, t !== void 0 && (this._filter[e] = t), this;
-  }
-  equals(e) {
-    return this._currentPath && (this._filter[this._currentPath] = e), this;
-  }
-  gt(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $gt: e }), this;
-  }
-  gte(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $gte: e }), this;
-  }
-  lt(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $lt: e }), this;
-  }
-  lte(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { ...this._filter[this._currentPath], $lte: e }), this;
-  }
-  in(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { $in: e }), this;
-  }
-  nin(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { $nin: e }), this;
-  }
-  ne(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { $ne: e }), this;
-  }
-  regex(e) {
-    return this._currentPath && (this._filter[this._currentPath] = { $regex: e }), this;
-  }
-  exists(e = !0) {
-    return this._currentPath && (this._filter[this._currentPath] = { $exists: e }), this;
-  }
-  or(e) {
-    return this._filter.$or = e, this;
-  }
-  and(e) {
-    return this._filter.$and = e, this;
-  }
-  nor(e) {
-    return this._filter.$nor = e, this;
-  }
-  async exec() {
-    const e = this._model.getCollection();
-    switch (this._operation) {
-      case "find": {
-        let t = e.find(this._filter, { projection: this._projection });
-        this._options.sort && (t = t.sort(this._options.sort)), this._options.skip && (t = t.skip(this._options.skip)), this._options.limit && (t = t.limit(this._options.limit));
-        const n = await t.toArray();
-        return this._options.lean ? n : n.map((s) => this._model.hydrate(s));
-      }
-      case "findOne": {
-        const t = await e.findOne(this._filter, { projection: this._projection });
-        return t ? this._options.lean ? t : this._model.hydrate(t) : null;
-      }
-      case "findOneAndUpdate": {
-        const t = await e.findOneAndUpdate(
-          this._filter,
-          this._update,
-          {
-            returnDocument: this._options.new ? "after" : "before",
-            upsert: this._options.upsert,
-            projection: this._projection
-          }
-        );
-        return t ? this._options.lean ? t : this._model.hydrate(t) : null;
-      }
-      case "findOneAndDelete": {
-        const t = await e.findOneAndDelete(this._filter, {
-          projection: this._projection
-        });
-        return t ? this._options.lean ? t : this._model.hydrate(t) : null;
-      }
-      default:
-        throw new Error(`Unknown operation: ${this._operation}`);
-    }
-  }
-  then(e, t) {
-    return this.exec().then(e, t);
-  }
-  catch(e) {
-    return this.exec().catch(e);
-  }
-  finally(e) {
-    return this.exec().finally(e);
-  }
-}
-class Q {
-  constructor(e, t) {
-    c(this, "_id");
-    c(this, "__v");
-    c(this, "isNew", !0);
-    c(this, "_model");
-    c(this, "_modified", /* @__PURE__ */ new Set());
-    /** Snapshot of document at load time for change tracking */
-    c(this, "_original", {});
-    var s;
-    if (this._model = e, this._id = ((s = t == null ? void 0 : t._id) == null ? void 0 : s.toString()) || new v().toString(), t) {
-      for (const [o, i] of Object.entries(t))
-        o === "_id" ? this._id = (i == null ? void 0 : i.toString()) || this._id : this[o] = i;
-      this._original = { ...t }, this.isNew = !1;
-    }
-    const n = e.schema;
-    for (const [o] of n.paths())
-      if (this[o] === void 0) {
-        const i = n.getDefault(o);
-        i !== void 0 && (this[o] = i);
-      }
-    for (const [o, i] of n.getVirtuals())
-      Object.defineProperty(this, o, {
-        get: i.get,
-        set: i.set,
-        enumerable: !0
-      });
-    for (const [o, i] of n.getMethods())
-      this[o] = i.bind(this);
-  }
-  /** Snapshot of document at load for change tracking */
-  get original() {
-    return this._original;
-  }
-  get id() {
-    return this._id;
-  }
-  isModified(e) {
-    return e ? this._modified.has(e) : this._modified.size > 0;
-  }
-  markModified(e) {
-    this._modified.add(e);
-  }
-  async save() {
-    var i;
-    const e = this._model.schema;
-    await this._model.runPreHooks("save", this);
-    const t = await e.validate(this.toObject());
-    if (!t.valid) {
-      const a = new Error(`Validation failed: ${(i = t.errors) == null ? void 0 : i.map((h) => h.message).join(", ")}`);
-      throw a.errors = t.errors, a;
-    }
-    const n = /* @__PURE__ */ new Date();
-    if (e.options.timestamps) {
-      const a = typeof e.options.timestamps == "object" && e.options.timestamps.createdAt || "createdAt", h = typeof e.options.timestamps == "object" && e.options.timestamps.updatedAt || "updatedAt";
-      this.isNew && a && (this[a] = n), this[h] = n;
-    }
-    const s = this._model.getCollection(), o = this.toObject();
-    if (this.isNew)
-      await s.insertOne({ _id: new v(this._id), ...o }), this.isNew = !1;
-    else {
-      if (e.options.versionKey) {
-        const a = typeof e.options.versionKey == "string" ? e.options.versionKey : "__v";
-        this[a] = (this[a] || 0) + 1;
-      }
-      await s.replaceOne({ _id: new v(this._id) }, o);
-    }
-    return this._original = { ...o }, this._modified.clear(), await this._model.runPostHooks("save", this), this;
-  }
-  async remove() {
-    return await this._model.runPreHooks("remove", this), await this._model.getCollection().deleteOne({ _id: new v(this._id) }), await this._model.runPostHooks("remove", this), this;
-  }
-  async deleteOne() {
-    await this._model.runPreHooks("deleteOne", this);
-    const t = await this._model.getCollection().deleteOne({ _id: new v(this._id) });
-    return await this._model.runPostHooks("deleteOne", this), {
-      acknowledged: t.acknowledged,
-      deletedCount: t.deletedCount
-    };
-  }
-  async updateOne(e) {
-    await this._model.runPreHooks("updateOne", this);
-    const n = await this._model.getCollection().updateOne({ _id: new v(this._id) }, e);
-    return await this._model.runPostHooks("updateOne", this), {
-      acknowledged: n.acknowledged,
-      modifiedCount: n.modifiedCount,
-      matchedCount: n.matchedCount
-    };
-  }
-  async populate(e) {
-    return this;
-  }
-  toObject() {
-    const e = { _id: this._id }, t = this._model.schema;
-    for (const [n] of t.paths())
-      n !== "_id" && this[n] !== void 0 && (e[n] = this[n]);
-    return e;
-  }
-  toJSON() {
-    return this.toObject();
-  }
-}
-const U = class U {
-  constructor(e, t, n) {
-    c(this, "_name");
-    c(this, "_schema");
-    c(this, "_collectionName");
-    this._name = e, this._schema = t, this._collectionName = n || e.toLowerCase() + "s";
-    for (const [s, o] of t.getStatics())
-      this[s] = o.bind(this);
-    U.models.set(e, this);
-  }
-  get modelName() {
-    return this._name;
-  }
-  get schema() {
-    return this._schema;
-  }
-  get collection() {
-    return { name: this._collectionName };
-  }
-  getCollection() {
-    if (!j.db)
-      throw new Error("[Harbor] Not connected to database. Call harbor.connect() first.");
-    return j.db.collection(this._collectionName);
-  }
-  // Create a new document instance
-  new(e) {
-    return new Q(this, e);
-  }
-  // Hydrate a plain object into a document
-  hydrate(e) {
-    const t = new Q(this, e);
-    return t.isNew = !1, t;
-  }
-  // Query methods
-  find(e, t, n) {
-    const s = new H(this, "find", e);
-    return t && s.select(t), n != null && n.sort && s.sort(n.sort), n != null && n.limit && s.limit(n.limit), n != null && n.skip && s.skip(n.skip), n != null && n.lean && s.lean(), s;
-  }
-  findOne(e, t, n) {
-    const s = new H(this, "findOne", e);
-    return t && s.select(t), n != null && n.lean && s.lean(), s;
-  }
-  findById(e, t, n) {
-    return this.findOne({ _id: new v(e) }, t, n);
-  }
-  // Create methods
-  async create(e) {
-    if (Array.isArray(e)) {
-      const n = [];
-      for (const s of e) {
-        const o = this.new(s);
-        await o.save(), n.push(o);
-      }
-      return n;
-    }
-    const t = this.new(e);
-    return await t.save(), t;
-  }
-  async insertMany(e, t) {
-    const n = this.getCollection(), s = e.map((i) => ({ _id: new v(), ...i })), o = await n.insertMany(s, { ordered: (t == null ? void 0 : t.ordered) ?? !0 });
-    return {
-      insertedCount: o.insertedCount,
-      insertedIds: Object.values(o.insertedIds).map((i) => i.toString())
-    };
-  }
-  // Update methods
-  async updateOne(e, t, n) {
-    var a;
-    await this.runPreHooks("updateOne", null);
-    const s = this.getCollection(), o = t.$set || t.$unset || t.$inc ? t : { $set: t }, i = await s.updateOne(e, o, { upsert: n == null ? void 0 : n.upsert });
-    return await this.runPostHooks("updateOne", null), {
-      acknowledged: i.acknowledged,
-      modifiedCount: i.modifiedCount,
-      matchedCount: i.matchedCount,
-      upsertedCount: i.upsertedCount,
-      upsertedId: (a = i.upsertedId) == null ? void 0 : a.toString()
-    };
-  }
-  async updateMany(e, t, n) {
-    await this.runPreHooks("updateMany", null);
-    const s = this.getCollection(), o = t.$set || t.$unset || t.$inc ? t : { $set: t }, i = await s.updateMany(e, o, { upsert: n == null ? void 0 : n.upsert });
-    return await this.runPostHooks("updateMany", null), {
-      acknowledged: i.acknowledged,
-      modifiedCount: i.modifiedCount,
-      matchedCount: i.matchedCount
-    };
-  }
-  findOneAndUpdate(e, t, n) {
-    const s = new H(this, "findOneAndUpdate", e, t);
-    return n != null && n.new && (s._options.new = !0), n != null && n.upsert && (s._options.upsert = !0), n != null && n.lean && s.lean(), s;
-  }
-  findByIdAndUpdate(e, t, n) {
-    return this.findOneAndUpdate({ _id: new v(e) }, t, n);
-  }
-  async replaceOne(e, t, n) {
-    const o = await this.getCollection().replaceOne(e, t, { upsert: n == null ? void 0 : n.upsert });
-    return {
-      acknowledged: o.acknowledged,
-      modifiedCount: o.modifiedCount,
-      matchedCount: o.matchedCount
-    };
-  }
-  // Delete methods
-  async deleteOne(e) {
-    await this.runPreHooks("deleteOne", null);
-    const n = await this.getCollection().deleteOne(e);
-    return await this.runPostHooks("deleteOne", null), {
-      acknowledged: n.acknowledged,
-      deletedCount: n.deletedCount
-    };
-  }
-  async deleteMany(e) {
-    await this.runPreHooks("deleteMany", null);
-    const n = await this.getCollection().deleteMany(e);
-    return await this.runPostHooks("deleteMany", null), {
-      acknowledged: n.acknowledged,
-      deletedCount: n.deletedCount
-    };
-  }
-  findOneAndDelete(e, t) {
-    const n = new H(this, "findOneAndDelete", e);
-    return t != null && t.lean && n.lean(), n;
-  }
-  findByIdAndDelete(e, t) {
-    return this.findOneAndDelete({ _id: new v(e) }, t);
-  }
-  // Count methods
-  async countDocuments(e) {
-    return this.getCollection().countDocuments(e || {});
-  }
-  async estimatedDocumentCount() {
-    return this.getCollection().estimatedDocumentCount();
-  }
-  // Aggregate
-  async aggregate(e, t) {
-    return this.getCollection().aggregate(e, t).toArray();
-  }
-  // Distinct
-  async distinct(e, t) {
-    return this.getCollection().distinct(e, t || {});
-  }
-  // Exists
-  async exists(e) {
-    const t = await this.findOne(e).select({ _id: 1 }).lean();
-    return t ? { _id: t._id.toString() } : null;
-  }
-  // Bulk operations
-  async bulkWrite(e) {
-    const n = await this.getCollection().bulkWrite(e);
-    return {
-      ok: n.ok,
-      insertedCount: n.insertedCount,
-      matchedCount: n.matchedCount,
-      modifiedCount: n.modifiedCount,
-      deletedCount: n.deletedCount,
-      upsertedCount: n.upsertedCount,
-      insertedIds: n.insertedIds || {},
-      upsertedIds: n.upsertedIds || {}
-    };
-  }
-  // Index methods
-  async createIndex(e, t) {
-    return this.getCollection().createIndex(e, t);
-  }
-  async createIndexes(e) {
-    const t = this.getCollection(), n = e.map((s) => ({ key: s.fields, ...s.options }));
-    return t.createIndexes(n);
-  }
-  async listIndexes() {
-    return this.getCollection().listIndexes().toArray();
-  }
-  async dropIndex(e) {
-    await this.getCollection().dropIndex(e);
-  }
-  // Populate
-  async populate(e, t) {
-    return e;
-  }
-  // Watch (change streams)
-  watch(e, t) {
-    return this.getCollection().watch(e, t);
-  }
-  // Hook execution
-  async runPreHooks(e, t) {
-    const n = this._schema.getPreHooks().get(e) || [];
-    for (const s of n)
-      await new Promise((o, i) => {
-        try {
-          const a = s.call(t, o);
-          a instanceof Promise && a.then(o).catch(i);
-        } catch (a) {
-          i(a);
-        }
-      });
-  }
-  async runPostHooks(e, t) {
-    const n = this._schema.getPostHooks().get(e) || [];
-    for (const s of n)
-      await new Promise((o, i) => {
-        try {
-          const a = s.call(t, o);
-          a instanceof Promise && a.then(o).catch(i);
-        } catch (a) {
-          i(a);
-        }
-      });
-  }
-};
-c(U, "models", /* @__PURE__ */ new Map());
-let L = U;
-function gt(r, e, t) {
-  const n = L.models.get(r);
-  return n || new L(r, e, t);
-}
-const pt = {
-  ObjectId: v
-}, k = A("changelog"), Ie = {
+const C = w("changelog"), Ee = {
   filePath: "./CHANGELOG.md",
   format: "markdown",
   includeUnreleased: !0
 };
-function xe(r = {}) {
-  const e = { ...Ie, ...r }, t = [];
-  let n = [];
-  function s() {
-    const d = R(process.cwd(), e.filePath);
-    if (!I(d)) {
-      k.info("No changelog file found, starting fresh");
+function Se(e = {}) {
+  const t = { ...Ee, ...e }, r = [];
+  let s = [];
+  function o() {
+    const a = _(process.cwd(), t.filePath);
+    if (!L(a)) {
+      C.info("No changelog file found, starting fresh");
       return;
     }
     try {
-      const l = X(d, "utf-8");
-      o(l), k.info("Changelog loaded", { entries: t.length });
-    } catch (l) {
-      k.error("Failed to load changelog", l);
+      const u = V(a, "utf-8");
+      n(u), C.info("Changelog loaded", { entries: r.length });
+    } catch (u) {
+      C.error("Failed to load changelog", u);
     }
   }
-  function o(d) {
-    const l = /## \[(\d+\.\d+\.\d+(?:-[\w.]+)?)\](?: - (\d{4}-\d{2}-\d{2}))?/g, u = d.split(l);
-    for (let f = 1; f < u.length; f += 3) {
-      const m = u[f], T = u[f + 1], y = u[f + 2];
-      if (m && y) {
-        const $ = {
+  function n(a) {
+    const u = /## \[(\d+\.\d+\.\d+(?:-[\w.]+)?)\](?: - (\d{4}-\d{2}-\d{2}))?/g, h = a.split(u);
+    for (let d = 1; d < h.length; d += 3) {
+      const m = h[d], $ = h[d + 1], S = h[d + 2];
+      if (m && S) {
+        const R = {
           version: m,
-          date: T ? new Date(T) : /* @__PURE__ */ new Date(),
-          changes: i(y)
+          date: $ ? new Date($) : /* @__PURE__ */ new Date(),
+          changes: c(S)
         };
-        t.push($);
+        r.push(R);
       }
     }
   }
-  function i(d) {
-    const l = [], u = d.split(`
+  function c(a) {
+    const u = [], h = a.split(`
 `);
-    let f = null;
-    for (const m of u) {
-      const T = m.match(/^### (Added|Changed|Deprecated|Removed|Fixed|Security)/i);
-      if (T) {
-        f = T[1].toLowerCase();
+    let d = null;
+    for (const m of h) {
+      const $ = m.match(/^### (Added|Changed|Deprecated|Removed|Fixed|Security)/i);
+      if ($) {
+        d = $[1].toLowerCase();
         continue;
       }
-      const y = m.match(/^- (.+)/);
-      y && f && l.push({
-        type: f,
-        description: y[1].trim()
+      const S = m.match(/^- (.+)/);
+      S && d && u.push({
+        type: d,
+        description: S[1].trim()
       });
     }
-    return l;
+    return u;
   }
-  function a() {
-    const d = R(process.cwd(), e.filePath), l = h();
-    se(d, l, "utf-8"), k.info("Changelog saved", { path: d });
+  function l() {
+    const a = _(process.cwd(), t.filePath), u = i();
+    W(a, u, "utf-8"), C.info("Changelog saved", { path: a });
   }
-  function h() {
-    let d = `# Changelog
+  function i() {
+    let a = `# Changelog
 
 `;
-    d += `All notable changes to this project will be documented in this file.
+    a += `All notable changes to this project will be documented in this file.
 
-`, d += `The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-`, d += `and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+`, a += `The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+`, a += `and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-`, e.includeUnreleased && n.length > 0 && (d += `## [Unreleased]
+`, t.includeUnreleased && s.length > 0 && (a += `## [Unreleased]
 
-`, d += g(n), d += `
+`, a += f(s), a += `
 `);
-    for (const l of t) {
-      const u = l.date.toISOString().split("T")[0];
-      if (d += `## [${l.version}] - ${u}
+    for (const u of r) {
+      const h = u.date.toISOString().split("T")[0];
+      if (a += `## [${u.version}] - ${h}
 
-`, d += g(l.changes), l.breaking && l.breaking.length > 0) {
-        d += `### BREAKING CHANGES
+`, a += f(u.changes), u.breaking && u.breaking.length > 0) {
+        a += `### BREAKING CHANGES
 
 `;
-        for (const f of l.breaking)
-          d += `- ${f.description}
+        for (const d of u.breaking)
+          a += `- ${d.description}
 `;
-        d += `
+        a += `
 `;
       }
-      d += `
+      a += `
 `;
     }
-    return d;
-  }
-  function g(d) {
-    const l = w(d);
-    let u = "";
-    const f = ["added", "changed", "deprecated", "removed", "fixed", "security"];
-    for (const m of f) {
-      const T = l[m];
-      if (T && T.length > 0) {
-        u += `### ${b(m)}
+    return a;
+  }
+  function f(a) {
+    const u = p(a);
+    let h = "";
+    const d = ["added", "changed", "deprecated", "removed", "fixed", "security"];
+    for (const m of d) {
+      const $ = u[m];
+      if ($ && $.length > 0) {
+        h += `### ${g(m)}
 
 `;
-        for (const y of T) {
-          let $ = `- ${y.description}`;
-          y.scope && ($ = `- **${y.scope}:** ${y.description}`), y.issue && ($ += ` (#${y.issue})`), u += $ + `
+        for (const S of $) {
+          let R = `- ${S.description}`;
+          S.scope && (R = `- **${S.scope}:** ${S.description}`), S.issue && (R += ` (#${S.issue})`), h += R + `
 `;
         }
-        u += `
+        h += `
 `;
       }
     }
-    return u;
+    return h;
   }
-  function w(d) {
-    const l = {
+  function p(a) {
+    const u = {
       added: [],
       changed: [],
       deprecated: [],
@@ -1788,145 +758,126 @@ function xe(r = {}) {
       fixed: [],
       security: []
     };
-    for (const u of d)
-      l[u.type].push(u);
-    return l;
+    for (const h of a)
+      u[h.type].push(h);
+    return u;
   }
-  function b(d) {
-    return d.charAt(0).toUpperCase() + d.slice(1);
+  function g(a) {
+    return a.charAt(0).toUpperCase() + a.slice(1);
   }
   return {
-    load: s,
-    save: a,
-    addChange(d, l, u) {
-      n.push({
-        type: d,
-        description: l,
-        scope: u == null ? void 0 : u.scope,
-        issue: u == null ? void 0 : u.issue
+    load: o,
+    save: l,
+    addChange(a, u, h) {
+      s.push({
+        type: a,
+        description: u,
+        scope: h?.scope,
+        issue: h?.issue
       });
     },
-    release(d) {
-      const l = {
-        version: d,
+    release(a) {
+      const u = {
+        version: a,
         date: /* @__PURE__ */ new Date(),
-        changes: [...n]
+        changes: [...s]
       };
-      return t.unshift(l), n = [], a(), k.info(`Released version ${d}`), l;
+      return r.unshift(u), s = [], l(), C.info(`Released version ${a}`), u;
     },
     getEntries() {
-      return [...t];
+      return [...r];
     },
     getUnreleased() {
-      return [...n];
+      return [...s];
     },
     getLatestVersion() {
-      var d;
-      return ((d = t[0]) == null ? void 0 : d.version) ?? null;
+      return r[0]?.version ?? null;
     },
-    getReleaseNotes(d) {
-      var f;
-      const l = t.find((m) => m.version === d);
-      if (!l) return null;
-      const u = w(l.changes);
+    getReleaseNotes(a) {
+      const u = r.find((d) => d.version === a);
+      if (!u) return null;
+      const h = p(u.changes);
       return {
-        version: l.version,
-        date: l.date,
-        added: u.added.map((m) => m.description),
-        changed: u.changed.map((m) => m.description),
-        deprecated: u.deprecated.map((m) => m.description),
-        removed: u.removed.map((m) => m.description),
-        fixed: u.fixed.map((m) => m.description),
-        security: u.security.map((m) => m.description),
-        breaking: ((f = l.breaking) == null ? void 0 : f.map((m) => m.description)) ?? []
+        version: u.version,
+        date: u.date,
+        added: h.added.map((d) => d.description),
+        changed: h.changed.map((d) => d.description),
+        deprecated: h.deprecated.map((d) => d.description),
+        removed: h.removed.map((d) => d.description),
+        fixed: h.fixed.map((d) => d.description),
+        security: h.security.map((d) => d.description),
+        breaking: u.breaking?.map((d) => d.description) ?? []
       };
     }
   };
 }
-class _t {
-  constructor(e) {
-    c(this, "manager");
-    c(this, "load", () => this.manager.load());
-    c(this, "save", () => this.manager.save());
-    c(this, "addChange", (...e) => this.manager.addChange(...e));
-    c(this, "release", (e) => this.manager.release(e));
-    c(this, "getEntries", () => this.manager.getEntries());
-    c(this, "getUnreleased", () => this.manager.getUnreleased());
-    c(this, "getLatestVersion", () => this.manager.getLatestVersion());
-    c(this, "getReleaseNotes", (e) => this.manager.getReleaseNotes(e));
-    this.manager = xe(e);
-  }
-}
-class De {
-  constructor(e = {}) {
-    this.options = e;
-  }
-  get config() {
-    return this.options;
-  }
-  generate() {
-    console.log("[Harbor] Portal generation is coming soon.");
-  }
-}
-function yt(r) {
-  return new De(r);
+class ke {
+  manager;
+  constructor(t) {
+    this.manager = Se(t);
+  }
+  load = () => this.manager.load();
+  save = () => this.manager.save();
+  addChange = (...t) => this.manager.addChange(...t);
+  release = (t) => this.manager.release(t);
+  getEntries = () => this.manager.getEntries();
+  getUnreleased = () => this.manager.getUnreleased();
+  getLatestVersion = () => this.manager.getLatestVersion();
+  getReleaseNotes = (t) => this.manager.getReleaseNotes(t);
 }
-function wt() {
-  console.log("[Harbor] API documentation generation is coming soon.");
+function G(e) {
+  return typeof e == "object" && e !== null && !Array.isArray(e);
 }
-function W(r) {
-  return typeof r == "object" && r !== null && !Array.isArray(r);
-}
-function Me(r, e) {
-  const t = { ...r };
-  for (const n in e)
-    if (Object.prototype.hasOwnProperty.call(e, n)) {
-      const s = e[n], o = r[n];
-      W(s) && W(o) ? t[n] = Me(
-        o,
-        s
-      ) : s !== void 0 && (t[n] = s);
+function ve(e, t) {
+  const r = { ...e };
+  for (const s in t)
+    if (Object.prototype.hasOwnProperty.call(t, s)) {
+      const o = t[s], n = e[s];
+      G(o) && G(n) ? r[s] = ve(
+        n,
+        o
+      ) : o !== void 0 && (r[s] = o);
     }
-  return t;
+  return r;
 }
-function vt(r, e) {
-  const t = {};
-  for (const n of e)
-    Object.prototype.hasOwnProperty.call(r, n) && (t[n] = r[n]);
-  return t;
+function Ge(e, t) {
+  const r = {};
+  for (const s of t)
+    Object.prototype.hasOwnProperty.call(e, s) && (r[s] = e[s]);
+  return r;
 }
-function bt(r, e) {
-  const t = { ...r };
-  for (const n of e)
-    delete t[n];
-  return t;
+function Ve(e, t) {
+  const r = { ...e };
+  for (const s of t)
+    delete r[s];
+  return r;
 }
-function Ct(r = 16) {
-  const e = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  let t = "";
-  for (let n = 0; n < r; n++)
-    t += e.charAt(Math.floor(Math.random() * e.length));
-  return t;
+function ze(e = 16) {
+  const t = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+  let r = "";
+  for (let s = 0; s < e; s++)
+    r += t.charAt(Math.floor(Math.random() * t.length));
+  return r;
 }
-function Tt(r, e = "ISO") {
-  if (e === "ISO")
-    return r.toISOString();
-  const t = r.getFullYear(), n = String(r.getMonth() + 1).padStart(2, "0"), s = String(r.getDate()).padStart(2, "0"), o = String(r.getHours()).padStart(2, "0"), i = String(r.getMinutes()).padStart(2, "0"), a = String(r.getSeconds()).padStart(2, "0");
-  switch (e) {
+function Qe(e, t = "ISO") {
+  if (t === "ISO")
+    return e.toISOString();
+  const r = e.getFullYear(), s = String(e.getMonth() + 1).padStart(2, "0"), o = String(e.getDate()).padStart(2, "0"), n = String(e.getHours()).padStart(2, "0"), c = String(e.getMinutes()).padStart(2, "0"), l = String(e.getSeconds()).padStart(2, "0");
+  switch (t) {
     case "DATE":
-      return `${t}-${n}-${s}`;
+      return `${r}-${s}-${o}`;
     case "TIME":
-      return `${o}:${i}:${a}`;
+      return `${n}:${c}:${l}`;
     case "DATETIME":
-      return `${t}-${n}-${s} ${o}:${i}:${a}`;
+      return `${r}-${s}-${o} ${n}:${c}:${l}`;
     default:
-      return r.toISOString();
+      return e.toISOString();
   }
 }
-function Ot(r) {
-  return new Promise((e) => setTimeout(e, r));
+function Ke(e) {
+  return new Promise((t) => setTimeout(t, e));
 }
-const N = A("http"), _ = {
+const P = w("http"), E = {
   info: "\x1B[36m",
   // Cyan for 1xx
   success: "\x1B[32m",
@@ -1939,10 +890,10 @@ const N = A("http"), _ = {
   // Red for 5xx
   reset: "\x1B[0m"
 };
-function je(r) {
-  return r >= 500 ? _.serverError : r >= 400 ? _.clientError : r >= 300 ? _.redirect : r >= 200 ? _.success : _.info;
+function $e(e) {
+  return e >= 500 ? E.serverError : e >= 400 ? E.clientError : e >= 300 ? E.redirect : e >= 200 ? E.success : E.info;
 }
-function G(r) {
+function b(e) {
   return {
     GET: "\x1B[32m",
     // Green
@@ -1958,137 +909,171 @@ function G(r) {
     // Cyan
     HEAD: "\x1B[36m"
     // Cyan
-  }[r] ?? "\x1B[0m";
+  }[e] ?? "\x1B[0m";
 }
-function Le(r) {
-  return r === 0 ? "-" : r < 1024 ? `${r}B` : r < 1024 * 1024 ? `${(r / 1024).toFixed(1)}KB` : `${(r / (1024 * 1024)).toFixed(1)}MB`;
+function Oe(e) {
+  return e === 0 ? "-" : e < 1024 ? `${e}B` : e < 1024 * 1024 ? `${(e / 1024).toFixed(1)}KB` : `${(e / (1024 * 1024)).toFixed(1)}MB`;
 }
-function Ue(r, e, t) {
-  const n = Date.now() - t, s = e.statusCode, o = e.get("content-length") ?? "0";
+function ye(e, t, r) {
+  const s = Date.now() - r, o = t.statusCode, n = t.get("content-length") ?? "0";
   return {
-    method: r.method,
-    url: r.originalUrl || r.url,
-    status: s,
-    statusColor: je(s),
-    responseTime: n,
-    contentLength: Le(parseInt(o, 10) || 0),
-    remoteAddr: r.ip || r.socket.remoteAddress || "-",
+    method: e.method,
+    url: e.originalUrl || e.url,
+    status: o,
+    statusColor: $e(o),
+    responseTime: s,
+    contentLength: Oe(parseInt(n, 10) || 0),
+    remoteAddr: e.ip || e.socket.remoteAddress || "-",
     date: (/* @__PURE__ */ new Date()).toISOString(),
-    httpVersion: `HTTP/${r.httpVersionMajor}.${r.httpVersionMinor}`,
-    userAgent: r.get("user-agent") ?? "-",
-    referrer: r.get("referrer") ?? "-"
+    httpVersion: `HTTP/${e.httpVersionMajor}.${e.httpVersionMinor}`,
+    userAgent: e.get("user-agent") ?? "-",
+    referrer: e.get("referrer") ?? "-"
   };
 }
-const Fe = {
-  tiny: (r, e) => {
-    const t = e ? `${G(r.method)}${r.method}${_.reset}` : r.method, n = e ? `${r.statusColor}${r.status}${_.reset}` : String(r.status);
-    return `${t} ${r.url} ${n} ${r.responseTime}ms`;
+const Ae = {
+  tiny: (e, t) => {
+    const r = t ? `${b(e.method)}${e.method}${E.reset}` : e.method, s = t ? `${e.statusColor}${e.status}${E.reset}` : String(e.status);
+    return `${r} ${e.url} ${s} ${e.responseTime}ms`;
   },
-  short: (r, e) => {
-    const t = e ? `${G(r.method)}${r.method}${_.reset}` : r.method, n = e ? `${r.statusColor}${r.status}${_.reset}` : String(r.status);
-    return `${r.remoteAddr} ${t} ${r.url} ${n} ${r.responseTime}ms - ${r.contentLength}`;
+  short: (e, t) => {
+    const r = t ? `${b(e.method)}${e.method}${E.reset}` : e.method, s = t ? `${e.statusColor}${e.status}${E.reset}` : String(e.status);
+    return `${e.remoteAddr} ${r} ${e.url} ${s} ${e.responseTime}ms - ${e.contentLength}`;
   },
-  dev: (r, e) => {
-    const t = e ? `${G(r.method)}${r.method.padEnd(7)}${_.reset}` : r.method.padEnd(7), n = e ? `${r.statusColor}${r.status}${_.reset}` : String(r.status), s = r.responseTime < 100 ? `${r.responseTime}ms` : r.responseTime < 1e3 ? `\x1B[33m${r.responseTime}ms${_.reset}` : `\x1B[31m${r.responseTime}ms${_.reset}`;
-    return `${t} ${r.url} ${n} ${e ? s : `${r.responseTime}ms`} - ${r.contentLength}`;
+  dev: (e, t) => {
+    const r = t ? `${b(e.method)}${e.method.padEnd(7)}${E.reset}` : e.method.padEnd(7), s = t ? `${e.statusColor}${e.status}${E.reset}` : String(e.status), o = e.responseTime < 100 ? `${e.responseTime}ms` : e.responseTime < 1e3 ? `\x1B[33m${e.responseTime}ms${E.reset}` : `\x1B[31m${e.responseTime}ms${E.reset}`;
+    return `${r} ${e.url} ${s} ${t ? o : `${e.responseTime}ms`} - ${e.contentLength}`;
   },
-  combined: (r) => `${r.remoteAddr} - - [${r.date}] "${r.method} ${r.url} ${r.httpVersion}" ${r.status} ${r.contentLength} "${r.referrer}" "${r.userAgent}"`,
-  common: (r) => `${r.remoteAddr} - - [${r.date}] "${r.method} ${r.url} ${r.httpVersion}" ${r.status} ${r.contentLength}`,
+  combined: (e) => `${e.remoteAddr} - - [${e.date}] "${e.method} ${e.url} ${e.httpVersion}" ${e.status} ${e.contentLength} "${e.referrer}" "${e.userAgent}"`,
+  common: (e) => `${e.remoteAddr} - - [${e.date}] "${e.method} ${e.url} ${e.httpVersion}" ${e.status} ${e.contentLength}`,
   custom: () => ""
   // Handled separately
 };
-function Et(r = {}) {
+function We(e = {}) {
   const {
-    format: e = "dev",
-    skip: t,
-    immediate: n = !1,
-    customFormat: s,
-    colorize: o = !0
-  } = r;
-  return (i, a, h) => {
-    const g = Date.now();
-    n && N.info(C("http.requestStart", { method: i.method, url: i.url }));
-    const w = a.end;
-    a.end = function(b, d, l) {
-      a.end = w;
-      const u = a.end(b, d, l);
-      if (t && t(i, a))
-        return u;
-      const f = Ue(i, a, g);
+    format: t = "dev",
+    skip: r,
+    immediate: s = !1,
+    customFormat: o,
+    colorize: n = !0
+  } = e;
+  return (c, l, i) => {
+    const f = Date.now();
+    s && P.info(y("http.requestStart", { method: c.method, url: c.url }));
+    const p = l.end;
+    l.end = function(g, a, u) {
+      l.end = p;
+      const h = l.end(g, a, u);
+      if (r && r(c, l))
+        return h;
+      const d = ye(c, l, f);
       let m;
-      return e === "custom" && s ? m = s(f) : m = Fe[e](f, o), f.status >= 500 ? N.error(m) : f.status >= 400 ? N.warn(m) : N.info(m), u;
-    }, h();
+      return t === "custom" && o ? m = o(d) : m = Ae[t](d, n), d.status >= 500 ? P.error(m) : d.status >= 400 ? P.warn(m) : P.info(m), h;
+    }, i();
   };
 }
-const St = {
+const Je = {
   /** Skip successful responses */
-  successOnly: (r, e) => e.statusCode < 400,
+  successOnly: (e, t) => t.statusCode < 400,
   /** Skip health check endpoints */
-  healthChecks: (r) => r.url === "/health" || r.url === "/healthz" || r.url === "/ready",
+  healthChecks: (e) => e.url === "/health" || e.url === "/healthz" || e.url === "/ready",
   /** Skip static files */
-  staticFiles: (r) => /\.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$/i.test(r.url),
+  staticFiles: (e) => /\.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$/i.test(e.url),
   /** Skip based on custom paths */
-  paths: (r) => (e) => r.some((t) => e.url.startsWith(t))
+  paths: (e) => (t) => e.some((r) => t.url.startsWith(r))
 };
-function At(r) {
-  return r;
+function Ye(e) {
+  return e;
 }
 export {
-  Je as CONTENT_TYPES,
-  _t as ChangelogManager,
-  lt as DELETE,
-  jt as DockerManager,
-  it as GET,
-  Ze as HEADERS,
-  Xe as HTTP_METHODS,
-  p as HTTP_STATUS,
-  Q as HarborDocument,
+  it as CONTENT_TYPES,
+  Wt as CacheManager,
+  ke as ChangelogManager,
+  Ue as DELETE,
+  fr as DockerManager,
+  Ne as GET,
+  ct as HEADERS,
+  ut as HTTP_METHODS,
+  T as HTTP_STATUS,
+  lt as HarborDocument,
   O as HarborError,
-  L as Model,
-  Ht as MongoValidator,
-  dt as PATCH,
-  at as POST,
-  ct as PUT,
-  De as PortalGenerator,
-  H as Query,
-  J as RouteBuilder,
-  Z as Schema,
-  pt as Types,
-  st as addTranslations,
-  mt as connect,
-  j as connection,
-  xe as createChangelogManager,
-  At as createCustomFormat,
-  Lt as createDockerManager,
-  Ee as createErrorHandler,
-  A as createLogger,
-  Nt as createMongoSchema,
-  It as createParamValidator,
-  yt as createPortal,
-  K as createRouter,
-  ht as createServer,
-  Me as deepMerge,
-  et as defineConfig,
-  ft as disconnect,
-  Tt as formatDate,
-  wt as generateDocs,
-  Ct as generateId,
-  rt as getAvailableLocales,
-  nt as getLocale,
-  Et as httpLogger,
-  me as loadConfig,
-  gt as model,
-  bt as omit,
-  vt as pick,
-  ot as registerLocale,
-  ut as route,
-  kt as setGlobalLogLevel,
-  tt as setLocale,
-  St as skipFunctions,
-  Ot as sleep,
-  C as t,
-  xt as validateField,
-  F as validateRequest,
-  Dt as validators
+  rr as JWT,
+  Jt as MemoryCache,
+  ht as Model,
+  tt as MongoValidator,
+  De as PATCH,
+  be as POST,
+  Fe as PUT,
+  ft as Query,
+  Rt as RateLimitRedisStore,
+  Yt as RedisCache,
+  K as RouteBuilder,
+  zt as Scheduler,
+  pt as Schema,
+  mt as Types,
+  kt as WebSocketManager,
+  gt as addTranslations,
+  sr as apiKeyAuth,
+  Zt as cache,
+  Xt as cacheResponse,
+  qt as cached,
+  Tt as connect,
+  Et as connection,
+  er as createCache,
+  Se as createChangelogManager,
+  Ye as createCustomFormat,
+  pr as createDockerManager,
+  he as createErrorHandler,
+  or as createJwt,
+  w as createLogger,
+  rt as createMongoSchema,
+  st as createParamValidator,
+  B as createRouter,
+  Qt as createScheduler,
+  Be as createServer,
+  Gt as createWebSocketServer,
+  Ct as customHealthCheck,
+  ve as deepMerge,
+  _t as defaultRegistry,
+  Ie as defineConfig,
+  St as disconnect,
+  Pt as diskHealthCheck,
+  Qe as formatDate,
+  nr as generateApiKey,
+  ze as generateId,
+  vt as getAvailableLocales,
+  $t as getLocale,
+  ar as hashPassword,
+  Lt as healthCheck,
+  We as httpLogger,
+  ir as jwtAuth,
+  re as loadConfig,
+  Ht as memoryHealthCheck,
+  xt as metricsEndpoint,
+  It as metricsMiddleware,
+  Mt as mimeToExtension,
+  Ot as model,
+  Nt as mongoHealthCheck,
+  Ve as omit,
+  Ge as pick,
+  bt as rateLimit,
+  Ft as redisHealthCheck,
+  yt as registerLocale,
+  cr as requirePermission,
+  ur as requireRole,
+  je as route,
+  Me as router,
+  qe as setGlobalLogLevel,
+  At as setLocale,
+  Je as skipFunctions,
+  Ke as sleep,
+  Dt as slidingWindowRateLimit,
+  y as t,
+  Ut as upload,
+  ot as validateField,
+  jt as validateFileType,
+  I as validateRequest,
+  nt as validators,
+  dr as verifyPassword,
+  lr as verifySignature
 };
 //# sourceMappingURL=index.es.js.map