@catbee/utils 2.0.0-next.0 → 2.0.0-next.1

package/async/index.mjs

@@ -43,7 +43,13 @@ function debounce(fn, delay) {
     pendingArgs = args;
     if (timer) clearTimeout(timer);
     timer = setTimeout(() => {
-      fn(...pendingArgs);
+      try {
+        fn(...pendingArgs);
+      } catch (err) {
+        getLogger().error({
+          err
+        }, "Error in debounced function");
+      }
       timer = null;
     }, delay);
   }
@@ -56,7 +62,13 @@ function debounce(fn, delay) {
   debounced.flush = () => {
     if (timer) {
       clearTimeout(timer);
-      fn(...pendingArgs);
+      try {
+        fn(...pendingArgs);
+      } catch (err) {
+        getLogger().error({
+          err
+        }, "Error in debounced.flush");
+      }
       timer = null;
       pendingArgs = null;
     }
@@ -82,14 +94,28 @@ function throttle(fn, limit, opts = {
         timer = null;
       }
       lastCall = now;
-      fn(...args);
+      try {
+        fn(...args);
+      } catch (err) {
+        getLogger().error({
+          err
+        }, "Error in throttled function");
+      }
     } else if (trailing) {
       savedArgs = args;
       if (!timer) {
         timer = setTimeout(() => {
           lastCall = leading ? Date.now() : 0;
           timer = null;
-          if (savedArgs) fn(...savedArgs);
+          if (savedArgs) {
+            try {
+              fn(...savedArgs);
+            } catch (err) {
+              getLogger().error({
+                err
+              }, "Error in throttled trailing call");
+            }
+          }
         }, remaining);
       }
     }
@@ -140,7 +166,7 @@ function singletonAsync(fn, drop = false) {
         promise = null;
       });
     } else if (drop) {
-      return Promise.reject(new Error("Busy: function already running"));
+      throw new Error("Function is already in progress");
     }
     return promise;
   };
