import * as amqplib from 'amqplib';
declare class Rabbitr {
    opts: Rabbitr.IOptions;
    /** @deprecated */
    protected ready: boolean;
    /** @deprecated */
    protected connected: boolean;
    protected connection: amqplib.Connection;
    protected log: any;
    private _openChannels;
    private _timerChannel;
    private _backoffChannel;
    private _publishChannel;
    private _rpcReturnChannel;
    _cachedChannel: amqplib.Channel;
    private connectionPromise;
    private isShuttingDown;
    private pendingMessagesCount;
    private shutdown;
    private postMessage;
    /**
     * An array of channel names used for debug mode. If this value is set, calls to
     *   #subscribe on channels not in this list will be ignored.
     *
     * This option is set from the environment variable `RABBITR_DEBUG`.
     */
    private debugChannelsWhitelist;
    constructor(opts: Rabbitr.IOptions);
    private initiateConnection;
    /** method to destroy anything for this instance of rabbitr */
    destroy(): Promise<void>;
    send(topic: string, data: any, opts?: Rabbitr.ISendOptions): Promise<void>;
    send<TInput>(topic: string, data: TInput, opts?: Rabbitr.ISendOptions): Promise<void>;
    subscribe(exchangeNames: string[], queueName: string, opts: Rabbitr.ISubscribeOptions, executorFunc: (data: Rabbitr.IMessage<any>) => void): Promise<amqplib.Channel>;
    subscribe<TMessage>(exchangeNames: string[], queueName: string, opts: Rabbitr.ISubscribeOptions, executorFunc: (data: Rabbitr.IMessage<TMessage>) => void): Promise<amqplib.Channel>;
    private _bindExchangeToQueue;
    private _timerQueueName;
    setTimer<TData>(topic: string, uniqueID: string, data: TData, ttl: number): Promise<void>;
    clearTimer(topic: string, uniqueID: string): Promise<void>;
    private _rpcQueueName;
    private _createTempQueue;
    rpcExec(topic: string, data: any, opts?: Rabbitr.IRpcExecOptions): Promise<any>;
    rpcExec<TInput, TOutput>(topic: string, data: TInput, opts?: Rabbitr.IRpcExecOptions): Promise<TOutput>;
    rpcListener(topic: string, opts: Rabbitr.IRpcListenerOptions<any, any>, executor: Rabbitr.IRpcListenerExecutor<any, any>): Promise<void>;
    rpcListener<TInput, TOutput>(topic: string, opts: Rabbitr.IRpcListenerOptions<TInput, TOutput>, executor: Rabbitr.IRpcListenerExecutor<TInput, TOutput>): Promise<void>;
}
declare module Rabbitr {
    /** you MUST provide a 'url' rather than separate 'host', 'password', 'vhost' now */
    interface IOptions {
        url: string;
        log?: (...args: string[]) => void;
        connectionOpts?: {
            heartbeat?: boolean;
        };
        defaultRPCExpiry?: number;
    }
    interface ErrorCallback {
        (err: Error): void;
    }
    interface Callback<T> {
        (err: Error): void;
        (err: Error, data: T): void;
    }
    interface IRpcExecOptions {
        timeout?: number;
        context?: any;
    }
    interface IRpcListenerOptions<TInput, TOutput> {
        prefetch?: number;
    }
    type IRpcListenerExecutor<TInput, TOutput> = ((message: IMessage<TInput>) => PromiseLike<TOutput>) | ((message: IMessage<TInput>, respond: Callback<TOutput>) => void);
    interface ISubscribeOptions {
        prefetch?: number;
        skipBackoff?: boolean;
        durable?: boolean;
    }
    interface ISendOptions {
    }
    interface IMessage<TData> {
        ack(): void;
        reject(error?: Error): void;
        topic: string;
        channel: amqplib.Channel;
        data: TData;
        properties?: any;
        send(topic: string, data: any, cb?: Rabbitr.ErrorCallback, opts?: Rabbitr.ISendOptions): Promise<void>;
        send<TInput>(topic: string, data: TInput, cb?: Rabbitr.ErrorCallback, opts?: Rabbitr.ISendOptions): Promise<void>;
        rpcExec(topic: string, data: any, cb?: Rabbitr.Callback<any>): Promise<any>;
        rpcExec(topic: string, data: any, opts: Rabbitr.IRpcExecOptions, cb?: Rabbitr.Callback<any>): Promise<any>;
        rpcExec<TInput, TOutput>(topic: string, data: TInput, cb?: Rabbitr.Callback<TOutput>): Promise<TOutput>;
        rpcExec<TInput, TOutput>(topic: string, data: TInput, opts: Rabbitr.IRpcExecOptions, cb?: Rabbitr.Callback<TOutput>): Promise<TOutput>;
        queue?: {
            shift: () => void;
        };
    }
    interface IMessageWithContext<TData> extends IMessage<TData> {
        context?: string;
    }
    interface IEnvelopedMessage<TData> extends IMessage<any> {
        data: {
            d: TData;
            expiration: number;
            returnQueue: string;
            context?: any;
        };
    }
}
export = Rabbitr;