@plyaz/types 1.13.13 → 1.13.15

package/dist/index.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+var config = require('@plyaz/config');
+
 // @plyaz package - Built with tsup
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -257,8 +259,8 @@ var ZodParsedType = util.arrayToEnum([
   "set"
 ]);
 var getParsedType = /* @__PURE__ */ __name((data) => {
-  const t2 = typeof data;
-  switch (t2) {
+  const t = typeof data;
+  switch (t) {
     case "undefined":
       return ZodParsedType.undefined;
     case "string":
@@ -549,7 +551,7 @@ var makeIssue = /* @__PURE__ */ __name((params) => {
     };
   }
   let errorMessage = "";
-  const maps = errorMaps.filter((m2) => !!m2).slice().reverse();
+  const maps = errorMaps.filter((m) => !!m).slice().reverse();
   for (const map of maps) {
     errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
   }
@@ -597,12 +599,12 @@ var ParseStatus = class _ParseStatus {
   }
   static mergeArray(status, results) {
     const arrayValue = [];
-    for (const s2 of results) {
-      if (s2.status === "aborted")
+    for (const s of results) {
+      if (s.status === "aborted")
         return INVALID;
-      if (s2.status === "dirty")
+      if (s.status === "dirty")
         status.dirty();
-      arrayValue.push(s2.value);
+      arrayValue.push(s.value);
     }
     return { status: status.value, value: arrayValue };
   }
@@ -4118,17 +4120,17 @@ __name(cleanParams, "cleanParams");
 function custom(check, _params = {}, fatal) {
   if (check)
     return ZodAny.create().superRefine((data, ctx) => {
-      const r2 = check(data);
-      if (r2 instanceof Promise) {
-        return r2.then((r3) => {
-          if (!r3) {
+      const r = check(data);
+      if (r instanceof Promise) {
+        return r.then((r2) => {
+          if (!r2) {
             const params = cleanParams(_params, data);
             const _fatal = params.fatal ?? fatal ?? true;
             ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
           }
         });
       }
-      if (!r2) {
+      if (!r) {
         const params = cleanParams(_params, data);
         const _fatal = params.fatal ?? fatal ?? true;
         ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
@@ -4458,27 +4460,19 @@ var COMMON_STORAGE_TYPES = {
   REDIS: "redis",
   DATABASE: "database"
 };
-
-// node_modules/.pnpm/@plyaz+types@1.13.12_@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",
+  CLIENT_CANCELLED: "CLIENT_CANCELLED",
   CONFIG_VALIDATION_FAILED: "CONFIG_VALIDATION_FAILED",
   HEADER_PROCESSING_FAILED: "HEADER_PROCESSING_FAILED",
   NETWORK_OVERRIDE_FAILED: "NETWORK_OVERRIDE_FAILED",
   // Request
   REQUEST_TIMEOUT: "REQUEST_TIMEOUT",
+  REQUEST_ABORTED: "REQUEST_ABORTED",
   REQUEST_INVALID_PARAMS: "REQUEST_INVALID_PARAMS",
   REQUEST_PREPARATION_FAILED: "REQUEST_PREPARATION_FAILED",
   // Response
@@ -4505,6 +4499,11 @@ var ERROR_CODES = {
   STRING_TOO_LONG: "STRING_TOO_LONG",
   // Network
   NETWORK_ERROR: "NETWORK_ERROR",
+  CONNECTION_FAILED: "CONNECTION_FAILED",
+  NETWORK_CONNECTION_FAILED: "NETWORK_CONNECTION_FAILED",
+  NETWORK_OFFLINE: "NETWORK_OFFLINE",
+  NETWORK_DNS_FAILED: "NETWORK_DNS_FAILED",
+  NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
   NETWORK_PRESET_NOT_FOUND: "NETWORK_PRESET_NOT_FOUND",
   NETWORK_CONFIGURATION_INVALID: "NETWORK_CONFIGURATION_INVALID",
   // Server
@@ -4539,6 +4538,8 @@ var ERROR_CODES = {
   TIMEOUT: "TIMEOUT",
   // Debugging
   DEBUG_TRACKING_FAILED: "DEBUG_TRACKING_FAILED",
+  // Polling
+  POLLING_CANCELLED: "POLLING_CANCELLED",
   POLLING_TIMEOUT: "POLLING_TIMEOUT",
   POLLING_INVALID_CONFIG: "POLLING_INVALID_CONFIG",
   // PubSub
@@ -4602,1294 +4603,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 = {
   // ===== API Package Error Definitions =====
   // Authentication
   [ERROR_CODES.AUTH_UNAUTHORIZED]: {
-    status: ke.UNAUTHORIZED},
+    code: ERROR_CODES.AUTH_UNAUTHORIZED,
+    status: config.HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    userMessage: "errors.auth.unauthorized",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.AUTH_FORBIDDEN]: {
-    status: ke.FORBIDDEN},
+    code: ERROR_CODES.AUTH_FORBIDDEN,
+    status: config.HTTP_STATUS.FORBIDDEN,
+    category: ERROR_CATEGORY.Authorization,
+    userMessage: "errors.auth.forbidden",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.AUTH_TOKEN_EXPIRED]: {
-    status: ke.UNAUTHORIZED},
+    code: ERROR_CODES.AUTH_TOKEN_EXPIRED,
+    status: config.HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    userMessage: "errors.auth.token_expired",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.AUTH_INVALID_CREDENTIALS]: {
-    status: ke.UNAUTHORIZED},
+    code: ERROR_CODES.AUTH_INVALID_CREDENTIALS,
+    status: config.HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    userMessage: "errors.auth.invalid_credentials",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   // Rate Limiting
   [ERROR_CODES.RATE_LIMIT_EXCEEDED]: {
-    status: ke.TOO_MANY_REQUESTS},
+    code: ERROR_CODES.RATE_LIMIT_EXCEEDED,
+    status: config.HTTP_STATUS.TOO_MANY_REQUESTS,
+    category: ERROR_CATEGORY.RateLimit,
+    userMessage: "errors.rate_limit.exceeded",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
   // Resources
   [ERROR_CODES.RESOURCE_NOT_FOUND]: {
-    status: ke.NOT_FOUND},
+    code: ERROR_CODES.RESOURCE_NOT_FOUND,
+    status: config.HTTP_STATUS.NOT_FOUND,
+    category: ERROR_CATEGORY.NotFound,
+    userMessage: "errors.resource.not_found",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.RESOURCE_CONFLICT]: {
-    status: ke.CONFLICT},
+    code: ERROR_CODES.RESOURCE_CONFLICT,
+    status: config.HTTP_STATUS.CONFLICT,
+    category: ERROR_CATEGORY.Conflict,
+    userMessage: "errors.resource.conflict",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   // Validation
   [ERROR_CODES.API_VALIDATION_FAILED]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.API_VALIDATION_FAILED,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.API_INVALID_INPUT]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.API_INVALID_INPUT,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.invalid_input",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.VALIDATION_ERROR]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.VALIDATION_ERROR,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.error",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.REQUIRED_FIELD_MISSING]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.REQUIRED_FIELD_MISSING,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.required_field_missing",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.INVALID_FORMAT]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.INVALID_FORMAT,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.invalid_format",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.VALIDATION_INVALID_FORMAT]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.VALIDATION_INVALID_FORMAT,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.invalid_format",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.STRING_TOO_SHORT]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.STRING_TOO_SHORT,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.string_too_short",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.STRING_TOO_LONG]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.STRING_TOO_LONG,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    userMessage: "errors.validation.string_too_long",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   // Network
   [ERROR_CODES.NETWORK_ERROR]: {
-    status: ke.BAD_GATEWAY},
+    code: ERROR_CODES.NETWORK_ERROR,
+    status: config.HTTP_STATUS.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,
+    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,
+    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,
+    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,
+    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,
+    status: 0,
+    category: ERROR_CATEGORY.Network,
+    userMessage: "errors.network.timeout",
+    severity: ERROR_SEVERITY.High,
+    retryable: true
+  },
   [ERROR_CODES.NETWORK_CONFIGURATION_INVALID]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.NETWORK_CONFIGURATION_INVALID,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    userMessage: "errors.network.configuration_invalid",
+    severity: ERROR_SEVERITY.Critical,
+    retryable: true
+  },
   [ERROR_CODES.NETWORK_PRESET_NOT_FOUND]: {
-    status: ke.NOT_FOUND},
+    code: ERROR_CODES.NETWORK_PRESET_NOT_FOUND,
+    status: config.HTTP_STATUS.NOT_FOUND,
+    category: ERROR_CATEGORY.Configuration,
+    userMessage: "errors.network.preset_not_found",
+    severity: ERROR_SEVERITY.High,
+    retryable: true
+  },
   // Server
   [ERROR_CODES.SERVER_ERROR]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.SERVER_ERROR,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Server,
+    userMessage: "errors.server.error",
+    severity: ERROR_SEVERITY.High,
+    retryable: false
+  },
   [ERROR_CODES.INTERNAL_SERVER_ERROR]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.INTERNAL_SERVER_ERROR,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Server,
+    userMessage: "errors.server.internal_error",
+    severity: ERROR_SEVERITY.High,
+    retryable: false
+  },
   [ERROR_CODES.SERVICE_UNAVAILABLE]: {
-    status: ke.SERVICE_UNAVAILABLE},
+    code: ERROR_CODES.SERVICE_UNAVAILABLE,
+    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.Server,
+    userMessage: "errors.server.service_unavailable",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
   // Cache
   [ERROR_CODES.CACHE_READ_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.CACHE_READ_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    userMessage: "errors.cache.read_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.CACHE_WRITE_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.CACHE_WRITE_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    userMessage: "errors.cache.write_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.CACHE_INVALIDATION_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.CACHE_INVALIDATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    userMessage: "errors.cache.invalidation_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.CACHE_STORAGE_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.CACHE_STORAGE_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    userMessage: "errors.cache.storage_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.CACHE_RETRIEVAL_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.CACHE_RETRIEVAL_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    userMessage: "errors.cache.retrieval_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   // Retry
   [ERROR_CODES.RETRY_LIMIT_EXCEEDED]: {
-    status: ke.SERVICE_UNAVAILABLE},
+    code: ERROR_CODES.RETRY_LIMIT_EXCEEDED,
+    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.Retry,
+    userMessage: "errors.retry.limit_exceeded",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
   [ERROR_CODES.RETRY_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.RETRY_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Retry,
+    userMessage: "errors.retry.failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
   [ERROR_CODES.RETRY_EXHAUSTED]: {
-    status: ke.SERVICE_UNAVAILABLE},
+    code: ERROR_CODES.RETRY_EXHAUSTED,
+    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.Retry,
+    userMessage: "errors.retry.exhausted",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
   [ERROR_CODES.RETRY_STRATEGY_INVALID]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.RETRY_STRATEGY_INVALID,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Configuration,
+    userMessage: "errors.retry.strategy_invalid",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true
+  },
   // Strategy
   [ERROR_CODES.STRATEGY_INVALID]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.STRATEGY_INVALID,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Configuration,
+    userMessage: "errors.strategy.invalid",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.STRATEGY_CONFLICT]: {
-    status: ke.CONFLICT},
+    code: ERROR_CODES.STRATEGY_CONFLICT,
+    status: config.HTTP_STATUS.CONFLICT,
+    category: ERROR_CATEGORY.Configuration,
+    userMessage: "errors.strategy.conflict",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.STRATEGY_EXECUTION_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.STRATEGY_EXECUTION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    userMessage: "errors.strategy.execution_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   // Headers
   [ERROR_CODES.HEADERS_ENRICHMENT_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Headers,
+    userMessage: "errors.headers.enrichment_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.HEADERS_VALIDATION_FAILED]: {
-    status: ke.BAD_REQUEST},
+    code: ERROR_CODES.HEADERS_VALIDATION_FAILED,
+    status: config.HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Headers,
+    userMessage: "errors.headers.validation_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.HEADERS_MERGE_CONFLICT]: {
-    status: ke.CONFLICT},
+    code: ERROR_CODES.HEADERS_MERGE_CONFLICT,
+    status: config.HTTP_STATUS.CONFLICT,
+    category: ERROR_CATEGORY.Headers,
+    userMessage: "errors.headers.merge_conflict",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   // Regional
   [ERROR_CODES.REGION_DETECTION_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.REGION_DETECTION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Network,
+    userMessage: "errors.regional.detection_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.REGIONAL_PRESET_NOT_FOUND]: {
-    status: ke.NOT_FOUND},
+    code: ERROR_CODES.REGIONAL_PRESET_NOT_FOUND,
+    status: config.HTTP_STATUS.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]: {
-    status: ke.BAD_GATEWAY},
+    code: ERROR_CODES.EXTERNAL_SERVICE_ERROR,
+    status: config.HTTP_STATUS.BAD_GATEWAY,
+    category: ERROR_CATEGORY.Server,
+    userMessage: "errors.external.service_error",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   // Timeout
   [ERROR_CODES.TIMEOUT]: {
-    status: ke.REQUEST_TIMEOUT},
+    code: ERROR_CODES.TIMEOUT,
+    status: config.HTTP_STATUS.REQUEST_TIMEOUT,
+    category: ERROR_CATEGORY.Timeout,
+    userMessage: "errors.timeout.generic",
+    severity: ERROR_SEVERITY.High,
+    retryable: true
+  },
   // Debugging
   [ERROR_CODES.DEBUG_TRACKING_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.DEBUG_TRACKING_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Client,
+    userMessage: "errors.debug.tracking_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [ERROR_CODES.DEBUG_OVERRIDE_FAILED]: {
-    status: ke.INTERNAL_SERVER_ERROR},
+    code: ERROR_CODES.DEBUG_OVERRIDE_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    userMessage: "errors.debug.override_failed",
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false
+  },
   [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";
-({ apiKey: globalThis.process.env.NEXT_PUBLIC_ALCHEMY_KEY, rpcUrls: { ethereum: `https://eth-mainnet.g.alchemy.com/v2/${globalThis.process.env.NEXT_PUBLIC_ALCHEMY_KEY}`, polygon: `https://polygon-mainnet.g.alchemy.com/v2/${globalThis.process.env.NEXT_PUBLIC_ALCHEMY_KEY}`, arbitrum: `https://arb-mainnet.g.alchemy.com/v2/${globalThis.process.env.NEXT_PUBLIC_ALCHEMY_KEY}`, optimism: `https://opt-mainnet.g.alchemy.com/v2/${globalThis.process.env.NEXT_PUBLIC_ALCHEMY_KEY}`, base: `https://base-mainnet.g.alchemy.com/v2/${globalThis.process.env.NEXT_PUBLIC_ALCHEMY_KEY}`, solana: `https://solana-mainnet.g.alchemy.com/v2/${globalThis.process.env.NEXT_PUBLIC_ALCHEMY_KEY}` } });
-({ google: { clientId: globalThis.process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID, clientSecret: globalThis.process.env.GOOGLE_CLIENT_SECRET, redirectUri: globalThis.process.env.NEXT_PUBLIC_GOOGLE_REDIRECT_URI}, discord: { clientId: globalThis.process.env.NEXT_PUBLIC_DISCORD_CLIENT_ID, clientSecret: globalThis.process.env.DISCORD_CLIENT_SECRET, redirectUri: globalThis.process.env.NEXT_PUBLIC_DISCORD_REDIRECT_URI}, facebook: { clientId: globalThis.process.env.NEXT_PUBLIC_FACEBOOK_CLIENT_ID, clientSecret: globalThis.process.env.FACEBOOK_CLIENT_SECRET, redirectUri: globalThis.process.env.NEXT_PUBLIC_FACEBOOK_REDIRECT_URI} });
-({ 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 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_CODES2 = {
-  // ===== 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",
-  CLIENT_CANCELLED: "CLIENT_CANCELLED",
-  CONFIG_VALIDATION_FAILED: "CONFIG_VALIDATION_FAILED",
-  HEADER_PROCESSING_FAILED: "HEADER_PROCESSING_FAILED",
-  NETWORK_OVERRIDE_FAILED: "NETWORK_OVERRIDE_FAILED",
-  // Request
-  REQUEST_TIMEOUT: "REQUEST_TIMEOUT",
-  REQUEST_ABORTED: "REQUEST_ABORTED",
-  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",
-  CONNECTION_FAILED: "CONNECTION_FAILED",
-  NETWORK_CONNECTION_FAILED: "NETWORK_CONNECTION_FAILED",
-  NETWORK_OFFLINE: "NETWORK_OFFLINE",
-  NETWORK_DNS_FAILED: "NETWORK_DNS_FAILED",
-  NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
-  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
-  POLLING_CANCELLED: "POLLING_CANCELLED",
-  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"
-};
-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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_CODES2.DEBUG_CONFLICT_DETECTED]: {
-    code: ERROR_CODES2.DEBUG_CONFLICT_DETECTED,
-    status: ke.CONFLICT,
+    code: ERROR_CODES.DEBUG_CONFLICT_DETECTED,
+    status: config.HTTP_STATUS.CONFLICT,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.debug.conflict_detected",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Endpoint
-  [ERROR_CODES2.ENDPOINT_BUILD_FAILED]: {
-    code: ERROR_CODES2.ENDPOINT_BUILD_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.ENDPOINT_BUILD_FAILED]: {
+    code: ERROR_CODES.ENDPOINT_BUILD_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.endpoint.build_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.ENDPOINT_NOT_FOUND]: {
-    code: ERROR_CODES2.ENDPOINT_NOT_FOUND,
-    status: ke.NOT_FOUND,
+  [ERROR_CODES.ENDPOINT_NOT_FOUND]: {
+    code: ERROR_CODES.ENDPOINT_NOT_FOUND,
+    status: config.HTTP_STATUS.NOT_FOUND,
     category: ERROR_CATEGORY.NotFound,
     userMessage: "errors.endpoint.not_found",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.ENDPOINT_INVALID_CONFIG]: {
-    code: ERROR_CODES2.ENDPOINT_INVALID_CONFIG,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.ENDPOINT_INVALID_CONFIG]: {
+    code: ERROR_CODES.ENDPOINT_INVALID_CONFIG,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.endpoint.invalid_config",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
   // Event
-  [ERROR_CODES2.EVENT_HANDLER_FAILED]: {
-    code: ERROR_CODES2.EVENT_HANDLER_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.EVENT_HANDLER_FAILED]: {
+    code: ERROR_CODES.EVENT_HANDLER_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.event.handler_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.EVENT_EMISSION_FAILED]: {
-    code: ERROR_CODES2.EVENT_EMISSION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.EVENT_EMISSION_FAILED]: {
+    code: ERROR_CODES.EVENT_EMISSION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.event.emission_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.MONITORING_FAILED]: {
-    code: ERROR_CODES2.MONITORING_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.MONITORING_FAILED]: {
+    code: ERROR_CODES.MONITORING_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.monitoring.failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Polling
-  [ERROR_CODES2.POLLING_CANCELLED]: {
-    code: ERROR_CODES2.POLLING_CANCELLED,
+  [ERROR_CODES.POLLING_CANCELLED]: {
+    code: ERROR_CODES.POLLING_CANCELLED,
     status: 0,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.polling.cancelled",
     severity: ERROR_SEVERITY.Low,
     retryable: false
   },
-  [ERROR_CODES2.POLLING_TIMEOUT]: {
-    code: ERROR_CODES2.POLLING_TIMEOUT,
-    status: ke.REQUEST_TIMEOUT,
+  [ERROR_CODES.POLLING_TIMEOUT]: {
+    code: ERROR_CODES.POLLING_TIMEOUT,
+    status: config.HTTP_STATUS.REQUEST_TIMEOUT,
     category: ERROR_CATEGORY.Timeout,
     userMessage: "errors.polling.timeout",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES2.POLLING_INVALID_CONFIG]: {
-    code: ERROR_CODES2.POLLING_INVALID_CONFIG,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.POLLING_INVALID_CONFIG]: {
+    code: ERROR_CODES.POLLING_INVALID_CONFIG,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.polling.invalid_config",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
   // PubSub
-  [ERROR_CODES2.PUBSUB_SUBSCRIPTION_FAILED]: {
-    code: ERROR_CODES2.PUBSUB_SUBSCRIPTION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.PUBSUB_SUBSCRIPTION_FAILED]: {
+    code: ERROR_CODES.PUBSUB_SUBSCRIPTION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.pubsub.subscription_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.PUBSUB_PUBLICATION_FAILED]: {
-    code: ERROR_CODES2.PUBSUB_PUBLICATION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.PUBSUB_PUBLICATION_FAILED]: {
+    code: ERROR_CODES.PUBSUB_PUBLICATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.pubsub.publication_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.PUBSUB_INVALID_TOPIC]: {
-    code: ERROR_CODES2.PUBSUB_INVALID_TOPIC,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.PUBSUB_INVALID_TOPIC]: {
+    code: ERROR_CODES.PUBSUB_INVALID_TOPIC,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.pubsub.invalid_topic",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.PUBSUB_CHANNEL_ERROR]: {
-    code: ERROR_CODES2.PUBSUB_CHANNEL_ERROR,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.PUBSUB_CHANNEL_ERROR]: {
+    code: ERROR_CODES.PUBSUB_CHANNEL_ERROR,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.pubsub.channel_error",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Revalidation
-  [ERROR_CODES2.REVALIDATION_FAILED]: {
-    code: ERROR_CODES2.REVALIDATION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.REVALIDATION_FAILED]: {
+    code: ERROR_CODES.REVALIDATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.revalidation.failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.REVALIDATION_IN_PROGRESS]: {
-    code: ERROR_CODES2.REVALIDATION_IN_PROGRESS,
-    status: ke.CONFLICT,
+  [ERROR_CODES.REVALIDATION_IN_PROGRESS]: {
+    code: ERROR_CODES.REVALIDATION_IN_PROGRESS,
+    status: config.HTTP_STATUS.CONFLICT,
     category: ERROR_CATEGORY.Cache,
     userMessage: "errors.revalidation.in_progress",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Context
-  [ERROR_CODES2.CONTEXT_OPERATION_FAILED]: {
-    code: ERROR_CODES2.CONTEXT_OPERATION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.CONTEXT_OPERATION_FAILED]: {
+    code: ERROR_CODES.CONTEXT_OPERATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.context.operation_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Request
-  [ERROR_CODES2.REQUEST_TIMEOUT]: {
-    code: ERROR_CODES2.REQUEST_TIMEOUT,
-    status: ke.REQUEST_TIMEOUT,
+  [ERROR_CODES.REQUEST_TIMEOUT]: {
+    code: ERROR_CODES.REQUEST_TIMEOUT,
+    status: config.HTTP_STATUS.REQUEST_TIMEOUT,
     category: ERROR_CATEGORY.Timeout,
     userMessage: "errors.request.timeout",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
-  [ERROR_CODES2.REQUEST_ABORTED]: {
-    code: ERROR_CODES2.REQUEST_ABORTED,
+  [ERROR_CODES.REQUEST_ABORTED]: {
+    code: ERROR_CODES.REQUEST_ABORTED,
     status: 0,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.request.aborted",
     severity: ERROR_SEVERITY.Medium,
     retryable: true
   },
-  [ERROR_CODES2.REQUEST_INVALID_PARAMS]: {
-    code: ERROR_CODES2.REQUEST_INVALID_PARAMS,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.REQUEST_INVALID_PARAMS]: {
+    code: ERROR_CODES.REQUEST_INVALID_PARAMS,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     userMessage: "errors.request.invalid_params",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.REQUEST_PREPARATION_FAILED]: {
-    code: ERROR_CODES2.REQUEST_PREPARATION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.REQUEST_PREPARATION_FAILED]: {
+    code: ERROR_CODES.REQUEST_PREPARATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.request.preparation_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Response
-  [ERROR_CODES2.RESPONSE_INVALID_FORMAT]: {
-    code: ERROR_CODES2.RESPONSE_INVALID_FORMAT,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.RESPONSE_INVALID_FORMAT]: {
+    code: ERROR_CODES.RESPONSE_INVALID_FORMAT,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.response.invalid_format",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.RESPONSE_PARSING_FAILED]: {
-    code: ERROR_CODES2.RESPONSE_PARSING_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.RESPONSE_PARSING_FAILED]: {
+    code: ERROR_CODES.RESPONSE_PARSING_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     userMessage: "errors.response.parsing_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
   // Client
-  [ERROR_CODES2.CLIENT_ERROR]: {
-    code: ERROR_CODES2.CLIENT_ERROR,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.CLIENT_ERROR]: {
+    code: ERROR_CODES.CLIENT_ERROR,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.error",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.CLIENT_INITIALIZATION_FAILED]: {
-    code: ERROR_CODES2.CLIENT_INITIALIZATION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.CLIENT_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.initialization_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.CLIENT_INVALID_CONFIG]: {
-    code: ERROR_CODES2.CLIENT_INVALID_CONFIG,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.CLIENT_INVALID_CONFIG]: {
+    code: ERROR_CODES.CLIENT_INVALID_CONFIG,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.invalid_config",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
-  [ERROR_CODES2.CLIENT_MISSING_BASE_URL]: {
-    code: ERROR_CODES2.CLIENT_MISSING_BASE_URL,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.CLIENT_MISSING_BASE_URL]: {
+    code: ERROR_CODES.CLIENT_MISSING_BASE_URL,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.client.missing_base_url",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
-  [ERROR_CODES2.CLIENT_CANCELLED]: {
-    code: ERROR_CODES2.CLIENT_CANCELLED,
+  [ERROR_CODES.CLIENT_CANCELLED]: {
+    code: ERROR_CODES.CLIENT_CANCELLED,
     status: 0,
     category: ERROR_CATEGORY.Client,
     userMessage: "errors.client.cancelled",
@@ -5897,34 +5336,34 @@ var ERROR_DEFINITIONS2 = {
     retryable: true
   },
   // Configuration
-  [ERROR_CODES2.CONFIG_VALIDATION_FAILED]: {
-    code: ERROR_CODES2.CONFIG_VALIDATION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
+    code: ERROR_CODES.CONFIG_VALIDATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     userMessage: "errors.config.validation_failed",
     severity: ERROR_SEVERITY.Critical,
     retryable: false
   },
-  [ERROR_CODES2.HEADER_PROCESSING_FAILED]: {
-    code: ERROR_CODES2.HEADER_PROCESSING_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.HEADER_PROCESSING_FAILED]: {
+    code: ERROR_CODES.HEADER_PROCESSING_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Headers,
     userMessage: "errors.headers.processing_failed",
     severity: ERROR_SEVERITY.Medium,
     retryable: false
   },
-  [ERROR_CODES2.NETWORK_OVERRIDE_FAILED]: {
-    code: ERROR_CODES2.NETWORK_OVERRIDE_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NETWORK_OVERRIDE_FAILED]: {
+    code: ERROR_CODES.NETWORK_OVERRIDE_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Network,
     userMessage: "errors.network.override_failed",
     severity: ERROR_SEVERITY.High,
     retryable: true
   },
   // Generic
-  [ERROR_CODES2.UNKNOWN_ERROR]: {
-    code: ERROR_CODES2.UNKNOWN_ERROR,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.UNKNOWN_ERROR]: {
+    code: ERROR_CODES.UNKNOWN_ERROR,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Unknown,
     userMessage: "errors.unknown",
     severity: ERROR_SEVERITY.Medium,
@@ -5932,224 +5371,224 @@ var ERROR_DEFINITIONS2 = {
   },
   // ===== Notification Package Error Definitions =====
   // Provider errors (retryable)
-  [ERROR_CODES2.NOTIFICATION_PROVIDER_SEND_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_PROVIDER_SEND_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NOTIFICATION_PROVIDER_SEND_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_PROVIDER_SEND_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.provider.send_failed"
   },
-  [ERROR_CODES2.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID]: {
-    code: ERROR_CODES2.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID]: {
+    code: ERROR_CODES.NOTIFICATION_PROVIDER_CONFIGURATION_INVALID,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.provider.configuration_invalid"
   },
-  [ERROR_CODES2.NOTIFICATION_PROVIDER_RATE_LIMIT]: {
-    code: ERROR_CODES2.NOTIFICATION_PROVIDER_RATE_LIMIT,
-    status: ke.TOO_MANY_REQUESTS,
+  [ERROR_CODES.NOTIFICATION_PROVIDER_RATE_LIMIT]: {
+    code: ERROR_CODES.NOTIFICATION_PROVIDER_RATE_LIMIT,
+    status: config.HTTP_STATUS.TOO_MANY_REQUESTS,
     category: ERROR_CATEGORY.RateLimit,
     severity: ERROR_SEVERITY.Medium,
     retryable: true,
     userMessage: "errors.notification.provider.rate_limit"
   },
-  [ERROR_CODES2.NOTIFICATION_PROVIDER_AUTH_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_PROVIDER_AUTH_FAILED,
-    status: ke.UNAUTHORIZED,
+  [ERROR_CODES.NOTIFICATION_PROVIDER_AUTH_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_PROVIDER_AUTH_FAILED,
+    status: config.HTTP_STATUS.UNAUTHORIZED,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.provider.auth_failed"
   },
-  [ERROR_CODES2.NOTIFICATION_PROVIDER_TIMEOUT]: {
-    code: ERROR_CODES2.NOTIFICATION_PROVIDER_TIMEOUT,
-    status: ke.GATEWAY_TIMEOUT,
+  [ERROR_CODES.NOTIFICATION_PROVIDER_TIMEOUT]: {
+    code: ERROR_CODES.NOTIFICATION_PROVIDER_TIMEOUT,
+    status: config.HTTP_STATUS.GATEWAY_TIMEOUT,
     category: ERROR_CATEGORY.Network,
     severity: ERROR_SEVERITY.Medium,
     retryable: true,
     userMessage: "errors.notification.provider.timeout"
   },
-  [ERROR_CODES2.NOTIFICATION_PROVIDER_UNAVAILABLE]: {
-    code: ERROR_CODES2.NOTIFICATION_PROVIDER_UNAVAILABLE,
-    status: ke.SERVICE_UNAVAILABLE,
+  [ERROR_CODES.NOTIFICATION_PROVIDER_UNAVAILABLE]: {
+    code: ERROR_CODES.NOTIFICATION_PROVIDER_UNAVAILABLE,
+    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.provider.unavailable"
   },
-  [ERROR_CODES2.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED]: {
-    code: ERROR_CODES2.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED,
-    status: ke.NOT_IMPLEMENTED,
+  [ERROR_CODES.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED]: {
+    code: ERROR_CODES.NOTIFICATION_PROVIDER_FEATURE_NOT_SUPPORTED,
+    status: config.HTTP_STATUS.NOT_IMPLEMENTED,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.Low,
     retryable: false,
     userMessage: "errors.notification.provider.feature_not_supported"
   },
-  [ERROR_CODES2.NOTIFICATION_ALL_PROVIDERS_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_ALL_PROVIDERS_FAILED,
-    status: ke.SERVICE_UNAVAILABLE,
+  [ERROR_CODES.NOTIFICATION_ALL_PROVIDERS_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_ALL_PROVIDERS_FAILED,
+    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Provider,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.all_providers_failed"
   },
   // Validation errors (non-retryable)
-  [ERROR_CODES2.NOTIFICATION_INVALID_INPUT]: {
-    code: ERROR_CODES2.NOTIFICATION_INVALID_INPUT,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.NOTIFICATION_INVALID_INPUT]: {
+    code: ERROR_CODES.NOTIFICATION_INVALID_INPUT,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_input"
   },
-  [ERROR_CODES2.NOTIFICATION_INVALID_RECIPIENT]: {
-    code: ERROR_CODES2.NOTIFICATION_INVALID_RECIPIENT,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.NOTIFICATION_INVALID_RECIPIENT]: {
+    code: ERROR_CODES.NOTIFICATION_INVALID_RECIPIENT,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_recipient"
   },
-  [ERROR_CODES2.NOTIFICATION_INVALID_TEMPLATE]: {
-    code: ERROR_CODES2.NOTIFICATION_INVALID_TEMPLATE,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.NOTIFICATION_INVALID_TEMPLATE]: {
+    code: ERROR_CODES.NOTIFICATION_INVALID_TEMPLATE,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Template,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_template"
   },
-  [ERROR_CODES2.NOTIFICATION_INVALID_PAYLOAD]: {
-    code: ERROR_CODES2.NOTIFICATION_INVALID_PAYLOAD,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.NOTIFICATION_INVALID_PAYLOAD]: {
+    code: ERROR_CODES.NOTIFICATION_INVALID_PAYLOAD,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.invalid_payload"
   },
-  [ERROR_CODES2.NOTIFICATION_MISSING_REQUIRED_FIELD]: {
-    code: ERROR_CODES2.NOTIFICATION_MISSING_REQUIRED_FIELD,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.NOTIFICATION_MISSING_REQUIRED_FIELD]: {
+    code: ERROR_CODES.NOTIFICATION_MISSING_REQUIRED_FIELD,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.required_field_missing"
   },
-  [ERROR_CODES2.NOTIFICATION_VALIDATION_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_VALIDATION_FAILED,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.NOTIFICATION_VALIDATION_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_VALIDATION_FAILED,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.validation.failed"
   },
   // User Preferences
-  [ERROR_CODES2.NOTIFICATION_USER_OPTED_OUT]: {
-    code: ERROR_CODES2.NOTIFICATION_USER_OPTED_OUT,
-    status: ke.OK,
+  [ERROR_CODES.NOTIFICATION_USER_OPTED_OUT]: {
+    code: ERROR_CODES.NOTIFICATION_USER_OPTED_OUT,
+    status: config.HTTP_STATUS.OK,
     category: ERROR_CATEGORY.Validation,
     severity: ERROR_SEVERITY.Low,
     retryable: false,
     userMessage: "errors.notification.user.opted_out"
   },
   // Queue errors (retryable)
-  [ERROR_CODES2.NOTIFICATION_QUEUE_FULL]: {
-    code: ERROR_CODES2.NOTIFICATION_QUEUE_FULL,
-    status: ke.SERVICE_UNAVAILABLE,
+  [ERROR_CODES.NOTIFICATION_QUEUE_FULL]: {
+    code: ERROR_CODES.NOTIFICATION_QUEUE_FULL,
+    status: config.HTTP_STATUS.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Queue,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.queue.full"
   },
-  [ERROR_CODES2.NOTIFICATION_QUEUE_PROCESSING_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_QUEUE_PROCESSING_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NOTIFICATION_QUEUE_PROCESSING_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_QUEUE_PROCESSING_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Queue,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.queue.processing_failed"
   },
   // Webhook errors
-  [ERROR_CODES2.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID]: {
-    code: ERROR_CODES2.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID,
-    status: ke.UNAUTHORIZED,
+  [ERROR_CODES.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID]: {
+    code: ERROR_CODES.NOTIFICATION_WEBHOOK_SIGNATURE_INVALID,
+    status: config.HTTP_STATUS.UNAUTHORIZED,
     category: ERROR_CATEGORY.Webhook,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.notification.webhook.signature_invalid"
   },
-  [ERROR_CODES2.NOTIFICATION_WEBHOOK_VALIDATION_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_WEBHOOK_VALIDATION_FAILED,
-    status: ke.BAD_REQUEST,
+  [ERROR_CODES.NOTIFICATION_WEBHOOK_VALIDATION_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_WEBHOOK_VALIDATION_FAILED,
+    status: config.HTTP_STATUS.BAD_REQUEST,
     category: ERROR_CATEGORY.Webhook,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.webhook.validation_failed"
   },
-  [ERROR_CODES2.NOTIFICATION_WEBHOOK_PROCESSING_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_WEBHOOK_PROCESSING_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NOTIFICATION_WEBHOOK_PROCESSING_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_WEBHOOK_PROCESSING_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Webhook,
     severity: ERROR_SEVERITY.High,
     retryable: true,
     userMessage: "errors.notification.webhook.processing_failed"
   },
   // Template errors
-  [ERROR_CODES2.NOTIFICATION_TEMPLATE_NOT_FOUND]: {
-    code: ERROR_CODES2.NOTIFICATION_TEMPLATE_NOT_FOUND,
-    status: ke.NOT_FOUND,
+  [ERROR_CODES.NOTIFICATION_TEMPLATE_NOT_FOUND]: {
+    code: ERROR_CODES.NOTIFICATION_TEMPLATE_NOT_FOUND,
+    status: config.HTTP_STATUS.NOT_FOUND,
     category: ERROR_CATEGORY.Template,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.notification.template.not_found"
   },
-  [ERROR_CODES2.NOTIFICATION_TEMPLATE_RENDER_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_TEMPLATE_RENDER_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NOTIFICATION_TEMPLATE_RENDER_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_TEMPLATE_RENDER_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Template,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.notification.template.render_failed"
   },
   // General notification errors
-  [ERROR_CODES2.NOTIFICATION_UNKNOWN_ERROR]: {
-    code: ERROR_CODES2.NOTIFICATION_UNKNOWN_ERROR,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NOTIFICATION_UNKNOWN_ERROR]: {
+    code: ERROR_CODES.NOTIFICATION_UNKNOWN_ERROR,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Unknown,
     severity: ERROR_SEVERITY.Medium,
     retryable: false,
     userMessage: "errors.notification.unknown"
   },
-  [ERROR_CODES2.NOTIFICATION_INITIALIZATION_FAILED]: {
-    code: ERROR_CODES2.NOTIFICATION_INITIALIZATION_FAILED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.NOTIFICATION_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.NOTIFICATION_INITIALIZATION_FAILED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.notification.initialization_failed"
   },
   // ===== Errors Package Errors =====
-  [ERROR_CODES2.ERROR_SYSTEM_NOT_INITIALIZED]: {
-    code: ERROR_CODES2.ERROR_SYSTEM_NOT_INITIALIZED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.ERROR_SYSTEM_NOT_INITIALIZED]: {
+    code: ERROR_CODES.ERROR_SYSTEM_NOT_INITIALIZED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.Critical,
     retryable: false,
     userMessage: "errors.system.not_initialized"
   },
-  [ERROR_CODES2.EVENT_FACTORY_NOT_REGISTERED]: {
-    code: ERROR_CODES2.EVENT_FACTORY_NOT_REGISTERED,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.EVENT_FACTORY_NOT_REGISTERED]: {
+    code: ERROR_CODES.EVENT_FACTORY_NOT_REGISTERED,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Configuration,
     severity: ERROR_SEVERITY.High,
     retryable: false,
     userMessage: "errors.event.factory.not_registered"
   },
-  [ERROR_CODES2.DATABASE_ERROR]: {
-    code: ERROR_CODES2.DATABASE_ERROR,
-    status: ke.INTERNAL_SERVER_ERROR,
+  [ERROR_CODES.DATABASE_ERROR]: {
+    code: ERROR_CODES.DATABASE_ERROR,
+    status: config.HTTP_STATUS.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server,
     severity: ERROR_SEVERITY.High,
     retryable: false,
@@ -6540,31 +5979,24 @@ var WEBHOOK_VERIFICATION_REASON = /* @__PURE__ */ ((WEBHOOK_VERIFICATION_REASON2
   WEBHOOK_VERIFICATION_REASON2["UnknownEndpoint"] = "unknown_endpoint";
   return WEBHOOK_VERIFICATION_REASON2;
 })(WEBHOOK_VERIFICATION_REASON || {});
-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 || {});
+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 || {});
 
 // src/notifications/enums.ts
 var NOTIFICATION_PROVIDERS = {
@@ -6584,7 +6016,7 @@ var NOTIFICATION_CHANNELS = {
   SMS: "sms",
   PUSH: "push"
 };
-var NOTIFICATION_CATEGORIES2 = {
+var NOTIFICATION_CATEGORIES = {
   /** Cannot be opted out - compliance requirement (password resets, order confirmations) */
   TRANSACTIONAL: "transactional",
   /** User can opt-out (newsletters, promotions) */
@@ -6682,29 +6114,29 @@ var FILE_EXTENSIONS = {
 };
 
 // src/notifications/schemas.ts
-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(
+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(
   /^[a-z0-9-/]+$/,
   "Template ID must contain only lowercase letters, numbers, hyphens, and slashes"
-).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");
+).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");
 
 // src/api/events/enum.ts
 var EVENT_NAMESPACES = {
@@ -6721,7 +6153,7 @@ var EVENT_NAMESPACES = {
   REVALIDATION: "revalidation",
   EVENT_MANAGER: "eventManager"
 };
-var HEADER_EVENTS2 = {
+var HEADER_EVENTS = {
   CHANGED: "headers:changed",
   ENRICHED: "headers:enriched",
   CONFLICT: "headers:conflict",
@@ -6736,7 +6168,7 @@ var HEADER_EVENTS2 = {
   // Wildcard for all header events
   ANY: "headers:*"
 };
-var NETWORK_EVENTS2 = {
+var NETWORK_EVENTS = {
   QUALITY_CHANGE: "network:quality:changed",
   INFO_UPDATE: "network:info-update",
   CONFIG_OVERRIDE: "network:config:override",
@@ -6750,7 +6182,7 @@ var NETWORK_EVENTS2 = {
   // Wildcard for all network events
   ANY: "network:*"
 };
-var ERROR_EVENTS2 = {
+var ERROR_EVENTS = {
   NETWORK_ERROR: "errors:network",
   VALIDATION_ERROR: "errors:validation",
   AUTHENTICATION_ERROR: "errors:authentication",
@@ -6772,7 +6204,7 @@ var ERROR_EVENTS2 = {
   // Wildcard for all error events
   ANY: "errors:*"
 };
-var HANDLER_SCOPES2 = {
+var HANDLER_SCOPES = {
   GLOBAL: "global",
   // Global handlers (lowest priority, persists across all instances)
   CONFIG: "config",
@@ -6784,14 +6216,14 @@ var HANDLER_SCOPES2 = {
   REQUEST: "request"
   // Request-level handlers (highest priority, per-request)
 };
-var EVENT_SCOPES2 = [
-  HANDLER_SCOPES2.GLOBAL,
-  HANDLER_SCOPES2.CONFIG,
-  HANDLER_SCOPES2.CLIENT,
-  HANDLER_SCOPES2.REQUEST
+var EVENT_SCOPES = [
+  HANDLER_SCOPES.GLOBAL,
+  HANDLER_SCOPES.CONFIG,
+  HANDLER_SCOPES.CLIENT,
+  HANDLER_SCOPES.REQUEST
 ];
-var EVENT_SCOPES_WITH_TEMPORARY2 = [...EVENT_SCOPES2, "temporary"];
-var DEBUG_EVENTS2 = {
+var EVENT_SCOPES_WITH_TEMPORARY = [...EVENT_SCOPES, "temporary"];
+var DEBUG_EVENTS = {
   CONFIG_CONFLICT: "debug:config-conflict",
   CONFIG_CHANGE: "debug:config-change",
   HEADERS_TRACKED: "debug:headers-tracked",
@@ -6817,7 +6249,7 @@ var EVENTS_CONFIG_SOURCES = {
   NETWORK_AWARE: "networkAware",
   ADAPTIVE: "adaptive"
 };
-var CONFIG_EVENTS2 = {
+var CONFIG_EVENTS = {
   GLOBAL_UPDATED: "config:global-updated",
   GLOBAL_RESET: "config:global-reset",
   ENVIRONMENT_CONFIGURED: "config:environment-configured",
@@ -6825,7 +6257,7 @@ var CONFIG_EVENTS2 = {
   // Wildcard for all config events
   ANY: "config:*"
 };
-var PERFORMANCE_EVENTS2 = {
+var PERFORMANCE_EVENTS = {
   REQUEST_START: "performance:request-start",
   REQUEST_COMPLETE: "performance:request-complete",
   RETRY: "performance:retry",
@@ -6835,29 +6267,29 @@ var PERFORMANCE_EVENTS2 = {
   // Wildcard for all performance events
   ANY: "performance:*"
 };
-var CLIENT_EVENTS2 = {
+var CLIENT_EVENTS = {
   CONFLICT: "client:conflict",
   DEBUG: "client:debug",
   CREATED: "client:created",
   // Wildcard for all client events
   ANY: "client:*"
 };
-var CACHE_EVENTS2 = {
+var CACHE_EVENTS = {
   HIT: "cache:hit",
   MISS: "cache:miss",
   INVALIDATE: "cache:invalidate",
   // Wildcard for all cache events
   ANY: "cache:*"
 };
-var ALL_EVENTS2 = {
-  ...HEADER_EVENTS2,
-  ...NETWORK_EVENTS2,
-  ...ERROR_EVENTS2,
-  ...DEBUG_EVENTS2,
-  ...CONFIG_EVENTS2,
-  ...PERFORMANCE_EVENTS2,
-  ...CLIENT_EVENTS2,
-  ...CACHE_EVENTS2
+var ALL_EVENTS = {
+  ...HEADER_EVENTS,
+  ...NETWORK_EVENTS,
+  ...ERROR_EVENTS,
+  ...DEBUG_EVENTS,
+  ...CONFIG_EVENTS,
+  ...PERFORMANCE_EVENTS,
+  ...CLIENT_EVENTS,
+  ...CACHE_EVENTS
 };
 
 // src/api/queue/enums.ts
@@ -6954,27 +6386,27 @@ var NETWORK_CONFIDENCE_LEVELS = {
   /** Threshold for medium confidence classification */
   MEDIUM_THRESHOLD: 0.4
 };
-var SPEED_THRESHOLDS2 = {
+var SPEED_THRESHOLDS = {
   EXCELLENT: 10,
   GOOD: 2,
   FAIR: 0.5
 };
-var RTT_THRESHOLDS2 = {
+var RTT_THRESHOLDS = {
   EXCELLENT: 50,
   GOOD: 150,
   FAIR: 400
 };
-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
+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
 };
 
 // src/api/debugger/enums.ts
-var FACTORY_OPERATIONS2 = {
+var FACTORY_OPERATIONS = {
   FACTORY_CREATED: "factory_created",
   FACTORY_ACCESSED: "factory_accessed",
   FACTORY_INITIALIZED: "factory_initialized",
@@ -6990,7 +6422,7 @@ var FACTORY_OPERATIONS2 = {
   SPECIFIC_HANDLER_REMOVED: "specific_handler_removed",
   SCOPE_LISTENERS_CLEARED: "scope_listeners_cleared"
 };
-var EVENT_OPERATIONS2 = {
+var EVENT_OPERATIONS = {
   ON: "on",
   ONCE: "once",
   OFF: "off",
@@ -7008,7 +6440,7 @@ var EVENT_OPERATIONS2 = {
   HANDLER_STRATEGY: "handler_strategy",
   HANDLER_STRATEGY_APPLIED: "handler_strategy_applied"
 };
-var QUEUE_OPERATIONS2 = {
+var QUEUE_OPERATIONS = {
   QUEUE_CREATED: "queue_created",
   QUEUE_PROCESSED: "queue_processed",
   QUEUE_CLEARED: "queue_cleared",
@@ -7018,7 +6450,7 @@ var QUEUE_OPERATIONS2 = {
   ITEM_DEQUEUED: "item_dequeued",
   PRIORITY_CHANGED: "priority_changed"
 };
-var DEBUGGER_CONFIG_SOURCES2 = {
+var DEBUGGER_CONFIG_SOURCES = {
   DEFAULT: "default",
   DIRECT: "direct",
   CLIENT: "client",
@@ -7045,7 +6477,7 @@ var DEBUGGER_CONFIG_SOURCES2 = {
   CONTEXT_HEADERS: "contextHeaders",
   ENCRYPTION: "encryption"
 };
-var HISTORY_TYPES2 = {
+var HISTORY_TYPES = {
   CONFIG: "config",
   HEADER: "header",
   NETWORK: "network",
@@ -7094,23 +6526,23 @@ var ALERT_TYPES = {
   PERFORMANCE: "performance",
   NETWORK: "network"
 };
-var UNIFIED_OPERATIONS2 = {
-  ...FACTORY_OPERATIONS2,
-  ...EVENT_OPERATIONS2,
-  ...QUEUE_OPERATIONS2
+var UNIFIED_OPERATIONS = {
+  ...FACTORY_OPERATIONS,
+  ...EVENT_OPERATIONS,
+  ...QUEUE_OPERATIONS
 };
-function isValidOperation2(operation) {
-  return Object.values(UNIFIED_OPERATIONS2).includes(operation);
+function isValidOperation(operation) {
+  return Object.values(UNIFIED_OPERATIONS).includes(operation);
 }
-__name(isValidOperation2, "isValidOperation");
-function isValidConfigSource2(source) {
-  return Object.values(DEBUGGER_CONFIG_SOURCES2).includes(source);
+__name(isValidOperation, "isValidOperation");
+function isValidConfigSource(source) {
+  return Object.values(DEBUGGER_CONFIG_SOURCES).includes(source);
 }
-__name(isValidConfigSource2, "isValidConfigSource");
-function isValidHistoryType2(type) {
-  return Object.values(HISTORY_TYPES2).includes(type);
+__name(isValidConfigSource, "isValidConfigSource");
+function isValidHistoryType(type) {
+  return Object.values(HISTORY_TYPES).includes(type);
 }
-__name(isValidHistoryType2, "isValidHistoryType");
+__name(isValidHistoryType, "isValidHistoryType");
 
 // src/api/client/enum.ts
 var EVENT_CONSTANTS = {
@@ -7177,11 +6609,11 @@ var COORDINATES = {
     MAX_LON: 146
   }
 };
-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 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 REGION_TO_PRESET = {
   eu: "gdpr",
   us: "ccpa",
@@ -7219,35 +6651,34 @@ var PUB_SUB_EVENT = {
 
 exports.ALERT_SEVERITIES = ALERT_SEVERITIES;
 exports.ALERT_TYPES = ALERT_TYPES;
-exports.ALL_EVENTS = ALL_EVENTS2;
-exports.API_ERROR_CODES = API_ERROR_CODES2;
+exports.ALL_EVENTS = ALL_EVENTS;
+exports.API_ERROR_CODES = API_ERROR_CODES;
 exports.AUTH_PROVIDER = AUTH_PROVIDER;
 exports.AUTH_PROVIDER_TYPE = AUTH_PROVIDER_TYPE;
-exports.CACHE_DURATION_MS = CACHE_DURATION_MS2;
-exports.CACHE_EVENTS = CACHE_EVENTS2;
+exports.CACHE_DURATION_MS = CACHE_DURATION_MS;
+exports.CACHE_EVENTS = CACHE_EVENTS;
 exports.CHAIN_ID = CHAIN_ID;
 exports.CHANGE_TYPES = CHANGE_TYPES;
-exports.CLIENT_EVENTS = CLIENT_EVENTS2;
+exports.CLIENT_EVENTS = CLIENT_EVENTS;
 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_EVENTS2;
+exports.CONFIG_EVENTS = CONFIG_EVENTS;
 exports.COORDINATES = COORDINATES;
 exports.CORRELATION_TYPE = CORRELATION_TYPE;
 exports.COSTOPTIMIZATIONSTRATEGY = COSTOPTIMIZATIONSTRATEGY;
-exports.CorrelationIdSchema = CorrelationIdSchema2;
+exports.CorrelationIdSchema = CorrelationIdSchema;
 exports.DATA_SAVER_PRESETS = DATA_SAVER_PRESETS;
-exports.DEBUGGER_CONFIG_SOURCES = DEBUGGER_CONFIG_SOURCES2;
-exports.DEBUG_EVENTS = DEBUG_EVENTS2;
-exports.DEFAULT_THRESHOLDS = DEFAULT_THRESHOLDS2;
-exports.DeviceTokenSchema = DeviceTokenSchema2;
-exports.ERRORSEVERITY = ERRORSEVERITY2;
+exports.DEBUGGER_CONFIG_SOURCES = DEBUGGER_CONFIG_SOURCES;
+exports.DEBUG_EVENTS = DEBUG_EVENTS;
+exports.DEFAULT_THRESHOLDS = DEFAULT_THRESHOLDS;
+exports.DeviceTokenSchema = DeviceTokenSchema;
 exports.ERROR_CATEGORY = ERROR_CATEGORY;
 exports.ERROR_CATEGORY_TO_EMITTER_KEY = ERROR_CATEGORY_TO_EMITTER_KEY;
-exports.ERROR_CODES = ERROR_CODES2;
-exports.ERROR_DEFINITIONS = ERROR_DEFINITIONS2;
-exports.ERROR_EVENTS = ERROR_EVENTS2;
+exports.ERROR_CODES = ERROR_CODES;
+exports.ERROR_DEFINITIONS = ERROR_DEFINITIONS;
+exports.ERROR_EVENTS = ERROR_EVENTS;
 exports.ERROR_FIELDS = COMMON_FIELDS;
 exports.ERROR_SEVERITY = ERROR_SEVERITY;
 exports.ERROR_TYPE = ERROR_TYPE;
@@ -7255,35 +6686,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_OPERATIONS2;
+exports.EVENT_OPERATIONS = EVENT_OPERATIONS;
 exports.EVENT_PRIORITY = EVENT_PRIORITY;
 exports.EVENT_PRIORITY_MAP = EVENT_PRIORITY_MAP;
-exports.EVENT_SCOPES = EVENT_SCOPES2;
-exports.EVENT_SCOPES_WITH_TEMPORARY = EVENT_SCOPES_WITH_TEMPORARY2;
+exports.EVENT_SCOPES = EVENT_SCOPES;
+exports.EVENT_SCOPES_WITH_TEMPORARY = EVENT_SCOPES_WITH_TEMPORARY;
 exports.EVENT_STATUS = EVENT_STATUS;
 exports.EVENT_TYPE = EVENT_TYPE;
-exports.EmailSchema = EmailSchema2;
-exports.FACTORY_OPERATIONS = FACTORY_OPERATIONS2;
+exports.EmailSchema = EmailSchema;
+exports.FACTORY_OPERATIONS = FACTORY_OPERATIONS;
 exports.FAILOVERSTRATEGY = FAILOVERSTRATEGY;
 exports.FILE_EXTENSIONS = FILE_EXTENSIONS;
-exports.HANDLER_SCOPES = HANDLER_SCOPES2;
-exports.HEADER_EVENTS = HEADER_EVENTS2;
+exports.HANDLER_SCOPES = HANDLER_SCOPES;
+exports.HEADER_EVENTS = HEADER_EVENTS;
 exports.HEADER_STAGES = HEADER_STAGES;
-exports.HISTORY_TYPES = HISTORY_TYPES2;
+exports.HISTORY_TYPES = HISTORY_TYPES;
 exports.IMPACT_LEVELS = IMPACT_LEVELS;
 exports.INTERNAL_STATUS_CODES = INTERNAL_STATUS_CODES;
 exports.LOADBALANCINGSTRATEGY = LOADBALANCINGSTRATEGY;
-exports.LocaleSchema = LocaleSchema2;
+exports.LocaleSchema = LocaleSchema;
 exports.MIME_TYPES = MIME_TYPES;
 exports.NETWORK_CONFIDENCE_LEVELS = NETWORK_CONFIDENCE_LEVELS;
-exports.NETWORK_EVENTS = NETWORK_EVENTS2;
+exports.NETWORK_EVENTS = NETWORK_EVENTS;
 exports.NETWORK_QUALITY = NETWORK_QUALITY;
-exports.NOTIFICATION_CATEGORIES = NOTIFICATION_CATEGORIES2;
+exports.NOTIFICATION_CATEGORIES = NOTIFICATION_CATEGORIES;
 exports.NOTIFICATION_CHANNELS = NOTIFICATION_CHANNELS;
-exports.NOTIFICATION_ERROR_CODES = NOTIFICATION_ERROR_CODES2;
+exports.NOTIFICATION_ERROR_CODES = NOTIFICATION_ERROR_CODES;
 exports.NOTIFICATION_PROVIDERS = NOTIFICATION_PROVIDERS;
 exports.NetworkPresetNames = NetworkPresetNames;
-exports.NotificationCategorySchema = NotificationCategorySchema2;
+exports.NotificationCategorySchema = NotificationCategorySchema;
 exports.OPERATIONS = COMMON_OPERATIONS;
 exports.PACKAGE_STATUS_CODES = INTERNAL_STATUS_CODES;
 exports.PAYMENTERRORCATEGORY = PAYMENTERRORCATEGORY;
@@ -7292,15 +6723,15 @@ exports.PAYMENTEVENTTYPE = PAYMENTEVENTTYPE;
 exports.PAYMENTMETHOD = PAYMENTMETHOD;
 exports.PAYMENTPROVIDERTYPE = PAYMENTPROVIDERTYPE;
 exports.PAYMENTSTATUS = PAYMENTSTATUS;
-exports.PAYMENT_ERROR_CATEGORY = PAYMENT_ERROR_CATEGORY2;
+exports.PAYMENT_ERROR_CATEGORY = PAYMENT_ERROR_CATEGORY;
 exports.PERFORMANCEMETRICTYPE = PERFORMANCEMETRICTYPE;
-exports.PERFORMANCE_EVENTS = PERFORMANCE_EVENTS2;
+exports.PERFORMANCE_EVENTS = PERFORMANCE_EVENTS;
 exports.PRIORITY_LEVEL = PRIORITY_LEVEL;
 exports.PRODUCTTYPE = PRODUCTTYPE;
 exports.PUB_SUB_EVENT = PUB_SUB_EVENT;
-exports.PhoneSchema = PhoneSchema2;
-exports.QUEUE_OPERATIONS = QUEUE_OPERATIONS2;
-exports.QueuePrioritySchema = QueuePrioritySchema2;
+exports.PhoneSchema = PhoneSchema;
+exports.QUEUE_OPERATIONS = QUEUE_OPERATIONS;
+exports.QueuePrioritySchema = QueuePrioritySchema;
 exports.REFUND_ERROR_TYPES = REFUND_ERROR_TYPES;
 exports.REFUND_NOT_ALLOWED_REASON = REFUND_NOT_ALLOWED_REASON;
 exports.REGIONAL_CONFIDENCE_LEVELS = REGIONAL_CONFIDENCE_LEVELS;
@@ -7310,28 +6741,28 @@ exports.REGULATORYFRAMEWORK = REGULATORYFRAMEWORK;
 exports.REGULATORY_FRAMEWORK = REGULATORY_FRAMEWORK;
 exports.REQUIREDACTIONTYPE = REQUIREDACTIONTYPE;
 exports.ROUTINGSTRATEGY = ROUTINGSTRATEGY;
-exports.RTT_THRESHOLDS = RTT_THRESHOLDS2;
+exports.RTT_THRESHOLDS = RTT_THRESHOLDS;
 exports.SECURITY_THREAT_TYPE = SECURITY_THREAT_TYPE;
 exports.SIGNATURE_METHOD = SIGNATURE_METHOD;
-exports.SPEED_THRESHOLDS = SPEED_THRESHOLDS2;
+exports.SPEED_THRESHOLDS = SPEED_THRESHOLDS;
 exports.STORAGE_TYPES = COMMON_STORAGE_TYPES;
 exports.TRACKING_PHASES = TRACKING_PHASES;
 exports.TRANSACTIONTYPE = TRANSACTIONTYPE;
-exports.TemplateDataSchema = TemplateDataSchema2;
-exports.TemplateIdSchema = TemplateIdSchema2;
-exports.UNIFIED_OPERATIONS = UNIFIED_OPERATIONS2;
+exports.TemplateDataSchema = TemplateDataSchema;
+exports.TemplateIdSchema = TemplateIdSchema;
+exports.UNIFIED_OPERATIONS = UNIFIED_OPERATIONS;
 exports.UPDATE_STRATEGIES = UPDATE_STRATEGIES;
 exports.USERTYPE = USERTYPE;
 exports.USER_ROLE = USER_ROLE;
 exports.USER_STATUS = USER_STATUS;
-exports.UserIdSchema = UserIdSchema2;
+exports.UserIdSchema = UserIdSchema;
 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 = isValidConfigSource2;
-exports.isValidHistoryType = isValidHistoryType2;
-exports.isValidOperation = isValidOperation2;
+exports.isValidConfigSource = isValidConfigSource;
+exports.isValidHistoryType = isValidHistoryType;
+exports.isValidOperation = isValidOperation;
 exports.loginCredentialsSchema = loginCredentialsSchema;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map