/**
 * Error Handling Service
 *
 * Provides structured error handling with sanitization
 * Prevents information disclosure while maintaining debugging capability
 */
export declare enum ErrorCode {
    INVALID_INPUT = "INVALID_INPUT",
    INVALID_ADDRESS = "INVALID_ADDRESS",
    INVALID_AMOUNT = "INVALID_AMOUNT",
    INVALID_CURRENCY = "INVALID_CURRENCY",
    REQUIRED_FIELD = "REQUIRED_FIELD",
    WALLET_NOT_CONNECTED = "WALLET_NOT_CONNECTED",
    UNAUTHORIZED = "UNAUTHORIZED",
    SESSION_EXPIRED = "SESSION_EXPIRED",
    NETWORK_ERROR = "NETWORK_ERROR",
    WRONG_NETWORK = "WRONG_NETWORK",
    TRANSACTION_FAILED = "TRANSACTION_FAILED",
    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
    GAS_ESTIMATION_FAILED = "GAS_ESTIMATION_FAILED",
    USER_REJECTED = "USER_REJECTED",
    PAYMENT_CREATION_FAILED = "PAYMENT_CREATION_FAILED",
    PAYMENT_NOT_FOUND = "PAYMENT_NOT_FOUND",
    PRICE_FETCH_FAILED = "PRICE_FETCH_FAILED",
    IPFS_UPLOAD_FAILED = "IPFS_UPLOAD_FAILED",
    IPFS_FETCH_FAILED = "IPFS_FETCH_FAILED",
    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
    NOT_INITIALIZED = "NOT_INITIALIZED",
    INITIALIZATION_FAILED = "INITIALIZATION_FAILED",
    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
    UNKNOWN_ERROR = "UNKNOWN_ERROR"
}
export declare enum ErrorSeverity {
    LOW = "LOW",// Minor issues, doesn't block user
    MEDIUM = "MEDIUM",// Important but recoverable
    HIGH = "HIGH",// Critical, blocks user flow
    CRITICAL = "CRITICAL"
}
export interface SerializedError {
    message: string;
    code: ErrorCode;
    severity: ErrorSeverity;
    details?: Record<string, unknown>;
    timestamp: number;
    retryable: boolean;
}
/**
 * Base application error class
 */
export declare class PMTError extends Error {
    readonly code: ErrorCode;
    readonly severity: ErrorSeverity;
    readonly retryable: boolean;
    readonly details?: Record<string, unknown>;
    readonly originalError?: Error;
    readonly timestamp: number;
    constructor(message: string, code: ErrorCode, options?: {
        severity?: ErrorSeverity;
        retryable?: boolean;
        details?: Record<string, unknown>;
        originalError?: Error;
    });
    /**
     * Serialize error for client consumption (sanitized)
     */
    toJSON(): SerializedError;
    /**
     * Sanitize details to prevent information disclosure
     */
    private sanitizeDetails;
    /**
     * Get full error for logging (includes sensitive info)
     */
    toLogObject(): Record<string, unknown>;
}
/**
 * Error handling utility
 */
export declare class ErrorHandler {
    /**
     * Convert any error to PMTError
     */
    static handle(error: unknown, context?: string): PMTError;
    /**
     * Check if error is from ethers.js
     */
    private static isEthersError;
    /**
     * Handle ethers.js specific errors
     */
    private static handleEthersError;
    /**
     * Check if error is validation error
     */
    private static isValidationError;
    /**
     * Check if error is network error
     */
    private static isNetworkError;
    /**
     * Get safe error message (remove sensitive info)
     */
    private static getSafeErrorMessage;
    /**
     * Log error appropriately based on environment
     */
    static logError(error: PMTError, context?: string): void;
    /**
     * Send error to monitoring service
     */
    private static sendToMonitoring;
    /**
     * Create user-friendly error message
     */
    static getUserMessage(error: PMTError): string;
}
//# sourceMappingURL=error.service.d.ts.map