import { SecurityLevel } from "../types/cia";
import { CIAComponentType, CIADataProvider, ROIMetrics } from "../types/cia-services";
import { ISecurityMetricsService } from "../types/services";
import { BaseService } from "./BaseService";
/**
 * Represents a security tool recommendation
 */
export interface SecurityTool {
    name: string;
    example: string;
    purpose: string;
}
/**
 * Cost estimation details for security implementation
 *
 * @property totalImplementationCost - Total upfront implementation cost (formatted string like "$50,000" or numeric value)
 * @property annualMaintenanceCost - Ongoing annual maintenance cost (formatted string or numeric value)
 * @property costBreakdown - Detailed breakdown by component (availability, integrity, confidentiality)
 * @property roi - Optional ROI analysis including payback period, risk reduction, and business benefits
 */
export interface CostEstimation {
    totalImplementationCost: string | number;
    annualMaintenanceCost: string | number;
    costBreakdown: Record<string, unknown>;
    roi?: Record<string, unknown>;
}
/**
 * Technical details response for security implementation
 *
 * @property architecture - Architecture details including components and optional diagrams
 * @property architecture.diagrams - Array of diagram objects with type and URL properties
 * @property implementation - Implementation plan details
 * @property implementation.steps - Optional implementation steps (when dynamically generated)
 * @property implementation.complexity - Optional complexity assessment (e.g., "Low", "Medium", "High")
 * @property technologies - Technology stack by component (availability, integrity, confidentiality)
 */
export interface TechnicalDetailsResponse {
    architecture: {
        description: string;
        components: Array<{
            name: string;
            purpose: string;
            security: string;
        }>;
        diagrams?: unknown[];
    };
    implementation: {
        steps?: string[];
        timeline: string;
        keyMilestones: string[];
        resources: Array<{
            role: string;
            effort: string;
        }>;
        complexity?: string;
    };
    technologies?: Record<string, unknown>;
}
/**
 * Business impact metrics for value creation
 */
export interface BusinessImpactMetrics {
    revenueProtection: string;
    costAvoidance: string;
    productivityImprovement: string;
}
/**
 * Value creation metrics
 */
export interface ValueCreationMetrics {
    roi: ROIMetrics;
    riskReduction: string;
    valuePoints: Array<{
        title: string;
        score: number;
        description: string;
    }>;
    businessImpacts?: BusinessImpactMetrics;
}
/**
 * Represents security metrics for a component
 */
export interface ComponentMetrics {
    level: SecurityLevel;
    score: number;
    description: string;
    recommendations: string[];
    component?: CIAComponentType;
    value?: number;
    percentage?: string;
    capex?: number;
    opex?: number;
}
/**
 * Represents impact metrics for analysis
 */
export interface ImpactMetrics {
    financialImpact: string;
    operationalImpact: string;
    reputationalImpact: string;
    complianceImpact: string;
    securityLevel?: SecurityLevel;
    riskReduction?: string;
    description?: string;
    technical?: string;
    businessImpact?: string;
    [key: string]: unknown;
}
/**
 * Represents comprehensive security metrics
 */
export interface SecurityMetrics {
    availability: ComponentMetrics;
    integrity: ComponentMetrics;
    confidentiality: ComponentMetrics;
    impactMetrics: ImpactMetrics;
    overallScore: number;
    score?: number;
    maxScore?: number;
    percentage?: string;
    totalCapex?: number;
    totalOpex?: number;
    totalCost?: number;
    riskReduction?: string;
    monitoring: number;
    resilience: number;
    compliance: number;
    benchmarkScore: number;
    securityMaturity: string;
}
/**
 * Interface for ROI estimates map
 */
export interface ROIEstimatesMap {
    NONE: {
        returnRate: string;
        value?: string;
        description: string;
        potentialSavings?: string;
        breakEvenPeriod?: string;
    };
    LOW: {
        returnRate: string;
        value?: string;
        description: string;
        potentialSavings?: string;
        breakEvenPeriod?: string;
    };
    MODERATE: {
        returnRate: string;
        value?: string;
        description: string;
        potentialSavings?: string;
        breakEvenPeriod?: string;
    };
    HIGH: {
        returnRate: string;
        value?: string;
        description: string;
        potentialSavings?: string;
        breakEvenPeriod?: string;
    };
    VERY_HIGH: {
        returnRate: string;
        value?: string;
        description: string;
        potentialSavings?: string;
        breakEvenPeriod?: string;
    };
}
/**
 * Service for security metrics and measurements
 *
 * ## Analytics Perspective
 *
 * This service provides quantitative metrics for security levels, enabling
 * organizations to measure their security posture, track improvements over time,
 * and quantify the impact of security investments through cost-benefit analysis
 * and risk reduction calculations. 📊
 *
 * @implements {ISecurityMetricsService}
 */
