/**
 * Queue provider types and interfaces
 *
 * Supports both in-memory (@vvlad1973/queues-manager) and distributed (RabbitMQ) implementations
 *
 * @module types/queue
 */
/**
 * Queue provider type
 */
export declare enum QueueProviderType {
    /** In-memory queue using @vvlad1973/queues-manager */
    InMemory = "in-memory",
    /** Distributed queue using RabbitMQ */
    RabbitMQ = "rabbitmq"
}
/**
 * Options for enqueuing a task
 */
export interface EnqueueOptions {
    /** Task priority (0-10, higher is more important) */
    priority?: number;
    /** Delay before execution in milliseconds */
    delay?: number;
    /** Task timeout in milliseconds */
    timeout?: number;
    /** Number of retry attempts */
    retries?: number;
    /** Custom metadata for the task */
    metadata?: Record<string, unknown>;
}
/**
 * Queue statistics
 */
export interface QueueStats {
    /** Number of tasks waiting in queue */
    pending: number;
    /** Number of tasks currently being processed */
    active: number;
    /** Number of completed tasks */
    completed: number;
    /** Number of failed tasks */
    failed: number;
    /** Tasks processed per second */
    throughput: number;
}
/**
 * Serializable task data
 * Used for distributed queues where functions cannot be serialized
 */
export interface SerializableTask {
    /** Task type identifier (must be registered in task registry) */
    type: string;
    /** Task payload data */
    payload: unknown;
}
/**
 * Task handler function
 * Processes tasks from the queue
 */
export type TaskHandler = (task: SerializableTask) => Promise<unknown>;
/**
 * Abstract queue provider interface
 * Supports both in-memory and distributed queue implementations
 */
export interface IQueueProvider {
    /**
     * Enqueue a task for execution
     * @param queueName - Queue identifier (e.g., botId, routeId)
     * @param task - Function to execute or serializable task data
     * @param options - Queue-specific options
     * @returns Promise that resolves with task result
     */
    enqueue<T>(queueName: string, task: (() => Promise<T>) | SerializableTask, options?: EnqueueOptions): Promise<T>;
    /**
     * Get queue statistics
     * @param queueName - Queue identifier
     * @returns Queue statistics
     */
    getStats(queueName: string): Promise<QueueStats>;
    /**
     * Close all connections and cleanup resources
     */
    close(): Promise<void>;
}
import type { LoggerOptions } from './logger.types.js';
/**
 * Configuration for in-memory queue provider
 */
export interface InMemoryQueueConfig extends LoggerOptions {
    /** Global rate limit (requests per second across all queues) */
    globalLimit?: number;
    /** Per-queue rate limit (requests per second per queue) */
    queueLimit?: number;
    /** Queue concurrency (parallel tasks per queue) */
    concurrency?: number;
    /** Enable debug logging */
    debug?: boolean;
}
/**
 * Configuration for RabbitMQ queue provider
 */
export interface RabbitMQQueueConfig {
    /** RabbitMQ connection URL */
    url: string;
    /** Main exchange name */
    exchange?: string;
    /** Consumer prefetch count for rate limiting */
    prefetch?: number;
    /** Maximum retry attempts */
    maxRetries?: number;
    /** Delay between retries in milliseconds */
    retryDelay?: number;
    /** Connection heartbeat in seconds */
    heartbeat?: number;
    /** Dead letter queue configuration */
    dlq?: {
        /** Enable dead letter queue */
        enabled: boolean;
        /** Message TTL in dead letter queue (milliseconds) */
        ttl: number;
    };
    /** Rate limiting via RabbitMQ plugins */
    rateLimit?: {
        /** Enable rate limiting */
        enabled: boolean;
        /** Maximum requests per second */
        maxPerSecond: number;
        /** Maximum requests per minute */
        maxPerMinute: number;
    };
}
/**
 * Combined queue provider configuration
 */
export type QueueProviderConfig = InMemoryQueueConfig | RabbitMQQueueConfig;