/**
 * SessionIntegrityGuard (L28)
 *
 * Prevents agent session smuggling, hijacking, and state tampering.
 * Inspired by Unit42 research on agent session attacks.
 *
 * Threat Model:
 * - Session token tampering and forgery
 * - Privilege escalation within established sessions
 * - Session hijacking via replay or sequence manipulation
 * - Concurrent session abuse
 *
 * Protection Capabilities:
 * - Session binding with token integrity verification
 * - Permission consistency enforcement (no escalation)
 * - Inactivity and absolute timeout enforcement
 * - Concurrent session limits per user
 * - State continuity validation
 * - Request sequence validation (replay/reorder detection)
 * - Scope binding and authority degradation
 *
 * This is an ARCHITECTURAL guard — it enforces session boundaries
 * regardless of detection. Even if an attacker injects a prompt,
 * they cannot escalate session permissions or hijack sessions.
 */
import { GuardLogger } from "../types";
export interface SessionIntegrityGuardConfig {
    /** Absolute session timeout in ms (default: 3600000 = 1hr) */
    maxSessionDuration?: number;
    /** Inactivity timeout in ms (default: 900000 = 15min) */
    inactivityTimeout?: number;
    /** Maximum concurrent sessions per user (default: 5) */
    maxConcurrentSessions?: number;
    /** Enforce permission consistency — block escalation attempts (default: true) */
    enforcePermissionConsistency?: boolean;
    /** Enforce request sequence validation — detect replay/reorder (default: true) */
    enforceSequenceValidation?: boolean;
    /** Allow permission escalation during a session (default: false) */
    allowPermissionEscalation?: boolean;
    /** Optional logger */
    logger?: GuardLogger;
}
export interface SessionState {
    /** Session identifier */
    sessionId: string;
    /** User who owns the session */
    userId: string;
    /** Permissions granted at session creation */
    initialPermissions: Set<string>;
    /** Current active permissions (can only shrink) */
    currentPermissions: Set<string>;
    /** Session creation timestamp */
    createdAt: number;
    /** Last activity timestamp */
    lastActivity: number;
    /** Monotonically increasing sequence counter */
    sequenceNumber: number;
    /** Set of seen request nonces for replay detection */
    seenNonces: Set<string>;
    /** Whether the session is still active */
    active: boolean;
    /** Optional metadata */
    metadata?: Record<string, unknown>;
}
export interface SessionIntegrityResult {
    allowed: boolean;
    reason?: string;
    violations: string[];
    /** Milliseconds since session creation */
    sessionAge?: number;
    /** Milliseconds since last request */
    lastActivity?: number;
    /** Permission changes detected */
    permissionDelta?: string[];
}
export declare class SessionIntegrityGuard {
    private config;
    private sessions;
    private userSessions;
    constructor(config?: SessionIntegrityGuardConfig);
    /**
     * Register a new session. Enforces concurrent session limits.
     */
    createSession(sessionId: string, userId: string, permissions: string[], metadata?: Record<string, unknown>): SessionIntegrityResult;
    /**
     * Validate a request within an existing session.
     * Enforces timeouts, permissions, sequence ordering, and scope binding.
     */
    validateRequest(sessionId: string, action: string, requestedPermissions?: string[], nonce?: string, sequenceNumber?: number): SessionIntegrityResult;
    /**
     * Degrade permissions for a session. Permissions can only be removed, never added.
     */
    degradePermissions(sessionId: string, permissionsToRemove: string[]): SessionIntegrityResult;
    /**
     * Terminate a session and clean up state.
     */
    endSession(sessionId: string): SessionIntegrityResult;
    /**
     * List active sessions for a user.
     */
    getActiveSessions(userId: string): string[];
    /**
     * Detect abrupt state changes — e.g., a read-only session attempting destructive actions.
     */
    private isAbruptStateChange;
    /**
     * Mark session inactive and remove from user tracking.
     */
    private terminateSession;
    /**
     * Purge expired sessions for a user to reclaim concurrent session slots.
     */
    private purgeExpiredSessions;
    private log;
}