/// <reference types="node" />
import { Options } from "amqplib";
import { RabbitMQConfiguration } from "../configuration";
export declare type AMQPExchangeType = "direct" | "topic" | "fanout";
export declare type AMQPConsumeFunc<T> = (message: Readonly<T>, ...args: any[]) => void;
export declare type AMQPProducer = Readonly<{
    exchange: string;
    type: AMQPExchangeType;
    publishOptions: Options.Publish;
}>;
export declare type AMQPConsumer<T> = Readonly<{
    exchange?: string;
    type?: AMQPExchangeType;
    bindingKey?: string;
    queue?: string;
    queueOptions: Options.AssertQueue;
    consumeFunc: AMQPConsumeFunc<T>;
    consumeFuncArgs?: any[];
    consumeOptions: Options.Consume;
}>;
export declare type ReturnListener = (exchange: string, routingKey: string, message: Buffer) => void;
export declare class AMQPBus<T = any> {
    private readonly appID;
    private readonly connectOptions;
    private readonly producer?;
    private readonly consumer?;
    private readonly heartbeatTimeout;
    readonly ready: Promise<void>;
    private connection;
    private channel;
    private readonly connectionName;
    private readonly pending;
    private state;
    private reconnectTimerID;
    private heartbeatTimerID;
    private returnListener;
    /**
     * @desc 构造函数
     * @param appID             应用ID
     * @param connectOptions    RabbitMQ连接参数
     * @param producer          生成者
     * @param consumer          消费者
     * @param heartbeatTimeout  应用层心跳超时, 单位: ms
     */
    constructor(appID: string, connectOptions: RabbitMQConfiguration, producer?: Readonly<{
        exchange: string;
        type: AMQPExchangeType;
        publishOptions: Options.Publish;
    }> | undefined, consumer?: Readonly<{
        exchange?: string | undefined;
        type?: AMQPExchangeType | undefined;
        bindingKey?: string | undefined;
        queue?: string | undefined;
        queueOptions: Options.AssertQueue;
        consumeFunc: AMQPConsumeFunc<T>;
        consumeFuncArgs?: any[] | undefined;
        consumeOptions: Options.Consume;
    }> | undefined, heartbeatTimeout?: number);
    setReturnListener: (l: ReturnListener) => this;
    protected isHeartbeat(message: Readonly<T>): boolean;
    private connect;
    /**
     * @desc 生产者
     * @param messages
     * @param routingKey
     */
    produce: (messages: string | ReadonlyArray<string>, routingKey: string) => boolean;
    /**
     * @desc 正常关闭, 如进程退出前包括收到SIGINT
     */
    close: () => Promise<void>;
    /**
     * @desc 应用层心跳超时, 如FreeSwitch HEARTBEAT事件
     */
    private closeByHeartbeatTimeout;
    private enterNormalDisconnected;
    private enterAbnormalDisconnecting;
    private enterAbnormalDisConnected;
    /**
     * @desc 初始化交换机
     * @param exchange 交换机名, 一般总是预先配置的Exchange
     * @param type     交换机主题类型
     * @returns        交换机名
     */
    private initExchange;
    /**
     * @desc 初始化消费队列
     * @returns
     */
    private initQueue;
    private onDrain;
    /**
     * @desc 应用层在连接成功和收到心跳时调用
     */
    protected resetHeartbeatTimer: () => void;
    private startHeartbeatTimer;
    private stopHeartbeatTimer;
    private startReconnectTimer;
    private stopReconnectTimer;
    private stopTimers;
    private isDisconnected;
    private isDisconnect;
    private isNormalDisconnect;
    private isAbnormalDisconnect;
    private URI;
}