@plyaz/types 1.13.10 → 1.13.11

package/dist/index.cjs

@@ -164,7 +164,7 @@ __export(external_exports, {
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
-  util2.assertEqual = (_2) => {
+  util2.assertEqual = (_) => {
   };
   function assertIs(_arg) {
   }
@@ -183,16 +183,16 @@ var util;
     return obj;
   };
   util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k2) => typeof obj[obj[k2]] !== "number");
+    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
     const filtered = {};
-    for (const k2 of validKeys) {
-      filtered[k2] = obj[k2];
+    for (const k of validKeys) {
+      filtered[k] = obj[k];
     }
     return util2.objectValues(filtered);
   };
   util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e2) {
-      return obj[e2];
+    return util2.objectKeys(obj).map(function(e) {
+      return obj[e];
     });
   };
   util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
@@ -217,7 +217,7 @@ var util;
   }
   __name(joinValues, "joinValues");
   util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_2, value) => {
+  util2.jsonStringifyReplacer = (_, value) => {
     if (typeof value === "bigint") {
       return value.toString();
     }
@@ -549,7 +549,7 @@ var makeIssue = /* @__PURE__ */ __name((params) => {
     };
   }
   let errorMessage = "";
-  const maps = errorMaps.filter((m) => !!m).slice().reverse();
+  const maps = errorMaps.filter((m2) => !!m2).slice().reverse();
   for (const map of maps) {
     errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
   }
@@ -597,12 +597,12 @@ var ParseStatus = class _ParseStatus {
   }
   static mergeArray(status, results) {
     const arrayValue = [];
-    for (const s of results) {
-      if (s.status === "aborted")
+    for (const s2 of results) {
+      if (s2.status === "aborted")
         return INVALID;
-      if (s.status === "dirty")
+      if (s2.status === "dirty")
         status.dirty();
-      arrayValue.push(s.value);
+      arrayValue.push(s2.value);
     }
     return { status: status.value, value: arrayValue };
   }
@@ -3028,17 +3028,17 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
     });
   }
 };
