import { Kysely, Transaction } from 'kysely';
import { KyselyDatabase } from './KyselyDatabase.js';
import { Database } from '../../Database.js';
import { DatabaseTransaction } from '../../DatabaseTransaction.js';
/**
 * Represents a transaction for querying a database with a specific schema.
 * @param DBSchema - The schema of the database.
 * @type {KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>}
 */
export type KyselyTransaction<DBSchema> = KyselyTransactionImpl<DBSchema> & Transaction<DBSchema>;
/**
 * Represents a transaction in a Postgres database.
 */
export declare class KyselyTransactionImpl<DBSchema> extends DatabaseTransaction {
    /**
     * A readonly property representing a writer for a Kysely object.
     * @type {Kysely<any>}
     */
    readonly writer: Kysely<any>;
    /**
     * A readonly property representing a reader of type Kysely<any>.
     * This property allows reading data of any type using the Kysely interface.
     */
    readonly reader: Kysely<any>;
    /**
     * A protected property representing a transaction of type any.
     */
    protected transaction: Transaction<any>;
    /**
     * A protected property representing a database instance.
     * @type {Database<KyselyTransaction<DBSchema>>}
     */
    protected database: Database<KyselyTransaction<DBSchema>>;
    /**
     * A private property that represents a deferred object.
     * @type {Deferred<any>}
     */
    private txWrapper;
    /**
     * Constructs a new instance of the class.
     * @param {Kysely<DBSchema>} delegate - The delegate object for the database query.
     * @param {KyselyDatabase<DBSchema>} database - The database object for the query.
     * @param {Kysely<DBSchema>} [reader] - An optional reader object for the query.
     * @returns None
     */
    private constructor();
    /**
     * Creates a new database transaction for the given database schema.
     * @param {Kysely<DBSchema>} connection - The connection object for the transaction.
     * @param {KyselyDatabase<DBSchema>} database - The database object for the transaction.
     * @param {Kysely<DBSchema>} [reader] - An optional reader object for the transaction.
     * @returns {Promise<KyselyTransaction<DBSchema>>} A promise that resolves to the created transaction.
     */
    static newTransaction<DBSchema>(connection: Kysely<DBSchema>, database: KyselyDatabase<DBSchema>, reader?: Kysely<DBSchema>): Promise<KyselyTransaction<DBSchema>>;
    /**
     * Asynchronously begins a transaction using a writer and resolves the transaction once it is executed.
     * @returns A Promise that resolves with the transaction object once the transaction is executed.
     */
    protected doBegin: () => Promise<unknown>;
    /**
     * Executes the commit operation by resolving the transaction wrapper and returning a resolved Promise.
     * @returns A Promise that resolves to null.
     */
    protected doCommit: () => Promise<void>;
    /**
     * Performs a rollback operation by rejecting the transaction wrapper with an error.
     * @returns A resolved Promise after the rollback operation is completed.
     */
    protected doRollback: () => Promise<void>;
}