@plyaz/types 1.7.22 → 1.7.23

package/dist/api/index.cjs

@@ -1,4 +1,1033 @@
 'use strict';
 
+// @plyaz package - Built with tsup
+
+// src/api/events/enum.ts
+var EVENT_NAMESPACES = {
+  HEADERS: "headers",
+  NETWORK: "network",
+  ERRORS: "errors",
+  DEBUG: "debug",
+  CONFIG: "config",
+  PERFORMANCE: "performance",
+  CLIENT: "client",
+  CACHE: "cache",
+  POLLING: "polling",
+  REQUEST: "request",
+  REVALIDATION: "revalidation",
+  EVENT_MANAGER: "eventManager"
+};
+var HEADER_EVENTS = {
+  CHANGED: "headers:changed",
+  ENRICHED: "headers:enriched",
+  CONFLICT: "headers:conflict",
+  OVERRIDE: "headers:override",
+  TRACKED: "headers:tracked",
+  MERGED: "headers:merged",
+  FILTERED: "headers:filtered",
+  VALIDATED: "headers:validated",
+  CACHED: "headers:cached",
+  CACHE_HIT: "headers:cache:hit",
+  CACHE_MISS: "headers:cache:miss",
+  // Wildcard for all header events
+  ANY: "headers:*"
+};
+var NETWORK_EVENTS = {
+  QUALITY_CHANGE: "network:quality:changed",
+  INFO_UPDATE: "network:info-update",
+  CONFIG_OVERRIDE: "network:config:override",
+  CONFIG_RESTORED: "network:config:restored",
+  OVERRIDE_CHANGE: "network:override-change",
+  PRESET_APPLIED: "network:preset-applied",
+  PRESET_CHANGED: "network:preset:changed",
+  HINTS_UPDATED: "network:hints:updated",
+  AUTO_DETECTION: "network:auto:detection",
+  MANUAL_UPDATE: "network:manual:update",
+  // Wildcard for all network events
+  ANY: "network:*"
+};
+var ERROR_EVENTS = {
+  NETWORK_ERROR: "errors:network",
+  VALIDATION_ERROR: "errors:validation",
+  AUTHENTICATION_ERROR: "errors:authentication",
+  AUTHORIZATION_ERROR: "errors:authorization",
+  RATE_LIMIT_ERROR: "errors:rate-limit",
+  SERVER_ERROR: "errors:server",
+  CLIENT_ERROR: "errors:client",
+  TIMEOUT_ERROR: "errors:timeout",
+  CONFLICT_ERROR: "errors:conflict",
+  CACHE_ERROR: "errors:cache",
+  HEADERS_ERROR: "errors:headers",
+  RETRY_ERROR: "errors:retry",
+  STRATEGY_ERROR: "errors:strategy",
+  REGIONAL_ERROR: "errors:regional",
+  NOT_FOUND_ERROR: "errors:not-found",
+  EXTERNAL_SERVICE_ERROR: "errors:external-service",
+  UNKNOWN_ERROR: "errors:unknown",
+  GENERIC_ERROR: "errors:generic",
+  // Wildcard for all error events
+  ANY: "errors:*"
+};
+var HANDLER_SCOPES = {
+  GLOBAL: "global",
+  // Global handlers (lowest priority, persists across all instances)
+  CONFIG: "config",
+  // Config-level handlers (middle priority, from setGlobalConfig)
+  CLIENT: "client",
+  // Client instance handlers (high priority, instance-specific)
+  TEMPORARY: "request",
+  // Temporary handlers (alias for REQUEST, highest priority)
+  REQUEST: "request"
+  // Request-level handlers (highest priority, per-request)
+};
+var EVENT_SCOPES = [
+  HANDLER_SCOPES.GLOBAL,
+  HANDLER_SCOPES.CONFIG,
+  HANDLER_SCOPES.CLIENT,
+  HANDLER_SCOPES.REQUEST
+];
+var EVENT_SCOPES_WITH_TEMPORARY = [...EVENT_SCOPES, "temporary"];
+var DEBUG_EVENTS = {
+  CONFIG_CONFLICT: "debug:config-conflict",
+  CONFIG_CHANGE: "debug:config-change",
+  HEADERS_TRACKED: "debug:headers-tracked",
+  NETWORK_OVERRIDE: "debug:network-override",
+  NETWORK_STATE_CHANGED: "debug:network-state-changed",
+  NETWORK_DATA_CLEARED: "debug:network-data-cleared",
+  DEBUG_INFO: "debug:info",
+  PERFORMANCE_IMPACT: "debug:performance-impact",
+  MONITORING_ALERT: "debug:monitoring-alert",
+  CONFIG_TRACKED: "debug:config-tracked",
+  CONFLICTS_BATCH: "debug:conflicts-batch",
+  EVENT_OPERATION: "debug:event-operation",
+  // Wildcard for all debug events
+  ANY: "debug:*"
+};
+var EVENTS_CONFIG_SOURCES = {
+  GLOBAL: "global",
+  CREATE_API_CLIENT: "createApiClient",
+  UPDATE_CONFIG: "updateConfig",
+  MANUAL: "manual",
+  ENVIRONMENT: "environment",
+  PRESET: "preset",
+  NETWORK_AWARE: "networkAware",
+  ADAPTIVE: "adaptive"
+};
+var CONFIG_EVENTS = {
+  GLOBAL_UPDATED: "config:global-updated",
+  GLOBAL_RESET: "config:global-reset",
+  ENVIRONMENT_CONFIGURED: "config:environment-configured",
+  PRESET_APPLIED: "config:preset-applied",
+  // Wildcard for all config events
+  ANY: "config:*"
+};
+var PERFORMANCE_EVENTS = {
+  REQUEST_START: "performance:request-start",
+  REQUEST_COMPLETE: "performance:request-complete",
+  RETRY: "performance:retry",
+  THRESHOLD_EXCEEDED: "performance:threshold-exceeded",
+  OPTIMIZATION_APPLIED: "performance:optimization-applied",
+  METRIC_RECORDED: "performance:metric-recorded",
+  // Wildcard for all performance events
+  ANY: "performance:*"
+};
+var CLIENT_EVENTS = {
+  CONFLICT: "client:conflict",
+  DEBUG: "client:debug",
+  CREATED: "client:created",
+  // Wildcard for all client events
+  ANY: "client:*"
+};
+var CACHE_EVENTS = {
+  HIT: "cache:hit",
+  MISS: "cache:miss",
+  INVALIDATE: "cache:invalidate",
+  // Wildcard for all cache events
+  ANY: "cache:*"
+};
+var ALL_EVENTS = {
+  ...HEADER_EVENTS,
+  ...NETWORK_EVENTS,
+  ...ERROR_EVENTS,
+  ...DEBUG_EVENTS,
+  ...CONFIG_EVENTS,
+  ...PERFORMANCE_EVENTS,
+  ...CLIENT_EVENTS,
+  ...CACHE_EVENTS
+};
+
+// node_modules/.pnpm/@plyaz+config@1.5.3_next@15.4.7_react-dom@19.2.0_react@19.2.0_typescript@5.9.3_zod@3.25.76/node_modules/@plyaz/config/dist/index.mjs
+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 po = { BAD_REQUEST: 400, UNAUTHORIZED: 401, FORBIDDEN: 403, NOT_FOUND: 404, REQUEST_TIMEOUT: 408, CONFLICT: 409, UNPROCESSABLE_ENTITY: 422, TOO_MANY_REQUESTS: 429, INTERNAL_SERVER_ERROR: 500, BAD_GATEWAY: 502, SERVICE_UNAVAILABLE: 503, GATEWAY_TIMEOUT: 504};
+var t = { unauthorized: { status: 401}, internal_server_error: { status: 500}};
+({ InvalidInput: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [t.internal_server_error.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [t.unauthorized.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+
+// src/errors/enums.ts
+var ERROR_CATEGORY = {
+  /** Client-side error (e.g., invalid request). */
+  Client: "client",
+  /** Server-side error (e.g., logic failure or exception). */
+  Server: "server",
+  /** Network-related error (e.g., unreachable endpoint). */
+  Network: "network",
+  /** Validation-specific error (e.g., failed constraints or field errors). */
+  Validation: "validation",
+  /** Authentication-related error (e.g., invalid credentials, expired token). */
+  Authentication: "authentication",
+  /** Authorization-related error (e.g., insufficient permissions). */
+  Authorization: "authorization",
+  /** Resource not found error. */
+  NotFound: "not.found",
+  /** Rate limiting error (too many requests). */
+  RateLimit: "rate.limit",
+  /** External service error (e.g., third-party API failure). */
+  ExternalService: "external.service",
+  /** Timeout error (request exceeded time limit). */
+  Timeout: "timeout",
+  /** Cache-related error. */
+  Cache: "cache",
+  /** Headers-related error (e.g., missing or invalid headers). */
+  Headers: "headers",
+  /** Retry-related error (e.g., max retries exceeded). */
+  Retry: "retry",
+  /** Strategy-related error (e.g., invalid retry or caching strategy). */
+  Strategy: "strategy",
+  /** Regional-related error (e.g., region detection failure). */
+  Regional: "regional",
+  /** Unknown or unclassified error. */
+  Unknown: "unknown"
+};
+
+// src/api/errors/enum.ts
+var OPERATIONS = {
+  STORAGE: "storage",
+  RETRIEVAL: "retrieval",
+  INVALIDATION: "invalidation",
+  ENRICHMENT: "enrichment",
+  VALIDATION: "validation",
+  PRESET_LOOKUP: "preset-lookup",
+  INITIALIZATION: "initialization",
+  CONFIGURATION: "configuration",
+  REQUEST: "request",
+  RESPONSE: "response",
+  RETRY: "retry",
+  REVALIDATION: "revalidation",
+  STRATEGY_EXECUTION: "strategy-execution",
+  POLLING: "polling",
+  SUBSCRIPTION: "subscription",
+  PUBLICATION: "publication",
+  DEBUG: "debug",
+  DEBUG_TRACKING: "debug-tracking",
+  ENDPOINT_BUILD: "endpoint-build",
+  TRACKING: "tracking",
+  NETWORK_CHECK: "network-check",
+  EVENT_HANDLING: "event-handling",
+  SERIALIZATION: "serialization",
+  DESERIALIZATION: "deserialization",
+  REGIONAL_DETECTION: "regional-detection",
+  MONITORING: "monitoring",
+  CONTEXT_SETUP: "context-setup",
+  FALLBACK: "fallback"
+};
+var ERROR_FIELDS = {
+  STORAGE: "storage",
+  CACHE: "cache",
+  HEADERS: "headers",
+  PRESET_NAME: "presetName",
+  PRESET_ID: "presetId",
+  CONFIG: "config",
+  URL: "url",
+  METHOD: "method",
+  STRATEGY: "strategy",
+  RETRY_COUNT: "retryCount",
+  MAX_RETRIES: "maxRetries",
+  POLLING_INTERVAL: "pollingInterval",
+  TOPIC: "topic",
+  CHANNEL: "channel",
+  ENDPOINT: "endpoint",
+  CLIENT: "client",
+  NETWORK_TYPE: "networkType",
+  TIME_INTERVAL: "timeInterval"
+};
+var STORAGE_TYPES = {
+  PRIMARY: "primary",
+  FALLBACK: "fallback",
+  MEMORY: "memory",
+  SESSION: "session",
+  LOCAL: "local"
+};
+var API_ERROR_CODES = {
+  // Client Configuration Errors
+  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 Errors
+  REQUEST_TIMEOUT: "REQUEST_TIMEOUT",
+  REQUEST_ABORTED: "REQUEST_ABORTED",
+  REQUEST_INVALID_PARAMS: "REQUEST_INVALID_PARAMS",
+  REQUEST_PREPARATION_FAILED: "REQUEST_PREPARATION_FAILED",
+  // Response Errors
+  RESPONSE_INVALID_FORMAT: "RESPONSE_INVALID_FORMAT",
+  RESPONSE_PARSING_FAILED: "RESPONSE_PARSING_FAILED",
+  // Network Errors
+  NETWORK_CONNECTION_FAILED: "NETWORK_CONNECTION_FAILED",
+  NETWORK_OFFLINE: "NETWORK_OFFLINE",
+  NETWORK_DNS_FAILED: "NETWORK_DNS_FAILED",
+  NETWORK_TIMEOUT: "NETWORK_TIMEOUT",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  NETWORK_PRESET_NOT_FOUND: "NETWORK_PRESET_NOT_FOUND",
+  NETWORK_CONFIGURATION_INVALID: "NETWORK_CONFIGURATION_INVALID",
+  // Regional Errors
+  REGIONAL_PRESET_NOT_FOUND: "REGIONAL_PRESET_NOT_FOUND",
+  REGION_DETECTION_FAILED: "REGION_DETECTION_FAILED",
+  // Header Errors
+  HEADERS_ENRICHMENT_FAILED: "HEADERS_ENRICHMENT_FAILED",
+  HEADERS_VALIDATION_FAILED: "HEADERS_VALIDATION_FAILED",
+  HEADERS_MERGE_CONFLICT: "HEADERS_MERGE_CONFLICT",
+  // Cache Errors
+  CACHE_STORAGE_FAILED: "CACHE_STORAGE_FAILED",
+  CACHE_RETRIEVAL_FAILED: "CACHE_RETRIEVAL_FAILED",
+  CACHE_INVALIDATION_FAILED: "CACHE_INVALIDATION_FAILED",
+  // Retry Errors
+  RETRY_EXHAUSTED: "RETRY_EXHAUSTED",
+  RETRY_STRATEGY_INVALID: "RETRY_STRATEGY_INVALID",
+  // Strategy Errors
+  STRATEGY_INVALID: "STRATEGY_INVALID",
+  STRATEGY_CONFLICT: "STRATEGY_CONFLICT",
+  STRATEGY_EXECUTION_FAILED: "STRATEGY_EXECUTION_FAILED",
+  // Polling Errors
+  POLLING_TIMEOUT: "POLLING_TIMEOUT",
+  POLLING_CANCELLED: "POLLING_CANCELLED",
+  POLLING_INVALID_CONFIG: "POLLING_INVALID_CONFIG",
+  // PubSub Errors
+  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 Errors
+  REVALIDATION_FAILED: "REVALIDATION_FAILED",
+  REVALIDATION_IN_PROGRESS: "REVALIDATION_IN_PROGRESS",
+  // Debugger Errors
+  DEBUG_TRACKING_FAILED: "DEBUG_TRACKING_FAILED",
+  DEBUG_OVERRIDE_FAILED: "DEBUG_OVERRIDE_FAILED",
+  DEBUG_CONFLICT_DETECTED: "DEBUG_CONFLICT_DETECTED",
+  // Endpoint Errors
+  ENDPOINT_BUILD_FAILED: "ENDPOINT_BUILD_FAILED",
+  ENDPOINT_NOT_FOUND: "ENDPOINT_NOT_FOUND",
+  ENDPOINT_INVALID_CONFIG: "ENDPOINT_INVALID_CONFIG",
+  // Event Errors
+  EVENT_HANDLER_FAILED: "EVENT_HANDLER_FAILED",
+  EVENT_EMISSION_FAILED: "EVENT_EMISSION_FAILED",
+  MONITORING_FAILED: "MONITORING_FAILED",
+  CONTEXT_OPERATION_FAILED: "CONTEXT_OPERATION_FAILED",
+  // Authentication Errors
+  AUTH_TOKEN_EXPIRED: "AUTH_TOKEN_EXPIRED",
+  AUTH_UNAUTHORIZED: "AUTH_UNAUTHORIZED",
+  AUTH_FORBIDDEN: "AUTH_FORBIDDEN",
+  AUTH_INVALID_CREDENTIALS: "AUTH_INVALID_CREDENTIALS",
+  // Rate Limiting
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  // Resource Errors
+  RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
+  // System Errors
+  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
+  SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
+  EXTERNAL_SERVICE_ERROR: "EXTERNAL_SERVICE_ERROR",
+  UNKNOWN_ERROR: "UNKNOWN_ERROR",
+  // Validation Errors
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  REQUIRED_FIELD_MISSING: "REQUIRED_FIELD_MISSING",
+  INVALID_FORMAT: "INVALID_FORMAT",
+  VALIDATION_INVALID_FORMAT: "INVALID_FORMAT",
+  // Alias for compatibility
+  STRING_TOO_SHORT: "STRING_TOO_SHORT",
+  STRING_TOO_LONG: "STRING_TOO_LONG",
+  // Generic HTTP Status Mappings
+  CLIENT_ERROR: "CLIENT_ERROR",
+  SERVER_ERROR: "SERVER_ERROR",
+  // Timeout
+  TIMEOUT: "TIMEOUT"
+};
+var PACKAGE_STATUS_CODES = {
+  // Configuration errors
+  INVALID_CONFIGURATION: 1001,
+  MISSING_CONFIGURATION: 1002,
+  CONFIGURATION_CONFLICT: 1003,
+  CONFIGURATION_TRACKING_FAILED: 1004,
+  DEBUG_TRACKING_FAILED: 1005,
+  // Resource errors (internal)
+  RESOURCE_NOT_FOUND: 1010,
+  RESOURCE_ALREADY_EXISTS: 1011,
+  RESOURCE_UNAVAILABLE: 1012,
+  // Validation errors (internal)
+  INVALID_PARAMETER: 1020,
+  MISSING_PARAMETER: 1021,
+  PARAMETER_OUT_OF_RANGE: 1022,
+  // Strategy/preset errors
+  STRATEGY_NOT_FOUND: 1030,
+  PRESET_NOT_FOUND: 1031,
+  INVALID_STRATEGY: 1032,
+  // Request/Response errors
+  REQUEST_FAILED: 1035,
+  // Internal system errors
+  INITIALIZATION_FAILED: 1040,
+  OPERATION_FAILED: 1041,
+  STATE_CORRUPTION: 1042,
+  SERIALIZATION_FAILED: 1043,
+  DESERIALIZATION_FAILED: 1044,
+  CONFIGURATION_INVALID: 1045,
+  HEADER_PROCESSING_ERROR: 1046,
+  REGION_DETECTION_ERROR: 1047,
+  NETWORK_OVERRIDE_ERROR: 1048
+};
+var ERROR_DEFINITIONS = {
+  // Authentication
+  [API_ERROR_CODES.AUTH_UNAUTHORIZED]: {
+    code: API_ERROR_CODES.AUTH_UNAUTHORIZED,
+    status: po.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication
+  },
+  [API_ERROR_CODES.AUTH_FORBIDDEN]: {
+    code: API_ERROR_CODES.AUTH_FORBIDDEN,
+    status: po.FORBIDDEN,
+    category: ERROR_CATEGORY.Authorization
+  },
+  [API_ERROR_CODES.AUTH_TOKEN_EXPIRED]: {
+    code: API_ERROR_CODES.AUTH_TOKEN_EXPIRED,
+    status: po.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication
+  },
+  [API_ERROR_CODES.AUTH_INVALID_CREDENTIALS]: {
+    code: API_ERROR_CODES.AUTH_INVALID_CREDENTIALS,
+    status: po.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication
+  },
+  // Rate Limiting
+  [API_ERROR_CODES.RATE_LIMIT_EXCEEDED]: {
+    code: API_ERROR_CODES.RATE_LIMIT_EXCEEDED,
+    status: po.TOO_MANY_REQUESTS,
+    category: ERROR_CATEGORY.RateLimit
+  },
+  // Resource Errors
+  [API_ERROR_CODES.RESOURCE_NOT_FOUND]: {
+    code: API_ERROR_CODES.RESOURCE_NOT_FOUND,
+    status: po.NOT_FOUND,
+    category: ERROR_CATEGORY.NotFound
+  },
+  // System Errors
+  [API_ERROR_CODES.INTERNAL_SERVER_ERROR]: {
+    code: API_ERROR_CODES.INTERNAL_SERVER_ERROR,
+    status: po.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Server
+  },
+  [API_ERROR_CODES.SERVICE_UNAVAILABLE]: {
+    code: API_ERROR_CODES.SERVICE_UNAVAILABLE,
+    status: po.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.Server
+  },
+  [API_ERROR_CODES.EXTERNAL_SERVICE_ERROR]: {
+    code: API_ERROR_CODES.EXTERNAL_SERVICE_ERROR,
+    status: po.BAD_GATEWAY,
+    category: ERROR_CATEGORY.ExternalService
+  },
+  // Validation
+  [API_ERROR_CODES.VALIDATION_ERROR]: {
+    code: API_ERROR_CODES.VALIDATION_ERROR,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation
+  },
+  [API_ERROR_CODES.VALIDATION_FAILED]: {
+    code: API_ERROR_CODES.VALIDATION_FAILED,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation
+  },
+  [API_ERROR_CODES.REQUIRED_FIELD_MISSING]: {
+    code: API_ERROR_CODES.REQUIRED_FIELD_MISSING,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    fieldsLeft: ["field"]
+  },
+  [API_ERROR_CODES.INVALID_FORMAT]: {
+    code: API_ERROR_CODES.INVALID_FORMAT,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation
+  },
+  [API_ERROR_CODES.STRING_TOO_SHORT]: {
+    code: API_ERROR_CODES.STRING_TOO_SHORT,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    fieldsLeft: ["field", "minLength"]
+  },
+  [API_ERROR_CODES.STRING_TOO_LONG]: {
+    code: API_ERROR_CODES.STRING_TOO_LONG,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    fieldsLeft: ["field", "maxLength"]
+  },
+  // Request Errors
+  [API_ERROR_CODES.REQUEST_TIMEOUT]: {
+    code: API_ERROR_CODES.REQUEST_TIMEOUT,
+    status: po.REQUEST_TIMEOUT,
+    category: ERROR_CATEGORY.Timeout
+  },
+  [API_ERROR_CODES.REQUEST_ABORTED]: {
+    code: API_ERROR_CODES.REQUEST_ABORTED,
+    status: 0,
+    // No HTTP status for aborted
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.REQUEST_INVALID_PARAMS]: {
+    code: API_ERROR_CODES.REQUEST_INVALID_PARAMS,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.REQUEST_PREPARATION_FAILED]: {
+    code: API_ERROR_CODES.REQUEST_PREPARATION_FAILED,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Client
+  },
+  // Response Errors
+  [API_ERROR_CODES.RESPONSE_INVALID_FORMAT]: {
+    code: API_ERROR_CODES.RESPONSE_INVALID_FORMAT,
+    status: po.UNPROCESSABLE_ENTITY,
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.RESPONSE_PARSING_FAILED]: {
+    code: API_ERROR_CODES.RESPONSE_PARSING_FAILED,
+    status: po.UNPROCESSABLE_ENTITY,
+    category: ERROR_CATEGORY.Client
+  },
+  // Network
+  [API_ERROR_CODES.NETWORK_ERROR]: {
+    code: API_ERROR_CODES.NETWORK_ERROR,
+    status: po.BAD_GATEWAY,
+    category: ERROR_CATEGORY.Network
+  },
+  [API_ERROR_CODES.NETWORK_TIMEOUT]: {
+    code: API_ERROR_CODES.NETWORK_TIMEOUT,
+    status: po.GATEWAY_TIMEOUT,
+    category: ERROR_CATEGORY.Timeout
+  },
+  [API_ERROR_CODES.NETWORK_CONNECTION_FAILED]: {
+    code: API_ERROR_CODES.NETWORK_CONNECTION_FAILED,
+    status: 0,
+    // No HTTP status for connection failure
+    category: ERROR_CATEGORY.Network
+  },
+  [API_ERROR_CODES.NETWORK_OFFLINE]: {
+    code: API_ERROR_CODES.NETWORK_OFFLINE,
+    status: 0,
+    // No HTTP status for offline
+    category: ERROR_CATEGORY.Network
+  },
+  [API_ERROR_CODES.NETWORK_DNS_FAILED]: {
+    code: API_ERROR_CODES.NETWORK_DNS_FAILED,
+    status: 0,
+    // No HTTP status for DNS failure
+    category: ERROR_CATEGORY.Network
+  },
+  // Server
+  [API_ERROR_CODES.SERVER_ERROR]: {
+    code: API_ERROR_CODES.SERVER_ERROR,
+    status: po.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Server
+  },
+  // Client
+  [API_ERROR_CODES.CLIENT_ERROR]: {
+    code: API_ERROR_CODES.CLIENT_ERROR,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.CLIENT_CANCELLED]: {
+    code: API_ERROR_CODES.CLIENT_CANCELLED,
+    status: 0,
+    // No HTTP status for cancelled
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED]: {
+    code: API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
+    status: 0,
+    // No HTTP status for initialization failure
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.CLIENT_INVALID_CONFIG]: {
+    code: API_ERROR_CODES.CLIENT_INVALID_CONFIG,
+    status: 0,
+    // No HTTP status for configuration errors
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.CLIENT_MISSING_BASE_URL]: {
+    code: API_ERROR_CODES.CLIENT_MISSING_BASE_URL,
+    status: 0,
+    // No HTTP status for configuration errors
+    category: ERROR_CATEGORY.Client
+  },
+  [API_ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
+    code: API_ERROR_CODES.CONFIG_VALIDATION_FAILED,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation
+  },
+  [API_ERROR_CODES.HEADER_PROCESSING_FAILED]: {
+    code: API_ERROR_CODES.HEADER_PROCESSING_FAILED,
+    status: po.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Headers
+  },
+  [API_ERROR_CODES.NETWORK_OVERRIDE_FAILED]: {
+    code: API_ERROR_CODES.NETWORK_OVERRIDE_FAILED,
+    status: po.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Network
+  },
+  // Headers
+  [API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED]: {
+    code: API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Headers
+  },
+  [API_ERROR_CODES.HEADERS_VALIDATION_FAILED]: {
+    code: API_ERROR_CODES.HEADERS_VALIDATION_FAILED,
+    status: po.BAD_REQUEST,
+    category: ERROR_CATEGORY.Headers
+  },
+  [API_ERROR_CODES.HEADERS_MERGE_CONFLICT]: {
+    code: API_ERROR_CODES.HEADERS_MERGE_CONFLICT,
+    status: po.CONFLICT,
+    category: ERROR_CATEGORY.Headers
+  },
+  // Cache
+  [API_ERROR_CODES.CACHE_STORAGE_FAILED]: {
+    code: API_ERROR_CODES.CACHE_STORAGE_FAILED,
+    status: 0,
+    // No HTTP status for cache failures
+    category: ERROR_CATEGORY.Cache
+  },
+  [API_ERROR_CODES.CACHE_RETRIEVAL_FAILED]: {
+    code: API_ERROR_CODES.CACHE_RETRIEVAL_FAILED,
+    status: 0,
+    // No HTTP status for cache failures
+    category: ERROR_CATEGORY.Cache
+  },
+  [API_ERROR_CODES.CACHE_INVALIDATION_FAILED]: {
+    code: API_ERROR_CODES.CACHE_INVALIDATION_FAILED,
+    status: 0,
+    // No HTTP status for cache failures
+    category: ERROR_CATEGORY.Cache
+  },
+  // Retry
+  [API_ERROR_CODES.RETRY_EXHAUSTED]: {
+    code: API_ERROR_CODES.RETRY_EXHAUSTED,
+    status: po.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.Retry
+  },
+  [API_ERROR_CODES.RETRY_STRATEGY_INVALID]: {
+    code: API_ERROR_CODES.RETRY_STRATEGY_INVALID,
+    status: 0,
+    // No HTTP status for strategy errors
+    category: ERROR_CATEGORY.Retry
+  },
+  // Strategy
+  [API_ERROR_CODES.STRATEGY_INVALID]: {
+    code: API_ERROR_CODES.STRATEGY_INVALID,
+    status: 0,
+    // No HTTP status for strategy errors
+    category: ERROR_CATEGORY.Strategy
+  },
+  [API_ERROR_CODES.STRATEGY_CONFLICT]: {
+    code: API_ERROR_CODES.STRATEGY_CONFLICT,
+    status: po.CONFLICT,
+    category: ERROR_CATEGORY.Strategy
+  },
+  // Regional
+  [API_ERROR_CODES.REGIONAL_PRESET_NOT_FOUND]: {
+    code: API_ERROR_CODES.REGIONAL_PRESET_NOT_FOUND,
+    status: 0,
+    // No HTTP status for regional preset errors
+    category: ERROR_CATEGORY.Regional
+  },
+  [API_ERROR_CODES.REGION_DETECTION_FAILED]: {
+    code: API_ERROR_CODES.REGION_DETECTION_FAILED,
+    status: po.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Regional
+  },
+  // Timeout
+  [API_ERROR_CODES.TIMEOUT]: {
+    code: API_ERROR_CODES.TIMEOUT,
+    status: po.REQUEST_TIMEOUT,
+    category: ERROR_CATEGORY.Timeout
+  },
+  // Unknown
+  [API_ERROR_CODES.UNKNOWN_ERROR]: {
+    code: API_ERROR_CODES.UNKNOWN_ERROR,
+    status: po.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Unknown
+  }
+};
+
+// src/api/queue/enums.ts
+var PRIORITY_LEVEL = {
+  /** Critical priority - highest urgency (0) */
+  CRITICAL: 0,
+  /** High priority (1) */
+  HIGH: 1,
+  /** Medium priority (2) */
+  MEDIUM: 2,
+  /** Normal priority (3) */
+  NORMAL: 3,
+  /** Low priority (4) */
+  LOW: 4,
+  /** Idle priority - lowest urgency (5) */
+  IDLE: 5
+};
+
+// src/api/headers/enum.ts
+var DATA_SAVER_PRESETS = {
+  performance: "offline",
+  cache: "aggressive",
+  retry: "conservative",
+  revalidation: "static"
+};
+var CLIENT_HINT_HEADERS = {
+  SAVE_DATA: "save-data",
+  ECT: "ect",
+  RTT: "rtt",
+  DOWNLINK: "downlink",
+  DEVICE_MEMORY: "device-memory",
+  ACCEPT_CH: "Accept-CH",
+  ACCEPT_CH_LIFETIME: "Accept-CH-Lifetime"
+};
+var VALIDATION_RANGES = {
+  RTT: { MIN: 0, MAX: 1e4 },
+  // 0-10 seconds
+  DOWNLINK: { MIN: 0, MAX: 1e4 },
+  // 0-10 Gbps
+  DEVICE_MEMORY: { MIN: 0, MAX: 128 }
+  // 0-128 GB
+};
+
+// src/api/network/enums.ts
+var NETWORK_QUALITY = /* @__PURE__ */ ((NETWORK_QUALITY2) => {
+  NETWORK_QUALITY2["EXCELLENT"] = "excellent";
+  NETWORK_QUALITY2["GOOD"] = "good";
+  NETWORK_QUALITY2["FAIR"] = "fair";
+  NETWORK_QUALITY2["POOR"] = "poor";
+  NETWORK_QUALITY2["OFFLINE"] = "offline";
+  NETWORK_QUALITY2["UNKNOWN"] = "unknown";
+  return NETWORK_QUALITY2;
+})(NETWORK_QUALITY || {});
+var EVENT_PRIORITY_MAP = {
+  // Critical events
+  error: "critical",
+  onNetworkError: "critical",
+  critical: "critical",
+  // High priority events
+  config: "high",
+  auth: "high",
+  conflict: "high",
+  // Normal priority events
+  network: "normal",
+  headers: "normal",
+  performance: "normal",
+  // Low priority events
+  debug: "low",
+  metrics: "low",
+  tracking: "low"
+};
+var NetworkPresetNames = {
+  OFFLINE_FIRST: "offline-first",
+  DATA_SAVER: "data-saver",
+  SLOW_CONNECTION: "slow-connection",
+  FAIR_CONNECTION: "fair-connection",
+  GOOD_CONNECTION: "good-connection",
+  EXCELLENT_CONNECTION: "excellent-connection",
+  AGGRESSIVE_CACHE: "aggressive-cache",
+  REALTIME: "realtime",
+  BACKGROUND_SYNC: "background-sync"
+};
+var NETWORK_CONFIDENCE_LEVELS = {
+  /** Excellent confidence (90%) */
+  EXCELLENT: 0.9,
+  /** High confidence (80%) */
+  HIGH: 0.8,
+  /** Medium confidence (70%) */
+  MEDIUM: 0.7,
+  /** Low confidence (50%) */
+  LOW: 0.5,
+  /** Threshold for high confidence classification */
+  HIGH_THRESHOLD: 0.7,
+  /** Threshold for medium confidence classification */
+  MEDIUM_THRESHOLD: 0.4
+};
+var SPEED_THRESHOLDS = {
+  EXCELLENT: 10,
+  GOOD: 2,
+  FAIR: 0.5
+};
+var RTT_THRESHOLDS = {
+  EXCELLENT: 50,
+  GOOD: 150,
+  FAIR: 400
+};
+var DEFAULT_THRESHOLDS = {
+  excellentRTT: RTT_THRESHOLDS.EXCELLENT,
+  goodRTT: RTT_THRESHOLDS.GOOD,
+  fairRTT: RTT_THRESHOLDS.FAIR,
+  excellentSpeed: SPEED_THRESHOLDS.EXCELLENT,
+  goodSpeed: SPEED_THRESHOLDS.GOOD,
+  fairSpeed: SPEED_THRESHOLDS.FAIR
+};
+
+// src/api/debugger/enums.ts
+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",
+  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"
+};
+var HISTORY_TYPES = {
+  CONFIG: "config",
+  HEADER: "header",
+  NETWORK: "network",
+  PERFORMANCE: "performance",
+  EVENT: "event",
+  EVENT_OPERATION: "event_operation"
+};
+var HEADER_STAGES = {
+  BASE: "base",
+  ENRICHED: "enriched",
+  INTERCEPTOR: "interceptor",
+  FINAL: "final"
+};
+var UPDATE_STRATEGIES = {
+  MERGE: "merge",
+  REPLACE: "replace",
+  TEMPORARY: "temporary"
+};
+var UNIFIED_OPERATIONS = {
+  ...FACTORY_OPERATIONS,
+  ...EVENT_OPERATIONS,
+  ...QUEUE_OPERATIONS
+};
+
+// src/api/client/enum.ts
+var EVENT_CONSTANTS = {
+  DEBUG_INFO_INTERVAL_MULTIPLIER: 5,
+  IMPACT_THRESHOLDS: {
+    NONE: 90,
+    LOW: 70,
+    MEDIUM: 50,
+    HIGH: 30
+  }
+};
+
+// src/api/regional/enum.ts
+var REGION_STORAGE_KEY = "@plyaz/api:userRegion";
+var REGIONAL_CONFIDENCE_LEVELS = {
+  CDN_HEADER: 0.95,
+  TIMEZONE_DIRECT: 0.9,
+  TIMEZONE_PREFIX: 0.8,
+  HIGH: 0.8,
+  LOCALE_DIRECT: 0.7,
+  MEDIUM: 0.7,
+  GEOLOCATION: 0.6,
+  LOCALE_LANGUAGE: 0.5,
+  LOW: 0.5,
+  GLOBAL_FALLBACK: 0.3,
+  UNKNOWN_FALLBACK: 0.2,
+  FINAL_FALLBACK: 0.1
+};
+var COORDINATES = {
+  EU: {
+    MIN_LAT: 35,
+    MAX_LAT: 70,
+    MIN_LON: -10,
+    MAX_LON: 40
+  },
+  US: {
+    MIN_LAT: 25,
+    MAX_LAT: 50,
+    MIN_LON: -125,
+    MAX_LON: -65
+  },
+  US_WEST: {
+    MIN_LAT: 32,
+    MAX_LAT: 42,
+    MIN_LON: -125,
+    MAX_LON: -114
+  },
+  US_EAST: {
+    MIN_LAT: 38,
+    MAX_LAT: 45,
+    MIN_LON: -80,
+    MAX_LON: -70
+  },
+  ASIA: {
+    MIN_LAT: 18,
+    MAX_LAT: 54,
+    MIN_LON: 73,
+    MAX_LON: 135
+  },
+  JAPAN: {
+    MIN_LAT: 30,
+    MAX_LAT: 46,
+    MIN_LON: 129,
+    MAX_LON: 146
+  }
+};
+var HOURS_PER_DAY = 24;
+var MINUTES_PER_HOUR = 60;
+var SECONDS_PER_MINUTE = 60;
+var MS_PER_SECOND = 1e3;
+var CACHE_DURATION_MS = HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MS_PER_SECOND;
+var REGION_TO_PRESET = {
+  eu: "gdpr",
+  us: "ccpa",
+  // Map US to CCPA (California compliance)
+  "us-ca": "ccpa",
+  cn: "pipl",
+  jp: "appi",
+  ca: "global",
+  // Canada uses global preset
+  global: "global"
+};
+
+// src/api/utils/enums.ts
+var CORRELATION_TYPE = /* @__PURE__ */ ((CORRELATION_TYPE2) => {
+  CORRELATION_TYPE2["NETWORK"] = "net";
+  CORRELATION_TYPE2["API"] = "api";
+  CORRELATION_TYPE2["SESSION"] = "session";
+  CORRELATION_TYPE2["TRANSACTION"] = "txn";
+  CORRELATION_TYPE2["EVENT"] = "evt";
+  CORRELATION_TYPE2["TRACE"] = "trace";
+  CORRELATION_TYPE2["GENERIC"] = "corr";
+  return CORRELATION_TYPE2;
+})(CORRELATION_TYPE || {});
+
+// src/api/pubsub/enum.ts
+var PUB_SUB_EVENT = {
+  CacheUpdate: "cache:update",
+  CacheDelete: "cache:delete",
+  CacheRevalidate: "cache:revalidate",
+  RequestStart: "request:start",
+  RequestSuccess: "request:success",
+  RequestError: "request:error",
+  RequestAbort: "request:abort"
+};
+
+exports.ALL_EVENTS = ALL_EVENTS;
+exports.API_ERROR_CODES = API_ERROR_CODES;
+exports.CACHE_DURATION_MS = CACHE_DURATION_MS;
+exports.CACHE_EVENTS = CACHE_EVENTS;
+exports.CLIENT_EVENTS = CLIENT_EVENTS;
+exports.CLIENT_HINT_HEADERS = CLIENT_HINT_HEADERS;
+exports.CONFIG_EVENTS = CONFIG_EVENTS;
+exports.COORDINATES = COORDINATES;
+exports.CORRELATION_TYPE = CORRELATION_TYPE;
+exports.DATA_SAVER_PRESETS = DATA_SAVER_PRESETS;
+exports.DEBUGGER_CONFIG_SOURCES = DEBUGGER_CONFIG_SOURCES;
+exports.DEBUG_EVENTS = DEBUG_EVENTS;
+exports.DEFAULT_THRESHOLDS = DEFAULT_THRESHOLDS;
+exports.ERROR_DEFINITIONS = ERROR_DEFINITIONS;
+exports.ERROR_EVENTS = ERROR_EVENTS;
+exports.ERROR_FIELDS = ERROR_FIELDS;
+exports.EVENTS_CONFIG_SOURCES = EVENTS_CONFIG_SOURCES;
+exports.EVENT_CONSTANTS = EVENT_CONSTANTS;
+exports.EVENT_NAMESPACES = EVENT_NAMESPACES;
+exports.EVENT_OPERATIONS = EVENT_OPERATIONS;
+exports.EVENT_PRIORITY_MAP = EVENT_PRIORITY_MAP;
+exports.EVENT_SCOPES = EVENT_SCOPES;
+exports.EVENT_SCOPES_WITH_TEMPORARY = EVENT_SCOPES_WITH_TEMPORARY;
+exports.FACTORY_OPERATIONS = FACTORY_OPERATIONS;
+exports.HANDLER_SCOPES = HANDLER_SCOPES;
+exports.HEADER_EVENTS = HEADER_EVENTS;
+exports.HEADER_STAGES = HEADER_STAGES;
+exports.HISTORY_TYPES = HISTORY_TYPES;
+exports.NETWORK_CONFIDENCE_LEVELS = NETWORK_CONFIDENCE_LEVELS;
+exports.NETWORK_EVENTS = NETWORK_EVENTS;
+exports.NETWORK_QUALITY = NETWORK_QUALITY;
+exports.NetworkPresetNames = NetworkPresetNames;
+exports.OPERATIONS = OPERATIONS;
+exports.PACKAGE_STATUS_CODES = PACKAGE_STATUS_CODES;
+exports.PERFORMANCE_EVENTS = PERFORMANCE_EVENTS;
+exports.PRIORITY_LEVEL = PRIORITY_LEVEL;
+exports.PUB_SUB_EVENT = PUB_SUB_EVENT;
+exports.QUEUE_OPERATIONS = QUEUE_OPERATIONS;
+exports.REGIONAL_CONFIDENCE_LEVELS = REGIONAL_CONFIDENCE_LEVELS;
+exports.REGION_STORAGE_KEY = REGION_STORAGE_KEY;
+exports.REGION_TO_PRESET = REGION_TO_PRESET;
+exports.RTT_THRESHOLDS = RTT_THRESHOLDS;
+exports.SPEED_THRESHOLDS = SPEED_THRESHOLDS;
+exports.STORAGE_TYPES = STORAGE_TYPES;
+exports.UNIFIED_OPERATIONS = UNIFIED_OPERATIONS;
+exports.UPDATE_STRATEGIES = UPDATE_STRATEGIES;
+exports.VALIDATION_RANGES = VALIDATION_RANGES;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map