@sailboat-computer/resilience/dist/types.d.ts

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

/**
 * Core types for the resilience framework
 */
import { CircuitBreakerState, MarineFailureType, OperationalContext, MarineEnvironmentStatus } from '@sailboat-computer/sailboat-types';
export { CircuitBreakerState, MarineFailureType, OperationalContext, MarineEnvironmentStatus };
export type CircuitBreakerStateType = CircuitBreakerState;
export type MarineFailureTypeType = MarineFailureType;
export type OperationalContextType = OperationalContext;
/**
 * Circuit breaker configuration
 */
export interface CircuitBreakerConfig {
    failureThreshold: number;
    successThreshold: number;
    timeout: number;
    operationalContext: OperationalContextType;
    failureTypes: MarineFailureTypeType[];
    environmentalAdjustments: {
        roughSeas: boolean;
        lowPower: boolean;
        limitedConnectivity: boolean;
    };
    volumeThreshold: number;
    errorPercentageThreshold: number;
    slowCallDurationThreshold: number;
    slowCallRateThreshold: number;
}
/**
 * Circuit breaker metrics
 */
export interface CircuitBreakerMetrics {
    state: CircuitBreakerStateType;
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    rejectedRequests: number;
    averageResponseTime: number;
    slowCalls: number;
    environmentalFailures: number;
    powerRelatedFailures: number;
    connectivityFailures: number;
    sensorFailures: number;
    lastFailureTime?: Date;
    lastSuccessTime?: Date;
    stateChangedAt: Date;
    nextAttemptAt?: Date;
}
/**
 * Bulkhead resource pool configuration
 */
export interface BulkheadConfig {
    poolName: string;
    maxConcurrentRequests: number;
    maxWaitTime: number;
    priority: 'critical' | 'normal' | 'low';
    marineSystemType: 'navigation' | 'safety' | 'comfort' | 'maintenance';
    powerConsumption: 'high' | 'medium' | 'low';
    operationalDependency: 'essential' | 'important' | 'optional';
}
/**
 * Resource pool metrics
 */
export interface ResourcePoolMetrics {
    poolName: string;
    totalCapacity: number;
    availableResources: number;
    activeRequests: number;
    queuedRequests: number;
    rejectedRequests: number;
    averageWaitTime: number;
    maxWaitTime: number;
    powerImpact: number;
    criticalRequestsActive: number;
    systemHealthImpact: number;
}
/**
 * Timeout configuration with hierarchical structure
 */
export interface TimeoutConfig {
    operationTimeout: number;
    serviceTimeout: number;
    systemTimeout: number;
    environmentalMultiplier: number;
    operationalContext: OperationalContextType;
    maxRetries: number;
    retryBackoffMultiplier: number;
    maxRetryDelay: number;
    criticalOperationTimeout: number;
    sensorReadTimeout: number;
    networkOperationTimeout: number;
}
/**
 * Timeout metrics
 */
export interface TimeoutMetrics {
    totalOperations: number;
    timedOutOperations: number;
    averageOperationTime: number;
    maxOperationTime: number;
    totalRetries: number;
    successfulRetries: number;
    failedRetries: number;
    environmentalTimeouts: number;
    criticalOperationTimeouts: number;
    sensorTimeouts: number;
}
/**
 * Resilience operation result
 */
export interface ResilienceResult<T> {
    success: boolean;
    data?: T;
    error?: Error;
    metrics: {
        executionTime: number;
        retryCount: number;
        circuitBreakerState?: CircuitBreakerStateType;
        resourcePoolUsed?: string;
        timeoutApplied?: number;
    };
    marineContext: {
        operationalContext: OperationalContextType;
        environmentalConditions: Record<string, any>;
        powerStatus: 'normal' | 'conservation' | 'critical';
        connectivityStatus: 'online' | 'intermittent' | 'offline';
    };
}
/**
 * Resilience event for monitoring and logging
 */
export interface ResilienceEvent {
    timestamp: Date;
    eventType: 'circuit_breaker_opened' | 'circuit_breaker_closed' | 'timeout' | 'retry' | 'bulkhead_rejection' | 'recovery';
    component: string;
    details: Record<string, any>;
    severity: 'info' | 'warning' | 'error' | 'critical';
    marineContext: {
        operationalContext: OperationalContextType;
        failureType?: MarineFailureTypeType;
        environmentalImpact?: boolean;
        safetyImpact?: boolean;
    };
}
/**
 * Resilience strategy configuration
 */
export interface ResilienceStrategy {
    name: string;
    description: string;
    circuitBreaker?: CircuitBreakerConfig;
    bulkhead?: BulkheadConfig;
    timeout?: TimeoutConfig;
    marineEnvironmentAdaptation: boolean;
    safetyFirst: boolean;
    powerAware: boolean;
    applicableContexts: OperationalContextType[];
    applicableFailureTypes: MarineFailureTypeType[];
    minimumSystemHealth: number;
}
/**
 * System resilience status
 */
export interface SystemResilienceStatus {
    overallHealth: number;
    componentStatus: {
        circuitBreakers: Record<string, CircuitBreakerMetrics>;
        resourcePools: Record<string, ResourcePoolMetrics>;
        timeouts: Record<string, TimeoutMetrics>;
    };
    marineStatus: MarineEnvironmentStatus;
    activeStrategies: string[];
    recentEvents: ResilienceEvent[];
    recommendations: {
        adjustTimeouts: boolean;
        enablePowerConservation: boolean;
        activateEmergencyMode: boolean;
        performMaintenance: string[];
    };
}
//# sourceMappingURL=types.d.ts.map