/**
 * Scalable API Utilities
 * Optimized HTTP request handling with connection pooling, retries, and circuit breakers
 */
import { EventEmitter } from 'events';
export interface ApiRequestConfig {
    url: string;
    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    headers?: Record<string, string>;
    body?: any;
    timeout?: number;
    retries?: number;
    retryDelay?: number;
    circuitBreakerThreshold?: number;
}
export interface ApiResponse<T = any> {
    data: T;
    status: number;
    statusText: string;
    headers: Record<string, string>;
    duration: number;
}
export interface ApiMetrics {
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    averageResponseTime: number;
    circuitBreakerActivations: number;
}
/**
 * Scalable API client with connection pooling, retries, and circuit breaker
 */
export declare class ScalableApiClient extends EventEmitter {
    private metrics;
    private circuitBreakers;
    private activeRequests;
    private requestQueue;
    private maxConcurrentRequests;
    private processingQueue;
    private readonly maxQueueSize;
    private batchQueue;
    private readonly maxBatchSize;
    private readonly maxBatchWaitTime;
    private batchTimer?;
    private readonly batchableMethods;
    constructor(options?: {
        maxConcurrentRequests?: number;
    });
    /**
     * Execute API request with retry logic and circuit breaker protection
     */
    request<T = any>(config: ApiRequestConfig): Promise<ApiResponse<T>>;
    /**
     * Check if request can be batched
     */
    private canBatchRequest;
    /**
     * Add request to batch queue
     */
    private batchRequest;
    /**
     * Process batch of requests
     */
    private processBatch;
    private executeRequest;
    private executeWithRetries;
    private makeHttpRequest;
    private makeFetchRequest;
    private makeNodeRequest;
    /**
     * Async response parsing to prevent blocking the event loop
     */
    private parseResponseAsync;
    private processQueue;
    private canExecuteRequest;
    private handleCircuitBreakerFailure;
    private resetCircuitBreaker;
    private getCircuitKey;
    private generateRequestId;
    private updateAverageResponseTime;
    /**
     * Get current API metrics
     */
    getMetrics(): ApiMetrics;
    /**
     * Get current queue size and active requests
     */
    getQueueStatus(): {
        queueSize: number;
        activeRequests: number;
    };
    /**
     * Reset all metrics
     */
    resetMetrics(): void;
    get<T = any>(url: string, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>>;
    post<T = any>(url: string, body?: any, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>>;
    put<T = any>(url: string, body?: any, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>>;
    delete<T = any>(url: string, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>>;
    patch<T = any>(url: string, body?: any, config?: Partial<ApiRequestConfig>): Promise<ApiResponse<T>>;
}
/**
 * Create a scalable API client with default configuration
 */
export declare function createScalableApiClient(options?: {
    maxConcurrentRequests?: number;
}): ScalableApiClient;
/**
 * Default API client instance for common use cases
 */
export declare const defaultApiClient: ScalableApiClient;
/**
 * Convenience methods for common HTTP operations
 */
export declare const api: {
    get: <T = any>(url: string, config?: Partial<ApiRequestConfig>) => Promise<ApiResponse<T>>;
    post: <T = any>(url: string, body?: any, config?: Partial<ApiRequestConfig>) => Promise<ApiResponse<T>>;
    put: <T = any>(url: string, body?: any, config?: Partial<ApiRequestConfig>) => Promise<ApiResponse<T>>;
    delete: <T = any>(url: string, config?: Partial<ApiRequestConfig>) => Promise<ApiResponse<T>>;
    patch: <T = any>(url: string, body?: any, config?: Partial<ApiRequestConfig>) => Promise<ApiResponse<T>>;
};
export default defaultApiClient;
//# sourceMappingURL=scalableApi.d.ts.map