/** Connection Pool Manager using generic-pool */
import { EventEmitter } from 'events';
export declare enum CircuitState {
    CLOSED = "closed",
    OPEN = "open",
    HALF_OPEN = "half-open"
}
export interface ConnectionPoolOptions {
    maxConnections?: number;
    acquireTimeout?: number;
    healthCheckInterval?: number;
    maxRetries?: number;
    retryDelay?: number;
}
export interface PoolStats {
    totalAcquisitions: number;
    successfulAcquisitions: number;
    failedAcquisitions: number;
    totalAcquireTime: number;
    connectionsCreated: number;
    connectionsDestroyed: number;
    activeConnections: number;
    waitingRequests: number;
}
export interface Factory<T> {
    create(): Promise<T>;
    destroy(connection: T): Promise<void>;
    validate?(connection: T): Promise<boolean>;
}
export declare class AdvancedConnectionPool extends EventEmitter {
    private factory;
    private options;
    private pool;
    private poolInit;
    private isShutdown;
    private circuitState;
    private failureCount;
    private lastFailureTime;
    private healthCheckInterval?;
    private autoTransitionId?;
    private config;
    private stats;
    constructor(factory: Factory<any>, options?: ConnectionPoolOptions);
    private initializePool;
    /**
     * Acquire a connection from the pool
     */
    acquire(): Promise<any>;
    /**
     * Release a connection back to the pool
     */
    release(connection: any): Promise<void>;
    /**
        * Shutdown the connection pool
        */
    shutdown(): Promise<void>;
    /**
     * Get pool statistics
     */
    getStats(): PoolStats;
    /**
     * Check if connections can be acquired
     */
    private canAcquire;
    /**
     * Handle connection failures
     */
    private handleFailure;
    /**
     * Start health monitoring
     */
    private startHealthMonitoring;
    /**
     * Perform health checks on all connections
     */
    private performHealthChecks;
    /**
     * Reset circuit breaker to closed state
     */
    resetCircuitBreaker(): void;
    /**
     * Get current circuit breaker state
     */
    getCircuitState(): CircuitState;
}
/**
 * Create a connection pool with factory
 */
export declare function createConnectionPool(factory: Factory<any>, options?: ConnectionPoolOptions): AdvancedConnectionPool;
declare const _default: {
    AdvancedConnectionPool: typeof AdvancedConnectionPool;
    createConnectionPool: typeof createConnectionPool;
    CircuitState: typeof CircuitState;
};
export default _default;
//# sourceMappingURL=connectionPool.d.ts.map