@plyaz/api 1.2.1 → 1.3.0

package/dist/index.mjs

@@ -1,11 +1,15 @@
-import { HTTP_STATUS, isDev, TIME_CONSTANTS, NUMERIC_CONSTANTS, MULTIPLIERS, NETWORK_SCORES, NETWORK_TIMEOUTS, RETRY_BACKOFF, RETRY_DELAYS, RETRY_ATTEMPTS, DEDUPE_TIME, CACHE_STALE, CACHE_TTL, BATCH_SIZES, PAGE_SIZES, TIMEZONE_REGIONS, LOCALE_REGIONS_DETAILED, COUNTRY_REGIONS_DETAILED, DEFAULT_API_CONFIG, DEFAULT_API_CLIENT_OPTIONS } from '@plyaz/config';
-import { ERROR_CATEGORY } from '@plyaz/types';
-export { ERROR_CATEGORY as ErrorCategory } from '@plyaz/types';
-import { API_ERROR_CODES, PRIORITY_LEVEL, EVENT_SCOPES, EVENT_NAMESPACES, HEADER_EVENTS, NETWORK_EVENTS, ERROR_EVENTS, DEBUG_EVENTS, CONFIG_EVENTS, PERFORMANCE_EVENTS, CACHE_EVENTS, CLIENT_EVENTS, NETWORK_QUALITY, EVENT_PRIORITY_MAP, PACKAGE_STATUS_CODES, OPERATIONS, HISTORY_TYPES, ERROR_DEFINITIONS as ERROR_DEFINITIONS$1, HANDLER_SCOPES as HANDLER_SCOPES$1, DEFAULT_THRESHOLDS, CORRELATION_TYPE, NETWORK_CONFIDENCE_LEVELS, ERROR_CATEGORY_TO_EMITTER_KEY, UPDATE_STRATEGIES, DEBUGGER_CONFIG_SOURCES, RTT_THRESHOLDS, SPEED_THRESHOLDS, REGIONAL_CONFIDENCE_LEVELS as REGIONAL_CONFIDENCE_LEVELS$1, COORDINATES, STORAGE_TYPES, ERROR_FIELDS, EVENT_OPERATIONS } from '@plyaz/types/api';
-export { API_ERROR_CODES, ERROR_DEFINITIONS, NETWORK_QUALITY, PUB_SUB_EVENT } from '@plyaz/types/api';
+import { ApiPackageError as ApiPackageError$1, emitScopedErrorEvent, generateCorrelationId, generateRequestId, generateTraceCorrelationId, registerEventFactory, registerErrorHandler as registerErrorHandler$1, registerScopedHandlers, setErrorHandlers as setErrorHandlers$1, getErrorHandlers as getErrorHandlers$1, unregisterScopedHandlers, clearErrorHandlers as clearErrorHandlers$1, registerOnceErrorHandler, isErrorSystemInitialized, setErrorLocale, addMessageCatalog, initializeErrorSystem } from '@plyaz/errors';
+export { getErrorCategory, getErrorCodeByStatus, getErrorDefinition } from '@plyaz/errors';
 import { abortRequest as abortRequest$1, isSlowConnection as isSlowConnection$1, deleteCache as deleteCache$1, getCache as getCache$1, mutate, setCache as setCache$1, subscribe as subscribe$1, revalidateAll as revalidateAll$1, revalidate, setDefaultConfig, createApiFetcher } from 'fetchff';
 export { removeRevalidators, revalidate, revalidateAll } from 'fetchff';
+import { PRIORITY_LEVEL, EVENT_SCOPES_WITH_TEMPORARY, EVENT_NAMESPACES, HEADER_EVENTS, NETWORK_EVENTS, ERROR_EVENTS, DEBUG_EVENTS, CONFIG_EVENTS, PERFORMANCE_EVENTS, CACHE_EVENTS, CLIENT_EVENTS, NETWORK_QUALITY, EVENT_PRIORITY_MAP, PACKAGE_STATUS_CODES, API_ERROR_CODES, OPERATIONS, HISTORY_TYPES, EVENT_SCOPES as EVENT_SCOPES$1, HANDLER_SCOPES as HANDLER_SCOPES$1, DEFAULT_THRESHOLDS, NETWORK_CONFIDENCE_LEVELS, UPDATE_STRATEGIES, DEBUGGER_CONFIG_SOURCES, RTT_THRESHOLDS, SPEED_THRESHOLDS, REGIONAL_CONFIDENCE_LEVELS as REGIONAL_CONFIDENCE_LEVELS$1, COORDINATES, STORAGE_TYPES, ERROR_FIELDS, EVENT_OPERATIONS } from '@plyaz/types/api';
+export { NETWORK_QUALITY, PUB_SUB_EVENT } from '@plyaz/types/api';
+import { ApiLogger } from '@plyaz/logger';
+import { LOGGER_SERVICES } from '@plyaz/types';
+import { isDev, HTTP_STATUS, TIME_CONSTANTS, NUMERIC_CONSTANTS, MULTIPLIERS, NETWORK_SCORES, NETWORK_TIMEOUTS, RETRY_BACKOFF, RETRY_DELAYS, RETRY_ATTEMPTS, DEDUPE_TIME, CACHE_STALE, CACHE_TTL, BATCH_SIZES, PAGE_SIZES, TIMEZONE_REGIONS, LOCALE_REGIONS_DETAILED, COUNTRY_REGIONS_DETAILED, DEFAULT_API_CONFIG, DEFAULT_API_CLIENT_OPTIONS } from '@plyaz/config';
 import 'events';
+import { INTERNAL_STATUS_CODES, API_ERROR_CODES as API_ERROR_CODES$1, COMMON_OPERATIONS } from '@plyaz/types/errors';
+export { API_ERROR_CODES, ERROR_DEFINITIONS, COMMON_FIELDS as ERROR_FIELDS, COMMON_OPERATIONS as OPERATIONS, COMMON_STORAGE_TYPES as STORAGE_TYPES } from '@plyaz/types/errors';
 import { AsyncLocalStorage } from 'async_hooks';
 import { Injectable, createParamDecorator } from '@nestjs/common';
 import { Observable } from 'rxjs';
@@ -1009,302 +1013,6 @@ function applyPollingStrategy(strategy) {
   return strategy;
 }
 __name(applyPollingStrategy, "applyPollingStrategy");
-var ERROR_DEFINITIONS = {
-  // Authentication
-  [API_ERROR_CODES.AUTH_UNAUTHORIZED]: {
-    code: API_ERROR_CODES.AUTH_UNAUTHORIZED,
-    status: HTTP_STATUS.UNAUTHORIZED,
-    category: ERROR_CATEGORY.Authentication
-  },
-  [API_ERROR_CODES.AUTH_FORBIDDEN]: {
-    code: API_ERROR_CODES.AUTH_FORBIDDEN,
-    status: HTTP_STATUS.FORBIDDEN,
-    category: ERROR_CATEGORY.Authorization
-  },
-  [API_ERROR_CODES.AUTH_TOKEN_EXPIRED]: {
-    code: API_ERROR_CODES.AUTH_TOKEN_EXPIRED,
-    status: HTTP_STATUS.UNAUTHORIZED,
-    category: ERROR_CATEGORY.Authentication
-  },
-  [API_ERROR_CODES.AUTH_INVALID_CREDENTIALS]: {
-    code: API_ERROR_CODES.AUTH_INVALID_CREDENTIALS,
-    status: HTTP_STATUS.UNAUTHORIZED,
-    category: ERROR_CATEGORY.Authentication
-  },
-  // Rate Limiting
-  [API_ERROR_CODES.RATE_LIMIT_EXCEEDED]: {
-    code: API_ERROR_CODES.RATE_LIMIT_EXCEEDED,
-    status: HTTP_STATUS.TOO_MANY_REQUESTS,
-    category: ERROR_CATEGORY.RateLimit
-  },
-  // Resource Errors
-  [API_ERROR_CODES.RESOURCE_NOT_FOUND]: {
-    code: API_ERROR_CODES.RESOURCE_NOT_FOUND,
-    status: HTTP_STATUS.NOT_FOUND,
-    category: ERROR_CATEGORY.NotFound
-  },
-  // System Errors
-  [API_ERROR_CODES.INTERNAL_SERVER_ERROR]: {
-    code: API_ERROR_CODES.INTERNAL_SERVER_ERROR,
-    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: ERROR_CATEGORY.Server
-  },
-  [API_ERROR_CODES.SERVICE_UNAVAILABLE]: {
-    code: API_ERROR_CODES.SERVICE_UNAVAILABLE,
-    status: HTTP_STATUS.SERVICE_UNAVAILABLE,
-    category: ERROR_CATEGORY.Server
-  },
-  [API_ERROR_CODES.EXTERNAL_SERVICE_ERROR]: {
-    code: API_ERROR_CODES.EXTERNAL_SERVICE_ERROR,
-    status: HTTP_STATUS.BAD_GATEWAY,
-    category: ERROR_CATEGORY.ExternalService
-  },
-  // Validation
-  [API_ERROR_CODES.VALIDATION_ERROR]: {
-    code: API_ERROR_CODES.VALIDATION_ERROR,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Validation
-  },
-  [API_ERROR_CODES.VALIDATION_FAILED]: {
-    code: API_ERROR_CODES.VALIDATION_FAILED,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Validation
-  },
-  [API_ERROR_CODES.REQUIRED_FIELD_MISSING]: {
-    code: API_ERROR_CODES.REQUIRED_FIELD_MISSING,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Validation,
-    fieldsLeft: ["field"]
-  },
-  [API_ERROR_CODES.INVALID_FORMAT]: {
-    code: API_ERROR_CODES.INVALID_FORMAT,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Validation
-  },
-  [API_ERROR_CODES.STRING_TOO_SHORT]: {
-    code: API_ERROR_CODES.STRING_TOO_SHORT,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Validation,
-    fieldsLeft: ["field", "minLength"]
-  },
-  [API_ERROR_CODES.STRING_TOO_LONG]: {
-    code: API_ERROR_CODES.STRING_TOO_LONG,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Validation,
-    fieldsLeft: ["field", "maxLength"]
-  },
-  // Request Errors
-  [API_ERROR_CODES.REQUEST_TIMEOUT]: {
-    code: API_ERROR_CODES.REQUEST_TIMEOUT,
-    status: HTTP_STATUS.REQUEST_TIMEOUT,
-    category: ERROR_CATEGORY.Timeout
-  },
-  [API_ERROR_CODES.REQUEST_ABORTED]: {
-    code: API_ERROR_CODES.REQUEST_ABORTED,
-    status: 0,
-    // No HTTP status for aborted
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.REQUEST_INVALID_PARAMS]: {
-    code: API_ERROR_CODES.REQUEST_INVALID_PARAMS,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.REQUEST_PREPARATION_FAILED]: {
-    code: API_ERROR_CODES.REQUEST_PREPARATION_FAILED,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Client
-  },
-  // Response Errors
-  [API_ERROR_CODES.RESPONSE_INVALID_FORMAT]: {
-    code: API_ERROR_CODES.RESPONSE_INVALID_FORMAT,
-    status: HTTP_STATUS.UNPROCESSABLE_ENTITY,
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.RESPONSE_PARSING_FAILED]: {
-    code: API_ERROR_CODES.RESPONSE_PARSING_FAILED,
-    status: HTTP_STATUS.UNPROCESSABLE_ENTITY,
-    category: ERROR_CATEGORY.Client
-  },
-  // Network
-  [API_ERROR_CODES.NETWORK_ERROR]: {
-    code: API_ERROR_CODES.NETWORK_ERROR,
-    status: HTTP_STATUS.BAD_GATEWAY,
-    category: ERROR_CATEGORY.Network
-  },
-  [API_ERROR_CODES.NETWORK_TIMEOUT]: {
-    code: API_ERROR_CODES.NETWORK_TIMEOUT,
-    status: HTTP_STATUS.GATEWAY_TIMEOUT,
-    category: ERROR_CATEGORY.Timeout
-  },
-  [API_ERROR_CODES.NETWORK_CONNECTION_FAILED]: {
-    code: API_ERROR_CODES.NETWORK_CONNECTION_FAILED,
-    status: 0,
-    // No HTTP status for connection failure
-    category: ERROR_CATEGORY.Network
-  },
-  [API_ERROR_CODES.NETWORK_OFFLINE]: {
-    code: API_ERROR_CODES.NETWORK_OFFLINE,
-    status: 0,
-    // No HTTP status for offline
-    category: ERROR_CATEGORY.Network
-  },
-  [API_ERROR_CODES.NETWORK_DNS_FAILED]: {
-    code: API_ERROR_CODES.NETWORK_DNS_FAILED,
-    status: 0,
-    // No HTTP status for DNS failure
-    category: ERROR_CATEGORY.Network
-  },
-  // Server
-  [API_ERROR_CODES.SERVER_ERROR]: {
-    code: API_ERROR_CODES.SERVER_ERROR,
-    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: ERROR_CATEGORY.Server
-  },
-  // Client
-  [API_ERROR_CODES.CLIENT_ERROR]: {
-    code: API_ERROR_CODES.CLIENT_ERROR,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.CLIENT_CANCELLED]: {
-    code: API_ERROR_CODES.CLIENT_CANCELLED,
-    status: 0,
-    // No HTTP status for cancelled
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED]: {
-    code: API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
-    status: 0,
-    // No HTTP status for initialization failure
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.CLIENT_INVALID_CONFIG]: {
-    code: API_ERROR_CODES.CLIENT_INVALID_CONFIG,
-    status: 0,
-    // No HTTP status for configuration errors
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.CLIENT_MISSING_BASE_URL]: {
-    code: API_ERROR_CODES.CLIENT_MISSING_BASE_URL,
-    status: 0,
-    // No HTTP status for configuration errors
-    category: ERROR_CATEGORY.Client
-  },
-  [API_ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
-    code: API_ERROR_CODES.CONFIG_VALIDATION_FAILED,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Validation
-  },
-  [API_ERROR_CODES.HEADER_PROCESSING_FAILED]: {
-    code: API_ERROR_CODES.HEADER_PROCESSING_FAILED,
-    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: ERROR_CATEGORY.Headers
-  },
-  [API_ERROR_CODES.NETWORK_OVERRIDE_FAILED]: {
-    code: API_ERROR_CODES.NETWORK_OVERRIDE_FAILED,
-    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: ERROR_CATEGORY.Network
-  },
-  // Headers
-  [API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED]: {
-    code: API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Headers
-  },
-  [API_ERROR_CODES.HEADERS_VALIDATION_FAILED]: {
-    code: API_ERROR_CODES.HEADERS_VALIDATION_FAILED,
-    status: HTTP_STATUS.BAD_REQUEST,
-    category: ERROR_CATEGORY.Headers
-  },
-  [API_ERROR_CODES.HEADERS_MERGE_CONFLICT]: {
-    code: API_ERROR_CODES.HEADERS_MERGE_CONFLICT,
-    status: HTTP_STATUS.CONFLICT,
-    category: ERROR_CATEGORY.Headers
-  },
-  // Cache
-  [API_ERROR_CODES.CACHE_STORAGE_FAILED]: {
-    code: API_ERROR_CODES.CACHE_STORAGE_FAILED,
-    status: 0,
-    // No HTTP status for cache failures
-    category: ERROR_CATEGORY.Cache
-  },
-  [API_ERROR_CODES.CACHE_RETRIEVAL_FAILED]: {
-    code: API_ERROR_CODES.CACHE_RETRIEVAL_FAILED,
-    status: 0,
-    // No HTTP status for cache failures
-    category: ERROR_CATEGORY.Cache
-  },
-  [API_ERROR_CODES.CACHE_INVALIDATION_FAILED]: {
-    code: API_ERROR_CODES.CACHE_INVALIDATION_FAILED,
-    status: 0,
-    // No HTTP status for cache failures
-    category: ERROR_CATEGORY.Cache
-  },
-  // Retry
-  [API_ERROR_CODES.RETRY_EXHAUSTED]: {
-    code: API_ERROR_CODES.RETRY_EXHAUSTED,
-    status: HTTP_STATUS.SERVICE_UNAVAILABLE,
-    category: ERROR_CATEGORY.Retry
-  },
-  [API_ERROR_CODES.RETRY_STRATEGY_INVALID]: {
-    code: API_ERROR_CODES.RETRY_STRATEGY_INVALID,
-    status: 0,
-    // No HTTP status for strategy errors
-    category: ERROR_CATEGORY.Retry
-  },
-  // Strategy
-  [API_ERROR_CODES.STRATEGY_INVALID]: {
-    code: API_ERROR_CODES.STRATEGY_INVALID,
-    status: 0,
-    // No HTTP status for strategy errors
-    category: ERROR_CATEGORY.Strategy
-  },
-  [API_ERROR_CODES.STRATEGY_CONFLICT]: {
-    code: API_ERROR_CODES.STRATEGY_CONFLICT,
-    status: HTTP_STATUS.CONFLICT,
-    category: ERROR_CATEGORY.Strategy
-  },
-  // Regional
-  [API_ERROR_CODES.REGIONAL_PRESET_NOT_FOUND]: {
-    code: API_ERROR_CODES.REGIONAL_PRESET_NOT_FOUND,
-    status: 0,
-    // No HTTP status for regional preset errors
-    category: ERROR_CATEGORY.Regional
-  },
-  [API_ERROR_CODES.REGION_DETECTION_FAILED]: {
-    code: API_ERROR_CODES.REGION_DETECTION_FAILED,
-    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: ERROR_CATEGORY.Regional
-  },
-  // Timeout
-  [API_ERROR_CODES.TIMEOUT]: {
-    code: API_ERROR_CODES.TIMEOUT,
-    status: HTTP_STATUS.REQUEST_TIMEOUT,
-    category: ERROR_CATEGORY.Timeout
-  },
-  // Unknown
-  [API_ERROR_CODES.UNKNOWN_ERROR]: {
-    code: API_ERROR_CODES.UNKNOWN_ERROR,
-    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: ERROR_CATEGORY.Unknown
-  }
-};
-function getErrorDefinition(errorCode) {
-  return ERROR_DEFINITIONS[errorCode];
-}
-__name(getErrorDefinition, "getErrorDefinition");
-function getErrorCodeByStatus(status) {
-  const entry = Object.entries(ERROR_DEFINITIONS).find(
-    ([, definition]) => definition.status === status
-  );
-  return entry?.[0];
-}
-__name(getErrorCodeByStatus, "getErrorCodeByStatus");
-function getErrorCategory(errorCode) {
-  return ERROR_DEFINITIONS[errorCode]?.category ?? ERROR_CATEGORY.Unknown;
-}
-__name(getErrorCategory, "getErrorCategory");
 var BINARY_HEAP = {
   /** Number of children per node in binary heap */
   CHILDREN_PER_NODE: 2,
@@ -2031,8 +1739,6 @@ function removeCircularReferences(obj) {
   }
 }
 __name(removeCircularReferences, "removeCircularReferences");
-
-// src/api/utils/time.ts
 var MS_IN_SECOND = 1e3;
 var SECONDS_PER_MINUTE = 60;
 var MINUTES_PER_HOUR = 60;