@@ -211,11 +237,19 @@ async function runInSeries(tasks) {
 __name(runInSeries, "runInSeries");
 function memoizeAsync(fn, options = {}) {
   const cache = /* @__PURE__ */ new Map();
-  const { ttl, keyFn = JSON.stringify } = options;
-  return async function(...args) {
-    const key = keyFn(args);
+  const { ttl } = options;
+  const generateKey = /* @__PURE__ */ __name((args) => {
+    try {
+      return options.keyFn?.(args) ?? JSON.stringify(args);
+    } catch {
+      getLogger().warn("memoizeAsync: key generation failed, falling back to JSON.stringify");
+      return JSON.stringify(args);
+    }
+  }, "generateKey");
+  return async (...args) => {
+    const key = generateKey(args);
     const cached = cache.get(key);
-    if (cached && (!ttl || Date.now() < cached.expires)) {
+    if (cached && Date.now() < cached.expires) {
       return cached.value;
     }
     const result = await fn(...args);
@@ -234,7 +268,10 @@ function abortable(promise, signal, abortValue = new Error("Operation aborted"))
   return Promise.race([
     promise,
     new Promise((_, reject) => {
-      const abort = /* @__PURE__ */ __name(() => reject(abortValue), "abort");
+      const abort = /* @__PURE__ */ __name(() => {
+        reject(abortValue);
+        signal.removeEventListener("abort", abort);
+      }, "abort");
       signal.addEventListener("abort", abort, {
         once: true
       });
@@ -303,39 +340,53 @@ var CircuitBreakerState = /* @__PURE__ */ (function(CircuitBreakerState2) {
 function circuitBreaker(fn, options = {}) {
   const { failureThreshold = 5, resetTimeout = 1e4, successThreshold = 1, onOpen, onClose, onHalfOpen } = options;
   let state = "CLOSED";
-  let failureCount = 0;
-  let successCount = 0;
-  let nextAttempt = Date.now();
-  return async function(...args) {
-    if (state === "OPEN") {
-      if (Date.now() < nextAttempt) {
-        throw new CircuitBreakerOpenError();
-      }
-      state = "HALF_OPEN";
-      if (onHalfOpen) onHalfOpen();
+  let fails = 0;
+  let halfSuccess = 0;
+  let unlockAt = 0;
+  const reset = /* @__PURE__ */ __name(() => {
+    fails = 0;
+    halfSuccess = 0;
+    state = "CLOSED";
+    onClose?.();
+  }, "reset");
+  const open = /* @__PURE__ */ __name(() => {
+    state = "OPEN";
+    unlockAt = Date.now() + resetTimeout;
+    onOpen?.();
+  }, "open");
+  const halfOpen = /* @__PURE__ */ __name(() => {
+    state = "HALF_OPEN";
+    onHalfOpen?.();
+  }, "halfOpen");
+  return async (...args) => {
+    const now = Date.now();
+    if (state === "OPEN" && now < unlockAt) {
+      throw new CircuitBreakerOpenError();
+    }
+    if (state === "OPEN" && now >= unlockAt) {
+      halfOpen();
     }
     try {
-      const result = await fn(...args);
+      const res = await fn(...args);
       if (state === "HALF_OPEN") {
-        successCount++;
-        if (successCount >= successThreshold) {
-          successCount = 0;
-          failureCount = 0;
-          state = "CLOSED";
-          if (onClose) onClose();
+        halfSuccess++;
+        if (halfSuccess >= successThreshold) {
+          reset();
+        } else {
+          state = "HALF_OPEN";
         }
       } else {
-        failureCount = 0;
+        fails = 0;
       }
-      return result;
-    } catch (error) {
-      failureCount++;
-      if ((state === "CLOSED" || state === "HALF_OPEN") && failureCount >= failureThreshold) {
-        state = "OPEN";
-        nextAttempt = Date.now() + resetTimeout;
-        if (onOpen) onOpen();
+      return res;
+    } catch (err) {
+      fails++;
+      if (state === "HALF_OPEN" || state === "CLOSED") {
+        if (fails >= failureThreshold) {
+          open();
+        }
       }
-      throw error;
+      throw err;
     }
   };
 }
@@ -351,12 +402,15 @@ async function runWithConcurrency(tasks, options = {}) {
   }
   return new Promise((resolve, reject) => {
     let taskIndex = 0;
+    let rejected = false;
     const processNext = /* @__PURE__ */ __name(async () => {
+      if (rejected) return;
       const currentTaskIndex = taskIndex++;
       if (currentTaskIndex >= totalTasks) return;
       try {
         const result = await tasks[currentTaskIndex]();
         if (signal?.aborted) {
+          rejected = true;
           reject(new Error("Aborted"));
           return;
         }
@@ -372,6 +426,7 @@ async function runWithConcurrency(tasks, options = {}) {
           }
         }
       } catch (error) {
+        rejected = true;
         reject(error);
         return;
       }
@@ -387,6 +442,7 @@ async function runWithConcurrency(tasks, options = {}) {
     }
     if (signal) {
       signal.addEventListener("abort", () => {
+        rejected = true;
         reject(new Error("Aborted"));
       }, {
         once: true

package/cache/index.cjs

@@ -40,7 +40,7 @@ var TTLCache = class {
   * @param options - Configuration options for the cache
   */
   constructor(options = {}) {
-    this.ttlMs = options.ttlMs ?? config.defaultCatbeeConfig.cache.defaultTtl;
+    this.ttlMs = options.ttlMs ?? config.getCatbeeGlobalConfig().cache.defaultTtl;
     this.maxSize = options.maxSize;
     const autoCleanupMs = options.autoCleanupMs;
     if (autoCleanupMs && autoCleanupMs > 0) {

package/cache/index.d.ts

@@ -22,4 +22,158 @@
  * SOFTWARE.
  */
 
-export * from './cache.utils';
+/**
+ * Options for configuring a TTLCache instance.
+ */
+interface TTLCacheOptions {
+    /** Default time-to-live in milliseconds for cache entries */
+    ttlMs?: number;
+    /** Maximum number of entries to keep in cache (uses LRU eviction policy) */
+    maxSize?: number;
+    /** Auto-cleanup interval in milliseconds (disabled if 0 or negative) */
+    autoCleanupMs?: number;
+}
+/**
+ * An in-memory cache with time-to-live (TTL) support for each entry.
+ *
+ * @typeParam K - Type of the key.
+ * @typeParam V - Type of the value.
+ *
+ * @example
+ * const cache = new TTLCache<string, number>({ ttlMs: 1000 });
+ * cache.set("x", 123);
+ * const value = cache.get("x"); // 123
+ */
+declare class TTLCache<K, V> {
+    private readonly cache;
+    private readonly ttlMs;
+    private readonly maxSize?;
+    private cleanupInterval?;
+    /**
+     * @param options - Configuration options for the cache
+     */
+    constructor(options?: TTLCacheOptions);
+    /**
+     * Sets a key-value pair in the cache with the default TTL.
+     *
+     * @param key - The key to set.
+     * @param value - The value to associate with the key.
+     */
+    set(key: K, value: V): void;
+    /**
+     * Sets a key-value pair in the cache with a custom TTL.
+     *
+     * @param key - The key to set.
+     * @param value - The value to associate with the key.
+     * @param ttlMs - Time-to-live in milliseconds.
+     */
+    setWithTTL(key: K, value: V, ttlMs: number): void;
+    /**
+     * Retrieves the value for a given key if it hasn't expired.
+     *
+     * @param key - The key to retrieve.
+     * @returns The cached value, or undefined if not found or expired.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Retrieves or computes a value if it's not in the cache or has expired.
+     *
+     * @param key - The key to retrieve
+     * @param producer - Function to generate the value if not cached
+     * @param ttlMs - Optional custom TTL for the computed value
+     * @returns The cached or computed value
+     */
+    getOrCompute(key: K, producer: () => Promise<V>, ttlMs?: number): Promise<V>;
+    /**
+     * Checks if the key exists and hasn't expired.
+     *
+     * @param key - The key to check.
+     * @returns `true` if key exists and is valid, otherwise `false`.
+     */
+    has(key: K): boolean;
+    /**
+     * Deletes a key from the cache.
+     *
+     * @param key - The key to delete.
+     * @returns `true` if the key existed and was removed, `false` otherwise.
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears all entries from the cache.
+     */
+    clear(): void;
+    /**
+     * Returns the number of entries currently in the cache (includes expired entries until next access/cleanup).
+     *
+     * @returns Number of items in the cache (may include expired keys).
+     */
+    size(): number;
+    /**
+     * Set multiple key-value pairs at once with the default TTL.
+     *
+     * @param entries - Array of [key, value] tuples to set
+     */
+    setMany(entries: [K, V][]): void;
+    /**
+     * Get multiple values at once.
+     *
+     * @param keys - Array of keys to retrieve
+     * @returns Array of values (undefined for keys that don't exist or expired)
+     */
+    getMany(keys: K[]): (V | undefined)[];
+    /**
+     * Removes all expired entries from the cache.
+     *
+     * @returns Number of entries removed.
+     */
+    cleanup(): number;
+    /**
+     * Returns an iterator of all current valid [key, value] pairs.
+     *
+     * @returns IterableIterator<[K, V]>
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Returns an iterator of all current valid keys.
+     *
+     * @returns IterableIterator<K>
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Returns an iterator of all current valid values.
+     *
+     * @returns IterableIterator<V>
+     */
+    values(): IterableIterator<V>;
+    /**
+     * Extends the expiration of a key by the specified time or default TTL.
+     *
+     * @param key - The key to refresh
+     * @param ttlMs - Optional new TTL in milliseconds (uses default if not specified)
+     * @returns true if the key was found and refreshed, false otherwise
+     */
+    refresh(key: K, ttlMs?: number): boolean;
+    /**
+     * Returns a snapshot of cache stats.
+     *
+     * @returns Object containing cache statistics
+     */
+    stats(): {
+        size: number;
+        validEntries: number;
+        expiredEntries: number;
+        maxSize: number | undefined;
+    };
+    /**
+     * Stop the auto-cleanup interval if it's running.
+     */
+    destroy(): void;
+    /**
+     * Evict the least recently used entry from the cache.
+     * @private
+     */
+    private evictLRU;
+}
+
+export { TTLCache };
+export type { TTLCacheOptions };

package/cache/index.mjs

@@ -22,7 +22,7 @@
  * SOFTWARE.
  */
 
-import { defaultCatbeeConfig } from '@catbee/utils/config';
+import { getCatbeeGlobalConfig } from '@catbee/utils/config';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -38,7 +38,7 @@ var TTLCache = class {
   * @param options - Configuration options for the cache
   */
   constructor(options = {}) {
-    this.ttlMs = options.ttlMs ?? defaultCatbeeConfig.cache.defaultTtl;
+    this.ttlMs = options.ttlMs ?? getCatbeeGlobalConfig().cache.defaultTtl;
     this.maxSize = options.maxSize;
     const autoCleanupMs = options.autoCleanupMs;
     if (autoCleanupMs && autoCleanupMs > 0) {

package/config/index.cjs

@@ -30,53 +30,35 @@ var obj = require('@catbee/utils/obj');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var defaultCatbeeConfig = {
-  logger: {
-    level: env.Env.get("LOGGER_LEVEL", env.Env.isDev() ? "debug" : "info"),
-    name: env.Env.get("LOGGER_NAME", env.Env.get("npm_package_name", "@catbee/utils")),
-    pretty: env.Env.getBoolean("LOGGER_PRETTY", false),
-    colorize: env.Env.getBoolean("LOGGER_PRETTY_COLORIZE", true),
-    singleLine: env.Env.getBoolean("LOGGER_PRETTY_SINGLE_LINE", false),
-    dir: env.Env.getPath("LOGGER_DIR", "", {
-      mustExist: false
-    })
-  },
-  cache: {
-    defaultTtl: env.Env.getNumber("CACHE_DEFAULT_TTL_SECONDS", 3600) * 1e3
-  },
-  server: {
-    skipHealthz: env.Env.getBoolean("SERVER_SKIP_HEALTHZ", false)
-  }
-};
 var defaultServerConfig = {
-  port: 3e3,
-  host: "0.0.0.0",
-  cors: false,
-  helmet: false,
-  compression: false,
+  port: env.Env.getNumber("SERVER_PORT", 0) || env.Env.getNumber("PORT", 3e3),
+  host: env.Env.get("SERVER_HOST", "") || env.Env.get("HOST", "0.0.0.0"),
+  cors: env.Env.getBoolean("SERVER_CORS_ENABLE", false) ? {} : false,
+  helmet: env.Env.getBoolean("SERVER_HELMET_ENABLE", false) ? {} : false,
+  compression: env.Env.getBoolean("SERVER_COMPRESSION_ENABLE", false) ? {} : false,
   bodyParser: {
     json: {
-      limit: "1mb"
+      limit: env.Env.get("SERVER_BODY_PARSER_JSON_LIMIT", "1mb")
     },
     urlencoded: {
       extended: true,
-      limit: "1mb"
+      limit: env.Env.get("SERVER_BODY_PARSER_URLENCODED_LIMIT", "1mb")
     }
   },
-  cookieParser: false,
-  isMicroservice: false,
-  appName: "express_app",
-  globalHeaders: {},
+  cookieParser: env.Env.getBoolean("SERVER_COOKIE_PARSER_ENABLE", false) ? {} : false,
+  isMicroservice: env.Env.getBoolean("SERVER_IS_MICROSERVICE", false),
+  appName: env.Env.get("SERVER_APP_NAME", env.Env.get("npm_package_name", "catbee_server")),
+  globalHeaders: env.Env.getJSON("SERVER_GLOBAL_HEADERS", {}),
   rateLimit: {
-    enable: false,
-    windowMs: 15 * 60 * 1e3,
-    max: 100,
-    message: "Too many requests",
-    standardHeaders: true,
-    legacyHeaders: false
+    enable: env.Env.getBoolean("SERVER_RATE_LIMIT_ENABLE", false),
+    windowMs: env.Env.getDuration("SERVER_RATE_LIMIT_WINDOW_MS", 15 * 60 * 1e3),
+    max: env.Env.getNumber("SERVER_RATE_LIMIT_MAX", 100),
+    message: env.Env.get("SERVER_RATE_LIMIT_MESSAGE", "Too many requests, please try again later."),
+    standardHeaders: env.Env.getBoolean("SERVER_RATE_LIMIT_STANDARD_HEADERS", true),
+    legacyHeaders: env.Env.getBoolean("SERVER_RATE_LIMIT_LEGACY_HEADERS", false)
   },
   requestLogging: {
-    enable: env.Env.isDev(),
+    enable: env.Env.getBoolean("SERVER_REQUEST_LOGGING_ENABLE", env.Env.isDev()),
     ignorePaths: /* @__PURE__ */ __name((req, _res) => {
       const skipPaths = [
         "/healthz",
@@ -87,50 +69,82 @@ var defaultServerConfig = {
       ];
       return skipPaths.some((path) => req.path.startsWith(path));
     }, "ignorePaths"),
-    skipNotFoundRoutes: false
+    skipNotFoundRoutes: env.Env.getBoolean("SERVER_REQUEST_LOGGING_SKIP_NOT_FOUND_ROUTES", true)
   },
+  trustProxy: env.Env.getBoolean("SERVER_TRUST_PROXY_ENABLE", false),
   openApi: {
-    enable: false,
-    mountPath: "/docs",
-    verbose: false,
-    withGlobalPrefix: false
+    enable: env.Env.getBoolean("SERVER_OPENAPI_ENABLE", false),
+    mountPath: env.Env.get("SERVER_OPENAPI_MOUNT_PATH", "/docs"),
+    verbose: env.Env.getBoolean("SERVER_OPENAPI_VERBOSE", false),
+    withGlobalPrefix: env.Env.getBoolean("SERVER_OPENAPI_WITH_GLOBAL_PREFIX", false)
   },
   healthCheck: {
-    path: "/healthz",
-    detailed: true
+    path: env.Env.get("SERVER_HEALTH_CHECK_PATH", "/healthz"),
+    detailed: env.Env.getBoolean("SERVER_HEALTH_CHECK_DETAILED_OUTPUT", true),
+    withGlobalPrefix: env.Env.getBoolean("SERVER_HEALTH_CHECK_WITH_GLOBAL_PREFIX", false)
   },
-  requestTimeout: 3e4,
+  requestTimeout: env.Env.getDuration("SERVER_REQUEST_TIMEOUT_MS", 0),
   responseTime: {
-    enable: false,
-    addHeader: true,
-    logOnComplete: false
+    enable: env.Env.getBoolean("SERVER_RESPONSE_TIME_ENABLE", false),
+    addHeader: env.Env.getBoolean("SERVER_RESPONSE_TIME_ADD_HEADER", true),
+    logOnComplete: env.Env.getBoolean("SERVER_RESPONSE_TIME_LOG_ON_COMPLETE", false)
   },
   requestId: {
-    headerName: "x-request-id",
-    exposeHeader: true,
+    headerName: env.Env.get("SERVER_REQUEST_ID_HEADER_NAME", "x-request-id"),
+    exposeHeader: env.Env.getBoolean("SERVER_REQUEST_ID_EXPOSE_HEADER", true),
     generator: /* @__PURE__ */ __name(() => id.uuid(), "generator")
   },
   metrics: {
-    enable: false,
-    path: "/metrics",
-    withGlobalPrefix: false
+    enable: env.Env.getBoolean("SERVER_METRICS_ENABLE", false),
+    path: env.Env.get("SERVER_METRICS_PATH", "/metrics"),
+    withGlobalPrefix: env.Env.getBoolean("SERVER_METRICS_WITH_GLOBAL_PREFIX", false)
   },
   serviceVersion: {
-    enable: false,
-    headerName: "x-service-version",
-    version: "0.0.0"
-  }
+    enable: env.Env.getBoolean("SERVER_SERVICE_VERSION_ENABLE", false),
+    headerName: env.Env.get("SERVER_SERVICE_VERSION_HEADER_NAME", "x-service-version"),
+    version: env.Env.get("SERVER_SERVICE_VERSION", "0.0.0")
+  },
+  skipHealthz: env.Env.getBoolean("SERVER_SKIP_HEALTHZ", false)
 };
-function setConfig(value) {
-  obj.deepObjMerge(defaultCatbeeConfig, value);
+var defaultCatbeeConfig = {
+  logger: {
+    level: env.Env.get("LOGGER_LEVEL", env.Env.isDev() || env.Env.isTest() ? "debug" : "info"),
+    name: env.Env.get("LOGGER_NAME", env.Env.get("npm_package_name", "@catbee/utils")),
+    pretty: env.Env.getBoolean("LOGGER_PRETTY", false),
+    colorize: env.Env.getBoolean("LOGGER_PRETTY_COLORIZE", true),
+    singleLine: env.Env.getBoolean("LOGGER_PRETTY_SINGLE_LINE", false),
+    dir: env.Env.getPath("LOGGER_DIR", "", {
+      mustExist: false
+    })
+  },
+  cache: {
+    defaultTtl: env.Env.getNumber("CACHE_DEFAULT_TTL_SECONDS", 3600) * 1e3
+  },
+  server: defaultServerConfig
+};
+var _config = obj.deepClone(defaultCatbeeConfig);
+function getCatbeeGlobalConfig() {
+  return obj.deepClone(_config);
+}
+__name(getCatbeeGlobalConfig, "getCatbeeGlobalConfig");
+var getConfig = getCatbeeGlobalConfig;
+function setCatbeeGlobalConfig(value) {
+  _config = obj.deepObjMerge(_config, value);
+}
+__name(setCatbeeGlobalConfig, "setCatbeeGlobalConfig");
+var setConfig = setCatbeeGlobalConfig;
+function setCatbeeServerGlobalConfig(value) {
+  _config.server = obj.deepObjMerge(_config.server, value);
 }
-__name(setConfig, "setConfig");
-function getConfig() {
-  return defaultCatbeeConfig;
+__name(setCatbeeServerGlobalConfig, "setCatbeeServerGlobalConfig");
+function getCatbeeServerGlobalConfig() {
+  return getCatbeeGlobalConfig().server;
 }
-__name(getConfig, "getConfig");
+__name(getCatbeeServerGlobalConfig, "getCatbeeServerGlobalConfig");
 
-exports.defaultCatbeeConfig = defaultCatbeeConfig;
-exports.defaultServerConfig = defaultServerConfig;
+exports.getCatbeeGlobalConfig = getCatbeeGlobalConfig;
+exports.getCatbeeServerGlobalConfig = getCatbeeServerGlobalConfig;
 exports.getConfig = getConfig;
+exports.setCatbeeGlobalConfig = setCatbeeGlobalConfig;
+exports.setCatbeeServerGlobalConfig = setCatbeeServerGlobalConfig;
 exports.setConfig = setConfig;

package/config/index.d.ts

@@ -22,5 +22,67 @@
  * SOFTWARE.
  */
 
-export { setConfig, getConfig } from './config';
-export { defaultCatbeeConfig, defaultServerConfig } from './config';
+import { CatbeeConfig, CatbeeGlobalServerConfig } from '@catbee/utils/types';
+import { Logger } from '@catbee/utils/logger';
+
+/**
+ * Extends Express Request interface to add request ID tracking.
+ * Added by requestId middleware during request processing.
+ */
+declare global {
+    namespace Express {
+        interface Request {
+            /** Unique request identifier (set by middleware) */
+            id?: string;
+            /** Logger instance for the request (set by middleware) */
+            logger?: Logger;
+            /** User information (set by authentication middleware) */
+            user?: any;
+        }
+    }
+}
+/**
+ * Gets the global Catbee configuration.
+ *
+ * @returns The current Catbee configuration.
+ */
+declare function getCatbeeGlobalConfig(): CatbeeConfig;
+/**
+ * Gets the global Catbee configuration.
+ *
+ * @deprecated Use `getCatbeeGlobalConfig` from `@catbee/utils/config` instead.
+ * @alias getCatbeeGlobalConfig
+ * @returns The current Catbee configuration.
+ */
+declare const getConfig: typeof getCatbeeGlobalConfig;
+/**
+ * Sets the global Catbee configuration.
+ * Merges the provided partial configuration with the existing one.
+ *
+ * @param value - Partial Catbee configuration to set
+ */
+declare function setCatbeeGlobalConfig(value: Partial<CatbeeConfig>): void;
+/**
+ * Sets the global Catbee configuration.
+ * Merges the provided partial configuration with the existing one.
+ *
+ * @deprecated Use `setCatbeeGlobalConfig` from `@catbee/utils/config` instead.
+ * @alias setCatbeeGlobalConfig
+ * @param value - Partial Catbee configuration to set
+ */
+declare const setConfig: typeof setCatbeeGlobalConfig;
+/**
+ * Sets the global Catbee server configuration.
+ * Merges the provided partial server configuration with the existing one.
+ *
+ * @param value - Partial Catbee server configuration to set
+ */
+declare function setCatbeeServerGlobalConfig(value: Partial<CatbeeGlobalServerConfig>): void;
+/**
+ * Gets the global Catbee server configuration.
+ *
+ * @returns The current Catbee server configuration.
+ */
+declare function getCatbeeServerGlobalConfig(): CatbeeGlobalServerConfig;
+
+export { getCatbeeGlobalConfig, getCatbeeServerGlobalConfig, getConfig, setCatbeeGlobalConfig, setCatbeeServerGlobalConfig, setConfig };