import { EventEmitter } from 'events';
import { ChatSession, SessionBranch, ConversationMessage, ProjectMemory, UserProfile } from '../types/memory';
import { ProjectContext } from '../types';
import { MemoryManager } from './memory-manager';
import { ConversationMemory } from './conversation-memory';
import { ProjectContextStorage } from './project-context-storage';
import { LearningAdaptationEngine } from './learning-adaptation';
export interface SessionConfig {
    maxActiveSessions: number;
    sessionTimeout: number;
    autoSaveInterval: number;
    branchingEnabled: boolean;
    crossDeviceSyncEnabled: boolean;
    sessionRestorationEnabled: boolean;
    contextWindow: number;
}
export interface SessionState {
    sessionId: string;
    userId?: string;
    projectPath?: string;
    workingDirectory: string;
    currentBranch?: string;
    parentSession?: string;
    createdAt: Date;
    lastActivity: Date;
    messageCount: number;
    status: 'active' | 'paused' | 'ended' | 'merged';
    contextData: SessionContextData;
    checkpoints: SessionCheckpoint[];
}
export interface SessionContextData {
    activeFiles: string[];
    recentCommands: string[];
    projectContext?: ProjectContext;
    userPreferences: Record<string, unknown>;
    environmentVariables: Record<string, string>;
    workflowState: Record<string, unknown>;
    temporaryData: Record<string, unknown>;
}
export interface SessionCheckpoint {
    id: string;
    timestamp: Date;
    description: string;
    state: SessionContextData;
    messageCount: number;
    automatic: boolean;
    tags: string[];
}
export interface SessionRestoreOptions {
    includeMessages: boolean;
    includeContext: boolean;
    includeCheckpoints: boolean;
    restorePoint?: Date | string;
    mergeBranches: boolean;
}
export interface SessionSnapshot {
    sessionId: string;
    timestamp: Date;
    state: SessionState;
    messages: ConversationMessage[];
    projectSnapshot?: ProjectMemory;
    userProfile?: UserProfile;
    checksumValidation: string;
}
export interface BranchingStrategy {
    maxBranches: number;
    autoMergeThreshold: number;
    conflictResolution: 'manual' | 'automatic' | 'prompt';
    branchNamingPattern: string;
}
export interface CrossDeviceSync {
    enabled: boolean;
    deviceId: string;
    lastSyncTime: Date;
    conflictingDevices: string[];
    syncStrategy: 'latest' | 'merge' | 'manual';
}
export declare class SessionManager extends EventEmitter {
    private logger;
    private memoryManager;
    private conversationMemory;
    private projectStorage;
    private learningEngine;
    private config;
    private activeSessions;
    private sessionCheckpoints;
    private branchingStrategy;
    private crossDeviceSync;
    private autoSaveTimer?;
    private cleanupTimer?;
    constructor(memoryManager: MemoryManager, conversationMemory: ConversationMemory, projectStorage: ProjectContextStorage, learningEngine: LearningAdaptationEngine, config?: SessionConfig);
    createSession(userId?: string, projectPath?: string, workingDirectory?: string): Promise<SessionState>;
    restoreSession(sessionId: string, options?: SessionRestoreOptions): Promise<SessionState | null>;
    pauseSession(sessionId: string): Promise<boolean>;
    resumeSession(sessionId: string): Promise<boolean>;
    endSession(sessionId: string, reason?: string): Promise<boolean>;
    createBranch(parentSessionId: string, reason: string, description?: string): Promise<string | null>;
    mergeBranches(targetSession: SessionState, branches: SessionBranch[]): Promise<boolean>;
    createCheckpoint(sessionId: string, description: string, automatic?: boolean, tags?: string[]): Promise<string | null>;
    restoreFromCheckpoint(sessionId: string, checkpointId: string): Promise<boolean>;
    updateSessionContext(sessionId: string, contextUpdates: Partial<SessionContextData>): Promise<boolean>;
    getSessionState(sessionId: string): Promise<SessionState | null>;
    getActiveSessionIds(): Promise<string[]>;
    getSessionHistory(userId?: string, projectPath?: string, limit?: number): Promise<ChatSession[]>;
    syncSessions(): Promise<boolean>;
    createSnapshot(sessionId: string): Promise<SessionSnapshot | null>;
    exportSession(sessionId: string, format?: 'json' | 'csv' | 'markdown'): Promise<string | null>;
    private saveSessionState;
    private loadCheckpoints;
    private saveCheckpoint;
    private findRestorePoint;
    private extractUserId;
    private captureEnvironment;
    private getBranches;
    private generateBranchName;
    private automaticMerge;
    private requestManualMerge;
    private promptForMerge;
    private handleSyncConflicts;
    private calculateSnapshotChecksum;
    private convertSnapshotToCsv;
    private convertSnapshotToMarkdown;
    private startAutoSave;
    private startCleanup;
    private performAutoSave;
    private performCleanup;
    private cleanupInactiveSessions;
    private generateSessionId;
    private generateCheckpointId;
    private generateDeviceId;
    shutdown(): Promise<void>;
}
//# sourceMappingURL=session-manager.d.ts.map