import amqp, { Options } from "amqplib";
import amqpManager from "amqp-connection-manager";
import { EBindKey, EExchangeNames, EExchangeTypes, IMessageEvent, TAckMessageCallback, TBackoffAttemptArray, TConsumerErrorCallback, TPublishErrorCallback } from "./interfaces.js";
import { EMicroServiceNames } from "../micro-services/index.js";
import { TVersionConflictCheck } from "../errors/index.js";
import { TLoggingFunc } from "../logging/index.js";
export declare abstract class AbstractConsumer<T extends IMessageEvent> {
    protected _channel: amqp.Channel | null;
    private readonly _exchangeName;
    private readonly _exchangeType;
    private readonly _bindKey;
    private _queueName;
    private _serviceName;
    private _maxErrorAttempts;
    private _maxVersionRetryAttempts;
    private _isSetup;
    protected constructor(messageEvent: T);
    protected get exchangeName(): EExchangeNames;
    protected get exchangeType(): EExchangeTypes;
    protected get queueName(): string;
    protected get bindKey(): EBindKey;
    get setup(): boolean;
    private _classGetTTLErrorExchangeName;
    private _classGetTTLVersionExchangeName;
    private _classGetTTLErrorQueueName;
    private _classGetVersionTTLQueueName;
    private _classGetDeadletterErrorTTLExchangeName;
    private _classGetVersionDeadletterTTLExchangeName;
    private _classErrorBindKey;
    private _classVersionBindKey;
    callSetup(channel: amqp.Channel, serviceName: EMicroServiceNames, queueOptions: Options.AssertQueue, exchangeOptions: Options.AssertExchange, backoffOptions: TBackoffAttemptArray, shared: boolean, maxVersionRetry: number, queueName: string): Promise<void>;
    callStart(concurrency: number, consumerOptions: Options.Consume, logger: TLoggingFunc): Promise<void>;
    private _classHandleErrorMessageRetry;
    private _classHandleVersionRetry;
    protected abstract protectOnMessage(data: T["data"], message: amqp.ConsumeMessage): void;
    protected protectHandleError(data: T["data"], message: amqp.ConsumeMessage, errorCallBack: TConsumerErrorCallback, runtimeLogger: TLoggingFunc, versionRetry: TVersionConflictCheck): Promise<void>;
    protected protectAckMessage(message: amqp.ConsumeMessage): void;
    protected protectAckMessageCallback(message: amqp.ConsumeMessage): TAckMessageCallback;
}
export declare abstract class AbstractPublisher<T extends IMessageEvent> {
    private readonly _exchangeName;
    private readonly _exchangeType;
    private readonly _bindKey;
    private _isSetup;
    private _isStarted;
    protected _managedChannel: amqpManager.ChannelWrapper | null;
    protected constructor(messageEvent: T);
    get exchangeName(): EExchangeNames;
    get exchangeType(): EExchangeTypes;
    get setup(): boolean;
    get started(): boolean;
    get bindKey(): EBindKey;
    callStart(managedChannel: amqpManager.ChannelWrapper): AbstractPublisher<T>;
    callSetup(channel: amqp.Channel, exchangeOptions: Options.AssertExchange): Promise<void>;
    protected protectPublish(managedChannel: amqpManager.ChannelWrapper | null, data: T["data"], errorLogger: TPublishErrorCallback, publishOptions: Options.Publish): Promise<void>;
}
//# sourceMappingURL=events.d.ts.map