/**
 * llm-trust-guard
 *
 * Security guards for LLM-powered applications.
 * Implements the Trust-Aware Orchestration Architecture.
 *
 * @example
 * ```typescript
 * import { TrustGuard } from 'llm-trust-guard';
 *
 * const guard = new TrustGuard({
 *   registry: { tools: myTools },
 *   policy: { roleHierarchy: { customer: 0, admin: 1 } }
 * });
 *
 * const result = guard.check(toolName, params, session);
 * if (!result.allowed) {
 *   console.log('Blocked:', result.block_reason);
 * }
 * ```
 */
export * from "./types";
export { InputSanitizer, InputSanitizerConfig, PAPSanitizerResult } from "./guards/input-sanitizer";
export { ToolRegistry, ToolRegistryConfig } from "./guards/tool-registry";
export { PolicyGate, PolicyGateConfig } from "./guards/policy-gate";
export { TenantBoundary, TenantBoundaryConfig } from "./guards/tenant-boundary";
export { SchemaValidator, SchemaValidatorConfig } from "./guards/schema-validator";
export { ExecutionMonitor, ExecutionMonitorConfig } from "./guards/execution-monitor";
export { OutputFilter, OutputFilterConfig } from "./guards/output-filter";
export { ConversationGuard, ConversationGuardConfig } from "./guards/conversation-guard";
export { ToolChainValidator, ToolChainValidatorConfig } from "./guards/tool-chain-validator";
export { EncodingDetector, EncodingDetectorConfig } from "./guards/encoding-detector";
export { MultiModalGuard, MultiModalGuardConfig, MultiModalContent, MultiModalGuardResult } from "./guards/multimodal-guard";
export { MemoryGuard, MemoryGuardConfig, MemoryItem, MemoryGuardResult } from "./guards/memory-guard";
export { RAGGuard, RAGGuardConfig, RAGDocument, RAGGuardResult, EmbeddingAttackResult } from "./guards/rag-guard";
export { CodeExecutionGuard, CodeExecutionGuardConfig, CodeAnalysisResult, SandboxConfig, CodeFinding, CodeAnalyzerBackend } from "./guards/code-execution-guard";
export { AgentCommunicationGuard, AgentCommunicationGuardConfig, AgentIdentity, AgentMessage, MessageValidationResult } from "./guards/agent-communication-guard";
export { CircuitBreaker, CircuitBreakerConfig, CircuitState, CircuitStats, CircuitBreakerResult } from "./guards/circuit-breaker";
export { DriftDetector, DriftDetectorConfig, BehaviorSample, BaselineProfile, DriftAnalysis, DriftDetectorResult } from "./guards/drift-detector";
export { MCPSecurityGuard, MCPSecurityGuardConfig, MCPServerIdentity, MCPToolDefinition, MCPServerRegistration, MCPToolCall, MCPSamplingResponse, MCPSecurityResult } from "./guards/mcp-security-guard";
export { PromptLeakageGuard, PromptLeakageGuardConfig, PromptLeakageResult, OutputLeakageResult } from "./guards/prompt-leakage-guard";
export { TrustExploitationGuard, TrustExploitationGuardConfig, AgentAction, TrustContext, TrustExploitationResult } from "./guards/trust-exploitation-guard";
export { AutonomyEscalationGuard, AutonomyEscalationGuardConfig, AutonomyRequest, AgentCapabilities, AutonomyEscalationResult } from "./guards/autonomy-escalation-guard";
export { StatePersistenceGuard, StatePersistenceGuardConfig, StateItem, StateOperation, StatePersistenceResult } from "./guards/state-persistence-guard";
export { ToolResultGuard, ToolResultGuardConfig, ToolResultGuardResult, ToolResultThreat } from "./guards/tool-result-guard";
export { ContextBudgetGuard, ContextBudgetGuardConfig, ContextBudgetResult } from "./guards/context-budget-guard";
export { OutputSchemaGuard, OutputSchemaGuardConfig, OutputSchemaResult } from "./guards/output-schema-guard";
export { TokenCostGuard, TokenCostGuardConfig, TokenCostResult, TokenUsage } from "./guards/token-cost-guard";
export { HeuristicAnalyzer, HeuristicAnalyzerConfig, HeuristicResult, HeuristicFeatures } from "./guards/heuristic-analyzer";
export { CompressionDetector, CompressionDetectorConfig, CompressionDetectorResult } from "./guards/compression-detector";
export { ExternalDataGuard, ExternalDataGuardConfig, ExternalDataGuardResult, DataProvenance } from "./guards/external-data-guard";
export { AgentSkillGuard, AgentSkillGuardConfig, AgentSkillGuardResult, SkillDefinition, SkillThreat } from "./guards/agent-skill-guard";
export { SessionIntegrityGuard, SessionIntegrityGuardConfig, SessionIntegrityResult, SessionState } from "./guards/session-integrity-guard";
export { SpawnPolicyGuard, SpawnPolicyGuardConfig, SpawnRequest, SpawnPolicyResult } from "./guards/spawn-policy-guard";
export { DelegationScopeGuard, DelegationScopeGuardConfig, DelegationRequest, DelegationScopeResult } from "./guards/delegation-scope-guard";
export { TrustTransitivityGuard, TrustTransitivityGuardConfig, TransitivityMode, AgentTrustEntry, TrustChainLink, TrustTransitivityResult } from "./guards/trust-transitivity-guard";
export { OutputGuard, OutputGuardConfig, OutputGuardResult, OutputThreat, OutputSink } from "./guards/output-guard";
export { DetectionClassifier, DetectionResult, DetectionThreat, DetectionContext, createRegexClassifier, mergeDetectionResults } from "./detection-backend";
import { InputSanitizer } from "./guards/input-sanitizer";
import { ToolRegistry } from "./guards/tool-registry";
import { PolicyGate } from "./guards/policy-gate";
import { TenantBoundary } from "./guards/tenant-boundary";
import { SchemaValidator } from "./guards/schema-validator";
import { ExecutionMonitor } from "./guards/execution-monitor";
import { OutputFilter } from "./guards/output-filter";
import { ConversationGuard } from "./guards/conversation-guard";
import { ToolChainValidator } from "./guards/tool-chain-validator";
import { EncodingDetector } from "./guards/encoding-detector";
import { MultiModalGuard } from "./guards/multimodal-guard";
import { MemoryGuard } from "./guards/memory-guard";
import { RAGGuard } from "./guards/rag-guard";
import { CodeExecutionGuard } from "./guards/code-execution-guard";
import { AgentCommunicationGuard } from "./guards/agent-communication-guard";
import { CircuitBreaker } from "./guards/circuit-breaker";
import { DriftDetector } from "./guards/drift-detector";
import { MCPSecurityGuard } from "./guards/mcp-security-guard";
import { PromptLeakageGuard } from "./guards/prompt-leakage-guard";
import { TrustExploitationGuard } from "./guards/trust-exploitation-guard";
import { AutonomyEscalationGuard } from "./guards/autonomy-escalation-guard";
import { StatePersistenceGuard } from "./guards/state-persistence-guard";
import { ToolResultGuard } from "./guards/tool-result-guard";
import { ContextBudgetGuard } from "./guards/context-budget-guard";
import { OutputSchemaGuard } from "./guards/output-schema-guard";
import { TokenCostGuard } from "./guards/token-cost-guard";
import { TrustGuardConfig, TrustGuardResult, SessionContext, ToolDefinition, Role } from "./types";
/**
 * TrustGuard - Main facade for all security guards (27 integrated + 4 standalone)
 *
 * Combines all protection layers into a single, easy-to-use interface.
 *
 * Protection Layers (Original):
 * - L1: Input Sanitizer - Detects prompt injection patterns (PAP)
 * - L2: Tool Registry - Prevents tool hallucination attacks
 * - L3: Policy Gate - Enforces RBAC with constraint validation
 * - L4: Tenant Boundary - Multi-tenant isolation
 * - L5: Schema Validator - Parameter validation & injection detection
 * - L6: Execution Monitor - Rate limiting & resource quotas
 * - L7: Output Filter - PII scrubbing & secret detection
 * - Conversation Guard - Multi-turn manipulation detection
 * - Tool Chain Validator - Dangerous tool sequence detection
 * - Encoding Detector - Encoding bypass attack detection
 *
 * Protection Layers (2026):
 * - MultiModal Guard - Image/audio injection prevention
 * - Memory Guard - Memory poisoning prevention (ASI06)
 * - RAG Guard - RAG document & embedding attack prevention
 * - Code Execution Guard - Safe code execution sandboxing
 * - Agent Communication Guard - Multi-agent message security
 * - Circuit Breaker - Cascading failure prevention
 * - Drift Detector - Behavioral anomaly detection
 * - MCP Security Guard - MCP tool shadowing prevention
 * - Prompt Leakage Guard - System prompt extraction prevention
 * - Trust Exploitation Guard - Trust boundary enforcement (ASI09)
 * - Autonomy Escalation Guard - Unauthorized autonomy prevention (ASI10)
 * - State Persistence Guard - State corruption prevention (ASI08)
 */
