type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
type ComplianceStatus = 'PASS' | 'PARTIAL' | 'FAIL';
interface Finding {
    id: string;
    category: 'memory_poisoning' | 'tool_poisoning' | 'compliance';
    severity: RiskLevel;
    title: string;
    description: string;
    details: string;
    recommendation: string;
    evidence?: any;
}
interface ComplianceResults {
    nist_ai_rmf: ComplianceStatus;
    iso_42001: ComplianceStatus;
    eu_ai_act_high_risk: ComplianceStatus;
    soc2_ai: ComplianceStatus;
}
interface AuditReport {
    audit_id: string;
    version: string;
    timestamp: string;
    mcp_server_url: string;
    overall_risk: RiskLevel;
    risk_score_0_100: number;
    findings_count: number;
    critical_findings: number;
    memory_poisoning_detected: boolean;
    tool_poisoning_detected: boolean;
    compliance: ComplianceResults;
    findings: Finding[];
    recommendations: string[];
    deepsweep_promo: string;
}
interface MCPServerConfig {
    url?: string;
    file?: string;
    docker?: boolean;
    apiKey?: string;
    bearerToken?: string;
}
interface AuditOptions {
    json?: boolean;
    html?: boolean;
    pdf?: boolean;
    share?: boolean;
    demo?: boolean;
    output?: string;
    telemetry?: boolean;
}
interface MCPSession {
    messages: any[];
    memory: any[];
    tools: any[];
    metadata: Record<string, any>;
}
interface MCPConnection {
    connect(): Promise<void>;
    getSession(): Promise<MCPSession>;
    disconnect(): Promise<void>;
}
interface Detector {
    name: string;
    category: 'memory_poisoning' | 'tool_poisoning';
    detect(session: MCPSession): Promise<Finding[]>;
}
interface ComplianceChecker {
    name: string;
    check(session: MCPSession, findings: Finding[]): Promise<ComplianceStatus>;
}

declare class Auditor {
    private config;
    private connector?;
    constructor(config: MCPServerConfig);
    audit(): Promise<AuditReport>;
    private generateRecommendations;
    private calculateRiskLevel;
}

declare class RemoteMCPConnector implements MCPConnection {
    private config;
    private httpClient?;
    private wsClient?;
    private session;
    constructor(config: MCPServerConfig);
    connect(): Promise<void>;
    private connectWebSocket;
    private connectHTTP;
    getSession(): Promise<MCPSession>;
    private fetchSessionComponents;
    private parseSessionData;
    disconnect(): Promise<void>;
}

declare class FileMCPConnector implements MCPConnection {
    private config;
    private session?;
    constructor(config: MCPServerConfig);
    connect(): Promise<void>;
    getSession(): Promise<MCPSession>;
    disconnect(): Promise<void>;
}

declare class LocalMCPConnector implements MCPConnection {
    private config;
    private remoteConnector?;
    private detectedPort?;
    constructor(config: MCPServerConfig);
    connect(): Promise<void>;
    getSession(): Promise<MCPSession>;
    disconnect(): Promise<void>;
    getDetectedPort(): number | undefined;
}

declare function createConnector(config: MCPServerConfig): MCPConnection;

declare class RecursiveInstructionsDetector implements Detector {
    name: string;
    category: "memory_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private extractContent;
    private detectSelfReferencingLoops;
    private truncate;
}

declare class PersistentOverridesDetector implements Detector {
    name: string;
    category: "memory_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private extractContent;
    private findDuplicatePersistentInstructions;
    private truncate;
}

declare class EncodedInjectionsDetector implements Detector {
    name: string;
    category: "memory_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private extractContent;
    private findBase64Strings;
    private findURLEncodedStrings;
    private findHexStrings;
    private isSuspicious;
    private truncate;
}

declare class MaliciousSignaturesDetector implements Detector {
    name: string;
    category: "memory_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private extractContent;
    private truncate;
}

