export type QueryMatcher<T> = (doc: T) => boolean;
import type { Query, QueryOptions, Update } from '../model';
import type { AggregationPipeline } from '../aggregation';
export type SchemaRecord = {
    modelName: string;
    version: string;
    definition: Record<string, unknown>;
    indexes: Array<{
        fields: string[];
        unique: boolean;
    }>;
    options: Record<string, unknown>;
    createdAt: Date;
    updatedAt: Date;
};
export interface StorageStrategy<T extends object = Record<string, unknown>> {
    initialize(): Promise<void>;
    getAll(): Promise<T[]>;
    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>;
    createIndex(fields: keyof T | Array<keyof T>, options?: {
        unique?: boolean;
    }): Promise<void>;
    rebuildIndexes(): Promise<void>;
    updateIndexForDocument(oldDoc: T | null, newDoc: T | null): void;
    checkUniqueConstraints(doc: Partial<T>, excludeDoc?: T): void;
    findDocuments(matcher: QueryMatcher<T>, indexHint?: {
        fields: Array<keyof T>;
        values: Record<string, unknown>;
    }): Promise<T[]>;
    queryNative?(query: Query<T>, options?: QueryOptions<T>): Promise<T[]>;
    updateNative?(query: Query<T>, update: Update<T>): Promise<{
        modifiedCount: number;
    }>;
    deleteNative?(query: Query<T>): Promise<{
        deletedCount: number;
    }>;
    countNative?(query: Query<T>): Promise<number>;
    aggregateNative?<R = Record<string, unknown>>(pipeline: AggregationPipeline<T>): Promise<R[]>;
    recordSchema?(schemaData: Omit<SchemaRecord, 'createdAt' | 'updatedAt'>): Promise<void>;
    getSchema?(modelName: string): Promise<SchemaRecord | null>;
    flush?(): Promise<void>;
    close?(): void;
}
//# sourceMappingURL=storage-strategy.d.ts.map