import type { DatabaseAdapter, DatabaseResult, ColumnInfo, FieldDefinition } from "../types.js";
export interface MysqlConfig {
    host?: string;
    port?: number;
    user?: string;
    password?: string;
    database?: string;
    connectionString?: string;
}
export declare class MysqlAdapter implements DatabaseAdapter {
    private config;
    /**
     * Postgres, MySQL and MSSQL all REQUIRE a name for a derived table, so
     * the COUNT probe in Database.countProbe wraps as
     * `FROM (sql) AS _count_query`. SQLite and Firebird leave this unset and
     * get no alias - Firebird rejects `AS` in that position.
     */
    readonly countSubqueryAlias = "_count_query";
    private connection;
    private _lastInsertId;
    private _inTransaction;
    constructor(config: MysqlConfig | string);
    /** Connect to MySQL. 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;
    private queryPromise;
    /** Translate SQL for MySQL dialect. */
    translateSql(sql: string): string;
    execute(sql: string, params?: unknown[]): unknown;
    executeMany(sql: string, paramsList: unknown[][]): {
        totalAffected: number;
        lastId?: number | bigint;
    };
    executeManyAsync(sql: string, paramsList: unknown[][]): Promise<{
        totalAffected: number;
        lastId?: number | bigint;
    }>;
    executeAsync(sql: string, params?: unknown[]): Promise<unknown>;
    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>;
    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>, params?: unknown[]): DatabaseResult;
    updateAsync(table: string, data: Record<string, unknown>, filter: Record<string, unknown> | string, params?: unknown[]): Promise<DatabaseResult>;
    delete(table: string, filter: Record<string, unknown>, params?: unknown[]): DatabaseResult;
    deleteAsync(table: string, filter: Record<string, unknown> | string, params?: 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[];
    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;
    createTableAsync(name: string, columns: Record<string, FieldDefinition>): Promise<void>;
}