@serve.zone/dcrouter 11.0.27 → 11.0.29

package/dist_ts/errors/base.errors.d.ts

@@ -0,0 +1,224 @@
+import { ErrorSeverity, ErrorCategory, ErrorRecoverability } from './error.codes.js';
+/**
+ * Context information added to structured errors
+ */
+export interface IErrorContext {
+    /** Component or service where the error occurred */
+    component?: string;
+    /** Operation that was being performed */
+    operation?: string;
+    /** Unique request ID if available */
+    requestId?: string;
+    /** Error occurred at timestamp */
+    timestamp?: number;
+    /** User-visible message (safe to display to end-users) */
+    userMessage?: string;
+    /** Additional structured data for debugging */
+    data?: Record<string, any>;
+    /** Related entity IDs if applicable */
+    entity?: {
+        type: string;
+        id: string | number;
+    };
+    /** Stack trace (if enabled in configuration) */
+    stack?: string;
+    /** Retry information if applicable */
+    retry?: {
+        /** Maximum number of retries allowed */
+        maxRetries?: number;
+        /** Current retry count */
+        currentRetry?: number;
+        /** Next retry timestamp */
+        nextRetryAt?: number;
+        /** Delay between retries (in ms) */
+        retryDelay?: number;
+    };
+}
+/**
+ * Base class for all errors in the Platform Service
+ * Adds structured error information, logging, and error tracking
+ */
+export declare class PlatformError extends Error {
+    /** Error code identifying the specific error type */
+    readonly code: string;
+    /** Error severity level */
+    readonly severity: ErrorSeverity;
+    /** Error category for grouping related errors */
+    readonly category: ErrorCategory;
+    /** Whether the error can be recovered from automatically */
+    readonly recoverability: ErrorRecoverability;
+    /** Additional context information */
+    readonly context: IErrorContext;
+    /**
+     * Creates a new PlatformError
+     *
+     * @param message Error message
+     * @param code Error code from error.codes.ts
+     * @param severity Error severity level
+     * @param category Error category
+     * @param recoverability Error recoverability indication
+     * @param context Additional context information
+     */
+    constructor(message: string, code: string, severity?: ErrorSeverity, category?: ErrorCategory, recoverability?: ErrorRecoverability, context?: IErrorContext);
+    /**
+     * Logs the error using the platform logger
+     */
+    private logError;
+    /**
+     * Maps severity levels to log levels
+     */
+    private getLogLevelFromSeverity;
+    /**
+     * Returns a JSON representation of the error
+     */
+    toJSON(): Record<string, any>;
+    /**
+     * Creates an instance with retry information
+     *
+     * @param maxRetries Maximum number of retries
+     * @param currentRetry Current retry count
+     * @param retryDelay Delay between retries in ms
+     */
+    withRetry(maxRetries: number, currentRetry?: number, retryDelay?: number): PlatformError;
+    /**
+     * Protected method to create a new instance with updated context
+     * Subclasses can override this to handle their own constructor signatures
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+    /**
+     * Checks if the error should be retried based on retry information
+     */
+    shouldRetry(): boolean;
+    /**
+     * Returns a user-friendly message that is safe to display to end users
+     */
+    getUserMessage(): string;
+}
+/**
+ * Error class for validation errors
+ */
+export declare class ValidationError extends PlatformError {
+    /**
+     * Creates a new validation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ValidationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for configuration errors
+ */
+export declare class ConfigurationError extends PlatformError {
+    /**
+     * Creates a new configuration error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ConfigurationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for network-related errors
+ */
+export declare class NetworkError extends PlatformError {
+    /**
+     * Creates a new network error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle NetworkError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for resource availability errors (rate limits, quotas)
+ */
+export declare class ResourceError extends PlatformError {
+    /**
+     * Creates a new resource error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ResourceError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for authentication/authorization errors
+ */
+export declare class AuthenticationError extends PlatformError {
+    /**
+     * Creates a new authentication error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle AuthenticationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for operation errors (API calls, processing)
+ */
+export declare class OperationError extends PlatformError {
+    /**
+     * Creates a new operation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle OperationError's constructor signature
+     */
+    protected createWithContext(context: IErrorContext): PlatformError;
+}
+/**
+ * Error class for critical system errors
+ */
+export declare class SystemError extends PlatformError {
+    /**
+     * Creates a new system error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message: string, code: string, context?: IErrorContext);
+}
+/**
+ * Helper to get the appropriate error class based on error category
+ *
+ * @param category Error category
+ * @returns The appropriate error class
+ */
+export declare function getErrorClassForCategory(category: ErrorCategory): any;

package/dist_ts/errors/base.errors.js

@@ -0,0 +1,320 @@
+import { ErrorSeverity, ErrorCategory, ErrorRecoverability } from './error.codes.js';
+import { logger } from '../logger.js';
+/**
+ * Base class for all errors in the Platform Service
+ * Adds structured error information, logging, and error tracking
+ */
+export class PlatformError extends Error {
+    /** Error code identifying the specific error type */
+    code;
+    /** Error severity level */
+    severity;
+    /** Error category for grouping related errors */
+    category;
+    /** Whether the error can be recovered from automatically */
+    recoverability;
+    /** Additional context information */
+    context;
+    /**
+     * Creates a new PlatformError
+     *
+     * @param message Error message
+     * @param code Error code from error.codes.ts
+     * @param severity Error severity level
+     * @param category Error category
+     * @param recoverability Error recoverability indication
+     * @param context Additional context information
+     */
+    constructor(message, code, severity = ErrorSeverity.MEDIUM, category = ErrorCategory.OTHER, recoverability = ErrorRecoverability.NON_RECOVERABLE, context = {}) {
+        super(message);
+        // Set error metadata
+        this.name = this.constructor.name;
+        this.code = code;
+        this.severity = severity;
+        this.category = category;
+        this.recoverability = recoverability;
+        // Add timestamp if not provided
+        this.context = {
+            ...context,
+            timestamp: context.timestamp || Date.now(),
+        };
+        // Capture stack trace
+        Error.captureStackTrace(this, this.constructor);
+        // Log the error automatically unless explicitly disabled
+        if (!context.data?.skipLogging) {
+            this.logError();
+        }
+    }
+    /**
+     * Logs the error using the platform logger
+     */
+    logError() {
+        const logLevel = this.getLogLevelFromSeverity();
+        // Construct structured log entry
+        const logData = {
+            error_code: this.code,
+            error_name: this.name,
+            severity: this.severity,
+            category: this.category,
+            recoverability: this.recoverability,
+            ...this.context
+        };
+        // Log with appropriate level
+        logger.log(logLevel, this.message, logData);
+    }
+    /**
+     * Maps severity levels to log levels
+     */
+    getLogLevelFromSeverity() {
+        switch (this.severity) {
+            case ErrorSeverity.CRITICAL:
+            case ErrorSeverity.HIGH:
+                return 'error';
+            case ErrorSeverity.MEDIUM:
+                return 'warn';
+            case ErrorSeverity.LOW:
+                return 'info';
+            case ErrorSeverity.INFO:
+                return 'debug';
+            default:
+                return 'error';
+        }
+    }
+    /**
+     * Returns a JSON representation of the error
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            severity: this.severity,
+            category: this.category,
+            recoverability: this.recoverability,
+            context: this.context,
+            stack: process.env.NODE_ENV !== 'production' ? this.stack : undefined
+        };
+    }
+    /**
+     * Creates an instance with retry information
+     *
+     * @param maxRetries Maximum number of retries
+     * @param currentRetry Current retry count
+     * @param retryDelay Delay between retries in ms
+     */
+    withRetry(maxRetries, currentRetry = 0, retryDelay = 1000) {
+        const nextRetryAt = Date.now() + retryDelay;
+        // Clone the error with updated context
+        const newContext = {
+            ...this.context,
+            retry: {
+                maxRetries,
+                currentRetry,
+                nextRetryAt,
+                retryDelay
+            }
+        };
+        // Create a new instance using the protected method that subclasses can override
+        const newError = this.createWithContext(newContext);
+        // Update recoverability if we can retry
+        if (currentRetry < maxRetries && newError.recoverability === ErrorRecoverability.NON_RECOVERABLE) {
+            newError.recoverability = ErrorRecoverability.MAYBE_RECOVERABLE;
+        }
+        return newError;
+    }
+    /**
+     * Protected method to create a new instance with updated context
+     * Subclasses can override this to handle their own constructor signatures
+     */
+    createWithContext(context) {
+        // Default implementation for PlatformError
+        return new this.constructor(this.message, this.code, this.severity, this.category, this.recoverability, context);
+    }
+    /**
+     * Checks if the error should be retried based on retry information
+     */
+    shouldRetry() {
+        const { retry } = this.context;
+        if (!retry)
+            return false;
+        return retry.currentRetry < retry.maxRetries;
+    }
+    /**
+     * Returns a user-friendly message that is safe to display to end users
+     */
+    getUserMessage() {
+        return this.context.userMessage || 'An unexpected error occurred.';
+    }
+}
+/**
+ * Error class for validation errors
+ */
+export class ValidationError extends PlatformError {
+    /**
+     * Creates a new validation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.LOW, ErrorCategory.VALIDATION, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ValidationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for configuration errors
+ */
+export class ConfigurationError extends PlatformError {
+    /**
+     * Creates a new configuration error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.CONFIGURATION, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ConfigurationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for network-related errors
+ */
+export class NetworkError extends PlatformError {
+    /**
+     * Creates a new network error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.CONNECTIVITY, ErrorRecoverability.MAYBE_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle NetworkError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for resource availability errors (rate limits, quotas)
+ */
+export class ResourceError extends PlatformError {
+    /**
+     * Creates a new resource error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.RESOURCE, ErrorRecoverability.MAYBE_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle ResourceError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for authentication/authorization errors
+ */
+export class AuthenticationError extends PlatformError {
+    /**
+     * Creates a new authentication error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.HIGH, ErrorCategory.AUTHENTICATION, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle AuthenticationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for operation errors (API calls, processing)
+ */
+export class OperationError extends PlatformError {
+    /**
+     * Creates a new operation error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.MEDIUM, ErrorCategory.OPERATION, ErrorRecoverability.MAYBE_RECOVERABLE, context);
+    }
+    /**
+     * Creates a new instance with updated context
+     * Overrides the base implementation to handle OperationError's constructor signature
+     */
+    createWithContext(context) {
+        return new this.constructor(this.message, this.code, context);
+    }
+}
+/**
+ * Error class for critical system errors
+ */
+export class SystemError extends PlatformError {
+    /**
+     * Creates a new system error
+     *
+     * @param message Error message
+     * @param code Error code
+     * @param context Additional context
+     */
+    constructor(message, code, context = {}) {
+        super(message, code, ErrorSeverity.CRITICAL, ErrorCategory.OTHER, ErrorRecoverability.NON_RECOVERABLE, context);
+    }
+}
+/**
+ * Helper to get the appropriate error class based on error category
+ *
+ * @param category Error category
+ * @returns The appropriate error class
+ */
+export function getErrorClassForCategory(category) {
+    switch (category) {
+        case ErrorCategory.VALIDATION:
+            return ValidationError;
+        case ErrorCategory.CONFIGURATION:
+            return ConfigurationError;
+        case ErrorCategory.CONNECTIVITY:
+            return NetworkError;
+        case ErrorCategory.RESOURCE:
+            return ResourceError;
+        case ErrorCategory.AUTHENTICATION:
+            return AuthenticationError;
+        case ErrorCategory.OPERATION:
+            return OperationError;
+        default:
+            return PlatformError;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.errors.js","sourceRoot":"","sources":["../../../ts/errors/base.errors.ts"],"names":[],"mappings":"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"}

package/dist_ts/errors/error.codes.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Platform Service Error Codes
+ *
+ * This file contains all error codes used across the platform service.
+ *
+ * Format: PREFIX_ERROR_TYPE
+ * - PREFIX: Component/domain prefix (e.g., EMAIL, MTA, SMS)
+ * - ERROR_TYPE: Specific error type within the domain
+ */
+export declare const PLATFORM_INITIALIZATION_ERROR = "PLATFORM_INITIALIZATION_ERROR";
+export declare const PLATFORM_CONFIGURATION_ERROR = "PLATFORM_CONFIGURATION_ERROR";
+export declare const PLATFORM_OPERATION_ERROR = "PLATFORM_OPERATION_ERROR";
+export declare const PLATFORM_NOT_IMPLEMENTED = "PLATFORM_NOT_IMPLEMENTED";
+export declare const PLATFORM_NOT_SUPPORTED = "PLATFORM_NOT_SUPPORTED";
+export declare const PLATFORM_SERVICE_UNAVAILABLE = "PLATFORM_SERVICE_UNAVAILABLE";
+export declare const EMAIL_SERVICE_ERROR = "EMAIL_SERVICE_ERROR";
+export declare const EMAIL_TEMPLATE_ERROR = "EMAIL_TEMPLATE_ERROR";
+export declare const EMAIL_VALIDATION_ERROR = "EMAIL_VALIDATION_ERROR";
+export declare const EMAIL_SEND_ERROR = "EMAIL_SEND_ERROR";
+export declare const EMAIL_RECEIVE_ERROR = "EMAIL_RECEIVE_ERROR";
+export declare const EMAIL_ATTACHMENT_ERROR = "EMAIL_ATTACHMENT_ERROR";
+export declare const EMAIL_PARSE_ERROR = "EMAIL_PARSE_ERROR";
+export declare const EMAIL_RATE_LIMIT_EXCEEDED = "EMAIL_RATE_LIMIT_EXCEEDED";
+export declare const MTA_CONNECTION_ERROR = "MTA_CONNECTION_ERROR";
+export declare const MTA_AUTHENTICATION_ERROR = "MTA_AUTHENTICATION_ERROR";
+export declare const MTA_DELIVERY_ERROR = "MTA_DELIVERY_ERROR";
+export declare const MTA_CONFIGURATION_ERROR = "MTA_CONFIGURATION_ERROR";
+export declare const MTA_DNS_ERROR = "MTA_DNS_ERROR";
+export declare const MTA_TIMEOUT_ERROR = "MTA_TIMEOUT_ERROR";
+export declare const MTA_PROTOCOL_ERROR = "MTA_PROTOCOL_ERROR";
+export declare const BOUNCE_PROCESSING_ERROR = "BOUNCE_PROCESSING_ERROR";
+export declare const BOUNCE_STORAGE_ERROR = "BOUNCE_STORAGE_ERROR";
+export declare const BOUNCE_CLASSIFICATION_ERROR = "BOUNCE_CLASSIFICATION_ERROR";
+export declare const AUTH_SPF_ERROR = "AUTH_SPF_ERROR";
+export declare const AUTH_DKIM_ERROR = "AUTH_DKIM_ERROR";
+export declare const AUTH_DMARC_ERROR = "AUTH_DMARC_ERROR";
+export declare const AUTH_KEY_ERROR = "AUTH_KEY_ERROR";
+export declare const SCAN_ANALYSIS_ERROR = "SCAN_ANALYSIS_ERROR";
+export declare const SCAN_MALWARE_DETECTED = "SCAN_MALWARE_DETECTED";
+export declare const SCAN_PHISHING_DETECTED = "SCAN_PHISHING_DETECTED";
+export declare const SCAN_CONTENT_REJECTED = "SCAN_CONTENT_REJECTED";
+export declare const REPUTATION_CHECK_ERROR = "REPUTATION_CHECK_ERROR";
+export declare const REPUTATION_DATA_ERROR = "REPUTATION_DATA_ERROR";
+export declare const REPUTATION_BLOCKLIST_ERROR = "REPUTATION_BLOCKLIST_ERROR";
+export declare const REPUTATION_UPDATE_ERROR = "REPUTATION_UPDATE_ERROR";
+export declare const WARMUP_ALLOCATION_ERROR = "WARMUP_ALLOCATION_ERROR";
+export declare const WARMUP_LIMIT_EXCEEDED = "WARMUP_LIMIT_EXCEEDED";
+export declare const WARMUP_SCHEDULE_ERROR = "WARMUP_SCHEDULE_ERROR";
+export declare const NETWORK_CONNECTION_ERROR = "NETWORK_CONNECTION_ERROR";
+export declare const NETWORK_TIMEOUT = "NETWORK_TIMEOUT";
+export declare const NETWORK_DNS_ERROR = "NETWORK_DNS_ERROR";
+export declare const NETWORK_TLS_ERROR = "NETWORK_TLS_ERROR";
+export declare const QUEUE_FULL_ERROR = "QUEUE_FULL_ERROR";
+export declare const QUEUE_PROCESSING_ERROR = "QUEUE_PROCESSING_ERROR";
+export declare const QUEUE_PERSISTENCE_ERROR = "QUEUE_PERSISTENCE_ERROR";
+export declare const QUEUE_ITEM_NOT_FOUND = "QUEUE_ITEM_NOT_FOUND";
+export declare const DCR_ROUTING_ERROR = "DCR_ROUTING_ERROR";
+export declare const DCR_CONFIGURATION_ERROR = "DCR_CONFIGURATION_ERROR";
+export declare const DCR_PROXY_ERROR = "DCR_PROXY_ERROR";
+export declare const DCR_DOMAIN_ERROR = "DCR_DOMAIN_ERROR";
+export declare const SMS_SERVICE_ERROR = "SMS_SERVICE_ERROR";
+export declare const SMS_SEND_ERROR = "SMS_SEND_ERROR";
+export declare const SMS_VALIDATION_ERROR = "SMS_VALIDATION_ERROR";
+export declare const SMS_RATE_LIMIT_EXCEEDED = "SMS_RATE_LIMIT_EXCEEDED";
+export declare const STORAGE_WRITE_ERROR = "STORAGE_WRITE_ERROR";
+export declare const STORAGE_READ_ERROR = "STORAGE_READ_ERROR";
+export declare const STORAGE_DELETE_ERROR = "STORAGE_DELETE_ERROR";
+export declare const STORAGE_QUOTA_EXCEEDED = "STORAGE_QUOTA_EXCEEDED";
+export declare const RULE_VALIDATION_ERROR = "RULE_VALIDATION_ERROR";
+export declare const RULE_EXECUTION_ERROR = "RULE_EXECUTION_ERROR";
+export declare const RULE_NOT_FOUND = "RULE_NOT_FOUND";
+export declare enum ErrorSeverity {
+    /** Critical errors that require immediate attention */
+    CRITICAL = "CRITICAL",
+    /** High-impact errors that may affect service functioning */
+    HIGH = "HIGH",
+    /** Medium-impact errors that cause partial degradation */
+    MEDIUM = "MEDIUM",
+    /** Low-impact errors that have minimal or local impact */
+    LOW = "LOW",
+    /** Informational errors that are not problematic */
+    INFO = "INFO"
+}
+export declare enum ErrorCategory {
+    /** Errors related to configuration */
+    CONFIGURATION = "CONFIGURATION",
+    /** Errors related to network connectivity */
+    CONNECTIVITY = "CONNECTIVITY",
+    /** Errors related to authentication/authorization */
+    AUTHENTICATION = "AUTHENTICATION",
+    /** Errors related to data validation */
+    VALIDATION = "VALIDATION",
+    /** Errors related to resource availability */
+    RESOURCE = "RESOURCE",
+    /** Errors related to service operations */
+    OPERATION = "OPERATION",
+    /** Errors related to third-party integrations */
+    INTEGRATION = "INTEGRATION",
+    /** Errors related to security */
+    SECURITY = "SECURITY",
+    /** Errors related to data storage */
+    STORAGE = "STORAGE",
+    /** Errors that don't fit into other categories */
+    OTHER = "OTHER"
+}
+export declare enum ErrorRecoverability {
+    /** Error cannot be automatically recovered from */
+    NON_RECOVERABLE = "NON_RECOVERABLE",
+    /** Error might be recoverable with retry */
+    MAYBE_RECOVERABLE = "MAYBE_RECOVERABLE",
+    /** Error is definitely recoverable with retries */
+    RECOVERABLE = "RECOVERABLE",
+    /** Error is transient and should resolve without action */
+    TRANSIENT = "TRANSIENT"
+}