import { Builder } from './Builder.js';
import type { Dialect } from './Dialect.js';
import type { Diff } from './Diff.js';
import type { Driver } from './Driver.js';
import { type HasQuery, type HasResolver, type HasSql, type HasTable, internalResolver } from './Internal.js';
import type { Async, Deliver, Either, QueryDialect, QueryMeta, Sync } from './MetaData.js';
import { BatchQuery } from './Queries.js';
import { Resolver } from './Resolver.js';
import { type Sql } from './Sql.js';
import type { Table } from './Table.js';
import type { SelectFirst } from './query/Select.js';
export declare class Database<Meta extends QueryMeta = Either> extends Builder<Meta> implements HasResolver<Meta> {
    driver: Driver;
    dialect: Dialect;
    diff: Diff;
    readonly [internalResolver]: Resolver<Meta>;
    constructor(driver: Driver, dialect: Dialect, diff: Diff);
    close(this: Database<Async>): Promise<void>;
    close(this: Database<Sync>): void;
    [Symbol.dispose](this: Database<Sync>): void;
    [Symbol.asyncDispose](this: Database<Async>): Promise<void>;
    create(...tables: Array<HasTable>): BatchQuery<unknown, Meta>;
    drop(...tables: Array<HasTable>): BatchQuery<unknown, Meta>;
    run(input: HasSql): Deliver<Meta, void>;
    get<Result extends Array<unknown>>(input: HasQuery<Result>): Deliver<Meta, Result[number]>;
    get<Result>(input: HasSql<Result>): Deliver<Meta, Result>;
    all<Result>(input: HasSql<Result>): Deliver<Meta, Array<Result>>;
    migrate(...tables: Array<Table>): Deliver<Meta, void>;
    batch<Queries extends Array<HasSql | HasQuery>>(queries: Queries): BatchQuery<unknown, Meta>;
    execute(input: HasSql): Deliver<Meta, void>;
    transaction<T>(this: Database<Sync>, run: (tx: Transaction<Meta>) => T, options?: TransactionOptions[Meta['dialect']]): T;
    transaction<T>(this: Database<Async>, run: (tx: Transaction<Meta>) => Promise<T>, options?: TransactionOptions[Meta['dialect']]): Promise<T>;
    transaction<T>(run: (tx: Transaction<Meta>) => T | Promise<T>, options?: TransactionOptions[Meta['dialect']]): Deliver<Meta, T>;
    $count(source: Table | HasSql, condition?: HasSql<boolean>): SelectFirst<Sql<number>, Meta>;
}
export interface TransactionUniversalOptions {
    async?: boolean;
}
export interface TransactionOptions {
    universal: TransactionUniversalOptions;
    sqlite: TransactionUniversalOptions & {
        behavior?: 'deferred' | 'immediate' | 'exclusive';
    };
    postgres: TransactionUniversalOptions & {
        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
        accessMode?: 'read only' | 'read write';
        deferrable?: boolean;
    };
    mysql: TransactionUniversalOptions & {
        isolationLevel?: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
        accessMode?: 'read only' | 'read write';
        withConsistentSnapshot?: boolean;
    };
}
export declare class Rollback<Data = never> extends Error {
    data: Data;
    constructor(data: Data);
}
export declare class Transaction<Meta extends QueryMeta> extends Database<Meta> {
    rollback<Data>(data?: Data): never;
}
export declare class SyncDatabase<Dialect extends QueryDialect> extends Database<Sync<Dialect>> {
}
export declare class AsyncDatabase<Dialect extends QueryDialect> extends Database<Async<Dialect>> {
}