/**
 * Graceful degradation strategies with marine-specific adaptations
 */
import { MarineEnvironmentStatus, ResilienceEvent } from '../types';
/**
 * Service quality level
 */
export declare enum ServiceQualityLevel {
    /**
     * Full functionality with optimal performance
     */
    OPTIMAL = "optimal",
    /**
     * Full functionality with reduced performance
     */
    REDUCED = "reduced",
    /**
     * Core functionality only
     */
    MINIMAL = "minimal",
    /**
     * Critical functionality only
     */
    CRITICAL = "critical",
    /**
     * Emergency functionality only
     */
    EMERGENCY = "emergency"
}
/**
 * Feature priority for degradation decisions
 */
export declare enum FeaturePriority {
    /**
     * Critical for vessel safety
     */
    CRITICAL = "critical",
    /**
     * Essential for operation
     */
    ESSENTIAL = "essential",
    /**
     * Important but can be degraded
     */
    IMPORTANT = "important",
    /**
     * Useful but non-essential
     */
    USEFUL = "useful",
    /**
     * Comfort or convenience only
     */
    COMFORT = "comfort"
}
/**
 * Degradation strategy configuration
 */
export interface DegradationConfig {
    /**
     * Default service quality level
     */
    defaultQualityLevel: ServiceQualityLevel;
    /**
     * Whether to adapt to marine conditions
     */
    adaptToMarineConditions: boolean;
    /**
     * Whether to adapt to power status
     */
    powerAware: boolean;
    /**
     * Whether to adapt to connectivity quality
     */
    connectivityAware: boolean;
    /**
     * Quality level thresholds for different conditions
     */
    qualityThresholds: {
        /**
         * Sea state thresholds
         */
        seaState: {
            rough: ServiceQualityLevel;
            veryRough: ServiceQualityLevel;
        };
        /**
         * Power status thresholds
         */
        powerStatus: {
            conservation: ServiceQualityLevel;
            critical: ServiceQualityLevel;
        };
        /**
         * Connectivity quality thresholds (0-1)
         */
        connectivityQuality: {
            low: number;
            lowQualityLevel: ServiceQualityLevel;
            veryLow: number;
            veryLowQualityLevel: ServiceQualityLevel;
        };
    };
    /**
     * Feature toggles configuration
     */
    featureToggles: {
        /**
         * Whether to enable automatic feature toggling
         */
        autoToggleFeatures: boolean;
        /**
         * Minimum priority level for each quality level
         */
        qualityLevelMinPriority: {
            [ServiceQualityLevel.OPTIMAL]: FeaturePriority;
            [ServiceQualityLevel.REDUCED]: FeaturePriority;
            [ServiceQualityLevel.MINIMAL]: FeaturePriority;
            [ServiceQualityLevel.CRITICAL]: FeaturePriority;
            [ServiceQualityLevel.EMERGENCY]: FeaturePriority;
        };
    };
    /**
     * Resource limits for different quality levels
     */
    resourceLimits: {
        /**
         * CPU usage percentage (0-100)
         */
        cpu: {
            [ServiceQualityLevel.OPTIMAL]: number;
            [ServiceQualityLevel.REDUCED]: number;
            [ServiceQualityLevel.MINIMAL]: number;
            [ServiceQualityLevel.CRITICAL]: number;
            [ServiceQualityLevel.EMERGENCY]: number;
        };
        /**
         * Memory usage percentage (0-100)
         */
        memory: {
            [ServiceQualityLevel.OPTIMAL]: number;
            [ServiceQualityLevel.REDUCED]: number;
            [ServiceQualityLevel.MINIMAL]: number;
            [ServiceQualityLevel.CRITICAL]: number;
            [ServiceQualityLevel.EMERGENCY]: number;
        };
        /**
         * Network bandwidth usage (KB/s)
         */
        bandwidth: {
            [ServiceQualityLevel.OPTIMAL]: number;
            [ServiceQualityLevel.REDUCED]: number;
            [ServiceQualityLevel.MINIMAL]: number;
            [ServiceQualityLevel.CRITICAL]: number;
            [ServiceQualityLevel.EMERGENCY]: number;
        };
        /**
         * Storage I/O operations per second
         */
        storageIops: {
            [ServiceQualityLevel.OPTIMAL]: number;
            [ServiceQualityLevel.REDUCED]: number;
            [ServiceQualityLevel.MINIMAL]: number;
            [ServiceQualityLevel.CRITICAL]: number;
            [ServiceQualityLevel.EMERGENCY]: number;
        };
    };
}
/**
 * Feature toggle definition
 */
