@plyaz/api 1.2.2 → 1.4.0

package/dist/index.cjs

@@ -1,16 +1,39 @@
 'use strict';
 
-var config = require('@plyaz/config');
-var types = require('@plyaz/types');
-var api = require('@plyaz/types/api');
+var errors$1 = require('@plyaz/errors');
 var fetchff = require('fetchff');
+var api = require('@plyaz/types/api');
+var logger$1 = require('@plyaz/logger');
+var types = require('@plyaz/types');
+var config = require('@plyaz/config');
+var errors = require('@plyaz/types/errors');
 var async_hooks = require('async_hooks');
 var common = require('@nestjs/common');
 var rxjs = require('rxjs');
-var crypto$1 = require('crypto');
+var crypto2 = require('crypto');
 var reactQuery = require('@tanstack/react-query');
 var react = require('react');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
+
 // @plyaz package - Built with tsup
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -610,7 +633,7 @@ function getCrypto() {
 }
 __name(getCrypto, "getCrypto");
 function generateUUID() {
-  const crypto2 = getCrypto();
+  const crypto3 = getCrypto();
   const UUID_CONSTANTS = {
     BYTES: 16,
     VERSION_POSITION: 6,
@@ -627,12 +650,12 @@ function generateUUID() {
     // eslint-disable-next-line no-magic-numbers
     POSITIONS: [8, 12, 16, 20, 32]
   };
-  if (crypto2 && typeof crypto2.randomUUID === "function") {
-    return crypto2.randomUUID();
+  if (crypto3 && typeof crypto3.randomUUID === "function") {
+    return crypto3.randomUUID();
   }
-  if (crypto2?.getRandomValues) {
+  if (crypto3?.getRandomValues) {
     const bytes = new Uint8Array(UUID_CONSTANTS.BYTES);
-    crypto2.getRandomValues(bytes);
+    crypto3.getRandomValues(bytes);
     bytes[UUID_CONSTANTS.VERSION_POSITION] = bytes[UUID_CONSTANTS.VERSION_POSITION] & UUID_CONSTANTS.VERSION_MASK | UUID_CONSTANTS.VERSION_VALUE;
     bytes[UUID_CONSTANTS.VARIANT_POSITION] = bytes[UUID_CONSTANTS.VARIANT_POSITION] & UUID_CONSTANTS.VARIANT_MASK | UUID_CONSTANTS.VARIANT_VALUE;
     const hex = Array.from(
@@ -1007,302 +1030,6 @@ function applyPollingStrategy(strategy) {
   return strategy;
 }
 __name(applyPollingStrategy, "applyPollingStrategy");
-var ERROR_DEFINITIONS = {
-  // Authentication
-  [api.API_ERROR_CODES.AUTH_UNAUTHORIZED]: {
-    code: api.API_ERROR_CODES.AUTH_UNAUTHORIZED,
-    status: config.HTTP_STATUS.UNAUTHORIZED,
-    category: types.ERROR_CATEGORY.Authentication
-  },
-  [api.API_ERROR_CODES.AUTH_FORBIDDEN]: {
-    code: api.API_ERROR_CODES.AUTH_FORBIDDEN,
-    status: config.HTTP_STATUS.FORBIDDEN,
-    category: types.ERROR_CATEGORY.Authorization
-  },
-  [api.API_ERROR_CODES.AUTH_TOKEN_EXPIRED]: {
-    code: api.API_ERROR_CODES.AUTH_TOKEN_EXPIRED,
-    status: config.HTTP_STATUS.UNAUTHORIZED,
-    category: types.ERROR_CATEGORY.Authentication
-  },
-  [api.API_ERROR_CODES.AUTH_INVALID_CREDENTIALS]: {
-    code: api.API_ERROR_CODES.AUTH_INVALID_CREDENTIALS,
-    status: config.HTTP_STATUS.UNAUTHORIZED,
-    category: types.ERROR_CATEGORY.Authentication
-  },
-  // Rate Limiting
-  [api.API_ERROR_CODES.RATE_LIMIT_EXCEEDED]: {
-    code: api.API_ERROR_CODES.RATE_LIMIT_EXCEEDED,
-    status: config.HTTP_STATUS.TOO_MANY_REQUESTS,
-    category: types.ERROR_CATEGORY.RateLimit
-  },
-  // Resource Errors
-  [api.API_ERROR_CODES.RESOURCE_NOT_FOUND]: {
-    code: api.API_ERROR_CODES.RESOURCE_NOT_FOUND,
-    status: config.HTTP_STATUS.NOT_FOUND,
-    category: types.ERROR_CATEGORY.NotFound
-  },
-  // System Errors
-  [api.API_ERROR_CODES.INTERNAL_SERVER_ERROR]: {
-    code: api.API_ERROR_CODES.INTERNAL_SERVER_ERROR,
-    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: types.ERROR_CATEGORY.Server
-  },
-  [api.API_ERROR_CODES.SERVICE_UNAVAILABLE]: {
-    code: api.API_ERROR_CODES.SERVICE_UNAVAILABLE,
-    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
-    category: types.ERROR_CATEGORY.Server
-  },
-  [api.API_ERROR_CODES.EXTERNAL_SERVICE_ERROR]: {
-    code: api.API_ERROR_CODES.EXTERNAL_SERVICE_ERROR,
-    status: config.HTTP_STATUS.BAD_GATEWAY,
-    category: types.ERROR_CATEGORY.ExternalService
-  },
-  // Validation
-  [api.API_ERROR_CODES.VALIDATION_ERROR]: {
-    code: api.API_ERROR_CODES.VALIDATION_ERROR,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Validation
-  },
-  [api.API_ERROR_CODES.VALIDATION_FAILED]: {
-    code: api.API_ERROR_CODES.VALIDATION_FAILED,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Validation
-  },
-  [api.API_ERROR_CODES.REQUIRED_FIELD_MISSING]: {
-    code: api.API_ERROR_CODES.REQUIRED_FIELD_MISSING,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Validation,
-    fieldsLeft: ["field"]
-  },
-  [api.API_ERROR_CODES.INVALID_FORMAT]: {
-    code: api.API_ERROR_CODES.INVALID_FORMAT,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Validation
-  },
-  [api.API_ERROR_CODES.STRING_TOO_SHORT]: {
-    code: api.API_ERROR_CODES.STRING_TOO_SHORT,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Validation,
-    fieldsLeft: ["field", "minLength"]
-  },
-  [api.API_ERROR_CODES.STRING_TOO_LONG]: {
-    code: api.API_ERROR_CODES.STRING_TOO_LONG,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Validation,
-    fieldsLeft: ["field", "maxLength"]
-  },
-  // Request Errors
-  [api.API_ERROR_CODES.REQUEST_TIMEOUT]: {
-    code: api.API_ERROR_CODES.REQUEST_TIMEOUT,
-    status: config.HTTP_STATUS.REQUEST_TIMEOUT,
-    category: types.ERROR_CATEGORY.Timeout
-  },
-  [api.API_ERROR_CODES.REQUEST_ABORTED]: {
-    code: api.API_ERROR_CODES.REQUEST_ABORTED,
-    status: 0,
-    // No HTTP status for aborted
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.REQUEST_INVALID_PARAMS]: {
-    code: api.API_ERROR_CODES.REQUEST_INVALID_PARAMS,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.REQUEST_PREPARATION_FAILED]: {
-    code: api.API_ERROR_CODES.REQUEST_PREPARATION_FAILED,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Client
-  },
-  // Response Errors
-  [api.API_ERROR_CODES.RESPONSE_INVALID_FORMAT]: {
-    code: api.API_ERROR_CODES.RESPONSE_INVALID_FORMAT,
-    status: config.HTTP_STATUS.UNPROCESSABLE_ENTITY,
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.RESPONSE_PARSING_FAILED]: {
-    code: api.API_ERROR_CODES.RESPONSE_PARSING_FAILED,
-    status: config.HTTP_STATUS.UNPROCESSABLE_ENTITY,
-    category: types.ERROR_CATEGORY.Client
-  },
-  // Network
-  [api.API_ERROR_CODES.NETWORK_ERROR]: {
-    code: api.API_ERROR_CODES.NETWORK_ERROR,
-    status: config.HTTP_STATUS.BAD_GATEWAY,
-    category: types.ERROR_CATEGORY.Network
-  },
-  [api.API_ERROR_CODES.NETWORK_TIMEOUT]: {
-    code: api.API_ERROR_CODES.NETWORK_TIMEOUT,
-    status: config.HTTP_STATUS.GATEWAY_TIMEOUT,
-    category: types.ERROR_CATEGORY.Timeout
-  },
-  [api.API_ERROR_CODES.NETWORK_CONNECTION_FAILED]: {
-    code: api.API_ERROR_CODES.NETWORK_CONNECTION_FAILED,
-    status: 0,
-    // No HTTP status for connection failure
-    category: types.ERROR_CATEGORY.Network
-  },
-  [api.API_ERROR_CODES.NETWORK_OFFLINE]: {
-    code: api.API_ERROR_CODES.NETWORK_OFFLINE,
-    status: 0,
-    // No HTTP status for offline
-    category: types.ERROR_CATEGORY.Network
-  },
-  [api.API_ERROR_CODES.NETWORK_DNS_FAILED]: {
-    code: api.API_ERROR_CODES.NETWORK_DNS_FAILED,
-    status: 0,
-    // No HTTP status for DNS failure
-    category: types.ERROR_CATEGORY.Network
-  },
-  // Server
-  [api.API_ERROR_CODES.SERVER_ERROR]: {
-    code: api.API_ERROR_CODES.SERVER_ERROR,
-    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: types.ERROR_CATEGORY.Server
-  },
-  // Client
-  [api.API_ERROR_CODES.CLIENT_ERROR]: {
-    code: api.API_ERROR_CODES.CLIENT_ERROR,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.CLIENT_CANCELLED]: {
-    code: api.API_ERROR_CODES.CLIENT_CANCELLED,
-    status: 0,
-    // No HTTP status for cancelled
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED]: {
-    code: api.API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
-    status: 0,
-    // No HTTP status for initialization failure
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.CLIENT_INVALID_CONFIG]: {
-    code: api.API_ERROR_CODES.CLIENT_INVALID_CONFIG,
-    status: 0,
-    // No HTTP status for configuration errors
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.CLIENT_MISSING_BASE_URL]: {
-    code: api.API_ERROR_CODES.CLIENT_MISSING_BASE_URL,
-    status: 0,
-    // No HTTP status for configuration errors
-    category: types.ERROR_CATEGORY.Client
-  },
-  [api.API_ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
-    code: api.API_ERROR_CODES.CONFIG_VALIDATION_FAILED,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Validation
-  },
-  [api.API_ERROR_CODES.HEADER_PROCESSING_FAILED]: {
-    code: api.API_ERROR_CODES.HEADER_PROCESSING_FAILED,
-    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: types.ERROR_CATEGORY.Headers
-  },
-  [api.API_ERROR_CODES.NETWORK_OVERRIDE_FAILED]: {
-    code: api.API_ERROR_CODES.NETWORK_OVERRIDE_FAILED,
-    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: types.ERROR_CATEGORY.Network
-  },
-  // Headers
-  [api.API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED]: {
-    code: api.API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Headers
-  },
-  [api.API_ERROR_CODES.HEADERS_VALIDATION_FAILED]: {
-    code: api.API_ERROR_CODES.HEADERS_VALIDATION_FAILED,
-    status: config.HTTP_STATUS.BAD_REQUEST,
-    category: types.ERROR_CATEGORY.Headers
-  },
-  [api.API_ERROR_CODES.HEADERS_MERGE_CONFLICT]: {
-    code: api.API_ERROR_CODES.HEADERS_MERGE_CONFLICT,
-    status: config.HTTP_STATUS.CONFLICT,
-    category: types.ERROR_CATEGORY.Headers
-  },
-  // Cache
-  [api.API_ERROR_CODES.CACHE_STORAGE_FAILED]: {
-    code: api.API_ERROR_CODES.CACHE_STORAGE_FAILED,
-    status: 0,
-    // No HTTP status for cache failures
-    category: types.ERROR_CATEGORY.Cache
-  },
-  [api.API_ERROR_CODES.CACHE_RETRIEVAL_FAILED]: {
-    code: api.API_ERROR_CODES.CACHE_RETRIEVAL_FAILED,
-    status: 0,
-    // No HTTP status for cache failures
-    category: types.ERROR_CATEGORY.Cache
-  },
-  [api.API_ERROR_CODES.CACHE_INVALIDATION_FAILED]: {
-    code: api.API_ERROR_CODES.CACHE_INVALIDATION_FAILED,
-    status: 0,
-    // No HTTP status for cache failures
-    category: types.ERROR_CATEGORY.Cache
-  },
-  // Retry
-  [api.API_ERROR_CODES.RETRY_EXHAUSTED]: {
-    code: api.API_ERROR_CODES.RETRY_EXHAUSTED,
-    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
-    category: types.ERROR_CATEGORY.Retry
-  },
-  [api.API_ERROR_CODES.RETRY_STRATEGY_INVALID]: {
-    code: api.API_ERROR_CODES.RETRY_STRATEGY_INVALID,
-    status: 0,
-    // No HTTP status for strategy errors
-    category: types.ERROR_CATEGORY.Retry
-  },
-  // Strategy
-  [api.API_ERROR_CODES.STRATEGY_INVALID]: {
-    code: api.API_ERROR_CODES.STRATEGY_INVALID,
-    status: 0,
-    // No HTTP status for strategy errors
-    category: types.ERROR_CATEGORY.Strategy
-  },
-  [api.API_ERROR_CODES.STRATEGY_CONFLICT]: {
-    code: api.API_ERROR_CODES.STRATEGY_CONFLICT,
-    status: config.HTTP_STATUS.CONFLICT,
-    category: types.ERROR_CATEGORY.Strategy
-  },
-  // Regional
-  [api.API_ERROR_CODES.REGIONAL_PRESET_NOT_FOUND]: {
-    code: api.API_ERROR_CODES.REGIONAL_PRESET_NOT_FOUND,
-    status: 0,
-    // No HTTP status for regional preset errors
-    category: types.ERROR_CATEGORY.Regional
-  },
-  [api.API_ERROR_CODES.REGION_DETECTION_FAILED]: {
-    code: api.API_ERROR_CODES.REGION_DETECTION_FAILED,
-    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: types.ERROR_CATEGORY.Regional
-  },
-  // Timeout
-  [api.API_ERROR_CODES.TIMEOUT]: {
-    code: api.API_ERROR_CODES.TIMEOUT,
-    status: config.HTTP_STATUS.REQUEST_TIMEOUT,
-    category: types.ERROR_CATEGORY.Timeout
-  },
-  // Unknown
-  [api.API_ERROR_CODES.UNKNOWN_ERROR]: {
-    code: api.API_ERROR_CODES.UNKNOWN_ERROR,
-    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
-    category: types.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 ?? types.ERROR_CATEGORY.Unknown;
-}
-__name(getErrorCategory, "getErrorCategory");
 var BINARY_HEAP = {
   /** Number of children per node in binary heap */
   CHILDREN_PER_NODE: 2,
@@ -2029,8 +1756,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;
@@ -2575,13 +2300,13 @@ var BaseEventFactory = class {
   constructor(namespace, emitter) {
     this.namespace = namespace;
     this.emitter = emitter;
-    api.EVENT_SCOPES.forEach((scope) => {
+    api.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: api.EVENT_SCOPES.length,
+      scopesInitialized: api.EVENT_SCOPES_WITH_TEMPORARY.length,
       emitterType: "EventEmitter"
     });
   }
@@ -2733,16 +2458,14 @@ var BaseEventFactory = class {
    * - Non-scoped wildcards for backwards compatibility (e.g., headers:*)
    */
   emitAcrossScopes(eventType, eventName, data, scopes) {
-    const targetScopes = scopes ?? api.EVENT_SCOPES;
-    const normalizedScopes = targetScopes.map(
-      (s) => s === "temporary" ? "request" : s
-    );
-    const scopeOrder = [...api.EVENT_SCOPES];
+    const targetScopes = scopes ?? api.EVENT_SCOPES_WITH_TEMPORARY;
+    const scopeOrder = [...api.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);
       }
@@ -2940,6 +2663,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
    *
@@ -4688,13 +4457,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}`;
 }
@@ -4886,6 +4655,7 @@ __name(getHandlerNamespaceForEvent, "getHandlerNamespaceForEvent");
 
 // src/api/events/EventManager.ts
 var SLOW_REQUEST_THRESHOLD_MS = 5e3;
+var logger = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.EVENT_MANAGER, transport: "console" });
 var EventManager = class _EventManager extends BaseEventFactory {
   static {
     __name(this, "EventManager");
@@ -4903,7 +4673,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() {
@@ -5079,9 +4849,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
+      });
     });
   }
   /**
@@ -5375,6 +5146,7 @@ var eventManager = {
   getEventStats: /* @__PURE__ */ __name(() => getEventManager().getEventStats(), "getEventStats"),
   getActiveScopes: /* @__PURE__ */ __name(() => getEventManager().getActiveScopes(), "getActiveScopes")
 };
+var logger2 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.EVENT_QUEUE, transport: "console" });
 var EventQueueManager = class _EventQueueManager {
   static {
     __name(this, "EventQueueManager");
@@ -5476,7 +5248,11 @@ var EventQueueManager = class _EventQueueManager {
         }
       }
       if (config.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)
+        });
       }
     }
   }
@@ -7515,6 +7291,7 @@ function colorProgressBar(value, max2, width = DEFAULT_PROGRESS_BAR_WIDTH) {
   return `[${bar}] ${percentText}`;
 }
 __name(colorProgressBar, "colorProgressBar");
+var logger3 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.DEBUG_REPORT, transport: "console" });
 var DEBUG_REPORT_CONSTANTS = {
   // Byte sizes
   BYTES_PER_KB: 1024,
@@ -9260,24 +9037,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 logger$1.ApiLogger({ service: types.LOGGER_SERVICES.UNIFIED_DEBUGGER, transport: "console" });
 var DEBUGGER_CONSTANTS = {
   // Array/Division constants
   HALF_DIVISOR: 2,
@@ -9463,7 +9242,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
@@ -9798,11 +9580,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",
@@ -9810,7 +9592,9 @@ var UnifiedDebugger = class _UnifiedDebugger {
         api.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;
     }
   }
@@ -10127,11 +9911,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) => {
@@ -10193,8 +9977,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",
@@ -10221,16 +10005,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) => {
@@ -10653,14 +10437,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
@@ -10669,8 +10453,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();
@@ -10691,7 +10475,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
@@ -11072,6 +10856,9 @@ function validateConfigUpdate(updates, options) {
   };
 }
 __name(validateConfigUpdate, "validateConfigUpdate");
+new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.CONFIG_QUEUE, transport: "console" });
+new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.QUEUE_ORCHESTRATOR, transport: "console" });
+var logger7 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.OPERATION_TRACKER, transport: "console" });
 var BaseOperationTracker = class {
   constructor(queueName, priorityDetector, sourceDetector) {
     this.queueName = queueName;
@@ -11136,7 +10923,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);
     }
   }
@@ -11145,8 +10935,9 @@ var BaseOperationTracker = class {
    */
   handleProcessingError(error, operation) {
     if (config.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
       });
@@ -11225,6 +11016,14 @@ function createDefaultSourceDetector() {
   };
 }
 __name(createDefaultSourceDetector, "createDefaultSourceDetector");
+new logger$1.ApiLogger({
+  service: types.LOGGER_SERVICES.EVENT_QUEUE_MANAGER,
+  transport: "console"
+});
+var logger9 = new logger$1.ApiLogger({
+  service: types.LOGGER_SERVICES.DEBUGGER_QUEUE_MANAGER,
+  transport: "console"
+});
 var DebuggerQueueManager = class _DebuggerQueueManager {
   static {
     __name(this, "DebuggerQueueManager");
@@ -11296,7 +11095,9 @@ var DebuggerQueueManager = class _DebuggerQueueManager {
       }
     } catch (error) {
       if (config.isDev) {
-        console.warn("[DebuggerQueue] Operation failed:", error);
+        logger9.warn("Operation failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
   }
@@ -11389,6 +11190,7 @@ var DebuggerQueueManager = class _DebuggerQueueManager {
   }
 };
 var MAX_RETRY_ATTEMPTS = 3;
+var logger10 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.OPERATION_TRACKER, transport: "console" });
 var OperationTracker = class _OperationTracker extends BaseOperationTracker {
   static {
     __name(this, "OperationTracker");
@@ -11452,7 +11254,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,
@@ -11461,7 +11268,12 @@ var OperationTracker = class _OperationTracker extends BaseOperationTracker {
         priority: api.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)
+      });
     }
   }
   /**
@@ -11544,6 +11356,7 @@ var trackingQueue = {
     return [];
   }
 };
+var logger11 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.PUB_SUB, transport: "console" });
 var EVENT_CONSTANTS = {
   /** Minimum event segments for scoped events (namespace:scope:event) */
   MIN_SCOPED_SEGMENTS: 2,
@@ -11649,7 +11462,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) => {
@@ -11662,7 +11478,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)
+              });
             }
           });
         }
@@ -11674,7 +11494,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)
+          });
         }
       });
     }
@@ -11839,7 +11662,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;
@@ -11909,847 +11734,228 @@ 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(api.HANDLER_SCOPES[scope], eventName, wrappedHandler, {
-        ...options,
-        originalHandler: handler
-      });
-    }
-  });
+  return mapped;
 }
-__name(registerScopedHandlers, "registerScopedHandlers");
-function retrieveScopedHandlers(scope) {
-  const scopeKey = api.HANDLER_SCOPES[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 errors$1.ApiPackageError {
+  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;
+  }
+  errors$1.registerEventFactory(API_ERROR_NAMESPACE, apiErrorEventFactory);
+  errors$1.ApiPackageError.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(
-    api.HANDLER_SCOPES[scope],
-    type,
-    wrappedHandler,
-    { strategy, originalHandler: handler }
-  );
+  return errors$1.registerErrorHandler(API_ERROR_NAMESPACE, eventType, handler, {
+    ...options,
+    eventFactory: apiErrorEventFactory
+  });
 }
 __name(registerErrorHandler, "registerErrorHandler");
+function registerErrorHandlers(handlers, options = {}) {
+  const { scope = "GLOBAL", ...rest } = options;
+  errors$1.registerScopedHandlers(API_ERROR_NAMESPACE, scope, handlers, {
+    ...rest,
+    eventFactory: apiErrorEventFactory
+  });
+}
+__name(registerErrorHandlers, "registerErrorHandlers");
 function setErrorHandlers(handlers, scope = "GLOBAL") {
-  registerScopedHandlers(scope, handlers);
+  errors$1.setErrorHandlers(API_ERROR_NAMESPACE, handlers, scope, apiErrorEventFactory);
 }
 __name(setErrorHandlers, "setErrorHandlers");
 function getErrorHandlers(scope = "GLOBAL") {
-  return retrieveScopedHandlers(scope);
+  return errors$1.getErrorHandlers(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 = api.HANDLER_SCOPES[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);
-    });
-  }
+  errors$1.unregisterScopedHandlers(API_ERROR_NAMESPACE, scope, eventTypes, apiErrorEventFactory);
 }
 __name(unregisterErrorHandlers, "unregisterErrorHandlers");
 function clearErrorHandlers(options = {}) {
-  const { scopes = ["GLOBAL"] } = options;
-  scopes.forEach((scope) => {
-    const scopeKey = api.HANDLER_SCOPES[scope];
-    eventManager.errors.clearScopedHandlers(scopeKey);
+  errors$1.clearErrorHandlers(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(api.HANDLER_SCOPES[scope], type, (event) => {
-    const eventData = event;
-    const error = eventData?.data?.error ?? event;
-    handler(error);
+  errors$1.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 api.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
-  };
-}
-__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 = api.CORRELATION_TYPE.GENERIC, options) {
-  const generator = getCorrelationGenerator(type);
-  return generator(options);
-}
-__name(generateCorrelationId, "generateCorrelationId");
-function generateContextualCorrelationId(context, type = api.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(api.CORRELATION_TYPE.NETWORK, options);
-}
-__name(generateNetworkCorrelationId, "generateNetworkCorrelationId");
-function generateApiCorrelationId(options) {
-  return generateCorrelationId(api.CORRELATION_TYPE.API, options);
-}
-__name(generateApiCorrelationId, "generateApiCorrelationId");
-function generateSessionCorrelationId(options) {
-  return generateCorrelationId(api.CORRELATION_TYPE.SESSION, options);
-}
-__name(generateSessionCorrelationId, "generateSessionCorrelationId");
-function generateTraceCorrelationId(options) {
-  return generateCorrelationId(api.CORRELATION_TYPE.TRACE, options);
-}
-__name(generateTraceCorrelationId, "generateTraceCorrelationId");
-function extractBaseCorrelationId(contextualId) {
-  let id = extractBaseId(contextualId, { separator: ":", extractLast: true });
-  const prefixes = Object.values(api.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(api.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 = api.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.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 = api.ERROR_DEFINITIONS[errorCode];
-    if (definition?.status !== void 0) {
-      return definition.status;
-    }
-    return config.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$1, clientContext) {
-    const statusCode = responseError.status ?? config.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$1?.url ?? "",
-        method: config$1?.method ?? "GET"
-      }
-    });
-  }
-  /**
-   * Creates an ApiPackageError from a standard Error
-   */
-  static fromError(error, statusCode, errorCode = api.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.API_ERROR_CODES.NETWORK_ERROR, status: 0 };
-    }
-    if (error.name === "TimeoutError" || error.message.includes("timeout")) {
-      return { code: api.API_ERROR_CODES.REQUEST_TIMEOUT, status: config.HTTP_STATUS.REQUEST_TIMEOUT };
-    }
-    if (error.name === "AbortError") {
-      return { code: api.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.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.API_ERROR_CODES.NETWORK_ERROR;
-    }
-    if (status >= config.HTTP_STATUS.BAD_REQUEST && status < config.HTTP_STATUS.INTERNAL_SERVER_ERROR) {
-      return api.API_ERROR_CODES.CLIENT_ERROR;
-    }
-    if (status >= config.HTTP_STATUS.INTERNAL_SERVER_ERROR) {
-      return api.API_ERROR_CODES.SERVER_ERROR;
-    }
-    return api.API_ERROR_CODES.UNKNOWN_ERROR;
-  }
-  /**
-   * Gets the error category from ERROR_DEFINITIONS
-   */
-  categorizeError() {
-    const definition = api.ERROR_DEFINITIONS[this.errorCode];
-    return definition?.category ?? types.ERROR_CATEGORY.Unknown;
-  }
-  /**
-   * Checks if this is a specific category of error
-   */
-  isAuthError() {
-    return this.category === types.ERROR_CATEGORY.Authentication || this.category === types.ERROR_CATEGORY.Authorization;
-  }
-  isValidationError() {
-    return this.category === types.ERROR_CATEGORY.Validation;
-  }
-  isNetworkError() {
-    return this.category === types.ERROR_CATEGORY.Network;
-  }
-  isServerError() {
-    return this.category === types.ERROR_CATEGORY.Server;
-  }
-  isClientError() {
-    return this.statusCode >= config.HTTP_STATUS.BAD_REQUEST && this.statusCode < config.HTTP_STATUS.INTERNAL_SERVER_ERROR;
-  }
-  isRetryable() {
-    return this.category === types.ERROR_CATEGORY.Network || this.category === types.ERROR_CATEGORY.Server || this.category === types.ERROR_CATEGORY.Timeout || this.statusCode === config.HTTP_STATUS.TOO_MANY_REQUESTS || // Rate limit
-    this.statusCode >= config.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 = {
-      [types.ERROR_CATEGORY.Authentication]: "Authentication failed. Please check your credentials.",
-      [types.ERROR_CATEGORY.Authorization]: "You do not have permission to perform this action.",
-      [types.ERROR_CATEGORY.Validation]: "Please check your input and try again.",
-      [types.ERROR_CATEGORY.NotFound]: "The requested resource was not found.",
-      [types.ERROR_CATEGORY.RateLimit]: "Too many requests. Please try again later.",
-      [types.ERROR_CATEGORY.Network]: "Network error. Please check your connection.",
-      [types.ERROR_CATEGORY.Timeout]: "The request timed out. Please try again.",
-      [types.ERROR_CATEGORY.Server]: "Server error. Please try again later.",
-      [types.ERROR_CATEGORY.Client]: "Client error. Please check your request.",
-      [types.ERROR_CATEGORY.Blockchain]: "Blockchain error. Please try again later.",
-      [types.ERROR_CATEGORY.ExternalService]: "External service error. Please try again later.",
-      [types.ERROR_CATEGORY.Conflict]: "Conflict detected. Please resolve and try again.",
-      [types.ERROR_CATEGORY.Cache]: "Cache error. Please try again.",
-      [types.ERROR_CATEGORY.Headers]: "Headers error. Please check your request headers.",
-      [types.ERROR_CATEGORY.Retry]: "Retry limit exceeded. Please try again later.",
-      [types.ERROR_CATEGORY.Strategy]: "Strategy error. Invalid configuration.",
-      [types.ERROR_CATEGORY.Regional]: "Regional configuration error. Please check your region settings.",
-      [types.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;
+  return config;
 }
 __name(getSSRSafePollingConfig, "getSSRSafePollingConfig");
 function createProgressivePolling(options = {}) {
@@ -12777,11 +11983,11 @@ function createConditionalPolling(options) {
       if (options.errorCondition?.(response)) {
         new ApiPackageError(
           "polling.error_condition",
-          PACKAGE_STATUS_CODES3.OPERATION_FAILED,
-          API_ERROR_CODES6.POLLING_CANCELLED,
+          errors.INTERNAL_STATUS_CODES.OPERATION_FAILED,
+          errors.API_ERROR_CODES.POLLING_CANCELLED,
           {
             context: {
-              operation: OPERATIONS3.POLLING,
+              operation: errors.COMMON_OPERATIONS.POLLING,
               reason: "Error condition met",
               i18n: {
                 reason: "error_condition"
@@ -12796,11 +12002,11 @@ function createConditionalPolling(options) {
         if (elapsed >= options.timeoutMs) {
           new ApiPackageError(
             "polling.timeout",
-            PACKAGE_STATUS_CODES3.OPERATION_FAILED,
-            API_ERROR_CODES6.POLLING_TIMEOUT,
+            errors.INTERNAL_STATUS_CODES.OPERATION_FAILED,
+            errors.API_ERROR_CODES.POLLING_TIMEOUT,
             {
               context: {
-                operation: OPERATIONS3.POLLING,
+                operation: errors.COMMON_OPERATIONS.POLLING,
                 timeoutMs: options.timeoutMs,
                 elapsed,
                 i18n: {
@@ -13967,7 +13173,7 @@ function filterToFetchffProperties(config) {
     maxPollingAttempts,
     shouldStopPolling,
     fetcher,
-    logger,
+    logger: logger19,
     // Cache properties
     cacheTime,
     staleTime,
@@ -14060,7 +13266,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;
@@ -14437,11 +13643,33 @@ function trackGlobalConfigUpdate(params) {
   });
 }
 __name(trackGlobalConfigUpdate, "trackGlobalConfigUpdate");
+function handleGlobalErrorSystemConfig(errorConfig) {
+  const alreadyInitialized = errors$1.isErrorSystemInitialized();
+  if (alreadyInitialized) {
+    if (errorConfig.locale) {
+      errors$1.setErrorLocale(errorConfig.locale);
+    }
+    if (errorConfig.additionalCatalogs) {
+      Object.entries(errorConfig.additionalCatalogs).forEach(([locale, catalog]) => {
+        errors$1.addMessageCatalog(locale, catalog, true);
+      });
+    }
+  } else {
+    errors$1.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
@@ -14616,10 +13844,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",
@@ -14632,9 +13856,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",
@@ -14712,6 +13933,213 @@ 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/virustotal.ts
+var virusTotalEndpoints = {
+  // ========== File Scanning ==========
+  /**
+   * POST /files - Upload file for scanning
+   * Multipart/form-data with file attachment
+   * See official documentation for current free tier limits:
+   * https://developers.virustotal.com/reference/overview#public-vs-premium-api
+   *
+   * @returns {object} response - Upload response with analysis ID
+   * @returns {string} response.data.id - Analysis ID for polling results
+   */
+  uploadFileForScanning: {
+    url: "/files",
+    method: "POST"
+  },
+  /**
+   * GET /analyses/{id} - Get analysis result
+   * Retrieve scan results for previously uploaded file
+   *
+   * @param {string} id - Analysis ID from upload response
+   * @returns {object} response - Analysis result with threat details
+   */
+  getAnalysisResult: {
+    url: "/analyses/:id",
+    method: "GET",
+    cacheTime: 0
+    // Don't cache scan results (they update)
+  },
+  // ========== Health & Info ==========
+  /**
+   * GET /version - Get API version info (health check)
+   * Simple endpoint to verify API availability
+   */
+  getApiVersion: {
+    url: "/version",
+    method: "GET",
+    cacheTime: 300,
+    // Cache for 5 minutes
+    staleTime: 600
+  }
+};
+({
+  ...virusTotalEndpoints
+});
+var cloudflareEndpoints = {
+  /**
+   * POST /zones/{zoneId}/purge_cache - Purge files from cache
+   * Purge specific files or all files in a zone
+   * Rate limits may change; see official documentation for current limits:
+   * https://developers.cloudflare.com/api/operations/zone-purge#rate-limits
+   *
+   * @param {string} zoneId - Cloudflare Zone ID
+   * @returns {object} response - Purge result with success status
+   */
+  cloudflarePurgeCache: {
+    url: "/zones/:zoneId/purge_cache",
+    method: "POST",
+    cacheTime: 0
+    // Don't cache purge operations
+  }
+};
+var cloudFrontEndpoints = {
+  /**
+   * POST /{apiVersion}/distribution/{distributionId}/invalidation - Create invalidation
+   * Creates an invalidation batch for specified paths
+   * Rate limits may change; see the official AWS documentation for current limits:
+   * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/cloudfront-limits.html
+   * Requires AWS Signature Version 4 authentication
+   *
+   * @param {string} distributionId - CloudFront Distribution ID
+   * @returns {object} response - Invalidation result with ID and status
+   */
+  cloudFrontCreateInvalidation: {
+    url: `/${config.AWS_CLOUDFRONT_CONFIG.API_VERSION}/distribution/:distributionId/invalidation`,
+    method: "POST",
+    cacheTime: 0
+  }
+};
+var fastlyEndpoints = {
+  /**
+   * POST /service/{serviceId}/purge/{url} - Purge single URL
+   * Instant soft-purge of specific URL
+   * Rate limit: Unlimited soft-purges. Hard-purges are limited to 1000 requests per hour per service (as of 2024-06). See Fastly documentation for updates:
+   * @see https://developer.fastly.com/reference/api/purging/#rate-limits
+   *
+   * @param {string} serviceId - Fastly Service ID
+   * @param {string} url - URL to purge (URL-encoded)
+   * @returns {object} response - Purge result with status
+   */
+  fastlyPurgeUrl: {
+    url: "/service/:serviceId/purge/:url",
+    method: "POST",
+    cacheTime: 0
+  }
+};
+var cdnEndpoints = {
+  ...cloudflareEndpoints,
+  ...cloudFrontEndpoints,
+  ...fastlyEndpoints
+};
+
 // src/api/endpoints/utils.ts
 function getEndpointUrl(name) {
   return endpoints[name].url;
@@ -14884,7 +14312,15 @@ __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,
+  // VirusTotal third-party provider endpoints (Virus/Malware scanning)
+  ...virusTotalEndpoints,
+  // CDN provider endpoints (Cloudflare, CloudFront, Fastly)
+  ...cloudflareEndpoints,
+  ...cloudFrontEndpoints,
+  ...fastlyEndpoints
 };
 var isSlowConnection = fetchff.isSlowConnection;
 function isNetworkAPISupported() {
@@ -18265,6 +17701,7 @@ async function prepareRequestConfigWithEnrichedHeaders(requestConfig, clientConf
   return config;
 }
 __name(prepareRequestConfigWithEnrichedHeaders, "prepareRequestConfigWithEnrichedHeaders");
+new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.EXPRESS_FRAMEWORK, transport: "console" });
 var networkDetectionMiddleware = /* @__PURE__ */ __name((req, res, next) => {
   const headerInfo = getNetworkInfoFromHeaders(req.headers);
   const networkInfo = {
@@ -18425,6 +17862,7 @@ __name(exports.MinimumConnectionGuard, "MinimumConnectionGuard");
 exports.MinimumConnectionGuard = __decorateClass([
   common.Injectable()
 ], exports.MinimumConnectionGuard);
+var logger13 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.NESTJS_GUARD, transport: "console" });
 var EnrichedHeadersGuard = class {
   constructor(options = {}) {
     this.options = options;
@@ -18439,7 +17877,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;
       }
@@ -18456,7 +17894,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;
     }
@@ -18466,7 +17904,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
         });
@@ -18480,7 +17918,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"]
@@ -18496,7 +17934,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;
   }
@@ -18528,7 +17966,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",
@@ -18576,6 +18016,7 @@ __name(EnrichedHeadersGuard, "EnrichedHeadersGuard");
 EnrichedHeadersGuard = __decorateClass([
   common.Injectable()
 ], EnrichedHeadersGuard);
+var logger14 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.NESTJS_INTERCEPTOR, transport: "console" });
 var EnrichedHeadersInterceptor = class {
   constructor(options = {}) {
     this.options = options;
@@ -18627,7 +18068,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",
@@ -18652,7 +18095,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",
@@ -18696,7 +18141,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",
@@ -18723,7 +18170,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"]
@@ -18731,7 +18178,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;
@@ -19456,65 +18903,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;
@@ -19796,6 +19184,10 @@ function getAllMediaExtensions() {
 }
 __name(getAllMediaExtensions, "getAllMediaExtensions");
 var MEDIA_MIME_PREFIXES = ["image/", "video/", "audio/"];
+var logger15 = new logger$1.ApiLogger({
+  service: types.LOGGER_SERVICES.CLIENT_EVENT_MANAGER,
+  transport: "console"
+});
 var EVENT_CONSTANTS2 = {
   DEBUG_INFO_INTERVAL_MULTIPLIER: 5,
   IMPACT_THRESHOLDS: {
@@ -20008,7 +19400,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) => {
@@ -20525,10 +19919,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);
+    errors$1.emitScopedErrorEvent(API_ERROR_NAMESPACE, error, {
+      scopes: ["CLIENT"],
+      eventFactory: apiErrorEventFactory,
+      category: error.category
+    });
   }
   /**
    * Emit request start event
@@ -21415,8 +20819,6 @@ function mergeHeaders(...headerSets) {
   return result;
 }
 __name(mergeHeaders, "mergeHeaders");
-
-// src/api/headers/headerBuilder.ts
 var HeaderBuilder = class {
   static {
     __name(this, "HeaderBuilder");
@@ -21651,7 +21053,7 @@ var HeaderBuilder = class {
    * ```
    */
   correlationId(id) {
-    this._headers["x-correlation-id"] = id ?? generateCorrelationId();
+    this._headers["x-correlation-id"] = id ?? errors$1.generateCorrelationId("req_correlation");
     return this;
   }
   /**
@@ -21667,7 +21069,7 @@ var HeaderBuilder = class {
    * ```
    */
   requestId(id) {
-    this._headers["x-request-id"] = id ?? generateRequestId();
+    this._headers["x-request-id"] = id ?? errors$1.generateRequestId();
     return this;
   }
   /**
@@ -21683,7 +21085,7 @@ var HeaderBuilder = class {
    * ```
    */
   traceId(traceId) {
-    this._headers["x-trace-id"] = traceId ?? generateTraceCorrelationId();
+    this._headers["x-trace-id"] = traceId ?? errors$1.generateTraceCorrelationId();
     return this;
   }
   /**
@@ -21993,7 +21395,7 @@ function getHeaderFingerprint(headers2) {
     return "no-cache-affecting-headers";
   }
   const content = parts.join("|");
-  return crypto$1.createHash("sha256").update(content).digest("hex").substring(0, FINGERPRINT_LENGTH);
+  return crypto2.createHash("sha256").update(content).digest("hex").substring(0, FINGERPRINT_LENGTH);
 }
 __name(getHeaderFingerprint, "getHeaderFingerprint");
 
@@ -22990,10 +22392,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 = config.HTTP_STATUS.OK;
+var logger16 = new logger$1.ApiLogger({ service: types.LOGGER_SERVICES.INTERCEPTORS, transport: "console" });
 function trackHeaderChanges(beforeHeaders, afterHeaders, interceptorIndex) {
   const changes = [];
   Object.entries(afterHeaders).forEach(([key, value]) => {
@@ -23036,7 +22437,7 @@ function createOnRetryHandler(handlers) {
   return (response, retryAttempt) => {
     const performanceFactory = getPerformanceEventFactory();
     performanceFactory.emitRetry({
-      requestId: generateRequestId(),
+      requestId: errors$1.generateRequestId(),
       attempt: retryAttempt,
       maxAttempts: DEFAULT_MAX_RETRIES,
       reason: response.error?.message ?? "Retry attempt",
@@ -23053,10 +22454,30 @@ 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();
+    const requestId = errors$1.generateRequestId();
     startRequestTracking(requestId);
     UnifiedDebugger.getInstance().trackConfigChange(
       { headers: config.headers },
@@ -23077,12 +22498,28 @@ function createOnRequestHandler(handlers, enrichedHeadersConfig, encryptionConfi
           "enrichedHeaders",
           { requestId }
         );
-        processedConfig = {
-          ...processedConfig,
-          headers: enrichedHeaders
-        };
+        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) {
-        console.error("Failed to enrich headers:", error);
+        logger16.error("Failed to enrich headers", {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
     if (encryptionConfig?.enabled) {
@@ -23092,7 +22529,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) {
@@ -23111,7 +22550,7 @@ function createOnResponseHandler(handlers, clearTemporaryOverrides2, clearOnComp
   return async (response) => {
     const performanceFactory = getPerformanceEventFactory();
     performanceFactory.emitRequestComplete({
-      requestId: generateRequestId(),
+      requestId: errors$1.generateRequestId(),
       url: response.config?.url ?? "",
       method: response.config?.method ?? "GET",
       status: response.status ?? DEFAULT_SUCCESS_STATUS,
@@ -23132,7 +22571,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) {
@@ -23146,7 +22587,7 @@ function createOnErrorHandler(handlers, clearTemporaryOverrides2, clearOnComplet
   return async (error) => {
     const performanceFactory = getPerformanceEventFactory();
     performanceFactory.emitRequestComplete({
-      requestId: generateRequestId(),
+      requestId: errors$1.generateRequestId(),
       url: error.config?.url ?? "",
       method: error.config?.method ?? "GET",
       status: error.status ?? 0,
@@ -23229,8 +22670,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,
@@ -23242,13 +22689,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 logger$1.ApiLogger({ service: types.LOGGER_SERVICES.API_CLIENT, transport: "console" });
 function applyStrategies(config, options) {
   let resolvedConfig = config;
   if (options.unifiedStrategy) {
@@ -23278,12 +22724,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);
@@ -23314,12 +22759,12 @@ async function finalizeConfig(resolvedConfig, options) {
   } catch (error) {
     new ApiPackageError(
       "headers.processing.failed",
-      PACKAGE_STATUS_CODES3.OPERATION_FAILED,
-      API_ERROR_CODES6.HEADERS_ENRICHMENT_FAILED,
+      errors.INTERNAL_STATUS_CODES.OPERATION_FAILED,
+      errors.API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
       {
         cause: error instanceof Error ? error : void 0,
         context: {
-          operation: OPERATIONS3.ENRICHMENT,
+          operation: errors.COMMON_OPERATIONS.ENRICHMENT,
           originalError: error instanceof Error ? error.message : String(error),
           i18n: {
             error: error instanceof Error ? error.message : String(error)
@@ -23360,12 +22805,12 @@ __name(applyDefaultOptions, "applyDefaultOptions");
 function handleClientInitError(error) {
   throw new ApiPackageError(
     "client.initialization.failed",
-    PACKAGE_STATUS_CODES3.INITIALIZATION_FAILED,
-    API_ERROR_CODES6.CLIENT_INITIALIZATION_FAILED,
+    errors.INTERNAL_STATUS_CODES.INITIALIZATION_FAILED,
+    errors.API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
     {
       cause: error instanceof Error ? error : void 0,
       context: {
-        operation: OPERATIONS3.INITIALIZATION,
+        operation: errors.COMMON_OPERATIONS.INITIALIZATION,
         originalError: error instanceof Error ? error.message : String(error),
         i18n: {
           error: error instanceof Error ? error.message : String(error)
@@ -23476,7 +22921,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(
     api.EVENT_OPERATIONS.CONFIG_UPDATE_FAILED,
     "updateConfig",
@@ -23551,6 +22998,25 @@ function trackSuccessfulConfigUpdate(params) {
   );
 }
 __name(trackSuccessfulConfigUpdate, "trackSuccessfulConfigUpdate");
+function handleClientErrorSystemConfig(errorConfig) {
+  const alreadyInitialized = errors$1.isErrorSystemInitialized();
+  if (alreadyInitialized) {
+    if (errorConfig.locale) {
+      errors$1.setErrorLocale(errorConfig.locale);
+    }
+    if (errorConfig.additionalCatalogs) {
+      Object.entries(errorConfig.additionalCatalogs).forEach(([locale, catalog]) => {
+        errors$1.addMessageCatalog(locale, catalog, true);
+      });
+    }
+  } else {
+    errors$1.initializeErrorSystem({
+      defaultLocale: errorConfig.locale,
+      additionalCatalogs: errorConfig.additionalCatalogs
+    });
+  }
+}
+__name(handleClientErrorSystemConfig, "handleClientErrorSystemConfig");
 function createUpdateConfigMethod(initialConfigState, eventManager2, client, setConfigState) {
   let configState = initialConfigState;
   return (updates, updateOptions) => {
@@ -23560,6 +23026,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);
@@ -23588,9 +23057,62 @@ function createUpdateConfigMethod(initialConfigState, eventManager2, client, set
   };
 }
 __name(createUpdateConfigMethod, "createUpdateConfigMethod");
+function createFetchffClient(fetchffConfig, effectiveConfig, options, unifiedHandlers) {
+  return fetchff.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);
@@ -23598,58 +23120,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 = fetchff.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);
     }
@@ -23724,18 +23231,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 reactQuery.useMutation(
       mergedMutationOptions
     );
@@ -24181,6 +23683,10 @@ function getEnhancedClientHints(headers2, options) {
   return response;
 }
 __name(getEnhancedClientHints, "getEnhancedClientHints");
+var logger18 = new logger$1.ApiLogger({
+  service: types.LOGGER_SERVICES.NETWORK_CONFIGURATION,
+  transport: "console"
+});
 var NetworkConfigurationManager = class {
   static {
     __name(this, "NetworkConfigurationManager");
@@ -24246,9 +23752,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
@@ -24424,7 +23932,7 @@ var NetworkConfigurationManager = class {
       }
     });
     this.cleanupFunctions.push(unsubscribe);
-    console.log("🔄 Auto preset switching enabled");
+    logger18.info("Auto preset switching enabled");
   }
   /**
    * Disable automatic preset monitoring
@@ -24433,7 +23941,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
@@ -24447,7 +23955,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
@@ -24699,7 +24207,7 @@ var NetworkConfigurationManager = class {
       changes.push("caching");
     }
     if (changes.length > 0) {
-      console.log(`👤 User preferences updated: ${changes.join(", ")}`);
+      logger18.info("User preferences updated", { changes });
     }
   }
   /**
@@ -25206,7 +24714,7 @@ function useOptimisticUpdate(key, initialData) {
     const nextState = {
       data: response.data,
       isValidating: response.isFetching ?? false,
-      error: response.error ?? void 0
+      error: response.error
     };
     setState(nextState);
   });
@@ -25683,6 +25191,684 @@ 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.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.to) {
+    throw new ApiPackageError(
+      "Missing required field: to",
+      void 0,
+      api.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.subject) {
+    throw new ApiPackageError(
+      "Missing required field: subject",
+      void 0,
+      api.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.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.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.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+      );
+    }
+    if (!message.content?.subject) {
+      throw new ApiPackageError(
+        `Missing required field: messages[${index}].content.subject`,
+        void 0,
+        api.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.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.to.includes("@")) {
+    throw new ApiPackageError(
+      "Invalid email format: must contain @",
+      void 0,
+      api.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.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.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.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.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.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");
+async function uploadFileForScanning(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.file) {
+    throw new ApiPackageError(
+      "Missing required field: file",
+      void 0,
+      api.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (!payload.filename) {
+    throw new ApiPackageError(
+      "Missing required field: filename",
+      void 0,
+      api.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  if (payload.file.length === 0) {
+    throw new ApiPackageError(
+      "File buffer cannot be empty",
+      void 0,
+      api.API_ERROR_CODES.INVALID_INPUT
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    // Allow retries for network issues
+    timeout: 6e4
+    // 60 second timeout for file uploads
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  const formData = new FormData();
+  const blob = new Blob([new Uint8Array(payload.file)]);
+  formData.append("file", blob, payload.filename);
+  return client.uploadFileForScanning({
+    body: formData
+  });
+}
+__name(uploadFileForScanning, "uploadFileForScanning");
+async function getAnalysisResult(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.analysisId) {
+    throw new ApiPackageError(
+      "Missing required field: analysisId",
+      void 0,
+      api.API_ERROR_CODES.REQUIRED_FIELD_MISSING
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 3 },
+    // Allow retries for polling
+    timeout: 3e4,
+    // 30 second timeout
+    cacheTime: 0
+    // Don't cache (results change as scan progresses)
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.getAnalysisResult({
+    params: { id: payload.analysisId }
+  });
+}
+__name(getAnalysisResult, "getAnalysisResult");
+async function cloudflarePurgeCache(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.zoneId) {
+    throw new ApiPackageError(
+      "Missing required field: zoneId",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFLARE_ZONE_NOT_FOUND
+    );
+  }
+  if (!payload.apiToken) {
+    throw new ApiPackageError(
+      "Missing required field: apiToken",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.CLOUDFLARE_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.files || payload.files.length === 0) {
+    throw new ApiPackageError(
+      "Missing required field: files (must be non-empty array)",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFLARE_INVALID_URL
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    timeout: 3e4
+    // 30 seconds
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.cloudflarePurgeCache({
+    params: { zoneId: payload.zoneId },
+    headers: {
+      Authorization: `Bearer ${payload.apiToken}`
+    },
+    body: {
+      files: payload.files,
+      zoneId: payload.zoneId,
+      apiToken: payload.apiToken
+    }
+  });
+}
+__name(cloudflarePurgeCache, "cloudflarePurgeCache");
+function generateAWSSignatureV4(options) {
+  const {
+    accessKeyId,
+    secretAccessKey,
+    sessionToken,
+    region,
+    service,
+    method,
+    path,
+    queryString = "",
+    headers: headers2,
+    payload,
+    host
+  } = options;
+  const timestamp = options.timestamp ?? (/* @__PURE__ */ new Date()).toISOString().replace(/[:-]|\.\d{3}/g, "");
+  const dateStamp = timestamp.split("T")[0];
+  const baseHeaders = { ...headers2 };
+  if (!Object.keys(baseHeaders).some((h) => h.toLowerCase() === "host")) {
+    baseHeaders["Host"] = host;
+  }
+  if (sessionToken) {
+    baseHeaders["X-Amz-Security-Token"] = sessionToken;
+  }
+  baseHeaders["X-Amz-Date"] = timestamp;
+  const canonicalHeaders = Object.keys(baseHeaders).sort().map((key) => `${key.toLowerCase()}:${baseHeaders[key].trim()}`).join("\n");
+  const signedHeaders = Object.keys(baseHeaders).sort().map((key) => key.toLowerCase()).join(";");
+  const payloadHash = crypto2__namespace.createHash("sha256").update(payload).digest("hex");
+  const canonicalRequest = [
+    method,
+    path,
+    queryString,
+    canonicalHeaders + "\n",
+    signedHeaders,
+    payloadHash
+  ].join("\n");
+  const algorithm = "AWS4-HMAC-SHA256";
+  const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const canonicalRequestHash = crypto2__namespace.createHash("sha256").update(canonicalRequest).digest("hex");
+  const stringToSign = [algorithm, timestamp, credentialScope, canonicalRequestHash].join("\n");
+  const kDate = crypto2__namespace.createHmac("sha256", `AWS4${secretAccessKey}`).update(dateStamp).digest();
+  const kRegion = crypto2__namespace.createHmac("sha256", kDate).update(region).digest();
+  const kService = crypto2__namespace.createHmac("sha256", kRegion).update(service).digest();
+  const kSigning = crypto2__namespace.createHmac("sha256", kService).update("aws4_request").digest();
+  const signature = crypto2__namespace.createHmac("sha256", kSigning).update(stringToSign).digest("hex");
+  const authorization = `${algorithm} Credential=${accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  return {
+    headers: baseHeaders,
+    authorization
+  };
+}
+__name(generateAWSSignatureV4, "generateAWSSignatureV4");
+
+// src/api/utils/aws/xml/cloudfront.ts
+function generateCloudFrontInvalidationXML(paths, callerReference) {
+  const items = paths.map((path) => `<Path>${escapeXml(path)}</Path>`).join("\n    ");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<InvalidationBatch xmlns="http://cloudfront.amazonaws.com/doc/2020-05-31/">
+  <Paths>
+    <Quantity>${paths.length}</Quantity>
+    <Items>
+    ${items}
+    </Items>
+  </Paths>
+  <CallerReference>${escapeXml(callerReference)}</CallerReference>
+</InvalidationBatch>`;
+}
+__name(generateCloudFrontInvalidationXML, "generateCloudFrontInvalidationXML");
+function escapeXml(str) {
+  const xmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&apos;"
+  };
+  return str.replace(/[&<>"']/g, (ch) => xmlEscapes[ch]);
+}
+__name(escapeXml, "escapeXml");
+function generateCloudFrontCallerReference(prefix = "api") {
+  return `${prefix}-${Date.now()}`;
+}
+__name(generateCloudFrontCallerReference, "generateCloudFrontCallerReference");
+
+// src/api/services/cdn/cloudfront/POST/cloudFrontCreateInvalidation.ts
+async function cloudFrontCreateInvalidation(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.distributionId) {
+    throw new ApiPackageError(
+      "Missing required field: distributionId",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFRONT_DISTRIBUTION_NOT_FOUND
+    );
+  }
+  if (!payload.accessKeyId) {
+    throw new ApiPackageError(
+      "Missing required field: accessKeyId",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.CLOUDFRONT_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.secretAccessKey) {
+    throw new ApiPackageError(
+      "Missing required field: secretAccessKey",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.CLOUDFRONT_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.paths || payload.paths.length === 0) {
+    throw new ApiPackageError(
+      "Missing required field: paths (must be non-empty array)",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.CLOUDFRONT_INVALID_PATH
+    );
+  }
+  const region = payload.region ?? config.AWS_CLOUDFRONT_CONFIG.DEFAULT_REGION;
+  const service = config.AWS_CLOUDFRONT_CONFIG.SERVICE_NAME;
+  const host = config.AWS_CLOUDFRONT_CONFIG.HOST;
+  const method = "POST";
+  const path = `/${config.AWS_CLOUDFRONT_CONFIG.API_VERSION}/distribution/${payload.distributionId}/invalidation`;
+  const callerReference = generateCloudFrontCallerReference("api");
+  const body = generateCloudFrontInvalidationXML(payload.paths, callerReference);
+  const { headers: signedHeaders, authorization } = generateAWSSignatureV4({
+    accessKeyId: payload.accessKeyId,
+    secretAccessKey: payload.secretAccessKey,
+    sessionToken: payload.sessionToken,
+    region,
+    service,
+    method,
+    path,
+    host,
+    headers: {
+      "Content-Type": "application/xml"
+    },
+    payload: body
+  });
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    timeout: 3e4
+    // 30 seconds
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.cloudFrontCreateInvalidation({
+    params: { distributionId: payload.distributionId },
+    headers: {
+      ...signedHeaders,
+      Authorization: authorization
+    },
+    body
+  });
+}
+__name(cloudFrontCreateInvalidation, "cloudFrontCreateInvalidation");
+async function fastlyPurgeUrl(payload, options) {
+  const client = options?.apiClient ?? getDefaultApiClient();
+  if (!payload.serviceId) {
+    throw new ApiPackageError(
+      "Missing required field: serviceId",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.FASTLY_SERVICE_NOT_FOUND
+    );
+  }
+  if (!payload.apiToken) {
+    throw new ApiPackageError(
+      "Missing required field: apiToken",
+      config.HTTP_STATUS.UNAUTHORIZED,
+      api.API_ERROR_CODES.FASTLY_AUTHENTICATION_FAILED
+    );
+  }
+  if (!payload.url) {
+    throw new ApiPackageError(
+      "Missing required field: url",
+      config.HTTP_STATUS.BAD_REQUEST,
+      api.API_ERROR_CODES.FASTLY_INVALID_URL
+    );
+  }
+  const serviceDefaults = {
+    retry: { attempts: 2 },
+    timeout: 15e3
+    // 15 seconds
+  };
+  const mergedConfig = mergeConfigs(serviceDefaults, options?.apiConfig ?? {});
+  const updateOptions = {
+    strategy: "temporary",
+    ...options?.updateConfigOptions
+  };
+  if (shouldApplyConfig(mergedConfig, updateOptions)) {
+    client.updateConfig(mergedConfig, updateOptions);
+  }
+  return client.fastlyPurgeUrl({
+    params: {
+      serviceId: payload.serviceId,
+      url: encodeURIComponent(payload.url)
+    },
+    headers: {
+      "Fastly-Key": payload.apiToken
+    }
+  });
+}
+__name(fastlyPurgeUrl, "fastlyPurgeUrl");
 function getSSRSafeConfig(config) {
   if (!isBrowser()) {
     return {
@@ -25900,17 +26086,29 @@ __name(toFetchffRevalidationConfig, "toFetchffRevalidationConfig");
   resources: revalidationStrategies.static
 });
 
-Object.defineProperty(exports, "ErrorCategory", {
+Object.defineProperty(exports, "getErrorCategory", {
   enumerable: true,
-  get: function () { return types.ERROR_CATEGORY; }
+  get: function () { return errors$1.getErrorCategory; }
 });
-Object.defineProperty(exports, "API_ERROR_CODES", {
+Object.defineProperty(exports, "getErrorCodeByStatus", {
   enumerable: true,
-  get: function () { return api.API_ERROR_CODES; }
+  get: function () { return errors$1.getErrorCodeByStatus; }
 });
-Object.defineProperty(exports, "ERROR_DEFINITIONS", {
+Object.defineProperty(exports, "getErrorDefinition", {
+  enumerable: true,
+  get: function () { return errors$1.getErrorDefinition; }
+});
+Object.defineProperty(exports, "removeRevalidators", {
   enumerable: true,
-  get: function () { return api.ERROR_DEFINITIONS; }
+  get: function () { return fetchff.removeRevalidators; }
+});
+Object.defineProperty(exports, "revalidate", {
+  enumerable: true,
+  get: function () { return fetchff.revalidate; }
+});
+Object.defineProperty(exports, "revalidateAll", {
+  enumerable: true,
+  get: function () { return fetchff.revalidateAll; }
 });
 Object.defineProperty(exports, "NETWORK_QUALITY", {
   enumerable: true,
@@ -25920,17 +26118,25 @@ Object.defineProperty(exports, "PUB_SUB_EVENT", {
   enumerable: true,
   get: function () { return api.PUB_SUB_EVENT; }
 });
-Object.defineProperty(exports, "removeRevalidators", {
+Object.defineProperty(exports, "API_ERROR_CODES", {
   enumerable: true,
-  get: function () { return fetchff.removeRevalidators; }
+  get: function () { return errors.API_ERROR_CODES; }
 });
-Object.defineProperty(exports, "revalidate", {
+Object.defineProperty(exports, "ERROR_DEFINITIONS", {
   enumerable: true,
-  get: function () { return fetchff.revalidate; }
+  get: function () { return errors.ERROR_DEFINITIONS; }
 });
-Object.defineProperty(exports, "revalidateAll", {
+Object.defineProperty(exports, "ERROR_FIELDS", {
   enumerable: true,
-  get: function () { return fetchff.revalidateAll; }
+  get: function () { return errors.COMMON_FIELDS; }
+});
+Object.defineProperty(exports, "OPERATIONS", {
+  enumerable: true,
+  get: function () { return errors.COMMON_OPERATIONS; }
+});
+Object.defineProperty(exports, "STORAGE_TYPES", {
+  enumerable: true,
+  get: function () { return errors.COMMON_STORAGE_TYPES; }
 });
 exports.ALL_EVENTS = ALL_EVENTS;
 exports.ApiPackageError = ApiPackageError;
@@ -25942,8 +26148,8 @@ exports.ConfigBuilder = ConfigBuilder;
 exports.DEBUG_EVENTS = DEBUG_EVENTS2;
 exports.ERROR_EVENTS = ERROR_EVENTS2;
 exports.EVENT_NAMESPACES = EVENT_NAMESPACES2;
-exports.EVENT_SCOPES = EVENT_SCOPES2;
-exports.EVENT_SCOPES_WITH_TEMPORARY = EVENT_SCOPES_WITH_TEMPORARY;
+exports.EVENT_SCOPES = EVENT_SCOPES;
+exports.EVENT_SCOPES_WITH_TEMPORARY = EVENT_SCOPES_WITH_TEMPORARY2;
 exports.Environment = Environment;
 exports.EventHelpers = EventHelpers;
 exports.EventManager = EventManager;
@@ -25998,6 +26204,7 @@ exports.buildCacheKey = buildCacheKey;
 exports.buildEndpointUrl = buildEndpointUrl;
 exports.buildFullUrl = buildFullUrl;
 exports.buildUrl = buildUrl;
+exports.bulkValidateInfobipEmails = bulkValidateInfobipEmails;
 exports.bytesToBase64 = bytesToBase64;
 exports.cacheKeyPatterns = cacheKeyPatterns;
 exports.cacheStrategies = cacheStrategies;
@@ -26007,6 +26214,7 @@ exports.calculatePollingDuration = calculatePollingDuration;
 exports.calculateRequestMetrics = calculateRequestMetrics;
 exports.campaignEndpoints = campaignEndpoints;
 exports.canPerformHeavyOperation = canPerformHeavyOperation;
+exports.cdnEndpoints = cdnEndpoints;
 exports.checkOverrideTriggers = checkOverrideTriggers;
 exports.clamp = clamp;
 exports.clampedPercentage = clampedPercentage;
@@ -26014,6 +26222,10 @@ exports.clearErrorHandlers = clearErrorHandlers;
 exports.clearNetworkDebugData = clearNetworkDebugData;
 exports.clearTemporaryOverrides = clearTemporaryOverrides;
 exports.cloneConfig = cloneConfig;
+exports.cloudFrontCreateInvalidation = cloudFrontCreateInvalidation;
+exports.cloudFrontEndpoints = cloudFrontEndpoints;
+exports.cloudflareEndpoints = cloudflareEndpoints;
+exports.cloudflarePurgeCache = cloudflarePurgeCache;
 exports.compactHistory = compactHistory;
 exports.configConflictDetector = configConflictDetector;
 exports.configureForEnvironment = configureForEnvironment;
@@ -26032,7 +26244,6 @@ exports.createConfigBuilder = createConfigBuilder;
 exports.createConfigHistoryEntry = createConfigHistoryEntry;
 exports.createConfigState = createConfigState;
 exports.createConflict = createConflict;
-exports.createCorrelationIdGenerator = createCorrelationIdGenerator;
 exports.createCustomPreset = createCustomPreset;
 exports.createCustomUnifiedStrategy = createCustomUnifiedStrategy;
 exports.createDate = createDate;
@@ -26045,7 +26256,6 @@ exports.createEncryptionInterceptors = createEncryptionInterceptors;
 exports.createEventEmitter = createEventEmitter;
 exports.createHistoryEntry = createHistoryEntry;
 exports.createHistorySummary = createHistorySummary;
-exports.createIdGenerator = createIdGenerator;
 exports.createLimitedInterval = createLimitedInterval;
 exports.createManagedInterval = createManagedInterval;
 exports.createNetworkDetectionMiddleware = createNetworkDetectionMiddleware;
@@ -26054,7 +26264,6 @@ exports.createPerformanceBenchmark = createPerformanceBenchmark;
 exports.createPollingStrategy = createPollingStrategy;
 exports.createPreservedConfig = createPreservedConfig;
 exports.createProgressivePolling = createProgressivePolling;
-exports.createRequestIdGenerator = createRequestIdGenerator;
 exports.createRetryConfig = createRetryConfig;
 exports.createRetryStrategy = createRetryStrategy;
 exports.createRevalidationKey = createRevalidationKey;
@@ -26087,17 +26296,19 @@ exports.endpoints = endpoints;
 exports.eventManager = eventManager;
 exports.exportKeyToBase64 = exportKeyToBase64;
 exports.extendRevalidationPresets = extendPresets;
-exports.extractBaseCorrelationId = extractBaseCorrelationId;
-exports.extractBaseId = extractBaseId;
-exports.extractBaseRequestId = extractBaseRequestId;
-exports.extractCorrelationType = extractCorrelationType;
 exports.extractFields = extractFields;
-exports.extractLinkedCorrelationIds = extractLinkedCorrelationIds;
 exports.extractUrlParams = extractUrlParams;
+exports.fastlyEndpoints = fastlyEndpoints;
+exports.fastlyPurgeUrl = fastlyPurgeUrl;
 exports.fetchCampaign = fetchCampaign;
 exports.fetchCampaignParticipants = fetchCampaignParticipants;
 exports.fetchCampaignStats = fetchCampaignStats;
 exports.fetchCampaigns = fetchCampaigns;
+exports.fetchInfobipEmailLogs = fetchInfobipEmailLogs;
+exports.fetchInfobipEmailReports = fetchInfobipEmailReports;
+exports.fetchInfobipScheduledEmailStatuses = fetchInfobipScheduledEmailStatuses;
+exports.fetchInfobipScheduledEmails = fetchInfobipScheduledEmails;
+exports.fetchInfobipValidations = fetchInfobipValidations;
 exports.filterHistory = filterHistory;
 exports.filterObject = filterObject;
 exports.findEndpointsByPattern = findEndpointsByPattern;
@@ -26109,22 +26320,11 @@ exports.formatTimeForInterval = formatTimeForInterval;
 exports.fromFetchffConfig = fromFetchffConfig;
 exports.fromISOString = fromISOString;
 exports.fromUnixTimestamp = fromUnixTimestamp;
-exports.generateApiCorrelationId = generateApiCorrelationId;
-exports.generateBaseId = generateBaseId;
 exports.generateComprehensiveReport = generateComprehensiveReport;
-exports.generateContextualCorrelationId = generateContextualCorrelationId;
-exports.generateContextualId = generateContextualId;
-exports.generateContextualRequestId = generateContextualRequestId;
-exports.generateCorrelationId = generateCorrelationId;
 exports.generateIV = generateIV;
 exports.generateIssueBreakdown = generateIssueBreakdown;
-exports.generateNetworkCorrelationId = generateNetworkCorrelationId;
 exports.generateRandomKey = generateRandomKey;
 exports.generateRecommendations = generateRecommendations;
-exports.generateRequestId = generateRequestId;
-exports.generateSessionCorrelationId = generateSessionCorrelationId;
-exports.generateShortRequestId = generateShortRequestId;
-exports.generateTraceCorrelationId = generateTraceCorrelationId;
 exports.generateUUID = generateUUID;
 exports.getActiveOverrideKeys = getActiveOverrideKeys;
 exports.getAdaptiveApiConfig = getAdaptiveApiConfig;
@@ -26136,6 +26336,7 @@ exports.getAdaptiveTimeout = getAdaptiveTimeout;
 exports.getAllEndpointUrls = getAllEndpointUrls;
 exports.getAllFieldPaths = getAllFieldPaths;
 exports.getAllMediaExtensions = getAllMediaExtensions;
+exports.getAnalysisResult = getAnalysisResult;
 exports.getAppVersion = getAppVersion;
 exports.getAuthenticationType = getAuthenticationType;
 exports.getCache = getCache;
@@ -26164,9 +26365,6 @@ exports.getEntries = getEntries;
 exports.getEnv = getEnv;
 exports.getEnvironmentInfo = getEnvironmentInfo;
 exports.getEnvironmentName = getEnvironmentName;
-exports.getErrorCategory = getErrorCategory;
-exports.getErrorCodeByStatus = getErrorCodeByStatus;
-exports.getErrorDefinition = getErrorDefinition;
 exports.getErrorHandlers = getErrorHandlers;
 exports.getEventManager = getEventManager;
 exports.getExtendedEnvironmentInfo = getExtendedEnvironmentInfo;
@@ -26254,6 +26452,8 @@ exports.importKey = importKey;
 exports.inBrowser = inBrowser;
 exports.inRange = inRange;
 exports.inServer = inServer;
+exports.infobipEmailEndpoints = infobipEmailEndpoints;
+exports.infobipEndpoints = infobipEndpoints;
 exports.invalidationScenarios = invalidationScenarios;
 exports.inverseLerp = inverseLerp;
 exports.isAbortError = isAbortError;
@@ -26317,15 +26517,12 @@ exports.isTest = isTest;
 exports.isToday = isToday;
 exports.isTouchDevice = isTouchDevice;
 exports.isUnifiedStrategyName = isUnifiedStrategyName;
-exports.isValidCorrelationId = isValidCorrelationId;
 exports.isValidDate = isValidDate;
 exports.isValidEnumValue = isValidEnumValue;
 exports.isValidFieldPath = isValidFieldPath;
-exports.isValidId = isValidId;
 exports.isValidJSON = isValidJSON;
 exports.isValidNumber = isValidNumber2;
 exports.isValidPollingConfig = isValidPollingConfig;
-exports.isValidRequestId = isValidRequestId;
 exports.isValidRevalidationStrategyName = isValidStrategyName;
 exports.isWebWorker = isWebWorker;
 exports.isWifiConnection = isWifiConnection;
@@ -26337,7 +26534,6 @@ exports.jsonEquals = jsonEquals;
 exports.keyBy = keyBy;
 exports.leaveCampaign = leaveCampaign;
 exports.lerp = lerp;
-exports.linkCorrelationIds = linkCorrelationIds;
 exports.logNetworkConfigReport = logNetworkConfigReport;
 exports.mapKeys = mapKeys;
 exports.mapObject = mapObject;
@@ -26373,7 +26569,6 @@ exports.onceErrorHandler = onceErrorHandler;
 exports.oneOf = oneOf;
 exports.parseAndValidateNumber = parseAndValidateNumber;
 exports.parseFieldPath = parseFieldPath;
-exports.parseId = parseId;
 exports.percentage = percentage;
 exports.pick = pick;
 exports.pollingEndpoints = pollingEndpoints;
@@ -26394,6 +26589,7 @@ exports.removeSensitiveHeaders = removeSensitiveHeaders;
 exports.removeUndefined = removeUndefined;
 exports.requestTracker = requestTracker;
 exports.requestWithTimeout = requestWithTimeout;
+exports.rescheduleInfobipEmails = rescheduleInfobipEmails;
 exports.resetGlobalConfig = resetGlobalConfig;
 exports.resetRevalidationPresets = resetPresets;
 exports.resolveConflict = resolveConflict;
@@ -26408,6 +26604,8 @@ exports.safeParseJSON = safeParseJSON;
 exports.safeStringify = safeStringify;
 exports.sanitizeHeaders = sanitizeHeaders2;
 exports.secondsToMs = secondsToMs;
+exports.sendInfobipAdvancedEmail = sendInfobipAdvancedEmail;
+exports.sendInfobipEmail = sendInfobipEmail;
 exports.sequentialRequests = sequentialRequests;
 exports.setCache = setCache;
 exports.setConfigWarnings = setConfigWarnings;
@@ -26461,6 +26659,8 @@ exports.unifiedStrategies = unifiedStrategies;
 exports.unregisterErrorHandlers = unregisterErrorHandlers;
 exports.updateCampaign = updateCampaign;
 exports.updateGlobalConfig = updateGlobalConfig;
+exports.updateInfobipScheduledEmailStatuses = updateInfobipScheduledEmailStatuses;
+exports.uploadFileForScanning = uploadFileForScanning;
 exports.useAbortableRequest = useAbortableRequest;
 exports.useApiConfigConflicts = useApiConfigConflicts;
 exports.useApiDebugInfo = useApiDebugInfo;
@@ -26488,8 +26688,10 @@ exports.useUpdateCampaign = useUpdateCampaign;
 exports.validateConfigUpdate = validateConfigUpdate;
 exports.validateEncryptionConfig = validateEncryptionConfig;
 exports.validateHeaders = validateHeaders2;
+exports.validateInfobipEmail = validateInfobipEmail;
 exports.validatePathParams = validatePathParams;
 exports.validatePreset = validatePreset;
+exports.virusTotalEndpoints = virusTotalEndpoints;
 exports.waitForOnline = waitForOnline;
 exports.withNetworkDetection = withNetworkDetection;
 exports.withNetworkInfo = withNetworkInfo;