import { StorageStrategy, QueryMatcher } from './storage-strategy';
import type { Query, QueryOptions, Update } from '../model';
import type { AggregationPipeline } from '../aggregation';
export interface SqliteStorageOptions {
    dataPath: string;
    modelName: string;
}
/**
 * SQLite storage strategy with native SQL query execution
 * All queries, updates, and aggregations execute directly in SQLite
 * No in-memory data array - everything stored and queried in database
 */
export declare class SqliteStorageStrategy<T extends object> implements StorageStrategy<T> {
    private _db;
    private _dataPath;
    private _modelName;
    private _dbFilePath;
    private _tableName;
    private _getDocId;
    private _initialized;
    private _pendingIndexes;
    private _queryBuilder;
    private _aggregationBuilder;
    private _uniqueIndexes;
    private _insertStmt?;
    private _deleteStmt?;
    private _selectAllStmt?;
    constructor(options: SqliteStorageOptions);
    initialize(): Promise<void>;
    /**
     * Register custom SQLite functions for query operators
     */
    private _registerCustomFunctions;
    /**
     * Execute query natively in SQLite - returns documents matching query
     */
    queryNative(query: Query<T>, options?: QueryOptions<T>): Promise<T[]>;
    /**
     * Execute update natively in SQLite - returns modified count
     */
    updateNative(query: Query<T>, update: Update<T>): Promise<{
        modifiedCount: number;
    }>;
    /**
     * Execute delete natively in SQLite - returns deleted count
     */
    deleteNative(query: Query<T>): Promise<{
        deletedCount: number;
    }>;
    /**
     * Execute count natively in SQLite
     */
    countNative(query: Query<T>): Promise<number>;
    /**
     * Execute aggregation natively in SQLite
     */
    aggregateNative<R = Record<string, unknown>>(pipeline: AggregationPipeline<T>): Promise<R[]>;
    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>;
    /**
     * SQL-based unique constraint checking
     */
    private _checkUniqueConstraintsSQL;
    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;
    /**
     * Fallback method for findDocuments - only used if queryNative is not called
     * In practice, Model will detect queryNative and use that instead
     */
    findDocuments(matcher: QueryMatcher<T>, _indexHint?: {
        fields: Array<keyof T>;
        values: Record<string, unknown>;
    }): Promise<T[]>;
    /**
     * Record schema information in the _schema table
     * 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<{
        modelName: string;
        version: string;
        definition: Record<string, unknown>;
        indexes: Array<{
            fields: string[];
            unique: boolean;
        }>;
        options: Record<string, unknown>;
        createdAt: Date;
        updatedAt: Date;
    } | null>;
    close(): void;
}
//# sourceMappingURL=sqlite-strategy.d.ts.map