rezo 1.0.5 → 1.0.7

package/dist/index.d.ts

@@ -6,9 +6,6 @@ import { Agent as HttpsAgent } from 'node:https';
 import { Socket } from 'node:net';
 import { Readable, Writable, WritableOptions } from 'node:stream';
 import { SecureContext, TLSSocket } from 'node:tls';
-import PQueue from 'p-queue';
-import { Options as Options$1, QueueAddOptions } from 'p-queue';
-import PriorityQueue from 'p-queue/dist/priority-queue';
 import { Cookie as TouchCookie, CookieJar as TouchCookieJar, CreateCookieOptions } from 'tough-cookie';
 
 export interface RezoHttpHeaders {
@@ -972,8 +969,17 @@ export interface ProxyCooldownConfig {
  * Complete configuration for proxy rotation, filtering, and failure handling
  */
 export interface ProxyManagerBaseConfig {
-	/** Array of proxies to manage */
-	proxies: ProxyInfo[];
+	/**
+	 * Array of proxies to manage
+	 * Accepts ProxyInfo objects or proxy URL strings (parsed via parseProxyString)
+	 * @example
+	 * proxies: [
+	 *   { protocol: 'http', host: '127.0.0.1', port: 8080 },
+	 *   'socks5://user:pass@proxy.example.com:1080',
+	 *   'http://proxy.example.com:3128'
+	 * ]
+	 */
+	proxies: (ProxyInfo | string)[];
 	/**
 	 * Whitelist patterns for URLs that should use proxy
 	 * - String: exact domain match (e.g., 'api.example.com') or subdomain match (e.g., 'example.com' matches '*.example.com')
@@ -1185,6 +1191,35 @@ export interface AfterProxyEnableContext {
 	/** Reason for enabling */
 	reason: "cooldown-expired" | "manual";
 }
+/**
+ * Context for onNoProxiesAvailable hook
+ * Triggered when no proxies are available and an error would be thrown
+ */
+export interface OnNoProxiesAvailableContext {
+	/** Request URL that needed a proxy */
+	url: string;
+	/** The error that will be thrown */
+	error: Error;
+	/** All proxies (including disabled ones) */
+	allProxies: ProxyState[];
+	/** Number of active proxies (should be 0) */
+	activeCount: number;
+	/** Number of disabled proxies */
+	disabledCount: number;
+	/** Number of proxies in cooldown */
+	cooldownCount: number;
+	/** Reasons why proxies are unavailable */
+	disabledReasons: {
+		/** Proxies disabled due to failures */
+		dead: number;
+		/** Proxies disabled due to request limit */
+		limitReached: number;
+		/** Proxies manually disabled */
+		manual: number;
+	};
+	/** Timestamp when this event occurred */
+	timestamp: number;
+}
 /**
  * Context provided to beforeRequest hook
  * Contains metadata about the current request state
@@ -1503,6 +1538,16 @@ export type AfterProxyRotateHook = (context: AfterProxyRotateContext) => void |
  * Use for notifications, logging
  */
 export type AfterProxyEnableHook = (context: AfterProxyEnableContext) => void | Promise<void>;
+/**
+ * Hook called when no proxies are available and an error is about to be thrown
+ * Use for alerting, logging exhausted proxy pools, or triggering proxy refresh
+ * This hook is called just before the error is thrown, allowing you to:
+ * - Log the exhaustion event for monitoring
+ * - Trigger external proxy pool refresh
+ * - Send alerts to monitoring systems
+ * - Record statistics about proxy pool health
+ */
+export type OnNoProxiesAvailableHook = (context: OnNoProxiesAvailableContext) => void | Promise<void>;
 /**
  * Collection of all hook types
  * All hooks are arrays to allow multiple handlers
@@ -1527,6 +1572,7 @@ export interface RezoHooks {
 	afterProxyDisable: AfterProxyDisableHook[];
 	afterProxyRotate: AfterProxyRotateHook[];
 	afterProxyEnable: AfterProxyEnableHook[];
+	onNoProxiesAvailable: OnNoProxiesAvailableHook[];
 	onSocket: OnSocketHook[];
 	onDns: OnDnsHook[];
 	onTls: OnTlsHook[];
@@ -1983,6 +2029,401 @@ export declare class RezoError<T = any> extends Error {
 	toString(): string;
 	getFullDetails(): string;
 }
+/**
+ * RezoQueue - High-performance task queue with priority, concurrency, and HTTP-aware features
+ * @module queue/types
+ */
+/**
+ * Priority levels for queue ordering (higher = runs first)
+ */
+export declare const Priority: {
+	readonly LOWEST: 0;
+	readonly LOW: 25;
+	readonly NORMAL: 50;
+	readonly HIGH: 75;
+	readonly HIGHEST: 100;
+	readonly CRITICAL: 1000;
+};
+/**
+ * HTTP method priority presets
+ */
+export declare const HttpMethodPriority: Record<string, number>;
+/**
+ * Queue configuration options
+ */
+export interface QueueConfig {
+	/** Maximum concurrent tasks (default: Infinity) */
+	concurrency?: number;
+	/** Auto-start processing when tasks are added (default: true) */
+	autoStart?: boolean;
+	/** Timeout per task in milliseconds (default: none) */
+	timeout?: number;
+	/** Throw on timeout vs silently fail (default: true) */
+	throwOnTimeout?: boolean;
+	/** Interval between task starts in ms for rate limiting */
+	interval?: number;
+	/** Max tasks to start per interval (default: Infinity) */
+	intervalCap?: number;
+	/** Carry over unused interval capacity to next interval */
+	carryoverConcurrencyCount?: boolean;
+}
+/**
+ * HTTP-specific queue configuration
+ */
+export interface HttpQueueConfig extends QueueConfig {
+	/** Per-domain concurrency limits */
+	domainConcurrency?: number | Record<string, number>;
+	/** Global requests per second limit */
+	requestsPerSecond?: number;
+	/** Respect Retry-After headers automatically */
+	respectRetryAfter?: boolean;
+	/** Respect X-RateLimit-* headers automatically */
+	respectRateLimitHeaders?: boolean;
+	/** Retry failed tasks automatically */
+	autoRetry?: boolean;
+	/** Max retry attempts for auto-retry */
+	maxRetries?: number;
+	/** Delay between retries (supports backoff function) */
+	retryDelay?: number | ((attempt: number) => number);
+	/** Status codes that trigger retry */
+	retryStatusCodes?: number[];
+}
+/**
+ * Task options when adding to queue
+ */
+export interface TaskOptions {
+	/** Task priority (higher runs first, default: 0) */
+	priority?: number;
+	/** Task-specific timeout (overrides queue default) */
+	timeout?: number;
+	/** Unique ID for tracking/cancellation */
+	id?: string;
+	/** Signal for external cancellation */
+	signal?: AbortSignal;
+}
+/**
+ * HTTP-specific task options
+ */
+export interface HttpTaskOptions extends TaskOptions {
+	/** Domain for per-domain limiting (auto-extracted if not provided) */
+	domain?: string;
+	/** HTTP method for method-based priority */
+	method?: string;
+	/** Retry this specific task on failure */
+	retry?: boolean | number;
+	/** Custom retry delay for this task */
+	retryDelay?: number;
+}
+/**
+ * Current queue state
+ */
+export interface QueueState {
+	/** Number of tasks currently running */
+	pending: number;
+	/** Number of tasks waiting in queue */
+	size: number;
+	/** Total tasks (pending + size) */
+	total: number;
+	/** Is queue paused */
+	isPaused: boolean;
+	/** Is queue idle (no tasks) */
+	isIdle: boolean;
+}
+/**
+ * Queue statistics
+ */
+export interface QueueStats {
+	/** Total tasks added since creation */
+	added: number;
+	/** Total tasks processed (started) */
+	processed: number;
+	/** Total successful completions */
+	completed: number;
+	/** Total failures */
+	failed: number;
+	/** Total timeouts */
+	timedOut: number;
+	/** Total cancellations */
+	cancelled: number;
+	/** Average task duration (ms) */
+	averageDuration: number;
+	/** Tasks per second (rolling average) */
+	throughput: number;
+}
+/**
+ * HTTP-specific statistics
+ */
+export interface HttpQueueStats extends QueueStats {
+	/** Stats per domain */
+	byDomain: Record<string, {
+		pending: number;
+		completed: number;
+		failed: number;
+		rateLimited: number;
+	}>;
+	/** Total retries performed */
+	retries: number;
+	/** Rate limit events */
+	rateLimitHits: number;
+}
+/**
+ * Domain-specific state
+ */
+export interface DomainState {
+	/** Number of tasks currently running for domain */
+	pending: number;
+	/** Number of tasks waiting for domain */
+	size: number;
+	/** Is domain paused */
+	isPaused: boolean;
+	/** Rate limit until timestamp (if rate limited) */
+	rateLimitedUntil?: number;
+}
+/**
+ * Queue event types
+ */
+export interface QueueEvents {
+	/** Task added to queue */
+	add: {
+		id: string;
+		priority: number;
+	};
+	/** Task started executing */
+	start: {
+		id: string;
+	};
+	/** Task completed successfully */
+	completed: {
+		id: string;
+		result: any;
+		duration: number;
+	};
+	/** Task failed with error */
+	error: {
+		id: string;
+		error: Error;
+	};
+	/** Task timed out */
+	timeout: {
+		id: string;
+	};
+	/** Task cancelled */
+	cancelled: {
+		id: string;
+	};
+	/** Queue became active (was idle, now processing) */
+	active: undefined;
+	/** Queue became idle (all tasks done) */
+	idle: undefined;
+	/** Queue was paused */
+	paused: undefined;
+	/** Queue was resumed */
+	resumed: undefined;
+	/** Next task about to run */
+	next: undefined;
+	/** Queue was emptied (no pending tasks) */
+	empty: undefined;
+}
+/**
+ * HTTP-specific events
+ */
+export interface HttpQueueEvents extends QueueEvents {
+	/** Rate limit hit for a domain */
+	rateLimited: {
+		domain: string;
+		retryAfter: number;
+	};
+	/** Domain queue became available */
+	domainAvailable: {
+		domain: string;
+	};
+	/** Task being retried */
+	retry: {
+		id: string;
+		attempt: number;
+		error: Error;
+	};
+}
+/**
+ * Event handler type
+ */
+export type EventHandler<T> = (data: T) => void;
+/**
+ * Task function type
+ */
+export type TaskFunction<T> = () => Promise<T>;
+/**
+ * RezoQueue - A high-performance task queue with priority and concurrency control
+ *
+ * Features:
+ * - Priority-based task ordering (higher priority runs first)
+ * - Configurable concurrency limits
+ * - Task timeout support
+ * - Pause/resume functionality
+ * - Interval-based rate limiting
+ * - Task cancellation by ID
+ * - Comprehensive event system
+ * - Detailed statistics tracking
+ *
+ * @example
+ * ```typescript
+ * const queue = new RezoQueue({ concurrency: 5 });
+ *
+ * // Add tasks with priority
+ * const result = await queue.add(() => fetchData(), { priority: 100 });
+ *
+ * // Wait for all tasks to complete
+ * await queue.onIdle();
+ * ```
+ */
+export declare class RezoQueue<T = any> {
+	private queue;
+	private pendingCount;
+	private isPausedFlag;
+	private intervalId?;
+	private intervalCount;
+	private intervalStart;
+	private eventHandlers;
+	private statsData;
+	private totalDuration;
+	private throughputWindow;
+	private readonly throughputWindowSize;
+	private idlePromise?;
+	private emptyPromise?;
+	readonly config: Required<QueueConfig>;
+	/**
+	 * Create a new RezoQueue
+	 * @param config - Queue configuration options
+	 */
+	constructor(config?: QueueConfig);
+	/**
+	 * Get current queue state
+	 */
+	get state(): QueueState;
+	/**
+	 * Get queue statistics
+	 */
+	get stats(): QueueStats;
+	/**
+	 * Get/set concurrency limit
+	 */
+	get concurrency(): number;
+	set concurrency(value: number);
+	/**
+	 * Number of pending (running) tasks
+	 */
+	get pending(): number;
+	/**
+	 * Number of tasks waiting in queue
+	 */
+	get size(): number;
+	/**
+	 * Check if queue is paused
+	 */
+	get isPaused(): boolean;
+	/**
+	 * Add a task to the queue
+	 * @param fn - Async function to execute
+	 * @param options - Task options
+	 * @returns Promise resolving to task result
+	 */
+	add<R = T>(fn: TaskFunction<R>, options?: TaskOptions): Promise<R>;
+	/**
+	 * Add multiple tasks to the queue
+	 * @param fns - Array of async functions
+	 * @param options - Task options (applied to all)
+	 * @returns Promise resolving to array of results
+	 */
+	addAll<R = T>(fns: TaskFunction<R>[], options?: TaskOptions): Promise<R[]>;
+	/**
+	 * Pause queue processing (running tasks continue)
+	 */
+	pause(): void;
+	/**
+	 * Resume queue processing
+	 */
+	start(): void;
+	/**
+	 * Clear all pending tasks from queue
+	 */
+	clear(): void;
+	/**
+	 * Cancel a specific task by ID
+	 * @param id - Task ID to cancel
+	 * @returns true if task was found and cancelled
+	 */
+	cancel(id: string): boolean;
+	/**
+	 * Cancel all tasks matching a predicate
+	 * @param predicate - Function to test each task
+	 * @returns Number of tasks cancelled
+	 */
+	cancelBy(predicate: (task: {
+		id: string;
+		priority: number;
+	}) => boolean): number;
+	/**
+	 * Wait for queue to become idle (no running or pending tasks)
+	 */
+	onIdle(): Promise<void>;
+	/**
+	 * Wait for queue to be empty (no pending tasks, but may have running)
+	 */
+	onEmpty(): Promise<void>;
+	/**
+	 * Wait for queue size to be less than limit
+	 * @param limit - Size threshold
+	 */
+	onSizeLessThan(limit: number): Promise<void>;
+	/**
+	 * Register an event handler
+	 * @param event - Event name
+	 * @param handler - Handler function
+	 */
+	on<E extends keyof QueueEvents>(event: E, handler: EventHandler<QueueEvents[E]>): void;
+	/**
+	 * Remove an event handler
+	 * @param event - Event name
+	 * @param handler - Handler function to remove
+	 */
+	off<E extends keyof QueueEvents>(event: E, handler: EventHandler<QueueEvents[E]>): void;
+	/**
+	 * Destroy the queue and cleanup resources
+	 */
+	destroy(): void;
+	/**
+	 * Insert task into queue maintaining priority order (highest first)
+	 */
+	private insertByPriority;
+	/**
+	 * Try to run next task if capacity available
+	 */
+	private tryRunNext;
+	/**
+	 * Execute a task
+	 */
+	private runTask;
+	/**
+	 * Record task duration for statistics
+	 */
+	private recordDuration;
+	/**
+	 * Start interval-based rate limiting
+	 */
+	private startInterval;
+	/**
+	 * Emit an event
+	 */
+	protected emit<E extends keyof QueueEvents>(event: E, data: QueueEvents[E]): void;
+	/**
+	 * Check if queue became empty
+	 */
+	private checkEmpty;
+	/**
+	 * Check if queue became idle
+	 */
+	private checkIdle;
+}
 type ProxyProtocol$1 = "http" | "https" | "socks4" | "socks5";
 /**
  * Configuration options for proxy connections
@@ -2104,7 +2545,7 @@ export interface RezoRequestConfig<D = any> {
 	/**
 	 * Queue to use for request execution
 	 */
-	queue?: PQueue | null;
+	queue?: RezoQueue | null;
 	/**
 	 * Controls how the response body is parsed and returned in `response.data`.
 	 *
@@ -2194,10 +2635,6 @@ export interface RezoRequestConfig<D = any> {
 	autoSetOrigin?: boolean;
 	treat302As303?: boolean;
 	startNewRequest?: boolean;
-	/** Whether to use HTTP/2 protocol */
-	http2?: boolean;
-	/** Whether to use cURL adapter */
-	curl?: boolean;
 	/**
 	 * DNS cache configuration for faster repeated requests.
 	 *
@@ -2301,6 +2738,12 @@ export interface RezoRequestConfig<D = any> {
 	withCredentials?: boolean;
 	/** Proxy configuration (URL string or detailed options) */
 	proxy?: string | ProxyOptions;
+	/**
+	 * Whether to use ProxyManager for this request
+	 * Set to false to bypass ProxyManager even when one is configured
+	 * @default true (uses ProxyManager if configured)
+	 */
+	useProxyManager?: boolean;
 	/** Whether to enable automatic cookie handling */
 	useCookies?: boolean;
 	/** Custom cookie jar for managing cookies */
@@ -2322,8 +2765,6 @@ export interface RezoRequestConfig<D = any> {
 	transformRequest?: Array<(data: any, headers: RezoHeaders) => any>;
 	/** Array of functions to transform response data */
 	transformResponse?: Array<(data: any) => any>;
-	/** Adapter to use for the request (name or custom function) */
-	adapter?: string | ((config: RezoRequestConfig) => Promise<any>);
 	/** AbortSignal to cancel the request */
 	signal?: AbortSignal;
 	/** File path to save the response to (for downloads) */
@@ -2540,6 +2981,7 @@ type BeforeProxyDisableHook$1 = (context: BeforeProxyDisableContext) => boolean
 type AfterProxyDisableHook$1 = (context: AfterProxyDisableContext) => void | Promise<void>;
 type AfterProxyRotateHook$1 = (context: AfterProxyRotateContext) => void | Promise<void>;
 type AfterProxyEnableHook$1 = (context: AfterProxyEnableContext) => void | Promise<void>;
+type OnNoProxiesAvailableHook$1 = (context: OnNoProxiesAvailableContext) => void | Promise<void>;
 /**
  * Proxy hooks collection for ProxyManager events
  */
@@ -2552,6 +2994,8 @@ export interface ProxyHooks {
 	afterProxyDisable: AfterProxyDisableHook$1[];
 	afterProxyRotate: AfterProxyRotateHook$1[];
 	afterProxyEnable: AfterProxyEnableHook$1[];
+	/** Hook triggered when no proxies are available */
+	onNoProxiesAvailable: OnNoProxiesAvailableHook$1[];
 }
 /**
  * ProxyManager - Advanced proxy rotation and pool management
@@ -2706,8 +3150,40 @@ export declare class ProxyManager {
 	private runAfterProxyRotateHooks;
 	private runAfterProxyDisableHooks;
 	private runAfterProxyEnableHooks;
+	/**
+	 * Run onNoProxiesAvailable hooks synchronously
+	 * Called when no proxies are available and an error is about to be thrown
+	 */
+	private runOnNoProxiesAvailableHooksSync;
+	/**
+	 * Run onNoProxiesAvailable hooks asynchronously
+	 * Called when no proxies are available and an error is about to be thrown
+	 */
+	runOnNoProxiesAvailableHooks(context: OnNoProxiesAvailableContext): Promise<void>;
+	/**
+	 * Notify that no proxies are available and trigger hooks
+	 * This method is called when proxy selection fails due to pool exhaustion
+	 *
+	 * @param url - The request URL that needed a proxy
+	 * @param error - The error that will be thrown
+	 * @returns The context object with detailed information about the proxy pool state
+	 *
+	 * @example
+	 * ```typescript
+	 * manager.hooks.onNoProxiesAvailable.push((context) => {
+	 *     console.error(`No proxies available for ${context.url}`);
+	 *     console.log(`Dead: ${context.disabledReasons.dead}, Limit: ${context.disabledReasons.limitReached}`);
+	 *     // Trigger external alert or proxy refresh
+	 *     alertSystem.notify('Proxy pool exhausted', context);
+	 * });
+	 *
+	 * // Called internally or by adapters when no proxies are available
+	 * const context = manager.notifyNoProxiesAvailable('https://api.example.com', new Error('No proxies'));
+	 * ```
+	 */
+	notifyNoProxiesAvailable(url: string, error: Error): OnNoProxiesAvailableContext;
 }
-export type queueOptions = Options$1<PriorityQueue, QueueAddOptions>;
+export type queueOptions = QueueConfig;
 export interface CacheConfig {
 	/** Response cache configuration */
 	response?: boolean | ResponseCacheConfig;
@@ -2766,10 +3242,6 @@ export interface RezoDefaultOptions {
 	keepAlive?: boolean;
 	/** Whether to detect and prevent redirect cycles */
 	enableRedirectCycleDetection?: boolean;
-	/** Whether to use HTTP/2 protocol */
-	http2?: boolean;
-	/** Whether to use cURL adapter */
-	curl?: boolean;
 	/** Whether to send cookies and authorization headers with cross-origin requests */
 	withCredentials?: boolean;
 	/** Proxy configuration (URL string or detailed options) */
@@ -2808,8 +3280,6 @@ export interface RezoDefaultOptions {
 	transformRequest?: RezoHttpRequest["transformRequest"];
 	/** Array of functions to transform response data */
 	transformResponse?: RezoHttpRequest["transformResponse"];
-	/** Adapter to use for the request (name or custom function) */
-	adapter?: RezoHttpRequest["adapter"];
 	/** Browser simulation configuration for user agent spoofing */
 	browser?: RezoHttpRequest["browser"];
 	/** Enable debug logging for the request */
@@ -3712,7 +4182,7 @@ export type AdapterFunction<T = any> = (options: RezoRequestConfig, defaultOptio
  * Main Rezo class - Enterprise-grade HTTP client with advanced features
  */
 export declare class Rezo {
-	protected queue: PQueue | null;
+	protected queue: RezoQueue | null;
 	protected isQueueEnabled: boolean;
 	defaults: RezoDefaultOptions;
 	hooks: RezoHooks;
@@ -3868,6 +4338,147 @@ export declare function createRezoInstance(adapter: AdapterFunction, config?: Re
  * Will throw if no global adapter has been set.
  */
 export declare function createDefaultInstance(config?: RezoDefaultOptions): RezoInstance;
+/**
+ * HttpQueue - An HTTP-aware task queue with advanced features
+ *
+ * Features:
+ * - Per-domain concurrency limiting
+ * - Automatic rate limit header parsing (Retry-After, X-RateLimit-*)
+ * - Automatic retry with exponential backoff
+ * - HTTP method-based priority
+ * - Domain pause/resume
+ * - Rate limit event handling
+ *
+ * @example
+ * ```typescript
+ * const queue = new HttpQueue({
+ *   concurrency: 10,
+ *   domainConcurrency: 2,
+ *   respectRetryAfter: true,
+ *   autoRetry: true,
+ *   maxRetries: 3
+ * });
+ *
+ * await queue.add(() => fetch('https://api.example.com/data'), {
+ *   domain: 'api.example.com'
+ * });
+ * ```
+ */
+export declare class HttpQueue extends RezoQueue<any> {
+	private domainQueues;
+	private domainPending;
+	private domainPaused;
+	private domainRateLimited;
+	private domainConcurrencyLimits;
+	private httpStatsData;
+	private httpEventHandlers;
+	readonly httpConfig: Required<HttpQueueConfig>;
+	/**
+	 * Create a new HttpQueue
+	 * @param config - HTTP queue configuration
+	 */
+	constructor(config?: HttpQueueConfig);
+	/**
+	 * Resume queue processing (overrides base to also process HTTP tasks)
+	 */
+	start(): void;
+	/**
+	 * Get HTTP-specific statistics
+	 */
+	get httpStats(): HttpQueueStats;
+	/**
+	 * Add an HTTP task to the queue
+	 * @param fn - Async function to execute
+	 * @param options - HTTP task options
+	 * @returns Promise resolving to task result
+	 */
+	addHttp<R = any>(fn: TaskFunction<R>, options?: HttpTaskOptions): Promise<R>;
+	/**
+	 * Pause requests to specific domain
+	 * @param domain - Domain to pause
+	 */
+	pauseDomain(domain: string): void;
+	/**
+	 * Resume requests to specific domain
+	 * @param domain - Domain to resume
+	 */
+	resumeDomain(domain: string): void;
+	/**
+	 * Set per-domain concurrency limit
+	 * @param domain - Domain to configure
+	 * @param limit - Concurrency limit
+	 */
+	setDomainConcurrency(domain: string, limit: number): void;
+	/**
+	 * Get domain-specific state
+	 * @param domain - Domain to query
+	 */
+	getDomainState(domain: string): DomainState;
+	/**
+	 * Handle rate limit response
+	 * @param domain - Domain that was rate limited
+	 * @param retryAfter - Seconds until retry is allowed
+	 */
+	handleRateLimit(domain: string, retryAfter: number): void;
+	/**
+	 * Cancel an HTTP task by ID
+	 * @param id - Task ID to cancel
+	 * @returns true if task was found and cancelled
+	 */
+	cancelHttp(id: string): boolean;
+	/**
+	 * Register an HTTP event handler
+	 * @param event - Event name
+	 * @param handler - Handler function
+	 */
+	onHttp<E extends keyof HttpQueueEvents>(event: E, handler: EventHandler<HttpQueueEvents[E]>): void;
+	/**
+	 * Remove an HTTP event handler
+	 * @param event - Event name
+	 * @param handler - Handler function to remove
+	 */
+	offHttp<E extends keyof HttpQueueEvents>(event: E, handler: EventHandler<HttpQueueEvents[E]>): void;
+	/**
+	 * Clear all HTTP tasks
+	 */
+	clearHttp(): void;
+	/**
+	 * Destroy the queue and cleanup resources
+	 */
+	destroy(): void;
+	/**
+	 * Insert HTTP task maintaining priority order
+	 */
+	private insertHttpTask;
+	/**
+	 * Get domain concurrency limit
+	 */
+	private getDomainLimit;
+	/**
+	 * Check if domain can accept more tasks
+	 */
+	private canRunDomain;
+	/**
+	 * Try to run next HTTP task
+	 */
+	private tryRunHttpNext;
+	/**
+	 * Execute an HTTP task
+	 */
+	private runHttpTask;
+	/**
+	 * Calculate retry delay for task
+	 */
+	private getRetryDelay;
+	/**
+	 * Ensure domain stats exist
+	 */
+	private ensureDomainStats;
+	/**
+	 * Emit an HTTP event
+	 */
+	private emitHttp;
+}
 export declare const isRezoError: typeof RezoError.isRezoError;
 export declare const Cancel: typeof RezoError;
 export declare const CancelToken: {