@sailboat-computer/resilience/dist/timeout/TimeoutManager.d.ts

Enhanced resilience patterns for sailboat computer v3 with marine-specific adaptations

/**
 * Hierarchical timeout management for marine operations
 */
import { TimeoutConfig, TimeoutMetrics, ResilienceEvent, MarineEnvironmentStatus } from '../types';
import { OperationalContextType } from '../types/marine-constants';
/**
 * Timeout execution context
 */
export interface TimeoutExecutionContext {
    operationName: string;
    operationalContext: OperationalContextType;
    marineSystemType: 'navigation' | 'safety' | 'comfort' | 'maintenance';
    priority: 'critical' | 'normal' | 'low';
    customTimeouts?: Partial<TimeoutConfig>;
}
/**
 * Timeout execution result
 */
export interface TimeoutExecutionResult<T> {
    success: boolean;
    data?: T;
    error?: Error;
    executionTime: number;
    timeoutApplied: number;
    timedOut: boolean;
    retryCount: number;
}
/**
 * Hierarchical timeout manager for marine operations
 */
export declare class TimeoutManager {
    private config;
    private metrics;
    private activeTimeouts;
    private eventListeners;
    private marineEnvironment?;
    private nextTimeoutId;
    constructor(config?: Partial<TimeoutConfig>);
    /**
     * Execute operation with hierarchical timeout protection
     */
    execute<T>(operation: () => Promise<T>, context: TimeoutExecutionContext): Promise<TimeoutExecutionResult<T>>;
    /**
     * Update marine environment for adaptive timeouts
     */
    updateMarineEnvironment(environment: MarineEnvironmentStatus): void;
    /**
     * Get current timeout metrics
     */
    getMetrics(): TimeoutMetrics;
    /**
     * Get active timeouts status
     */
    getActiveTimeouts(): {
        id: string;
        operationName: string;
        startTime: Date;
        timeoutMs: number;
        elapsedTime: number;
        remainingTime: number;
        context: {
            operationalContext: import("@sailboat-computer/sailboat-types/dist/common").OperationalContext;
            marineSystemType: "navigation" | "safety" | "comfort" | "maintenance";
            priority: "critical" | "normal" | "low";
        };
    }[];
    /**
     * Cancel all active timeouts (emergency)
     */
    cancelAllTimeouts(reason?: string): void;
    /**
     * Add event listener
     */
    onEvent(listener: (event: ResilienceEvent) => void): void;
    /**
     * Execute operation with timeout
     */
    private executeWithTimeout;
    /**
     * Calculate timeout based on context and marine conditions
     */
    private calculateTimeout;
    /**
     * Check if error is a timeout error
     */
    private isTimeoutError;
    /**
     * Check if operation should be retried
     */
    private shouldRetry;
    /**
     * Calculate retry delay with exponential backoff
     */
    private calculateRetryDelay;
    /**
     * Update marine-specific timeout counters
     */
    private updateMarineTimeoutCounters;
    /**
     * Update metrics
     */
    private updateMetrics;
    /**
     * Delay helper function
     */
    private delay;
    /**
     * Emit resilience event
     */
    private emitEvent;
    /**
     * Initialize metrics
     */
    private initializeMetrics;
}
/**
 * Default timeout manager instance
 */
export declare const defaultTimeoutManager: TimeoutManager;
/**
 * Convenience function to execute with timeout protection
 */
export declare function executeWithTimeout<T>(operation: () => Promise<T>, context: TimeoutExecutionContext): Promise<TimeoutExecutionResult<T>>;
/**
 * Pre-configured timeout contexts for marine operations
 */
export declare const TimeoutContexts: {
    /**
     * Navigation sensor reading
     */
    navigationSensor: (operationName: string, operationalContext?: OperationalContextType) => TimeoutExecutionContext;
    /**
     * Safety system operation
     */
    safetyOperation: (operationName: string, operationalContext?: OperationalContextType) => TimeoutExecutionContext;
    /**
     * Network communication
     */
    networkOperation: (operationName: string, operationalContext?: OperationalContextType) => TimeoutExecutionContext;
    /**
     * Maintenance operation
     */
    maintenanceOperation: (operationName: string) => TimeoutExecutionContext;
    /**
     * Comfort system operation
     */
    comfortOperation: (operationName: string, operationalContext?: OperationalContextType) => TimeoutExecutionContext;
};
//# sourceMappingURL=TimeoutManager.d.ts.map