/**
 * StrictDB — The Unified Database Interface
 *
 * One API for MongoDB, PostgreSQL, MySQL, MSSQL, SQLite, and Elasticsearch.
 * Auto-detects backend from URI. All operations flow through the pipeline:
 *
 *   Developer/AI call → StrictDB (router)
 *     → sanitize (clean input)
 *     → guardrails (block dangerous ops)
 *     → validate (schema check if enabled)
 *     → adapter (mongo/sql/elastic)
 *     → receipts (wrap result)
 *     → logger (emit event)
 *     → return to caller
 */
import type { AggregateOptions, BatchOperation, CollectionDescription, CollectionSchema, ConfirmOptions, ConnectionStatus, ExplainResult, IndexDefinition, LookupOptions, NativeBulkWriteOp, OperationReceipt, QueryOptions, StrictDBConfig, StrictDBEvents, StrictFilter, UpdateOperators, ValidationResult } from './types.js';
import type { SqlOptions, SqlMode2Result } from './sql/index.js';
export declare class StrictDB {
    private adapter;
    private emitter;
    private logger;
    private config;
    private backend;
    private schemaValidation;
    private guardrailsEnabled;
    private guardrailLimitRequired;
    private guardrailEmptyFilter;
    private guardrailNullComparison;
    private sanitizeEnabled;
    private sanitizeRules;
    private timestampConfig;
    private constructor();
    /**
     * Create a new StrictDB instance. Auto-detects backend from URI.
     */
    static create(config: StrictDBConfig): Promise<StrictDB>;
    queryOne<TFilter = Record<string, unknown>, TDoc = Record<string, unknown>>(collection: string, filter: StrictFilter<TFilter>, options?: QueryOptions<TDoc>): Promise<TDoc | null>;
    queryMany<TFilter = Record<string, unknown>, TDoc = Record<string, unknown>>(collection: string, filter: StrictFilter<TFilter>, options?: QueryOptions<TDoc>): Promise<TDoc[]>;
    queryWithLookup<T>(collection: string, options: LookupOptions<T>): Promise<T | null>;
    count<T>(collection: string, filter?: StrictFilter<T>): Promise<number>;
    insertOne<T>(collection: string, doc: T): Promise<OperationReceipt>;
    insertMany<T>(collection: string, docs: T[]): Promise<OperationReceipt>;
    updateOne<TFilter = Record<string, unknown>, TDoc = Record<string, unknown>>(collection: string, filter: StrictFilter<TFilter>, update: UpdateOperators<TDoc>, upsert?: boolean): Promise<OperationReceipt>;
    updateMany<TFilter = Record<string, unknown>, TDoc = Record<string, unknown>>(collection: string, filter: StrictFilter<TFilter>, update: UpdateOperators<TDoc>, options?: ConfirmOptions): Promise<OperationReceipt>;
    deleteOne<T>(collection: string, filter: StrictFilter<T>, options?: ConfirmOptions): Promise<OperationReceipt>;
    deleteMany<T>(collection: string, filter: StrictFilter<T>, options?: ConfirmOptions): Promise<OperationReceipt>;
    batch(operations: BatchOperation[]): Promise<OperationReceipt>;
    private _sqlAdapter?;
    private getSqlAdapter;
    sql(sql: string, options?: SqlOptions): Promise<SqlMode2Result | OperationReceipt>;
    /**
     * Execute a native MongoDB aggregate pipeline.
     * On MongoDB: zero-overhead passthrough — pipeline goes straight to the driver.
     * On SQL/ES: pipeline stages are translated to the backend's query language.
     */
    aggregate<T = Record<string, unknown>>(collection: string, pipeline: Record<string, unknown>[], options?: AggregateOptions): Promise<T[]>;
    /**
     * Execute native MongoDB-format bulk write operations.
     * Accepts the exact MongoDB bulkWrite format.
     * On MongoDB: zero-overhead passthrough.
     * On SQL/ES: operations translated to the backend's write format.
     */
    nativeBulkWrite(collection: string, operations: NativeBulkWriteOp[]): Promise<OperationReceipt>;
    /**
     * Alias for nativeBulkWrite — matches MongoDB driver naming convention.
     */
    bulkWrite(collection: string, operations: NativeBulkWriteOp[]): Promise<OperationReceipt>;
    withTransaction<T>(fn: (tx: StrictDB) => Promise<T>): Promise<T>;
    registerCollection<T>(definition: CollectionSchema<T>): void;
    registerIndex(definition: IndexDefinition): void;
    ensureCollections(options?: {
        dryRun?: boolean;
    }): Promise<void>;
    ensureIndexes(options?: {
        dryRun?: boolean;
    }): Promise<void>;
    describe(collection: string): Promise<CollectionDescription>;
    validate(collection: string, operation: {
        filter?: Record<string, unknown>;
        update?: UpdateOperators<Record<string, unknown>>;
        doc?: Record<string, unknown>;
    }): Promise<ValidationResult>;
    explain(collection: string, operation: {
        filter?: Record<string, unknown>;
        sort?: Record<string, unknown>;
        limit?: number;
    }): Promise<ExplainResult>;
    status(): ConnectionStatus;
    on<E extends keyof StrictDBEvents>(event: E, listener: (payload: StrictDBEvents[E]) => void): this;
    once<E extends keyof StrictDBEvents>(event: E, listener: (payload: StrictDBEvents[E]) => void): this;
    off<E extends keyof StrictDBEvents>(event: E, listener: (payload: StrictDBEvents[E]) => void): this;
    private applyRulesToFilter;
    private applyRulesToUpdate;
    close(): Promise<void>;
    gracefulShutdown(exitCode?: number): Promise<void>;
    raw(): unknown;
}
//# sourceMappingURL=strictdb.d.ts.map