export interface PooledConnection {
    id: string;
    provider: string;
    createdAt: number;
    lastUsedAt: number;
    inUse: boolean;
}
export declare class ConnectionPool {
    private pool;
    private maxPerProvider;
    private ttlMs;
    private logger;
    constructor(maxPerProvider?: number, ttlMs?: number);
    acquire(provider: string): PooledConnection;
    release(id: string): void;
    getStats(): Record<string, {
        total: number;
        inUse: number;
    }>;
    drain(): void;
}
export interface BatchRequest<T> {
    payload: T;
    resolve: (result: unknown) => void;
    reject: (error: Error) => void;
}
export declare class RequestBatcher<T> {
    private queue;
    private timer;
    private maxBatchSize;
    private delayMs;
    private processor;
    private logger;
    constructor(processor: (batch: T[]) => Promise<unknown[]>, maxBatchSize?: number, delayMs?: number);
    add(payload: T): Promise<unknown>;
    flush(): Promise<void>;
    get pending(): number;
}
export declare class LazyLoader<T> {
    private cache;
    private loaders;
    register(name: string, loader: () => Promise<T>): void;
    get(name: string): Promise<T>;
    isLoaded(name: string): boolean;
    evict(name: string): void;
    clear(): void;
    get loadedCount(): number;
    get registeredCount(): number;
}
//# sourceMappingURL=performance.d.ts.map