import { StorageStrategy, QueryMatcher } from './storage-strategy';
interface DurableObjectSqlStorage {
    exec<T = unknown>(query: string): {
        results: T[];
    };
    prepare(query: string): {
        bind(...values: any[]): {
            run(): void;
            all<T = unknown>(): {
                results: T[];
            };
            first<T = unknown>(): T | null;
        };
    };
}
interface DurableObjectState {
    storage: {
        sql: DurableObjectSqlStorage;
    };
    blockConcurrencyWhile(callback: () => Promise<void>): void;
}
/**
 * Durable Object SQL Storage Strategy
 *
 * Uses Cloudflare Durable Objects' SQL API for persistence.
 * Much faster than KV for bulk operations!
 *
 * Still loads all documents into memory for synchronous access,
 * but initial load is MUCH faster with SQL SELECT.
 */
export declare class DurableObjectSqlStorageStrategy<T extends object> implements StorageStrategy<T> {
    private modelName;
    private ctx;
    private indexes;
    private initialized;
    private _data;
    lastOperationTime: number;
    constructor(ctx: DurableObjectState, modelName: string);
    /**
     * Initialize storage - creates tables and loads all documents
     */
    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>;
    createIndex(fields: keyof T | Array<keyof T>, options?: {
        unique?: boolean;
    }): Promise<void>;
    checkUniqueConstraints(doc: Partial<T>, excludeDoc?: T): void;
    findDocuments(matcher: QueryMatcher<T>, indexHint?: {
        fields: Array<keyof T>;
        values: Record<string, unknown>;
    }): T[];
    rebuildIndexes(): Promise<void>;
    updateIndexForDocument(oldDoc: T | null, newDoc: T | null): void;
}
export {};
//# sourceMappingURL=durable-object-sql-strategy.d.ts.map