import { SqlResult } from '../models/SqlResult';
import { SqlEngine, DriverConfig } from '../models/SqlEngine';
import { DriverTransaction } from '../driver/SqlDriver';
import { Dialect } from '../builder/Dialect';
import { SqlFragment } from '../builder/SqlTag';
import { ResultSet } from '../result/ResultSet';
/** Transaction handle: driver tx plus the client's dialect/engine, so QueryBuilder.run(tx) works. */
export type SqlTransaction = DriverTransaction & {
    dialect: Dialect;
    engine: SqlEngine;
};
export interface SqlClientConfig extends DriverConfig {
    /** Explicit engine; if omitted, inferred from `connectionString`'s scheme. */
    engine?: SqlEngine;
    /** Override the dialect (rarely needed). */
    dialect?: Dialect;
}
/** Engine-agnostic SQL client. Resolves the engine via the Abstract Factory and delegates. */
export declare class SqlClient {
    readonly engine: SqlEngine;
    readonly dialect: Dialect;
    private driver;
    constructor(config: SqlClientConfig);
    query<T = Record<string, unknown>>(fragment: SqlFragment): Promise<SqlResult<T>>;
    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<SqlResult<T>>;
    execute(fragment: SqlFragment): Promise<SqlResult>;
    execute(sql: string, params?: unknown[]): Promise<SqlResult>;
    /** query() + rows(): fetch straight into a ResultSet. */
    fetch<T extends object = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<ResultSet<T>>;
    /** Split a multi-statement script with this engine's rules and execute each statement in order. */
    runScript(sqlText: string): Promise<void>;
    /** Cheap connectivity check; throws if the engine is unreachable. */
    ping(): Promise<void>;
    transaction<R>(fn: (tx: SqlTransaction) => Promise<R>): Promise<R>;
    end(): Promise<void>;
}