/**
 * MemoryGuard (L9)
 *
 * Protects persistent memory/context from poisoning attacks.
 * Prevents cross-session contamination and instruction injection in stored context.
 *
 * Threat Model:
 * - ASI06: Memory & Context Poisoning
 * - Memory Persistence Attacks (cross-session instruction injection)
 * - Context window manipulation
 *
 * Protection Capabilities:
 * - Memory content integrity verification
 * - Instruction injection detection in stored context
 * - Cross-session contamination prevention
 * - Memory rollback capabilities
 * - Cryptographic content signing
 */
export interface MemoryGuardConfig {
    /** Enable content integrity checking */
    enableIntegrityCheck?: boolean;
    /** Enable injection detection in memory */
    detectInjections?: boolean;
    /** Maximum memory items per session */
    maxMemoryItems?: number;
    /** Maximum age of memory items in milliseconds */
    maxMemoryAge?: number;
    /** Secret key for HMAC signing (auto-generated if not provided) */
    signingKey?: string;
    /** Enable automatic quarantine of suspicious content */
    autoQuarantine?: boolean;
    /** Risk threshold for blocking (0-100) */
    riskThreshold?: number;
}
export interface MemoryItem {
    /** Unique identifier for the memory item */
    id: string;
    /** The actual content stored */
    content: string;
    /** Source of the memory (user, assistant, system, external) */
    source: "user" | "assistant" | "system" | "external" | "rag";
    /** Timestamp when created */
    timestamp: number;
    /** Session ID that created this memory */
    sessionId: string;
    /** Optional metadata */
    metadata?: Record<string, any>;
    /** Integrity signature */
    signature?: string;
    /** Trust score (0-100) */
    trustScore?: number;
}
export interface MemoryGuardResult {
    allowed: boolean;
    reason: string;
    violations: string[];
    request_id: string;
    memory_analysis: {
        items_checked: number;
        items_quarantined: number;
        injection_attempts: number;
        integrity_failures: number;
        cross_session_contamination: boolean;
        risk_score: number;
    };
    quarantined_items: string[];
    recommendations: string[];
}
export interface MemoryWriteResult {
    allowed: boolean;
    reason: string;
    violations: string[];
    request_id: string;
    item_id?: string;
    signature?: string;
    sanitized_content?: string;
}
export declare class MemoryGuard {
    private config;
    private signingKey;
    private quarantine;
    private memoryStore;
    private integrityCache;
    private readonly MEMORY_INJECTION_PATTERNS;
    private readonly CONTAMINATION_PATTERNS;
    constructor(config?: MemoryGuardConfig);
    /**
     * Check if content is safe to write to memory
     */
    checkWrite(content: string, source: MemoryItem["source"], sessionId: string, metadata?: Record<string, any>, requestId?: string): MemoryWriteResult;
    /**
     * Check if memory items are safe to read/use
     */
    checkRead(sessionId: string, itemIds?: string[], requestId?: string): MemoryGuardResult;
    /**
     * Validate external memory/context before injecting into prompts
     */
    validateContextInjection(context: string | string[], sessionId: string, requestId?: string): MemoryGuardResult;
    /**
     * Get safe memory items for a session (excluding quarantined)
     */
    getSafeMemory(sessionId: string): MemoryItem[];
    /**
     * Rollback memory to a specific point in time
     */
    rollbackMemory(sessionId: string, beforeTimestamp: number): number;
    /**
     * Clear quarantine for a session
     */
    clearQuarantine(sessionId?: string): number;
    /**
     * Clear all memory for a session
     */
    clearSession(sessionId: string): void;
    /**
     * Get quarantined items for review
     */
    getQuarantinedItems(sessionId?: string): MemoryItem[];
    private preprocessContent;
    private signContent;
    private sanitizeContent;
    private quarantineItem;
    private generateRecommendations;
}