export declare class SecurityMetricsService extends BaseService implements ISecurityMetricsService {
    /**
     * Service name for identification
     */
    readonly name: string;
    /**
     * Create a new SecurityMetricsService instance
     *
     * @param dataProvider - Data provider for CIA options and metrics data
     * @throws {ServiceError} If dataProvider is not provided
     */
    constructor(dataProvider: CIADataProvider);
    /**
     * Calculate ROI metrics based on security level and implementation cost
     *
     * Computes return on investment (ROI) for security implementations by analyzing
     * the expected returns for different security levels. Higher security levels
     * typically yield better ROI through reduced incident costs and improved resilience.
     *
     * @param securityLevel - Selected security level to calculate ROI for
     * @param implementationCost - Total cost of implementation in currency units (CAPEX + OPEX)
     * @returns ROI metrics including monetary value, percentage return, and description
     * @throws {ServiceError} If security level is invalid
     *
     * @example
     * ```typescript
     * const service = new SecurityMetricsService(dataProvider);
     *
     * // Calculate ROI for High security level with $100,000 investment
     * const roi = service.calculateRoi('High', 100000);
     * console.log(roi.value);        // "$300,000"
     * console.log(roi.percentage);   // "300%"
     * console.log(roi.description);  // "Return on investment for High security level implementation"
     *
     * // No ROI for zero investment
     * const noRoi = service.calculateRoi('High', 0);
     * console.log(noRoi.value);      // "$0"
     * ```
     */
    calculateRoi(securityLevel: SecurityLevel, implementationCost: number): ROIMetrics;
    /**
     * Get ROI estimates from the data provider
     *
     * Retrieves pre-configured return on investment estimates for all security levels.
     * Each level has associated return rates, potential savings, and break-even periods
     * based on industry research and historical data.
     *
     * @returns Map of ROI estimates keyed by security level (NONE, LOW, MODERATE, HIGH, VERY_HIGH)
     *
     * @example
     * ```typescript
     * const service = new SecurityMetricsService(dataProvider);
     * const estimates = service.getROIEstimates();
     *
     * console.log(estimates.HIGH.returnRate);        // "300%"
     * console.log(estimates.HIGH.description);       // "High ROI with significant risk reduction"
     * console.log(estimates.MODERATE.breakEvenPeriod); // "2 years"
     * ```
     */
    getROIEstimates(): ROIEstimatesMap;
    /**
     * Get comprehensive security metrics for selected security levels
     *
     * Calculates a complete security assessment including scores, costs, risk reduction,
     * compliance metrics, and component-specific analysis. This is the primary method
     * for obtaining a holistic view of security posture across all CIA triad components.
     *
     * @param availabilityLevel - Availability security level
     * @param integrityLevel - Integrity security level (defaults to availabilityLevel if not provided)
     * @param confidentialityLevel - Confidentiality security level (defaults to availabilityLevel if not provided)
     * @returns Comprehensive security metrics object with scores, costs, and assessments
     *
     * @example
     * ```typescript
     * const service = new SecurityMetricsService(dataProvider);
     *
     * // Get metrics for specific configuration
     * const metrics = service.getSecurityMetrics('High', 'Very High', 'Moderate');
     * console.log(metrics.overallScore);     // 75 (0-100 scale)
     * console.log(metrics.totalCost);        // 450000 (total CAPEX + OPEX)
     * console.log(metrics.riskReduction);    // "85%"
     * console.log(metrics.securityMaturity); // "Advanced"
     *
     * // Use uniform level across all components
     * const uniformMetrics = service.getSecurityMetrics('Moderate');
     * console.log(uniformMetrics.availability.level);      // "Moderate"
     * console.log(uniformMetrics.integrity.level);         // "Moderate"
     * console.log(uniformMetrics.confidentiality.level);   // "Moderate"
     *
     * // Access component-specific metrics
     * console.log(metrics.availability.score);           // Score for availability
     * console.log(metrics.availability.recommendations); // Recommendations array
     * ```
     */
    getSecurityMetrics(availabilityLevel: SecurityLevel, integrityLevel?: SecurityLevel, confidentialityLevel?: SecurityLevel): SecurityMetrics;
    /**
     * Get component-specific security metrics
     *
     * Provides detailed metrics for a single CIA component at a specific security level,
     * including score, description, recommendations, and cost information. Useful for
     * component-level analysis and detailed reporting.
     *
     * @param component - CIA component type ('availability', 'integrity', or 'confidentiality')
     * @param level - Security level for the component
     * @returns Component metrics with score, description, recommendations, and cost details
     *
     * @example
     * ```typescript
     * const service = new SecurityMetricsService(dataProvider);
     *
     * // Get metrics for availability at High level
     * const availMetrics = service.getComponentMetrics('availability', 'High');
     * console.log(availMetrics.score);         // 75 (0-100 scale)
     * console.log(availMetrics.level);         // "High"
     * console.log(availMetrics.description);   // "High availability with 99.9% uptime"
     * console.log(availMetrics.recommendations); // Array of improvement suggestions
     * console.log(availMetrics.capex);         // Capital expenditure cost
     * console.log(availMetrics.opex);          // Operational expenditure cost
     *
     * // Get metrics for integrity
     * const integrityMetrics = service.getComponentMetrics('integrity', 'Very High');
     * console.log(integrityMetrics.component); // "integrity"
     * ```
     */
    getComponentMetrics(component: CIAComponentType, level: SecurityLevel): ComponentMetrics;
    /**
     * Get technical metrics for a component
     *
     * @param component The CIA component
     * @param level The security level
     * @returns Component technical metrics
     */
    getComponentTechnicalMetrics(component: CIAComponentType, level: SecurityLevel): Record<string, string>;
    /**
     * Get impact metrics for a component and level
     *
     * @param component - CIA component type
     * @param level - Security level
     * @returns Impact metrics
     */
    getImpactMetrics(component: CIAComponentType, level: SecurityLevel): ImpactMetrics;
    /**
     * Calculate impact metrics based on security levels
     *
     * @param availabilityLevel - Availability security level
     * @param integrityLevel - Integrity security level
     * @param confidentialityLevel - Confidentiality security level
     * @returns Impact metrics
     */
    private calculateImpactMetrics;
    /**
     * Calculate financial impact level
     */
    private calculateFinancialImpactLevel;
    /**
     * Calculate operational impact level
     */
    private calculateOperationalImpactLevel;
    /**
     * Calculate reputational impact level
     */
    private calculateReputationalImpactLevel;
    /**
     * Calculate compliance impact level
     */
    private calculateComplianceImpactLevel;
    /**
     * Calculate risk reduction percentage for a combination of security levels
     *
     * @param availabilityLevel - Availability security level
     * @param integrityLevel - Integrity security level
     * @param confidentialityLevel - Confidentiality security level
     * @returns Risk reduction percentage as a string
     */
    private calculateRiskReduction;
    /**
     * Calculate risk reduction for a single security level
     *
     * @param level - Security level
     * @returns Risk reduction percentage
     */
    private calculateSingleComponentRiskReduction;
    /**
     * Get security level description based on level
     *
     * @param level - Security level
     * @returns Textual description of security level
     */
    getSecurityLevelDescription(level: SecurityLevel): string;
    /**
     * Get protection level based on security level
     *
     * @param level - Security level
     * @returns Protection level description
     */
    getProtectionLevel(level: SecurityLevel): string;
    /**
     * Get appropriate UI badge variant for a risk level
     *
     * @param riskLevel - Risk level string (High, Medium, Low, etc.)
     * @returns Badge variant name
     */
    getRiskBadgeVariant(riskLevel: string): "error" | "warning" | "info" | "success" | "neutral";
    /**
     * Get security icon for a security level
     *
     * @param level - Security level
     * @returns Security icon (emoji)
     */
    getSecurityIcon(level: SecurityLevel): string;
    /**
     * Get risk level based on security score
     *
     * @param score Security score (0-100)
     * @returns Risk level description
     */
    getRiskLevel(score: number): string;
    /**
     * Get security level from a numeric value
     *
     * @param value - Numeric security level value (0-4)
     * @returns Security level string representation
     */
    getSecurityLevelFromValue(value: number): SecurityLevel;
    /**
     * Calculate security score based on security levels
     *
     * @param availabilityLevel - Availability security level
     * @param integrityLevel - Integrity security level
     * @param confidentialityLevel - Confidentiality security level
     * @returns Security score (0-100)
     */
    calculateSecurityScore(availabilityLevel: SecurityLevel, integrityLevel?: SecurityLevel, confidentialityLevel?: SecurityLevel): number;
    /**
     * Calculate monitoring score based on security levels
     */
    private calculateMonitoringScore;
    /**
     * Calculate resilience score based on availability level
     */
    private calculateResilienceScore;
    /**
     * Calculate compliance score based on security levels
     */
    private calculateComplianceScore;
    /**
     * Calculate security maturity based on security levels
     */
    private calculateSecurityMaturity;
    /**
     * Calculate overall score based on security levels and other metrics
     */
    private calculateOverallScore;
    /**
     * Calculate average security level from an array of security levels
     */
    private calculateAverageSecurityLevel;
    /**
     * Convert security level to percentage value (0-100)
     */
    private securityLevelToPercentage;
    /**
     * Get security level value (0-4)
     */
    protected getSecurityLevelValue(level: SecurityLevel): number;
    /**
     * Get default security icon for a security level
     *
     * @param level - Security level
     * @returns Security icon (emoji)
     */
    protected getDefaultSecurityIcon(level: SecurityLevel): string;
}
/**
 * Create a SecurityMetricsService instance
 *
 * @param dataProvider - Optional data provider for the service
 * @returns A new SecurityMetricsService instance
 */