export declare class TrustGuard {
    private sanitizer?;
    private registry?;
    private policy?;
    private tenant?;
    private schema?;
    private execution?;
    private output?;
    private conversation?;
    private chain?;
    private encoding?;
    private multiModal?;
    private memoryGuard?;
    private ragGuard?;
    private codeExecution?;
    private agentCommunication?;
    private circuitBreaker?;
    private driftDetector?;
    private mcpSecurity?;
    private promptLeakage?;
    private trustExploitation?;
    private autonomyEscalation?;
    private statePersistence?;
    private toolResultGuard?;
    private contextBudget?;
    private outputSchema?;
    private tokenCostGuard?;
    private classifier?;
    private onBlock?;
    private onAlert?;
    private onError?;
    private metrics;
    private maxInputLength;
    private failMode;
    private logger;
    constructor(config?: TrustGuardConfig);
    /**
     * Run all enabled guards on a tool call
     */
    check(toolName: string, params: Record<string, any>, session: SessionContext | undefined, options?: {
        userInput?: string;
        claimedRole?: Role;
        allToolsInRequest?: string[];
    }): TrustGuardResult;
    private runChecks;
    /**
     * Filter output for PII, secrets, and prompt leakage (L7 + Prompt Leakage)
     */
    filterOutput(output: any, role?: string, requestId?: string): {
        allowed: boolean;
        filtered: any;
        pii_detected: boolean;
        secrets_detected: boolean;
        prompt_leakage_detected: boolean;
    };
    /**
     * Mark an operation as complete (for rate limiting and circuit breaker)
     */
    completeOperation(session?: SessionContext, toolName?: string, success?: boolean): void;
    /**
     * Get tools available for a role
     */
    getToolsForRole(role: Role): ToolDefinition[];
    /**
     * Get individual guard instances for advanced usage.
     * All 22 guards are accessible through this method.
     */
    /**
     * Get runtime metrics for monitoring
     */
    getMetrics(): {
        totalChecks: number;
        blockedChecks: number;
        blockRate: number;
        avgExecutionTimeMs: number;
        errors: number;
    };
    getGuards(): {
        sanitizer: InputSanitizer | undefined;
        registry: ToolRegistry | undefined;
        policy: PolicyGate | undefined;
        tenant: TenantBoundary | undefined;
        schema: SchemaValidator | undefined;
        execution: ExecutionMonitor | undefined;
        output: OutputFilter | undefined;
        conversation: ConversationGuard | undefined;
        chain: ToolChainValidator | undefined;
        encoding: EncodingDetector | undefined;
        multiModal: MultiModalGuard | undefined;
        memory: MemoryGuard | undefined;
        rag: RAGGuard | undefined;
        codeExecution: CodeExecutionGuard | undefined;
        agentCommunication: AgentCommunicationGuard | undefined;
        circuitBreaker: CircuitBreaker | undefined;
        driftDetector: DriftDetector | undefined;
        mcpSecurity: MCPSecurityGuard | undefined;
        promptLeakage: PromptLeakageGuard | undefined;
        trustExploitation: TrustExploitationGuard | undefined;
        autonomyEscalation: AutonomyEscalationGuard | undefined;
        statePersistence: StatePersistenceGuard | undefined;
        toolResult: ToolResultGuard | undefined;
        contextBudget: ContextBudgetGuard | undefined;
        outputSchema: OutputSchemaGuard | undefined;
        tokenCost: TokenCostGuard | undefined;
    };
    /**
     * Reset session state across all session-aware guards
     */
    resetSession(sessionId: string): void;
    /**
     * Destroy all guards and release resources.
     * Call this on server shutdown or when the guard instance is no longer needed.
     */
    destroy(): void;
    /**
     * Validate a tool's return value before feeding it back to the LLM context.
     * Call this after tool execution, before sending the result to the LLM.
     */
    validateToolResult(toolName: string, result: any, requestId?: string): {
        allowed: boolean;
        violations: string[];
        filtered?: any;
    };
    /**
     * Validate LLM structured output (JSON, function calls) before sending to downstream systems.
     */
    validateOutput(output: any, schemaName?: string, requestId?: string): {
        allowed: boolean;
        violations: string[];
        threats: Array<{
            field: string;
            type: string;
            detail: string;
        }>;
    };
    /**
     * Async version of check() that also runs the pluggable detection classifier.
     * Use this when you have an ML-based or API-based classifier configured.
     * Falls back to sync check() when no classifier is configured.
     */
    checkAsync(toolName: string, params: Record<string, any>, session: SessionContext | undefined, options?: {
        userInput?: string;
        claimedRole?: Role;
        allToolsInRequest?: string[];
    }): Promise<TrustGuardResult>;
}
export * from "./integrations/index.js";
export default TrustGuard;