@sailboat-computer/health-monitoring/dist/recovery/RecoveryOrchestrator.d.ts

Comprehensive health monitoring system for sailboat computer v3 with marine-specific health checks

/**
 * Recovery orchestrator for self-healing mechanisms
 */
import { HealthCheckResult, OperationalContextType, MarineEnvironmentStatus } from '../types';
import { BaseRecoveryAction, RecoveryActionResult, RecoveryPolicy, RecoveryEvent } from './RecoveryAction';
/**
 * Recovery orchestrator configuration
 */
export interface RecoveryOrchestratorConfig {
    /**
     * Whether automated recovery is enabled
     */
    automatedRecoveryEnabled: boolean;
    /**
     * Maximum concurrent recovery actions
     */
    maxConcurrentActions: number;
    /**
     * Default timeout for recovery actions in ms
     */
    defaultActionTimeout: number;
    /**
     * Default retry count for recovery actions
     */
    defaultRetryCount: number;
    /**
     * Default retry delay in ms
     */
    defaultRetryDelay: number;
    /**
     * Whether to prioritize safety-critical systems
     */
    prioritizeSafetyCritical: boolean;
    /**
     * Marine-specific settings
     */
    marineSettings: {
        /**
         * Whether to adapt recovery to marine conditions
         */
        adaptToMarineConditions: boolean;
        /**
         * Whether to adapt to power status
         */
        powerAware: boolean;
        /**
         * Whether to limit recovery actions in rough seas
         */
        limitInRoughSeas: boolean;
        /**
         * Whether to require approval in emergency situations
         */
        requireApprovalInEmergency: boolean;
    };
}
/**
 * Recovery orchestrator for managing self-healing actions
 */
export declare class RecoveryOrchestrator {
    private config;
    private recoveryActions;
    private recoveryPolicies;
    private activeRecoveries;
    private recoveryHistory;
    private eventListeners;
    private currentOperationalContext;
    private currentMarineEnvironment?;
    constructor(config: RecoveryOrchestratorConfig);
    /**
     * Register a recovery action
     */
    registerRecoveryAction(action: BaseRecoveryAction): void;
    /**
     * Register a recovery policy
     */
    registerRecoveryPolicy(policy: RecoveryPolicy): void;
    /**
     * Update operational context
     */
    updateOperationalContext(context: OperationalContextType): void;
    /**
     * Update marine environment
     */
    updateMarineEnvironment(environment: MarineEnvironmentStatus): void;
    /**
     * Process a health check result and trigger recovery if needed
     */
    processHealthCheckResult(result: HealthCheckResult): Promise<void>;
    /**
     * Execute a recovery policy
     */
    private executeRecoveryPolicy;
    /**
     * Check if a policy is applicable in the current context
     */
    private isPolicyApplicable;
    /**
     * Subscribe to recovery events
     */
    onEvent(listener: (event: RecoveryEvent) => void): () => void;
    /**
     * Emit a recovery event
     */
    private emitEvent;
    /**
     * Get recovery history
     */
    getRecoveryHistory(): RecoveryActionResult[];
    /**
     * Get active recoveries
     */
    getActiveRecoveries(): string[];
    /**
     * Get registered recovery actions
     */
    getRegisteredActions(): string[];
    /**
     * Get registered recovery policies
     */
    getRegisteredPolicies(): string[];
}
/**
 * Create a default recovery orchestrator
 */
export declare const defaultRecoveryOrchestrator: RecoveryOrchestrator;
//# sourceMappingURL=RecoveryOrchestrator.d.ts.map