-function mergeValues(a2, b) {
-  const aType = getParsedType(a2);
+function mergeValues(a, b) {
+  const aType = getParsedType(a);
   const bType = getParsedType(b);
-  if (a2 === b) {
-    return { valid: true, data: a2 };
+  if (a === b) {
+    return { valid: true, data: a };
   } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
     const bKeys = util.objectKeys(b);
-    const sharedKeys = util.objectKeys(a2).filter((key) => bKeys.indexOf(key) !== -1);
-    const newObj = { ...a2, ...b };
+    const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const newObj = { ...a, ...b };
     for (const key of sharedKeys) {
-      const sharedValue = mergeValues(a2[key], b[key]);
+      const sharedValue = mergeValues(a[key], b[key]);
       if (!sharedValue.valid) {
         return { valid: false };
       }
@@ -3046,12 +3046,12 @@ function mergeValues(a2, b) {
     }
     return { valid: true, data: newObj };
   } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
-    if (a2.length !== b.length) {
+    if (a.length !== b.length) {
       return { valid: false };
     }
     const newArray = [];
-    for (let index = 0; index < a2.length; index++) {
-      const itemA = a2[index];
+    for (let index = 0; index < a.length; index++) {
+      const itemA = a[index];
       const itemB = b[index];
       const sharedValue = mergeValues(itemA, itemB);
       if (!sharedValue.valid) {
@@ -3060,8 +3060,8 @@ function mergeValues(a2, b) {
       newArray.push(sharedValue.data);
     }
     return { valid: true, data: newArray };
-  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a2 === +b) {
-    return { valid: true, data: a2 };
+  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
+    return { valid: true, data: a };
   } else {
     return { valid: false };
   }
@@ -3455,13 +3455,13 @@ var ZodFunction = class _ZodFunction extends ZodType {
       const me = this;
       return OK(async function(...args) {
         const error = new ZodError([]);
-        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e2) => {
-          error.addIssue(makeArgsIssue(args, e2));
+        const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
+          error.addIssue(makeArgsIssue(args, e));
           throw error;
         });
         const result = await Reflect.apply(fn, this, parsedArgs);
-        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e2) => {
-          error.addIssue(makeReturnsIssue(result, e2));
+        const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
+          error.addIssue(makeReturnsIssue(result, e));
           throw error;
         });
         return parsedReturns;
@@ -4076,9 +4076,9 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
       }
     }
   }
-  static create(a2, b) {
+  static create(a, b) {
     return new _ZodPipeline({
-      in: a2,
+      in: a,
       out: b,
       typeName: ZodFirstPartyTypeKind.ZodPipeline
     });
@@ -4118,17 +4118,17 @@ __name(cleanParams, "cleanParams");
 function custom(check, _params = {}, fatal) {
   if (check)
     return ZodAny.create().superRefine((data, ctx) => {
-      const r = check(data);
-      if (r instanceof Promise) {
-        return r.then((r2) => {
-          if (!r2) {
+      const r2 = check(data);
+      if (r2 instanceof Promise) {
+        return r2.then((r3) => {
+          if (!r3) {
             const params = cleanParams(_params, data);
             const _fatal = params.fatal ?? fatal ?? true;
             ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
           }
         });
       }
-      if (!r) {
+      if (!r2) {
         const params = cleanParams(_params, data);
         const _fatal = params.fatal ?? fatal ?? true;
         ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
@@ -4459,7 +4459,544 @@ var COMMON_STORAGE_TYPES = {
   DATABASE: "database"
 };
 
-// node_modules/.pnpm/@plyaz+config@1.7.0_@darraghor+eslint-plugin-nestjs-typed@6.9.3_@types+react@19.2.2_@typescri_jlylpdixjp6vxjtx3yd6pjsxpe/node_modules/@plyaz/config/dist/index.mjs
+// node_modules/.pnpm/@plyaz+types@1.13.10_@types+react@19.2.2_next@15.4.7_react-dom@19.2.0_react@19.2.0/node_modules/@plyaz/types/dist/index.js
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+external_exports.object({
+  // The user's email address. Must be a valid email format.
+  email: external_exports.string().email("Invalid email format"),
+  // The user's password. No format constraints applied here.
+  password: external_exports.string()
+});
+var ERROR_CODES = {
+  // ===== API Package Errors =====
+  // Client Configuration
+  CLIENT_INITIALIZATION_FAILED: "CLIENT_INITIALIZATION_FAILED",
+  CLIENT_INVALID_CONFIG: "CLIENT_INVALID_CONFIG",
+  CLIENT_MISSING_BASE_URL: "CLIENT_MISSING_BASE_URL",
+  CONFIG_VALIDATION_FAILED: "CONFIG_VALIDATION_FAILED",
+  HEADER_PROCESSING_FAILED: "HEADER_PROCESSING_FAILED",
+  NETWORK_OVERRIDE_FAILED: "NETWORK_OVERRIDE_FAILED",
+  // Request
+  REQUEST_TIMEOUT: "REQUEST_TIMEOUT",
+  REQUEST_INVALID_PARAMS: "REQUEST_INVALID_PARAMS",
+  REQUEST_PREPARATION_FAILED: "REQUEST_PREPARATION_FAILED",
+  // Response
+  RESPONSE_INVALID_FORMAT: "RESPONSE_INVALID_FORMAT",
+  RESPONSE_PARSING_FAILED: "RESPONSE_PARSING_FAILED",
+  // Authentication/Authorization
+  AUTH_UNAUTHORIZED: "AUTH_UNAUTHORIZED",
+  AUTH_FORBIDDEN: "AUTH_FORBIDDEN",
+  AUTH_TOKEN_EXPIRED: "AUTH_TOKEN_EXPIRED",
+  AUTH_INVALID_CREDENTIALS: "AUTH_INVALID_CREDENTIALS",
+  // Rate Limiting
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  // Resources
+  RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
+  RESOURCE_CONFLICT: "RESOURCE_CONFLICT",
+  // Validation
+  API_VALIDATION_FAILED: "API_VALIDATION_FAILED",
+  API_INVALID_INPUT: "API_INVALID_INPUT",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  REQUIRED_FIELD_MISSING: "REQUIRED_FIELD_MISSING",
+  INVALID_FORMAT: "INVALID_FORMAT",
+  VALIDATION_INVALID_FORMAT: "VALIDATION_INVALID_FORMAT",
+  STRING_TOO_SHORT: "STRING_TOO_SHORT",
+  STRING_TOO_LONG: "STRING_TOO_LONG",
+  // Network
+  NETWORK_ERROR: "NETWORK_ERROR",
+  NETWORK_PRESET_NOT_FOUND: "NETWORK_PRESET_NOT_FOUND",
+  NETWORK_CONFIGURATION_INVALID: "NETWORK_CONFIGURATION_INVALID",
+  // Server
+  SERVER_ERROR: "SERVER_ERROR",
+  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  // Cache
+  CACHE_READ_FAILED: "CACHE_READ_FAILED",
+  CACHE_WRITE_FAILED: "CACHE_WRITE_FAILED",
+  CACHE_INVALIDATION_FAILED: "CACHE_INVALIDATION_FAILED",
+  CACHE_STORAGE_FAILED: "CACHE_STORAGE_FAILED",
+  CACHE_RETRIEVAL_FAILED: "CACHE_RETRIEVAL_FAILED",
+  // Retry
+  RETRY_LIMIT_EXCEEDED: "RETRY_LIMIT_EXCEEDED",
+  RETRY_FAILED: "RETRY_FAILED",
+  RETRY_EXHAUSTED: "RETRY_EXHAUSTED",
+  RETRY_STRATEGY_INVALID: "RETRY_STRATEGY_INVALID",
+  // Strategy
+  STRATEGY_INVALID: "STRATEGY_INVALID",
+  STRATEGY_CONFLICT: "STRATEGY_CONFLICT",
+  STRATEGY_EXECUTION_FAILED: "STRATEGY_EXECUTION_FAILED",
+  // Headers
+  HEADERS_ENRICHMENT_FAILED: "HEADERS_ENRICHMENT_FAILED",
+  HEADERS_VALIDATION_FAILED: "HEADERS_VALIDATION_FAILED",
+  HEADERS_MERGE_CONFLICT: "HEADERS_MERGE_CONFLICT",
+  // Regional
+  REGION_DETECTION_FAILED: "REGION_DETECTION_FAILED",
+  REGIONAL_PRESET_NOT_FOUND: "REGIONAL_PRESET_NOT_FOUND",
+  // External Services
+  EXTERNAL_SERVICE_ERROR: "EXTERNAL_SERVICE_ERROR",
+  // Timeout (generic)
+  TIMEOUT: "TIMEOUT",
+  // Debugging
+  DEBUG_TRACKING_FAILED: "DEBUG_TRACKING_FAILED",
+  POLLING_TIMEOUT: "POLLING_TIMEOUT",
+  POLLING_INVALID_CONFIG: "POLLING_INVALID_CONFIG",
+  // PubSub
+  PUBSUB_SUBSCRIPTION_FAILED: "PUBSUB_SUBSCRIPTION_FAILED",
+  PUBSUB_PUBLICATION_FAILED: "PUBSUB_PUBLICATION_FAILED",
+  PUBSUB_INVALID_TOPIC: "PUBSUB_INVALID_TOPIC",
+  PUBSUB_CHANNEL_ERROR: "PUBSUB_CHANNEL_ERROR",
+  // Revalidation
+  REVALIDATION_FAILED: "REVALIDATION_FAILED",
+  REVALIDATION_IN_PROGRESS: "REVALIDATION_IN_PROGRESS",
+  // Debugging
+  DEBUG_OVERRIDE_FAILED: "DEBUG_OVERRIDE_FAILED",
+  DEBUG_CONFLICT_DETECTED: "DEBUG_CONFLICT_DETECTED",
+  // Endpoint
+  ENDPOINT_BUILD_FAILED: "ENDPOINT_BUILD_FAILED",
+  ENDPOINT_NOT_FOUND: "ENDPOINT_NOT_FOUND",
+  ENDPOINT_INVALID_CONFIG: "ENDPOINT_INVALID_CONFIG",
+  // Event
+  EVENT_HANDLER_FAILED: "EVENT_HANDLER_FAILED",
+  EVENT_EMISSION_FAILED: "EVENT_EMISSION_FAILED",
+  MONITORING_FAILED: "MONITORING_FAILED",
+  // Context
+  CONTEXT_OPERATION_FAILED: "CONTEXT_OPERATION_FAILED",
+  // Generic
+  CLIENT_ERROR: "CLIENT_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  // ===== Notification Package Errors =====
+  // Provider
+  NOTIFICATION_PROVIDER_SEND_FAILED: "notification.provider.send.failed",
+  NOTIFICATION_PROVIDER_CONFIGURATION_INVALID: "notification.provider.configuration.invalid",
+  NOTIFICATION_PROVIDER_RATE_LIMIT: "notification.provider.rate.limit",
+  NOTIFICATION_PROVIDER_AUTH_FAILED: "notification.provider.auth.failed",
+  NOTIFICATION_PROVIDER_TIMEOUT: "notification.provider.timeout",
+  NOTIFICATION_PROVIDER_UNAVAILABLE: "notification.provider.unavailable",
+  NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED: "notification.provider.feature.not.supported",
+  NOTIFICATION_ALL_PROVIDERS_FAILED: "notification.all.providers.failed",
+  // Validation
+  NOTIFICATION_INVALID_INPUT: "notification.validation.input.invalid",
+  NOTIFICATION_INVALID_RECIPIENT: "notification.validation.recipient.invalid",
+  NOTIFICATION_INVALID_TEMPLATE: "notification.validation.template.invalid",
+  NOTIFICATION_INVALID_PAYLOAD: "notification.validation.payload.invalid",
+  NOTIFICATION_MISSING_REQUIRED_FIELD: "notification.validation.field.required",
+  NOTIFICATION_VALIDATION_FAILED: "notification.validation.failed",
+  // User Preferences
+  NOTIFICATION_USER_OPTED_OUT: "notification.user.opted.out",
+  // Queue
+  NOTIFICATION_QUEUE_FULL: "notification.queue.full",
+  NOTIFICATION_QUEUE_PROCESSING_FAILED: "notification.queue.processing.failed",
+  // Webhook
+  NOTIFICATION_WEBHOOK_SIGNATURE_INVALID: "notification.webhook.signature.invalid",
+  NOTIFICATION_WEBHOOK_VALIDATION_FAILED: "notification.webhook.validation.failed",
+  NOTIFICATION_WEBHOOK_PROCESSING_FAILED: "notification.webhook.processing.failed",
+  // Template
+  NOTIFICATION_TEMPLATE_NOT_FOUND: "notification.template.not.found",
+  NOTIFICATION_TEMPLATE_RENDER_FAILED: "notification.template.render.failed",
+  // General Notification
+  NOTIFICATION_UNKNOWN_ERROR: "notification.unknown.error",
+  NOTIFICATION_INITIALIZATION_FAILED: "notification.initialization.failed",
+  // ===== Errors Package Errors =====
+  ERROR_SYSTEM_NOT_INITIALIZED: "error.system.not.initialized",
+  EVENT_FACTORY_NOT_REGISTERED: "error.event.factory.not.registered",
+  DATABASE_ERROR: "error.database"
+};
+({
+  // ===== API Package Error Definitions =====
+  // Authentication
+  [ERROR_CODES.AUTH_UNAUTHORIZED]: {
+    status: ke.UNAUTHORIZED},
+  [ERROR_CODES.AUTH_FORBIDDEN]: {
+    status: ke.FORBIDDEN},
+  [ERROR_CODES.AUTH_TOKEN_EXPIRED]: {
+    status: ke.UNAUTHORIZED},
+  [ERROR_CODES.AUTH_INVALID_CREDENTIALS]: {
+    status: ke.UNAUTHORIZED},
+  // Rate Limiting
+  [ERROR_CODES.RATE_LIMIT_EXCEEDED]: {
+    status: ke.TOO_MANY_REQUESTS},
+  // Resources
+  [ERROR_CODES.RESOURCE_NOT_FOUND]: {
+    status: ke.NOT_FOUND},
+  [ERROR_CODES.RESOURCE_CONFLICT]: {
+    status: ke.CONFLICT},
+  // Validation
+  [ERROR_CODES.API_VALIDATION_FAILED]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.API_INVALID_INPUT]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.VALIDATION_ERROR]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.REQUIRED_FIELD_MISSING]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.INVALID_FORMAT]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.VALIDATION_INVALID_FORMAT]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.STRING_TOO_SHORT]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.STRING_TOO_LONG]: {
+    status: ke.BAD_REQUEST},
+  // Network
+  [ERROR_CODES.NETWORK_ERROR]: {
+    status: ke.BAD_GATEWAY},
+  [ERROR_CODES.NETWORK_CONFIGURATION_INVALID]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.NETWORK_PRESET_NOT_FOUND]: {
+    status: ke.NOT_FOUND},
+  // Server
+  [ERROR_CODES.SERVER_ERROR]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.INTERNAL_SERVER_ERROR]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.SERVICE_UNAVAILABLE]: {
+    status: ke.SERVICE_UNAVAILABLE},
+  // Cache
+  [ERROR_CODES.CACHE_READ_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.CACHE_WRITE_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.CACHE_INVALIDATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.CACHE_STORAGE_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.CACHE_RETRIEVAL_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Retry
+  [ERROR_CODES.RETRY_LIMIT_EXCEEDED]: {
+    status: ke.SERVICE_UNAVAILABLE},
+  [ERROR_CODES.RETRY_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.RETRY_EXHAUSTED]: {
+    status: ke.SERVICE_UNAVAILABLE},
+  [ERROR_CODES.RETRY_STRATEGY_INVALID]: {
+    status: ke.BAD_REQUEST},
+  // Strategy
+  [ERROR_CODES.STRATEGY_INVALID]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.STRATEGY_CONFLICT]: {
+    status: ke.CONFLICT},
+  [ERROR_CODES.STRATEGY_EXECUTION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Headers
+  [ERROR_CODES.HEADERS_ENRICHMENT_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.HEADERS_VALIDATION_FAILED]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.HEADERS_MERGE_CONFLICT]: {
+    status: ke.CONFLICT},
+  // Regional
+  [ERROR_CODES.REGION_DETECTION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.REGIONAL_PRESET_NOT_FOUND]: {
+    status: ke.NOT_FOUND},
+  // External Services
+  [ERROR_CODES.EXTERNAL_SERVICE_ERROR]: {
+    status: ke.BAD_GATEWAY},
+  // Timeout
+  [ERROR_CODES.TIMEOUT]: {
+    status: ke.REQUEST_TIMEOUT},
+  // Debugging
+  [ERROR_CODES.DEBUG_TRACKING_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.DEBUG_OVERRIDE_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.DEBUG_CONFLICT_DETECTED]: {
+    status: ke.CONFLICT},
+  // Endpoint
+  [ERROR_CODES.ENDPOINT_BUILD_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.ENDPOINT_NOT_FOUND]: {
+    status: ke.NOT_FOUND},
+  [ERROR_CODES.ENDPOINT_INVALID_CONFIG]: {
+    status: ke.BAD_REQUEST},
+  // Event
+  [ERROR_CODES.EVENT_HANDLER_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.EVENT_EMISSION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.MONITORING_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.POLLING_TIMEOUT]: {
+    status: ke.REQUEST_TIMEOUT},
+  [ERROR_CODES.POLLING_INVALID_CONFIG]: {
+    status: ke.BAD_REQUEST},
+  // PubSub
+  [ERROR_CODES.PUBSUB_SUBSCRIPTION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.PUBSUB_PUBLICATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.PUBSUB_INVALID_TOPIC]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.PUBSUB_CHANNEL_ERROR]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Revalidation
+  [ERROR_CODES.REVALIDATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.REVALIDATION_IN_PROGRESS]: {
+    status: ke.CONFLICT},
+  // Context
+  [ERROR_CODES.CONTEXT_OPERATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Request
+  [ERROR_CODES.REQUEST_TIMEOUT]: {
+    status: ke.REQUEST_TIMEOUT},
+  [ERROR_CODES.REQUEST_INVALID_PARAMS]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.REQUEST_PREPARATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Response
+  [ERROR_CODES.RESPONSE_INVALID_FORMAT]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.RESPONSE_PARSING_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Client
+  [ERROR_CODES.CLIENT_ERROR]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.CLIENT_INITIALIZATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.CLIENT_INVALID_CONFIG]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.CLIENT_MISSING_BASE_URL]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Configuration
+  [ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.HEADER_PROCESSING_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.NETWORK_OVERRIDE_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Generic
+  [ERROR_CODES.UNKNOWN_ERROR]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // ===== Notification Package Error Definitions =====
+  // Provider errors (retryable)
+  [ERROR_CODES.NOTIFICATION_PROVIDER_SEND_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.NOTIFICATION_PROVIDER_RATE_LIMIT]: {
+    status: ke.TOO_MANY_REQUESTS},
+  [ERROR_CODES.NOTIFICATION_PROVIDER_AUTH_FAILED]: {
+    status: ke.UNAUTHORIZED},
+  [ERROR_CODES.NOTIFICATION_PROVIDER_TIMEOUT]: {
+    status: ke.GATEWAY_TIMEOUT},
+  [ERROR_CODES.NOTIFICATION_PROVIDER_UNAVAILABLE]: {
+    status: ke.SERVICE_UNAVAILABLE},
+  [ERROR_CODES.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED]: {
+    status: ke.NOT_IMPLEMENTED},
+  [ERROR_CODES.NOTIFICATION_ALL_PROVIDERS_FAILED]: {
+    status: ke.SERVICE_UNAVAILABLE},
+  // Validation errors (non-retryable)
+  [ERROR_CODES.NOTIFICATION_INVALID_INPUT]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.NOTIFICATION_INVALID_RECIPIENT]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.NOTIFICATION_INVALID_TEMPLATE]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.NOTIFICATION_INVALID_PAYLOAD]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.NOTIFICATION_MISSING_REQUIRED_FIELD]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.NOTIFICATION_VALIDATION_FAILED]: {
+    status: ke.BAD_REQUEST},
+  // User Preferences
+  [ERROR_CODES.NOTIFICATION_USER_OPTED_OUT]: {
+    status: ke.OK},
+  // Queue errors (retryable)
+  [ERROR_CODES.NOTIFICATION_QUEUE_FULL]: {
+    status: ke.SERVICE_UNAVAILABLE},
+  [ERROR_CODES.NOTIFICATION_QUEUE_PROCESSING_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Webhook errors
+  [ERROR_CODES.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID]: {
+    status: ke.UNAUTHORIZED},
+  [ERROR_CODES.NOTIFICATION_WEBHOOK_VALIDATION_FAILED]: {
+    status: ke.BAD_REQUEST},
+  [ERROR_CODES.NOTIFICATION_WEBHOOK_PROCESSING_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // Template errors
+  [ERROR_CODES.NOTIFICATION_TEMPLATE_NOT_FOUND]: {
+    status: ke.NOT_FOUND},
+  [ERROR_CODES.NOTIFICATION_TEMPLATE_RENDER_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // General notification errors
+  [ERROR_CODES.NOTIFICATION_UNKNOWN_ERROR]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.NOTIFICATION_INITIALIZATION_FAILED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  // ===== Errors Package Errors =====
+  [ERROR_CODES.ERROR_SYSTEM_NOT_INITIALIZED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.EVENT_FACTORY_NOT_REGISTERED]: {
+    status: ke.INTERNAL_SERVER_ERROR},
+  [ERROR_CODES.DATABASE_ERROR]: {
+    status: ke.INTERNAL_SERVER_ERROR}
+});
+var PAYMENT_ERROR_CATEGORY = /* @__PURE__ */ ((PAYMENT_ERROR_CATEGORY22) => {
+  PAYMENT_ERROR_CATEGORY22["Validation"] = "validation";
+  PAYMENT_ERROR_CATEGORY22["Authentication"] = "authentication";
+  PAYMENT_ERROR_CATEGORY22["Authorization"] = "authorization";
+  PAYMENT_ERROR_CATEGORY22["Processing"] = "processing";
+  PAYMENT_ERROR_CATEGORY22["Provider"] = "provider";
+  PAYMENT_ERROR_CATEGORY22["Network"] = "network";
+  PAYMENT_ERROR_CATEGORY22["Fraud"] = "fraud";
+  PAYMENT_ERROR_CATEGORY22["Compliance"] = "compliance";
+  PAYMENT_ERROR_CATEGORY22["Limits"] = "limits";
+  PAYMENT_ERROR_CATEGORY22["Configuration"] = "configuration";
+  PAYMENT_ERROR_CATEGORY22["Timeout"] = "timeout";
+  PAYMENT_ERROR_CATEGORY22["System"] = "system";
+  PAYMENT_ERROR_CATEGORY22["Webhook"] = "webhook";
+  PAYMENT_ERROR_CATEGORY22["Refund"] = "refund";
+  PAYMENT_ERROR_CATEGORY22["Security"] = "security";
+  return PAYMENT_ERROR_CATEGORY22;
+})(PAYMENT_ERROR_CATEGORY || {});
+var ERRORSEVERITY = /* @__PURE__ */ ((ERRORSEVERITY22) => {
+  ERRORSEVERITY22["Low"] = "low";
+  ERRORSEVERITY22["Medium"] = "medium";
+  ERRORSEVERITY22["High"] = "high";
+  ERRORSEVERITY22["Critical"] = "critical";
+  return ERRORSEVERITY22;
+})(ERRORSEVERITY || {});
+var NOTIFICATION_CATEGORIES = {
+  /** Cannot be opted out - compliance requirement (password resets, order confirmations) */
+  TRANSACTIONAL: "transactional",
+  /** User can opt-out (newsletters, promotions) */
+  MARKETING: "marketing",
+  /** User can opt-out (likes, comments, follows) */
+  SOCIAL: "social",
+  /** System alerts and notifications (security alerts, system status) */
+  SYSTEM: "system",
+  /** Promotional offers and campaigns */
+  PROMOTIONAL: "promotional"
+};
+var MAX_EMAIL_LENGTH = 255;
+var MAX_USER_ID_LENGTH = 255;
+var MAX_TEMPLATE_ID_LENGTH = 255;
+var MAX_DEVICE_TOKEN_LENGTH = 512;
+external_exports.string().email("Invalid email address format").max(MAX_EMAIL_LENGTH, "Email address must be 255 characters or less").transform((val) => val.trim().toLowerCase());
+external_exports.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number format (E.164 expected)").describe("Phone number in E.164 format");
+external_exports.string().min(1, "User ID is required").max(MAX_USER_ID_LENGTH, "User ID must be 255 characters or less");
+external_exports.string().min(1, "Template ID is required").regex(
+  /^[a-z0-9-/]+$/,
+  "Template ID must contain only lowercase letters, numbers, hyphens, and slashes"
+).max(MAX_TEMPLATE_ID_LENGTH, "Template ID must be 255 characters or less");
+external_exports.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/, "Locale must be in format: en, en-US, es, es-MX").describe("Locale in ISO 639-1 format");
+external_exports.enum([
+  NOTIFICATION_CATEGORIES.TRANSACTIONAL,
+  NOTIFICATION_CATEGORIES.MARKETING,
+  NOTIFICATION_CATEGORIES.SOCIAL,
+  NOTIFICATION_CATEGORIES.SYSTEM,
+  NOTIFICATION_CATEGORIES.PROMOTIONAL
+]).default(NOTIFICATION_CATEGORIES.TRANSACTIONAL).describe("Notification category for compliance and user preferences");
+external_exports.enum(["high", "normal", "low"]);
+external_exports.string().uuid("Correlation ID must be a valid UUID v4").describe("UUID v4 correlation ID");
+external_exports.record(external_exports.string(), external_exports.unknown()).optional();
+external_exports.string().min(1, "Device token is required").max(MAX_DEVICE_TOKEN_LENGTH, "Device token must be 512 characters or less");
+var FACTORY_OPERATIONS = {
+  FACTORY_CREATED: "factory_created",
+  FACTORY_ACCESSED: "factory_accessed",
+  FACTORY_INITIALIZED: "factory_initialized",
+  FACTORIES_RESET: "factories_reset",
+  FACTORY_REGISTER: "factory_register",
+  HANDLER_REGISTERED: "handler_registered",
+  HANDLER_UNREGISTERED: "handler_unregistered",
+  /**
+   * Indicates that a specific handler instance has been removed from a factory or scope.
+   * Use this when removing a particular handler by reference or ID, as opposed to
+   * HANDLER_UNREGISTERED, which refers to unregistering a handler type or all handlers.
+   */
+  SPECIFIC_HANDLER_REMOVED: "specific_handler_removed",
+  SCOPE_LISTENERS_CLEARED: "scope_listeners_cleared"
+};
+var EVENT_OPERATIONS = {
+  ON: "on",
+  ONCE: "once",
+  OFF: "off",
+  EMIT: "emit",
+  EMIT_ACROSS_SCOPES: "emit_across_scopes",
+  REMOVE_ALL_LISTENERS: "removeAllListeners",
+  ONCE_EXECUTED: "once_executed",
+  CONFIG_UPDATE: "config_update",
+  CONFIG_UPDATE_FAILED: "config_update_failed",
+  GLOBAL_CONFIG_UPDATE: "global_config_update",
+  GLOBAL_CONFIG_RESET: "global_config_reset",
+  SCOPE_CHANGE: "scope_change",
+  FACTORY_CREATE: "factory_create",
+  FACTORY_COORDINATION: "factory_coordination",
+  HANDLER_STRATEGY: "handler_strategy",
+  HANDLER_STRATEGY_APPLIED: "handler_strategy_applied"
+};
+var QUEUE_OPERATIONS = {
+  QUEUE_CREATED: "queue_created",
+  QUEUE_PROCESSED: "queue_processed",
+  QUEUE_CLEARED: "queue_cleared",
+  QUEUE_ERROR: "queue_error",
+  BATCH_PROCESSED: "batch_processed",
+  ITEM_ENQUEUED: "item_enqueued",
+  ITEM_DEQUEUED: "item_dequeued",
+  PRIORITY_CHANGED: "priority_changed"
+};
+var DEBUGGER_CONFIG_SOURCES = {
+  DEFAULT: "default",
+  DIRECT: "direct",
+  CLIENT: "client",
+  UNIFIED_STRATEGY: "unifiedStrategy",
+  PERFORMANCE_PRESET: "performancePreset",
+  DATA_PATTERN: "dataPattern",
+  CACHE_STRATEGY: "cacheStrategy",
+  RETRY_STRATEGY: "retryStrategy",
+  REVALIDATION_STRATEGY: "revalidationStrategy",
+  ADAPTIVE_CONFIG: "adaptiveConfig",
+  MONITORING_CONFIG: "monitoringConfig",
+  POLLING_CONFIG: "pollingConfig",
+  NETWORK_PRESET: "networkPreset",
+  NETWORK_AWARE: "networkAware",
+  NETWORK_QUALITY: "networkQuality",
+  USER_PREFERENCE: "userPreference",
+  TEMPORARY_OVERRIDE: "temporaryOverride",
+  AUTO_OPTIMIZATION: "autoOptimization",
+  NETWORK_CLIENT_HINTS: "networkClientHints",
+  HEADER_PRESET: "headerPreset",
+  ENRICHED_HEADERS: "enrichedHeaders",
+  USER_HEADERS: "userHeaders",
+  INTERCEPTOR: "interceptor",
+  CONTEXT_HEADERS: "contextHeaders",
+  ENCRYPTION: "encryption"
+};
+var HISTORY_TYPES = {
+  CONFIG: "config",
+  HEADER: "header",
+  NETWORK: "network",
+  PERFORMANCE: "performance",
+  EVENT: "event",
+  EVENT_OPERATION: "event_operation"
+};
+var UNIFIED_OPERATIONS = {
+  ...FACTORY_OPERATIONS,
+  ...EVENT_OPERATIONS,
+  ...QUEUE_OPERATIONS
+};
+function isValidOperation(operation) {
+  return Object.values(UNIFIED_OPERATIONS).includes(operation);
+}
+__name(isValidOperation, "isValidOperation");
+__name2(isValidOperation, "isValidOperation");
+function isValidConfigSource(source) {
+  return Object.values(DEBUGGER_CONFIG_SOURCES).includes(source);
+}
+__name(isValidConfigSource, "isValidConfigSource");
+__name2(isValidConfigSource, "isValidConfigSource");
+function isValidHistoryType(type) {
+  return Object.values(HISTORY_TYPES).includes(type);
+}
+__name(isValidHistoryType, "isValidHistoryType");
+__name2(isValidHistoryType, "isValidHistoryType");
+
+// node_modules/.pnpm/@plyaz+config@1.7.1_@darraghor+eslint-plugin-nestjs-typed@6.9.3_@types+react@19.2.2_@typescri_cwk4elgn7ium52d23sqbv3s4u4/node_modules/@plyaz/config/dist/index.mjs
+var c = Object.defineProperty;
+var o = /* @__PURE__ */ __name((e, I) => c(e, "name", { value: I, configurable: true }), "o");
 globalThis.process.env.NODE_ENV === "development";
 globalThis.process.env.NODE_ENV === "production";
 globalThis.process.env.NODE_ENV === "test";
