import { EventEmitter } from "node:events";
import type { DLPConfig, DataClassification, EncryptedData, EncryptionConfig, EncryptionRule, KeyManagementConfig, SecurityMonitoringConfig, SecuritySeverity, ThreatEvent, ThreatProtectionConfig } from "./enterprise-security-manager";
export declare class SecurityError extends Error {
    code: string;
    details?: Record<string, unknown>;
    constructor(code: string, message: string, details?: Record<string, unknown>);
}
export interface ThreatSummary {
    totalThreats: number;
    activeMitigation: number;
    riskLevel: SecuritySeverity;
}
export interface EncryptionStatus {
    activeKeys: number;
    encryptedObjects: number;
    keyRotationStatus: string;
}
export interface DLPStatus {
    policiesActive: number;
    violationsToday: number;
    complianceScore: number;
}
export interface MonitoringStatus {
    uptime: number;
    eventsProcessed: number;
    alertsSent: number;
}
export declare class KeyManager extends EventEmitter {
    private config;
    private currentKeyIdValue;
    private dataKeys;
    private signingKeyPair;
    constructor(config: KeyManagementConfig);
    rotateKey(keyId?: string): Promise<void>;
    getKeysForRotation(): Promise<string[]>;
    keyExists(keyId: string): Promise<boolean>;
    resolveKey(keyId: string): Promise<Buffer>;
    deriveDataKey(_: unknown): Promise<Buffer>;
    currentKeyId(): Promise<string>;
    sign(data: Buffer): Promise<Buffer>;
    verifySignature(data: Buffer, signature: Buffer): Promise<boolean>;
    getKeyHealth(): Promise<SecuritySeverity>;
}
export declare class EncryptionEngine {
    private readonly config;
    private readonly keyManager;
    constructor(config: EncryptionConfig, keyManager: KeyManager);
    encrypt(data: unknown, rule: EncryptionRule, classification: DataClassification, opts?: {
        aad?: string;
    }): Promise<EncryptedData>;
    decrypt(enc: EncryptedData, opts?: {
        aad?: string;
    }): Promise<unknown>;
    getStatus(): Promise<EncryptionStatus>;
    getSecurityLevel(): Promise<SecuritySeverity>;
}
export declare class ThreatDetector extends EventEmitter {
    private config;
    constructor(config: ThreatProtectionConfig);
    detectIntrusions(_data: unknown, _context: Record<string, unknown>): Promise<ThreatEvent[]>;
    detectAnomalies(_data: unknown, _context: Record<string, unknown>): Promise<ThreatEvent[]>;
    scanMalware(_data: unknown, _context: Record<string, unknown>): Promise<ThreatEvent[]>;
    detectExfiltration(_data: unknown, _context: Record<string, unknown>): Promise<ThreatEvent[]>;
    getSummary(): Promise<ThreatSummary>;
    getRiskLevel(): Promise<SecuritySeverity>;
}
export declare class DLPEngine extends EventEmitter {
    private config;
    constructor(config: DLPConfig);
    inspect(data: unknown, _classification: DataClassification, _context?: Record<string, unknown>): Promise<{
        blocked: boolean;
        redacted: boolean;
        policy?: string;
        data?: unknown;
    }>;
    checkTransferPolicy(_data: unknown, _destination: string, _classification: DataClassification): Promise<void>;
    getStatus(): Promise<DLPStatus>;
    getComplianceLevel(): Promise<SecuritySeverity>;
}
export declare class SecurityMonitor extends EventEmitter {
    private config;
    constructor(config: SecurityMonitoringConfig);
    start(): void;
    recordEvent(_type: string, _data: Record<string, unknown>): Promise<void>;
    sendAlert(_alert: unknown): Promise<void>;
    getStatus(): Promise<MonitoringStatus>;
}
export declare class SecurityAuditLogger {
    logEncryption(classification: DataClassification, keyId: string, context?: Record<string, unknown>): Promise<void>;
    logDecryption(classification: DataClassification, keyId: string, context?: Record<string, unknown>): Promise<void>;
    logKeyRotation(keyId: string, status: string, _error?: unknown): Promise<void>;
    logThreat(threat: ThreatEvent): Promise<void>;
    logDLPViolation(violation: unknown): Promise<void>;
    logSecurityError(type: string, _error: unknown, context?: Record<string, unknown>): Promise<void>;
}