/**
 * Connection Pool Manager for NoSQL Storage Engine
 * Optimizes connection reuse and resource management for sub-10ms latency
 */
import { ConnectionPoolConfig } from '../types';
export interface PooledConnection<T> {
    id: string;
    connection: T;
    created: number;
    lastUsed: number;
    inUse: boolean;
    usageCount: number;
    healthy: boolean;
}
export interface ConnectionFactory<T> {
    create(): Promise<T>;
    validate(connection: T): Promise<boolean>;
    destroy(connection: T): Promise<void>;
}
export interface PoolMetrics {
    totalConnections: number;
    activeConnections: number;
    idleConnections: number;
    queuedRequests: number;
    averageWaitTime: number;
    connectionErrors: number;
    poolHitRate: number;
}
export declare class ConnectionPool<T> {
    private factory;
    private config;
    private connections;
    private waitingQueue;
    private metrics;
    private cleanupInterval?;
    private healthCheckInterval?;
    private destroyed;
    constructor(factory: ConnectionFactory<T>, config: ConnectionPoolConfig);
    acquire(): Promise<PooledConnection<T>>;
    release(connection: PooledConnection<T>): Promise<void>;
    destroy(): Promise<void>;
    getMetrics(): PoolMetrics;
    warmUp(): Promise<void>;
    private getIdleConnection;
    private canCreateConnection;
    private createConnection;
    private generateConnectionId;
    private startCleanupProcess;
    private startHealthChecking;
    private cleanupIdleConnections;
    private performHealthChecks;
    private updateConnectionCounts;
    private updateMetrics;
    private resetMetrics;
}
export declare class D1ConnectionFactory implements ConnectionFactory<D1Database> {
    private database;
    constructor(database: D1Database);
    create(): Promise<D1Database>;
    validate(connection: D1Database): Promise<boolean>;
    destroy(connection: D1Database): Promise<void>;
}
export declare class KVConnectionFactory implements ConnectionFactory<KVNamespace> {
    private namespace;
    constructor(namespace: KVNamespace);
    create(): Promise<KVNamespace>;
    validate(connection: KVNamespace): Promise<boolean>;
    destroy(connection: KVNamespace): Promise<void>;
}
export declare class R2ConnectionFactory implements ConnectionFactory<R2Bucket> {
    private bucket;
    constructor(bucket: R2Bucket);
    create(): Promise<R2Bucket>;
    validate(connection: R2Bucket): Promise<boolean>;
    destroy(connection: R2Bucket): Promise<void>;
}
export declare class DurableObjectConnectionFactory implements ConnectionFactory<DurableObjectStub> {
    private namespace;
    private objectId;
    constructor(namespace: DurableObjectNamespace, objectId: string);
    create(): Promise<DurableObjectStub>;
    validate(connection: DurableObjectStub): Promise<boolean>;
    destroy(connection: DurableObjectStub): Promise<void>;
}
//# sourceMappingURL=connection-pool.d.ts.map