@affectively/aeon 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,812 @@
+import { Operation, OperationPriority } from './core/index.js';
+export { BandwidthProfile, CRDTOperation, ConflictDetectionResult, EventCallback, EventUnsubscribe, IEventEmitter, NetworkState, OperationStatus, OperationType, PresenceInfo, ResolutionStrategy, SyncBatch, SyncCoordinatorConfig, SyncResult, VectorClock } from './core/index.js';
+export { Logger, createNamespacedLogger, disableLogging, getLogger, logger, resetLogger, setLogger } from './utils/index.js';
+export { CompatibilityRule, DataTransformer, FieldTransformer, Migration, MigrationEngine, MigrationRecord, MigrationResult, MigrationState, MigrationTracker, RollbackPath, SchemaVersion, SchemaVersionManager, TransformationResult, TransformationRule, VersionMetadata } from './versioning/index.js';
+export { A as AEON_CAPABILITIES, a as AeonCapability, b as AeonCapabilityResult, c as AeonCryptoConfig, d as AeonEncryptionMode, e as AuthenticatedMessageFields, C as Capability, D as DEFAULT_CRYPTO_CONFIG, f as DID, g as DecryptionResult, h as DomainCategory, E as ECKeyPair, i as EncryptedPayload, j as EncryptionAlgorithm, H as Handshake, I as ICryptoProvider, k as Identity, K as KeyPair, M as MergeStrategy, N as NullCryptoProvider, P as ProtocolError, R as ReconciliationResult, l as Replica, m as ReplicationEvent, n as ReplicationManager, o as ReplicationPolicy, S as SecureNodeInfo, p as SecureSyncSession, q as SignedSyncData, r as SigningAlgorithm, s as StateDiff, t as StateReconciler, u as StateVersion, v as SyncCoordinator, w as SyncEvent, x as SyncMessage, y as SyncNode, z as SyncProtocol, B as SyncRequest, F as SyncResponse, G as SyncSession, U as UCANPayload, J as UCANToken, V as VerificationResult } from './index-C_4CMV5c.js';
+import { EventEmitter } from 'eventemitter3';
+
+/**
+ * Offline Operation Queue (Phase 11)
+ *
+ * Manages pending operations for offline-first clients.
+ * Provides priority-based queuing, persistence, and retry logic.
+ */
+
+interface OfflineOperation {
+    id: string;
+    type: Operation['type'];
+    data: Record<string, unknown>;
+    sessionId: string;
+    priority: OperationPriority;
+    createdAt: number;
+    retryCount: number;
+    maxRetries: number;
+    lastError?: string;
+    status: 'pending' | 'syncing' | 'failed' | 'synced';
+}
+interface OfflineQueueStats {
+    pending: number;
+    syncing: number;
+    failed: number;
+    synced: number;
+    totalOperations: number;
+    oldestPendingMs: number;
+    averageRetries: number;
+}
+interface OfflineQueueEvents {
+    'operation-added': (operation: OfflineOperation) => void;
+    'operation-synced': (operation: OfflineOperation) => void;
+    'operation-failed': (operation: OfflineOperation, error: Error) => void;
+    'queue-empty': () => void;
+    'sync-started': () => void;
+    'sync-completed': (stats: {
+        synced: number;
+        failed: number;
+    }) => void;
+}
+declare class OfflineOperationQueue extends EventEmitter<OfflineQueueEvents> {
+    private queue;
+    private syncingIds;
+    private maxQueueSize;
+    private defaultMaxRetries;
+    constructor(maxQueueSize?: number, defaultMaxRetries?: number);
+    /**
+     * Add operation to the queue
+     */
+    enqueue(type: Operation['type'], data: Record<string, unknown>, sessionId: string, priority?: OperationPriority, maxRetries?: number): OfflineOperation;
+    /**
+     * Get next operations to sync (by priority)
+     */
+    getNextBatch(batchSize?: number): OfflineOperation[];
+    /**
+     * Mark operations as syncing
+     */
+    markSyncing(operationIds: string[]): void;
+    /**
+     * Mark operation as synced
+     */
+    markSynced(operationId: string): void;
+    /**
+     * Mark operation as failed
+     */
+    markFailed(operationId: string, error: Error): void;
+    /**
+     * Get operation by ID
+     */
+    getOperation(operationId: string): OfflineOperation | undefined;
+    /**
+     * Get all pending operations
+     */
+    getPendingOperations(): OfflineOperation[];
+    /**
+     * Get pending count
+     */
+    getPendingCount(): number;
+    /**
+     * Get queue statistics
+     */
+    getStats(): OfflineQueueStats;
+    /**
+     * Clear all operations
+     */
+    clear(): void;
+    /**
+     * Clear failed operations
+     */
+    clearFailed(): void;
+    /**
+     * Retry failed operations
+     */
+    retryFailed(): void;
+    /**
+     * Find oldest low-priority operation
+     */
+    private findOldestLowPriority;
+    /**
+     * Export queue for persistence
+     */
+    export(): OfflineOperation[];
+    /**
+     * Import queue from persistence
+     */
+    import(operations: OfflineOperation[]): void;
+}
+declare function getOfflineOperationQueue(): OfflineOperationQueue;
+declare function resetOfflineOperationQueue(): void;
+
+/**
+ * Compression Engine (Phase 12)
+ *
+ * Provides compression for delta operations using native CompressionStream API.
+ * Falls back gracefully when native compression is unavailable.
+ */
+interface CompressedBatch {
+    id: string;
+    compressed: Uint8Array;
+    originalSize: number;
+    compressedSize: number;
+    compressionRatio: number;
+    algorithm: 'gzip' | 'deflate' | 'none';
+    timestamp: number;
+}
+interface CompressedChunk {
+    chunkId: string;
+    batchId: string;
+    data: Uint8Array;
+    index: number;
+    total: number;
+    checksum: string;
+}
+interface CompressionStats {
+    totalCompressed: number;
+    totalDecompressed: number;
+    totalOriginalBytes: number;
+    totalCompressedBytes: number;
+    averageCompressionRatio: number;
+    compressionTimeMs: number;
+    decompressionTimeMs: number;
+}
+declare class CompressionEngine {
+    private stats;
+    private preferredAlgorithm;
+    constructor(preferredAlgorithm?: 'gzip' | 'deflate');
+    /**
+     * Check if native compression is available
+     */
+    supportsNativeCompression(): boolean;
+    /**
+     * Compress data
+     */
+    compress(data: Uint8Array | string): Promise<CompressedBatch>;
+    /**
+     * Decompress data
+     */
+    decompress(batch: CompressedBatch): Promise<Uint8Array>;
+    /**
+     * Compress using native CompressionStream
+     */
+    private compressNative;
+    /**
+     * Decompress using native DecompressionStream
+     */
+    private decompressNative;
+    /**
+     * Split compressed batch into chunks for transmission
+     */
+    splitIntoChunks(batch: CompressedBatch, chunkSize?: number): CompressedChunk[];
+    /**
+     * Reassemble chunks into compressed batch
+     */
+    reassembleChunks(chunks: CompressedChunk[]): Uint8Array;
+    /**
+     * Simple checksum for chunk verification
+     */
+    private simpleChecksum;
+    /**
+     * Update average compression ratio
+     */
+    private updateAverageRatio;
+    /**
+     * Get statistics
+     */
+    getStats(): CompressionStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+}
+declare function getCompressionEngine(): CompressionEngine;
+declare function resetCompressionEngine(): void;
+
+/**
+ * Delta Sync Optimizer (Phase 12)
+ *
+ * Implements field-level change detection to reduce payload size.
+ * Computes delta between current and previous operation state.
+ *
+ * Performance Impact:
+ * - Delta sync alone: 70-80% payload reduction
+ * - Combined with compression: 80-90% total reduction
+ */
+
+/**
+ * Delta operation - represents only changed fields
+ */
+interface DeltaOperation {
+    id: string;
+    type: 'full' | 'delta';
+    operationId: string;
+    operationType: Operation['type'];
+    sessionId: string;
+    timestamp: number;
+    changes?: Record<string, unknown>;
+    changeMask?: string[];
+    fullData?: Record<string, unknown>;
+    priority?: 'high' | 'normal' | 'low';
+}
+/**
+ * Batch of delta operations
+ */
+interface DeltaBatch {
+    batchId: string;
+    operations: DeltaOperation[];
+    timestamp: number;
+    totalOriginalSize: number;
+    totalDeltaSize: number;
+    reductionPercent: number;
+}
+/**
+ * Statistics about delta sync performance
+ */
+interface DeltaStats {
+    totalOperations: number;
+    totalFull: number;
+    totalDelta: number;
+    totalOriginalSize: number;
+    totalDeltaSize: number;
+    averageReductionPercent: number;
+    lastSyncTime: number;
+    fullOperationThreshold: number;
+}
+declare class DeltaSyncOptimizer {
+    private operationHistory;
+    private stats;
+    constructor(fullOperationThreshold?: number);
+    /**
+     * Compute delta for single operation
+     */
+    computeDelta(operation: Operation): DeltaOperation;
+    /**
+     * Compute deltas for batch of operations
+     */
+    computeBatchDeltas(operations: Operation[]): DeltaBatch;
+    /**
+     * Decompress delta operation back to full operation
+     */
+    decompressDelta(delta: DeltaOperation): Operation;
+    /**
+     * Update history after successful sync
+     */
+    updateHistory(operations: Operation[]): void;
+    /**
+     * Clear history for specific operations
+     */
+    clearHistory(operationIds: string[]): void;
+    /**
+     * Get current performance statistics
+     */
+    getStats(): DeltaStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Set the full operation threshold
+     */
+    setFullOperationThreshold(bytes: number): void;
+    /**
+     * Get history size for memory monitoring
+     */
+    getHistorySize(): number;
+    /**
+     * Get memory footprint estimate
+     */
+    getMemoryEstimate(): number;
+    /**
+     * Deep equality check for nested objects
+     */
+    private deepEqual;
+}
+declare function getDeltaSyncOptimizer(threshold?: number): DeltaSyncOptimizer;
+declare function resetDeltaSyncOptimizer(): void;
+
+/**
+ * Prefetching Engine (Phase 13)
+ *
+ * Predictively pre-compresses batches based on detected operation patterns.
+ * Analyzes historical data to predict which operations are most likely to occur.
+ */
+
+/**
+ * Pattern in operation sequence
+ */
+interface OperationPattern {
+    sequence: string[];
+    frequency: number;
+    probability: number;
+    lastOccurred: number;
+    avgIntervalMs: number;
+}
+/**
+ * Prediction for next operations
+ */
+interface OperationPrediction {
+    operationType: string;
+    probability: number;
+    reason: string;
+    shouldPrefetch: boolean;
+    estimatedTimeMs: number;
+}
+/**
+ * Prefetched batch
+ */
+interface PrefetchedBatch {
+    id: string;
+    operationType: string;
+    compressed: Uint8Array;
+    compressedSize: number;
+    originalSize: number;
+    compressionRatio: number;
+    compressed_at: number;
+    created_at: number;
+    ttl: number;
+    expiresAt: number;
+    hitCount: number;
+    missCount: number;
+}
+/**
+ * Prefetching statistics
+ */
+interface PrefetchingStats {
+    totalPrefetched: number;
+    totalHits: number;
+    totalMisses: number;
+    totalOverwrites: number;
+    hitRatio: number;
+    bandwidthSaved: number;
+    patternsDetected: number;
+    predictionAccuracy: number;
+}
+declare class PrefetchingEngine {
+    private operationHistory;
+    private patterns;
+    private prefetchCache;
+    private maxHistoryEntries;
+    private maxCachePerType;
+    private prefetchTTL;
+    private predictionThreshold;
+    private stats;
+    private lastPredictionTime;
+    private predictionInterval;
+    constructor();
+    /**
+     * Record operation for pattern analysis
+     */
+    recordOperation(operationType: string, size: number): void;
+    /**
+     * Analyze patterns in operation history
+     */
+    private analyzePatterns;
+    /**
+     * Predict next operations
+     */
+    predictNextOperations(recentOperations: Operation[]): OperationPrediction[];
+    /**
+     * Add prefetched batch
+     */
+    addPrefetchedBatch(operationType: string, compressed: Uint8Array, originalSize: number): PrefetchedBatch;
+    /**
+     * Try to use prefetched batch
+     */
+    getPrefetchedBatch(operationType: string): PrefetchedBatch | null;
+    /**
+     * Update prediction accuracy metric
+     */
+    private updatePredictionAccuracy;
+    /**
+     * Clean expired prefetches
+     */
+    private cleanExpiredPrefetches;
+    /**
+     * Get statistics
+     */
+    getStats(): PrefetchingStats;
+    /**
+     * Clear all caches
+     */
+    clear(): void;
+}
+declare function getPrefetchingEngine(): PrefetchingEngine;
+declare function resetPrefetchingEngine(): void;
+
+/**
+ * Batch Timing Optimizer (Phase 13)
+ *
+ * Intelligently schedules batch transmission based on network conditions,
+ * device resources, and user activity patterns.
+ */
+/**
+ * Network window quality assessment
+ */
+interface NetworkWindow {
+    startTime: number;
+    endTime: number;
+    expectedDurationMs: number;
+    latencyMs: number;
+    bandwidthMbps: number;
+    quality: 'excellent' | 'good' | 'fair' | 'poor';
+    isStable: boolean;
+    congestionLevel: number;
+    recommendedBatchSize: number;
+}
+/**
+ * Activity pattern
+ */
+interface ActivityPattern {
+    type: 'user-active' | 'idle' | 'background' | 'sleep';
+    startTime: number;
+    duration: number;
+    probability: number;
+}
+/**
+ * Batch scheduling decision
+ */
+interface SchedulingDecision {
+    shouldSendNow: boolean;
+    nextOptimalWindowMs: number;
+    recommendedDelay: number;
+    reason: string;
+    priority: 'critical' | 'high' | 'normal' | 'low';
+    estimatedDeliveryMs: number;
+}
+/**
+ * Batch timing statistics
+ */
+interface BatchTimingStats {
+    totalBatches: number;
+    immediateDeliveries: number;
+    deferredBatches: number;
+    averageWaitTimeMs: number;
+    averageDeliveryTimeMs: number;
+    networkWindowsUsed: number;
+    congestionAvoided: number;
+    userFocusedOptimizations: number;
+}
+declare class BatchTimingOptimizer {
+    private networkHistory;
+    private activityHistory;
+    private stats;
+    private lastActivityTime;
+    private isUserActive;
+    private congestionDetectionWindow;
+    private optimalBatchSize;
+    constructor();
+    /**
+     * Record network measurement
+     */
+    recordNetworkMeasurement(latencyMs: number, bandwidthMbps: number): void;
+    /**
+     * Assess network quality
+     */
+    private assessNetworkQuality;
+    /**
+     * Detect congestion in network
+     */
+    private detectCongestion;
+    /**
+     * Find next optimal network window
+     */
+    private findOptimalWindow;
+    /**
+     * Get scheduling decision for a batch
+     */
+    getSchedulingDecision(batchSize: number, batchPriority?: 'critical' | 'high' | 'normal' | 'low', isUserTriggered?: boolean): SchedulingDecision;
+    /**
+     * Apply scheduling and update stats
+     */
+    applyScheduling(batchSize: number, sendNow: boolean, actualDelay: number): void;
+    /**
+     * Get optimal batch size recommendation
+     */
+    getOptimalBatchSize(): number;
+    /**
+     * Get current network window
+     */
+    getCurrentNetworkWindow(): NetworkWindow;
+    /**
+     * Set user activity state
+     */
+    setUserActive(active: boolean): void;
+    /**
+     * Get statistics
+     */
+    getStats(): BatchTimingStats;
+    /**
+     * Clear history
+     */
+    clear(): void;
+}
+declare function getBatchTimingOptimizer(): BatchTimingOptimizer;
+declare function resetBatchTimingOptimizer(): void;
+
+/**
+ * Adaptive Compression Optimizer (Phase 13)
+ *
+ * Automatically adjusts compression level based on network conditions,
+ * device capabilities, and real-time performance metrics.
+ */
+/**
+ * Network conditions affecting compression
+ */
+interface NetworkProfile {
+    estimatedSpeedKbps: number;
+    latencyMs: number;
+    isOnline: boolean;
+    isWifi: boolean;
+    isFast: boolean;
+    isSlow: boolean;
+    isEmpty: boolean;
+}
+/**
+ * Device capabilities for compression
+ */
+interface DeviceProfile {
+    cpuCores: number;
+    cpuUtilization: number;
+    memoryAvailableMB: number;
+    memoryTotalMB: number;
+    isConstrained: boolean;
+    isPremium: boolean;
+    supportsWebWorkers: boolean;
+    supportsWebAssembly: boolean;
+}
+/**
+ * Compression recommendation based on conditions
+ */
+interface CompressionRecommendation {
+    recommendedLevel: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    reason: string;
+    confidence: number;
+    estimatedCompressionMs: number;
+    estimatedRatio: number;
+    networkFactor: number;
+    deviceFactor: number;
+}
+/**
+ * Adaptive compression statistics
+ */
+interface AdaptiveStats {
+    currentLevel: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    averageCompressionMs: number;
+    averageRatio: number;
+    levelsUsed: Set<number>;
+    adjustmentCount: number;
+    totalBatches: number;
+    networkCondition: 'fast' | 'normal' | 'slow' | 'offline';
+}
+declare class AdaptiveCompressionOptimizer {
+    private currentLevel;
+    private networkProfile;
+    private deviceProfile;
+    private compressionHistory;
+    private stats;
+    constructor();
+    /**
+     * Update network conditions
+     */
+    updateNetworkConditions(speedKbps: number, latencyMs?: number, isOnline?: boolean): void;
+    /**
+     * Update device resource usage
+     */
+    updateDeviceResources(cpuUtilization: number, memoryAvailableMB: number): void;
+    /**
+     * Record compression performance
+     */
+    recordCompressionPerformance(level: number, compressionMs: number, ratio: number): void;
+    /**
+     * Get compression recommendation based on conditions
+     */
+    getRecommendedLevel(): CompressionRecommendation;
+    /**
+     * Calculate network factor (0-1)
+     */
+    private calculateNetworkFactor;
+    /**
+     * Calculate device factor (0-1)
+     */
+    private calculateDeviceFactor;
+    /**
+     * Estimate compression time for a level (in ms)
+     */
+    private estimateCompressionTime;
+    /**
+     * Estimate compression ratio for a level
+     */
+    private estimateCompressionRatio;
+    /**
+     * Apply recommendation and get new level
+     */
+    applyRecommendation(): 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    /**
+     * Get current level
+     */
+    getCurrentLevel(): 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    /**
+     * Get statistics
+     */
+    getStats(): AdaptiveStats;
+    /**
+     * Get detailed analysis
+     */
+    getDetailedAnalysis(): {
+        stats: AdaptiveStats;
+        network: NetworkProfile;
+        device: DeviceProfile;
+        recommendation: CompressionRecommendation;
+        history: {
+            level: number;
+            ratio: number;
+            timeMs: number;
+            timestamp: number;
+        }[];
+    };
+}
+declare function getAdaptiveCompressionOptimizer(): AdaptiveCompressionOptimizer;
+declare function resetAdaptiveCompressionOptimizer(): void;
+
+/**
+ * Agent Presence Manager (Phase 14)
+ *
+ * Tracks real-time presence of all agents in a session.
+ * Provides status updates, cursor tracking, and activity monitoring.
+ */
+
+interface AgentPresence {
+    agentId: string;
+    name: string;
+    role: 'user' | 'assistant' | 'monitor' | 'admin';
+    status: 'online' | 'away' | 'offline' | 'reconnecting';
+    joinedAt: string;
+    lastSeen: string;
+    cursorPosition?: {
+        x: number;
+        y: number;
+        path: string;
+    };
+    activeSection?: string;
+    metadata?: Record<string, unknown>;
+}
+interface PresenceUpdate {
+    agentId: string;
+    changes: Partial<AgentPresence>;
+    timestamp: string;
+}
+interface PresenceEvents {
+    presence_updated: (data: {
+        agentId: string;
+        presence: AgentPresence;
+    }) => void;
+    agent_joined: (data: {
+        agentId: string;
+        presence: AgentPresence;
+    }) => void;
+    agent_left: (data: {
+        agentId: string;
+        presence: AgentPresence;
+    }) => void;
+    cursor_updated: (data: {
+        agentId: string;
+        cursorPosition: {
+            x: number;
+            y: number;
+            path: string;
+        };
+    }) => void;
+    section_updated: (data: {
+        agentId: string;
+        activeSection: string;
+    }) => void;
+    status_updated: (data: {
+        agentId: string;
+        status: AgentPresence['status'];
+    }) => void;
+}
+declare class AgentPresenceManager extends EventEmitter<PresenceEvents> {
+    private presences;
+    private sessionId;
+    private heartbeatInterval;
+    private heartbeatTimeout;
+    private inactivityThreshold;
+    constructor(sessionId: string);
+    /**
+     * Add or update agent presence
+     */
+    updatePresence(agentId: string, presence: Omit<AgentPresence, 'joinedAt' | 'lastSeen'>): void;
+    /**
+     * Agent joined
+     */
+    agentJoined(agentId: string, name: string, role?: AgentPresence['role'], metadata?: Record<string, unknown>): void;
+    /**
+     * Agent left
+     */
+    agentLeft(agentId: string): void;
+    /**
+     * Update cursor position
+     */
+    updateCursor(agentId: string, x: number, y: number, path: string): void;
+    /**
+     * Update active section
+     */
+    updateActiveSection(agentId: string, section: string): void;
+    /**
+     * Update status
+     */
+    updateStatus(agentId: string, status: AgentPresence['status']): void;
+    /**
+     * Heartbeat from agent (keeps them online)
+     */
+    heartbeat(agentId: string): void;
+    /**
+     * Get presence for agent
+     */
+    getPresence(agentId: string): AgentPresence | undefined;
+    /**
+     * Get all online agents
+     */
+    getOnlineAgents(): AgentPresence[];
+    /**
+     * Get all agents
+     */
+    getAllAgents(): AgentPresence[];
+    /**
+     * Get all presences
+     */
+    getAllPresences(): AgentPresence[];
+    /**
+     * Get agent count
+     */
+    getAgentCount(): Record<AgentPresence['status'], number>;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalAgents: number;
+        onlineAgents: number;
+        offlineAgents: number;
+        awayAgents: number;
+        reconnectingAgents: number;
+    };
+    /**
+     * Clear expired presences
+     */
+    clearExpiredPresences(maxAgeMs: number): void;
+    /**
+     * Get agents by role
+     */
+    getByRole(role: AgentPresence['role']): AgentPresence[];
+    /**
+     * Get agents in active section
+     */
+    getInSection(section: string): AgentPresence[];
+    /**
+     * Get presence timeline
+     */
+    getPresenceStats(): {
+        total: number;
+        online: number;
+        away: number;
+        offline: number;
+        reconnecting: number;
+        byRole: Record<string, number>;
+    };
+    /**
+     * Start heartbeat check (mark inactive agents as away)
+     */
+    private startHeartbeatCheck;
+    /**
+     * Stop heartbeat monitoring
+     */
+    stopHeartbeatMonitoring(): void;
+    /**
+     * Clear all presences
+     */
+    clear(): void;
+    /**
+     * Destroy the manager
+     */
+    destroy(): void;
+}
+declare function getAgentPresenceManager(sessionId: string): AgentPresenceManager;
+declare function clearAgentPresenceManager(sessionId: string): void;
+
+export { type ActivityPattern, AdaptiveCompressionOptimizer, type AdaptiveStats, type AgentPresence, AgentPresenceManager, BatchTimingOptimizer, type BatchTimingStats, type CompressedBatch, type CompressedChunk, CompressionEngine, type CompressionRecommendation, type CompressionStats, type DeltaBatch, type DeltaOperation, type DeltaStats, DeltaSyncOptimizer, type DeviceProfile, type NetworkProfile, type NetworkWindow, type OfflineOperation, OfflineOperationQueue, type OfflineQueueEvents, type OfflineQueueStats, Operation, type OperationPattern, type OperationPrediction, OperationPriority, type PrefetchedBatch, PrefetchingEngine, type PrefetchingStats, type PresenceEvents, type PresenceUpdate, type SchedulingDecision, clearAgentPresenceManager, getAdaptiveCompressionOptimizer, getAgentPresenceManager, getBatchTimingOptimizer, getCompressionEngine, getDeltaSyncOptimizer, getOfflineOperationQueue, getPrefetchingEngine, resetAdaptiveCompressionOptimizer, resetBatchTimingOptimizer, resetCompressionEngine, resetDeltaSyncOptimizer, resetOfflineOperationQueue, resetPrefetchingEngine };