import { StorageStrategy, QueryMatcher, SchemaRecord } from './storage-strategy';
export interface FileStorageOptions {
    dataPath: string;
    modelName: string;
    persistMode?: 'immediate' | 'debounced';
    debounceMs?: number;
    compaction?: {
        operationThreshold?: number;
        intervalMs?: number;
        sizeThresholdBytes?: number;
        walDataRatio?: number;
        emergencyOperations?: number;
        emergencySizeBytes?: number;
        emergencyRatio?: number;
        debounceMs?: number;
        useWorkerThread?: boolean;
        workerThreshold?: number;
    };
    compactionThreshold?: number;
}
export declare class FileStorageStrategy<T extends object> implements StorageStrategy<T> {
    private _data;
    private _dataPath;
    private _modelName;
    private _persistMode;
    private _debounceMs;
    private _dataFilePath;
    private _walFilePath;
    private _indexFilePath;
    private _debounceTimer?;
    private _writeQueue;
    private _pendingWrite;
    private _index;
    private _walOperationCount;
    private _walOffset;
    private _getDocId;
    private _queryIndexes;
    private _compactionDebounceMs;
    private _compactionTimer?;
    private _compacting;
    private _initialized;
    private _initPromise?;
    private _dropped;
    constructor(options: FileStorageOptions);
    initialize(): Promise<void>;
    private _ensureInitialized;
    private _loadDataIndex;
    private _rebuildDataFileIndex;
    private _rebuildWalIndex;
    private _rebuildDataArray;
    private _readDocumentAtOffset;
    getAll(): Promise<T[]>;
    private _waitForCompaction;
    add(doc: T): Promise<void>;
    addMany(docs: T[]): Promise<void>;
    update(oldDoc: T, newDoc: T): Promise<void>;
    remove(doc: T): Promise<void>;
    removeMany(docs: T[]): Promise<void>;
    clear(): Promise<void>;
    drop(): Promise<void>;
    private _appendToWal;
    private _schedulePersist;
    private _persist;
    private _scheduleCompaction;
    private _compact;
    flush(): Promise<void>;
    createIndex(fields: keyof T | Array<keyof T>, options?: {
        unique?: boolean;
    }): Promise<void>;
    rebuildIndexes(): Promise<void>;
    updateIndexForDocument(oldDoc: T | null, newDoc: T | null): void;
    private _updateQueryIndexes;
    checkUniqueConstraints(doc: Partial<T>, excludeDoc?: T): void;
    findDocuments(matcher: QueryMatcher<T>, indexHint?: {
        fields: Array<keyof T>;
        values: Record<string, unknown>;
    }): Promise<T[]>;
    /**
     * Record schema information in a JSON file
     * This is called automatically when a model is initialized
     */
    recordSchema(schemaData: {
        modelName: string;
        version: string;
        definition: Record<string, unknown>;
        indexes: Array<{
            fields: string[];
            unique: boolean;
        }>;
        options: Record<string, unknown>;
    }): Promise<void>;
    /**
     * Retrieve schema information for a model
     */
    getSchema(modelName: string): Promise<SchemaRecord | null>;
}
//# sourceMappingURL=file-strategy.d.ts.map