export declare function createSecurityMetricsService(dataProvider?: CIADataProvider): SecurityMetricsService;
/**
 * Get cost estimation based on security levels
 *
 * @param availabilityLevel - Availability security level
 * @param integrityLevel - Integrity security level
 * @param confidentialityLevel - Confidentiality security level
 * @returns Cost estimation details
 */
export declare const getCostEstimation: (availabilityLevel: SecurityLevel, integrityLevel: SecurityLevel, confidentialityLevel: SecurityLevel) => Promise<CostEstimation>;
/**
 * Get value creation metrics based on security levels
 *
 * @param availabilityLevel - Availability security level
 * @param integrityLevel - Integrity security level
 * @param confidentialityLevel - Confidentiality security level
 * @returns Value creation metrics
 */
export declare const getValueCreationMetrics: (availabilityLevel: SecurityLevel, integrityLevel: SecurityLevel, confidentialityLevel: SecurityLevel) => Promise<ValueCreationMetrics>;
/**
 * Get security metrics based on security levels
 *
 * @param availabilityLevel - Availability security level
 * @param integrityLevel - Integrity security level
 * @param confidentialityLevel - Confidentiality security level
 * @returns Security metrics
 */
export declare const getSecurityMetrics: (availabilityLevel: SecurityLevel, integrityLevel: SecurityLevel, confidentialityLevel: SecurityLevel) => Promise<SecurityMetrics>;
/**
 * Get technical details based on security levels
 *
 * @param availabilityLevel - Availability security level
 * @param integrityLevel - Integrity security level
 * @param confidentialityLevel - Confidentiality security level
 * @returns Technical details
 */
export declare const getTechnicalDetails: (availabilityLevel: SecurityLevel, integrityLevel: SecurityLevel, confidentialityLevel: SecurityLevel) => Promise<TechnicalDetailsResponse>;
/**
 * Get security resources based on security levels
 *
 * @param availabilityLevel - Availability security level
 * @param integrityLevel - Integrity security level
 * @param confidentialityLevel - Confidentiality security level
 * @returns Security resources
 */
export declare const getSecurityResources: (availabilityLevel: SecurityLevel, integrityLevel: SecurityLevel, confidentialityLevel: SecurityLevel) => Promise<Record<string, unknown>>;
//# sourceMappingURL=securityMetricsService.d.ts.map