@serve.zone/dcrouter 11.14.0 → 11.16.0

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 ?? 0) < (retry.maxRetries ?? 0);
+    }
+    /**
+     * 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":"AAAA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAoDtC;;;GAGG;AACH,MAAM,OAAO,aAAc,SAAQ,KAAK;IACtC,qDAAqD;IACrC,IAAI,CAAS;IAE7B,2BAA2B;IACX,QAAQ,CAAgB;IAExC,iDAAiD;IACjC,QAAQ,CAAgB;IAExC,4DAA4D;IAC5C,cAAc,CAAsB;IAEpD,qCAAqC;IACrB,OAAO,CAAgB;IAEvC;;;;;;;;;OASG;IACH,YACE,OAAe,EACf,IAAY,EACZ,WAA0B,aAAa,CAAC,MAAM,EAC9C,WAA0B,aAAa,CAAC,KAAK,EAC7C,iBAAsC,mBAAmB,CAAC,eAAe,EACzE,UAAyB,EAAE;QAE3B,KAAK,CAAC,OAAO,CAAC,CAAC;QAEf,qBAAqB;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QAErC,gCAAgC;QAChC,IAAI,CAAC,OAAO,GAAG;YACb,GAAG,OAAO;YACV,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE;SAC3C,CAAC;QAEF,sBAAsB;QACtB,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAEhD,yDAAyD;QACzD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,CAAC;YAC/B,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC;IACH,CAAC;IAED;;OAEG;IACK,QAAQ;QACd,MAAM,QAAQ,GAAG,IAAI,CAAC,uBAAuB,EAAe,CAAC;QAE7D,iCAAiC;QACjC,MAAM,OAAO,GAAG;YACd,UAAU,EAAE,IAAI,CAAC,IAAI;YACrB,UAAU,EAAE,IAAI,CAAC,IAAI;YACrB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,GAAG,IAAI,CAAC,OAAO;SAChB,CAAC;QAEF,6BAA6B;QAC7B,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC7B,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;YACtB,KAAK,aAAa,CAAC,QAAQ,CAAC;YAC5B,KAAK,aAAa,CAAC,IAAI;gBACrB,OAAO,OAAO,CAAC;YACjB,KAAK,aAAa,CAAC,MAAM;gBACvB,OAAO,MAAM,CAAC;YAChB,KAAK,aAAa,CAAC,GAAG;gBACpB,OAAO,MAAM,CAAC;YAChB,KAAK,aAAa,CAAC,IAAI;gBACrB,OAAO,OAAO,CAAC;YACjB;gBACE,OAAO,OAAO,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;OAEG;IACI,MAAM;QACX,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;SACtE,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACI,SAAS,CACd,UAAkB,EAClB,eAAuB,CAAC,EACxB,aAAqB,IAAI;QAEzB,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,UAAU,CAAC;QAE5C,uCAAuC;QACvC,MAAM,UAAU,GAAG;YACjB,GAAG,IAAI,CAAC,OAAO;YACf,KAAK,EAAE;gBACL,UAAU;gBACV,YAAY;gBACZ,WAAW;gBACX,UAAU;aACX;SACF,CAAC;QAEF,gFAAgF;QAChF,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAEpD,wCAAwC;QACxC,IAAI,YAAY,GAAG,UAAU,IAAI,QAAQ,CAAC,cAAc,KAAK,mBAAmB,CAAC,eAAe,EAAE,CAAC;YAChG,QAAgB,CAAC,cAAc,GAAG,mBAAmB,CAAC,iBAAiB,CAAC;QAC3E,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAsB;QAChD,2CAA2C;QAC3C,OAAO,IAAK,IAAI,CAAC,WAAoC,CACnD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,EACT,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,cAAc,EACnB,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,KAAK;YAAE,OAAO,KAAK,CAAC;QAEzB,OAAO,CAAC,KAAK,CAAC,YAAY,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,UAAU,IAAI,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACI,cAAc;QACnB,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,IAAI,+BAA+B,CAAC;IACrE,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,eAAgB,SAAQ,aAAa;IAChD;;;;;;OAMG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAyB,EAAE;QAE3B,KAAK,CACH,OAAO,EACP,IAAI,EACJ,aAAa,CAAC,GAAG,EACjB,aAAa,CAAC,UAAU,EACxB,mBAAmB,CAAC,eAAe,EACnC,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAsB;QAChD,OAAO,IAAK,IAAI,CAAC,WAAsC,CACrD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,EACT,OAAO,CACR,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,kBAAmB,SAAQ,aAAa;IACnD;;;;;;OAMG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAyB,EAAE;QAE3B,KAAK,CACH,OAAO,EACP,IAAI,EACJ,aAAa,CAAC,MAAM,EACpB,aAAa,CAAC,aAAa,EAC3B,mBAAmB,CAAC,eAAe,EACnC,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAsB;QAChD,OAAO,IAAK,IAAI,CAAC,WAAyC,CACxD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,EACT,OAAO,CACR,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,YAAa,SAAQ,aAAa;IAC7C;;;;;;OAMG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAyB,EAAE;QAE3B,KAAK,CACH,OAAO,EACP,IAAI,EACJ,aAAa,CAAC,MAAM,EACpB,aAAa,CAAC,YAAY,EAC1B,mBAAmB,CAAC,iBAAiB,EACrC,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAsB;QAChD,OAAO,IAAK,IAAI,CAAC,WAAmC,CAClD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,EACT,OAAO,CACR,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,aAAa;IAC9C;;;;;;OAMG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAyB,EAAE;QAE3B,KAAK,CACH,OAAO,EACP,IAAI,EACJ,aAAa,CAAC,MAAM,EACpB,aAAa,CAAC,QAAQ,EACtB,mBAAmB,CAAC,iBAAiB,EACrC,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAsB;QAChD,OAAO,IAAK,IAAI,CAAC,WAAoC,CACnD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,EACT,OAAO,CACR,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,mBAAoB,SAAQ,aAAa;IACpD;;;;;;OAMG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAyB,EAAE;QAE3B,KAAK,CACH,OAAO,EACP,IAAI,EACJ,aAAa,CAAC,IAAI,EAClB,aAAa,CAAC,cAAc,EAC5B,mBAAmB,CAAC,eAAe,EACnC,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAsB;QAChD,OAAO,IAAK,IAAI,CAAC,WAA0C,CACzD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,EACT,OAAO,CACR,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,cAAe,SAAQ,aAAa;IAC/C;;;;;;OAMG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAyB,EAAE;QAE3B,KAAK,CACH,OAAO,EACP,IAAI,EACJ,aAAa,CAAC,MAAM,EACpB,aAAa,CAAC,SAAS,EACvB,mBAAmB,CAAC,iBAAiB,EACrC,OAAO,CACR,CAAC;IACJ,CAAC;IAED;;;OAGG;IACO,iBAAiB,CAAC,OAAsB;QAChD,OAAO,IAAK,IAAI,CAAC,WAAqC,CACpD,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,IAAI,EACT,OAAO,CACR,CAAC;IACJ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,aAAa;IAC5C;;;;;;OAMG;IACH,YACE,OAAe,EACf,IAAY,EACZ,UAAyB,EAAE;QAE3B,KAAK,CACH,OAAO,EACP,IAAI,EACJ,aAAa,CAAC,QAAQ,EACtB,aAAa,CAAC,KAAK,EACnB,mBAAmB,CAAC,eAAe,EACnC,OAAO,CACR,CAAC;IACJ,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAC,QAAuB;IAC9D,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,aAAa,CAAC,UAAU;YAC3B,OAAO,eAAe,CAAC;QACzB,KAAK,aAAa,CAAC,aAAa;YAC9B,OAAO,kBAAkB,CAAC;QAC5B,KAAK,aAAa,CAAC,YAAY;YAC7B,OAAO,YAAY,CAAC;QACtB,KAAK,aAAa,CAAC,QAAQ;YACzB,OAAO,aAAa,CAAC;QACvB,KAAK,aAAa,CAAC,cAAc;YAC/B,OAAO,mBAAmB,CAAC;QAC7B,KAAK,aAAa,CAAC,SAAS;YAC1B,OAAO,cAAc,CAAC;QACxB;YACE,OAAO,aAAa,CAAC;IACzB,CAAC;AACH,CAAC"}

package/dist_ts/errors/error-handler.d.ts

@@ -0,0 +1,98 @@
+import { PlatformError } from './base.errors.js';
+import type { IErrorContext } from './base.errors.js';
+/**
+ * Error handler configuration
+ */
+export interface IErrorHandlerConfig {
+    /** Whether to log errors automatically */
+    logErrors: boolean;
+    /** Whether to include stack traces in prod environment */
+    includeStacksInProd: boolean;
+    /** Default retry options */
+    retry: {
+        /** Maximum retry attempts */
+        maxAttempts: number;
+        /** Base delay between retries in ms */
+        baseDelay: number;
+        /** Maximum delay between retries in ms */
+        maxDelay: number;
+        /** Backoff factor for exponential backoff */
+        backoffFactor: number;
+    };
+}
+/**
+ * Error handler utility
+ * Provides methods for consistent error handling across the platform
+ */
+export declare class ErrorHandler {
+    /**
+     * Current configuration
+     */
+    static config: IErrorHandlerConfig;
+    /**
+     * Update error handler configuration
+     *
+     * @param newConfig New configuration (partial)
+     */
+    static configure(newConfig: Partial<IErrorHandlerConfig>): void;
+    /**
+     * Convert any error to a PlatformError
+     *
+     * @param error Error to convert
+     * @param defaultCode Default error code if not a PlatformError
+     * @param context Additional context
+     * @returns PlatformError instance
+     */
+    static toPlatformError(error: any, defaultCode: string, context?: IErrorContext): PlatformError;
+    /**
+     * Format an error for API responses
+     * Sanitizes errors for safe external exposure
+     *
+     * @param error Error to format
+     * @param includeDetails Whether to include detailed information
+     * @returns Formatted error object
+     */
+    static formatErrorForResponse(error: any, includeDetails?: boolean): Record<string, any>;
+    /**
+     * Handle an error with consistent logging and formatting
+     *
+     * @param error Error to handle
+     * @param defaultCode Default error code if not a PlatformError
+     * @param context Additional context
+     * @returns Formatted error for response
+     */
+    static handleError(error: any, defaultCode: string, context?: IErrorContext): Record<string, any>;
+    /**
+     * Execute a function with error handling
+     *
+     * @param fn Function to execute
+     * @param defaultCode Default error code if the function throws
+     * @param context Additional context
+     * @returns Function result or error
+     */
+    static execute<T>(fn: () => Promise<T>, defaultCode: string, context?: IErrorContext): Promise<T>;
+    /**
+     * Execute a function with retries and exponential backoff
+     *
+     * @param fn Function to execute
+     * @param defaultCode Default error code if the function throws
+     * @param options Retry options
+     * @param context Additional context
+     * @returns Function result or error after max retries
+     */
+    static executeWithRetry<T>(fn: () => Promise<T>, defaultCode: string, options?: {
+        maxAttempts?: number;
+        baseDelay?: number;
+        maxDelay?: number;
+        backoffFactor?: number;
+        retryableErrorCodes?: string[];
+        retryableErrorPatterns?: RegExp[];
+        onRetry?: (error: PlatformError, attempt: number, delay: number) => void;
+    }, context?: IErrorContext): Promise<T>;
+}
+/**
+ * Create a middleware for handling errors in HTTP requests
+ *
+ * @returns Middleware function
+ */
+export declare function createErrorHandlerMiddleware(): (error: any, req: any, res: any, next: any) => void;