import * as amqp from 'amqplib';
import { RpcOptions, RpcRequest } from '../utils/rpc-request';
import { IRpcResponse, RpcResponse } from '../utils/rpc-response';
import { AmqpChannelPoolService } from './amqp-channel-pool-service';
export { IRpcResponse, RpcRequest, RpcResponse };
export declare type RpcType = 'rpc' | 'endpoint';
export interface IConsumerInfo {
    channel: amqp.Channel;
    tag: string;
    options?: RpcOptions;
    key: string;
    consumer: (msg: any) => Promise<void>;
    consumerOpts?: any;
}
export declare type RpcHook = (rpc: any) => Promise<any>;
export declare enum RpcHookType {
    PRE_ENDPOINT = 0,
    POST_ENDPOINT = 1,
    PRE_RPC = 2,
    POST_RPC = 3,
    PRE_ENDPOINT_ERROR = 4,
    POST_ENDPOINT_ERROR = 5,
    PRE_RPC_ERROR = 6,
    POST_RPC_ERROR = 7
}
export interface RpcEntities {
    [rpcName: string]: {
        handler: (req: any) => Promise<any>;
        type: RpcType;
        rpcOptions?: RpcOptions;
    };
}
export interface InitializeOptions {
    useReviver?: boolean;
    consumerAmqpChannelPool?: AmqpChannelPoolService;
}
export declare class RPCService {
    private requestConsumerInfo;
    private responseQueueName;
    private waitingResponse;
    private timedOut;
    private timedOutOrdered;
    private channelPool;
    private consumerChannelPool;
    private serviceName;
    private hooks;
    private purging;
    private rpcEntities;
    private queuesAvailableSince;
    constructor(serviceName?: string);
    initialize(channelPool: AmqpChannelPoolService, opts?: InitializeOptions): Promise<any>;
    _publish(exchange: any, routingKey: any, content: any, options?: any): Promise<boolean>;
    purge(): Promise<void>;
    sigInfo(): Promise<void>;
    registerHook(type: RpcHookType, hook: RpcHook): void;
    register(rpcName: string, handler: (req: any) => Promise<any>, type: RpcType, rpcOptions?: RpcOptions): Promise<void>;
    listen(): Promise<void>;
    pause(name: string): Promise<void>;
    pauseAll(): Promise<void>;
    resume(name: string): Promise<void>;
    resumeAll(): Promise<void>;
    unregister(name: string): Promise<void>;
    unregisterAll(): Promise<void>;
    invoke<T, U>(name: string, msg: T, opts?: {
        withRawdata?: boolean;
        timeout?: number;
        noUseCLS?: boolean;
    }): Promise<U>;
    protected _consume(key: string, handler: (msg: any) => Promise<any>, noAck?: boolean): Promise<IConsumerInfo>;
    private isGuaranteedExecTime;
    private throwTimeout;
    private makeTimeoutError;
    private shutdown;
    private makeRoutingKey;
    private makeResponseQueueName;
    private consumeForResponse;
    private onSystemDiagnosis;
    private dispatchDiagnosis;
    private onDiagnosisRpc;
    private waitResponse;
    private makeInvokeOption;
    private makeInvokeHeader;
    private earlyThrowWith503;
    private is503;
    private isCritical;
    private logRpcError;
    private attachExtraError;
    private reply;
    private makeReplyHeader;
    private enterScope;
    private dohook;
    private assertQueues;
    private assertExchanges;
    private bindQueuesToExchanges;
    private startConsumingQueues;
    private determineFlowControl;
    private startConsumingQueue;
    private assertMessage;
}