/**
 * Transaction Manager
 *
 * Manages distributed transactions with ACID-like semantics
 */
import type { TransactionConfig, TransactionContext, TransactionOperation, TransactionResult, TransactionStats, TransactionState, TransactionManagerConfig, TransactionCallbacks } from './types.js';
/**
 * Transaction Manager
 */
export declare class TransactionManager {
    private config;
    private transactions;
    private stats;
    private cleanupTimer?;
    private logger;
    private metrics;
    private transactionCounter;
    constructor(config?: TransactionManagerConfig);
    /**
     * Initialize transaction manager
     */
    initialize(): Promise<void>;
    /**
     * Begin a new transaction
     */
    begin(config?: TransactionConfig, callbacks?: TransactionCallbacks): Promise<Transaction>;
    /**
     * Get transaction context
     */
    getTransaction(transactionId: string): TransactionContext | undefined;
    /**
     * Commit a transaction
     */
    commit(transactionId: string, callbacks?: TransactionCallbacks): Promise<TransactionResult>;
    /**
     * Rollback a transaction
     */
    rollback(transactionId: string, callbacks?: TransactionCallbacks): Promise<TransactionResult>;
    /**
     * Get transaction statistics
     */
    getStats(): TransactionStats;
    /**
     * Destroy transaction manager
     */
    destroy(): Promise<void>;
    /**
     * Add operation to transaction
     */
    addOperation(context: TransactionContext, operation: TransactionOperation): void;
    /**
     * Execute an operation
     */
    private executeOperation;
    /**
     * Handle version conflict
     */
    private handleConflict;
    /**
     * Generate transaction ID
     */
    private generateTransactionId;
    /**
     * Start cleanup timer for expired transactions
     */
    private startCleanupTimer;
    /**
     * Cleanup expired transactions
     */
    private cleanupExpiredTransactions;
    /**
     * Update average statistics
     */
    private updateAverages;
}
/**
 * Transaction class for fluent API
 */
export declare class Transaction {
    private manager;
    private context;
    private callbacks?;
    private savepoints;
    constructor(manager: TransactionManager, context: TransactionContext, callbacks?: TransactionCallbacks);
    /**
     * Get transaction ID
     */
    getId(): string;
    /**
     * Get transaction state
     */
    getState(): TransactionState;
    /**
     * Read a document
     */
    read<T>(index: string, id: string): Promise<T | null>;
    /**
     * Create a document
     */
    create<T>(index: string, id: string, document: T): Promise<void>;
    /**
     * Update a document
     */
    update<T>(index: string, id: string, document: Partial<T>): Promise<void>;
    /**
     * Delete a document
     */
    delete(index: string, id: string): Promise<void>;
    /**
     * Create a savepoint
     */
    savepoint(name: string): void;
    /**
     * Rollback to savepoint
     */
    rollbackTo(name: string): void;
    /**
     * Commit the transaction
     */
    commit(): Promise<TransactionResult>;
    /**
     * Rollback the transaction
     */
    rollback(): Promise<TransactionResult>;
}
/**
 * Create a transaction manager
 */
export declare function createTransactionManager(config?: TransactionManagerConfig): TransactionManager;