/// <reference types="node" />
import { EventEmitter } from 'events';
import { ConsumerOptions } from '../interfaces/config';
import { BatchMiddleware, MessageMiddleware } from '../types/middleware';
/**
 * QueueConsumer class for processing AWS SQS queue messages
 * Provides both individual message processing and batch processing capabilities
 * Supports middleware, retry logic, dead letter queues, and performance metrics
 */
export default class QueueConsumer extends EventEmitter {
    private readonly _client;
    private readonly _url;
    private readonly _handler;
    private readonly _batchHandler;
    private _isShuttingDown;
    private _isRunning;
    private _stoppedFunction;
    private readonly _retryOptions;
    private readonly _dlqOptions;
    private readonly _metricsOptions;
    private readonly _batchOptions;
    private readonly _middlewareOptions;
    private readonly _awsConfig;
    private _messageMiddleware;
    private _batchMiddleware;
    private _startTime;
    private _messagesProcessed;
    private _messagesFailed;
    private _messagesSentToDlq;
    private _totalRetries;
    private _totalProcessingTime;
    private _messagesFiltered;
    private static readonly DEFAULT_RETRY_OPTIONS;
    private static readonly DEFAULT_DLQ_OPTIONS;
    private static readonly DEFAULT_METRICS_OPTIONS;
    private static readonly DEFAULT_BATCH_OPTIONS;
    private static readonly DEFAULT_MIDDLEWARE_OPTIONS;
    private static readonly DEFAULT_AWS_CONFIG;
    /**
     * Creates a new QueueConsumer instance
     * @param options Configuration options for the consumer
     */
    constructor(options: ConsumerOptions);
    /**
     * Starts the queue consumer
     * @returns This instance for chaining
     */
    run(): Promise<void>;
    /**
     * Stops the queue consumer gracefully
     * @returns Promise that resolves when consumer has fully stopped
     */
    stop(): void;
    /**
     * Returns the number of available messages in the queue
     * @returns Promise resolving to the number of available messages
     */
    getAvailableQueueNumber(): Promise<number>;
    /**
     * Sets a function to be called when the consumer stops
     * @param stopFunction Function to execute when consumer stops
     */
    setStoppedFunction(stopFunction: () => Promise<void>): void;
    /**
     * Registers a message middleware function
     * @param middleware The middleware function to register
     * @returns This instance for chaining
     */
    use(middleware: MessageMiddleware): QueueConsumer;
    /**
     * Registers a batch middleware function
     * @param middleware The middleware function to register
     * @returns This instance for chaining
     */
    useBatch(middleware: BatchMiddleware): QueueConsumer;
    get isRunning(): boolean;
    /**
     * Extract region from queue URL
     * @param queueUrl The SQS queue URL
     * @returns The AWS region extracted from the URL
     */
    private getRegionFromQueueUrl;
    /**
     * Process received messages
     * @param messages Array of SQS messages to process
     */
    private processMessages;
    /**
     * Get consumer metrics
     * @returns Object containing current consumer metrics
     */
    private getMetrics;
    /**
     * Process a group of messages
     * @param groupId Group ID for the messages
     * @param messages Array of SQS messages to process
     */
    private processMessageGroup;
    /**
     * Process an individual message
     * @param message SQS message to process
     * @param groupId Group ID for the message
     */
    private processIndividualMessage;
    /**
     * Execute batch middleware pipeline
     * @param context Batch middleware context
     */
    private executeBatchMiddlewarePipeline;
    /**
     * Execute message middleware pipeline
     * @param context Message middleware context
     */
    private executeMessageMiddlewarePipeline;
    /**
     * Send a failed message to the Dead Letter Queue
     * @param message Failed SQS message
     * @param error Error that caused the failure
     * @param retryCount Number of retries attempted
     */
    private sendToDeadLetterQueue;
    /**
     * Calculate retry backoff delay using exponential backoff
     * @param retryCount Current retry attempt number
     * @returns Delay in milliseconds before next retry
     */
    private calculateBackoffDelay;
    /**
     * Extend visibility timeout for a message
     * @param message SQS message
     * @param visibilityTimeout New visibility timeout in seconds
     */
    private extendMessageVisibility;
    /**
     * Sleep for a specified duration
     * @param ms Time to sleep in milliseconds
     */
    private sleep;
    /**
     * Main polling loop for retrieving messages from the queue
     */
    private pollMessages;
    /**
     * Parses an SQS message into a more usable format
     * @param message Raw SQS message
     * @param groupId Group ID for the message
     * @returns Parsed message or null if parsing failed
     */
    private parseMessage;
    /**
     * Deletes a batch of messages in a single SQS request
     * @param messages Array of SQS messages to delete
     * @returns Object containing arrays of successful and failed message IDs
     */
    private deleteMessageBatch;
    /**
     * Process a batch of messages using the batch handler
     * @param groupId Group ID for the batch
     * @param messages Array of SQS messages to process as a batch
     */
    private processBatchWithBatchHandler;
}