/**
 * Transaction Manager
 *
 * Manages database transactions across different database adapters.
 * Provides transaction creation, lifecycle management, and savepoint handling.
 */
import { ITransactionOptions, ITransaction, ISavepoint, ITransactionCallback, ITransactionContext, TransactionStatus } from '../types/transaction.interface';
import { BaseAdapter } from '../adapters/base.adapter';
/**
 * Transaction implementation
 */
declare class Transaction implements ITransaction {
    readonly id: string;
    private _status;
    private context;
    private adapter;
    private savepoints;
    constructor(id: string, adapter: BaseAdapter, context: ITransactionContext);
    get status(): TransactionStatus;
    get client(): any;
    commit(): Promise<void>;
    rollback(): Promise<void>;
    isActive(): boolean;
    savepoint(name: string): Promise<ISavepoint>;
    /**
     * Get a savepoint by name
     */
    getSavepoint(name: string): ISavepoint | undefined;
    /**
     * Remove a savepoint from tracking (after release or rollback)
     */
    removeSavepoint(name: string): void;
    /**
     * Get the transaction context
     */
    getContext(): ITransactionContext;
}
/**
 * Savepoint implementation
 */
declare class Savepoint implements ISavepoint {
    readonly name: string;
    private transaction;
    private adapter;
    private released;
    private rolledBack;
    constructor(name: string, transaction: Transaction, adapter: BaseAdapter);
    release(): Promise<void>;
    rollback(): Promise<void>;
}
/**
 * Transaction Manager for managing database transactions
 */
export declare class TransactionManager {
    private activeTransactions;
    private transactionTimeouts;
    /**
     * Begin a new transaction
     * @param adapter Database adapter
     * @param options Transaction options
     * @returns Transaction object
     */
    beginTransaction(adapter: BaseAdapter, options: ITransactionOptions): Promise<ITransaction>;
    /**
     * Execute a callback within a transaction
     * Automatically commits on success, rolls back on error
     * @param adapter Database adapter
     * @param options Transaction options
     * @param callback Transaction callback
     * @returns Result from callback
     */
    executeTransaction<T>(adapter: BaseAdapter, options: ITransactionOptions, callback: ITransactionCallback<T>): Promise<T>;
    /**
     * Create a savepoint within a transaction
     * @param transaction Transaction
     * @param name Savepoint name
     * @param adapter Database adapter
     * @returns Savepoint object
     */
    createSavepoint(transaction: Transaction, name: string, adapter: BaseAdapter): Savepoint;
    /**
     * Get an active transaction by ID
     * @param id Transaction ID
     * @returns Transaction context or undefined
     */
    getActiveTransaction(id: string): ITransactionContext | undefined;
    /**
     * Get all active transactions
     * @returns Map of active transaction contexts
     */
    getAllActiveTransactions(): Map<string, ITransactionContext>;
    /**
     * Get count of active transactions
     * @returns Number of active transactions
     */
    getActiveTransactionCount(): number;
    /**
     * Check if a transaction is active
     * @param id Transaction ID
     * @returns True if transaction is active
     */
    isTransactionActive(id: string): boolean;
    /**
     * Force rollback all active transactions (for cleanup)
     * @param adapter Database adapter
     */
    rollbackAllTransactions(adapter: BaseAdapter): Promise<void>;
    private parseIsolationLevel;
    private setTransactionTimeout;
    private cleanupTransaction;
    private clearAllTimeouts;
}
export { Transaction, Savepoint };