/**
 * Security Configuration Management System
 * Provides centralized security policy and configuration management
 */
interface SecurityPolicy {
    id: string;
    name: string;
    version: string;
    description: string;
    enabled: boolean;
    scope: "global" | "environment" | "application" | "endpoint";
    rules: SecurityPolicyRule[];
    compliance: {
        frameworks: string[];
        requirements: string[];
    };
    metadata: {
        created: Date;
        updated: Date;
        author: string;
        approved: boolean;
    };
}
interface SecurityPolicyRule {
    id: string;
    name: string;
    type: "authentication" | "authorization" | "input-validation" | "crypto" | "session" | "logging" | "monitoring";
    action: "enforce" | "warn" | "log" | "block";
    conditions: {
        environments?: string[];
        methods?: string[];
        paths?: string[];
        userRoles?: string[];
    };
    parameters: Record<string, unknown>;
    exceptions: string[];
}
interface SecurityConfiguration {
    configId: string;
    version: string;
    environment: string;
    policies: SecurityPolicy[];
    settings: {
        authentication: AuthenticationSettings;
        authorization: AuthorizationSettings;
        inputValidation: InputValidationSettings;
        cryptography: CryptographySettings;
        session: SessionSettings;
        logging: LoggingSettings;
        monitoring: MonitoringSettings;
    };
    overrides: Record<string, unknown>;
    metadata: {
        lastUpdated: Date;
        checksum: string;
    };
}
interface AuthenticationSettings {
    methods: ("password" | "jwt" | "oauth" | "api-key")[];
    passwordPolicy: {
        minLength: number;
        requireUppercase: boolean;
        requireLowercase: boolean;
        requireNumbers: boolean;
        requireSpecialChars: boolean;
        maxAge: number;
        preventReuse: number;
    };
    jwtSettings: {
        algorithm: string;
        expiresIn: string;
        issuer: string;
        audience: string;
    };
    rateLimiting: {
        maxAttempts: number;
        windowMs: number;
        blockDuration: number;
    };
    mfa: {
        enabled: boolean;
        methods: string[];
        required: boolean;
    };
}
interface AuthorizationSettings {
    rbac: {
        enabled: boolean;
        defaultRole: string;
        roleHierarchy: Record<string, string[]>;
    };
    permissions: {
        strict: boolean;
        defaultDeny: boolean;
        inheritance: boolean;
    };
    sessionTimeout: number;
    resourceAccess: {
        checkOrigin: boolean;
        allowedOrigins: string[];
        csrfProtection: boolean;
    };
}
interface InputValidationSettings {
    sanitization: {
        enabled: boolean;
        htmlStripping: boolean;
        sqlEscaping: boolean;
        jsEscaping: boolean;
    };
    validation: {
        strict: boolean;
        maxStringLength: number;
        maxFileSize: number;
        allowedFileTypes: string[];
        blockedPatterns: string[];
    };
    xssProtection: {
        enabled: boolean;
        mode: "filter" | "block";
        reportUri: string;
    };
}
interface CryptographySettings {
    encryption: {
        algorithm: "AES-256-GCM" | "AES-256-CBC" | "ChaCha20-Poly1305";
        keyDerivation: "PBKDF2" | "scrypt" | "Argon2";
        keyRotation: {
            enabled: boolean;
            intervalDays: number;
        };
    };
    hashing: {
        algorithm: "bcrypt" | "scrypt" | "Argon2";
        saltRounds: number;
    };
    tls: {
        minVersion: string;
        cipherSuites: string[];
        hsts: {
            enabled: boolean;
            maxAge: number;
            includeSubDomains: boolean;
        };
    };
}
interface SessionSettings {
    storage: "memory" | "redis" | "database";
    security: {
        httpOnly: boolean;
        secure: boolean;
        sameSite: "strict" | "lax" | "none";
    };
    timeout: {
        idle: number;
        absolute: number;
    };
    regeneration: {
        onLogin: boolean;
        onPrivilegeChange: boolean;
        interval: number;
    };
}
interface LoggingSettings {
    level: "error" | "warn" | "info" | "debug";
    security: {
        logFailedAuth: boolean;
        logPrivilegeEscalation: boolean;
        logDataAccess: boolean;
        logConfigChanges: boolean;
    };
    retention: {
        days: number;
        compression: boolean;
        encryption: boolean;
    };
    alerting: {
        enabled: boolean;
        thresholds: Record<string, number>;
        channels: string[];
    };
}
interface MonitoringSettings {
    realTime: {
        enabled: boolean;
        metrics: string[];
        alertThresholds: Record<string, number>;
    };
    anomalyDetection: {
        enabled: boolean;
        sensitivity: "low" | "medium" | "high";
        models: string[];
    };
    compliance: {
        enabled: boolean;
        frameworks: string[];
        reportingSchedule: string;
    };
}
/**
 * Security Configuration Manager
 */
export declare class SecurityConfigManager {
    private configurations;
    private policies;
    private configPath;
    constructor(configPath?: string);
    /**
     * Initialize security configuration manager
     */
    initialize(): Promise<void>;
    /**
     * Create a new security policy
     */
    createPolicy(policyData: Omit<SecurityPolicy, "id" | "metadata">): Promise<SecurityPolicy>;
    /**
     * Update an existing security policy
     */
    updatePolicy(policyId: string, updates: Partial<SecurityPolicy>): Promise<SecurityPolicy>;
    /**
     * Create a new security configuration
     */
    createConfiguration(environment: string, configData: Partial<SecurityConfiguration>): Promise<SecurityConfiguration>;
    /**
     * Get configuration for environment
     */
    getConfiguration(environment: string): SecurityConfiguration | null;
    /**
     * Get all configurations
     */
    getAllConfigurations(): SecurityConfiguration[];
    /**
     * Apply policies to configuration
     */
    applyPoliciesToConfiguration(environment: string, policyIds: string[]): Promise<SecurityConfiguration>;
    /**
     * Validate configuration compliance
     */
    validateCompliance(environment: string): Promise<{
        compliant: boolean;
        violations: string[];
        recommendations: string[];
    }>;
    /**
     * Generate default security settings
     */
    private getDefaultSettings;
    /**
     * Load configurations from files
     */
    private loadConfigurations;
    /**
     * Load policies from files
     */
    private loadPolicies;
    /**
     * Save configuration to file
     */
    private saveConfigurationToFile;
    /**
     * Save policy to file
     */
    private savePolicyToFile;
    /**
     * Ensure config directory exists
     */
    private ensureConfigDirectory;
    /**
     * Calculate configuration checksum
     */
    private calculateChecksum;
    /**
     * Get all policies
     */
    getAllPolicies(): SecurityPolicy[];
    /**
     * Get policy by ID
     */
    getPolicy(policyId: string): SecurityPolicy | null;
    /**
     * Delete policy
     */
    deletePolicy(policyId: string): Promise<boolean>;
    /**
     * Export configuration
     */
    exportConfiguration(environment: string): Promise<string>;
    /**
     * Import configuration
     */
    importConfiguration(configData: string): Promise<SecurityConfiguration>;
}
export {};
//# sourceMappingURL=SecurityConfigManager.d.ts.map