import type { Context, SQSBatchResponse, SQSEvent } from 'aws-lambda';
import Transaction, { TransactionConfig } from './Transaction.js';
import Response, { ResponseErrorType } from '../API/Response.js';
/**
 * Type definition for an event processor execution function.
 * @param {Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse>} transaction - The transaction object.
 * @param {string | object} recordContent - The content of the record being processed.
 * @returns {Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse>} - A promise that resolves to the response or batch response.
 */
export type EventProcessorExecution<ResponseInnerType> = (transaction: Transaction<null, ResponseInnerType | ResponseErrorType, SQSBatchResponse | null>, recordContent: string | object) => Promise<Response<ResponseInnerType | ResponseErrorType> | SQSBatchResponse | null>;
/**
 * EventProcessor class that processes events from an SQS queue.
 * @template ResponseInnerType - The type of the inner response object.
 */
export default class EventProcessor<ResponseInnerType> {
    /**
     * A boolean flag indicating whether failures are allowed or not.
     * @readonly
     */
    private readonly allowFailure;
    /**
     * The configuration object for the API transaction.
     */
    private readonly config;
    /**
     * The private readonly context property of the class.
     * @type {Context}
     */
    private readonly context;
    /**
     * The SQS event object that triggered the Lambda function.
     */
    private readonly event;
    /**
     * Constructs a new instance of the class.
     * @param {SQSEvent} event - The event object representing the incoming SQS message.
     * @param {Context} context - The context object representing the AWS Lambda execution context.
     * @param {TransactionConfig} [config] - Optional configuration object for the transaction.
     * @param {boolean} [allowFailure] - Optional flag indicating whether to allow failure for the transaction.
     * @returns None
     */
    constructor(event: SQSEvent, context: Context, config?: TransactionConfig, allowFailure?: boolean);
    /**
     * Processes an event using the provided execution object and returns a response.
     * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution object containing the event to process.
     * @param {boolean} [doNotDecodeMessage] - Optional flag indicating whether to decode the message.
     * @returns {Promise<Response<ResponseErrorType> | null | SQSBatchResponse>} - A promise that resolves to the response object, or null if no response is available.
     * @throws {Error} - Throws an error if the response code is not within the range of 200 to 299 and failure is not allowed.
     */
    processEvent(execution: EventProcessorExecution<ResponseInnerType>, doNotDecodeMessage?: boolean): Promise<Response<ResponseErrorType | null> | null | SQSBatchResponse>;
    /**
     * Processes a raw event by executing the provided execution function and handling any errors or failures.
     * @param {EventProcessorExecution<ResponseInnerType>} execution - The execution function to process the event.
     * @param {boolean} doNotDecodeMessage - Flag indicating whether to decode the message or not.
     * @returns {Promise<Response<ResponseErrorType> | null | SQSBatchResponse>} - A promise that resolves to a response object, null, or a SQS batch response.
     */
    private processRawEvent;
}