import { FileSystemStorage, type OpfsSyncAccessHandle } from '../engine/file-system-storage.js';
import { BrowserAcquisitionJournal } from './acquisition-journal.js';
import { type AssetRecord, type ModelAssetKind, type ModelLoadProgress, type RegistryManifest } from './types.js';
/** Browser OPFS policy for deciding when GGUF assets are split into shards. */
export interface BrowserCachePolicyOptions {
    /** Maximum single-file GGUF size loaded directly before browser-side splitting is used. */
    readonly directLoadMaxBytes?: number;
    /** Maximum target size for each browser-created GGUF shard. */
    readonly shardMaxBytes?: number;
}
export interface GgufSplitRuntime {
    browserCacheLayout(sourceBytes: number, sourceBytesKnown: boolean, directLoadMaxBytes: number, shardMaxBytes: number): Promise<'single-file' | 'split-gguf'>;
    planGgufSplitCount(sourceBytes: number, shardMaxBytes: number, callbacks: {
        readAt(offset: number, target: Uint8Array): number | void;
    }): Promise<number>;
    splitGgufStream(sourceBytes: number, outputPrefix: string, shardMaxBytes: number, callbacks: {
        readAt(offset: number, target: Uint8Array): number | void;
        openShard(path: string, index: number, count: number): number | void;
        writeShard(bytes: Uint8Array): number | void;
        closeShard(): number | void;
    }): Promise<void>;
}
export interface RemoteAssetMetadata {
    readonly url: string;
    readonly canonicalUrl: string;
    readonly name: string;
    readonly bytes: number;
    readonly etag?: string;
    readonly lastModified?: string;
}
export interface RemoteStoreReceipt {
    readonly records: readonly AssetRecord[];
    readonly createdAssetIds: readonly string[];
}
export interface InstallAssetInput {
    kind: ModelAssetKind;
    file: File;
    sourceUrl?: string;
    sourceEtag?: string;
    sourceLastModified?: string;
    signal?: AbortSignal;
    onProgress?: (progress: ModelLoadProgress) => void;
}
export declare class AssetStore {
    private readonly storage;
    private readonly browserCachePolicy;
    constructor(storage?: FileSystemStorage, browserCachePolicy?: BrowserCachePolicyOptions);
    ensureAvailable(): void;
    downloadRemote(metadata: RemoteAssetMetadata, kind: ModelAssetKind, response: Response, signal?: AbortSignal, onProgress?: (progress: ModelLoadProgress) => void, journal?: BrowserAcquisitionJournal): Promise<RemoteStoreReceipt>;
    downloadRemoteGguf(metadata: RemoteAssetMetadata, runtime: GgufSplitRuntime, response: Response, signal?: AbortSignal, onProgress?: (progress: ModelLoadProgress) => void, journal?: BrowserAcquisitionJournal): Promise<RemoteStoreReceipt>;
    installLocalGguf(file: File, runtime: GgufSplitRuntime, manifest: RegistryManifest, signal?: AbortSignal, onProgress?: (progress: ModelLoadProgress) => void): Promise<AssetRecord[]>;
    installFile(input: InstallAssetInput): Promise<AssetRecord>;
    getFile(record: AssetRecord): Promise<File>;
    openSyncHandle(record: AssetRecord): Promise<{
        name: string;
        handle: OpfsSyncAccessHandle;
        size: number;
    }>;
    delete(record: AssetRecord): Promise<void>;
    cleanupBrowserSplitArtifacts(manifest: RegistryManifest): Promise<void>;
    openAcquisitionJournal(acquisitionId: string): BrowserAcquisitionJournal;
    registerStoredFile(input: {
        kind: ModelAssetKind;
        name: string;
        storagePath: string;
        sourceUrl?: string;
        sourceEtag?: string;
        sourceLastModified?: string;
        sourceBytes?: number;
        sourcePartIndex?: number;
        sourcePartCount?: number;
        sourceFileName?: string;
        sourceFileLastModified?: number;
        signal?: AbortSignal;
        onProgress?: (progress: ModelLoadProgress) => void;
    }): Promise<AssetRecord>;
    private splitStoredGguf;
    private emitStoreProgress;
    private buildAssetRecord;
}