/**
 * Browserless Rate Limiter
 *
 * Manages rate limiting, connection pooling, and unit tracking for Browserless.io API.
 *
 * Free Plan Limits (as of 2025):
 * - 1,000 units/month (1 unit = 30 seconds of browser time)
 * - 1 max concurrent browser
 * - 1 minute max session time
 *
 * @see https://www.browserless.io/pricing
 * @see https://docs.browserless.io/baas/troubleshooting/timeouts
 */
export interface BrowserlessPlanLimits {
    /** Maximum concurrent browser sessions */
    maxConcurrent: number;
    /** Maximum session duration in milliseconds */
    maxSessionDuration: number;
    /** Monthly unit quota */
    monthlyUnits: number;
    /** Queue size (requests waiting for a slot) */
    queueSize: number;
    /** Connection timeout in milliseconds */
    connectionTimeout: number;
}
export interface BrowserlessUsageStats {
    /** Units consumed this month */
    unitsUsed: number;
    /** Units remaining this month */
    unitsRemaining: number;
    /** Current active connections */
    activeConnections: number;
    /** Requests currently queued */
    queuedRequests: number;
    /** Total requests processed */
    totalRequests: number;
    /** Requests that timed out */
    timedOutRequests: number;
    /** Requests rejected due to quota */
    rejectedRequests: number;
    /** Month reset date */
    quotaResetDate: Date;
}
/** Plan configurations */
export declare const BROWSERLESS_PLANS: Record<string, BrowserlessPlanLimits>;
export declare class BrowserlessRateLimiter {
    private limits;
    private activeConnections;
    private requestQueue;
    private unitsUsed;
    private totalRequests;
    private timedOutRequests;
    private rejectedRequests;
    private quotaResetDate;
    private activeSessions;
    constructor(plan?: keyof typeof BROWSERLESS_PLANS);
    /**
     * Get the next month reset date (1st of next month)
     */
    private getNextMonthReset;
    /**
     * Check if quota has reset and update if needed
     */
    private checkQuotaReset;
    /**
     * Calculate units for a session duration
     * 1 unit = 30 seconds of browser time
     */
    calculateUnits(durationMs: number): number;
    /**
     * Check if we have enough units remaining
     */
    hasUnitsAvailable(estimatedUnits?: number): boolean;
    /**
     * Acquire a connection slot
     * Returns a release function to call when done
     */
    acquire(sessionId: string): Promise<() => void>;
    /**
     * Create a new session and return release function
     */
    private createSession;
    /**
     * Release a session and process queue
     */
    private releaseSession;
    /**
     * Wait in queue for a connection slot
     */
    private waitInQueue;
    /**
     * Process the next request in queue
     */
    private processQueue;
    /**
     * Get current usage statistics
     */
    getStats(): BrowserlessUsageStats;
    /**
     * Get plan limits
     */
    getLimits(): BrowserlessPlanLimits;
    /**
     * Update plan (e.g., after upgrade)
     */
    setPlan(plan: keyof typeof BROWSERLESS_PLANS): void;
    /**
     * Check if request should be retried based on error
     */
    shouldRetry(error: Error, attempt: number, maxAttempts?: number): boolean;
    /**
     * Calculate retry delay with exponential backoff
     */
    getRetryDelay(attempt: number): number;
    /**
     * Clean up all sessions (call on shutdown)
     */
    cleanup(): void;
}
export declare class BrowserlessQuotaExceededError extends Error {
    constructor(message: string);
}
export declare class BrowserlessQueueFullError extends Error {
    constructor(message: string);
}
export declare class BrowserlessTimeoutError extends Error {
    constructor(message: string);
}
/**
 * Get the default rate limiter instance
 */
export declare function getDefaultRateLimiter(): BrowserlessRateLimiter;
/**
 * Reset the default rate limiter (useful for testing)
 */
export declare function resetDefaultRateLimiter(): void;
//# sourceMappingURL=browserless-rate-limiter.d.ts.map