@@ -4468,14 +5005,23 @@ globalThis.process.env.NODE_ENV === "test";
 ({ isLoggingEnabled: globalThis.process.env.NODE_ENV === "development" });
 ({ api: globalThis.process.env.NEXT_PUBLIC_API_URL });
 ({ FNV_64_PRIME: BigInt("0x100000001b3"), FNV_64_OFFSET: BigInt("0xcbf29ce484222325")});
-var Ue = { OK: 200, BAD_REQUEST: 400, UNAUTHORIZED: 401, FORBIDDEN: 403, NOT_FOUND: 404, REQUEST_TIMEOUT: 408, CONFLICT: 409, TOO_MANY_REQUESTS: 429, INTERNAL_SERVER_ERROR: 500, NOT_IMPLEMENTED: 501, BAD_GATEWAY: 502, SERVICE_UNAVAILABLE: 503, GATEWAY_TIMEOUT: 504};
-var a = { unauthorized: { status: 401}, internal_server_error: { status: 500}};
-({ InvalidInput: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [a.internal_server_error.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [a.unauthorized.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+var ke = { OK: 200, BAD_REQUEST: 400, UNAUTHORIZED: 401, FORBIDDEN: 403, NOT_FOUND: 404, REQUEST_TIMEOUT: 408, CONFLICT: 409, TOO_MANY_REQUESTS: 429, INTERNAL_SERVER_ERROR: 500, NOT_IMPLEMENTED: 501, BAD_GATEWAY: 502, SERVICE_UNAVAILABLE: 503, GATEWAY_TIMEOUT: 504};
+var s = { unauthorized: { status: 401}, internal_server_error: { status: 500}};
+({ InvalidInput: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [s.internal_server_error.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [s.unauthorized.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
 ({ SUPABASE_URL: globalThis.process.env.NEXT_PUBLIC_SUPABASE_URL ?? "", SUPABASE_ANON_KEY: globalThis.process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY ?? "" });
 globalThis.process.env.NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY ?? "";
+({ [ERRORSEVERITY.Low]: true, [ERRORSEVERITY.Medium]: false, [ERRORSEVERITY.High]: true, [ERRORSEVERITY.Critical]: true });
+({ DEFAULT_CATEGORY: PAYMENT_ERROR_CATEGORY.Webhook});
+({ DEFAULT_CATEGORY: PAYMENT_ERROR_CATEGORY.Validation});
+o(() => [], "EmptyArray");
+o(() => Date.now(), "CurrentTimestamp");
+({ requiredFileMissing: o((e) => `Required field "${e}" is missing.`, "requiredFileMissing") });
+var u = ((E) => (E.ASSIGNMENT = "assignment", E.LOGICAL = "logical", E.COMPARISON = "comparison", E.ARITHMETIC = "arithmetic", E.CONDITIONAL = "conditional", E.CONCATENATE = "concatenate", E))(u || {});
+var t = { REGISTRY: "ProviderRegistry", FACTORY: "ProviderFactory"};
+({ providerAlreadyRegistered: o((e) => `[${t.REGISTRY}] Provider '${e}' is already registered. Overwriting.`, "providerAlreadyRegistered"), providerRegistered: o((e) => `[${t.FACTORY}] Registered provider: ${e}`, "providerRegistered"), providerNotRegistered: o((e) => `[${t.REGISTRY}] Provider '${e}' is not registered.`, "providerNotRegistered"), adapterInitFailed: o((e) => `[${t.FACTORY}] Failed to initialize adapter for ${e}`, "adapterInitFailed"), optimalAdapterFailed: o((e) => `[${t.FACTORY}] Failed to get optimal adapter for: ${e}`, "optimalAdapterFailed") });
 
 // src/errors/codes.ts
-var ERROR_CODES = {
+var ERROR_CODES2 = {
   // ===== API Package Errors =====
   // Client Configuration
   CLIENT_INITIALIZATION_FAILED: "CLIENT_INITIALIZATION_FAILED",
@@ -4618,732 +5164,732 @@ var ERROR_CODES = {
   EVENT_FACTORY_NOT_REGISTERED: "error.event.factory.not.registered",
   DATABASE_ERROR: "error.database"
 };
-var API_ERROR_CODES = {
-  CLIENT_INITIALIZATION_FAILED: ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
-  CLIENT_INVALID_CONFIG: ERROR_CODES.CLIENT_INVALID_CONFIG,
-  CLIENT_MISSING_BASE_URL: ERROR_CODES.CLIENT_MISSING_BASE_URL,
-  CLIENT_CANCELLED: ERROR_CODES.CLIENT_CANCELLED,
-  CONFIG_VALIDATION_FAILED: ERROR_CODES.CONFIG_VALIDATION_FAILED,
-  HEADER_PROCESSING_FAILED: ERROR_CODES.HEADER_PROCESSING_FAILED,
-  NETWORK_OVERRIDE_FAILED: ERROR_CODES.NETWORK_OVERRIDE_FAILED,
-  REQUEST_TIMEOUT: ERROR_CODES.REQUEST_TIMEOUT,
-  REQUEST_ABORTED: ERROR_CODES.REQUEST_ABORTED,
-  REQUEST_INVALID_PARAMS: ERROR_CODES.REQUEST_INVALID_PARAMS,
-  REQUEST_PREPARATION_FAILED: ERROR_CODES.REQUEST_PREPARATION_FAILED,
-  RESPONSE_INVALID_FORMAT: ERROR_CODES.RESPONSE_INVALID_FORMAT,
-  RESPONSE_PARSING_FAILED: ERROR_CODES.RESPONSE_PARSING_FAILED,
-  AUTH_UNAUTHORIZED: ERROR_CODES.AUTH_UNAUTHORIZED,
-  AUTH_FORBIDDEN: ERROR_CODES.AUTH_FORBIDDEN,
-  AUTH_TOKEN_EXPIRED: ERROR_CODES.AUTH_TOKEN_EXPIRED,
-  AUTH_INVALID_CREDENTIALS: ERROR_CODES.AUTH_INVALID_CREDENTIALS,
-  RATE_LIMIT_EXCEEDED: ERROR_CODES.RATE_LIMIT_EXCEEDED,
-  RESOURCE_NOT_FOUND: ERROR_CODES.RESOURCE_NOT_FOUND,
-  RESOURCE_CONFLICT: ERROR_CODES.RESOURCE_CONFLICT,
-  VALIDATION_FAILED: ERROR_CODES.API_VALIDATION_FAILED,
-  INVALID_INPUT: ERROR_CODES.API_INVALID_INPUT,
-  VALIDATION_ERROR: ERROR_CODES.VALIDATION_ERROR,
-  REQUIRED_FIELD_MISSING: ERROR_CODES.REQUIRED_FIELD_MISSING,
-  INVALID_FORMAT: ERROR_CODES.INVALID_FORMAT,
-  VALIDATION_INVALID_FORMAT: ERROR_CODES.VALIDATION_INVALID_FORMAT,
-  STRING_TOO_SHORT: ERROR_CODES.STRING_TOO_SHORT,
-  STRING_TOO_LONG: ERROR_CODES.STRING_TOO_LONG,
-  NETWORK_ERROR: ERROR_CODES.NETWORK_ERROR,
-  CONNECTION_FAILED: ERROR_CODES.CONNECTION_FAILED,
-  NETWORK_CONNECTION_FAILED: ERROR_CODES.NETWORK_CONNECTION_FAILED,
-  NETWORK_OFFLINE: ERROR_CODES.NETWORK_OFFLINE,
-  NETWORK_DNS_FAILED: ERROR_CODES.NETWORK_DNS_FAILED,
-  NETWORK_TIMEOUT: ERROR_CODES.NETWORK_TIMEOUT,
-  NETWORK_CONFIGURATION_INVALID: ERROR_CODES.NETWORK_CONFIGURATION_INVALID,
-  SERVER_ERROR: ERROR_CODES.SERVER_ERROR,
-  INTERNAL_SERVER_ERROR: ERROR_CODES.INTERNAL_SERVER_ERROR,
-  SERVICE_UNAVAILABLE: ERROR_CODES.SERVICE_UNAVAILABLE,
-  CACHE_READ_FAILED: ERROR_CODES.CACHE_READ_FAILED,
-  CACHE_WRITE_FAILED: ERROR_CODES.CACHE_WRITE_FAILED,
-  CACHE_INVALIDATION_FAILED: ERROR_CODES.CACHE_INVALIDATION_FAILED,
-  CACHE_STORAGE_FAILED: ERROR_CODES.CACHE_STORAGE_FAILED,
-  CACHE_RETRIEVAL_FAILED: ERROR_CODES.CACHE_RETRIEVAL_FAILED,
-  RETRY_LIMIT_EXCEEDED: ERROR_CODES.RETRY_LIMIT_EXCEEDED,
-  RETRY_FAILED: ERROR_CODES.RETRY_FAILED,
-  RETRY_EXHAUSTED: ERROR_CODES.RETRY_EXHAUSTED,
-  RETRY_STRATEGY_INVALID: ERROR_CODES.RETRY_STRATEGY_INVALID,
-  STRATEGY_INVALID: ERROR_CODES.STRATEGY_INVALID,
-  STRATEGY_CONFLICT: ERROR_CODES.STRATEGY_CONFLICT,
-  STRATEGY_EXECUTION_FAILED: ERROR_CODES.STRATEGY_EXECUTION_FAILED,
-  HEADERS_ENRICHMENT_FAILED: ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
-  HEADERS_VALIDATION_FAILED: ERROR_CODES.HEADERS_VALIDATION_FAILED,
-  HEADERS_MERGE_CONFLICT: ERROR_CODES.HEADERS_MERGE_CONFLICT,
-  REGION_DETECTION_FAILED: ERROR_CODES.REGION_DETECTION_FAILED,
-  REGIONAL_PRESET_NOT_FOUND: ERROR_CODES.REGIONAL_PRESET_NOT_FOUND,
-  EXTERNAL_SERVICE_ERROR: ERROR_CODES.EXTERNAL_SERVICE_ERROR,
-  NETWORK_PRESET_NOT_FOUND: ERROR_CODES.NETWORK_PRESET_NOT_FOUND,
-  TIMEOUT: ERROR_CODES.TIMEOUT,
-  DEBUG_TRACKING_FAILED: ERROR_CODES.DEBUG_TRACKING_FAILED,
-  DEBUG_OVERRIDE_FAILED: ERROR_CODES.DEBUG_OVERRIDE_FAILED,
-  DEBUG_CONFLICT_DETECTED: ERROR_CODES.DEBUG_CONFLICT_DETECTED,
-  POLLING_CANCELLED: ERROR_CODES.POLLING_CANCELLED,
-  POLLING_TIMEOUT: ERROR_CODES.POLLING_TIMEOUT,
-  POLLING_INVALID_CONFIG: ERROR_CODES.POLLING_INVALID_CONFIG,
-  PUBSUB_SUBSCRIPTION_FAILED: ERROR_CODES.PUBSUB_SUBSCRIPTION_FAILED,
-  PUBSUB_PUBLICATION_FAILED: ERROR_CODES.PUBSUB_PUBLICATION_FAILED,
-  PUBSUB_INVALID_TOPIC: ERROR_CODES.PUBSUB_INVALID_TOPIC,
-  PUBSUB_CHANNEL_ERROR: ERROR_CODES.PUBSUB_CHANNEL_ERROR,
-  REVALIDATION_FAILED: ERROR_CODES.REVALIDATION_FAILED,
-  REVALIDATION_IN_PROGRESS: ERROR_CODES.REVALIDATION_IN_PROGRESS,
-  ENDPOINT_BUILD_FAILED: ERROR_CODES.ENDPOINT_BUILD_FAILED,
-  ENDPOINT_NOT_FOUND: ERROR_CODES.ENDPOINT_NOT_FOUND,
-  ENDPOINT_INVALID_CONFIG: ERROR_CODES.ENDPOINT_INVALID_CONFIG,
-  EVENT_HANDLER_FAILED: ERROR_CODES.EVENT_HANDLER_FAILED,
-  EVENT_EMISSION_FAILED: ERROR_CODES.EVENT_EMISSION_FAILED,
-  MONITORING_FAILED: ERROR_CODES.MONITORING_FAILED,
-  CONTEXT_OPERATION_FAILED: ERROR_CODES.CONTEXT_OPERATION_FAILED,
-  CLIENT_ERROR: ERROR_CODES.CLIENT_ERROR,
-  UNKNOWN_ERROR: ERROR_CODES.UNKNOWN_ERROR
-};
-var NOTIFICATION_ERROR_CODES = {
-  PROVIDER_SEND_FAILED: ERROR_CODES.NOTIFICATION_PROVIDER_SEND_FAILED,
-  PROVIDER_CONFIGURATION_INVALID: ERROR_CODES.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID,
-  PROVIDER_RATE_LIMIT: ERROR_CODES.NOTIFICATION_PROVIDER_RATE_LIMIT,
-  PROVIDER_AUTH_FAILED: ERROR_CODES.NOTIFICATION_PROVIDER_AUTH_FAILED,
-  PROVIDER_TIMEOUT: ERROR_CODES.NOTIFICATION_PROVIDER_TIMEOUT,
-  PROVIDER_UNAVAILABLE: ERROR_CODES.NOTIFICATION_PROVIDER_UNAVAILABLE,
-  PROVIDER_FEATURE_NOT_SUPPORTED: ERROR_CODES.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED,
-  ALL_PROVIDERS_FAILED: ERROR_CODES.NOTIFICATION_ALL_PROVIDERS_FAILED,
-  INVALID_INPUT: ERROR_CODES.NOTIFICATION_INVALID_INPUT,
-  INVALID_RECIPIENT: ERROR_CODES.NOTIFICATION_INVALID_RECIPIENT,
-  INVALID_TEMPLATE: ERROR_CODES.NOTIFICATION_INVALID_TEMPLATE,
-  INVALID_PAYLOAD: ERROR_CODES.NOTIFICATION_INVALID_PAYLOAD,
-  MISSING_REQUIRED_FIELD: ERROR_CODES.NOTIFICATION_MISSING_REQUIRED_FIELD,
-  VALIDATION_FAILED: ERROR_CODES.NOTIFICATION_VALIDATION_FAILED,
-  USER_OPTED_OUT: ERROR_CODES.NOTIFICATION_USER_OPTED_OUT,
-  QUEUE_FULL: ERROR_CODES.NOTIFICATION_QUEUE_FULL,
-  QUEUE_PROCESSING_FAILED: ERROR_CODES.NOTIFICATION_QUEUE_PROCESSING_FAILED,
-  WEBHOOK_SIGNATURE_INVALID: ERROR_CODES.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID,
-  WEBHOOK_VALIDATION_FAILED: ERROR_CODES.NOTIFICATION_WEBHOOK_VALIDATION_FAILED,
-  WEBHOOK_PROCESSING_FAILED: ERROR_CODES.NOTIFICATION_WEBHOOK_PROCESSING_FAILED,
-  TEMPLATE_NOT_FOUND: ERROR_CODES.NOTIFICATION_TEMPLATE_NOT_FOUND,
-  TEMPLATE_RENDER_FAILED: ERROR_CODES.NOTIFICATION_TEMPLATE_RENDER_FAILED,
-  UNKNOWN_ERROR: ERROR_CODES.NOTIFICATION_UNKNOWN_ERROR,
-  INITIALIZATION_FAILED: ERROR_CODES.NOTIFICATION_INITIALIZATION_FAILED
-};
-var ERROR_DEFINITIONS = {
+var API_ERROR_CODES2 = {
+  CLIENT_INITIALIZATION_FAILED: ERROR_CODES2.CLIENT_INITIALIZATION_FAILED,
+  CLIENT_INVALID_CONFIG: ERROR_CODES2.CLIENT_INVALID_CONFIG,
+  CLIENT_MISSING_BASE_URL: ERROR_CODES2.CLIENT_MISSING_BASE_URL,
+  CLIENT_CANCELLED: ERROR_CODES2.CLIENT_CANCELLED,
+  CONFIG_VALIDATION_FAILED: ERROR_CODES2.CONFIG_VALIDATION_FAILED,
+  HEADER_PROCESSING_FAILED: ERROR_CODES2.HEADER_PROCESSING_FAILED,
+  NETWORK_OVERRIDE_FAILED: ERROR_CODES2.NETWORK_OVERRIDE_FAILED,
+  REQUEST_TIMEOUT: ERROR_CODES2.REQUEST_TIMEOUT,
+  REQUEST_ABORTED: ERROR_CODES2.REQUEST_ABORTED,
+  REQUEST_INVALID_PARAMS: ERROR_CODES2.REQUEST_INVALID_PARAMS,
+  REQUEST_PREPARATION_FAILED: ERROR_CODES2.REQUEST_PREPARATION_FAILED,
+  RESPONSE_INVALID_FORMAT: ERROR_CODES2.RESPONSE_INVALID_FORMAT,
+  RESPONSE_PARSING_FAILED: ERROR_CODES2.RESPONSE_PARSING_FAILED,
+  AUTH_UNAUTHORIZED: ERROR_CODES2.AUTH_UNAUTHORIZED,
+  AUTH_FORBIDDEN: ERROR_CODES2.AUTH_FORBIDDEN,
+  AUTH_TOKEN_EXPIRED: ERROR_CODES2.AUTH_TOKEN_EXPIRED,
+  AUTH_INVALID_CREDENTIALS: ERROR_CODES2.AUTH_INVALID_CREDENTIALS,
+  RATE_LIMIT_EXCEEDED: ERROR_CODES2.RATE_LIMIT_EXCEEDED,
+  RESOURCE_NOT_FOUND: ERROR_CODES2.RESOURCE_NOT_FOUND,
+  RESOURCE_CONFLICT: ERROR_CODES2.RESOURCE_CONFLICT,
+  VALIDATION_FAILED: ERROR_CODES2.API_VALIDATION_FAILED,
+  INVALID_INPUT: ERROR_CODES2.API_INVALID_INPUT,
+  VALIDATION_ERROR: ERROR_CODES2.VALIDATION_ERROR,
+  REQUIRED_FIELD_MISSING: ERROR_CODES2.REQUIRED_FIELD_MISSING,
+  INVALID_FORMAT: ERROR_CODES2.INVALID_FORMAT,
+  VALIDATION_INVALID_FORMAT: ERROR_CODES2.VALIDATION_INVALID_FORMAT,
+  STRING_TOO_SHORT: ERROR_CODES2.STRING_TOO_SHORT,
+  STRING_TOO_LONG: ERROR_CODES2.STRING_TOO_LONG,
+  NETWORK_ERROR: ERROR_CODES2.NETWORK_ERROR,
+  CONNECTION_FAILED: ERROR_CODES2.CONNECTION_FAILED,
+  NETWORK_CONNECTION_FAILED: ERROR_CODES2.NETWORK_CONNECTION_FAILED,
+  NETWORK_OFFLINE: ERROR_CODES2.NETWORK_OFFLINE,
+  NETWORK_DNS_FAILED: ERROR_CODES2.NETWORK_DNS_FAILED,
+  NETWORK_TIMEOUT: ERROR_CODES2.NETWORK_TIMEOUT,
+  NETWORK_CONFIGURATION_INVALID: ERROR_CODES2.NETWORK_CONFIGURATION_INVALID,
+  SERVER_ERROR: ERROR_CODES2.SERVER_ERROR,
+  INTERNAL_SERVER_ERROR: ERROR_CODES2.INTERNAL_SERVER_ERROR,
+  SERVICE_UNAVAILABLE: ERROR_CODES2.SERVICE_UNAVAILABLE,
+  CACHE_READ_FAILED: ERROR_CODES2.CACHE_READ_FAILED,
+  CACHE_WRITE_FAILED: ERROR_CODES2.CACHE_WRITE_FAILED,
+  CACHE_INVALIDATION_FAILED: ERROR_CODES2.CACHE_INVALIDATION_FAILED,
+  CACHE_STORAGE_FAILED: ERROR_CODES2.CACHE_STORAGE_FAILED,
+  CACHE_RETRIEVAL_FAILED: ERROR_CODES2.CACHE_RETRIEVAL_FAILED,
+  RETRY_LIMIT_EXCEEDED: ERROR_CODES2.RETRY_LIMIT_EXCEEDED,
+  RETRY_FAILED: ERROR_CODES2.RETRY_FAILED,
+  RETRY_EXHAUSTED: ERROR_CODES2.RETRY_EXHAUSTED,
+  RETRY_STRATEGY_INVALID: ERROR_CODES2.RETRY_STRATEGY_INVALID,
+  STRATEGY_INVALID: ERROR_CODES2.STRATEGY_INVALID,
+  STRATEGY_CONFLICT: ERROR_CODES2.STRATEGY_CONFLICT,
+  STRATEGY_EXECUTION_FAILED: ERROR_CODES2.STRATEGY_EXECUTION_FAILED,
+  HEADERS_ENRICHMENT_FAILED: ERROR_CODES2.HEADERS_ENRICHMENT_FAILED,
+  HEADERS_VALIDATION_FAILED: ERROR_CODES2.HEADERS_VALIDATION_FAILED,
+  HEADERS_MERGE_CONFLICT: ERROR_CODES2.HEADERS_MERGE_CONFLICT,
+  REGION_DETECTION_FAILED: ERROR_CODES2.REGION_DETECTION_FAILED,
+  REGIONAL_PRESET_NOT_FOUND: ERROR_CODES2.REGIONAL_PRESET_NOT_FOUND,
+  EXTERNAL_SERVICE_ERROR: ERROR_CODES2.EXTERNAL_SERVICE_ERROR,
+  NETWORK_PRESET_NOT_FOUND: ERROR_CODES2.NETWORK_PRESET_NOT_FOUND,
+  TIMEOUT: ERROR_CODES2.TIMEOUT,
+  DEBUG_TRACKING_FAILED: ERROR_CODES2.DEBUG_TRACKING_FAILED,
+  DEBUG_OVERRIDE_FAILED: ERROR_CODES2.DEBUG_OVERRIDE_FAILED,
+  DEBUG_CONFLICT_DETECTED: ERROR_CODES2.DEBUG_CONFLICT_DETECTED,
+  POLLING_CANCELLED: ERROR_CODES2.POLLING_CANCELLED,
+  POLLING_TIMEOUT: ERROR_CODES2.POLLING_TIMEOUT,
+  POLLING_INVALID_CONFIG: ERROR_CODES2.POLLING_INVALID_CONFIG,
+  PUBSUB_SUBSCRIPTION_FAILED: ERROR_CODES2.PUBSUB_SUBSCRIPTION_FAILED,
+  PUBSUB_PUBLICATION_FAILED: ERROR_CODES2.PUBSUB_PUBLICATION_FAILED,
+  PUBSUB_INVALID_TOPIC: ERROR_CODES2.PUBSUB_INVALID_TOPIC,
+  PUBSUB_CHANNEL_ERROR: ERROR_CODES2.PUBSUB_CHANNEL_ERROR,
+  REVALIDATION_FAILED: ERROR_CODES2.REVALIDATION_FAILED,
+  REVALIDATION_IN_PROGRESS: ERROR_CODES2.REVALIDATION_IN_PROGRESS,
+  ENDPOINT_BUILD_FAILED: ERROR_CODES2.ENDPOINT_BUILD_FAILED,
+  ENDPOINT_NOT_FOUND: ERROR_CODES2.ENDPOINT_NOT_FOUND,
+  ENDPOINT_INVALID_CONFIG: ERROR_CODES2.ENDPOINT_INVALID_CONFIG,
+  EVENT_HANDLER_FAILED: ERROR_CODES2.EVENT_HANDLER_FAILED,
+  EVENT_EMISSION_FAILED: ERROR_CODES2.EVENT_EMISSION_FAILED,
+  MONITORING_FAILED: ERROR_CODES2.MONITORING_FAILED,
+  CONTEXT_OPERATION_FAILED: ERROR_CODES2.CONTEXT_OPERATION_FAILED,
+  CLIENT_ERROR: ERROR_CODES2.CLIENT_ERROR,
+  UNKNOWN_ERROR: ERROR_CODES2.UNKNOWN_ERROR
+};
+var NOTIFICATION_ERROR_CODES2 = {
+  PROVIDER_SEND_FAILED: ERROR_CODES2.NOTIFICATION_PROVIDER_SEND_FAILED,
+  PROVIDER_CONFIGURATION_INVALID: ERROR_CODES2.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID,
+  PROVIDER_RATE_LIMIT: ERROR_CODES2.NOTIFICATION_PROVIDER_RATE_LIMIT,
+  PROVIDER_AUTH_FAILED: ERROR_CODES2.NOTIFICATION_PROVIDER_AUTH_FAILED,
+  PROVIDER_TIMEOUT: ERROR_CODES2.NOTIFICATION_PROVIDER_TIMEOUT,
+  PROVIDER_UNAVAILABLE: ERROR_CODES2.NOTIFICATION_PROVIDER_UNAVAILABLE,
+  PROVIDER_FEATURE_NOT_SUPPORTED: ERROR_CODES2.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED,
+  ALL_PROVIDERS_FAILED: ERROR_CODES2.NOTIFICATION_ALL_PROVIDERS_FAILED,
+  INVALID_INPUT: ERROR_CODES2.NOTIFICATION_INVALID_INPUT,
+  INVALID_RECIPIENT: ERROR_CODES2.NOTIFICATION_INVALID_RECIPIENT,
+  INVALID_TEMPLATE: ERROR_CODES2.NOTIFICATION_INVALID_TEMPLATE,
+  INVALID_PAYLOAD: ERROR_CODES2.NOTIFICATION_INVALID_PAYLOAD,
+  MISSING_REQUIRED_FIELD: ERROR_CODES2.NOTIFICATION_MISSING_REQUIRED_FIELD,
+  VALIDATION_FAILED: ERROR_CODES2.NOTIFICATION_VALIDATION_FAILED,
+  USER_OPTED_OUT: ERROR_CODES2.NOTIFICATION_USER_OPTED_OUT,
+  QUEUE_FULL: ERROR_CODES2.NOTIFICATION_QUEUE_FULL,
+  QUEUE_PROCESSING_FAILED: ERROR_CODES2.NOTIFICATION_QUEUE_PROCESSING_FAILED,
+  WEBHOOK_SIGNATURE_INVALID: ERROR_CODES2.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID,
+  WEBHOOK_VALIDATION_FAILED: ERROR_CODES2.NOTIFICATION_WEBHOOK_VALIDATION_FAILED,
+  WEBHOOK_PROCESSING_FAILED: ERROR_CODES2.NOTIFICATION_WEBHOOK_PROCESSING_FAILED,
+  TEMPLATE_NOT_FOUND: ERROR_CODES2.NOTIFICATION_TEMPLATE_NOT_FOUND,
+  TEMPLATE_RENDER_FAILED: ERROR_CODES2.NOTIFICATION_TEMPLATE_RENDER_FAILED,
+  UNKNOWN_ERROR: ERROR_CODES2.NOTIFICATION_UNKNOWN_ERROR,
+  INITIALIZATION_FAILED: ERROR_CODES2.NOTIFICATION_INITIALIZATION_FAILED
+};
+var ERROR_DEFINITIONS2 = {
   // ===== API Package Error Definitions =====
   // Authentication
-  [ERROR_CODES.AUTH_UNAUTHORIZED]: {
-    code: ERROR_CODES.AUTH_UNAUTHORIZED,
-    status: Ue.UNAUTHORIZED,
+  [ERROR_CODES2.AUTH_UNAUTHORIZED]: {
+    code: ERROR_CODES2.AUTH_UNAUTHORIZED,
+    status: ke.UNAUTHORIZED,
     category: ERROR_CATEGORY.Authentication,
     userMessage: "errors.auth.unauthorized",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.AUTH_FORBIDDEN]: {
-    code: ERROR_CODES.AUTH_FORBIDDEN,
-    status: Ue.FORBIDDEN,
+  [ERROR_CODES2.AUTH_FORBIDDEN]: {
+    code: ERROR_CODES2.AUTH_FORBIDDEN,
+    status: ke.FORBIDDEN,
     category: ERROR_CATEGORY.Authorization,
     userMessage: "errors.auth.forbidden",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.AUTH_TOKEN_EXPIRED]: {
-    code: ERROR_CODES.AUTH_TOKEN_EXPIRED,
-    status: Ue.UNAUTHORIZED,
+  [ERROR_CODES2.AUTH_TOKEN_EXPIRED]: {
+    code: ERROR_CODES2.AUTH_TOKEN_EXPIRED,
+    status: ke.UNAUTHORIZED,
     category: ERROR_CATEGORY.Authentication,
     userMessage: "errors.auth.token_expired",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.AUTH_INVALID_CREDENTIALS]: {
-    code: ERROR_CODES.AUTH_INVALID_CREDENTIALS,
-    status: Ue.UNAUTHORIZED,
+  [ERROR_CODES2.AUTH_INVALID_CREDENTIALS]: {
+    code: ERROR_CODES2.AUTH_INVALID_CREDENTIALS,
+    status: ke.UNAUTHORIZED,
     category: ERROR_CATEGORY.Authentication,
     userMessage: "errors.auth.invalid_credentials",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Rate Limiting
-  [ERROR_CODES.RATE_LIMIT_EXCEEDED]: {
-    code: ERROR_CODES.RATE_LIMIT_EXCEEDED,
-    status: Ue.TOO_MANY_REQUESTS,
+  [ERROR_CODES2.RATE_LIMIT_EXCEEDED]: {
+    code: ERROR_CODES2.RATE_LIMIT_EXCEEDED,
+    status: ke.TOO_MANY_REQUESTS,
     category: ERROR_CATEGORY.RateLimit,
     userMessage: "errors.rate_limit.exceeded",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
   // Resources
-  [ERROR_CODES.RESOURCE_NOT_FOUND]: {
-    code: ERROR_CODES.RESOURCE_NOT_FOUND,
-    status: Ue.NOT_FOUND,
+  [ERROR_CODES2.RESOURCE_NOT_FOUND]: {
+    code: ERROR_CODES2.RESOURCE_NOT_FOUND,
+    status: ke.NOT_FOUND,
     category: ERROR_CATEGORY.NotFound,
     userMessage: "errors.resource.not_found",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.RESOURCE_CONFLICT]: {
-    code: ERROR_CODES.RESOURCE_CONFLICT,
-    status: Ue.CONFLICT,
+  [ERROR_CODES2.RESOURCE_CONFLICT]: {
+    code: ERROR_CODES2.RESOURCE_CONFLICT,
+    status: ke.CONFLICT,
     category: ERROR_CATEGORY.Conflict,
     userMessage: "errors.resource.conflict",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Validation
-  [ERROR_CODES.API_VALIDATION_FAILED]: {
-    code: ERROR_CODES.API_VALIDATION_FAILED,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.API_VALIDATION_FAILED]: {
+    code: ERROR_CODES2.API_VALIDATION_FAILED,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.API_INVALID_INPUT]: {
-    code: ERROR_CODES.API_INVALID_INPUT,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.API_INVALID_INPUT]: {
+    code: ERROR_CODES2.API_INVALID_INPUT,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.invalid_input",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.VALIDATION_ERROR]: {
-    code: ERROR_CODES.VALIDATION_ERROR,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.VALIDATION_ERROR]: {
+    code: ERROR_CODES2.VALIDATION_ERROR,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.error",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.REQUIRED_FIELD_MISSING]: {
-    code: ERROR_CODES.REQUIRED_FIELD_MISSING,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.REQUIRED_FIELD_MISSING]: {
+    code: ERROR_CODES2.REQUIRED_FIELD_MISSING,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.required_field_missing",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.INVALID_FORMAT]: {
-    code: ERROR_CODES.INVALID_FORMAT,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.INVALID_FORMAT]: {
+    code: ERROR_CODES2.INVALID_FORMAT,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.invalid_format",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.VALIDATION_INVALID_FORMAT]: {
-    code: ERROR_CODES.VALIDATION_INVALID_FORMAT,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.VALIDATION_INVALID_FORMAT]: {
+    code: ERROR_CODES2.VALIDATION_INVALID_FORMAT,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.invalid_format",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.STRING_TOO_SHORT]: {
-    code: ERROR_CODES.STRING_TOO_SHORT,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.STRING_TOO_SHORT]: {
+    code: ERROR_CODES2.STRING_TOO_SHORT,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.string_too_short",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.STRING_TOO_LONG]: {
-    code: ERROR_CODES.STRING_TOO_LONG,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.STRING_TOO_LONG]: {
+    code: ERROR_CODES2.STRING_TOO_LONG,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.validation.string_too_long",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Network
-  [ERROR_CODES.NETWORK_ERROR]: {
-    code: ERROR_CODES.NETWORK_ERROR,
-    status: Ue.BAD_GATEWAY,
+  [ERROR_CODES2.NETWORK_ERROR]: {
+    code: ERROR_CODES2.NETWORK_ERROR,
+    status: ke.BAD_GATEWAY,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.error",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.CONNECTION_FAILED]: {
-    code: ERROR_CODES.CONNECTION_FAILED,
+  [ERROR_CODES2.CONNECTION_FAILED]: {
+    code: ERROR_CODES2.CONNECTION_FAILED,
     status: 0,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.connection_failed",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.NETWORK_CONNECTION_FAILED]: {
-    code: ERROR_CODES.NETWORK_CONNECTION_FAILED,
+  [ERROR_CODES2.NETWORK_CONNECTION_FAILED]: {
+    code: ERROR_CODES2.NETWORK_CONNECTION_FAILED,
     status: 0,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.connection_failed",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.NETWORK_OFFLINE]: {
-    code: ERROR_CODES.NETWORK_OFFLINE,
+  [ERROR_CODES2.NETWORK_OFFLINE]: {
+    code: ERROR_CODES2.NETWORK_OFFLINE,
     status: 0,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.offline",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.NETWORK_DNS_FAILED]: {
-    code: ERROR_CODES.NETWORK_DNS_FAILED,
+  [ERROR_CODES2.NETWORK_DNS_FAILED]: {
+    code: ERROR_CODES2.NETWORK_DNS_FAILED,
     status: 0,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.dns_failed",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.NETWORK_TIMEOUT]: {
-    code: ERROR_CODES.NETWORK_TIMEOUT,
+  [ERROR_CODES2.NETWORK_TIMEOUT]: {
+    code: ERROR_CODES2.NETWORK_TIMEOUT,
     status: 0,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.timeout",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.NETWORK_CONFIGURATION_INVALID]: {
-    code: ERROR_CODES.NETWORK_CONFIGURATION_INVALID,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NETWORK_CONFIGURATION_INVALID]: {
+    code: ERROR_CODES2.NETWORK_CONFIGURATION_INVALID,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.network.configuration_invalid",
     severity: ERROR_SEVERITY.Critical,
     retryable: true
   },
-  [ERROR_CODES.NETWORK_PRESET_NOT_FOUND]: {
-    code: ERROR_CODES.NETWORK_PRESET_NOT_FOUND,
-    status: Ue.NOT_FOUND,
+  [ERROR_CODES2.NETWORK_PRESET_NOT_FOUND]: {
+    code: ERROR_CODES2.NETWORK_PRESET_NOT_FOUND,
+    status: ke.NOT_FOUND,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.network.preset_not_found",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
   // Server
-  [ERROR_CODES.SERVER_ERROR]: {
-    code: ERROR_CODES.SERVER_ERROR,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.SERVER_ERROR]: {
+    code: ERROR_CODES2.SERVER_ERROR,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.server.error",
     severity: ERROR_SEVERITY.High,
     retryable: false
   },
-  [ERROR_CODES.INTERNAL_SERVER_ERROR]: {
-    code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.INTERNAL_SERVER_ERROR]: {
+    code: ERROR_CODES2.INTERNAL_SERVER_ERROR,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.server.internal_error",
     severity: ERROR_SEVERITY.High,
     retryable: false
   },
-  [ERROR_CODES.SERVICE_UNAVAILABLE]: {
-    code: ERROR_CODES.SERVICE_UNAVAILABLE,
-    status: Ue.SERVICE_UNAVAILABLE,
+  [ERROR_CODES2.SERVICE_UNAVAILABLE]: {
+    code: ERROR_CODES2.SERVICE_UNAVAILABLE,
+    status: ke.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.server.service_unavailable",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
   // Cache
-  [ERROR_CODES.CACHE_READ_FAILED]: {
-    code: ERROR_CODES.CACHE_READ_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CACHE_READ_FAILED]: {
+    code: ERROR_CODES2.CACHE_READ_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.cache.read_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.CACHE_WRITE_FAILED]: {
-    code: ERROR_CODES.CACHE_WRITE_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CACHE_WRITE_FAILED]: {
+    code: ERROR_CODES2.CACHE_WRITE_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.cache.write_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.CACHE_INVALIDATION_FAILED]: {
-    code: ERROR_CODES.CACHE_INVALIDATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CACHE_INVALIDATION_FAILED]: {
+    code: ERROR_CODES2.CACHE_INVALIDATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.cache.invalidation_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.CACHE_STORAGE_FAILED]: {
-    code: ERROR_CODES.CACHE_STORAGE_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CACHE_STORAGE_FAILED]: {
+    code: ERROR_CODES2.CACHE_STORAGE_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.cache.storage_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.CACHE_RETRIEVAL_FAILED]: {
-    code: ERROR_CODES.CACHE_RETRIEVAL_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CACHE_RETRIEVAL_FAILED]: {
+    code: ERROR_CODES2.CACHE_RETRIEVAL_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.cache.retrieval_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Retry
-  [ERROR_CODES.RETRY_LIMIT_EXCEEDED]: {
-    code: ERROR_CODES.RETRY_LIMIT_EXCEEDED,
-    status: Ue.SERVICE_UNAVAILABLE,
+  [ERROR_CODES2.RETRY_LIMIT_EXCEEDED]: {
+    code: ERROR_CODES2.RETRY_LIMIT_EXCEEDED,
+    status: ke.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Retry,
     userMessage: "errors.retry.limit_exceeded",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
-  [ERROR_CODES.RETRY_FAILED]: {
-    code: ERROR_CODES.RETRY_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.RETRY_FAILED]: {
+    code: ERROR_CODES2.RETRY_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Retry,
     userMessage: "errors.retry.failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
-  [ERROR_CODES.RETRY_EXHAUSTED]: {
-    code: ERROR_CODES.RETRY_EXHAUSTED,
-    status: Ue.SERVICE_UNAVAILABLE,
+  [ERROR_CODES2.RETRY_EXHAUSTED]: {
+    code: ERROR_CODES2.RETRY_EXHAUSTED,
+    status: ke.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Retry,
     userMessage: "errors.retry.exhausted",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
-  [ERROR_CODES.RETRY_STRATEGY_INVALID]: {
-    code: ERROR_CODES.RETRY_STRATEGY_INVALID,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.RETRY_STRATEGY_INVALID]: {
+    code: ERROR_CODES2.RETRY_STRATEGY_INVALID,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.retry.strategy_invalid",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
   // Strategy
-  [ERROR_CODES.STRATEGY_INVALID]: {
-    code: ERROR_CODES.STRATEGY_INVALID,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.STRATEGY_INVALID]: {
+    code: ERROR_CODES2.STRATEGY_INVALID,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.strategy.invalid",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.STRATEGY_CONFLICT]: {
-    code: ERROR_CODES.STRATEGY_CONFLICT,
-    status: Ue.CONFLICT,
+  [ERROR_CODES2.STRATEGY_CONFLICT]: {
+    code: ERROR_CODES2.STRATEGY_CONFLICT,
+    status: ke.CONFLICT,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.strategy.conflict",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.STRATEGY_EXECUTION_FAILED]: {
-    code: ERROR_CODES.STRATEGY_EXECUTION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.STRATEGY_EXECUTION_FAILED]: {
+    code: ERROR_CODES2.STRATEGY_EXECUTION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.strategy.execution_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Headers
-  [ERROR_CODES.HEADERS_ENRICHMENT_FAILED]: {
-    code: ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.HEADERS_ENRICHMENT_FAILED]: {
+    code: ERROR_CODES2.HEADERS_ENRICHMENT_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Headers,
     userMessage: "errors.headers.enrichment_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.HEADERS_VALIDATION_FAILED]: {
-    code: ERROR_CODES.HEADERS_VALIDATION_FAILED,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.HEADERS_VALIDATION_FAILED]: {
+    code: ERROR_CODES2.HEADERS_VALIDATION_FAILED,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Headers,
     userMessage: "errors.headers.validation_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.HEADERS_MERGE_CONFLICT]: {
-    code: ERROR_CODES.HEADERS_MERGE_CONFLICT,
-    status: Ue.CONFLICT,
+  [ERROR_CODES2.HEADERS_MERGE_CONFLICT]: {
+    code: ERROR_CODES2.HEADERS_MERGE_CONFLICT,
+    status: ke.CONFLICT,
     category: ERROR_CATEGORY.Headers,
     userMessage: "errors.headers.merge_conflict",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Regional
-  [ERROR_CODES.REGION_DETECTION_FAILED]: {
-    code: ERROR_CODES.REGION_DETECTION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.REGION_DETECTION_FAILED]: {
+    code: ERROR_CODES2.REGION_DETECTION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.regional.detection_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.REGIONAL_PRESET_NOT_FOUND]: {
-    code: ERROR_CODES.REGIONAL_PRESET_NOT_FOUND,
-    status: Ue.NOT_FOUND,
+  [ERROR_CODES2.REGIONAL_PRESET_NOT_FOUND]: {
+    code: ERROR_CODES2.REGIONAL_PRESET_NOT_FOUND,
+    status: ke.NOT_FOUND,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.regional.preset_not_found",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // External Services
-  [ERROR_CODES.EXTERNAL_SERVICE_ERROR]: {
-    code: ERROR_CODES.EXTERNAL_SERVICE_ERROR,
-    status: Ue.BAD_GATEWAY,
+  [ERROR_CODES2.EXTERNAL_SERVICE_ERROR]: {
+    code: ERROR_CODES2.EXTERNAL_SERVICE_ERROR,
+    status: ke.BAD_GATEWAY,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.external.service_error",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Timeout
-  [ERROR_CODES.TIMEOUT]: {
-    code: ERROR_CODES.TIMEOUT,
-    status: Ue.REQUEST_TIMEOUT,
+  [ERROR_CODES2.TIMEOUT]: {
+    code: ERROR_CODES2.TIMEOUT,
+    status: ke.REQUEST_TIMEOUT,
     category: ERROR_CATEGORY.Timeout,
     userMessage: "errors.timeout.generic",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
   // Debugging
-  [ERROR_CODES.DEBUG_TRACKING_FAILED]: {
-    code: ERROR_CODES.DEBUG_TRACKING_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.DEBUG_TRACKING_FAILED]: {
+    code: ERROR_CODES2.DEBUG_TRACKING_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.debug.tracking_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.DEBUG_OVERRIDE_FAILED]: {
-    code: ERROR_CODES.DEBUG_OVERRIDE_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.DEBUG_OVERRIDE_FAILED]: {
+    code: ERROR_CODES2.DEBUG_OVERRIDE_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.debug.override_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.DEBUG_CONFLICT_DETECTED]: {
-    code: ERROR_CODES.DEBUG_CONFLICT_DETECTED,
-    status: Ue.CONFLICT,
+  [ERROR_CODES2.DEBUG_CONFLICT_DETECTED]: {
+    code: ERROR_CODES2.DEBUG_CONFLICT_DETECTED,
+    status: ke.CONFLICT,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.debug.conflict_detected",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Endpoint
-  [ERROR_CODES.ENDPOINT_BUILD_FAILED]: {
-    code: ERROR_CODES.ENDPOINT_BUILD_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.ENDPOINT_BUILD_FAILED]: {
+    code: ERROR_CODES2.ENDPOINT_BUILD_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.endpoint.build_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.ENDPOINT_NOT_FOUND]: {
-    code: ERROR_CODES.ENDPOINT_NOT_FOUND,
-    status: Ue.NOT_FOUND,
+  [ERROR_CODES2.ENDPOINT_NOT_FOUND]: {
+    code: ERROR_CODES2.ENDPOINT_NOT_FOUND,
+    status: ke.NOT_FOUND,
     category: ERROR_CATEGORY.NotFound,
     userMessage: "errors.endpoint.not_found",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.ENDPOINT_INVALID_CONFIG]: {
-    code: ERROR_CODES.ENDPOINT_INVALID_CONFIG,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.ENDPOINT_INVALID_CONFIG]: {
+    code: ERROR_CODES2.ENDPOINT_INVALID_CONFIG,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.endpoint.invalid_config",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
   // Event
-  [ERROR_CODES.EVENT_HANDLER_FAILED]: {
-    code: ERROR_CODES.EVENT_HANDLER_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.EVENT_HANDLER_FAILED]: {
+    code: ERROR_CODES2.EVENT_HANDLER_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.event.handler_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.EVENT_EMISSION_FAILED]: {
-    code: ERROR_CODES.EVENT_EMISSION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.EVENT_EMISSION_FAILED]: {
+    code: ERROR_CODES2.EVENT_EMISSION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.event.emission_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.MONITORING_FAILED]: {
-    code: ERROR_CODES.MONITORING_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.MONITORING_FAILED]: {
+    code: ERROR_CODES2.MONITORING_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.monitoring.failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Polling
-  [ERROR_CODES.POLLING_CANCELLED]: {
-    code: ERROR_CODES.POLLING_CANCELLED,
+  [ERROR_CODES2.POLLING_CANCELLED]: {
+    code: ERROR_CODES2.POLLING_CANCELLED,
     status: 0,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.polling.cancelled",
     severity: ERROR_SEVERITY.Low,
     retryable: false
   },
-  [ERROR_CODES.POLLING_TIMEOUT]: {
-    code: ERROR_CODES.POLLING_TIMEOUT,
-    status: Ue.REQUEST_TIMEOUT,
+  [ERROR_CODES2.POLLING_TIMEOUT]: {
+    code: ERROR_CODES2.POLLING_TIMEOUT,
+    status: ke.REQUEST_TIMEOUT,
     category: ERROR_CATEGORY.Timeout,
     userMessage: "errors.polling.timeout",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.POLLING_INVALID_CONFIG]: {
-    code: ERROR_CODES.POLLING_INVALID_CONFIG,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.POLLING_INVALID_CONFIG]: {
+    code: ERROR_CODES2.POLLING_INVALID_CONFIG,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.polling.invalid_config",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
   // PubSub
-  [ERROR_CODES.PUBSUB_SUBSCRIPTION_FAILED]: {
-    code: ERROR_CODES.PUBSUB_SUBSCRIPTION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.PUBSUB_SUBSCRIPTION_FAILED]: {
+    code: ERROR_CODES2.PUBSUB_SUBSCRIPTION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.pubsub.subscription_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.PUBSUB_PUBLICATION_FAILED]: {
-    code: ERROR_CODES.PUBSUB_PUBLICATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.PUBSUB_PUBLICATION_FAILED]: {
+    code: ERROR_CODES2.PUBSUB_PUBLICATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.pubsub.publication_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.PUBSUB_INVALID_TOPIC]: {
-    code: ERROR_CODES.PUBSUB_INVALID_TOPIC,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.PUBSUB_INVALID_TOPIC]: {
+    code: ERROR_CODES2.PUBSUB_INVALID_TOPIC,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.pubsub.invalid_topic",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.PUBSUB_CHANNEL_ERROR]: {
-    code: ERROR_CODES.PUBSUB_CHANNEL_ERROR,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.PUBSUB_CHANNEL_ERROR]: {
+    code: ERROR_CODES2.PUBSUB_CHANNEL_ERROR,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.pubsub.channel_error",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Revalidation
-  [ERROR_CODES.REVALIDATION_FAILED]: {
-    code: ERROR_CODES.REVALIDATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.REVALIDATION_FAILED]: {
+    code: ERROR_CODES2.REVALIDATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.revalidation.failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.REVALIDATION_IN_PROGRESS]: {
-    code: ERROR_CODES.REVALIDATION_IN_PROGRESS,
-    status: Ue.CONFLICT,
+  [ERROR_CODES2.REVALIDATION_IN_PROGRESS]: {
+    code: ERROR_CODES2.REVALIDATION_IN_PROGRESS,
+    status: ke.CONFLICT,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.revalidation.in_progress",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Context
-  [ERROR_CODES.CONTEXT_OPERATION_FAILED]: {
-    code: ERROR_CODES.CONTEXT_OPERATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CONTEXT_OPERATION_FAILED]: {
+    code: ERROR_CODES2.CONTEXT_OPERATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.context.operation_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Request
-  [ERROR_CODES.REQUEST_TIMEOUT]: {
-    code: ERROR_CODES.REQUEST_TIMEOUT,
-    status: Ue.REQUEST_TIMEOUT,
+  [ERROR_CODES2.REQUEST_TIMEOUT]: {
+    code: ERROR_CODES2.REQUEST_TIMEOUT,
+    status: ke.REQUEST_TIMEOUT,
     category: ERROR_CATEGORY.Timeout,
     userMessage: "errors.request.timeout",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES.REQUEST_ABORTED]: {
-    code: ERROR_CODES.REQUEST_ABORTED,
+  [ERROR_CODES2.REQUEST_ABORTED]: {
+    code: ERROR_CODES2.REQUEST_ABORTED,
     status: 0,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.request.aborted",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
-  [ERROR_CODES.REQUEST_INVALID_PARAMS]: {
-    code: ERROR_CODES.REQUEST_INVALID_PARAMS,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.REQUEST_INVALID_PARAMS]: {
+    code: ERROR_CODES2.REQUEST_INVALID_PARAMS,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.request.invalid_params",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.REQUEST_PREPARATION_FAILED]: {
-    code: ERROR_CODES.REQUEST_PREPARATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.REQUEST_PREPARATION_FAILED]: {
+    code: ERROR_CODES2.REQUEST_PREPARATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.request.preparation_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Response
-  [ERROR_CODES.RESPONSE_INVALID_FORMAT]: {
-    code: ERROR_CODES.RESPONSE_INVALID_FORMAT,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.RESPONSE_INVALID_FORMAT]: {
+    code: ERROR_CODES2.RESPONSE_INVALID_FORMAT,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.response.invalid_format",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.RESPONSE_PARSING_FAILED]: {
-    code: ERROR_CODES.RESPONSE_PARSING_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.RESPONSE_PARSING_FAILED]: {
+    code: ERROR_CODES2.RESPONSE_PARSING_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.response.parsing_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Client
-  [ERROR_CODES.CLIENT_ERROR]: {
-    code: ERROR_CODES.CLIENT_ERROR,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.CLIENT_ERROR]: {
+    code: ERROR_CODES2.CLIENT_ERROR,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.error",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.CLIENT_INITIALIZATION_FAILED]: {
-    code: ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CLIENT_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES2.CLIENT_INITIALIZATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.initialization_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.CLIENT_INVALID_CONFIG]: {
-    code: ERROR_CODES.CLIENT_INVALID_CONFIG,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CLIENT_INVALID_CONFIG]: {
+    code: ERROR_CODES2.CLIENT_INVALID_CONFIG,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.invalid_config",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
-  [ERROR_CODES.CLIENT_MISSING_BASE_URL]: {
-    code: ERROR_CODES.CLIENT_MISSING_BASE_URL,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CLIENT_MISSING_BASE_URL]: {
+    code: ERROR_CODES2.CLIENT_MISSING_BASE_URL,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.client.missing_base_url",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
-  [ERROR_CODES.CLIENT_CANCELLED]: {
-    code: ERROR_CODES.CLIENT_CANCELLED,
+  [ERROR_CODES2.CLIENT_CANCELLED]: {
+    code: ERROR_CODES2.CLIENT_CANCELLED,
     status: 0,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.cancelled",
@@ -5351,34 +5897,34 @@ var ERROR_DEFINITIONS = {
     retryable: true
   },
   // Configuration
-  [ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
-    code: ERROR_CODES.CONFIG_VALIDATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.CONFIG_VALIDATION_FAILED]: {
+    code: ERROR_CODES2.CONFIG_VALIDATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.config.validation_failed",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
-  [ERROR_CODES.HEADER_PROCESSING_FAILED]: {
-    code: ERROR_CODES.HEADER_PROCESSING_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.HEADER_PROCESSING_FAILED]: {
+    code: ERROR_CODES2.HEADER_PROCESSING_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Headers,
     userMessage: "errors.headers.processing_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES.NETWORK_OVERRIDE_FAILED]: {
-    code: ERROR_CODES.NETWORK_OVERRIDE_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NETWORK_OVERRIDE_FAILED]: {
+    code: ERROR_CODES2.NETWORK_OVERRIDE_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.override_failed",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
   // Generic
-  [ERROR_CODES.UNKNOWN_ERROR]: {
-    code: ERROR_CODES.UNKNOWN_ERROR,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.UNKNOWN_ERROR]: {
+    code: ERROR_CODES2.UNKNOWN_ERROR,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Unknown,
     userMessage: "errors.unknown",
     severity: ERROR_SEVERITY.Medium,
@@ -5386,224 +5932,224 @@ var ERROR_DEFINITIONS = {
   },
   // ===== Notification Package Error Definitions =====
   // Provider errors (retryable)
-  [ERROR_CODES.NOTIFICATION_PROVIDER_SEND_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_PROVIDER_SEND_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NOTIFICATION_PROVIDER_SEND_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_PROVIDER_SEND_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.provider.send_failed"
   },
-  [ERROR_CODES.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID]: {
-    code: ERROR_CODES.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID]: {
+    code: ERROR_CODES2.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.provider.configuration_invalid"
   },
-  [ERROR_CODES.NOTIFICATION_PROVIDER_RATE_LIMIT]: {
-    code: ERROR_CODES.NOTIFICATION_PROVIDER_RATE_LIMIT,
-    status: Ue.TOO_MANY_REQUESTS,
+  [ERROR_CODES2.NOTIFICATION_PROVIDER_RATE_LIMIT]: {
+    code: ERROR_CODES2.NOTIFICATION_PROVIDER_RATE_LIMIT,
+    status: ke.TOO_MANY_REQUESTS,
     category: ERROR_CATEGORY.RateLimit,
     severity: ERROR_SEVERITY.Medium,
     retryable: true,
     userMessage: "errors.notification.provider.rate_limit"
   },
-  [ERROR_CODES.NOTIFICATION_PROVIDER_AUTH_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_PROVIDER_AUTH_FAILED,
-    status: Ue.UNAUTHORIZED,
+  [ERROR_CODES2.NOTIFICATION_PROVIDER_AUTH_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_PROVIDER_AUTH_FAILED,
+    status: ke.UNAUTHORIZED,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.provider.auth_failed"
   },
-  [ERROR_CODES.NOTIFICATION_PROVIDER_TIMEOUT]: {
-    code: ERROR_CODES.NOTIFICATION_PROVIDER_TIMEOUT,
-    status: Ue.GATEWAY_TIMEOUT,
+  [ERROR_CODES2.NOTIFICATION_PROVIDER_TIMEOUT]: {
+    code: ERROR_CODES2.NOTIFICATION_PROVIDER_TIMEOUT,
+    status: ke.GATEWAY_TIMEOUT,
     category: ERROR_CATEGORY.Network,
     severity: ERROR_SEVERITY.Medium,
     retryable: true,
     userMessage: "errors.notification.provider.timeout"
   },
-  [ERROR_CODES.NOTIFICATION_PROVIDER_UNAVAILABLE]: {
-    code: ERROR_CODES.NOTIFICATION_PROVIDER_UNAVAILABLE,
-    status: Ue.SERVICE_UNAVAILABLE,
+  [ERROR_CODES2.NOTIFICATION_PROVIDER_UNAVAILABLE]: {
+    code: ERROR_CODES2.NOTIFICATION_PROVIDER_UNAVAILABLE,
+    status: ke.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.provider.unavailable"
   },
-  [ERROR_CODES.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED]: {
-    code: ERROR_CODES.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED,
-    status: Ue.NOT_IMPLEMENTED,
+  [ERROR_CODES2.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED]: {
+    code: ERROR_CODES2.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED,
+    status: ke.NOT_IMPLEMENTED,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.Low,
     retryable: false,
     userMessage: "errors.notification.provider.feature_not_supported"
   },
-  [ERROR_CODES.NOTIFICATION_ALL_PROVIDERS_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_ALL_PROVIDERS_FAILED,
-    status: Ue.SERVICE_UNAVAILABLE,
+  [ERROR_CODES2.NOTIFICATION_ALL_PROVIDERS_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_ALL_PROVIDERS_FAILED,
+    status: ke.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.all_providers_failed"
   },
   // Validation errors (non-retryable)
-  [ERROR_CODES.NOTIFICATION_INVALID_INPUT]: {
-    code: ERROR_CODES.NOTIFICATION_INVALID_INPUT,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.NOTIFICATION_INVALID_INPUT]: {
+    code: ERROR_CODES2.NOTIFICATION_INVALID_INPUT,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_input"
   },
-  [ERROR_CODES.NOTIFICATION_INVALID_RECIPIENT]: {
-    code: ERROR_CODES.NOTIFICATION_INVALID_RECIPIENT,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.NOTIFICATION_INVALID_RECIPIENT]: {
+    code: ERROR_CODES2.NOTIFICATION_INVALID_RECIPIENT,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_recipient"
   },
-  [ERROR_CODES.NOTIFICATION_INVALID_TEMPLATE]: {
-    code: ERROR_CODES.NOTIFICATION_INVALID_TEMPLATE,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.NOTIFICATION_INVALID_TEMPLATE]: {
+    code: ERROR_CODES2.NOTIFICATION_INVALID_TEMPLATE,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Template,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_template"
   },
-  [ERROR_CODES.NOTIFICATION_INVALID_PAYLOAD]: {
-    code: ERROR_CODES.NOTIFICATION_INVALID_PAYLOAD,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.NOTIFICATION_INVALID_PAYLOAD]: {
+    code: ERROR_CODES2.NOTIFICATION_INVALID_PAYLOAD,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_payload"
   },
-  [ERROR_CODES.NOTIFICATION_MISSING_REQUIRED_FIELD]: {
-    code: ERROR_CODES.NOTIFICATION_MISSING_REQUIRED_FIELD,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.NOTIFICATION_MISSING_REQUIRED_FIELD]: {
+    code: ERROR_CODES2.NOTIFICATION_MISSING_REQUIRED_FIELD,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.required_field_missing"
   },
-  [ERROR_CODES.NOTIFICATION_VALIDATION_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_VALIDATION_FAILED,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.NOTIFICATION_VALIDATION_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_VALIDATION_FAILED,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.failed"
   },
   // User Preferences
-  [ERROR_CODES.NOTIFICATION_USER_OPTED_OUT]: {
-    code: ERROR_CODES.NOTIFICATION_USER_OPTED_OUT,
-    status: Ue.OK,
+  [ERROR_CODES2.NOTIFICATION_USER_OPTED_OUT]: {
+    code: ERROR_CODES2.NOTIFICATION_USER_OPTED_OUT,
+    status: ke.OK,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Low,
     retryable: false,
     userMessage: "errors.notification.user.opted_out"
   },
   // Queue errors (retryable)
-  [ERROR_CODES.NOTIFICATION_QUEUE_FULL]: {
-    code: ERROR_CODES.NOTIFICATION_QUEUE_FULL,
-    status: Ue.SERVICE_UNAVAILABLE,
+  [ERROR_CODES2.NOTIFICATION_QUEUE_FULL]: {
+    code: ERROR_CODES2.NOTIFICATION_QUEUE_FULL,
+    status: ke.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Queue,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.queue.full"
   },
-  [ERROR_CODES.NOTIFICATION_QUEUE_PROCESSING_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_QUEUE_PROCESSING_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NOTIFICATION_QUEUE_PROCESSING_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_QUEUE_PROCESSING_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Queue,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.queue.processing_failed"
   },
   // Webhook errors
-  [ERROR_CODES.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID]: {
-    code: ERROR_CODES.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID,
-    status: Ue.UNAUTHORIZED,
+  [ERROR_CODES2.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID]: {
+    code: ERROR_CODES2.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID,
+    status: ke.UNAUTHORIZED,
     category: ERROR_CATEGORY.Webhook,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.notification.webhook.signature_invalid"
   },
-  [ERROR_CODES.NOTIFICATION_WEBHOOK_VALIDATION_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_WEBHOOK_VALIDATION_FAILED,
-    status: Ue.BAD_REQUEST,
+  [ERROR_CODES2.NOTIFICATION_WEBHOOK_VALIDATION_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_WEBHOOK_VALIDATION_FAILED,
+    status: ke.BAD_REQUEST,
     category: ERROR_CATEGORY.Webhook,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.webhook.validation_failed"
   },
-  [ERROR_CODES.NOTIFICATION_WEBHOOK_PROCESSING_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_WEBHOOK_PROCESSING_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NOTIFICATION_WEBHOOK_PROCESSING_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_WEBHOOK_PROCESSING_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Webhook,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.webhook.processing_failed"
   },
   // Template errors
-  [ERROR_CODES.NOTIFICATION_TEMPLATE_NOT_FOUND]: {
-    code: ERROR_CODES.NOTIFICATION_TEMPLATE_NOT_FOUND,
-    status: Ue.NOT_FOUND,
+  [ERROR_CODES2.NOTIFICATION_TEMPLATE_NOT_FOUND]: {
+    code: ERROR_CODES2.NOTIFICATION_TEMPLATE_NOT_FOUND,
+    status: ke.NOT_FOUND,
     category: ERROR_CATEGORY.Template,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.notification.template.not_found"
   },
-  [ERROR_CODES.NOTIFICATION_TEMPLATE_RENDER_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_TEMPLATE_RENDER_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NOTIFICATION_TEMPLATE_RENDER_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_TEMPLATE_RENDER_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Template,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.notification.template.render_failed"
   },
   // General notification errors
-  [ERROR_CODES.NOTIFICATION_UNKNOWN_ERROR]: {
-    code: ERROR_CODES.NOTIFICATION_UNKNOWN_ERROR,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NOTIFICATION_UNKNOWN_ERROR]: {
+    code: ERROR_CODES2.NOTIFICATION_UNKNOWN_ERROR,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Unknown,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.unknown"
   },
-  [ERROR_CODES.NOTIFICATION_INITIALIZATION_FAILED]: {
-    code: ERROR_CODES.NOTIFICATION_INITIALIZATION_FAILED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.NOTIFICATION_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES2.NOTIFICATION_INITIALIZATION_FAILED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.initialization_failed"
   },
   // ===== Errors Package Errors =====
-  [ERROR_CODES.ERROR_SYSTEM_NOT_INITIALIZED]: {
-    code: ERROR_CODES.ERROR_SYSTEM_NOT_INITIALIZED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.ERROR_SYSTEM_NOT_INITIALIZED]: {
+    code: ERROR_CODES2.ERROR_SYSTEM_NOT_INITIALIZED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.system.not_initialized"
   },
-  [ERROR_CODES.EVENT_FACTORY_NOT_REGISTERED]: {
-    code: ERROR_CODES.EVENT_FACTORY_NOT_REGISTERED,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.EVENT_FACTORY_NOT_REGISTERED]: {
+    code: ERROR_CODES2.EVENT_FACTORY_NOT_REGISTERED,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.event.factory.not_registered"
   },
-  [ERROR_CODES.DATABASE_ERROR]: {
-    code: ERROR_CODES.DATABASE_ERROR,
-    status: Ue.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES2.DATABASE_ERROR]: {
+    code: ERROR_CODES2.DATABASE_ERROR,
+    status: ke.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     severity: ERROR_SEVERITY.High,
     retryable: false,
@@ -5994,31 +6540,31 @@ var WEBHOOK_VERIFICATION_REASON = /* @__PURE__ */ ((WEBHOOK_VERIFICATION_REASON2
   WEBHOOK_VERIFICATION_REASON2["UnknownEndpoint"] = "unknown_endpoint";
   return WEBHOOK_VERIFICATION_REASON2;
 })(WEBHOOK_VERIFICATION_REASON || {});
-var PAYMENT_ERROR_CATEGORY = /* @__PURE__ */ ((PAYMENT_ERROR_CATEGORY2) => {
-  PAYMENT_ERROR_CATEGORY2["Validation"] = "validation";
-  PAYMENT_ERROR_CATEGORY2["Authentication"] = "authentication";
-  PAYMENT_ERROR_CATEGORY2["Authorization"] = "authorization";
-  PAYMENT_ERROR_CATEGORY2["Processing"] = "processing";
-  PAYMENT_ERROR_CATEGORY2["Provider"] = "provider";
-  PAYMENT_ERROR_CATEGORY2["Network"] = "network";
-  PAYMENT_ERROR_CATEGORY2["Fraud"] = "fraud";
-  PAYMENT_ERROR_CATEGORY2["Compliance"] = "compliance";
-  PAYMENT_ERROR_CATEGORY2["Limits"] = "limits";
-  PAYMENT_ERROR_CATEGORY2["Configuration"] = "configuration";
-  PAYMENT_ERROR_CATEGORY2["Timeout"] = "timeout";
-  PAYMENT_ERROR_CATEGORY2["System"] = "system";
-  PAYMENT_ERROR_CATEGORY2["Webhook"] = "webhook";
-  PAYMENT_ERROR_CATEGORY2["Refund"] = "refund";
-  PAYMENT_ERROR_CATEGORY2["Security"] = "security";
-  return PAYMENT_ERROR_CATEGORY2;
-})(PAYMENT_ERROR_CATEGORY || {});
-var ERRORSEVERITY = /* @__PURE__ */ ((ERRORSEVERITY2) => {
-  ERRORSEVERITY2["Low"] = "low";
-  ERRORSEVERITY2["Medium"] = "medium";
-  ERRORSEVERITY2["High"] = "high";
-  ERRORSEVERITY2["Critical"] = "critical";
-  return ERRORSEVERITY2;
-})(ERRORSEVERITY || {});
+var PAYMENT_ERROR_CATEGORY2 = /* @__PURE__ */ ((PAYMENT_ERROR_CATEGORY3) => {
+  PAYMENT_ERROR_CATEGORY3["Validation"] = "validation";
+  PAYMENT_ERROR_CATEGORY3["Authentication"] = "authentication";
+  PAYMENT_ERROR_CATEGORY3["Authorization"] = "authorization";
+  PAYMENT_ERROR_CATEGORY3["Processing"] = "processing";
+  PAYMENT_ERROR_CATEGORY3["Provider"] = "provider";
+  PAYMENT_ERROR_CATEGORY3["Network"] = "network";
+  PAYMENT_ERROR_CATEGORY3["Fraud"] = "fraud";
+  PAYMENT_ERROR_CATEGORY3["Compliance"] = "compliance";
+  PAYMENT_ERROR_CATEGORY3["Limits"] = "limits";
+  PAYMENT_ERROR_CATEGORY3["Configuration"] = "configuration";
+  PAYMENT_ERROR_CATEGORY3["Timeout"] = "timeout";
+  PAYMENT_ERROR_CATEGORY3["System"] = "system";
+  PAYMENT_ERROR_CATEGORY3["Webhook"] = "webhook";
+  PAYMENT_ERROR_CATEGORY3["Refund"] = "refund";
+  PAYMENT_ERROR_CATEGORY3["Security"] = "security";
+  return PAYMENT_ERROR_CATEGORY3;
+})(PAYMENT_ERROR_CATEGORY2 || {});
+var ERRORSEVERITY2 = /* @__PURE__ */ ((ERRORSEVERITY3) => {
+  ERRORSEVERITY3["Low"] = "low";
+  ERRORSEVERITY3["Medium"] = "medium";
+  ERRORSEVERITY3["High"] = "high";
+  ERRORSEVERITY3["Critical"] = "critical";
+  return ERRORSEVERITY3;
+})(ERRORSEVERITY2 || {});
 
 // src/notifications/enums.ts
 var NOTIFICATION_PROVIDERS = {
@@ -6038,7 +6584,7 @@ var NOTIFICATION_CHANNELS = {
   SMS: "sms",
   PUSH: "push"
 };
-var NOTIFICATION_CATEGORIES = {
+var NOTIFICATION_CATEGORIES2 = {
   /** Cannot be opted out - compliance requirement (password resets, order confirmations) */
   TRANSACTIONAL: "transactional",
   /** User can opt-out (newsletters, promotions) */
@@ -6136,29 +6682,29 @@ var FILE_EXTENSIONS = {
 };
 
 // src/notifications/schemas.ts
-var MAX_EMAIL_LENGTH = 255;
-var MAX_USER_ID_LENGTH = 255;
-var MAX_TEMPLATE_ID_LENGTH = 255;
-var MAX_DEVICE_TOKEN_LENGTH = 512;
-var EmailSchema = external_exports.string().email("Invalid email address format").max(MAX_EMAIL_LENGTH, "Email address must be 255 characters or less").transform((val) => val.trim().toLowerCase());
-var PhoneSchema = external_exports.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number format (E.164 expected)").describe("Phone number in E.164 format");
-var UserIdSchema = external_exports.string().min(1, "User ID is required").max(MAX_USER_ID_LENGTH, "User ID must be 255 characters or less");
-var TemplateIdSchema = external_exports.string().min(1, "Template ID is required").regex(
+var MAX_EMAIL_LENGTH2 = 255;
+var MAX_USER_ID_LENGTH2 = 255;
+var MAX_TEMPLATE_ID_LENGTH2 = 255;
+var MAX_DEVICE_TOKEN_LENGTH2 = 512;
+var EmailSchema2 = external_exports.string().email("Invalid email address format").max(MAX_EMAIL_LENGTH2, "Email address must be 255 characters or less").transform((val) => val.trim().toLowerCase());
+var PhoneSchema2 = external_exports.string().regex(/^\+?[1-9]\d{1,14}$/, "Invalid phone number format (E.164 expected)").describe("Phone number in E.164 format");
+var UserIdSchema2 = external_exports.string().min(1, "User ID is required").max(MAX_USER_ID_LENGTH2, "User ID must be 255 characters or less");
+var TemplateIdSchema2 = external_exports.string().min(1, "Template ID is required").regex(
   /^[a-z0-9-/]+$/,
   "Template ID must contain only lowercase letters, numbers, hyphens, and slashes"
-).max(MAX_TEMPLATE_ID_LENGTH, "Template ID must be 255 characters or less");
-var LocaleSchema = external_exports.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/, "Locale must be in format: en, en-US, es, es-MX").describe("Locale in ISO 639-1 format");
-var NotificationCategorySchema = external_exports.enum([
-  NOTIFICATION_CATEGORIES.TRANSACTIONAL,
-  NOTIFICATION_CATEGORIES.MARKETING,
-  NOTIFICATION_CATEGORIES.SOCIAL,
-  NOTIFICATION_CATEGORIES.SYSTEM,
-  NOTIFICATION_CATEGORIES.PROMOTIONAL
-]).default(NOTIFICATION_CATEGORIES.TRANSACTIONAL).describe("Notification category for compliance and user preferences");
-var QueuePrioritySchema = external_exports.enum(["high", "normal", "low"]);
-var CorrelationIdSchema = external_exports.string().uuid("Correlation ID must be a valid UUID v4").describe("UUID v4 correlation ID");
-var TemplateDataSchema = external_exports.record(external_exports.string(), external_exports.unknown()).optional();
-var DeviceTokenSchema = external_exports.string().min(1, "Device token is required").max(MAX_DEVICE_TOKEN_LENGTH, "Device token must be 512 characters or less");
+).max(MAX_TEMPLATE_ID_LENGTH2, "Template ID must be 255 characters or less");
+var LocaleSchema2 = external_exports.string().regex(/^[a-z]{2}(-[A-Z]{2})?$/, "Locale must be in format: en, en-US, es, es-MX").describe("Locale in ISO 639-1 format");
+var NotificationCategorySchema2 = external_exports.enum([
+  NOTIFICATION_CATEGORIES2.TRANSACTIONAL,
+  NOTIFICATION_CATEGORIES2.MARKETING,
+  NOTIFICATION_CATEGORIES2.SOCIAL,
+  NOTIFICATION_CATEGORIES2.SYSTEM,
+  NOTIFICATION_CATEGORIES2.PROMOTIONAL
+]).default(NOTIFICATION_CATEGORIES2.TRANSACTIONAL).describe("Notification category for compliance and user preferences");
+var QueuePrioritySchema2 = external_exports.enum(["high", "normal", "low"]);
+var CorrelationIdSchema2 = external_exports.string().uuid("Correlation ID must be a valid UUID v4").describe("UUID v4 correlation ID");
+var TemplateDataSchema2 = external_exports.record(external_exports.string(), external_exports.unknown()).optional();
+var DeviceTokenSchema2 = external_exports.string().min(1, "Device token is required").max(MAX_DEVICE_TOKEN_LENGTH2, "Device token must be 512 characters or less");
 
 // src/api/events/enum.ts
 var EVENT_NAMESPACES = {
@@ -6175,7 +6721,7 @@ var EVENT_NAMESPACES = {
   REVALIDATION: "revalidation",
   EVENT_MANAGER: "eventManager"
 };
-var HEADER_EVENTS = {
+var HEADER_EVENTS2 = {
   CHANGED: "headers:changed",
   ENRICHED: "headers:enriched",
   CONFLICT: "headers:conflict",
@@ -6190,7 +6736,7 @@ var HEADER_EVENTS = {
   // Wildcard for all header events
   ANY: "headers:*"
 };
-var NETWORK_EVENTS = {
+var NETWORK_EVENTS2 = {
   QUALITY_CHANGE: "network:quality:changed",
   INFO_UPDATE: "network:info-update",
   CONFIG_OVERRIDE: "network:config:override",
@@ -6204,7 +6750,7 @@ var NETWORK_EVENTS = {
   // Wildcard for all network events
   ANY: "network:*"
 };
-var ERROR_EVENTS = {
+var ERROR_EVENTS2 = {
   NETWORK_ERROR: "errors:network",
   VALIDATION_ERROR: "errors:validation",
   AUTHENTICATION_ERROR: "errors:authentication",
@@ -6226,7 +6772,7 @@ var ERROR_EVENTS = {
   // Wildcard for all error events
   ANY: "errors:*"
 };
-var HANDLER_SCOPES = {
+var HANDLER_SCOPES2 = {
   GLOBAL: "global",
   // Global handlers (lowest priority, persists across all instances)
   CONFIG: "config",
@@ -6238,14 +6784,14 @@ var HANDLER_SCOPES = {
   REQUEST: "request"
   // Request-level handlers (highest priority, per-request)
 };
-var EVENT_SCOPES = [
-  HANDLER_SCOPES.GLOBAL,
-  HANDLER_SCOPES.CONFIG,
-  HANDLER_SCOPES.CLIENT,
-  HANDLER_SCOPES.REQUEST
+var EVENT_SCOPES2 = [
+  HANDLER_SCOPES2.GLOBAL,
+  HANDLER_SCOPES2.CONFIG,
+  HANDLER_SCOPES2.CLIENT,
+  HANDLER_SCOPES2.REQUEST
 ];
-var EVENT_SCOPES_WITH_TEMPORARY = [...EVENT_SCOPES, "temporary"];
-var DEBUG_EVENTS = {
+var EVENT_SCOPES_WITH_TEMPORARY2 = [...EVENT_SCOPES2, "temporary"];
+var DEBUG_EVENTS2 = {
   CONFIG_CONFLICT: "debug:config-conflict",
   CONFIG_CHANGE: "debug:config-change",
   HEADERS_TRACKED: "debug:headers-tracked",
@@ -6271,7 +6817,7 @@ var EVENTS_CONFIG_SOURCES = {
   NETWORK_AWARE: "networkAware",
   ADAPTIVE: "adaptive"
 };
-var CONFIG_EVENTS = {
+var CONFIG_EVENTS2 = {
   GLOBAL_UPDATED: "config:global-updated",
   GLOBAL_RESET: "config:global-reset",
   ENVIRONMENT_CONFIGURED: "config:environment-configured",
@@ -6279,7 +6825,7 @@ var CONFIG_EVENTS = {
   // Wildcard for all config events
   ANY: "config:*"
 };
-var PERFORMANCE_EVENTS = {
+var PERFORMANCE_EVENTS2 = {
   REQUEST_START: "performance:request-start",
   REQUEST_COMPLETE: "performance:request-complete",
   RETRY: "performance:retry",
@@ -6289,29 +6835,29 @@ var PERFORMANCE_EVENTS = {
   // Wildcard for all performance events
   ANY: "performance:*"
 };
-var CLIENT_EVENTS = {
+var CLIENT_EVENTS2 = {
   CONFLICT: "client:conflict",
   DEBUG: "client:debug",
   CREATED: "client:created",
   // Wildcard for all client events
   ANY: "client:*"
 };
-var CACHE_EVENTS = {
+var CACHE_EVENTS2 = {
   HIT: "cache:hit",
   MISS: "cache:miss",
   INVALIDATE: "cache:invalidate",
   // Wildcard for all cache events
   ANY: "cache:*"
 };
-var ALL_EVENTS = {
-  ...HEADER_EVENTS,
-  ...NETWORK_EVENTS,
-  ...ERROR_EVENTS,
-  ...DEBUG_EVENTS,
-  ...CONFIG_EVENTS,
-  ...PERFORMANCE_EVENTS,
-  ...CLIENT_EVENTS,
-  ...CACHE_EVENTS
+var ALL_EVENTS2 = {
+  ...HEADER_EVENTS2,
+  ...NETWORK_EVENTS2,
+  ...ERROR_EVENTS2,
+  ...DEBUG_EVENTS2,
+  ...CONFIG_EVENTS2,
+  ...PERFORMANCE_EVENTS2,
+  ...CLIENT_EVENTS2,
+  ...CACHE_EVENTS2
 };
 
 // src/api/queue/enums.ts
@@ -6408,27 +6954,27 @@ var NETWORK_CONFIDENCE_LEVELS = {
   /** Threshold for medium confidence classification */
   MEDIUM_THRESHOLD: 0.4
 };
-var SPEED_THRESHOLDS = {
+var SPEED_THRESHOLDS2 = {
   EXCELLENT: 10,
   GOOD: 2,
   FAIR: 0.5
 };
-var RTT_THRESHOLDS = {
+var RTT_THRESHOLDS2 = {
   EXCELLENT: 50,
   GOOD: 150,
   FAIR: 400
 };
-var DEFAULT_THRESHOLDS = {
-  excellentRTT: RTT_THRESHOLDS.EXCELLENT,
-  goodRTT: RTT_THRESHOLDS.GOOD,
-  fairRTT: RTT_THRESHOLDS.FAIR,
-  excellentSpeed: SPEED_THRESHOLDS.EXCELLENT,
-  goodSpeed: SPEED_THRESHOLDS.GOOD,
-  fairSpeed: SPEED_THRESHOLDS.FAIR
+var DEFAULT_THRESHOLDS2 = {
+  excellentRTT: RTT_THRESHOLDS2.EXCELLENT,
+  goodRTT: RTT_THRESHOLDS2.GOOD,
+  fairRTT: RTT_THRESHOLDS2.FAIR,
+  excellentSpeed: SPEED_THRESHOLDS2.EXCELLENT,
+  goodSpeed: SPEED_THRESHOLDS2.GOOD,
+  fairSpeed: SPEED_THRESHOLDS2.FAIR
 };
 
 // src/api/debugger/enums.ts
-var FACTORY_OPERATIONS = {
+var FACTORY_OPERATIONS2 = {
   FACTORY_CREATED: "factory_created",
   FACTORY_ACCESSED: "factory_accessed",
   FACTORY_INITIALIZED: "factory_initialized",
@@ -6444,7 +6990,7 @@ var FACTORY_OPERATIONS = {
   SPECIFIC_HANDLER_REMOVED: "specific_handler_removed",
   SCOPE_LISTENERS_CLEARED: "scope_listeners_cleared"
 };
-var EVENT_OPERATIONS = {
+var EVENT_OPERATIONS2 = {
   ON: "on",
   ONCE: "once",
   OFF: "off",
@@ -6462,7 +7008,7 @@ var EVENT_OPERATIONS = {
   HANDLER_STRATEGY: "handler_strategy",
   HANDLER_STRATEGY_APPLIED: "handler_strategy_applied"
 };
-var QUEUE_OPERATIONS = {
+var QUEUE_OPERATIONS2 = {
   QUEUE_CREATED: "queue_created",
   QUEUE_PROCESSED: "queue_processed",
   QUEUE_CLEARED: "queue_cleared",
@@ -6472,7 +7018,7 @@ var QUEUE_OPERATIONS = {
   ITEM_DEQUEUED: "item_dequeued",
   PRIORITY_CHANGED: "priority_changed"
 };
-var DEBUGGER_CONFIG_SOURCES = {
+var DEBUGGER_CONFIG_SOURCES2 = {
   DEFAULT: "default",
   DIRECT: "direct",
   CLIENT: "client",
@@ -6499,7 +7045,7 @@ var DEBUGGER_CONFIG_SOURCES = {
   CONTEXT_HEADERS: "contextHeaders",
   ENCRYPTION: "encryption"
 };
-var HISTORY_TYPES = {
+var HISTORY_TYPES2 = {
   CONFIG: "config",
   HEADER: "header",
   NETWORK: "network",
@@ -6548,23 +7094,23 @@ var ALERT_TYPES = {
   PERFORMANCE: "performance",
   NETWORK: "network"
 };
-var UNIFIED_OPERATIONS = {
-  ...FACTORY_OPERATIONS,
-  ...EVENT_OPERATIONS,
-  ...QUEUE_OPERATIONS
+var UNIFIED_OPERATIONS2 = {
+  ...FACTORY_OPERATIONS2,
+  ...EVENT_OPERATIONS2,
+  ...QUEUE_OPERATIONS2
 };
-function isValidOperation(operation) {
-  return Object.values(UNIFIED_OPERATIONS).includes(operation);
+function isValidOperation2(operation) {
+  return Object.values(UNIFIED_OPERATIONS2).includes(operation);
 }
-__name(isValidOperation, "isValidOperation");
-function isValidConfigSource(source) {
-  return Object.values(DEBUGGER_CONFIG_SOURCES).includes(source);
+__name(isValidOperation2, "isValidOperation");
+function isValidConfigSource2(source) {
+  return Object.values(DEBUGGER_CONFIG_SOURCES2).includes(source);
 }
-__name(isValidConfigSource, "isValidConfigSource");
-function isValidHistoryType(type) {
-  return Object.values(HISTORY_TYPES).includes(type);
+__name(isValidConfigSource2, "isValidConfigSource");
+function isValidHistoryType2(type) {
+  return Object.values(HISTORY_TYPES2).includes(type);
 }
-__name(isValidHistoryType, "isValidHistoryType");
+__name(isValidHistoryType2, "isValidHistoryType");
 
 // src/api/client/enum.ts
 var EVENT_CONSTANTS = {
@@ -6631,11 +7177,11 @@ var COORDINATES = {
     MAX_LON: 146
   }
 };
-var HOURS_PER_DAY = 24;
-var MINUTES_PER_HOUR = 60;
-var SECONDS_PER_MINUTE = 60;
-var MS_PER_SECOND = 1e3;
-var CACHE_DURATION_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var HOURS_PER_DAY2 = 24;
+var MINUTES_PER_HOUR2 = 60;
+var SECONDS_PER_MINUTE2 = 60;
+var MS_PER_SECOND2 = 1e3;
+var CACHE_DURATION_MS2 = HOURS_PER_DAY2 * MINUTES_PER_HOUR2 * SECONDS_PER_MINUTE2 * MS_PER_SECOND2;
 var REGION_TO_PRESET = {
   eu: "gdpr",
   us: "ccpa",
@@ -6673,35 +7219,35 @@ var PUB_SUB_EVENT = {
 
 exports.ALERT_SEVERITIES = ALERT_SEVERITIES;
 exports.ALERT_TYPES = ALERT_TYPES;
-exports.ALL_EVENTS = ALL_EVENTS;
-exports.API_ERROR_CODES = API_ERROR_CODES;
+exports.ALL_EVENTS = ALL_EVENTS2;
+exports.API_ERROR_CODES = API_ERROR_CODES2;
 exports.AUTH_PROVIDER = AUTH_PROVIDER;
 exports.AUTH_PROVIDER_TYPE = AUTH_PROVIDER_TYPE;
-exports.CACHE_DURATION_MS = CACHE_DURATION_MS;
-exports.CACHE_EVENTS = CACHE_EVENTS;
+exports.CACHE_DURATION_MS = CACHE_DURATION_MS2;
+exports.CACHE_EVENTS = CACHE_EVENTS2;
 exports.CHAIN_ID = CHAIN_ID;
 exports.CHANGE_TYPES = CHANGE_TYPES;
-exports.CLIENT_EVENTS = CLIENT_EVENTS;
+exports.CLIENT_EVENTS = CLIENT_EVENTS2;
 exports.CLIENT_HINT_HEADERS = CLIENT_HINT_HEADERS;
 exports.COMMON_FIELDS = COMMON_FIELDS;
 exports.COMMON_OPERATIONS = COMMON_OPERATIONS;
 exports.COMMON_STORAGE_TYPES = COMMON_STORAGE_TYPES;
-exports.CONFIG_EVENTS = CONFIG_EVENTS;
+exports.CONFIG_EVENTS = CONFIG_EVENTS2;
 exports.COORDINATES = COORDINATES;
 exports.CORRELATION_TYPE = CORRELATION_TYPE;
 exports.COSTOPTIMIZATIONSTRATEGY = COSTOPTIMIZATIONSTRATEGY;
-exports.CorrelationIdSchema = CorrelationIdSchema;
+exports.CorrelationIdSchema = CorrelationIdSchema2;
 exports.DATA_SAVER_PRESETS = DATA_SAVER_PRESETS;
-exports.DEBUGGER_CONFIG_SOURCES = DEBUGGER_CONFIG_SOURCES;
-exports.DEBUG_EVENTS = DEBUG_EVENTS;
-exports.DEFAULT_THRESHOLDS = DEFAULT_THRESHOLDS;
-exports.DeviceTokenSchema = DeviceTokenSchema;
-exports.ERRORSEVERITY = ERRORSEVERITY;
+exports.DEBUGGER_CONFIG_SOURCES = DEBUGGER_CONFIG_SOURCES2;
+exports.DEBUG_EVENTS = DEBUG_EVENTS2;
+exports.DEFAULT_THRESHOLDS = DEFAULT_THRESHOLDS2;
+exports.DeviceTokenSchema = DeviceTokenSchema2;
+exports.ERRORSEVERITY = ERRORSEVERITY2;
 exports.ERROR_CATEGORY = ERROR_CATEGORY;
 exports.ERROR_CATEGORY_TO_EMITTER_KEY = ERROR_CATEGORY_TO_EMITTER_KEY;
-exports.ERROR_CODES = ERROR_CODES;
-exports.ERROR_DEFINITIONS = ERROR_DEFINITIONS;
-exports.ERROR_EVENTS = ERROR_EVENTS;
+exports.ERROR_CODES = ERROR_CODES2;
+exports.ERROR_DEFINITIONS = ERROR_DEFINITIONS2;
+exports.ERROR_EVENTS = ERROR_EVENTS2;
 exports.ERROR_FIELDS = COMMON_FIELDS;
 exports.ERROR_SEVERITY = ERROR_SEVERITY;
 exports.ERROR_TYPE = ERROR_TYPE;
@@ -6709,35 +7255,35 @@ exports.EVENTPROCESSINGSTATUS = EVENTPROCESSINGSTATUS;
 exports.EVENTS_CONFIG_SOURCES = EVENTS_CONFIG_SOURCES;
 exports.EVENT_CONSTANTS = EVENT_CONSTANTS;
 exports.EVENT_NAMESPACES = EVENT_NAMESPACES;
-exports.EVENT_OPERATIONS = EVENT_OPERATIONS;
+exports.EVENT_OPERATIONS = EVENT_OPERATIONS2;
 exports.EVENT_PRIORITY = EVENT_PRIORITY;
 exports.EVENT_PRIORITY_MAP = EVENT_PRIORITY_MAP;
-exports.EVENT_SCOPES = EVENT_SCOPES;
-exports.EVENT_SCOPES_WITH_TEMPORARY = EVENT_SCOPES_WITH_TEMPORARY;
+exports.EVENT_SCOPES = EVENT_SCOPES2;
+exports.EVENT_SCOPES_WITH_TEMPORARY = EVENT_SCOPES_WITH_TEMPORARY2;
 exports.EVENT_STATUS = EVENT_STATUS;
 exports.EVENT_TYPE = EVENT_TYPE;
-exports.EmailSchema = EmailSchema;
-exports.FACTORY_OPERATIONS = FACTORY_OPERATIONS;
+exports.EmailSchema = EmailSchema2;
+exports.FACTORY_OPERATIONS = FACTORY_OPERATIONS2;
 exports.FAILOVERSTRATEGY = FAILOVERSTRATEGY;
 exports.FILE_EXTENSIONS = FILE_EXTENSIONS;
-exports.HANDLER_SCOPES = HANDLER_SCOPES;
-exports.HEADER_EVENTS = HEADER_EVENTS;
+exports.HANDLER_SCOPES = HANDLER_SCOPES2;
+exports.HEADER_EVENTS = HEADER_EVENTS2;
 exports.HEADER_STAGES = HEADER_STAGES;
-exports.HISTORY_TYPES = HISTORY_TYPES;
+exports.HISTORY_TYPES = HISTORY_TYPES2;
 exports.IMPACT_LEVELS = IMPACT_LEVELS;
 exports.INTERNAL_STATUS_CODES = INTERNAL_STATUS_CODES;
 exports.LOADBALANCINGSTRATEGY = LOADBALANCINGSTRATEGY;
-exports.LocaleSchema = LocaleSchema;
+exports.LocaleSchema = LocaleSchema2;
 exports.MIME_TYPES = MIME_TYPES;
 exports.NETWORK_CONFIDENCE_LEVELS = NETWORK_CONFIDENCE_LEVELS;
-exports.NETWORK_EVENTS = NETWORK_EVENTS;
+exports.NETWORK_EVENTS = NETWORK_EVENTS2;
 exports.NETWORK_QUALITY = NETWORK_QUALITY;
-exports.NOTIFICATION_CATEGORIES = NOTIFICATION_CATEGORIES;
+exports.NOTIFICATION_CATEGORIES = NOTIFICATION_CATEGORIES2;
 exports.NOTIFICATION_CHANNELS = NOTIFICATION_CHANNELS;
-exports.NOTIFICATION_ERROR_CODES = NOTIFICATION_ERROR_CODES;
+exports.NOTIFICATION_ERROR_CODES = NOTIFICATION_ERROR_CODES2;
 exports.NOTIFICATION_PROVIDERS = NOTIFICATION_PROVIDERS;
 exports.NetworkPresetNames = NetworkPresetNames;
-exports.NotificationCategorySchema = NotificationCategorySchema;
+exports.NotificationCategorySchema = NotificationCategorySchema2;
 exports.OPERATIONS = COMMON_OPERATIONS;
 exports.PACKAGE_STATUS_CODES = INTERNAL_STATUS_CODES;
 exports.PAYMENTERRORCATEGORY = PAYMENTERRORCATEGORY;
@@ -6746,15 +7292,15 @@ exports.PAYMENTEVENTTYPE = PAYMENTEVENTTYPE;
 exports.PAYMENTMETHOD = PAYMENTMETHOD;
 exports.PAYMENTPROVIDERTYPE = PAYMENTPROVIDERTYPE;
 exports.PAYMENTSTATUS = PAYMENTSTATUS;
-exports.PAYMENT_ERROR_CATEGORY = PAYMENT_ERROR_CATEGORY;
+exports.PAYMENT_ERROR_CATEGORY = PAYMENT_ERROR_CATEGORY2;
 exports.PERFORMANCEMETRICTYPE = PERFORMANCEMETRICTYPE;
-exports.PERFORMANCE_EVENTS = PERFORMANCE_EVENTS;
+exports.PERFORMANCE_EVENTS = PERFORMANCE_EVENTS2;
 exports.PRIORITY_LEVEL = PRIORITY_LEVEL;
 exports.PRODUCTTYPE = PRODUCTTYPE;
 exports.PUB_SUB_EVENT = PUB_SUB_EVENT;
-exports.PhoneSchema = PhoneSchema;
-exports.QUEUE_OPERATIONS = QUEUE_OPERATIONS;
-exports.QueuePrioritySchema = QueuePrioritySchema;
+exports.PhoneSchema = PhoneSchema2;
+exports.QUEUE_OPERATIONS = QUEUE_OPERATIONS2;
+exports.QueuePrioritySchema = QueuePrioritySchema2;
 exports.REFUND_ERROR_TYPES = REFUND_ERROR_TYPES;
 exports.REFUND_NOT_ALLOWED_REASON = REFUND_NOT_ALLOWED_REASON;
 exports.REGIONAL_CONFIDENCE_LEVELS = REGIONAL_CONFIDENCE_LEVELS;
@@ -6764,28 +7310,28 @@ exports.REGULATORYFRAMEWORK = REGULATORYFRAMEWORK;
 exports.REGULATORY_FRAMEWORK = REGULATORY_FRAMEWORK;
 exports.REQUIREDACTIONTYPE = REQUIREDACTIONTYPE;
 exports.ROUTINGSTRATEGY = ROUTINGSTRATEGY;
-exports.RTT_THRESHOLDS = RTT_THRESHOLDS;
+exports.RTT_THRESHOLDS = RTT_THRESHOLDS2;
 exports.SECURITY_THREAT_TYPE = SECURITY_THREAT_TYPE;
 exports.SIGNATURE_METHOD = SIGNATURE_METHOD;
-exports.SPEED_THRESHOLDS = SPEED_THRESHOLDS;
+exports.SPEED_THRESHOLDS = SPEED_THRESHOLDS2;
 exports.STORAGE_TYPES = COMMON_STORAGE_TYPES;
 exports.TRACKING_PHASES = TRACKING_PHASES;
 exports.TRANSACTIONTYPE = TRANSACTIONTYPE;
-exports.TemplateDataSchema = TemplateDataSchema;
-exports.TemplateIdSchema = TemplateIdSchema;
-exports.UNIFIED_OPERATIONS = UNIFIED_OPERATIONS;
+exports.TemplateDataSchema = TemplateDataSchema2;
+exports.TemplateIdSchema = TemplateIdSchema2;
+exports.UNIFIED_OPERATIONS = UNIFIED_OPERATIONS2;
 exports.UPDATE_STRATEGIES = UPDATE_STRATEGIES;
 exports.USERTYPE = USERTYPE;
 exports.USER_ROLE = USER_ROLE;
 exports.USER_STATUS = USER_STATUS;
-exports.UserIdSchema = UserIdSchema;
+exports.UserIdSchema = UserIdSchema2;
 exports.VALIDATION_RANGES = VALIDATION_RANGES;
 exports.WEBHOOK_ENCRYPTION_METHOD = WEBHOOK_ENCRYPTION_METHOD;
 exports.WEBHOOK_EVENT_TYPE = WEBHOOK_EVENT_TYPE;
 exports.WEBHOOK_VERIFICATION_REASON = WEBHOOK_VERIFICATION_REASON;
-exports.isValidConfigSource = isValidConfigSource;
-exports.isValidHistoryType = isValidHistoryType;
-exports.isValidOperation = isValidOperation;
+exports.isValidConfigSource = isValidConfigSource2;
+exports.isValidHistoryType = isValidHistoryType2;
+exports.isValidOperation = isValidOperation2;
 exports.loginCredentialsSchema = loginCredentialsSchema;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map