declare class EntropyAnomalyDetector implements Detector {
    name: string;
    category: "memory_poisoning";
    private readonly HIGH_ENTROPY_THRESHOLD;
    private readonly VERY_HIGH_ENTROPY_THRESHOLD;
    detect(session: MCPSession): Promise<Finding[]>;
    private calculateEntropy;
    private detectEntropyAnomalies;
    private extractContent;
    private truncate;
}

declare class GoalDriftDetector implements Detector {
    name: string;
    category: "memory_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private extractSystemPrompt;
    private extractLaterContent;
    private calculateSemanticSimilarity;
    private tokenize;
    private detectGoalManipulation;
    private extractContent;
    private truncate;
}

declare function getAllMemoryDetectors(): Detector[];

declare class BroadPermissionsDetector implements Detector {
    name: string;
    category: "tool_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private getToolName;
    private extractPermissions;
    private sanitizeTool;
}

declare class RuntimeAdditionsDetector implements Detector {
    name: string;
    category: "tool_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private getToolName;
    private getInitialTools;
    private getLaterTools;
    private getTimestamp;
    private isDynamicTool;
    private hasAuthorizationMetadata;
    private sanitizeTool;
}

declare class SuspiciousParametersDetector implements Detector {
    name: string;
    category: "tool_poisoning";
    detect(session: MCPSession): Promise<Finding[]>;
    private getToolName;
    private extractParameters;
    private isUnboundedString;
    private acceptsArbitraryCode;
    private sanitizeTool;
    private truncate;
}

declare function getAllToolDetectors(): Detector[];

declare function getAllDetectors(): Detector[];

declare class NISTAIRMFChecker implements ComplianceChecker {
    name: string;
    check(session: MCPSession, findings: Finding[]): Promise<ComplianceStatus>;
    private checkGovernance;
    private checkMapping;
    private checkMeasurement;
    private checkManagement;
}

declare class ISO42001Checker implements ComplianceChecker {
    name: string;
    check(session: MCPSession, findings: Finding[]): Promise<ComplianceStatus>;
    private checkRiskManagement;
    private checkDataGovernance;
    private checkTransparency;
    private checkMonitoring;
    private checkIncidentManagement;
}

declare class SOC2Checker implements ComplianceChecker {
    name: string;
    check(session: MCPSession, findings: Finding[]): Promise<ComplianceStatus>;
    private checkSecurityViolations;
    private checkIntegrityViolations;
    private checkConfidentialityViolations;
    private checkSecurityControls;
    private checkAccessControls;
    private checkAuditLogging;
}

declare class EUAIActChecker implements ComplianceChecker {
    name: string;
    check(session: MCPSession, findings: Finding[]): Promise<ComplianceStatus>;
    private checkRiskManagement;
    private checkDataGovernance;
    private checkDocumentation;
    private checkRecordKeeping;
    private checkTransparency;
    private checkHumanOversight;
    private checkCybersecurity;
}

declare function runComplianceChecks(session: MCPSession, findings: Finding[]): Promise<ComplianceResults>;

declare function generateJSONReport(report: AuditReport, outputPath: string): Promise<void>;

declare function generateConsoleReport(report: AuditReport): string;

declare function generateHTMLReport(report: AuditReport, outputPath: string): Promise<void>;

declare function generatePDFReport(report: AuditReport, outputPath: string): Promise<void>;

export { type AuditOptions, type AuditReport, Auditor, BroadPermissionsDetector, type ComplianceChecker, type ComplianceResults, type ComplianceStatus, type Detector, EUAIActChecker, EncodedInjectionsDetector, EntropyAnomalyDetector, FileMCPConnector, type Finding, GoalDriftDetector, ISO42001Checker, LocalMCPConnector, type MCPConnection, type MCPServerConfig, type MCPSession, MaliciousSignaturesDetector, NISTAIRMFChecker, PersistentOverridesDetector, RecursiveInstructionsDetector, RemoteMCPConnector, type RiskLevel, RuntimeAdditionsDetector, SOC2Checker, SuspiciousParametersDetector, createConnector, generateConsoleReport, generateHTMLReport, generateJSONReport, generatePDFReport, getAllDetectors, getAllMemoryDetectors, getAllToolDetectors, runComplianceChecks };