@@ -2577,13 +2283,13 @@ var BaseEventFactory = class {
   constructor(namespace, emitter) {
     this.namespace = namespace;
     this.emitter = emitter;
-    EVENT_SCOPES.forEach((scope) => {
+    EVENT_SCOPES_WITH_TEMPORARY.forEach((scope) => {
       this.scopedHandlers.set(scope, /* @__PURE__ */ new Map());
       this.originalHandlers.set(scope, /* @__PURE__ */ new Map());
     });
     this.trackFactoryOperation("factory_initialized", {
       namespace: this.namespace,
-      scopesInitialized: EVENT_SCOPES.length,
+      scopesInitialized: EVENT_SCOPES_WITH_TEMPORARY.length,
       emitterType: "EventEmitter"
     });
   }
@@ -2735,16 +2441,14 @@ var BaseEventFactory = class {
    * - Non-scoped wildcards for backwards compatibility (e.g., headers:*)
    */
   emitAcrossScopes(eventType, eventName, data, scopes) {
-    const targetScopes = scopes ?? EVENT_SCOPES;
-    const normalizedScopes = targetScopes.map(
-      (s) => s === "temporary" ? "request" : s
-    );
-    const scopeOrder = [...EVENT_SCOPES];
+    const targetScopes = scopes ?? EVENT_SCOPES_WITH_TEMPORARY;
+    const scopeOrder = [...EVENT_SCOPES_WITH_TEMPORARY];
     for (const scope of scopeOrder) {
-      if (normalizedScopes.includes(scope)) {
-        const namespacedEvent = `${scope}:${eventType}:${eventName}`;
+      if (targetScopes.includes(scope)) {
+        const emitScope = scope === "temporary" ? "request" : scope;
+        const namespacedEvent = `${emitScope}:${eventType}:${eventName}`;
         this.emitter.emit(namespacedEvent, data);
-        const wildcardEvent = `${scope}:${eventType}:*`;
+        const wildcardEvent = `${emitScope}:${eventType}:*`;
         const wildcardData2 = typeof data === "object" && data !== null ? { ...data, originalEvent: eventName } : { data, originalEvent: eventName };
         this.emitter.emit(wildcardEvent, wildcardData2);
       }
@@ -2942,6 +2646,52 @@ var BaseEventFactory = class {
     });
     return this.createHandlerUnsubscribe(scope, eventName, handler, unsubscribes);
   }
+  /**
+   * Remove a specific handler from a scoped event
+   *
+   * @param scope - The scope to remove from ('global', 'config', 'client', 'request')
+   * @param eventName - The event name (e.g., 'validation', 'network', '*')
+   * @param handler - The specific handler to remove (should be the original handler, not wrapped)
+   */
+  removeScopedHandler(scope, eventName, handler) {
+    const startTime = Date.now();
+    const scopeMap = this.scopedHandlers.get(scope);
+    const originalMap = this.originalHandlers.get(scope);
+    if (!scopeMap || !originalMap) {
+      return;
+    }
+    const handlers = scopeMap.get(eventName);
+    const originals = originalMap.get(eventName);
+    if (!handlers || !originals) {
+      return;
+    }
+    const handlerAsUnknown = handler;
+    const originalIndex = originals.indexOf(handlerAsUnknown);
+    if (originalIndex === -1) {
+      return;
+    }
+    const beforeCount = handlers.length;
+    const wrappedHandler = handlers[originalIndex];
+    handlers.splice(originalIndex, 1);
+    originals.splice(originalIndex, 1);
+    const scopedEventKey = `${scope}:${this.namespace}:${eventName}`;
+    this.emitter.off(scopedEventKey, wrappedHandler);
+    if (handlers.length === 0) {
+      scopeMap.delete(eventName);
+      originalMap.delete(eventName);
+    } else {
+      scopeMap.set(eventName, handlers);
+      originalMap.set(eventName, originals);
+    }
+    this.trackFactoryOperation("specific_handler_removed", {
+      scope,
+      eventName,
+      beforeHandlerCount: beforeCount,
+      afterHandlerCount: handlers.length,
+      eventDeleted: handlers.length === 0,
+      removalTime: Date.now() - startTime
+    });
+  }
   /**
    * Remove all listeners for a scoped event
    *
@@ -4690,13 +4440,13 @@ var HANDLER_SCOPES = {
   REQUEST: "request"
   // Request-level handlers (highest priority, per-request)
 };
-var EVENT_SCOPES2 = [
+var EVENT_SCOPES = [
   HANDLER_SCOPES.GLOBAL,
   HANDLER_SCOPES.CONFIG,
   HANDLER_SCOPES.CLIENT,
   HANDLER_SCOPES.REQUEST
 ];
-var EVENT_SCOPES_WITH_TEMPORARY = [...EVENT_SCOPES2, "temporary"];
+var EVENT_SCOPES_WITH_TEMPORARY2 = [...EVENT_SCOPES, "temporary"];
 function createHandlerNamespace(eventType, scope) {
   return `${HANDLER_SCOPES[scope]}:${eventType}`;
 }
@@ -4888,6 +4638,7 @@ __name(getHandlerNamespaceForEvent, "getHandlerNamespaceForEvent");
 
 // src/api/events/EventManager.ts
 var SLOW_REQUEST_THRESHOLD_MS = 5e3;
+var logger = new ApiLogger({ service: LOGGER_SERVICES.EVENT_MANAGER, transport: "console" });
 var EventManager = class _EventManager extends BaseEventFactory {
   static {
     __name(this, "EventManager");
@@ -4905,7 +4656,7 @@ var EventManager = class _EventManager extends BaseEventFactory {
   // DEFAULT: ALL scopes are active ['global', 'config', 'client', 'request']
   // This means events are emitted to handlers at all scope levels by default
   // Can be restricted by calling setEventScopes() with specific scopes
-  eventScopes = [...EVENT_SCOPES2];
+  eventScopes = [...EVENT_SCOPES];
   currentEventScopes = this.eventScopes;
   // Alias for compatibility
   constructor() {
@@ -5081,9 +4832,10 @@ var EventManager = class _EventManager extends BaseEventFactory {
    */
   setupDebugHandlers() {
     this.on(DEBUG_EVENTS2.CONFIG_CONFLICT, (event) => {
-      if (typeof console !== "undefined" && typeof console.debug === "function") {
-        console.debug("[EventManager] Config conflict detected:", event);
-      }
+      logger.debug("Config conflict detected", {
+        conflictType: event.type,
+        source: event.source
+      });
     });
   }
   /**
@@ -5377,6 +5129,7 @@ var eventManager = {
   getEventStats: /* @__PURE__ */ __name(() => getEventManager().getEventStats(), "getEventStats"),
   getActiveScopes: /* @__PURE__ */ __name(() => getEventManager().getActiveScopes(), "getActiveScopes")
 };
+var logger2 = new ApiLogger({ service: LOGGER_SERVICES.EVENT_QUEUE, transport: "console" });
 var EventQueueManager = class _EventQueueManager {
   static {
     __name(this, "EventQueueManager");
@@ -5478,7 +5231,11 @@ var EventQueueManager = class _EventQueueManager {
         }
       }
       if (isDev) {
-        console.warn("[EventQueue] Event processing failed:", error);
+        logger2.warn("Event processing failed", {
+          eventType: event.eventType,
+          eventName: event.eventName,
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
   }
@@ -7517,6 +7274,7 @@ function colorProgressBar(value, max2, width = DEFAULT_PROGRESS_BAR_WIDTH) {
   return `[${bar}] ${percentText}`;
 }
 __name(colorProgressBar, "colorProgressBar");
+var logger3 = new ApiLogger({ service: LOGGER_SERVICES.DEBUG_REPORT, transport: "console" });
 var DEBUG_REPORT_CONSTANTS = {
   // Byte sizes
   BYTES_PER_KB: 1024,
@@ -9262,24 +9020,26 @@ function logNetworkOverride(params) {
     networkQuality,
     duration
   } = params;
-  console.group(`🔧 Network Config Override: ${property}`);
-  console.log(`Value: ${originalValue} → ${overrideValue}`);
-  console.log(`Source: ${source}`);
-  console.log(`Reason: ${reason}`);
+  logger3.group(`🔧 Network Config Override: ${property}`);
+  logger3.info("Value changed", {
+    from: originalValue,
+    to: overrideValue
+  });
+  logger3.info("Source", { source });
+  logger3.info("Reason", { reason });
   if (networkQuality) {
-    console.log(`Network Quality: ${networkQuality.toLowerCase()}`);
+    logger3.info("Network Quality", { quality: networkQuality.toLowerCase() });
   }
   if (networkInfo?.saveData) {
-    console.log("Save-Data: enabled");
+    logger3.info("Save-Data enabled");
   }
   if (duration) {
-    console.log(`Duration: ${duration}ms`);
+    logger3.info("Duration", { ms: duration });
   }
-  console.groupEnd();
+  logger3.groupEnd();
 }
 __name(logNetworkOverride, "logNetworkOverride");
-
-// src/api/debugger/UnifiedDebugger.ts
+var logger4 = new ApiLogger({ service: LOGGER_SERVICES.UNIFIED_DEBUGGER, transport: "console" });
 var DEBUGGER_CONSTANTS = {
   // Array/Division constants
   HALF_DIVISOR: 2,
@@ -9465,7 +9225,10 @@ var UnifiedDebugger = class _UnifiedDebugger {
         }
       }
     );
-    console.warn("⚠️ Debugger tracking failed:", apiError.message, apiError.context);
+    logger4.warn("⚠️ Debugger tracking failed", {
+      error: apiError.message,
+      context: apiError.context
+    });
   }
   /**
    * Safe tracking helper that handles errors properly
@@ -9800,11 +9563,11 @@ var UnifiedDebugger = class _UnifiedDebugger {
     try {
       const presetReport = this.getPresetChangeReport();
       if (presetReport) {
-        console.log(presetReport);
-        console.log("");
+        logger4.info(presetReport);
+        logger4.info("");
       }
       const report = await generateComprehensiveReport();
-      console.log(formatReportForConsole(report));
+      logger4.info(formatReportForConsole(report));
     } catch (err) {
       const error = new ApiPackageError(
         "Failed to generate debug report",
@@ -9812,7 +9575,9 @@ var UnifiedDebugger = class _UnifiedDebugger {
         API_ERROR_CODES.DEBUG_TRACKING_FAILED,
         { cause: err }
       );
-      console.error("⚠️ Failed to generate debug report:", error.message);
+      logger4.error("⚠️ Failed to generate debug report", {
+        error: error.message
+      });
       throw error;
     }
   }
@@ -10129,11 +9894,11 @@ var UnifiedDebugger = class _UnifiedDebugger {
         trigger: options.trigger,
         timestamp
       };
-      if (this.enabled && typeof console !== "undefined") {
-        console.group(`📋 Network preset applied: ${options.preset}`);
-        console.log(`Quality: ${options.networkConditions.quality}`);
-        console.log(`Trigger: ${options.trigger}`);
-        console.groupEnd();
+      if (this.enabled) {
+        logger4.group(`📋 Network preset applied: ${options.preset}`);
+        logger4.info(`Quality: ${options.networkConditions.quality}`);
+        logger4.info(`Trigger: ${options.trigger}`);
+        logger4.groupEnd();
       }
     }
     options.changes.forEach((change) => {
@@ -10195,8 +9960,8 @@ var UnifiedDebugger = class _UnifiedDebugger {
       source: "networkPreset",
       reason: options.trigger
     });
-    if (this.enabled && typeof console !== "undefined") {
-      console.log(`🔄 Network config restored: ${property}`);
+    if (this.enabled) {
+      logger4.info("🔄 Network config restored", { property });
     }
     this.addToHistory({
       type: "network",
@@ -10223,16 +9988,16 @@ var UnifiedDebugger = class _UnifiedDebugger {
       trigger: options.trigger,
       timestamp: Date.now()
     };
-    if (this.enabled && typeof console !== "undefined") {
-      console.group(`📋 Network preset applied: ${presetId}`);
-      console.log(`Quality: ${options.networkQuality}`);
-      console.log(`Trigger: ${options.trigger}`);
+    if (this.enabled) {
+      logger4.group(`📋 Network preset applied: ${presetId}`);
+      logger4.info(`Quality: ${options.networkQuality}`);
+      logger4.info(`Trigger: ${options.trigger}`);
       changes.forEach((change) => {
         const prev = typeof change.previousValue === "string" ? `"${change.previousValue}"` : String(change.previousValue);
         const next = typeof change.newValue === "string" ? `"${change.newValue}"` : String(change.newValue);
-        console.log(`  ${change.property}: ${prev} → ${next}`);
+        logger4.info(`  ${change.property}: ${prev} → ${next}`);
       });
-      console.groupEnd();
+      logger4.groupEnd();
     }
     const configChanges = changes.reduce(
       (acc, change) => {
@@ -10655,14 +10420,14 @@ var UnifiedDebugger = class _UnifiedDebugger {
    */
   enableNetworkDebug() {
     this.setEnabled(true);
-    console.log("🌐 Network configuration debugging enabled");
+    logger4.info("🌐 Network configuration debugging enabled");
   }
   /**
    * Disable network config debugging
    */
   disableNetworkDebug() {
     this.setEnabled(false);
-    console.log("🌐 Network configuration debugging disabled");
+    logger4.info("🌐 Network configuration debugging disabled");
   }
   /**
    * Clear network debug data
@@ -10671,8 +10436,8 @@ var UnifiedDebugger = class _UnifiedDebugger {
     this.networkOverrides.clear();
     this.history = [];
     this.lastPresetChange = void 0;
-    if (this.enabled && typeof console !== "undefined") {
-      console.log("🗑️ Network configuration debug data cleared");
+    if (this.enabled) {
+      logger4.info("🗑️ Network configuration debug data cleared");
     }
     this.getDebugFactory().emitNetworkDataCleared();
     eventManager.debug.emitNetworkDataCleared();
@@ -10693,7 +10458,7 @@ var UnifiedDebugger = class _UnifiedDebugger {
       duration: config.duration
     });
     if (this.enabled && config.trigger) {
-      console.log(`🌐 Network override triggered by ${config.trigger}:`, {
+      logger4.info(`🌐 Network override triggered by ${config.trigger}`, {
         property: config.property,
         value: config.overrideValue,
         reason: config.reason
@@ -11074,6 +10839,9 @@ function validateConfigUpdate(updates, options) {
   };
 }
 __name(validateConfigUpdate, "validateConfigUpdate");
+new ApiLogger({ service: LOGGER_SERVICES.CONFIG_QUEUE, transport: "console" });
+new ApiLogger({ service: LOGGER_SERVICES.QUEUE_ORCHESTRATOR, transport: "console" });
+var logger7 = new ApiLogger({ service: LOGGER_SERVICES.OPERATION_TRACKER, transport: "console" });
 var BaseOperationTracker = class {
   constructor(queueName, priorityDetector, sourceDetector) {
     this.queueName = queueName;
@@ -11138,7 +10906,10 @@ var BaseOperationTracker = class {
     try {
       await this.processor(op.data);
     } catch (error) {
-      console.error(`[${this.queueName}] Failed to process operation:`, error);
+      logger7.error("Failed to process operation", {
+        queueName: this.queueName,
+        error: error instanceof Error ? error.message : String(error)
+      });
       this.handleProcessingError(error, op.data);
     }
   }
@@ -11147,8 +10918,9 @@ var BaseOperationTracker = class {
    */
   handleProcessingError(error, operation) {
     if (isDev) {
-      console.debug(`[${this.queueName}] Error processing operation:`, {
-        error,
+      logger7.debug("Error processing operation", {
+        queueName: this.queueName,
+        error: error instanceof Error ? error.message : String(error),
         operation: operation.operation,
         event: operation.event
       });
@@ -11227,6 +10999,14 @@ function createDefaultSourceDetector() {
   };
 }
 __name(createDefaultSourceDetector, "createDefaultSourceDetector");
+new ApiLogger({
+  service: LOGGER_SERVICES.EVENT_QUEUE_MANAGER,
+  transport: "console"
+});
+var logger9 = new ApiLogger({
+  service: LOGGER_SERVICES.DEBUGGER_QUEUE_MANAGER,
+  transport: "console"
+});
 var DebuggerQueueManager = class _DebuggerQueueManager {
   static {
     __name(this, "DebuggerQueueManager");
@@ -11298,7 +11078,9 @@ var DebuggerQueueManager = class _DebuggerQueueManager {
       }
     } catch (error) {
       if (isDev) {
-        console.warn("[DebuggerQueue] Operation failed:", error);
+        logger9.warn("Operation failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
   }
@@ -11391,6 +11173,7 @@ var DebuggerQueueManager = class _DebuggerQueueManager {
   }
 };
 var MAX_RETRY_ATTEMPTS = 3;
+var logger10 = new ApiLogger({ service: LOGGER_SERVICES.OPERATION_TRACKER, transport: "console" });
 var OperationTracker = class _OperationTracker extends BaseOperationTracker {
   static {
     __name(this, "OperationTracker");
@@ -11454,7 +11237,12 @@ var OperationTracker = class _OperationTracker extends BaseOperationTracker {
   handleProcessingError(error, operation) {
     const retryCount = operation.retryCount ?? 0;
     if (operation.category === "debugging" && retryCount < MAX_RETRY_ATTEMPTS) {
-      console.warn(`[OperationTracker] Retrying critical operation (attempt ${retryCount + 1})`);
+      logger10.warn("Retrying critical operation", {
+        attempt: retryCount + 1,
+        maxAttempts: MAX_RETRY_ATTEMPTS,
+        operation: operation.operation,
+        category: operation.category
+      });
       this.getQueue().add({
         data: {
           ...operation,
@@ -11463,7 +11251,12 @@ var OperationTracker = class _OperationTracker extends BaseOperationTracker {
         priority: PRIORITY_LEVEL.CRITICAL
       });
     } else {
-      console.error(`[OperationTracker] Failed to process operation after retries:`, error);
+      logger10.error("Failed to process operation after retries", {
+        operation: operation.operation,
+        category: operation.category,
+        retryCount,
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
   }
   /**
@@ -11546,6 +11339,7 @@ var trackingQueue = {
     return [];
   }
 };
+var logger11 = new ApiLogger({ service: LOGGER_SERVICES.PUB_SUB, transport: "console" });
 var EVENT_CONSTANTS = {
   /** Minimum event segments for scoped events (namespace:scope:event) */
   MIN_SCOPED_SEGMENTS: 2,
@@ -11651,7 +11445,10 @@ function createEmitMethod(listeners, trackOperation) {
       try {
         callback(data);
       } catch (error) {
-        console.error(`Error in event listener for ${event}:`, error);
+        logger11.error("Event listener failed", {
+          event,
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     });
     listeners.forEach((callbacks, pattern) => {
@@ -11664,7 +11461,11 @@ function createEmitMethod(listeners, trackOperation) {
               const wildcardData = typeof data === "object" && data !== null ? { ...data, originalEvent: event.split(":").pop() } : { data, originalEvent: event.split(":").pop() };
               callback(wildcardData);
             } catch (error) {
-              console.error(`Error in wildcard listener for ${event}:`, error);
+              logger11.error("Wildcard listener failed", {
+                event,
+                pattern: prefix,
+                error: error instanceof Error ? error.message : String(error)
+              });
             }
           });
         }
@@ -11676,7 +11477,10 @@ function createEmitMethod(listeners, trackOperation) {
         try {
           callback(data);
         } catch (error) {
-          console.error(`Error in global wildcard listener for ${event}:`, error);
+          logger11.error("Global wildcard listener failed", {
+            event,
+            error: error instanceof Error ? error.message : String(error)
+          });
         }
       });
     }
@@ -11841,7 +11645,9 @@ function createEventEmitter() {
               result = handlerResult;
             }
           } catch (error) {
-            console.warn("Handler in chain failed:", error);
+            logger11.warn("Handler in chain failed", {
+              error: error instanceof Error ? error.message : String(error)
+            });
           }
         }
         return result;
@@ -11911,858 +11717,239 @@ var EventHelpers = {
     return namespace ? [`${namespace}:*`] : [];
   }, "getMatchingWildcards")
 };
+var API_ERROR_NAMESPACE = "api";
+var DEFAULT_TIMEOUT_MS2 = 3e4;
 var DEFAULT_SERVER_ERROR_STATUS2 = 500;
-var DEFAULT_CLIENT_ERROR_STATUS = 400;
-function getErrorEventType(errorEvent) {
-  return errorEvent.replace(/^errors:/, "");
-}
-__name(getErrorEventType, "getErrorEventType");
-var ANY_ERROR_HANDLER = "onAnyError";
-function mapHandlerNameToEventName(handlerName) {
-  if (handlerName === ANY_ERROR_HANDLER) {
-    return "*";
+var SCOPE_MAP = {
+  GLOBAL: "global",
+  CONFIG: "config",
+  CLIENT: "client",
+  REQUEST: "request",
+  TEMPORARY: "temporary"
+};
+function convertToApiEventScope(scope) {
+  const mapped = SCOPE_MAP[scope];
+  if (!mapped) {
+    throw new Error(`Invalid EventScope: ${scope}`);
   }
-  return handlerName.replace(/^on/, "").replace(/Error$/, "").replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
-}
-__name(mapHandlerNameToEventName, "mapHandlerNameToEventName");
-function registerScopedHandlers(scope, handlers, options = {}) {
-  Object.entries(handlers).forEach(([handlerName, handler]) => {
-    if (handler) {
-      const eventName = mapHandlerNameToEventName(handlerName);
-      const wrappedHandler = /* @__PURE__ */ __name((event) => {
-        const error = event?.data?.error ?? event;
-        try {
-          handler(error);
-        } catch (err) {
-          console.error("Error in error handler:", err);
-        }
-      }, "wrappedHandler");
-      eventManager.errors.addScopedHandler(HANDLER_SCOPES$1[scope], eventName, wrappedHandler, {
-        ...options,
-        originalHandler: handler
-      });
-    }
-  });
+  return mapped;
 }
-__name(registerScopedHandlers, "registerScopedHandlers");
-function retrieveScopedHandlers(scope) {
-  const scopeKey = HANDLER_SCOPES$1[scope];
-  const originalHandlersMap = eventManager.errors.getOriginalScopedHandlers(scopeKey);
-  const result = {};
-  originalHandlersMap.forEach((handlers, eventName) => {
-    let handlerName;
-    if (eventName === "*") {
-      handlerName = "onAnyError";
+__name(convertToApiEventScope, "convertToApiEventScope");
+var ApiPackageError = class extends ApiPackageError$1 {
+  static {
+    __name(this, "ApiPackageError");
+  }
+};
+var apiErrorEventFactory = {
+  addScopedHandler(scope, eventName, handler, options) {
+    const eventScope = convertToApiEventScope(scope);
+    eventManager.errors.addScopedHandler(eventScope, eventName, handler, options);
+  },
+  removeScopedHandler(scope, eventName, handler) {
+    const apiScope = convertToApiEventScope(scope);
+    if (!handler) {
+      eventManager.errors.removeAllScopedListeners(apiScope, eventName);
     } else {
-      const camelCase = eventName.replace(/-(.)/g, (_, c) => c.toUpperCase());
-      handlerName = `on${camelCase.charAt(0).toUpperCase() + camelCase.slice(1)}Error`;
+      eventManager.errors.removeScopedHandler(apiScope, eventName, handler);
     }
-    if (handlers.length > 0) {
-      const key = handlerName;
-      result[key] = handlers[0];
+  },
+  getOriginalScopedHandlers(scope) {
+    const eventScope = convertToApiEventScope(scope);
+    return eventManager.errors.getOriginalScopedHandlers(eventScope);
+  },
+  emit(eventName, data, options) {
+    if (options?.scopes && options.scopes.length > 0) {
+      options.scopes.forEach((scope) => {
+        const apiScope = convertToApiEventScope(scope);
+        const scopedEventKey = `${apiScope}:errors:${eventName}`;
+        eventManager.errors.emit(scopedEventKey, data);
+      });
+    } else {
+      eventManager.errors.emit(eventName, data);
     }
+  }
+};
+var isApiNamespaceRegistered = false;
+function ensureApiNamespaceRegistered() {
+  if (isApiNamespaceRegistered) {
+    return;
+  }
+  registerEventFactory(API_ERROR_NAMESPACE, apiErrorEventFactory);
+  ApiPackageError$1.configure({
+    namespace: API_ERROR_NAMESPACE,
+    eventFactory: apiErrorEventFactory
   });
-  return result;
+  isApiNamespaceRegistered = true;
 }
-__name(retrieveScopedHandlers, "retrieveScopedHandlers");
+__name(ensureApiNamespaceRegistered, "ensureApiNamespaceRegistered");
+ensureApiNamespaceRegistered();
 function registerErrorHandler(eventType, handler, options = {}) {
-  const { scope = "GLOBAL", strategy = "merge" } = options;
-  const type = typeof eventType === "string" && eventType.startsWith("errors:") ? getErrorEventType(eventType) : eventType;
-  const wrappedHandler = /* @__PURE__ */ __name((event) => {
-    const error = event?.data?.error ?? event;
-    try {
-      handler(error);
-    } catch (err) {
-      console.error("Error in error handler:", err);
-    }
-  }, "wrappedHandler");
-  return eventManager.errors.addScopedHandler(
-    HANDLER_SCOPES$1[scope],
-    type,
-    wrappedHandler,
-    { strategy, originalHandler: handler }
-  );
+  return registerErrorHandler$1(API_ERROR_NAMESPACE, eventType, handler, {
+    ...options,
+    eventFactory: apiErrorEventFactory
+  });
 }
 __name(registerErrorHandler, "registerErrorHandler");
+function registerErrorHandlers(handlers, options = {}) {
+  const { scope = "GLOBAL", ...rest } = options;
+  registerScopedHandlers(API_ERROR_NAMESPACE, scope, handlers, {
+    ...rest,
+    eventFactory: apiErrorEventFactory
+  });
+}
+__name(registerErrorHandlers, "registerErrorHandlers");
 function setErrorHandlers(handlers, scope = "GLOBAL") {
-  registerScopedHandlers(scope, handlers);
+  setErrorHandlers$1(API_ERROR_NAMESPACE, handlers, scope, apiErrorEventFactory);
 }
 __name(setErrorHandlers, "setErrorHandlers");
 function getErrorHandlers(scope = "GLOBAL") {
-  return retrieveScopedHandlers(scope);
+  return getErrorHandlers$1(API_ERROR_NAMESPACE, scope, apiErrorEventFactory);
 }
 __name(getErrorHandlers, "getErrorHandlers");
-function registerErrorHandlers(handlers, options = {}) {
-  const { scope = "GLOBAL", strategy = "merge" } = options;
-  registerScopedHandlers(scope, handlers, { strategy });
-}
-__name(registerErrorHandlers, "registerErrorHandlers");
 function unregisterErrorHandlers(eventTypes, options = {}) {
   const { scope = "GLOBAL" } = options;
-  const scopeKey = HANDLER_SCOPES$1[scope];
-  if (!eventTypes) {
-    eventManager.errors.clearScopedHandlers(scopeKey);
-  } else {
-    eventTypes.forEach((eventType) => {
-      const type = typeof eventType === "string" && eventType.startsWith("errors:") ? getErrorEventType(eventType) : eventType;
-      eventManager.errors.removeAllScopedListeners(scopeKey, type);
-    });
-  }
+  unregisterScopedHandlers(API_ERROR_NAMESPACE, scope, eventTypes, apiErrorEventFactory);
 }
 __name(unregisterErrorHandlers, "unregisterErrorHandlers");
 function clearErrorHandlers(options = {}) {
-  const { scopes = ["GLOBAL"] } = options;
-  scopes.forEach((scope) => {
-    const scopeKey = HANDLER_SCOPES$1[scope];
-    eventManager.errors.clearScopedHandlers(scopeKey);
+  clearErrorHandlers$1(API_ERROR_NAMESPACE, {
+    ...options,
+    eventFactory: apiErrorEventFactory
   });
 }
 __name(clearErrorHandlers, "clearErrorHandlers");
 function onceErrorHandler(eventType, handler, options = {}) {
-  const { scope = "GLOBAL" } = options;
-  const type = typeof eventType === "string" && eventType.startsWith("errors:") ? getErrorEventType(eventType) : eventType;
-  eventManager.errors.onceScoped(HANDLER_SCOPES$1[scope], type, (event) => {
-    const eventData = event;
-    const error = eventData?.data?.error ?? event;
-    handler(error);
+  registerOnceErrorHandler(API_ERROR_NAMESPACE, eventType, handler, {
+    ...options,
+    eventFactory: apiErrorEventFactory
   });
 }
 __name(onceErrorHandler, "onceErrorHandler");
-var ERROR_EMITTERS = {
-  network: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitNetworkError({
-      error,
-      url: error.context?.url,
-      method: error.context?.method,
-      status: error.statusCode,
-      retryable: error.context?.retryable
-    });
-  }, "network"),
-  validation: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitValidationError({
-      error,
-      field: error.context?.field,
-      value: error.context?.value,
-      constraints: error.context?.constraints
-    });
-  }, "validation"),
-  authentication: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitAuthenticationError(
-      error,
-      error.context?.realm,
-      error.context?.scheme
-    );
-  }, "authentication"),
-  rateLimit: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitRateLimitError({
-      error,
-      limit: error.context?.limit,
-      remaining: error.context?.remaining,
-      resetAt: error.context?.resetAt,
-      retryAfter: error.context?.retryAfter
-    });
-  }, "rateLimit"),
-  server: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitServerError({
-      error,
-      statusCode: error.statusCode ?? DEFAULT_SERVER_ERROR_STATUS2,
-      serverMessage: error.context?.serverMessage,
-      traceId: error.context?.traceId
-    });
-  }, "server"),
-  timeout: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitTimeoutError({
-      error,
-      timeout: error.context?.timeoutMs || error.context?.timeout || 0,
-      operation: error.context?.operation,
-      url: error.context?.url
-    });
-  }, "timeout"),
-  authorization: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitAuthorizationError({
-      error,
-      url: error.context?.url,
-      method: error.context?.method,
-      resource: void 0,
-      permission: void 0
-    });
-  }, "authorization"),
-  notFound: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitNotFoundError(error, error.context?.url, void 0);
-  }, "notFound"),
-  conflict: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitConflictError({
-      error,
-      conflictingResource: void 0,
-      currentValue: void 0,
-      attemptedValue: void 0
-    });
-  }, "conflict"),
-  client: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitClientError({
-      error,
-      status: error.statusCode ?? DEFAULT_CLIENT_ERROR_STATUS,
-      url: error.context?.url,
-      method: error.context?.method
-    });
-  }, "client"),
-  externalService: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitExternalServiceError({
-      error,
-      service: void 0,
-      endpoint: error.context?.url,
-      timeout: error.context?.timeout
-    });
-  }, "externalService"),
-  cache: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitCacheError(
-      error,
-      error.context?.operation,
-      error.context && "cacheKey" in error.context ? error.context.cacheKey : "unknown"
-    );
-  }, "cache"),
-  headers: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitHeadersError(error, void 0, error.context?.operation);
-  }, "headers"),
-  retry: /* @__PURE__ */ __name((error) => {
-    eventManager.errors.emitRetryError({
-      error,
-      attempts: void 0,
-      maxAttempts: void 0,
-      lastError: error.context?.originalError
-    });
-  }, "retry")
-};
-function getCategoryKey(category) {
-  if (!category) {
-    return "unknown";
-  }
-  return ERROR_CATEGORY_TO_EMITTER_KEY[category] || category.toLowerCase();
-}
-__name(getCategoryKey, "getCategoryKey");
-async function emitErrorEvent(error) {
-  const categoryKey = getCategoryKey(error.category);
-  const emitter = ERROR_EMITTERS[categoryKey];
-  if (emitter) {
-    emitter(error);
-  } else {
-    eventManager.errors.emitGenericError(error);
-  }
-}
-__name(emitErrorEvent, "emitErrorEvent");
-
-// src/api/utils/generation/id-generator.ts
-var ID_CONSTANTS = {
-  RANDOM_START_INDEX: 2,
-  DEFAULT_RANDOM_LENGTH: 8,
-  MAX_PREFIX_LENGTH: 10,
-  DEFAULT_RADIX: 36,
-  TWO_PARTS: 2
-};
-var DEFAULT_OPTIONS = {
-  prefix: "",
-  suffix: "",
-  useTimestamp: false,
-  separator: "_",
-  includeRandom: true,
-  radix: ID_CONSTANTS.DEFAULT_RADIX,
-  randomLength: ID_CONSTANTS.DEFAULT_RANDOM_LENGTH
-};
-function generateBaseId(options = {}) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const components = [];
-  if (opts.prefix) {
-    components.push(opts.prefix);
-  }
-  if (opts.useTimestamp) {
-    const timestamp = Date.now().toString(opts.radix);
-    components.push(timestamp);
-    if (opts.includeRandom) {
-      const random = Math.random().toString(opts.radix).slice(
-        ID_CONSTANTS.RANDOM_START_INDEX,
-        ID_CONSTANTS.RANDOM_START_INDEX + opts.randomLength
-      );
-      components.push(random);
-    }
-  } else {
-    components.push(generateUUID());
-  }
-  if (opts.suffix) {
-    components.push(opts.suffix);
-  }
-  return components.join(opts.separator);
-}
-__name(generateBaseId, "generateBaseId");
-function generateContextualId(context, options = {}) {
-  const baseId = generateBaseId(options);
-  const contextParts = [];
-  for (const [, value] of Object.entries(context)) {
-    if (value !== void 0) {
-      contextParts.push(String(value));
-    }
-  }
-  if (contextParts.length > 0) {
-    return `${contextParts.join(":")}:${baseId}`;
-  }
-  return baseId;
-}
-__name(generateContextualId, "generateContextualId");
-function extractFromLastSeparator(id, separator) {
-  const lastIndex = id.lastIndexOf(separator);
-  return lastIndex !== -1 ? id.substring(lastIndex + 1) : null;
-}
-__name(extractFromLastSeparator, "extractFromLastSeparator");
-function extractFromFirstSeparator(id, separator) {
-  const firstIndex = id.indexOf(separator);
-  return firstIndex !== -1 ? id.substring(0, firstIndex) : null;
-}
-__name(extractFromFirstSeparator, "extractFromFirstSeparator");
-function extractAfterPrefix(id, separator) {
-  const firstIndex = id.indexOf(separator);
-  if (firstIndex === -1 || separator !== "_") {
-    return null;
-  }
-  const prefix = id.substring(0, firstIndex);
-  const isShortAlphabeticPrefix = prefix.length <= ID_CONSTANTS.MAX_PREFIX_LENGTH && /^[a-z]+$/i.test(prefix);
-  return isShortAlphabeticPrefix ? id.substring(firstIndex + 1) : null;
-}
-__name(extractAfterPrefix, "extractAfterPrefix");
-function extractWithUnderscoreSeparator(id, separator) {
-  const afterPrefix = extractAfterPrefix(id, separator);
-  if (afterPrefix) {
-    return afterPrefix;
-  }
-  return extractFromLastSeparator(id, separator);
+function emitNetworkErrorEvent(error, context) {
+  eventManager.errors.emitNetworkError({
+    error,
+    url: context?.url,
+    method: context?.method,
+    status: error.statusCode,
+    retryable: error.retryable
+  });
 }
-__name(extractWithUnderscoreSeparator, "extractWithUnderscoreSeparator");
-function extractBySeparatorType(id, separator) {
-  if (separator === ":") {
-    return extractFromLastSeparator(id, separator);
-  }
-  return extractWithUnderscoreSeparator(id, separator);
+__name(emitNetworkErrorEvent, "emitNetworkErrorEvent");
+function emitTimeoutErrorEvent(error, context) {
+  eventManager.errors.emitTimeoutError({
+    error,
+    timeout: context?.timeout ?? context?.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+    url: context?.url,
+    operation: context?.operation
+  });
 }
-__name(extractBySeparatorType, "extractBySeparatorType");
-function extractBaseId(id, options = {}) {
-  const { separator = ":", extractLast = true } = options;
-  if (!extractLast) {
-    return extractFromFirstSeparator(id, separator) ?? id;
-  }
-  return extractBySeparatorType(id, separator) ?? id;
+__name(emitTimeoutErrorEvent, "emitTimeoutErrorEvent");
+function emitServerErrorEvent(error, context) {
+  eventManager.errors.emitServerError({
+    error,
+    statusCode: error.statusCode ?? DEFAULT_SERVER_ERROR_STATUS2,
+    serverMessage: context?.serverMessage,
+    traceId: context?.traceId
+  });
 }
-__name(extractBaseId, "extractBaseId");
-function isUuidPattern(id) {
-  const uuidRegex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
-  return uuidRegex.test(id);
+__name(emitServerErrorEvent, "emitServerErrorEvent");
+function emitAuthorizationErrorEvent(error, context) {
+  eventManager.errors.emitAuthorizationError({
+    error,
+    url: context?.url,
+    method: context?.method,
+    resource: context?.resource,
+    permission: context?.permission
+  });
 }
-__name(isUuidPattern, "isUuidPattern");
-function isTimestampPattern(id) {
-  const timestampRegex = /^[a-z]+_[0-9a-z]+_[0-9a-z]+$/i;
-  return timestampRegex.test(id);
+__name(emitAuthorizationErrorEvent, "emitAuthorizationErrorEvent");
+function emitRateLimitErrorEvent(error, context) {
+  eventManager.errors.emitRateLimitError({
+    error,
+    limit: context?.limit,
+    remaining: context?.remaining,
+    resetAt: context?.resetAt,
+    retryAfter: context?.retryAfter
+  });
 }
-__name(isTimestampPattern, "isTimestampPattern");
-function isPrefixedPattern(id) {
-  const prefixedRegex = /^[a-z]+_[0-9a-z-]+$/i;
-  return prefixedRegex.test(id);
+__name(emitRateLimitErrorEvent, "emitRateLimitErrorEvent");
+function emitValidationErrorEvent(error) {
+  eventManager.errors.emitValidationError({
+    error,
+    field: void 0,
+    value: void 0,
+    constraints: void 0
+  });
 }
-__name(isPrefixedPattern, "isPrefixedPattern");
-function isValidFallbackPattern(id) {
-  const fallbackRegex = /^[0-9a-z][\w-]*$/i;
-  if (!fallbackRegex.test(id)) {
-    return false;
-  }
-  const rejectList = ["invalid", "invalid-uuid"];
-  return !rejectList.includes(id);
+__name(emitValidationErrorEvent, "emitValidationErrorEvent");
+function emitAuthenticationErrorEvent(error, context) {
+  eventManager.errors.emitAuthenticationError(
+    error,
+    context?.realm,
+    context?.scheme
+  );
 }
-__name(isValidFallbackPattern, "isValidFallbackPattern");
-function checkPatterns(id, patterns) {
-  for (const { check, allowed } of patterns) {
-    if (check(id)) {
-      return allowed;
-    }
+__name(emitAuthenticationErrorEvent, "emitAuthenticationErrorEvent");
+function emitNotFoundErrorEvent(error, context) {
+  eventManager.errors.emitNotFoundError(error, context?.url);
+}
+__name(emitNotFoundErrorEvent, "emitNotFoundErrorEvent");
+var ERROR_CATEGORY_HANDLERS = {
+  network: emitNetworkErrorEvent,
+  validation: emitValidationErrorEvent,
+  authentication: emitAuthenticationErrorEvent,
+  authorization: emitAuthorizationErrorEvent,
+  "rate.limit": emitRateLimitErrorEvent,
+  timeout: emitTimeoutErrorEvent,
+  "not.found": emitNotFoundErrorEvent,
+  server: emitServerErrorEvent
+};
+function emitErrorEvent(error) {
+  const context = error.context;
+  const category = error.category?.toLowerCase();
+  const handler = category ? ERROR_CATEGORY_HANDLERS[category] : void 0;
+  if (handler) {
+    handler(error, context);
+  } else {
+    eventManager.errors.emitGenericError(error);
   }
-  return null;
-}
-__name(checkPatterns, "checkPatterns");
-function isAnyPatternAllowed(options) {
-  return !!(options.allowUuid ?? options.allowTimestamp ?? options.allowPrefix);
 }
-__name(isAnyPatternAllowed, "isAnyPatternAllowed");
-function checkIdPatterns(id, options) {
-  const patterns = [
-    { check: isUuidPattern, allowed: options.allowUuid },
-    { check: isTimestampPattern, allowed: options.allowTimestamp },
-    { check: isPrefixedPattern, allowed: options.allowPrefix }
-  ];
-  return checkPatterns(id, patterns);
-}
-__name(checkIdPatterns, "checkIdPatterns");
-function validateIdWithPatterns(id, options) {
-  const patternResult = checkIdPatterns(id, options);
-  if (patternResult !== null) {
-    return patternResult;
-  }
-  return isAnyPatternAllowed(options) && isValidFallbackPattern(id);
+__name(emitErrorEvent, "emitErrorEvent");
+
+// src/api/polling/utils.ts
+function isPollingActive(config) {
+  return (config.interval ?? 0) > 0;
 }
-__name(validateIdWithPatterns, "validateIdWithPatterns");
-function isValidId(id, options = {}) {
-  const { allowUuid = true, allowTimestamp = true, allowPrefix = true, minLength = 5 } = options;
-  if (id.length < minLength) {
-    return false;
+__name(isPollingActive, "isPollingActive");
+function calculatePollingDuration(config) {
+  if (!config.interval || !config.maxAttempts || config.maxAttempts <= 0) {
+    return null;
   }
-  return validateIdWithPatterns(id, { allowUuid, allowTimestamp, allowPrefix });
+  const intervals = config.interval * config.maxAttempts;
+  const delays = (config.delay ?? 0) * config.maxAttempts;
+  return intervals + delays;
 }
-__name(isValidId, "isValidId");
-function parseId(id, options = {}) {
-  const { separator = "_" } = options;
-  if (id.includes(":")) {
-    const lastColonIndex = id.lastIndexOf(":");
+__name(calculatePollingDuration, "calculatePollingDuration");
+function getSSRSafePollingConfig(config) {
+  if (!isBrowser()) {
     return {
-      context: id.substring(0, lastColonIndex),
-      core: id.substring(lastColonIndex + 1),
-      full: id
+      ...config,
+      interval: 0,
+      maxAttempts: 1
     };
   }
-  const parts = id.split(separator);
-  if (parts.length === 1) {
-    return { core: id, full: id };
-  }
-  if (parts.length === ID_CONSTANTS.TWO_PARTS) {
-    if (parts[0].length <= ID_CONSTANTS.MAX_PREFIX_LENGTH && /^[a-z]+$/i.test(parts[0])) {
-      return { prefix: parts[0], core: parts[1], full: id };
-    }
-    return { core: parts[0], suffix: parts[1], full: id };
-  }
-  return {
-    prefix: parts[0],
-    core: parts.slice(1, -1).join(separator),
-    suffix: parts[parts.length - 1],
-    full: id
-  };
+  return config;
 }
-__name(parseId, "parseId");
-function createIdGenerator(defaultOptions = {}) {
-  return (options) => {
-    return generateBaseId({ ...defaultOptions, ...options });
-  };
-}
-__name(createIdGenerator, "createIdGenerator");
-var correlationGenerators = /* @__PURE__ */ new Map();
-function getCorrelationGenerator(type) {
-  if (!correlationGenerators.has(type)) {
-    correlationGenerators.set(
-      type,
-      createIdGenerator({
-        prefix: type,
-        useTimestamp: true,
-        includeRandom: true,
-        radix: 36,
-        randomLength: 8
-      })
-    );
-  }
-  return correlationGenerators.get(type);
-}
-__name(getCorrelationGenerator, "getCorrelationGenerator");
-function generateCorrelationId(type = CORRELATION_TYPE.GENERIC, options) {
-  const generator = getCorrelationGenerator(type);
-  return generator(options);
-}
-__name(generateCorrelationId, "generateCorrelationId");
-function generateContextualCorrelationId(context, type = CORRELATION_TYPE.GENERIC, options) {
-  return generateContextualId(context, {
-    prefix: type,
-    useTimestamp: true,
-    includeRandom: true,
-    radix: 36,
-    randomLength: 8,
-    ...options
-  });
-}
-__name(generateContextualCorrelationId, "generateContextualCorrelationId");
-function generateNetworkCorrelationId(options) {
-  return generateCorrelationId(CORRELATION_TYPE.NETWORK, options);
-}
-__name(generateNetworkCorrelationId, "generateNetworkCorrelationId");
-function generateApiCorrelationId(options) {
-  return generateCorrelationId(CORRELATION_TYPE.API, options);
-}
-__name(generateApiCorrelationId, "generateApiCorrelationId");
-function generateSessionCorrelationId(options) {
-  return generateCorrelationId(CORRELATION_TYPE.SESSION, options);
-}
-__name(generateSessionCorrelationId, "generateSessionCorrelationId");
-function generateTraceCorrelationId(options) {
-  return generateCorrelationId(CORRELATION_TYPE.TRACE, options);
-}
-__name(generateTraceCorrelationId, "generateTraceCorrelationId");
-function extractBaseCorrelationId(contextualId) {
-  let id = extractBaseId(contextualId, { separator: ":", extractLast: true });
-  const prefixes = Object.values(CORRELATION_TYPE);
-  for (const prefix of prefixes) {
-    if (id.startsWith(`${prefix}_`)) {
-      id = id.substring(prefix.length + 1);
-      break;
-    }
-  }
-  return id;
-}
-__name(extractBaseCorrelationId, "extractBaseCorrelationId");
-function extractCorrelationType(id) {
-  let idToCheck = id;
-  if (id.includes(":")) {
-    const parts = id.split(":");
-    idToCheck = parts[parts.length - 1];
-  }
-  const parsed = parseId(idToCheck, { separator: "_" });
-  if (parsed.prefix) {
-    const types = Object.values(CORRELATION_TYPE);
-    if (types.includes(parsed.prefix)) {
-      return parsed.prefix;
-    }
-  }
-  return void 0;
-}
-__name(extractCorrelationType, "extractCorrelationType");
-function isValidCorrelationId(id) {
-  let idToValidate = id;
-  if (id.includes(":")) {
-    const parts = id.split(":");
-    idToValidate = parts[parts.length - 1];
-  }
-  return isValidId(idToValidate, {
-    allowUuid: true,
-    allowTimestamp: true,
-    allowPrefix: true,
-    minLength: 5
-  });
-}
-__name(isValidCorrelationId, "isValidCorrelationId");
-function createCorrelationIdGenerator(type = CORRELATION_TYPE.GENERIC, defaultOptions = {}) {
-  return createIdGenerator({
-    prefix: type,
-    useTimestamp: true,
-    includeRandom: true,
-    radix: 36,
-    randomLength: 8,
-    ...defaultOptions
-  });
-}
-__name(createCorrelationIdGenerator, "createCorrelationIdGenerator");
-function linkCorrelationIds(...ids) {
-  return ids.join("->");
-}
-__name(linkCorrelationIds, "linkCorrelationIds");
-function extractLinkedCorrelationIds(linkedId) {
-  return linkedId.split("->");
-}
-__name(extractLinkedCorrelationIds, "extractLinkedCorrelationIds");
-
-// src/api/errors/ApiPackageError.ts
-var ApiPackageError = class _ApiPackageError extends Error {
-  static {
-    __name(this, "ApiPackageError");
-  }
-  statusCode;
-  errorCode;
-  message;
-  errors;
-  correlationId;
-  timestamp;
-  // Additional properties beyond ErrorResponse
-  responseError;
-  category;
-  cause;
-  context;
-  // Store the original request/response data from fetchff (not Web API types)
-  requestConfig;
-  responseData;
-  details;
-  originalError;
-  metadata;
-  /**
-   * Getter for code property (alias for errorCode)
-   * Provides compatibility with standard error patterns
-   */
-  get code() {
-    return this.errorCode;
-  }
-  constructor(message, statusCode, errorCode = API_ERROR_CODES.UNKNOWN_ERROR, options) {
-    super(message);
-    this.name = "ApiPackageError";
-    this.message = message;
-    this.errorCode = errorCode;
-    this.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    this.statusCode = this.resolveStatusCode(statusCode, errorCode);
-    if (options) {
-      this.errors = options.errors;
-      this.correlationId = options.correlationId ?? generateApiCorrelationId();
-      this.responseError = options.responseError;
-      this.cause = options.cause;
-      this.context = options.context;
-      this.details = options.errors;
-      this.originalError = options.cause;
-      if (options.responseError) {
-        this.requestConfig = options.responseError.request;
-        this.responseData = options.responseError.response;
-      }
-    } else {
-      this.correlationId = generateApiCorrelationId();
-    }
-    this.category = this.categorizeError();
-    Object.setPrototypeOf(this, _ApiPackageError.prototype);
-    this.emitEvent();
-  }
-  /**
-   * Resolves the status code from the provided value or error definitions
-   */
-  resolveStatusCode(statusCode, errorCode) {
-    if (statusCode !== void 0) {
-      return statusCode;
-    }
-    const definition = ERROR_DEFINITIONS$1[errorCode];
-    if (definition?.status !== void 0) {
-      return definition.status;
-    }
-    return HTTP_STATUS.INTERNAL_SERVER_ERROR;
-  }
-  /**
-   * Emit error event for this error
-   * Can be called with a specific client context or uses global handlers
-   */
-  emitEvent() {
-    void Promise.resolve().then(() => emitErrorEvent(this)).catch(() => {
-    });
-  }
-  /**
-   * Creates an ApiPackageError from a fetchff ResponseError
-   */
-  static fromResponseError(responseError, config, clientContext) {
-    const statusCode = responseError.status ?? HTTP_STATUS.INTERNAL_SERVER_ERROR;
-    const message = responseError.message ?? "An error occurred";
-    const code = this.determineErrorCode(responseError);
-    return new _ApiPackageError(message, statusCode, code, {
-      responseError,
-      cause: responseError,
-      clientContext,
-      context: {
-        url: config?.url ?? "",
-        method: config?.method ?? "GET"
-      }
-    });
-  }
-  /**
-   * Creates an ApiPackageError from a standard Error
-   */
-  static fromError(error, statusCode, errorCode = API_ERROR_CODES.UNKNOWN_ERROR, context) {
-    if (error instanceof _ApiPackageError) {
-      return error;
-    }
-    const { code, status } = this.classifyError(error, errorCode, statusCode);
-    return new _ApiPackageError(error.message, status, code, {
-      cause: error,
-      clientContext: context
-    });
-  }
-  /**
-   * Classifies an error and returns appropriate code and status
-   */
-  static classifyError(error, defaultCode, defaultStatus) {
-    if (error.name === "NetworkError" || error.message.includes("network")) {
-      return { code: API_ERROR_CODES.NETWORK_ERROR, status: 0 };
-    }
-    if (error.name === "TimeoutError" || error.message.includes("timeout")) {
-      return { code: API_ERROR_CODES.REQUEST_TIMEOUT, status: HTTP_STATUS.REQUEST_TIMEOUT };
-    }
-    if (error.name === "AbortError") {
-      return { code: API_ERROR_CODES.REQUEST_ABORTED, status: 0 };
-    }
-    return { code: defaultCode, status: defaultStatus };
-  }
-  /**
-   * Determines appropriate error code from ResponseError by looking up status in ERROR_DEFINITIONS
-   */
-  static determineErrorCode(error) {
-    if ("isCancelled" in error && error.isCancelled) {
-      return API_ERROR_CODES.CLIENT_CANCELLED;
-    }
-    const status = error.status ?? 0;
-    const errorCode = getErrorCodeByStatus(status);
-    if (errorCode) {
-      return errorCode;
-    }
-    return this.getGenericErrorCode(status);
-  }
-  /**
-   * Gets a generic error code based on HTTP status range
-   */
-  static getGenericErrorCode(status) {
-    if (status === 0) {
-      return API_ERROR_CODES.NETWORK_ERROR;
-    }
-    if (status >= HTTP_STATUS.BAD_REQUEST && status < HTTP_STATUS.INTERNAL_SERVER_ERROR) {
-      return API_ERROR_CODES.CLIENT_ERROR;
-    }
-    if (status >= HTTP_STATUS.INTERNAL_SERVER_ERROR) {
-      return API_ERROR_CODES.SERVER_ERROR;
-    }
-    return API_ERROR_CODES.UNKNOWN_ERROR;
-  }
-  /**
-   * Gets the error category from ERROR_DEFINITIONS
-   */
-  categorizeError() {
-    const definition = ERROR_DEFINITIONS$1[this.errorCode];
-    return definition?.category ?? ERROR_CATEGORY.Unknown;
-  }
-  /**
-   * Checks if this is a specific category of error
-   */
-  isAuthError() {
-    return this.category === ERROR_CATEGORY.Authentication || this.category === ERROR_CATEGORY.Authorization;
-  }
-  isValidationError() {
-    return this.category === ERROR_CATEGORY.Validation;
-  }
-  isNetworkError() {
-    return this.category === ERROR_CATEGORY.Network;
-  }
-  isServerError() {
-    return this.category === ERROR_CATEGORY.Server;
-  }
-  isClientError() {
-    return this.statusCode >= HTTP_STATUS.BAD_REQUEST && this.statusCode < HTTP_STATUS.INTERNAL_SERVER_ERROR;
-  }
-  isRetryable() {
-    return this.category === ERROR_CATEGORY.Network || this.category === ERROR_CATEGORY.Server || this.category === ERROR_CATEGORY.Timeout || this.statusCode === HTTP_STATUS.TOO_MANY_REQUESTS || // Rate limit
-    this.statusCode >= HTTP_STATUS.INTERNAL_SERVER_ERROR;
-  }
-  /**
-   * Converts to ErrorResponse format (as per task-020)
-   */
-  toJSON() {
-    return {
-      statusCode: this.statusCode,
-      errorCode: this.errorCode,
-      message: this.message,
-      errors: this.errors ?? [],
-      correlationId: this.correlationId,
-      timestamp: this.timestamp
-    };
-  }
-  /**
-   * Creates a string representation
-   */
-  toString() {
-    return `[${this.errorCode}] ${this.message} (Status: ${this.statusCode}, Category: ${this.category})`;
-  }
-  /**
-   * Check if error is an ApiPackageError
-   */
-  static isApiPackageError(error) {
-    return error instanceof _ApiPackageError;
-  }
-  /**
-   * Get user-friendly message for display
-   */
-  getUserMessage() {
-    const customMessage = this.getCustomUserMessage();
-    if (customMessage) {
-      return customMessage;
-    }
-    return this.getDefaultUserMessage();
-  }
-  /**
-   * Gets custom user message from error details if available
-   */
-  getCustomUserMessage() {
-    if (!this.details?.length) {
-      return null;
-    }
-    const userMessage = this.details.find((d) => d.field === "userMessage");
-    return userMessage ? userMessage.message : null;
-  }
-  /**
-   * Gets default user message based on error category
-   */
-  getDefaultUserMessage() {
-    const messages = {
-      [ERROR_CATEGORY.Authentication]: "Authentication failed. Please check your credentials.",
-      [ERROR_CATEGORY.Authorization]: "You do not have permission to perform this action.",
-      [ERROR_CATEGORY.Validation]: "Please check your input and try again.",
-      [ERROR_CATEGORY.NotFound]: "The requested resource was not found.",
-      [ERROR_CATEGORY.RateLimit]: "Too many requests. Please try again later.",
-      [ERROR_CATEGORY.Network]: "Network error. Please check your connection.",
-      [ERROR_CATEGORY.Timeout]: "The request timed out. Please try again.",
-      [ERROR_CATEGORY.Server]: "Server error. Please try again later.",
-      [ERROR_CATEGORY.Client]: "Client error. Please check your request.",
-      [ERROR_CATEGORY.Blockchain]: "Blockchain error. Please try again later.",
-      [ERROR_CATEGORY.ExternalService]: "External service error. Please try again later.",
-      [ERROR_CATEGORY.Conflict]: "Conflict detected. Please resolve and try again.",
-      [ERROR_CATEGORY.Cache]: "Cache error. Please try again.",
-      [ERROR_CATEGORY.Headers]: "Headers error. Please check your request headers.",
-      [ERROR_CATEGORY.Retry]: "Retry limit exceeded. Please try again later.",
-      [ERROR_CATEGORY.Strategy]: "Strategy error. Invalid configuration.",
-      [ERROR_CATEGORY.Regional]: "Regional configuration error. Please check your region settings.",
-      [ERROR_CATEGORY.Unknown]: "An unexpected error occurred. Please try again later."
-    };
-    return messages[this.category] ?? "An unexpected error occurred. Please try again later.";
-  }
-};
-
-// src/api/errors/error-codes.ts
-var API_ERROR_CODES6 = {
-  // Client Configuration Errors
-  CLIENT_INITIALIZATION_FAILED: "CLIENT_INITIALIZATION_FAILED",
-  // Header Errors
-  HEADERS_ENRICHMENT_FAILED: "HEADERS_ENRICHMENT_FAILED",
-  // Polling Errors
-  POLLING_TIMEOUT: "POLLING_TIMEOUT",
-  POLLING_CANCELLED: "POLLING_CANCELLED"};
-var PACKAGE_STATUS_CODES3 = {
-  // Internal system errors
-  INITIALIZATION_FAILED: 1040,
-  OPERATION_FAILED: 1041};
-
-// src/api/errors/types-constants.ts
-var OPERATIONS3 = {
-  ENRICHMENT: "enrichment",
-  INITIALIZATION: "initialization",
-  POLLING: "polling"};
-
-// src/api/polling/utils.ts
-function isPollingActive(config) {
-  return (config.interval ?? 0) > 0;
-}
-__name(isPollingActive, "isPollingActive");
-function calculatePollingDuration(config) {
-  if (!config.interval || !config.maxAttempts || config.maxAttempts <= 0) {
-    return null;
-  }
-  const intervals = config.interval * config.maxAttempts;
-  const delays = (config.delay ?? 0) * config.maxAttempts;
-  return intervals + delays;
-}
-__name(calculatePollingDuration, "calculatePollingDuration");
-function getSSRSafePollingConfig(config) {
-  if (!isBrowser()) {
-    return {
-      ...config,
-      interval: 0,
-      maxAttempts: 1
-    };
-  }
-  return config;
-}
-__name(getSSRSafePollingConfig, "getSSRSafePollingConfig");
-function createProgressivePolling(options = {}) {
-  const { baseInterval = 1e3, maxInterval = 3e4, multiplier = 1.5 } = options;
-  return {
-    interval: baseInterval,
-    delay: 0,
-    maxAttempts: -1,
-    shouldStop: /* @__PURE__ */ __name((_response, attempt) => {
-      return false;
-    }, "shouldStop")
+__name(getSSRSafePollingConfig, "getSSRSafePollingConfig");
+function createProgressivePolling(options = {}) {
+  const { baseInterval = 1e3, maxInterval = 3e4, multiplier = 1.5 } = options;
+  return {
+    interval: baseInterval,
+    delay: 0,
+    maxAttempts: -1,
+    shouldStop: /* @__PURE__ */ __name((_response, attempt) => {
+      return false;
+    }, "shouldStop")
   };
 }
 __name(createProgressivePolling, "createProgressivePolling");
@@ -12779,11 +11966,11 @@ function createConditionalPolling(options) {
       if (options.errorCondition?.(response)) {
         new ApiPackageError(
           "polling.error_condition",
-          PACKAGE_STATUS_CODES3.OPERATION_FAILED,
-          API_ERROR_CODES6.POLLING_CANCELLED,
+          INTERNAL_STATUS_CODES.OPERATION_FAILED,
+          API_ERROR_CODES$1.POLLING_CANCELLED,
           {
             context: {
-              operation: OPERATIONS3.POLLING,
+              operation: COMMON_OPERATIONS.POLLING,
               reason: "Error condition met",
               i18n: {
                 reason: "error_condition"
@@ -12798,11 +11985,11 @@ function createConditionalPolling(options) {
         if (elapsed >= options.timeoutMs) {
           new ApiPackageError(
             "polling.timeout",
-            PACKAGE_STATUS_CODES3.OPERATION_FAILED,
-            API_ERROR_CODES6.POLLING_TIMEOUT,
+            INTERNAL_STATUS_CODES.OPERATION_FAILED,
+            API_ERROR_CODES$1.POLLING_TIMEOUT,
             {
               context: {
-                operation: OPERATIONS3.POLLING,
+                operation: COMMON_OPERATIONS.POLLING,
                 timeoutMs: options.timeoutMs,
                 elapsed,
                 i18n: {
@@ -13969,7 +13156,7 @@ function filterToFetchffProperties(config) {
     maxPollingAttempts,
     shouldStopPolling,
     fetcher,
-    logger,
+    logger: logger19,
     // Cache properties
     cacheTime,
     staleTime,
@@ -14062,7 +13249,7 @@ function filterToFetchffProperties(config) {
   if (shouldStopPolling !== void 0 && shouldStopPolling !== null)
     fetchffConfig.shouldStopPolling = shouldStopPolling;
   if (fetcher !== void 0 && fetcher !== null) fetchffConfig.fetcher = fetcher;
-  if (logger !== void 0 && logger !== null) fetchffConfig.logger = logger;
+  if (logger19 !== void 0 && logger19 !== null) fetchffConfig.logger = logger19;
   if (cacheTime !== void 0) fetchffConfig.cacheTime = cacheTime;
   if (staleTime !== void 0) fetchffConfig.staleTime = staleTime;
   if (skipCache !== void 0) fetchffConfig.skipCache = skipCache;
@@ -14439,11 +13626,33 @@ function trackGlobalConfigUpdate(params) {
   });
 }
 __name(trackGlobalConfigUpdate, "trackGlobalConfigUpdate");
+function handleGlobalErrorSystemConfig(errorConfig) {
+  const alreadyInitialized = isErrorSystemInitialized();
+  if (alreadyInitialized) {
+    if (errorConfig.locale) {
+      setErrorLocale(errorConfig.locale);
+    }
+    if (errorConfig.additionalCatalogs) {
+      Object.entries(errorConfig.additionalCatalogs).forEach(([locale, catalog]) => {
+        addMessageCatalog(locale, catalog, true);
+      });
+    }
+  } else {
+    initializeErrorSystem({
+      defaultLocale: errorConfig.locale,
+      additionalCatalogs: errorConfig.additionalCatalogs
+    });
+  }
+}
+__name(handleGlobalErrorSystemConfig, "handleGlobalErrorSystemConfig");
 function setGlobalConfig(config) {
   try {
     const startTime = Date.now();
     const currentConfig = globalApiConfig;
     validateConfigObject(config);
+    if (config.errors) {
+      handleGlobalErrorSystemConfig(config.errors);
+    }
     const { merged: mergedConfig, entries: configEntries } = mergeGlobalConfig(
       currentConfig,
       config
@@ -14504,7 +13713,7 @@ function resetGlobalConfig() {
     activeScopes: eventManager.getActiveScopes?.() ?? []
   };
   globalApiConfig = {};
-  eventManager.setEventScopes([...EVENT_SCOPES]);
+  eventManager.setEventScopes([...EVENT_SCOPES$1]);
   const afterEventState = {
     totalEvents: eventManager.getEventStats?.()?.totalEvents ?? 0,
     totalListeners: eventManager.getEventStats?.()?.totalListeners ?? 0,
@@ -14618,10 +13827,6 @@ var campaignEndpoints = {
   createCampaign: {
     url: "/campaigns",
     method: "POST"
-    // Example: Override global settings for this endpoint
-    // cancellable: true,        // Cancel previous create requests
-    // timeout: 60000,           // Longer timeout for creation
-    // retry: { attempts: 1 }    // Don't retry POST requests
   },
   updateCampaign: {
     url: "/campaigns/:id",
@@ -14634,9 +13839,6 @@ var campaignEndpoints = {
   getCampaignStats: {
     url: "/campaigns/:id/stats",
     method: "GET"
-    // Example: Cache stats for longer
-    // cacheTime: 600,          // Cache for 10 minutes
-    // staleTime: 1200          // Consider stale after 20 minutes
   },
   getCampaignParticipants: {
     url: "/campaigns/:id/participants",
@@ -14714,13 +13916,263 @@ var pollingEndpoints = {
   }
 };
 
+// src/api/endpoints/infobip.ts
+var infobipEmailEndpoints = {
+  // ========== Outbound Email ==========
+  /**
+   * POST /email/3/send - Send email (simple, with attachment support)
+   * Multipart/form-data for attachments
+   */
+  sendEmail: {
+    url: "/email/3/send",
+    method: "POST"
+  },
+  /**
+   * POST /email/4/send - Send advanced email
+   * JSON payload with full customization
+   */
+  sendAdvancedEmail: {
+    url: "/email/4/messages",
+    method: "POST"
+  },
+  /**
+   * POST /email/3/mime - Send email via MIME format
+   */
+  sendEmailMime: {
+    url: "/email/3/mime",
+    method: "POST"
+  },
+  // ========== Email Validation ==========
+  /**
+   * POST /email/2/validation - Validate single email address
+   */
+  validateEmail: {
+    url: "/email/2/validation",
+    method: "POST"
+  },
+  /**
+   * POST /email/2/validations - Bulk validate email addresses
+   * Returns 202 with validation request ID
+   */
+  bulkValidateEmails: {
+    url: "/email/2/validations",
+    method: "POST"
+  },
+  /**
+   * GET /email/2/validations - Get validation results
+   * Retrieve bulk validation results with filtering
+   */
+  getValidations: {
+    url: "/email/2/validations",
+    method: "GET",
+    cacheTime: 30,
+    staleTime: 60
+  },
+  // ========== Logs & Reports ==========
+  /**
+   * GET /email/1/reports - Get email delivery reports
+   */
+  getEmailReports: {
+    url: "/email/1/reports",
+    method: "GET",
+    cacheTime: 30,
+    staleTime: 60
+  },
+  /**
+   * GET /email/1/logs - Get email logs
+   */
+  getEmailLogs: {
+    url: "/email/1/logs",
+    method: "GET",
+    cacheTime: 60,
+    staleTime: 120
+  },
+  // ========== Scheduled Messages (Bulk Operations) ==========
+  /**
+   * GET /email/1/bulks - Get scheduled email bulks
+   */
+  getScheduledEmails: {
+    url: "/email/1/bulks",
+    method: "GET"
+  },
+  /**
+   * GET /email/1/bulks/status - Get scheduled email statuses
+   */
+  getScheduledEmailStatuses: {
+    url: "/email/1/bulks/status",
+    method: "GET"
+  },
+  /**
+   * PUT /email/1/bulks - Reschedule emails
+   */
+  rescheduleEmails: {
+    url: "/email/1/bulks",
+    method: "PUT"
+  },
+  /**
+   * PUT /email/1/bulks/status - Update scheduled email statuses
+   */
+  updateScheduledEmailStatuses: {
+    url: "/email/1/bulks/status",
+    method: "PUT"
+  }
+};
+var infobipEndpoints = {
+  ...infobipEmailEndpoints
+};
+
 // src/api/endpoints/utils.ts
 function getEndpointUrl(name) {
   return endpoints[name].url;
 }
 __name(getEndpointUrl, "getEndpointUrl");
+function getAllEndpointUrls() {
+  const urls = {};
+  Object.entries(endpoints).forEach(([name, config]) => {
+    urls[name] = config.url;
+  });
+  return urls;
+}
+__name(getAllEndpointUrls, "getAllEndpointUrls");
+function hasEndpoint(name) {
+  return name in endpoints;
+}
+__name(hasEndpoint, "hasEndpoint");
+function getEndpointConfig(name) {
+  return endpoints[name];
+}
+__name(getEndpointConfig, "getEndpointConfig");
+function buildEndpointUrl(endpoint, pathParams) {
+  let url = getEndpointUrl(endpoint);
+  if (pathParams) {
+    Object.entries(pathParams).forEach(([key, value]) => {
+      url = url.replace(`:${key}`, String(value));
+    });
+  }
+  return url;
+}
+__name(buildEndpointUrl, "buildEndpointUrl");
+function getEndpointParams(endpoint) {
+  const url = getEndpointUrl(endpoint);
+  const matches = url.match(/:(\w+)/g);
+  return matches ? matches.map((m) => m.substring(1)) : [];
+}
+__name(getEndpointParams, "getEndpointParams");
+function hasPathParams(endpoint) {
+  return getEndpointUrl(endpoint).includes(":");
+}
+__name(hasPathParams, "hasPathParams");
+function getEndpointMetadata(endpoint) {
+  const config = endpoints[endpoint];
+  return {
+    name: endpoint,
+    url: config.url,
+    method: config.method ?? "GET",
+    hasParams: hasPathParams(endpoint),
+    params: getEndpointParams(endpoint),
+    config
+  };
+}
+__name(getEndpointMetadata, "getEndpointMetadata");
+function buildUrl(url, params) {
+  if (!params) return url;
+  let result = url;
+  Object.entries(params).forEach(([key, value]) => {
+    result = result.replace(`:${key}`, String(value));
+  });
+  return result;
+}
+__name(buildUrl, "buildUrl");
+function extractUrlParams(url) {
+  const matches = url.match(/:(\w+)/g);
+  return matches ? matches.map((m) => m.substring(1)) : [];
+}
+__name(extractUrlParams, "extractUrlParams");
 
 // src/api/endpoints/builders.ts
+function endpointCacheKey(endpoint, params) {
+  let url = getEndpointUrl(endpoint);
+  if (params?.pathParams) {
+    url = buildUrl(url, params.pathParams);
+  }
+  if (params?.queryParams) {
+    try {
+      const queryStr = JSON.stringify(params.queryParams);
+      return `${url}:${queryStr}`;
+    } catch {
+      return `${url}:[unstringifiable]`;
+    }
+  }
+  return url;
+}
+__name(endpointCacheKey, "endpointCacheKey");
+function endpointCachePattern(endpoint, wildcardParam) {
+  const url = getEndpointUrl(endpoint);
+  if (wildcardParam) {
+    return url.replace(`:${wildcardParam}`, "*");
+  }
+  return url.replace(/:(\w+)/g, "*");
+}
+__name(endpointCachePattern, "endpointCachePattern");
+function findEndpointsByPattern(pattern) {
+  return Object.entries(endpoints).filter(([, config]) => pattern.test(config.url)).map(([name, config]) => ({
+    name,
+    ...config
+  }));
+}
+__name(findEndpointsByPattern, "findEndpointsByPattern");
+function getEndpointsByMethod(method) {
+  const upperMethod = method.toUpperCase();
+  return Object.entries(endpoints).filter(([, config]) => (config.method ?? "GET") === upperMethod).map(([name, config]) => ({
+    name,
+    ...config
+  }));
+}
+__name(getEndpointsByMethod, "getEndpointsByMethod");
+var endpointCachePatterns = {
+  // Campaign-specific patterns
+  allCampaigns: /* @__PURE__ */ __name(() => endpointCachePattern("listCampaigns"), "allCampaigns"),
+  campaignById: /* @__PURE__ */ __name((id) => endpointCacheKey("getCampaign", {
+    pathParams: { id }
+  }), "campaignById"),
+  campaignsByPattern: /* @__PURE__ */ __name(() => "/campaigns/*", "campaignsByPattern"),
+  campaignStats: /* @__PURE__ */ __name((id) => endpointCacheKey("getCampaignStats", {
+    pathParams: { id }
+  }), "campaignStats"),
+  // Generic patterns
+  all: /* @__PURE__ */ __name(() => "/*", "all"),
+  byEndpoint: /* @__PURE__ */ __name((endpoint) => endpointCachePattern(endpoint), "byEndpoint"),
+  // Helper to create custom patterns
+  custom: /* @__PURE__ */ __name((pattern) => pattern, "custom")
+};
+function buildFullUrl(endpoint, baseURL, params) {
+  let url = getEndpointUrl(endpoint);
+  if (params?.pathParams) {
+    url = buildUrl(url, params.pathParams);
+  }
+  const fullUrl = `${baseURL.replace(/\/$/, "")}${url}`;
+  if (params?.queryParams) {
+    let searchParams;
+    if (params.queryParams instanceof URLSearchParams) {
+      searchParams = params.queryParams;
+    } else if (Array.isArray(params.queryParams)) {
+      searchParams = new URLSearchParams(params.queryParams);
+    } else {
+      searchParams = new URLSearchParams();
+      Object.entries(params.queryParams).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+          value.forEach((v) => searchParams.append(key, String(v)));
+        } else if (value !== void 0 && value !== null) {
+          searchParams.append(key, String(value));
+        }
+      });
+    }
+    const queryString = searchParams.toString();
+    return queryString ? `${fullUrl}?${queryString}` : fullUrl;
+  }
+  return fullUrl;
+}
+__name(buildFullUrl, "buildFullUrl");
 function validatePathParams(endpoint, pathParams) {
   const url = getEndpointUrl(endpoint);
   const required = url.match(/:(\w+)/g);
@@ -14741,7 +14193,9 @@ __name(validatePathParams, "validatePathParams");
 var endpoints = {
   ...campaignEndpoints,
   // These are only examples for the polling, none of these endpoints doesnt exist yet
-  ...pollingEndpoints
+  ...pollingEndpoints,
+  // Infobip third-party provider endpoints (Email, SMS, WhatsApp)
+  ...infobipEndpoints
 };
 var isSlowConnection = isSlowConnection$1;
 function isNetworkAPISupported() {
@@ -18122,6 +17576,7 @@ async function prepareRequestConfigWithEnrichedHeaders(requestConfig, clientConf
   return config;
 }
 __name(prepareRequestConfigWithEnrichedHeaders, "prepareRequestConfigWithEnrichedHeaders");
+new ApiLogger({ service: LOGGER_SERVICES.EXPRESS_FRAMEWORK, transport: "console" });
 var networkDetectionMiddleware = /* @__PURE__ */ __name((req, res, next) => {
   const headerInfo = getNetworkInfoFromHeaders(req.headers);
   const networkInfo = {
@@ -18282,6 +17737,7 @@ __name(MinimumConnectionGuard, "MinimumConnectionGuard");
 MinimumConnectionGuard = __decorateClass([
   Injectable()
 ], MinimumConnectionGuard);
+var logger13 = new ApiLogger({ service: LOGGER_SERVICES.NESTJS_GUARD, transport: "console" });
 var EnrichedHeadersGuard = class {
   constructor(options = {}) {
     this.options = options;
@@ -18296,7 +17752,7 @@ var EnrichedHeadersGuard = class {
     for (const requiredHeader of requiredHeaders) {
       if (!enrichedHeaders[requiredHeader]) {
         if (debug) {
-          console.warn(`[EnrichedHeadersGuard] Missing required header: ${requiredHeader}`);
+          logger13.warn("Missing required header", { requiredHeader });
         }
         return false;
       }
@@ -18313,7 +17769,7 @@ var EnrichedHeadersGuard = class {
     const complianceHeader = enrichedHeaders["x-compliance-required"];
     if (!complianceHeader) {
       if (debug) {
-        console.warn("[EnrichedHeadersGuard] No compliance information available");
+        logger13.warn("No compliance information available");
       }
       return false;
     }
@@ -18323,7 +17779,7 @@ var EnrichedHeadersGuard = class {
     );
     if (!hasRequiredCompliance) {
       if (debug) {
-        console.warn("[EnrichedHeadersGuard] Required compliance not met:", {
+        logger13.warn("Required compliance not met", {
           required: requiredCompliance,
           current: currentCompliance
         });
@@ -18337,7 +17793,7 @@ var EnrichedHeadersGuard = class {
    */
   async buildHeadersForRequest(request, enrichedOptions, debug) {
     if (debug) {
-      console.log("[EnrichedHeadersGuard] Processing request:", {
+      logger13.debug("Processing request with enriched headers guard", {
         method: request.method,
         url: request.url,
         userAgent: request.headers["user-agent"]
@@ -18353,7 +17809,7 @@ var EnrichedHeadersGuard = class {
     };
     const enrichedHeaders = await buildEnrichedHeaders(requestContext, enrichedOptions);
     if (debug) {
-      console.log("[EnrichedHeadersGuard] Built headers:", enrichedHeaders);
+      logger13.debug("Built enriched headers in guard", { enrichedHeaders });
     }
     return enrichedHeaders;
   }
@@ -18385,7 +17841,9 @@ var EnrichedHeadersGuard = class {
    */
   async handleBuildError(error, request, debug) {
     if (debug) {
-      console.error("[EnrichedHeadersGuard] Error building headers:", error);
+      logger13.error("Error building headers in guard", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
     new ApiPackageError(
       "nestjs.guard.enriched_headers_failed",
@@ -18433,6 +17891,7 @@ __name(EnrichedHeadersGuard, "EnrichedHeadersGuard");
 EnrichedHeadersGuard = __decorateClass([
   Injectable()
 ], EnrichedHeadersGuard);
+var logger14 = new ApiLogger({ service: LOGGER_SERVICES.NESTJS_INTERCEPTOR, transport: "console" });
 var EnrichedHeadersInterceptor = class {
   constructor(options = {}) {
     this.options = options;
@@ -18484,7 +17943,9 @@ var EnrichedHeadersInterceptor = class {
    */
   handleContextError(error, request, debug) {
     if (debug) {
-      console.error("[EnrichedHeadersInterceptor] Error in context:", error);
+      logger14.error("Error in interceptor context", {
+        error: error.message
+      });
     }
     new ApiPackageError(
       "nestjs.interceptor.context_error",
@@ -18509,7 +17970,9 @@ var EnrichedHeadersInterceptor = class {
    */
   handleBuildError(error, request, next, debug) {
     if (debug) {
-      console.error("[EnrichedHeadersInterceptor] Error building headers:", error);
+      logger14.error("Error building headers in interceptor", {
+        error: error instanceof Error ? error.message : String(error)
+      });
     }
     new ApiPackageError(
       "nestjs.interceptor.enriched_headers_failed",
@@ -18553,7 +18016,9 @@ var EnrichedHeadersInterceptor = class {
    */
   handleFallbackError(error, request, debug) {
     if (debug) {
-      console.error("[EnrichedHeadersInterceptor] Error in fallback context:", error);
+      logger14.error("Error in fallback context", {
+        error: error.message
+      });
     }
     new ApiPackageError(
       "nestjs.interceptor.fallback_error",
@@ -18580,7 +18045,7 @@ var EnrichedHeadersInterceptor = class {
     const response = http.getResponse();
     try {
       if (debug) {
-        console.log("[EnrichedHeadersInterceptor] Processing request:", {
+        logger14.debug("Processing request with enriched headers interceptor", {
           method: request.method,
           url: request.url,
           userAgent: request.headers["user-agent"]
@@ -18588,7 +18053,7 @@ var EnrichedHeadersInterceptor = class {
       }
       const enrichedHeaders = await this.buildHeaders(request, enrichedOptions);
       if (debug) {
-        console.log("[EnrichedHeadersInterceptor] Built headers:", enrichedHeaders);
+        logger14.debug("Built enriched headers in interceptor", { enrichedHeaders });
       }
       if (storeInRequest) {
         request.enrichedHeaders = enrichedHeaders;
@@ -19313,65 +18778,6 @@ var NetworkPresetNames = {
   BACKGROUND_SYNC: "background-sync"
 };
 
-// src/api/utils/generation/request-id.ts
-var REQUEST_ID_CONSTANTS = {
-  PREFIX_LENGTH: 4
-  // Length of 'req_'
-};
-var requestIdGenerator = createIdGenerator({
-  prefix: "req",
-  useTimestamp: false
-  // Use UUID for request IDs for guaranteed uniqueness
-});
-function generateRequestId(options) {
-  return requestIdGenerator(options);
-}
-__name(generateRequestId, "generateRequestId");
-function generateContextualRequestId(method, url, options) {
-  const context = {};
-  if (method || url) {
-    context.method = method ?? "UNKNOWN";
-    context.url = url ?? "UNKNOWN";
-  }
-  return generateContextualId(context, {
-    prefix: "req",
-    ...options
-  });
-}
-__name(generateContextualRequestId, "generateContextualRequestId");
-function extractBaseRequestId(contextualId) {
-  let id = extractBaseId(contextualId, { separator: ":", extractLast: true });
-  if (id.startsWith("req_")) {
-    id = id.substring(REQUEST_ID_CONSTANTS.PREFIX_LENGTH);
-  }
-  return id;
-}
-__name(extractBaseRequestId, "extractBaseRequestId");
-function isValidRequestId(id) {
-  return isValidId(id, {
-    allowUuid: true,
-    allowTimestamp: true,
-    allowPrefix: true,
-    minLength: 5
-  });
-}
-__name(isValidRequestId, "isValidRequestId");
-function generateShortRequestId(options) {
-  return requestIdGenerator({
-    useTimestamp: true,
-    randomLength: 8,
-    ...options
-  });
-}
-__name(generateShortRequestId, "generateShortRequestId");
-function createRequestIdGenerator(defaultOptions = {}) {
-  return createIdGenerator({
-    prefix: "req",
-    ...defaultOptions
-  });
-}
-__name(createRequestIdGenerator, "createRequestIdGenerator");
-
 // src/api/utils/async-control.ts
 function debounce(func, delay) {
   let timeoutId;
@@ -19653,6 +19059,10 @@ function getAllMediaExtensions() {
 }
 __name(getAllMediaExtensions, "getAllMediaExtensions");
 var MEDIA_MIME_PREFIXES = ["image/", "video/", "audio/"];
+var logger15 = new ApiLogger({
+  service: LOGGER_SERVICES.CLIENT_EVENT_MANAGER,
+  transport: "console"
+});
 var EVENT_CONSTANTS2 = {
   DEBUG_INFO_INTERVAL_MULTIPLIER: 5,
   IMPACT_THRESHOLDS: {
@@ -19669,10 +19079,10 @@ var ClientEventManager = class _ClientEventManager {
     if (!this.config.configOverride) {
       this.config.configOverride = {
         // By default, client emits to all scopes (merged behavior)
-        eventScopes: [...EVENT_SCOPES]
+        eventScopes: [...EVENT_SCOPES$1]
       };
     } else {
-      this.config.configOverride.eventScopes ??= [...EVENT_SCOPES];
+      this.config.configOverride.eventScopes ??= [...EVENT_SCOPES$1];
     }
     eventManager.setEventScopes(this.config.configOverride.eventScopes);
     this.setupEventHandlers();
@@ -19865,7 +19275,9 @@ var ClientEventManager = class _ClientEventManager {
     const registeredHandlers = [];
     finalHandlers.forEach((h) => {
       if (typeof h !== "function") {
-        console.warn("Invalid handler provided - not a function:", h);
+        logger15.warn("Invalid handler provided - not a function", {
+          handlerType: typeof h
+        });
         return;
       }
       const wrappedHandler = /* @__PURE__ */ __name((eventData) => {
@@ -20095,7 +19507,7 @@ var ClientEventManager = class _ClientEventManager {
    */
   setupEventScopes(updates, strategy) {
     updates.configOverride ??= {};
-    updates.configOverride.eventScopes ??= strategy === "temporary" ? ["request"] : [...EVENT_SCOPES];
+    updates.configOverride.eventScopes ??= strategy === "temporary" ? ["request"] : [...EVENT_SCOPES$1];
     if (updates.configOverride?.eventScopes) {
       eventManager.setEventScopes(updates.configOverride.eventScopes);
     } else if (this.config.configOverride?.eventScopes) {
@@ -20382,10 +19794,20 @@ var ClientEventManager = class _ClientEventManager {
     return this.eventManager.getActiveScopes();
   }
   /**
-   * Emit error event (delegates to emitErrorEvent for consistency)
+   * Emit error event at CLIENT scope
+   *
+   * Note: ApiPackageError instances automatically emit to ALL scopes when created.
+   * This method emits specifically at CLIENT scope, useful for:
+   * - Re-emitting errors that were caught and handled elsewhere
+   * - Manual emission timing control
+   * - Client-level error broadcasting
    */
   emitError(error) {
-    void emitErrorEvent(error);
+    emitScopedErrorEvent(API_ERROR_NAMESPACE, error, {
+      scopes: ["CLIENT"],
+      eventFactory: apiErrorEventFactory,
+      category: error.category
+    });
   }
   /**
    * Emit request start event
@@ -20441,11 +19863,11 @@ function setupClientEvents(client, globalConfig, clientConfig) {
   if (!eventConfig.configOverride?.eventScopes) {
     if (!eventConfig.configOverride) {
       eventConfig.configOverride = {
-        eventScopes: [...EVENT_SCOPES]
+        eventScopes: [...EVENT_SCOPES$1]
         // All scopes (merged)
       };
     } else {
-      eventConfig.configOverride.eventScopes = [...EVENT_SCOPES];
+      eventConfig.configOverride.eventScopes = [...EVENT_SCOPES$1];
     }
   }
   const eventManager2 = new ClientEventManager(client, eventConfig);
@@ -21272,8 +20694,6 @@ function mergeHeaders(...headerSets) {
   return result;
 }
 __name(mergeHeaders, "mergeHeaders");
-
-// src/api/headers/headerBuilder.ts
 var HeaderBuilder = class {
   static {
     __name(this, "HeaderBuilder");
@@ -21508,7 +20928,7 @@ var HeaderBuilder = class {
    * ```
    */
   correlationId(id) {
-    this._headers["x-correlation-id"] = id ?? generateCorrelationId();
+    this._headers["x-correlation-id"] = id ?? generateCorrelationId("req_correlation");
     return this;
   }
   /**
@@ -22847,10 +22267,9 @@ function hasEncryptableFields(requestConfig, config) {
   return targets.some((target) => hasMatchingFieldsInTarget(target, requestConfig, config));
 }
 __name(hasEncryptableFields, "hasEncryptableFields");
-
-// src/api/client/helpers/interceptors.ts
 var DEFAULT_MAX_RETRIES = 3;
 var DEFAULT_SUCCESS_STATUS = HTTP_STATUS.OK;
+var logger16 = new ApiLogger({ service: LOGGER_SERVICES.INTERCEPTORS, transport: "console" });
 function trackHeaderChanges(beforeHeaders, afterHeaders, interceptorIndex) {
   const changes = [];
   Object.entries(afterHeaders).forEach(([key, value]) => {
@@ -22910,7 +22329,27 @@ function createOnRetryHandler(handlers) {
   };
 }
 __name(createOnRetryHandler, "createOnRetryHandler");
-function createOnRequestHandler(handlers, enrichedHeadersConfig, encryptionConfig) {
+function normalizeHeaders4(headers2) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers2 || {})) {
+    normalized[key.toLowerCase()] = value;
+  }
+  return normalized;
+}
+__name(normalizeHeaders4, "normalizeHeaders");
+function mergeHeadersCaseInsensitive(...headerSets) {
+  const result = {};
+  for (const headers2 of headerSets) {
+    if (!headers2) continue;
+    for (const [key, value] of Object.entries(headers2)) {
+      const normalizedKey = key.toLowerCase();
+      result[normalizedKey] = value;
+    }
+  }
+  return result;
+}
+__name(mergeHeadersCaseInsensitive, "mergeHeadersCaseInsensitive");
+function createOnRequestHandler(handlers, enrichedHeadersConfig, encryptionConfig, configStrategy) {
   return async (config) => {
     const performanceFactory = getPerformanceEventFactory();
     const requestId = generateRequestId();
@@ -22934,12 +22373,28 @@ function createOnRequestHandler(handlers, enrichedHeadersConfig, encryptionConfi
           "enrichedHeaders",
           { requestId }
         );
-        processedConfig = {
-          ...processedConfig,
-          headers: enrichedHeaders
-        };
-      } catch (error) {
-        console.error("Failed to enrich headers:", error);
+        const strategy = configStrategy;
+        if (strategy === "replace") {
+          processedConfig = {
+            ...processedConfig,
+            headers: normalizeHeaders4(enrichedHeaders)
+          };
+        } else {
+          const mergedHeaders = mergeHeadersCaseInsensitive(
+            enrichedHeaders,
+            // Enriched headers (x-correlation-id, x-platform-type, etc.)
+            config.headers
+            // Existing headers (Authorization, Content-Type, etc.) - OVERRIDE enriched
+          );
+          processedConfig = {
+            ...processedConfig,
+            headers: mergedHeaders
+          };
+        }
+      } catch (error) {
+        logger16.error("Failed to enrich headers", {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
     if (encryptionConfig?.enabled) {
@@ -22949,7 +22404,9 @@ function createOnRequestHandler(handlers, enrichedHeadersConfig, encryptionConfi
         processedConfig = await encryptionInterceptor(processedConfig);
         UnifiedDebugger.getInstance().trackConfigChange({ encryption: "applied" }, "encryption");
       } catch (error) {
-        console.error("Failed to encrypt request:", error);
+        logger16.error("Failed to encrypt request", {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
     if (handlers && handlers.length > 0) {
@@ -22989,7 +22446,9 @@ function createOnResponseHandler(handlers, clearTemporaryOverrides2, clearOnComp
         processedResponse = await decryptionInterceptor(processedResponse);
         UnifiedDebugger.getInstance().trackConfigChange({ decryption: "applied" }, "encryption");
       } catch (error) {
-        console.error("Failed to decrypt response:", error);
+        logger16.error("Failed to decrypt response", {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
     if (clearOnComplete && clearTemporaryOverrides2) {
@@ -23086,8 +22545,14 @@ function setupUnifiedHandlers(params) {
   );
   const clearOnComplete = mergedConfig.configOverride?.clearOnComplete ?? globalConfig?.configOverride?.clearOnComplete ?? clientOptions?.configOverride?.clearOnComplete;
   const encryptionConfig = mergedConfig.encryption ?? globalConfig?.encryption ?? clientOptions?.encryption;
+  const configStrategy = mergedConfig.configOverride?.strategy ?? clientOptions?.configOverride?.strategy ?? globalConfig?.configOverride?.strategy ?? "merge";
   return {
-    onRequest: createOnRequestHandler(mergedOnRequest, enrichedHeadersConfig, encryptionConfig),
+    onRequest: createOnRequestHandler(
+      mergedOnRequest,
+      enrichedHeadersConfig,
+      encryptionConfig,
+      configStrategy
+    ),
     onResponse: createOnResponseHandler(
       mergedOnResponse,
       clearTemporaryOverrides2,
@@ -23099,13 +22564,12 @@ function setupUnifiedHandlers(params) {
   };
 }
 __name(setupUnifiedHandlers, "setupUnifiedHandlers");
-
-// src/api/client/createApiClient.ts
 var ID_GENERATION = {
   BASE: 36,
   SUBSTR_START: 2,
   SUBSTR_LENGTH: 9
 };
+var logger17 = new ApiLogger({ service: LOGGER_SERVICES.API_CLIENT, transport: "console" });
 function applyStrategies(config, options) {
   let resolvedConfig = config;
   if (options.unifiedStrategy) {
@@ -23135,12 +22599,11 @@ function applyStrategies(config, options) {
           );
         }
       });
-      console.warn(
-        `Individual strategies will override unified strategy settings. Unified strategy: ${options.unifiedStrategy}`,
+      logger17.warn("Individual strategies override unified strategy", {
+        unifiedStrategy: options.unifiedStrategy,
         individualStrategies,
-        "Conflicts detected and tracked in debug report",
-        debuggerInstance.getConflicts()
-      );
+        conflictsCount: debuggerInstance.getConflicts().length
+      });
     }
   }
   resolvedConfig = applyIndividualStrategies(resolvedConfig, options);
@@ -23171,12 +22634,12 @@ async function finalizeConfig(resolvedConfig, options) {
   } catch (error) {
     new ApiPackageError(
       "headers.processing.failed",
-      PACKAGE_STATUS_CODES3.OPERATION_FAILED,
-      API_ERROR_CODES6.HEADERS_ENRICHMENT_FAILED,
+      INTERNAL_STATUS_CODES.OPERATION_FAILED,
+      API_ERROR_CODES$1.HEADERS_ENRICHMENT_FAILED,
       {
         cause: error instanceof Error ? error : void 0,
         context: {
-          operation: OPERATIONS3.ENRICHMENT,
+          operation: COMMON_OPERATIONS.ENRICHMENT,
           originalError: error instanceof Error ? error.message : String(error),
           i18n: {
             error: error instanceof Error ? error.message : String(error)
@@ -23217,12 +22680,12 @@ __name(applyDefaultOptions, "applyDefaultOptions");
 function handleClientInitError(error) {
   throw new ApiPackageError(
     "client.initialization.failed",
-    PACKAGE_STATUS_CODES3.INITIALIZATION_FAILED,
-    API_ERROR_CODES6.CLIENT_INITIALIZATION_FAILED,
+    INTERNAL_STATUS_CODES.INITIALIZATION_FAILED,
+    API_ERROR_CODES$1.CLIENT_INITIALIZATION_FAILED,
     {
       cause: error instanceof Error ? error : void 0,
       context: {
-        operation: OPERATIONS3.INITIALIZATION,
+        operation: COMMON_OPERATIONS.INITIALIZATION,
         originalError: error instanceof Error ? error.message : String(error),
         i18n: {
           error: error instanceof Error ? error.message : String(error)
@@ -23333,7 +22796,9 @@ function analyzeConfigChanges(previousConfig, newConfig, updates) {
 }
 __name(analyzeConfigChanges, "analyzeConfigChanges");
 function handleInvalidConfigUpdate(validation, updates, updateOptions) {
-  console.warn("Invalid configuration update:", validation.errors);
+  logger17.warn("Invalid configuration update", {
+    errors: validation.errors
+  });
   UnifiedDebugger.getInstance().trackEventOperation(
     EVENT_OPERATIONS.CONFIG_UPDATE_FAILED,
     "updateConfig",
@@ -23408,6 +22873,25 @@ function trackSuccessfulConfigUpdate(params) {
   );
 }
 __name(trackSuccessfulConfigUpdate, "trackSuccessfulConfigUpdate");
+function handleClientErrorSystemConfig(errorConfig) {
+  const alreadyInitialized = isErrorSystemInitialized();
+  if (alreadyInitialized) {
+    if (errorConfig.locale) {
+      setErrorLocale(errorConfig.locale);
+    }
+    if (errorConfig.additionalCatalogs) {
+      Object.entries(errorConfig.additionalCatalogs).forEach(([locale, catalog]) => {
+        addMessageCatalog(locale, catalog, true);
+      });
+    }
+  } else {
+    initializeErrorSystem({
+      defaultLocale: errorConfig.locale,
+      additionalCatalogs: errorConfig.additionalCatalogs
+    });
+  }
+}
+__name(handleClientErrorSystemConfig, "handleClientErrorSystemConfig");
 function createUpdateConfigMethod(initialConfigState, eventManager2, client, setConfigState) {
   let configState = initialConfigState;
   return (updates, updateOptions) => {
@@ -23417,6 +22901,9 @@ function createUpdateConfigMethod(initialConfigState, eventManager2, client, set
     if (updates.tracking) {
       applyTrackingConfiguration(updates);
     }
+    if (updates.errors) {
+      handleClientErrorSystemConfig(updates.errors);
+    }
     const validation = validateConfigUpdate(updates, updateOptions);
     if (!validation.valid) {
       handleInvalidConfigUpdate(validation, updates, updateOptions);
@@ -23445,9 +22932,62 @@ function createUpdateConfigMethod(initialConfigState, eventManager2, client, set
   };
 }
 __name(createUpdateConfigMethod, "createUpdateConfigMethod");
+function createFetchffClient(fetchffConfig, effectiveConfig, options, unifiedHandlers) {
+  return createApiFetcher({
+    ...fetchffConfig,
+    baseURL: effectiveConfig.baseURL ?? options.apiUrl,
+    endpoints,
+    onRequest: unifiedHandlers.onRequest,
+    onResponse: unifiedHandlers.onResponse,
+    onError: unifiedHandlers.onError,
+    onRetry: unifiedHandlers.onRetry
+  });
+}
+__name(createFetchffClient, "createFetchffClient");
+function enhanceClientWithMethods(params) {
+  const {
+    clientWithEvents,
+    stateContainer,
+    eventManager: eventManager2,
+    client,
+    clientId,
+    globalConfig,
+    options
+  } = params;
+  clientWithEvents.updateConfig = createUpdateConfigMethod(
+    stateContainer.current,
+    eventManager2,
+    client,
+    (newState) => {
+      stateContainer.current = newState;
+    }
+  );
+  clientWithEvents.getConfig = createGetConfigMethod(
+    () => stateContainer.current,
+    globalConfig,
+    clientId,
+    options
+  );
+  clientWithEvents.clearTemporaryOverrides = createClearTemporaryOverridesMethod(
+    () => stateContainer.current,
+    (newState) => {
+      stateContainer.current = newState;
+    },
+    client,
+    eventManager2
+  );
+}
+__name(enhanceClientWithMethods, "enhanceClientWithMethods");
+function initializeClientSystems(options) {
+  applyTrackingConfiguration(options);
+  if (options.errors) {
+    handleClientErrorSystemConfig(options.errors);
+  }
+}
+__name(initializeClientSystems, "initializeClientSystems");
 async function createApiClient(options = {}) {
   try {
-    applyTrackingConfiguration(options);
+    initializeClientSystems(options);
     UnifiedDebugger.getInstance().clear();
     options = applyDefaultOptions(options);
     const userConfig = createPreservedConfig(options);
@@ -23455,58 +22995,43 @@ async function createApiClient(options = {}) {
     const mergedConfig = await finalizeConfig(resolvedConfig, options);
     void UnifiedDebugger.getInstance().logConflicts();
     const globalConfig = getGlobalConfig();
-    let configState = createConfigState(mergedConfig);
+    const stateContainer = {
+      current: createConfigState(mergedConfig)
+    };
     if (options.configOverride) {
-      const result = applyConfigOverride(configState, options.configOverride);
-      configState = result.state;
+      const result = applyConfigOverride(stateContainer.current, options.configOverride);
+      stateContainer.current = result.state;
     }
-    const effectiveConfig = getEffectiveConfig(configState);
+    const effectiveConfig = getEffectiveConfig(stateContainer.current);
     const fetchffConfig = toFetchffConfig(effectiveConfig);
     let clearTemporaryOverridesFn;
     const unifiedHandlers = setupUnifiedHandlers({
       mergedConfig: effectiveConfig,
-      // Use effective config here too
       enrichedHeadersConfig: options.enrichedHeaders,
       globalConfig,
       clientOptions: options,
       clearTemporaryOverrides: /* @__PURE__ */ __name(() => clearTemporaryOverridesFn?.(), "clearTemporaryOverrides")
     });
-    const client = createApiFetcher({
-      ...fetchffConfig,
-      baseURL: effectiveConfig.baseURL ?? options.url,
-      endpoints,
-      // Use unified handlers that handle both ApiConfig callbacks and event emissions
-      onRequest: unifiedHandlers.onRequest,
-      onResponse: unifiedHandlers.onResponse,
-      onError: unifiedHandlers.onError,
-      onRetry: unifiedHandlers.onRetry
-    });
+    const client = createFetchffClient(fetchffConfig, effectiveConfig, options, unifiedHandlers);
     const clientWithEvents = setupClientEvents(client, globalConfig, options);
     const { eventManager: eventManager2 } = clientWithEvents;
+    Object.defineProperty(clientWithEvents, "then", {
+      value: void 0,
+      writable: false,
+      enumerable: false,
+      configurable: true
+    });
     clearTemporaryOverridesFn = /* @__PURE__ */ __name(() => eventManager2.clearTemporaryOverrides(), "clearTemporaryOverridesFn");
     const clientId = emitClientCreatedEvent(effectiveConfig, options);
-    clientWithEvents.updateConfig = createUpdateConfigMethod(
-      configState,
-      eventManager2,
+    enhanceClientWithMethods({
+      clientWithEvents,
+      stateContainer,
+      eventManager: eventManager2,
       client,
-      (newState) => {
-        configState = newState;
-      }
-    );
-    clientWithEvents.getConfig = createGetConfigMethod(
-      () => configState,
-      globalConfig,
       clientId,
+      globalConfig,
       options
-    );
-    clientWithEvents.clearTemporaryOverrides = createClearTemporaryOverridesMethod(
-      () => configState,
-      (newState) => {
-        configState = newState;
-      },
-      client,
-      eventManager2
-    );
+    });
     if (options.networkAware?.enabled) {
       setupNetworkMonitoring(clientWithEvents, options, userConfig);
     }
@@ -23581,18 +23106,13 @@ function createApiQuery(serviceFn, defaultOptions) {
 __name(createApiQuery, "createApiQuery");
 function createApiMutation(serviceFn, defaultOptions) {
   return /* @__PURE__ */ __name(function useApiMutation(serviceOptions, mutationOptions) {
-    const mergedMutationOptions = deepMerge(
-      DEFAULT_MUTATION_OPTIONS,
-      defaultOptions ?? {},
-      mutationOptions ?? {},
-      {
-        mutationFn: /* @__PURE__ */ __name(async (variables) => {
-          const response = await serviceFn(variables, serviceOptions);
-          if (response.error) throw response.error;
-          return response.data;
-        }, "mutationFn")
-      }
-    );
+    const mergedMutationOptions = deepMerge(DEFAULT_MUTATION_OPTIONS, defaultOptions ?? {}, mutationOptions ?? {}, {
+      mutationFn: /* @__PURE__ */ __name(async (variables) => {
+        const response = await serviceFn(variables, serviceOptions);
+        if (response.error) throw response.error;
+        return response.data;
+      }, "mutationFn")
+    });
     return useMutation(
       mergedMutationOptions
     );
@@ -24038,6 +23558,10 @@ function getEnhancedClientHints(headers2, options) {
   return response;
 }
 __name(getEnhancedClientHints, "getEnhancedClientHints");
+var logger18 = new ApiLogger({
+  service: LOGGER_SERVICES.NETWORK_CONFIGURATION,
+  transport: "console"
+});
 var NetworkConfigurationManager = class {
   static {
     __name(this, "NetworkConfigurationManager");
@@ -24103,9 +23627,11 @@ var NetworkConfigurationManager = class {
    */
   registerPreset(preset) {
     this.availablePresets.set(preset.id, preset);
-    console.log(
-      `📋 Registered network preset: ${preset.name} (${preset.id}) for ${preset.targetQuality} quality`
-    );
+    logger18.info("Network preset registered", {
+      presetName: preset.name,
+      presetId: preset.id,
+      targetQuality: preset.targetQuality
+    });
   }
   /**
    * Get all available presets
@@ -24281,7 +23807,7 @@ var NetworkConfigurationManager = class {
       }
     });
     this.cleanupFunctions.push(unsubscribe);
-    console.log("🔄 Auto preset switching enabled");
+    logger18.info("Auto preset switching enabled");
   }
   /**
    * Disable automatic preset monitoring
@@ -24290,7 +23816,7 @@ var NetworkConfigurationManager = class {
     this.monitoringEnabled = false;
     this.cleanupFunctions.forEach((cleanup) => cleanup());
     this.cleanupFunctions = [];
-    console.log("🔄 Auto preset switching disabled");
+    logger18.info("Auto preset switching disabled");
   }
   /**
    * Get current active overrides for debugging
@@ -24304,7 +23830,7 @@ var NetworkConfigurationManager = class {
   restoreAllOverrides() {
     const overrides = Array.from(this.activeOverrides.values());
     overrides.forEach((override) => override.restore());
-    console.log(`🔄 Restored ${overrides.length} temporary overrides`);
+    logger18.info("Restored temporary overrides", { count: overrides.length });
   }
   /**
    * Get configuration manager stats for debugging
@@ -24556,7 +24082,7 @@ var NetworkConfigurationManager = class {
       changes.push("caching");
     }
     if (changes.length > 0) {
-      console.log(`👤 User preferences updated: ${changes.join(", ")}`);
+      logger18.info("User preferences updated", { changes });
     }
   }
   /**
@@ -25063,7 +24589,7 @@ function useOptimisticUpdate(key, initialData) {
     const nextState = {
       data: response.data,
       isValidating: response.isFetching ?? false,
-      error: response.error ?? void 0
+      error: response.error
     };
     setState(nextState);
   });
@@ -25540,6 +25066,355 @@ function useDeleteCampaign(serviceOptions, mutationOptions) {
   })(serviceOptions, mutationOptions);
 }
 __name(useDeleteCampaign, "useDeleteCampaign");
+async function sendInfobipEmail(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.from) {
+    throw new ApiPackageError(
+      "Missing required field: from",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.to) {
+    throw new ApiPackageError(
+      "Missing required field: to",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.subject) {
+    throw new ApiPackageError(
+      "Missing required field: subject",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 0 },
+    timeout: 15e3
+    // 15 second timeout for email sends
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.sendEmail({
+    body: payload
+  });
+}
+__name(sendInfobipEmail, "sendInfobipEmail");
+async function sendInfobipAdvancedEmail(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.messages || payload.messages.length === 0) {
+    throw new ApiPackageError(
+      "Missing required field: messages (must be a non-empty array)",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  for (const [index, message] of payload.messages.entries()) {
+    if (!message.sender) {
+      throw new ApiPackageError(
+        `Missing required field: messages[${index}].sender`,
+        void 0,
+        API_ERROR_CODES.REQUIRED_FIELD_MISSING
+      );
+    }
+    if (!message.destinations || message.destinations.length === 0) {
+      throw new ApiPackageError(
+        `Missing required field: messages[${index}].destinations (must be a non-empty array)`,
+        void 0,
+        API_ERROR_CODES.REQUIRED_FIELD_MISSING
+      );
+    }
+    if (!message.content?.subject) {
+      throw new ApiPackageError(
+        `Missing required field: messages[${index}].content.subject`,
+        void 0,
+        API_ERROR_CODES.REQUIRED_FIELD_MISSING
+      );
+    }
+  }
+  const serviceDefaults = {
+    retry: { attempts: 0 },
+    timeout: 15e3
+    // 15 second timeout for email sends
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.sendAdvancedEmail({
+    body: payload
+  });
+}
+__name(sendInfobipAdvancedEmail, "sendInfobipAdvancedEmail");
+async function validateInfobipEmail(email, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  const payload = typeof email === "string" ? { to: email } : email;
+  if (!payload?.to) {
+    throw new ApiPackageError(
+      "Missing required field: to (email address)",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.to.includes("@")) {
+    throw new ApiPackageError(
+      "Invalid email format: must contain @",
+      void 0,
+      API_ERROR_CODES.INVALID_FORMAT
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 2, delay: 500 },
+    cacheTime: 300,
+    // Cache validation results for 5 minutes
+    staleTime: 600,
+    // Consider stale after 10 minutes
+    timeout: 5e3
+    // 5 second timeout
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.validateEmail({
+    body: payload
+  });
+}
+__name(validateInfobipEmail, "validateInfobipEmail");
+async function bulkValidateInfobipEmails(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  const MAX_BULK_EMAIL_VALIDATION_SIZE = 1e4;
+  if (!payload.destinations || payload.destinations.length === 0) {
+    throw new ApiPackageError(
+      "Missing required field: destinations (must be a non-empty array)",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (payload.destinations.length > MAX_BULK_EMAIL_VALIDATION_SIZE) {
+    throw new ApiPackageError(
+      `Too many email addresses: maximum ${MAX_BULK_EMAIL_VALIDATION_SIZE} per request`,
+      void 0,
+      API_ERROR_CODES.INVALID_FORMAT
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 0 },
+    // Don't retry bulk validation requests
+    timeout: 3e4
+    // 30 second timeout for bulk operations
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.bulkValidateEmails({
+    body: payload
+  });
+}
+__name(bulkValidateInfobipEmails, "bulkValidateInfobipEmails");
+
+// src/api/services/infobip/email/GET/fetchEmailReports.ts
+async function fetchInfobipEmailReports(params, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  const serviceDefaults = {
+    cacheTime: 30,
+    // Cache for 30 seconds
+    staleTime: 60,
+    // Consider stale after 1 minute
+    timeout: 1e4
+    // 10 second timeout
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.getEmailReports({
+    params
+  });
+}
+__name(fetchInfobipEmailReports, "fetchInfobipEmailReports");
+
+// src/api/services/infobip/email/GET/fetchEmailLogs.ts
+async function fetchInfobipEmailLogs(params, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  const serviceDefaults = {
+    cacheTime: 60,
+    // Cache for 1 minute
+    staleTime: 120,
+    // Consider stale after 2 minutes
+    timeout: 1e4
+    // 10 second timeout
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.getEmailLogs({
+    params
+  });
+}
+__name(fetchInfobipEmailLogs, "fetchInfobipEmailLogs");
+
+// src/api/services/infobip/email/GET/fetchScheduledEmails.ts
+async function fetchInfobipScheduledEmails(params, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  const serviceDefaults = {
+    retry: { attempts: 2, delay: 500 },
+    cacheTime: 30,
+    staleTime: 60,
+    timeout: 1e4
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.getScheduledEmails({
+    params
+  });
+}
+__name(fetchInfobipScheduledEmails, "fetchInfobipScheduledEmails");
+
+// src/api/services/infobip/email/GET/fetchScheduledEmailStatuses.ts
+async function fetchInfobipScheduledEmailStatuses(params, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  const serviceDefaults = {
+    retry: { attempts: 2, delay: 500 },
+    cacheTime: 30,
+    staleTime: 60,
+    timeout: 1e4
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.getScheduledEmailStatuses({
+    params
+  });
+}
+__name(fetchInfobipScheduledEmailStatuses, "fetchInfobipScheduledEmailStatuses");
+
+// src/api/services/infobip/email/GET/fetchValidations.ts
+async function fetchInfobipValidations(params, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  const serviceDefaults = {
+    retry: { attempts: 2, delay: 500 },
+    cacheTime: 60,
+    // Cache results for 1 minute
+    staleTime: 120,
+    // Consider stale after 2 minutes
+    timeout: 1e4
+    // 10 second timeout
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.getValidations({
+    params
+  });
+}
+__name(fetchInfobipValidations, "fetchInfobipValidations");
+async function rescheduleInfobipEmails(params, payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.sendAt) {
+    throw new ApiPackageError(
+      "Missing required field: sendAt",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 1 },
+    timeout: 1e4
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.rescheduleEmails({
+    params,
+    body: payload
+  });
+}
+__name(rescheduleInfobipEmails, "rescheduleInfobipEmails");
+async function updateInfobipScheduledEmailStatuses(params, payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.status) {
+    throw new ApiPackageError(
+      "Missing required field: status",
+      void 0,
+      API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (payload.status !== "PAUSED" && payload.status !== "PROCESSING") {
+    throw new ApiPackageError(
+      "Invalid status: must be PAUSED or PROCESSING",
+      void 0,
+      API_ERROR_CODES.INVALID_FORMAT
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 1 },
+    timeout: 1e4
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.updateScheduledEmailStatuses({
+    params,
+    body: payload
+  });
+}
+__name(updateInfobipScheduledEmailStatuses, "updateInfobipScheduledEmailStatuses");
 function getSSRSafeConfig(config) {
   if (!isBrowser()) {
     return {
@@ -25757,6 +25632,6 @@ __name(toFetchffRevalidationConfig, "toFetchffRevalidationConfig");
   resources: revalidationStrategies.static
 });
 
-export { ALL_EVENTS, ApiPackageError, CACHE_EVENTS2 as CACHE_EVENTS, CLIENT_EVENTS2 as CLIENT_EVENTS, CONFIG_EVENTS2 as CONFIG_EVENTS, ClientHintsInterceptor, ConfigBuilder, DEBUG_EVENTS2 as DEBUG_EVENTS, ERROR_EVENTS2 as ERROR_EVENTS, EVENT_NAMESPACES2 as EVENT_NAMESPACES, EVENT_SCOPES2 as EVENT_SCOPES, EVENT_SCOPES_WITH_TEMPORARY, Environment, EventHelpers, EventManager, HANDLER_SCOPES, HEADER_EVENTS2 as HEADER_EVENTS, HeaderBuilder, IntervalManager, MEDIA_EXTENSIONS, MEDIA_MIME_PREFIXES, MinimumConnectionGuard, NETWORK_EVENTS2 as NETWORK_EVENTS, NetworkConfigurationManager, NetworkDetectionMiddleware, NetworkGuard, NetworkInfoParam, NetworkPresetNames, NetworkProperty, NoDataSaverGuard, PERFORMANCE_EVENTS2 as PERFORMANCE_EVENTS, RequestTracker, UnifiedDebugger, abortAllRequests, abortByPattern, abortRequest, abortSearchRequests, abortUploadRequests, addClientHintsToResponse, addInterval, addTime, analyzeComplianceIssues, analyzeConfigImpact, analyzeConflictPatterns, analyzeEventSystemIssues, analyzeHistoryPatterns, analyzePerformanceIssues, applyConfigOverride, applyConfigPreset, applyConfigUpdate, applyPollingStrategy, applyRetryStrategy, applyRevalidationStrategy, applyTemporaryNetworkOverride, applyUnifiedStrategy, arrayOf, average, base64ToBytes, buildCacheKey, bytesToBase64, cacheKeyPatterns, cacheStrategies, calculateCacheDuration, calculatePerformanceImpact, calculatePollingDuration, calculateRequestMetrics, canPerformHeavyOperation, clamp, clampedPercentage, clearErrorHandlers, clearNetworkDebugData, clearTemporaryOverrides, cloneConfig, compactHistory, configConflictDetector, configureForEnvironment, containsAny, convertEndpointsToFetchff, createAbortError, createAdaptiveResponse, createApiClient, createCachePattern, createCacheStrategy, createCampaign, createComplianceReport, createConditionalInterval, createConditionalPolling, createConfigBuilder, createConfigHistoryEntry, createConfigState, createConflict, createCorrelationIdGenerator, createCustomPreset, createCustomUnifiedStrategy, createDate, createDebouncedAbort, createDebugReport, createDecryptionInterceptor, createDelay, createEncryptionInterceptor, createEncryptionInterceptors, createEventEmitter, createHistoryEntry, createHistorySummary, createIdGenerator, createLimitedInterval, createManagedInterval, createNetworkDetectionMiddleware, createPerformanceAnalysis, createPerformanceBenchmark, createPollingStrategy, createProgressivePolling, createRequestIdGenerator, createRetryConfig, createRetryStrategy, createRevalidationKey, createRevalidationStrategy, createRouteGuard, createRouteScope, createScopedAbort, createStatusCodeLimits, createThrottledAbort, createTypedSubscription, createVisibilityAwarePolling, dateDiff, debounce, decrypt, deepMerge, deleteCache, deleteCampaign, detectConfigConflicts, detectConflicts, detectPlatform, determinePrecedenceReason, disableNetworkConfigDebug, enableNetworkConfigDebug, encrypt, endOfDay, eventManager, exportKeyToBase64, extendPresets as extendRevalidationPresets, extractBaseCorrelationId, extractBaseId, extractBaseRequestId, extractCorrelationType, extractFields, extractLinkedCorrelationIds, fetchCampaign, fetchCampaignParticipants, fetchCampaignStats, fetchCampaigns, filterHistory, filterObject, findMatchingPaths, flattenObject, formatDuration, formatReportForConsole, formatTimeForInterval, fromFetchffConfig, fromISOString, fromUnixTimestamp, generateApiCorrelationId, generateBaseId, generateComprehensiveReport, generateContextualCorrelationId, generateContextualId, generateContextualRequestId, generateCorrelationId, generateIV, generateIssueBreakdown, generateNetworkCorrelationId, generateRandomKey, generateRecommendations, generateRequestId, generateSessionCorrelationId, generateShortRequestId, generateTraceCorrelationId, generateUUID, getActiveOverrideKeys, getAdaptiveApiConfig, getAdaptiveBatchSize, getAdaptiveCacheDuration, getAdaptiveConfig, getAdaptivePageSize, getAdaptiveTimeout, getAllFieldPaths, getAllMediaExtensions, getAppVersion, getAuthenticationType, getCache, getCacheAffectingHeaders, getCacheStrategy, getClientHintHeaders, getConfigHierarchy, getConnection, getConnectionType, getConsole, getContextHeaders, getCrypto, getDefaultApiClient, getDeviceId, getDeviceInfo, getDocument, getEffectiveConfig, getEffectiveConnectionType, getEnhancedClientHints, getEntries, getEnv, getEnvironmentInfo, getEnvironmentName, getErrorCategory, getErrorCodeByStatus, getErrorDefinition, getErrorHandlers, getEventManager, getExtendedEnvironmentInfo, getFieldValue, getFileExtension, getFrameworkAdaptiveBatchSize, getFrameworkAdaptiveTimeout, getGlobal, getGlobalConfig, getHeaderFingerprint, getHeaderSummary, getISOWeek, getIntervalBoundaries, getIntervalDifference, getIntervalEnd, getIntervalStart, getJSONSize, getKeys, getLocalStorage, getLocation, getMatchingPresets, getNavigator, getNetworkConfigFromHeaders, getNetworkDebugStats, getNetworkEventStats, getNetworkInfo, getNetworkInfoFromHeaders, getNetworkInfoFromRequest, getNetworkOptimizedConfig, getNetworkPreset, getNetworkQuality, getNetworkQualityFromHeaders, getNetworkQualityScore, getNetworkRTT, getNetworkSpeed, getNonCacheAffectingHeaders, getOptimizedNetworkConfig, getPresetForNetworkInfo, getPresetForQuality, getPresetNames, getProcess, getQuarter, getRelativeTime, getRetryStrategy, getPreset as getRevalidationPreset, getPresets as getRevalidationPresets, getRevalidationStrategy, getRuntimeEnvironment, getSSRSafeConfig, getSSRSafePollingConfig, getSessionStorage, getTimeComponents, getUnifiedDebugger, getUnifiedStrategy, getUnifiedStrategyNames, getUnixTimestamp, getUserAgent, getValues, getWindow, groupBy, handleArrayMerge, handleObjectMerge, hasAnyExtension, hasAuthentication, hasEncryptableFields, hasGlobal, hasIndexedDB, hasLocalStorage, hasMatchingFields, hasNavigator, hasNetworkInfo2 as hasNetworkInfoExpress, hasNetworkInfo as hasNetworkInfoNextjs, hasPreset, hasProperty, hasSessionStorage, hasWebGL, hasWebPSupport, headerPresets, headers, headersContext, importKey, inBrowser, inRange, inServer, invalidationScenarios, inverseLerp, isAbortError, isArray, isBoolean, isBrowser, isBun, isCI, isCacheValid, isCellularConnection, isCryptoAvailable, isDataFresh, isDataSaverEnabled, isDataSaverEnabledFromHeaders, isDebug, isDeno, isDevelopment, isDocumentVisible, isElectron, isEmpty, isEmptyObject, isEncryptedMetadata, isError, isFunction, isFuture, isInIframe, isInRange, isInteger, isMergeableObject, isMobile, isNetworkAPISupported, isNode, isNonEmptyArray, isNonEmptyObject, isNonEmptyString2 as isNonEmptyString, isNonNegativeNumber, isNotNullish, isNullish, isNumber, isObject, isOffline, isOneOfIgnoreCase, isOnline, isPageFocused, isPast, isPlainObject, isPollingActive, isPositiveNumber, isProduction, isPromise, isReactNative, isRevalidationSupported, isSSR, isSameDay, isSameInterval, isServer, isSlowConnection, isStaging, isString, isTest, isToday, isTouchDevice, isUnifiedStrategyName, isValidCorrelationId, isValidDate, isValidEnumValue, isValidFieldPath, isValidId, isValidJSON, isValidNumber2 as isValidNumber, isValidPollingConfig, isValidRequestId, isValidStrategyName as isValidRevalidationStrategyName, isWebWorker, isWifiConnection, isWildcard, isWithinDedupeWindow, joinCampaign, jsonClone, jsonEquals, keyBy, leaveCampaign, lerp, linkCorrelationIds, logNetworkConfigReport, mapKeys, mapObject, mapRange, matchFieldPath, matchesAny, max, median, mergeCacheStrategies, mergeConfigs, mergeConflicts, mergeHeaders, mergePollingConfigs, mergePresets, mergeRetryStrategies, mergeRevalidationStrategies, mergeUnifiedStrategy, min, msToSeconds, mutate2 as mutate, networkConfigDebugger, networkConfigManager, networkDetectionMiddleware, networkPresets, networkStatus, normalizeHeaders3 as normalizeHeaders, now, nowInSeconds, omit, onOffline, onOnline, onceErrorHandler, oneOf, parseAndValidateNumber, parseFieldPath, parseId, percentage, pick, pollingStrategies, prepareRequestConfig, prepareRequestConfigWithEnrichedHeaders, prettyStringify, raceRequests, randomBetween, randomInt, registerErrorHandler, registerErrorHandlers, removeCircularReferences, removeEmpty, removeNullish, removeSensitiveHeaders, removeUndefined, requestTracker, requestWithTimeout, resetGlobalConfig, resetPresets as resetRevalidationPresets, resolveConflict, retryConditions, retryStrategies, genericPresets as revalidationPresets, revalidationStrategies, round, runWithHeaders, runWithHeadersAsync, safeParseJSON, safeStringify, sanitizeHeaders2 as sanitizeHeaders, secondsToMs, sequentialRequests, setCache, setConfigWarnings, setDefaultApiClient, setErrorHandlers, setFieldValue, setGlobalConfig, setupClientEvents, setupRouteChangeCleanup, shouldApplyConfig, shouldAutoRefresh, shouldPrefetch, shouldServeHighQuality, shouldUseAggressiveCaching, sleep, sortIssuesByPriority, startNetworkEventMonitoring, startOfDay, startRequestTracking, subscribe, subscribeMultiple, subscribeOnce, subscribeWithTimeout, sum, supportsBroadcastChannel, supportsFetch, supportsGeolocation, supportsIntersectionObserver, supportsLocalStorage, supportsNotifications, supportsPushNotifications, supportsRequestIdleCallback, supportsServiceWorker, supportsSessionStorage, supportsWebSocket, throttle, timeAgo, toFetchffConfig, toFetchffRevalidationConfig, toISOString, trackConfig, trackNetworkOverride, trackableSpread, transformFields, truncateJSON, unifiedStrategies, unregisterErrorHandlers, updateCampaign, updateGlobalConfig, useAbortableRequest, useApiConfigConflicts, useApiDebugInfo, useApiMonitor, useApiNetworkQuality, useCampaign, useCampaignParticipants, useCampaignStats, useCampaigns, useConditionalSubscription, useCreateCampaign, useDebouncedSubscription, useDeleteCampaign, useJoinCampaign, useLeaveCampaign, useMultipleSubscriptions, useOptimisticUpdate, useRealTimeData, useRequestCleanup, useRequestGroup, useRouteAwareRequest, useSubscription, useSubscriptionState, useUpdateCampaign, validateConfigUpdate, validateEncryptionConfig, validateHeaders2 as validateHeaders, validatePreset, waitForOnline, withNetworkDetection, withNetworkInfo, withTimeout };
+export { ALL_EVENTS, ApiPackageError, CACHE_EVENTS2 as CACHE_EVENTS, CLIENT_EVENTS2 as CLIENT_EVENTS, CONFIG_EVENTS2 as CONFIG_EVENTS, ClientEventManager, ClientHintsInterceptor, ConfigBuilder, DEBUG_EVENTS2 as DEBUG_EVENTS, ERROR_EVENTS2 as ERROR_EVENTS, EVENT_NAMESPACES2 as EVENT_NAMESPACES, EVENT_SCOPES, EVENT_SCOPES_WITH_TEMPORARY2 as EVENT_SCOPES_WITH_TEMPORARY, Environment, EventHelpers, EventManager, HANDLER_SCOPES, HEADER_EVENTS2 as HEADER_EVENTS, HeaderBuilder, IntervalManager, MEDIA_EXTENSIONS, MEDIA_MIME_PREFIXES, MinimumConnectionGuard, NETWORK_EVENTS2 as NETWORK_EVENTS, NetworkConfigurationManager, NetworkDetectionMiddleware, NetworkGuard, NetworkInfoParam, NetworkPresetNames, NetworkProperty, NoDataSaverGuard, PERFORMANCE_EVENTS2 as PERFORMANCE_EVENTS, RequestTracker, UnifiedDebugger, abortAllRequests, abortByPattern, abortRequest, abortSearchRequests, abortUploadRequests, addClientHintsToResponse, addInterval, addTime, analyzeComplianceIssues, analyzeConfigImpact, analyzeConflictPatterns, analyzeEventSystemIssues, analyzeHistoryPatterns, analyzePerformanceIssues, applyCacheStrategyConfig, applyConfigOverride, applyConfigPreset, applyConfigUpdate, applyCustomQualityPresetStrategies, applyHeaderPresets, applyIndividualStrategies, applyPerformancePresetConfig, applyPollingStrategy, applyPollingStrategyConfig, applyRetryStrategy, applyRetryStrategyConfig, applyRevalidationStrategy, applyTemporaryNetworkOverride, applyUnifiedStrategy, applyUnifiedStrategyToConfig, arrayOf, average, base64ToBytes, buildCacheKey, buildEndpointUrl, buildFullUrl, buildUrl, bulkValidateInfobipEmails, bytesToBase64, cacheKeyPatterns, cacheStrategies, calculateCacheDuration, calculatePerformanceImpact, calculatePollingDuration, calculateRequestMetrics, campaignEndpoints, canPerformHeavyOperation, checkOverrideTriggers, clamp, clampedPercentage, clearErrorHandlers, clearNetworkDebugData, clearTemporaryOverrides, cloneConfig, compactHistory, configConflictDetector, configureForEnvironment, containsAny, convertEndpointsToFetchff, createAbortError, createAdaptiveResponse, createApiClient, createCachePattern, createCacheStrategy, createCampaign, createComplianceReport, createConditionalInterval, createConditionalPolling, createConfigBuilder, createConfigHistoryEntry, createConfigState, createConflict, createCustomPreset, createCustomUnifiedStrategy, createDate, createDebouncedAbort, createDebugReport, createDecryptionInterceptor, createDelay, createEncryptionInterceptor, createEncryptionInterceptors, createEventEmitter, createHistoryEntry, createHistorySummary, createLimitedInterval, createManagedInterval, createNetworkDetectionMiddleware, createPerformanceAnalysis, createPerformanceBenchmark, createPollingStrategy, createPreservedConfig, createProgressivePolling, createRetryConfig, createRetryStrategy, createRevalidationKey, createRevalidationStrategy, createRouteGuard, createRouteScope, createScopedAbort, createStatusCodeLimits, createThrottledAbort, createTypedSubscription, createVisibilityAwarePolling, dateDiff, debounce, decrypt, deepMerge, deleteCache, deleteCampaign, detectConfigConflicts, detectConflicts, detectPlatform, determinePrecedenceReason, disableNetworkConfigDebug, enableNetworkConfigDebug, encrypt, endOfDay, endpointCacheKey, endpointCachePattern, endpointCachePatterns, endpoints, eventManager, exportKeyToBase64, extendPresets as extendRevalidationPresets, extractFields, extractUrlParams, fetchCampaign, fetchCampaignParticipants, fetchCampaignStats, fetchCampaigns, fetchInfobipEmailLogs, fetchInfobipEmailReports, fetchInfobipScheduledEmailStatuses, fetchInfobipScheduledEmails, fetchInfobipValidations, filterHistory, filterObject, findEndpointsByPattern, findMatchingPaths, flattenObject, formatDuration, formatReportForConsole, formatTimeForInterval, fromFetchffConfig, fromISOString, fromUnixTimestamp, generateComprehensiveReport, generateIV, generateIssueBreakdown, generateRandomKey, generateRecommendations, generateUUID, getActiveOverrideKeys, getAdaptiveApiConfig, getAdaptiveBatchSize, getAdaptiveCacheDuration, getAdaptiveConfig, getAdaptivePageSize, getAdaptiveTimeout, getAllEndpointUrls, getAllFieldPaths, getAllMediaExtensions, getAppVersion, getAuthenticationType, getCache, getCacheAffectingHeaders, getCacheStrategy, getClientHintHeaders, getConfigHierarchy, getConnection, getConnectionType, getConsole, getContextHeaders, getCrypto, getDefaultApiClient, getDeviceId, getDeviceInfo, getDocument, getEffectiveConfig, getEffectiveConnectionType, getEndpointConfig, getEndpointMetadata, getEndpointParams, getEndpointUrl, getEndpointsByMethod, getEnhancedClientHints, getEntries, getEnv, getEnvironmentInfo, getEnvironmentName, getErrorHandlers, getEventManager, getExtendedEnvironmentInfo, getFieldValue, getFileExtension, getFrameworkAdaptiveBatchSize, getFrameworkAdaptiveTimeout, getGlobal, getGlobalConfig, getHeaderFingerprint, getHeaderSummary, getISOWeek, getIntervalBoundaries, getIntervalDifference, getIntervalEnd, getIntervalStart, getJSONSize, getKeys, getLocalStorage, getLocation, getMatchingPresets, getNavigator, getNetworkConfigFromHeaders, getNetworkDebugStats, getNetworkEventStats, getNetworkInfo, getNetworkInfoFromHeaders, getNetworkInfoFromRequest, getNetworkOptimizedConfig, getNetworkPreset, getNetworkQuality, getNetworkQualityFromHeaders, getNetworkQualityScore, getNetworkQualityWithThresholds, getNetworkRTT, getNetworkSpeed, getNonCacheAffectingHeaders, getOptimizedNetworkConfig, getPresetForNetworkInfo, getPresetForQuality, getPresetNames, getProcess, getQuarter, getRelativeTime, getRetryStrategy, getPreset as getRevalidationPreset, getPresets as getRevalidationPresets, getRevalidationStrategy, getRuntimeEnvironment, getSSRSafeConfig, getSSRSafePollingConfig, getSessionStorage, getTimeComponents, getUnifiedDebugger, getUnifiedStrategy, getUnifiedStrategyNames, getUnixTimestamp, getUserAgent, getValues, getWindow, groupBy, handleArrayMerge, handleObjectMerge, hasAnyExtension, hasAuthentication, hasEncryptableFields, hasEndpoint, hasGlobal, hasIndexedDB, hasLocalStorage, hasMatchingFields, hasNavigator, hasNetworkInfo2 as hasNetworkInfoExpress, hasNetworkInfo as hasNetworkInfoNextjs, hasPathParams, hasPreset, hasProperty, hasSessionStorage, hasWebGL, hasWebPSupport, headerPresets, headers, headersContext, importKey, inBrowser, inRange, inServer, infobipEmailEndpoints, infobipEndpoints, invalidationScenarios, inverseLerp, isAbortError, isArray, isBoolean, isBrowser, isBun, isCI, isCacheValid, isCellularConnection, isCryptoAvailable, isDataFresh, isDataSaverEnabled, isDataSaverEnabledFromHeaders, isDebug, isDeno, isDevelopment, isDocumentVisible, isElectron, isEmpty, isEmptyObject, isEncryptedMetadata, isError, isFunction, isFuture, isInIframe, isInRange, isInteger, isMergeableObject, isMobile, isNetworkAPISupported, isNode, isNonEmptyArray, isNonEmptyObject, isNonEmptyString2 as isNonEmptyString, isNonNegativeNumber, isNotNullish, isNullish, isNumber, isObject, isOffline, isOneOfIgnoreCase, isOnline, isPageFocused, isPast, isPlainObject, isPollingActive, isPositiveNumber, isProduction, isPromise, isReactNative, isRevalidationSupported, isSSR, isSameDay, isSameInterval, isServer, isSlowConnection, isStaging, isString, isTest, isToday, isTouchDevice, isUnifiedStrategyName, isValidDate, isValidEnumValue, isValidFieldPath, isValidJSON, isValidNumber2 as isValidNumber, isValidPollingConfig, isValidStrategyName as isValidRevalidationStrategyName, isWebWorker, isWifiConnection, isWildcard, isWithinDedupeWindow, joinCampaign, jsonClone, jsonEquals, keyBy, leaveCampaign, lerp, logNetworkConfigReport, mapKeys, mapObject, mapRange, matchFieldPath, matchesAny, max, median, mergeCacheStrategies, mergeConfigs, mergeConflicts, mergeHeaders, mergePollingConfigs, mergePresets, mergeRetryStrategies, mergeRevalidationStrategies, mergeUnifiedStrategy, min, msToSeconds, mutate2 as mutate, networkConfigDebugger, networkConfigManager, networkDetectionMiddleware, networkPresets, networkStatus, normalizeHeaders3 as normalizeHeaders, now, nowInSeconds, omit, onOffline, onOnline, onceErrorHandler, oneOf, parseAndValidateNumber, parseFieldPath, percentage, pick, pollingEndpoints, pollingStrategies, prepareRequestConfig, prepareRequestConfigWithEnrichedHeaders, prettyStringify, processHeaders2 as processHeaders, raceRequests, randomBetween, randomInt, registerErrorHandler, registerErrorHandlers, removeCircularReferences, removeEmpty, removeNullish, removeSensitiveHeaders, removeUndefined, requestTracker, requestWithTimeout, rescheduleInfobipEmails, resetGlobalConfig, resetPresets as resetRevalidationPresets, resolveConflict, retryConditions, retryStrategies, genericPresets as revalidationPresets, revalidationStrategies, round, runWithHeaders, runWithHeadersAsync, safeParseJSON, safeStringify, sanitizeHeaders2 as sanitizeHeaders, secondsToMs, sendInfobipAdvancedEmail, sendInfobipEmail, sequentialRequests, setCache, setConfigWarnings, setDefaultApiClient, setErrorHandlers, setFieldValue, setGlobalConfig, setupClientEvents, setupNetworkMonitoring, setupRouteChangeCleanup, setupTemporaryOverride, shouldApplyConfig, shouldAutoRefresh, shouldPrefetch, shouldServeHighQuality, shouldUseAggressiveCaching, sleep, sortIssuesByPriority, startNetworkEventMonitoring, startOfDay, startRequestTracking, subscribe, subscribeMultiple, subscribeOnce, subscribeWithTimeout, sum, supportsBroadcastChannel, supportsFetch, supportsGeolocation, supportsIntersectionObserver, supportsLocalStorage, supportsNotifications, supportsPushNotifications, supportsRequestIdleCallback, supportsServiceWorker, supportsSessionStorage, supportsWebSocket, throttle, timeAgo, toFetchffConfig, toFetchffRevalidationConfig, toISOString, trackConfig, trackDirectCacheConfig, trackNetworkOverride, trackSpreadProperties, trackableSpread, transformFields, truncateJSON, unifiedStrategies, unregisterErrorHandlers, updateCampaign, updateGlobalConfig, updateInfobipScheduledEmailStatuses, useAbortableRequest, useApiConfigConflicts, useApiDebugInfo, useApiMonitor, useApiNetworkQuality, useCampaign, useCampaignParticipants, useCampaignStats, useCampaigns, useConditionalSubscription, useCreateCampaign, useDebouncedSubscription, useDeleteCampaign, useJoinCampaign, useLeaveCampaign, useMultipleSubscriptions, useOptimisticUpdate, useRealTimeData, useRequestCleanup, useRequestGroup, useRouteAwareRequest, useSubscription, useSubscriptionState, useUpdateCampaign, validateConfigUpdate, validateEncryptionConfig, validateHeaders2 as validateHeaders, validateInfobipEmail, validatePathParams, validatePreset, waitForOnline, withNetworkDetection, withNetworkInfo, withTimeout };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map