@sailboat-computer/data-storage/dist/storage/UnifiedStorageManagerImpl.d.ts

Shared data storage library for sailboat computer v3

/**
 * Unified storage manager implementation
 */
import { UnifiedStorageManager, UnifiedStorageManagerOptions, StorageConfig, StorageStatus, LocalStorageStatus, ClearResult, SyncResult, ResilienceMetrics, DataQuery, StoredData, StorageTierType, CleanupResult, StorageOptions } from '../types';
/**
 * Unified storage manager implementation
 */
export declare class UnifiedStorageManagerImpl implements UnifiedStorageManager {
    private config;
    private options;
    private initialized;
    private remoteStorageManager;
    private localStorageProvider;
    private syncInterval?;
    private offlineBuffer;
    private lastOperation;
    private metrics;
    /**
     * Create a new unified storage manager
     *
     * @param config - Storage configuration
     * @param options - Storage manager options
     */
    constructor(config: StorageConfig, options?: UnifiedStorageManagerOptions);
    /**
     * Initialize the storage manager
     */
    initialize(): Promise<void>;
    /**
     * Store data
     *
     * @param data - Data to store
     * @param category - Data category
     * @param options - Storage options
     * @returns Data ID
     */
    store(data: any, category: string, options?: StorageOptions): Promise<string>;
    /**
     * Retrieve data
     *
     * @param query - Data query
     * @param tier - Storage tier to query (optional)
     * @returns Stored data
     */
    retrieve(query: DataQuery, tier?: StorageTierType): Promise<StoredData[]>;
    /**
     * Update data
     *
     * @param data - Data to update
     */
    update(data: StoredData): Promise<void>;
    /**
     * Delete data
     *
     * @param id - Data ID
     */
    delete(id: string): Promise<void>;
    /**
     * Store multiple data items
     *
     * @param items - Data items to store
     * @returns Data IDs
     */
    storeBatch(items: Array<{
        data: any;
        category: string;
        options?: StorageOptions;
    }>): Promise<string[]>;
    /**
     * Retrieve multiple data sets
     *
     * @param queries - Data queries
     * @param tier - Storage tier to query (optional)
     * @returns Stored data sets
     */
    retrieveBatch(queries: DataQuery[], tier?: StorageTierType): Promise<StoredData[][]>;
    /**
     * Clean up old data
     *
     * @param category - Data category
     * @param tier - Storage tier
     * @param retentionDays - Retention period in days
     * @returns Cleanup result
     */
    cleanup(category: string, tier: StorageTierType, retentionDays: number): Promise<CleanupResult>;
    /**
     * Migrate data between tiers
     *
     * @param id - Data ID
     * @param fromTier - Source tier
     * @param toTier - Destination tier
     */
    migrate(id: string, fromTier: StorageTierType, toTier: StorageTierType): Promise<void>;
    /**
     * Shutdown the storage manager
     */
    shutdown(): Promise<void>;
    /**
     * Get storage status
     *
     * @returns Storage status
     */
    getStatus(): Promise<StorageStatus>;
    /**
     * Get local storage status
     *
     * @returns Local storage status
     */
    getLocalStatus(): Promise<LocalStorageStatus>;
    /**
     * Clear local cache
     *
     * @returns Clear result
     */
    clearLocalCache(): Promise<ClearResult>;
    /**
     * Synchronize local and remote storage
     *
     * @returns Sync result
     */
    synchronize(): Promise<SyncResult>;
    /**
     * Start sync interval
     */
    private startSyncInterval;
    /**
     * Update metrics
     *
     * @param latencyMs - Operation latency in milliseconds
     * @param isError - Whether the operation resulted in an error
     */
    private updateMetrics;
    /**
     * Get resilience metrics
     *
     * @returns Resilience metrics
     */
    getResilienceMetrics(): ResilienceMetrics;
    /**
     * Ensure provider is initialized
     *
     * @throws StorageError if not initialized
     */
    private ensureInitialized;
}
/**
 * Create a new unified storage manager
 *
 * @param config - Storage configuration
 * @param options - Storage manager options
 * @returns Unified storage manager
 */
export declare function createUnifiedStorageManager(config: StorageConfig, options?: UnifiedStorageManagerOptions): UnifiedStorageManager;