@catbee/utils 2.1.1 → 2.2.0

package/server/index.mjs

@@ -26,17 +26,18 @@ import express from 'express';
 import http from 'http';
 import https from 'https';
 import { HttpStatusCodes } from '@catbee/utils/http-status-codes';
-import { createFinalErrorResponse, SuccessResponse } from '@catbee/utils/response';
+import { createFinalErrorResponse } from '@catbee/utils/response';
 import { requestId, setupRequestContext, timeout, responseTime, errorHandler } from '@catbee/utils/middleware';
 import { Env } from '@catbee/utils/env';
 import { getLogger } from '@catbee/utils/logger';
-import { ServiceUnavailableException, InternalServerErrorException, NotFoundException } from '@catbee/utils/exception';
+import { ServiceUnavailableException, NotFoundException } from '@catbee/utils/exception';
 import { getCatbeeServerGlobalConfig } from '@catbee/utils/config';
-import { deepObjMerge, isPlainObject, deepClone } from '@catbee/utils/object';
+import { isPlainObject, deepClone, deepObjMerge } from '@catbee/utils/object';
 import { fileExists, readFile, readFileSync } from '@catbee/utils/fs';
 import { isPort, isHostname } from '@catbee/utils/validation';
 import { optionalRequire } from '@catbee/utils/async';
 import { uuid } from '@catbee/utils/id';
+import { HealthzServer } from '@catbee/utils/healthz-server';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -299,36 +300,53 @@ var ServerConfigBuilder = class {
     return this.setEnabled("requestLogging", false);
   }
   /**
-  * Configures server health check endpoint.
+  * Configures the dedicated Healthz probe HTTP server for Kubernetes.
   *
-  * @param opts - Health check configuration options
+  * @param opts - Healthz server configuration options or boolean toggle
   * @returns The builder instance for chaining
-  * @default - { path: '/healthz', detailed: true, withGlobalPrefix: false }
   *
   * @example
   * ```typescript
-  * builder.withHealthCheck({
-  *   path: '/health',
-  *   detailed: true
+  * builder.withHealthzServer({
+  *   port: 8282,
+  *   shutdownDelayMs: 5000,
+  *   readinessChecks: [
+  *     { name: 'db', check: () => checkDb() }
+  *   ]
   * })
   * ```
   */
