import { B as BaseStorage, S as StorageBackend, k as ModelMeta, p as TensorChunk, q as TokenizerData, n as SyncProgress, U as UserAdapter, r as TrainingLogEntry } from '../../base-storage-CfkDwX0r.js';

/**
 * OPFS Storage Implementation
 *
 * Uses Origin Private File System for model weight storage.
 * Provides best performance for large binary data in browsers.
 */

declare class OPFSStorage extends BaseStorage {
    readonly backend: StorageBackend;
    private root;
    private metaDb;
    private metaFile;
    /**
     * Initialize OPFS storage
     */
    initialize(): Promise<void>;
    private loadMetadata;
    private saveMetadata;
    private getModelDir;
    getModelMeta(modelId: string): Promise<ModelMeta | null>;
    setModelMeta(meta: ModelMeta): Promise<void>;
    deleteModelMeta(modelId: string): Promise<void>;
    listModels(): Promise<ModelMeta[]>;
    getTensorChunks(modelId: string, layerIndex: number): Promise<TensorChunk[]>;
    getTensorChunk(modelId: string, tensorName: string, chunkIndex: number): Promise<TensorChunk | null>;
    storeTensorChunk(chunk: TensorChunk): Promise<void>;
    deleteTensorChunks(modelId: string): Promise<void>;
    getTokenizer(modelId: string): Promise<TokenizerData | null>;
    setTokenizer(data: TokenizerData): Promise<void>;
    getSyncProgress(modelId: string): Promise<SyncProgress[]>;
    updateSyncProgress(progress: SyncProgress): Promise<void>;
    clearSyncProgress(modelId: string): Promise<void>;
    getUserAdapter(modelId: string, userId: string, adapterId?: string): Promise<UserAdapter | null>;
    setUserAdapter(adapter: UserAdapter): Promise<void>;
    deleteUserAdapter(adapterId: string): Promise<void>;
    addTrainingLogEntry(entry: Omit<TrainingLogEntry, 'id'>): Promise<number>;
    getTrainingLog(adapterId: string, limit?: number): Promise<TrainingLogEntry[]>;
    isModelComplete(modelId: string): Promise<boolean>;
    getStorageUsed(): Promise<number>;
    clear(): Promise<void>;
}

/**
 * IndexedDB Storage Implementation
 *
 * Fallback storage for browsers without OPFS support.
 * Uses IndexedDB with structured stores for model data.
 */

declare class IndexedDBStorage extends BaseStorage {
    readonly backend: StorageBackend;
    private db;
    /**
     * Initialize IndexedDB storage
     */
    initialize(): Promise<void>;
    private getStore;
    private promisify;
    getModelMeta(modelId: string): Promise<ModelMeta | null>;
    setModelMeta(meta: ModelMeta): Promise<void>;
    deleteModelMeta(modelId: string): Promise<void>;
    listModels(): Promise<ModelMeta[]>;
    getTensorChunks(modelId: string, layerIndex: number): Promise<TensorChunk[]>;
    getTensorChunk(modelId: string, tensorName: string, chunkIndex: number): Promise<TensorChunk | null>;
    storeTensorChunk(chunk: TensorChunk): Promise<void>;
    deleteTensorChunks(modelId: string): Promise<void>;
    getTokenizer(modelId: string): Promise<TokenizerData | null>;
    setTokenizer(data: TokenizerData): Promise<void>;
    getSyncProgress(modelId: string): Promise<SyncProgress[]>;
    updateSyncProgress(progress: SyncProgress): Promise<void>;
    clearSyncProgress(modelId: string): Promise<void>;
    getUserAdapter(modelId: string, userId: string, adapterId?: string): Promise<UserAdapter | null>;
    setUserAdapter(adapter: UserAdapter): Promise<void>;
    deleteUserAdapter(adapterId: string): Promise<void>;
    addTrainingLogEntry(entry: Omit<TrainingLogEntry, 'id'>): Promise<number>;
    getTrainingLog(adapterId: string, limit?: number): Promise<TrainingLogEntry[]>;
    isModelComplete(modelId: string): Promise<boolean>;
    getStorageUsed(): Promise<number>;
    clear(): Promise<void>;
}

/**
 * Memory Storage Implementation
 *
 * In-memory storage for testing and Node.js environments.
 * Does not persist data between sessions.
 */

declare class MemoryStorage extends BaseStorage {
    readonly backend: StorageBackend;
    private models;
    private tensorChunks;
    private tokenizers;
    private syncProgress;
    private userAdapters;
    private trainingLog;
    private nextLogId;
    initialize(): Promise<void>;
    getModelMeta(modelId: string): Promise<ModelMeta | null>;
    setModelMeta(meta: ModelMeta): Promise<void>;
    deleteModelMeta(modelId: string): Promise<void>;
    listModels(): Promise<ModelMeta[]>;
    getTensorChunks(modelId: string, layerIndex: number): Promise<TensorChunk[]>;
    getTensorChunk(modelId: string, tensorName: string, chunkIndex: number): Promise<TensorChunk | null>;
    storeTensorChunk(chunk: TensorChunk): Promise<void>;
    deleteTensorChunks(modelId: string): Promise<void>;
    getTokenizer(modelId: string): Promise<TokenizerData | null>;
    setTokenizer(data: TokenizerData): Promise<void>;
    getSyncProgress(modelId: string): Promise<SyncProgress[]>;
    updateSyncProgress(progress: SyncProgress): Promise<void>;
    clearSyncProgress(modelId: string): Promise<void>;
    getUserAdapter(modelId: string, userId: string, adapterId?: string): Promise<UserAdapter | null>;
    setUserAdapter(adapter: UserAdapter): Promise<void>;
    deleteUserAdapter(adapterId: string): Promise<void>;
    addTrainingLogEntry(entry: Omit<TrainingLogEntry, 'id'>): Promise<number>;
    getTrainingLog(adapterId: string, limit?: number): Promise<TrainingLogEntry[]>;
    isModelComplete(modelId: string): Promise<boolean>;
    getStorageUsed(): Promise<number>;
    clear(): Promise<void>;
}

/**
 * Storage Factory
 *
 * Creates appropriate storage backend based on environment capabilities.
 */

interface StorageOptions {
    /** Preferred storage backend */
    backend?: StorageBackend;
    /** Force the specified backend even if not optimal */
    force?: boolean;
}
/**
 * Detect the best available storage backend
 */
declare function detectBestBackend(): StorageBackend;
/**
 * Create a storage instance
 */
declare function createStorage(options?: StorageOptions): Promise<BaseStorage>;

export { IndexedDBStorage, MemoryStorage, OPFSStorage, type StorageOptions, createStorage, detectBestBackend };