export interface FeatureToggle {
    /**
     * Feature ID
     */
    id: string;
    /**
     * Feature name
     */
    name: string;
    /**
     * Feature description
     */
    description: string;
    /**
     * Feature priority
     */
    priority: FeaturePriority;
    /**
     * Whether the feature is currently enabled
     */
    enabled: boolean;
    /**
     * Whether the feature can be manually toggled
     */
    manualToggleAllowed: boolean;
    /**
     * Power consumption in watts when enabled
     */
    powerConsumption: number;
    /**
     * CPU usage percentage when enabled
     */
    cpuUsage: number;
    /**
     * Memory usage in MB when enabled
     */
    memoryUsage: number;
    /**
     * Network bandwidth usage in KB/s when enabled
     */
    bandwidthUsage: number;
    /**
     * Storage I/O operations per second when enabled
     */
    storageIops: number;
    /**
     * Marine-specific settings
     */
    marineSettings: {
        /**
         * Whether this feature is required in rough seas
         */
        requiredInRoughSeas: boolean;
        /**
         * Whether this feature is required for navigation
         */
        requiredForNavigation: boolean;
        /**
         * Whether this feature is required for safety
         */
        requiredForSafety: boolean;
        /**
         * Whether this feature requires good connectivity
         */
        requiresGoodConnectivity: boolean;
    };
}
/**
 * Degradation metrics
 */
export interface DegradationMetrics {
    /**
     * Current service quality level
     */
    currentQualityLevel: ServiceQualityLevel;
    /**
     * Previous service quality level
     */
    previousQualityLevel: ServiceQualityLevel;
    /**
     * Time spent at each quality level (ms)
     */
    timeAtQualityLevel: {
        [key in ServiceQualityLevel]: number;
    };
    /**
     * Number of quality level changes
     */
    qualityLevelChanges: number;
    /**
     * Feature toggle metrics
     */
    featureToggles: {
        /**
         * Total number of features
         */
        total: number;
        /**
         * Number of enabled features
         */
        enabled: number;
        /**
         * Number of disabled features
         */
        disabled: number;
        /**
         * Number of features toggled automatically
         */
        autoToggled: number;
        /**
         * Number of features toggled manually
         */
        manuallyToggled: number;
    };
    /**
     * Resource usage metrics
     */
    resourceUsage: {
        /**
         * CPU usage percentage
         */
        cpu: number;
        /**
         * Memory usage percentage
         */
        memory: number;
        /**
         * Network bandwidth usage (KB/s)
         */
        bandwidth: number;
        /**
         * Storage I/O operations per second
         */
        storageIops: number;
        /**
         * Power consumption in watts
         */
        power: number;
    };
    /**
     * Marine-specific metrics
     */
    marineMetrics: {
        /**
         * Time spent in rough seas (ms)
         */
        timeInRoughSeas: number;
        /**
         * Time spent in power conservation mode (ms)
         */
        timeInPowerConservation: number;
        /**
         * Time spent with poor connectivity (ms)
         */
        timeWithPoorConnectivity: number;
        /**
         * Time spent in emergency mode (ms)
         */
        timeInEmergencyMode: number;
    };
}
/**
 * Degradation manager for graceful service degradation
 */
export declare class DegradationManager {
    private config;
    private currentQualityLevel;
    private featureToggles;
    private metrics;
    private eventListeners;
    private marineEnvironment?;
    private qualityLevelTimestamps;
    private lastQualityUpdateTime;
    constructor(config?: Partial<DegradationConfig>);
    /**
     * Register a feature toggle
     */
    registerFeature(feature: FeatureToggle): void;
    /**
     * Unregister a feature toggle
     */
    unregisterFeature(featureId: string): boolean;
    /**
     * Check if a feature is enabled
     */
    isFeatureEnabled(featureId: string): boolean;
    /**
     * Manually enable a feature
     */
    enableFeature(featureId: string): boolean;
    /**
     * Manually disable a feature
     */
    disableFeature(featureId: string): boolean;
    /**
     * Get current service quality level
     */
    getQualityLevel(): ServiceQualityLevel;
    /**
     * Set service quality level manually
     */
    setQualityLevel(level: ServiceQualityLevel): void;
    /**
     * Update marine environment for adaptive degradation
     */
    updateMarineEnvironment(environment: MarineEnvironmentStatus): void;
    /**
     * Get current degradation metrics
     */
    getMetrics(): DegradationMetrics;
    /**
     * Get all registered features
     */
    getAllFeatures(): FeatureToggle[];
    /**
     * Get enabled features
     */
    getEnabledFeatures(): FeatureToggle[];
    /**
     * Get disabled features
     */
    getDisabledFeatures(): FeatureToggle[];
    /**
     * Add event listener
     */
    onEvent(listener: (event: ResilienceEvent) => void): void;
    /**
     * Remove event listener
     */
    removeEventListener(listener: (event: ResilienceEvent) => void): void;
    /**
     * Determine quality level from marine environment
     */
    private determineQualityLevelFromEnvironment;
    /**
     * Get the more restrictive of two quality levels
     */
    private getMoreRestrictiveLevel;
    /**
     * Apply quality level to all features
     */
    private applyQualityLevelToAllFeatures;
    /**
     * Apply quality level to a specific feature
     */
    private applyQualityLevelToFeature;
    /**
     * Update metrics
     */
    private updateMetrics;
    /**
     * Initialize metrics
     */
    private initializeMetrics;
    /**
     * Emit resilience event
     */
    private emitEvent;
}
/**
 * Default degradation manager instance
 */
export declare const defaultDegradationManager: DegradationManager;
//# sourceMappingURL=DegradationManager.d.ts.map