/**
 * Slack API Rate Limiter
 *
 * Implements rate limiting and request queuing for Slack Web API calls
 * to prevent hitting API limits and ensure reliable operation.
 *
 * Slack API Limits:
 * - Tier 1: 1+ request per second per workspace
 * - Tier 2: 20+ requests per minute per workspace
 * - Tier 3: 50+ requests per minute per workspace
 * - Tier 4: 100+ requests per minute per workspace
 *
 * Reference: https://api.slack.com/docs/rate-limits
 */
export interface RateLimitConfig {
    /** Maximum requests per minute (default: 50) */
    maxRequestsPerMinute?: number;
    /** Minimum interval between requests in ms (default: 1000ms) */
    minIntervalMs?: number;
    /** Maximum queue size (default: 100) */
    maxQueueSize?: number;
    /** Request timeout in ms (default: 30000ms) */
    requestTimeoutMs?: number;
    /** Enable retry on rate limit errors (default: true) */
    enableRetry?: boolean;
    /** Maximum retry attempts (default: 3) */
    maxRetries?: number;
    /** Base retry delay in ms (default: 2000ms) */
    retryDelayMs?: number;
}
export interface QueuedRequest<T> {
    /** Unique request ID for tracking */
    id: string;
    /** The API call to execute */
    apiCall: () => Promise<T>;
    /** Promise resolve function */
    resolve: (value: T) => void;
    /** Promise reject function */
    reject: (error: Error) => void;
    /** Timestamp when request was queued */
    queuedAt: number;
    /** Number of retry attempts */
    attempts: number;
    /** Request timeout handle */
    timeoutHandle?: NodeJS.Timeout;
    /** Retry delay timeout handle (for pending retry) */
    retryTimeoutHandle?: NodeJS.Timeout;
}
export interface RateLimitStats {
    /** Total requests processed */
    totalRequests: number;
    /** Requests currently queued */
    queuedRequests: number;
    /** Rate limit hits */
    rateLimitHits: number;
    /** Failed requests */
    failedRequests: number;
    /** Average response time in ms */
    averageResponseTime: number;
    /** Last request timestamp */
    lastRequestTime: number;
}
/**
 * Slack API Rate Limiter with request queuing and retry logic
 */
export declare class SlackRateLimiter {
    private config;
    private logger;
    /** Queue of pending requests */
    private requestQueue;
    /** Whether the limiter is currently processing requests */
    private processing;
    /** Timestamps of recent requests for rate tracking */
    private requestHistory;
    /** Last API call timestamp */
    private lastRequestTime;
    /** Statistics tracking */
    private stats;
    /** Response time tracking for averages */
    private responseTimes;
    constructor(config?: RateLimitConfig);
    /**
     * Queue an API request for rate-limited execution
     */
    queueRequest<T>(apiCall: () => Promise<T>): Promise<T>;
    /**
     * Start processing the request queue
     */
    private startProcessing;
    /**
     * Process a single request with rate limiting
     */
    private processRequest;
    /**
     * Wait if necessary to respect rate limits
     */
    private waitForRateLimit;
    /**
     * Check if an error is a rate limit error with strict type validation
     */
    private isRateLimitError;
    /**
     * Calculate retry delay with exponential backoff
     */
    private calculateRetryDelay;
    /**
     * Update statistics tracking
     */
    private updateStats;
    /**
     * Remove a request from the queue by ID
     */
    private removeFromQueue;
    /**
     * Generate a unique request ID
     */
    private generateRequestId;
    /**
     * Sleep for the specified number of milliseconds
     */
    private sleep;
    /**
     * Get current rate limiter statistics
     */
    getStats(): RateLimitStats;
    /**
     * Clear the request queue and reset statistics
     */
    reset(): void;
    /**
     * Get current queue size
     */
    getQueueSize(): number;
    /**
     * Check if the limiter is currently processing requests
     */
    isProcessing(): boolean;
}
//# sourceMappingURL=slack-rate-limiter.d.ts.map