/**
 * Error Handler Registry
 * Central registry for error messages and handling functions
 * Provides standardized error handling across all modules
 */
import { ErrorHandlingCenter } from 'rcc-errorhandling';
interface ErrorContext {
    error: unknown;
    source: string;
    severity: string;
    timestamp: number;
    module?: string;
    context: unknown;
}
interface DeferredHandler {
    resolve: (value: unknown) => void;
    reject: (reason?: unknown) => void;
}
export interface RateLimitPipelineDescriptor {
    pipelineId: string;
    [key: string]: unknown;
}
export interface RateLimitHookTelemetryEvent {
    type: '429-backoff' | '429-final-fail';
    timestamp: number;
    pipelineId?: string;
    delay?: number;
    requestId?: string;
    message?: string;
}
export interface RateLimitHandlerHooks {
    getAvailablePipelines?(exclude: Set<string>): RateLimitPipelineDescriptor[];
    selectNextRoundRobin?(candidates: RateLimitPipelineDescriptor[]): RateLimitPipelineDescriptor;
    processWithPipeline?(pipeline: RateLimitPipelineDescriptor): Promise<unknown>;
    getPipelineById?(pipelineId: string): RateLimitPipelineDescriptor | undefined;
    errorCenter?: {
        handleError?(event: RateLimitHookTelemetryEvent): Promise<void>;
    };
}
export interface RateLimitHandlerContext {
    hooks?: RateLimitHandlerHooks;
    schedule?: number[];
    attemptedPipelineIds?: string[];
    deferred?: DeferredHandler;
    request?: {
        route?: {
            requestId?: string;
        };
    };
}
/**
 * Error handler function type
 */
export type ErrorHandlerFunction = (context: ErrorContext) => Promise<void>;
/**
 * Error message template interface
 */
export interface ErrorMessageTemplate {
    code: string;
    message: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    category: string;
    description?: string;
    recovery?: string;
}
/**
 * Error handler registration interface
 */
export interface ErrorHandlerRegistration {
    errorCode: string;
    handler: ErrorHandlerFunction;
    priority: number;
    description?: string;
}
/**
 * Error Handler Registry class
 * Centralized error handling system with registered handlers and message templates
 */
export declare class ErrorHandlerRegistry {
    private static instance;
    private errorHandlingCenter;
    private messageTemplates;
    private errorHandlers;
    private initialized;
    private constructor();
    /**
     * Get singleton instance
     */
    static getInstance(): ErrorHandlerRegistry;
    /**
     * Initialize the error handler registry
     */
    initialize(): Promise<void>;
    /**
     * Register error message template
     */
    registerErrorMessage(template: ErrorMessageTemplate): void;
    /**
     * Override the internal ErrorHandlingCenter instance.
     * Allows host applications to inject a shared center so hooks and logging stay unified.
     */
    attachErrorHandlingCenter(center: ErrorHandlingCenter): void;
    /**
     * Register error handler function
     */
    registerErrorHandler(registration: ErrorHandlerRegistration): void;
    /**
     * Handle error with registered handlers
     */
    handleError(error: Error, context: string, moduleId: string, additionalContext?: Record<string, unknown>): Promise<void>;
    private extractErrorExtras;
    /**
     * Get error message template for error
     */
    private getErrorMessageTemplate;
    /**
     * Generate error code based on error type and context
     */
    private generateErrorCode;
    /**
     * Execute registered error handlers for specific error code
     */
    private executeErrorHandlers;
    /**
     * Register default error messages
     */
    private registerDefaultErrorMessages;
    /**
     * Register default error handlers
     */
    private registerDefaultErrorHandlers;
    private logDebugEvent;
    /**
     * Get all registered error message templates
     */
    getRegisteredMessages(): ErrorMessageTemplate[];
    /**
     * Get registered handlers for specific error code
     */
    getRegisteredHandlers(errorCode: string): ErrorHandlerFunction[];
    /**
     * Destroy registry and cleanup resources
     */
    destroy(): Promise<void>;
}
export {};