import { EventEmitter } from 'events';
import { AtomicTask, Project, TaskStatus, TaskPriority } from '../types/task.js';
import { EnhancedError } from '../utils/enhanced-errors.js';
import { Result } from './unified-lifecycle-manager.js';
export type StorageId = string & {
    readonly __brand: 'StorageId';
};
export type TransactionId = string & {
    readonly __brand: 'TransactionId';
};
export type BackupId = string & {
    readonly __brand: 'BackupId';
};
export type CacheKey = string & {
    readonly __brand: 'CacheKey';
};
export declare function createStorageId(id: string): StorageId;
export declare function createTransactionId(id: string): TransactionId;
export declare function createBackupId(id: string): BackupId;
export declare function createCacheKey(key: string): CacheKey;
export type StorageFormat = 'json' | 'yaml' | 'binary' | 'compressed';
export type StorageOperation = 'create' | 'read' | 'update' | 'delete' | 'list' | 'search';
export type StorageEntity = 'task' | 'project' | 'dependency' | 'epic' | 'graph';
export type TransactionStatus = 'pending' | 'committed' | 'rolled_back' | 'failed';
export interface CacheConfig {
    enabled: boolean;
    maxSize: number;
    ttlSeconds: number;
    compressionEnabled: boolean;
    persistToDisk: boolean;
}
export interface BackupConfig {
    enabled: boolean;
    intervalMinutes: number;
    maxBackups: number;
    compressionEnabled: boolean;
    encryptionEnabled: boolean;
    remoteBackupEnabled: boolean;
}
export interface StorageTransaction {
    id: TransactionId;
    status: TransactionStatus;
    operations: StorageOperation[];
    entities: StorageEntity[];
    startTime: Date;
    endTime?: Date;
    rollbackData: Map<string, unknown>;
    metadata: {
        initiator: string;
        reason: string;
        priority: 'low' | 'medium' | 'high';
    };
}
export interface CacheEntry<T = unknown> {
    key: CacheKey;
    value: T;
    createdAt: Date;
    expiresAt: Date;
    accessCount: number;
    lastAccessed: Date;
    size: number;
    compressed: boolean;
}
export interface StorageBackup {
    id: BackupId;
    createdAt: Date;
    size: number;
    entities: StorageEntity[];
    compressed: boolean;
    encrypted: boolean;
    checksum: string;
    metadata: {
        version: string;
        creator: string;
        description: string;
    };
}
export interface StorageStatistics {
    totalOperations: number;
    operationsByType: Record<StorageOperation, number>;
    operationsByEntity: Record<StorageEntity, number>;
    averageResponseTime: number;
    cacheHitRate: number;
    storageSize: number;
    activeTransactions: number;
    totalBackups: number;
    errorRate: number;
}
export interface TaskIndex {
    tasks: Array<{
        id: string;
        title: string;
        status: TaskStatus;
        priority: TaskPriority;
        projectId: string;
        epicId: string;
        estimatedHours: number;
        createdAt: Date;
        updatedAt: Date;
    }>;
    lastUpdated: string;
    version: string;
}
export interface ProjectIndex {
    projects: Array<{
        id: string;
        name: string;
        createdAt: Date;
        updatedAt: Date;
    }>;
    lastUpdated: string;
    version: string;
}
export interface DependencyIndex {
    dependencies: Array<{
        id: string;
        fromTaskId: string;
        toTaskId: string;
        type: string;
        critical: boolean;
        createdAt: Date;
    }>;
    lastUpdated: string;
    version: string;
}
export interface EpicIndex {
    epics: string[];
    lastUpdated: string;
    version: string;
}
export interface UnifiedStorageEngineConfig {
    dataDirectory: string;
    format: StorageFormat;
    cache: CacheConfig;
    backup: BackupConfig;
    performance: {
        batchSize: number;
        maxConcurrentOperations: number;
        enableCompression: boolean;
        enableEncryption: boolean;
    };
    monitoring: {
        enableMetrics: boolean;
        metricsInterval: number;
        enableAuditLog: boolean;
        enablePerformanceTracking: boolean;
    };
}
export declare class UnifiedStorageEngine extends EventEmitter {
    private static instance;
    private readonly config;
    private readonly dataDirectory;
    private initialized;
    private readonly cache;
    private readonly transactions;
    private readonly backups;
    private taskIndex;
    private projectIndex;
    private dependencyIndex;
    private epicIndex;
    private operationCount;
    private operationsByType;
    private operationsByEntity;
    private totalResponseTime;
    private cacheHits;
    private cacheRequests;
    private backupTimer;
    private cacheCleanupTimer;
    private metricsTimer;
    private constructor();
    static getInstance(config?: UnifiedStorageEngineConfig): UnifiedStorageEngine;
    static resetInstance(): void;
    initialize(): Promise<Result<void, EnhancedError>>;
    private createDirectoryStructure;
    private loadIndexes;
    private startBackgroundProcesses;
    createTask(task: AtomicTask): Promise<Result<AtomicTask, EnhancedError>>;
    getTask(taskId: string): Promise<Result<AtomicTask, EnhancedError>>;
    updateTask(taskId: string, updates: Partial<AtomicTask>): Promise<Result<AtomicTask, EnhancedError>>;
    deleteTask(taskId: string): Promise<Result<void, EnhancedError>>;
    listTasks(projectId?: string): Promise<Result<AtomicTask[], EnhancedError>>;
    taskExists(taskId: string): Promise<boolean>;
    createProject(project: Project): Promise<Result<Project, EnhancedError>>;
    getProject(projectId: string): Promise<Result<Project, EnhancedError>>;
    projectExists(projectId: string): Promise<boolean>;
    updateProject(projectId: string, updates: Partial<Project>): Promise<Result<Project, EnhancedError>>;
    deleteProject(projectId: string): Promise<Result<void, EnhancedError>>;
    listProjects(): Promise<Result<Project[], EnhancedError>>;
    private setCache;
    private getCache;
    private cleanupCache;
    private evictOldestCacheEntries;
    private performBackup;
    private cleanupOldBackups;
    private saveTaskIndex;
    private saveProjectIndex;
    private fileExists;
    private copyDirectory;
    private removeDirectory;
    private getDirectorySize;
    private calculateChecksum;
    private trackOperation;
    private collectMetrics;
    getStatistics(): StorageStatistics;
    dispose(): void;
}
export declare function createDefaultStorageConfig(): UnifiedStorageEngineConfig;
//# sourceMappingURL=unified-storage-engine.d.ts.map