/**
 * Tina4 MongoDB Adapter — uses the `mongodb` package (optional peer dependency).
 *
 * Install: npm install mongodb
 * URL format: mongodb://host:port/dbname  or  mongodb+srv://user:pass@host/dbname
 */
import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
export interface MongoConfig {
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    database?: string;
    connectionString?: string;
}
export declare class MongodbAdapter implements DatabaseAdapter {
    private config;
    private client;
    private db;
    private session;
    private _lastInsertId;
    private _inTransaction;
    private _connectionString;
    private _dbName;
    constructor(config: MongoConfig | string);
    /** Connect to MongoDB. Must be called before using the adapter. */
    /** ADR-0044 required adapter capability. */
    getDatabaseType(): string;
    /** ADR-0044: readable/writable native boolean. */
    autocommit: boolean;
    /**
     * ADR-0044 / DBA-P02: every built-in adapter can guarantee an atomic
     * multi-row batch by default. A test-only deployment representing one
     * that cannot sets this false so executeMany rejects BEFORE the first
     * write rather than risking partial durability.
     */
    supportsAtomicBatch: boolean;
    connect(): Promise<void>;
    private ensureConnected;
    /** Execute a SQL-like statement translated to a MongoDB operation. */
    execute(sql: string, params?: unknown[]): unknown;
    executeAsync(sql: string, params?: unknown[]): Promise<unknown>;
    executeMany(sql: string, paramsList: unknown[][]): {
        totalAffected: number;
        lastId?: number | bigint;
    };
    executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{
        totalAffected: number;
        lastId?: number | bigint;
    }>;
    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): T[];
    queryAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
    fetch<T = Record<string, unknown>>(sql: string, params?: unknown[], limit?: number, skip?: number): T[];
    fetchAsync<T = Record<string, unknown>>(sql: string, params?: unknown[], limit?: number, skip?: number): Promise<T[]>;
    fetchOne<T = Record<string, unknown>>(sql: string, params?: unknown[]): T | null;
    fetchOneAsync<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T | null>;
    /**
     * Atomic, monotonic, concurrency-safe next id — feature 16. A
     * findOneAndUpdate($inc) on the tina4_sequences collection, keyed by _id (its
     * built-in unique index makes concurrent first-use upserts race-safe: two
     * callers can never create two counters for one table). Seeds from
     * MAX(pkColumn) the FIRST time only ($setOnInsert). Throws on an impossible
     * empty result rather than returning a fixed id that could collide with a row.
     */
    getNextId(table: string, pkColumn?: string): Promise<number>;
    insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult;
    insertAsync(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseResult>;
    update(table: string, data: Record<string, unknown>, filter: Record<string, unknown>): DatabaseResult;
    updateAsync(table: string, data: Record<string, unknown>, filter: Record<string, unknown>): Promise<DatabaseResult>;
    delete(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[]): DatabaseResult;
    deleteAsync(table: string, filter: Record<string, unknown> | string | Record<string, unknown>[]): Promise<DatabaseResult>;
    startTransaction(): void;
    startTransactionAsync(): Promise<void>;
    commit(): void;
    commitAsync(): Promise<void>;
    rollback(): void;
    rollbackAsync(): Promise<void>;
    getTables(): string[];
    tablesAsync(): Promise<string[]>;
    getColumns(table: string): ColumnInfo[];
    /**
     * Infer column schema by sampling a document from the collection.
     * MongoDB is schema-less; this returns field names and inferred JS types.
     */
    columnsAsync(table: string): Promise<ColumnInfo[]>;
    lastInsertId(): number | bigint | null;
    close(): void;
    tableExists(name: string): boolean;
    tableExistsAsync(name: string): Promise<boolean>;
    createTable(name: string, columns: Record<string, FieldDefinition>): void;
    /**
     * Create a MongoDB collection with optional JSON schema validation derived
     * from the Tina4 field definitions.
     */
    createTableAsync(name: string, columns: Record<string, FieldDefinition>): Promise<void>;
    /** Get column info as a plain array (legacy migration support). */
    getTableColumnsAsync(table: string): Promise<Array<{
        name: string;
        type: string;
    }>>;
}