-  withHealthCheck(opts) {
-    this.mergeConfig("healthCheck", opts);
+  withHealthzServer(opts) {
+    if (typeof opts === "boolean") {
+      this.config.healthzServer = opts;
+    } else {
+      const current = isPlainObject(this.config.healthzServer) ? deepClone(this.config.healthzServer) : {};
+      this.config.healthzServer = deepObjMerge({}, current, {
+        enable: true,
+        ...opts
+      });
+    }
     return this;
   }
   /**
-  * Enables health check endpoint with default or custom settings
-  * @param opts - Optional health check configuration
+  * Enables the dedicated Healthz probe HTTP server.
+  *
+  * @param opts - Optional Healthz server configuration options
   * @returns The builder instance for chaining
+  */
+  enableHealthzServer(opts = {}) {
+    return this.withHealthzServer({
+      ...opts,
+      enable: true
+    });
+  }
+  /**
+  * Disables the dedicated Healthz probe HTTP server.
   *
-  * @example
-  * ```typescript
-  * builder.disableHealthCheck()
-  * ```
+  * @returns The builder instance for chaining
   */
-  disableHealthCheck() {
-    return this.setEnabled("healthCheck", false);
+  disableHealthzServer() {
+    return this.withHealthzServer(false);
   }
   /**
   * Configures OpenAPI/Swagger documentation for the API.
@@ -718,11 +736,12 @@ var ExpressServer = class {
   gracefulShutdownRegistered = false;
   /** Map of registered signal listeners for clean teardown */
   signalListeners = /* @__PURE__ */ new Map();
-  /**
-  * Collection of registered health check functions.
-  * These are executed when the health check endpoint is accessed.
-  */
-  healthChecks = [];
+  /** Running address info for the Healthz probe server */
+  healthzAddress;
+  /** Named checks queued for Healthz liveness probe */
+  healthzChecks = [];
+  /** Named checks queued for Healthz readiness probe */
+  healthzReadinessChecks = [];
   /** Promise that resolves when initialization (middleware + routes) is complete */
   initPromise;
   /** In-flight start promise to protect against concurrent start() calls */
@@ -757,8 +776,19 @@ var ExpressServer = class {
       getLogger().error(msg);
       throw new Error(msg);
     }
-    if (config?.healthCheck?.checks) {
-      this.healthChecks.push(...config.healthCheck.checks);
+    if (typeof this.config.healthzServer === "boolean") {
+      this.config.healthzServer = {
+        ...HealthzServer.getDefaultConfig(),
+        enable: this.config.healthzServer
+      };
+    }
+    if (this.config.healthzServer && typeof this.config.healthzServer === "object") {
+      if (this.config.healthzServer.checks) {
+        this.healthzChecks.push(...this.config.healthzServer.checks);
+      }
+      if (this.config.healthzServer.readinessChecks) {
+        this.healthzReadinessChecks.push(...this.config.healthzServer.readinessChecks);
+      }
     }
     this.globalPrefix = this.normalizePath(this.config.globalPrefix ?? "", false);
     this.hooks = hooks;
@@ -1106,10 +1136,6 @@ var ExpressServer = class {
   * 4. Error handler
   */
   async setupRoutes() {
-    const healthCheckPath = this.normalizePath(this.config.healthCheck?.path || "/healthz", this.config.healthCheck?.withGlobalPrefix);
-    this.app.get(healthCheckPath, async (_req, res) => {
-      return this.handleHealthCheckRequest(res);
-    });
     this.app.use(this.globalPrefix, this.rootRouter);
     await this.runHook("afterRoutes", this.app);
     this.app.use((req, res) => {
@@ -1133,60 +1159,25 @@ var ExpressServer = class {
     });
   }
   /**
-  * Execute health check and return response.
+  * Whether the Healthz probe server is enabled.
   */
-  async handleHealthCheckRequest(res) {
-    try {
-      if (!this.healthChecks.length || getCatbeeServerGlobalConfig().skipHealthzChecksValidation) {
-        return res.status(HttpStatusCodes.OK).json(new SuccessResponse("OK"));
-      }
-      const results = await this.executeHealthChecks();
-      const allOk = results.every((r) => r.status);
-      const status = allOk ? HttpStatusCodes.OK : HttpStatusCodes.SERVICE_UNAVAILABLE;
-      const response = new SuccessResponse(allOk ? "OK" : "Service unavailable");
-      if (!allOk) response.error = true;
-      if (this.config.healthCheck?.detailed) response.data = {
-        checks: results
-      };
-      return res.status(status).json(response);
-    } catch {
-      return res.status(HttpStatusCodes.INTERNAL_SERVER_ERROR).json(new InternalServerErrorException("Health check failed"));
+  isHealthzServerEnabled() {
+    if (typeof this.config.healthzServer === "boolean") {
+      return this.config.healthzServer;
     }
+    return this.config.healthzServer?.enable === true;
   }
   /**
-  * Execute all registered health checks and return results.
+  * Get the graceful shutdown delay in milliseconds configured for HealthzServer.
   */
-  async executeHealthChecks() {
-    const checkResults = await Promise.allSettled(this.healthChecks.map(async ({ name, check }) => {
-      try {
-        const status = await Promise.resolve(check());
-        return {
-          name,
-          status,
-          error: null
-        };
-      } catch (error) {
-        return {
-          name,
-          status: false,
-          error: error.message
-        };
-      }
-    }));
-    return checkResults.map((result) => {
-      if (result.status === "fulfilled") return result.value;
-      return {
-        name: "unknown",
-        status: false,
-        error: result.reason
-      };
-    });
+  getHealthzShutdownDelay() {
+    return typeof this.config.healthzServer === "object" ? this.config.healthzServer.shutdownDelayMs ?? 0 : 0;
   }
   /**
-  * Register a new health check function for monitoring service dependencies.
+  * Register a new health check function for monitoring service dependencies on the Healthz probe server.
   *
-  * Health checks are executed when the health endpoint is accessed and
-  * help determine if the service is ready to handle requests.
+  * By default, external dependencies (DB, Redis, etc.) are registered as `readiness` checks.
+  * Can also be registered as `liveness` or `both`.
   *
   * Examples:
   * - Database connectivity
@@ -1195,33 +1186,61 @@ var ExpressServer = class {
   * - Memory/CPU usage checks
   *
   * @param name Unique identifier for the check (used in detailed responses)
-  * @param check Function returning boolean or Promise<boolean> indicating health
+  * @param check Function returning boolean or Promise<boolean> indicating health (supports optional AbortSignal)
+  * @param options Target probe type ('readiness' | 'liveness' | 'both') or options object
   * @returns This instance for method chaining
   */
-  registerHealthCheck(name, check) {
-    this.healthChecks.push({
+  registerHealthCheck(name, check, options) {
+    const probeType = typeof options === "string" ? options : options?.type ?? "readiness";
+    const namedCheck = {
       name,
       check
-    });
+    };
+    if (probeType === "liveness" || probeType === "both") {
+      this.healthzChecks.push(namedCheck);
+    }
+    if (probeType === "readiness" || probeType === "both") {
+      this.healthzReadinessChecks.push(namedCheck);
+    }
+    HealthzServer.registerCheck(namedCheck, probeType);
     return this;
   }
   /**
-  * Run registered health checks and return whether the service is ready.
-  * Useful for readiness probes in deployment tooling.
+  * Mark the service as ready / not-ready for traffic on the Healthz probe server.
   *
-  * @returns Promise resolving to `true` when all checks pass, otherwise `false`.
+  * @param ready Whether the service is ready to receive traffic
+  * @returns This instance for method chaining
   */
-  async ready() {
-    try {
-      if (!this.healthChecks.length || getCatbeeServerGlobalConfig().skipHealthzChecksValidation) return true;
-      const results = await this.executeHealthChecks();
-      return results.every((r) => r.status === true);
-    } catch (err) {
-      getLogger().error({
-        err
-      }, "Error while running readiness checks");
-      return false;
-    }
+  setReady(ready) {
+    HealthzServer.setReady(ready);
+    return this;
+  }
+  /**
+  * Whether the service is currently marked as ready for traffic on the Healthz probe server.
+  */
+  isReady() {
+    return HealthzServer.isReady();
+  }
+  /**
+  * Get the running HealthzServer instance (if started).
+  */
+  getHealthzServer() {
+    return HealthzServer.getInstance();
+  }
+  /**
+  * Get the address info of the running HealthzServer (if started).
+  */
+  getHealthzAddress() {
+    return this.healthzAddress;
+  }
+  /**
+  * Returns whether the service is currently marked as ready for traffic on the Healthz probe server.
+  * Useful for readiness checks in deployment tooling.
+  *
+  * @returns `true` when ready, otherwise `false`.
+  */
+  ready() {
+    return HealthzServer.isReady();
   }
   /**
   * Get the underlying Express application instance.
@@ -1291,6 +1310,10 @@ var ExpressServer = class {
           try {
             server.removeAllListeners();
             server.close();
+            if (HealthzServer.isStarted()) {
+              HealthzServer.stop().catch(() => {
+              });
+            }
           } catch {
           }
           this.server = null;
@@ -1305,10 +1328,50 @@ var ExpressServer = class {
       this.setupConnectionTracking();
       Promise.resolve(this.runHook("onServerCreated", server)).then(() => {
         const onListening = /* @__PURE__ */ __name(async () => {
-          isListening = true;
-          this.logServerStartInfo();
-          await this.runHook("afterStart", server);
-          resolve(server);
+          try {
+            if (this.isHealthzServerEnabled()) {
+              const healthzConfig = {
+                ...typeof this.config.healthzServer === "object" ? this.config.healthzServer : {},
+                handleSignals: false,
+                checks: [
+                  ...this.healthzChecks
+                ],
+                readinessChecks: [
+                  ...this.healthzReadinessChecks
+                ]
+              };
+              const addr = await HealthzServer.start(healthzConfig);
+              if (!addr) {
+                throw new Error("Healthz probe server failed to start (already running in this process)");
+              }
+              this.healthzAddress = addr;
+            }
+            this.logServerStartInfo();
+            await this.runHook("afterStart", server);
+            if (this.isHealthzServerEnabled()) {
+              HealthzServer.setReady(true);
+            }
+            isListening = true;
+            resolve(server);
+          } catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            getLogger().error({
+              err: error
+            }, "Server startup failed");
+            if (HealthzServer.isStarted()) {
+              await HealthzServer.stop().catch(() => {
+              });
+            }
+            try {
+              server.removeAllListeners();
+              server.close();
+            } catch {
+            }
+            this.server = null;
+            this.healthzAddress = null;
+            this.connections.clear();
+            reject(error);
+          }
         }, "onListening");
         const listenArgs = [
           this.config.port,
@@ -1359,8 +1422,8 @@ var ExpressServer = class {
     const host = this.formatHostForUrl(this.config.host || "localhost");
     const url = `${protocol}://${host}:${port}`;
     getLogger().info(`Server running on ${url}`);
-    if (this.config.healthCheck && this.config.healthCheck?.path) {
-      getLogger().info(`Health check available at ${url}${this.normalizePath(this.config.healthCheck.path, this.config.healthCheck.withGlobalPrefix)}`);
+    if (this.healthzAddress) {
+      getLogger().info(`Healthz probe server running on http://${this.healthzAddress.address}:${this.healthzAddress.port}`);
     }
     if (this.config.openApi?.enable) {
       getLogger().info(`API docs available at ${url}${this.normalizePath(this.config.openApi.mountPath, this.config.openApi.withGlobalPrefix)}`);
@@ -1383,7 +1446,7 @@ var ExpressServer = class {
   * - Monitoring systems are notified
   */
   async stop(force = false) {
-    if (!this.server) {
+    if (!this.server && !HealthzServer.isStarted()) {
       getLogger().warn("Stop called but server is not running");
       return;
     }
@@ -1392,10 +1455,26 @@ var ExpressServer = class {
       return;
     }
     this.isShuttingDown = true;
-    await this.runHook("beforeStop", this.server);
+    if (HealthzServer.isStarted()) {
+      HealthzServer.setReady(false);
+    }
+    if (this.server) {
+      await this.runHook("beforeStop", this.server);
+    }
     try {
-      await this.gracefulShutdown(force);
+      const shutdownDelay = this.getHealthzShutdownDelay();
+      if (shutdownDelay > 0 && !force && HealthzServer.isStarted()) {
+        getLogger().info(`Waiting ${shutdownDelay}ms for load balancer to drain traffic...`);
+        await new Promise((resolve) => setTimeout(resolve, shutdownDelay));
+      }
+      if (this.server) {
+        await this.gracefulShutdown(force);
+      }
     } finally {
+      if (HealthzServer.isStarted()) {
+        await HealthzServer.stop();
+        this.healthzAddress = null;
+      }
       this.isShuttingDown = false;
     }
   }
@@ -1484,7 +1563,7 @@ var ExpressServer = class {
         getLogger().info(`Received ${signal}, initiating graceful shutdown...`);
         try {
           this.disableGracefulShutdown();
-          await this.stop(true);
+          await this.stop(false);
           process.exit(0);
         } catch (err) {
           getLogger().fatal({

package/types/index.d.ts

@@ -157,6 +157,134 @@ type Without<T, U> = {
     [P in keyof T as T[P] extends U ? never : P]: T[P];
 };
 
+/**
+ * A health check function that can be synchronous or asynchronous.
+ * Receives an AbortSignal that is triggered when `checkTimeoutMs` is exceeded.
+ *
+ * > **Cancellation Note**: Cancellation is cooperative. The check function must listen to
+ * > `signal.aborted` or pass `signal` to underlying asynchronous APIs (e.g. database drivers, `fetch`).
+ * > Synchronous CPU-bound loops or operations that ignore `signal` cannot be forcibly stopped by JavaScript.
+ *
+ * - Return `true` (or resolve to true) to signal healthy.
+ * - Return `false` (or resolve to false) to signal unhealthy.
+ * - Throw an error (or reject) to signal unhealthy with an error message.
+ */
+type HealthCheckFn = (signal?: AbortSignal) => boolean | Promise<boolean>;
+/**
+ * A readiness check function.
+ * Receives an AbortSignal that is triggered when `checkTimeoutMs` is exceeded.
+ *
+ * > **Cancellation Note**: Cancellation is cooperative. The check function must listen to
+ * > `signal.aborted` or pass `signal` to underlying asynchronous APIs (e.g. database drivers, `fetch`).
+ * > Synchronous CPU-bound loops or operations that ignore `signal` cannot be forcibly stopped by JavaScript.
+ *
+ * - Return `true` (or resolve to true) to signal ready.
+ * - Return `false` (or resolve to false) to signal not ready.
+ * - Throw an error (or reject) to signal not ready with an error.
+ */
+type ReadinessCheckFn = (signal?: AbortSignal) => boolean | Promise<boolean>;
+/**
+ * A named health check with an associated check function.
+ */
+interface NamedCheck {
+    /** Human-readable name for this check (e.g. 'database', 'redis', 'disk') */
+    name: string;
+    /**
+     * Check function — return false or throw to indicate failure.
+     * Receives an AbortSignal that is triggered when the check times out.
+     * Cancellation via the signal is cooperative.
+     */
+    check: (signal?: AbortSignal) => boolean | Promise<boolean>;
+}
+/**
+ * Configuration for the standalone healthz HTTP server.
+ */
+interface CatbeeHealthzServerConfig {
+    /** Hostname / IP to bind to
+     *  - **default**: `'0.0.0.0'`
+     *  - **env**: `HEALTHZ_HOST` (fallback: `SERVER_HOST`, `HOST`)
+     */
+    host?: string;
+    /** Port to listen on
+     *  - **default**: `8282`
+     *  - **env**: `HEALTHZ_PORT` (fallback: `SERVER_HEALTHZ_PORT`)
+     */
+    port?: number;
+    /** Liveness probe path — Kubernetes `livenessProbe.httpGet.path`
+     *  - **default**: `'/healthz'`
+     *  - **env**: `HEALTHZ_PATH` (fallback: `SERVER_HEALTH_CHECK_PATH`)
+     */
+    healthzPath?: string;
+    /** Readiness probe path — Kubernetes `readinessProbe.httpGet.path`
+     *  - **default**: `'/readyz'`
+     *  - **env**: `HEALTHZ_READYZ_PATH` (fallback: `SERVER_READYZ_PATH`)
+     */
+    readyzPath?: string;
+    /** Startup probe path — Kubernetes `startupProbe.httpGet.path`
+     *  - **default**: `'/startupz'`
+     *  - **env**: `HEALTHZ_STARTUPZ_PATH` (fallback: `SERVER_STARTUPZ_PATH`)
+     */
+    startupzPath?: string;
+    /** Include individual check results in the JSON response
+     *  - **default**: `true`
+     *  - **env**: `HEALTHZ_DETAILED` (fallback: `SERVER_HEALTH_CHECK_DETAILED_OUTPUT`)
+     */
+    detailed?: boolean;
+    /**
+     * Named checks to run on the liveness endpoint (`/healthz`).
+     *
+     * > **Kubernetes Best Practice**: Keep liveness checks very lightweight (e.g. process is responsive,
+     * > event loop not blocked). Avoid placing external dependencies (DB, Redis, downstream APIs) here;
+     * > if a shared dependency encounters transient downtime, failing liveness causes Kubernetes to restart
+     * > the container, risking cascading restart storms.
+     * >
+     * > Place external dependency checks in `readinessChecks` instead.
+     */
+    checks?: NamedCheck[];
+    /**
+     * Named checks to run on the readiness endpoint (`/readyz`).
+     *
+     * Use this for external dependencies (DB, Redis, cache, message broker).
+     * If a dependency goes down, Kubernetes will temporarily remove the pod from traffic rotation
+     * without killing/restarting the container, allowing it to recover cleanly.
+     *
+     * - If **omitted** (`undefined`): falls back to `checks`.
+     * - If **explicitly empty** (`[]`): no readiness checks are run (traffic gated purely by `setReady(true)`).
+     */
+    readinessChecks?: NamedCheck[];
+    /**
+     * Custom liveness check function. Runs *in addition to* `checks`.
+     * Return `false` or throw to indicate unhealthy.
+     */
+    onHealthCheck?: HealthCheckFn;
+    /**
+     * Custom readiness check function. Runs *in addition to* `readinessChecks`.
+     * Return `false` or throw to indicate not ready.
+     */
+    onReadinessCheck?: ReadinessCheckFn;
+    /** Timeout (ms) per individual check before it's considered failed
+     *  - **default**: `5000`
+     *  - **env**: `HEALTHZ_CHECK_TIMEOUT_MS`
+     */
+    checkTimeoutMs?: number;
+    /**
+     * Graceful shutdown delay in milliseconds.
+     * After receiving SIGTERM/SIGINT the server immediately flips readiness
+     * to `false` and waits this many ms before closing — giving the load
+     * balancer time to drain traffic.
+     *  - **default**: `5000`
+     *  - **env**: `HEALTHZ_SHUTDOWN_DELAY_MS`
+     */
+    shutdownDelayMs?: number;
+    /**
+     * Whether the HealthzServer should register its own SIGTERM/SIGINT process signal listeners.
+     * When managed by an orchestrating server (such as Catbee ExpressServer), set this to `false`
+     * to prevent signal listener conflicts and allow coordinated teardown.
+     *  - **default**: `true`
+     */
+    handleSignals?: boolean;
+}
+
 /**
  * Server configuration for Catbee HTTP/Express server.
  * Designed with secure and high-performance defaults for production use.
@@ -370,35 +498,19 @@ interface CatbeeServerConfig {
          */
         skipNotFoundRoutes?: boolean;
     };
-    /** Health-check configuration
-     *  - **path**: `/healthz`
-     *  - **detailed**: `true`
-     *  - **withGlobalPrefix**: `false`
+    /** Standalone Healthz probe HTTP server configuration (for Kubernetes liveness, readiness, startup probes)
+     *  - **default**: `false`
+     *  - **env**: `SERVER_HEALTHZ_ENABLE` || `HEALTHZ_ENABLE`
+     *
+     * When enabled, ExpressServer automatically:
+     * - Starts `HealthzServer` on `server.start()`
+     * - Sets `HealthzServer.setReady(true)` after Express server is listening and ready
+     * - Sets `HealthzServer.setReady(false)` and gracefully drains/stops `HealthzServer` on `server.stop()`
+     * - Syncs health checks registered via `server.registerHealthCheck()` to `HealthzServer`
      */
-    healthCheck?: {
-        /** Health-check endpoint path
-         *  - **default**: `'/healthz'`
-         *  - **env**: `SERVER_HEALTH_CHECK_PATH`
-         */
-        path?: string;
-        /** Include detailed check results in the response
-         *  - **default**: `true`
-         *  - **env**: `SERVER_HEALTH_CHECK_DETAILED_OUTPUT`
-         */
-        detailed?: boolean;
-        /** Apply global route prefix
-         *  - **default**: `false`
-         *  - **env**: `SERVER_HEALTH_CHECK_WITH_GLOBAL_PREFIX`
-         */
-        withGlobalPrefix?: boolean;
-        /** Custom health checks */
-        checks?: Array<{
-            /** Name of the health check */
-            name: string;
-            /** Check function that returns boolean or Promise<boolean> */
-            check: () => Promise<boolean> | boolean;
-        }>;
-    };
+    healthzServer?: ToggleConfig<CatbeeHealthzServerConfig & {
+        enable?: boolean;
+    }>;
     /** Request timeout in ms
      *  - **default**: `30000` (30 seconds)
      *  - **env**: `SERVER_REQUEST_TIMEOUT_MS`
@@ -557,25 +669,8 @@ interface CatbeeServerHooks {
     /** Called before response is sent */
     onResponse?: (req: Request, res: Response, next: NextFunction) => void;
 }
-interface GlobalServerAddons {
-    /**
-     * Skip healthz endpoint even if health checks are configured
-     *  - **default**: `false`
-     *  - **env**: `SERVER_SKIP_HEALTHZ_CHECKS_VALIDATION`
-     *
-     * @additionalInfo
-     * Set to true to return `200 OK` for `/healthz` without checks
-     * Useful in environments where a simple liveness probe is needed
-     * without performing actual health checks
-     * Example: Kubernetes liveness probe
-     * Note: This does not disable the health check functionality itself
-     *       Health checks can still be performed programmatically
-     *       or via other endpoints if needed
-     */
-    skipHealthzChecksValidation: boolean;
-}
 /** Combined global server configuration type */
-type CatbeeGlobalServerConfig = CatbeeServerConfig & GlobalServerAddons;
+type CatbeeGlobalServerConfig = CatbeeServerConfig;
 
 /**
  * Generic API response format.
@@ -781,4 +876,4 @@ interface CatbeeConfig {
 }
 
 export { SortDirection };
-export type { ApiErrorResponse, ApiResponse, ApiSuccessResponse, AsyncOperationResponse, Awaited, BatchResponse, CatbeeConfig, CatbeeGlobalServerConfig, CatbeeServerConfig, CatbeeServerHooks, DeepPartial, DeepReadonly, DeepRequired, DeepStringifyOrNull, Func, GlobalServerAddons, IsEqual, KeysOfType, MaybePromise, Mutable, NonEmptyArray, Nullable, Optional, Optional2, Pagination, PaginationParams, PaginationResponse, PartialPick, PickByType, Primitive, RecordOptional, RequireAtLeastOne, StreamResponse, StringKeyedRecord, ToggleConfig, UnionToIntersection, ValueOf, WithPagination, Without, Writable };
+export type { ApiErrorResponse, ApiResponse, ApiSuccessResponse, AsyncOperationResponse, Awaited, BatchResponse, CatbeeConfig, CatbeeGlobalServerConfig, CatbeeServerConfig, CatbeeServerHooks, DeepPartial, DeepReadonly, DeepRequired, DeepStringifyOrNull, Func, IsEqual, KeysOfType, MaybePromise, Mutable, NonEmptyArray, Nullable, Optional, Optional2, Pagination, PaginationParams, PaginationResponse, PartialPick, PickByType, Primitive, RecordOptional, RequireAtLeastOne, StreamResponse, StringKeyedRecord, ToggleConfig, UnionToIntersection, ValueOf, WithPagination, Without, Writable };