@types/amqplib

connection: Connection;

ack: (message: Message, allUpTo?: boolean) => void;

ackAll: () => void;

assertExchange: (
    exchange: string,
    type: 'direct' | 'topic' | 'headers' | 'fanout' | 'match' | string,
    options?: Options.AssertExchange
) => Promise<Replies.AssertExchange>;

assertQueue: (
    queue: string,
    options?: Options.AssertQueue
) => Promise<Replies.AssertQueue>;

bindExchange: (
    destination: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

bindQueue: (
    queue: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

cancel: (consumerTag: string) => Promise<Replies.Empty>;

checkExchange: (exchange: string) => Promise<Replies.Empty>;

checkQueue: (queue: string) => Promise<Replies.AssertQueue>;

close: () => Promise<void>;

consume: (
    queue: string,
    onMessage: (msg: ConsumeMessage | null) => void,
    options?: Options.Consume
) => Promise<Replies.Consume>;

deleteExchange: (
    exchange: string,
    options?: Options.DeleteExchange
) => Promise<Replies.Empty>;

deleteQueue: (
    queue: string,
    options?: Options.DeleteQueue
) => Promise<Replies.DeleteQueue>;

get: (queue: string, options?: Options.Get) => Promise<GetMessage | false>;

nack: (message: Message, allUpTo?: boolean, requeue?: boolean) => void;

nackAll: (requeue?: boolean) => void;

prefetch: (count: number, global?: boolean) => Promise<Replies.Empty>;

publish: (
    exchange: string,
    routingKey: string,
    content: Buffer,
    options?: Options.Publish
) => boolean;

purgeQueue: (queue: string) => Promise<Replies.PurgeQueue>;

recover: () => Promise<Replies.Empty>;

reject: (message: Message, requeue?: boolean) => void;

sendToQueue: (
    queue: string,
    content: Buffer,
    options?: Options.Publish
) => boolean;

unbindExchange: (
    destination: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

unbindQueue: (
    queue: string,
    source: string,
    pattern: string,
    args?: any
) => Promise<Replies.Empty>;

deliveryTag: number;

exchange: string;

redelivered: boolean;

routingKey: string;

publish: (
    exchange: string,
    routingKey: string,
    content: Buffer,
    options?: Options.Publish,
    callback?: (err: any, ok: Replies.Empty) => void
) => boolean;

sendToQueue: (
    queue: string,
    content: Buffer,
    options?: Options.Publish,
    callback?: (err: any, ok: Replies.Empty) => void
) => boolean;

waitForConfirms: () => Promise<void>;

connection: {
    serverProperties: ServerProperties;
};

close: () => Promise<void>;

createChannel: () => Promise<Channel>;

createConfirmChannel: () => Promise<ConfirmChannel>;

fields: ConsumeMessageFields;

consumerTag: string;

fields: GetMessageFields;

messageCount: number;

content: Buffer;

fields: MessageFields;

properties: MessageProperties;

consumerTag?: string | undefined;

messageCount?: number | undefined;

appId: any | undefined;

clusterId: any | undefined;

contentEncoding: any | undefined;

contentType: any | undefined;

correlationId: any | undefined;

deliveryMode: any | undefined;

expiration: any | undefined;

headers: MessagePropertyHeaders | undefined;

messageId: any | undefined;

priority: any | undefined;

replyTo: any | undefined;

timestamp: any | undefined;

type: any | undefined;

userId: any | undefined;

'x-death'?: XDeath[] | undefined;

'x-first-death-exchange'?: string | undefined;

'x-first-death-queue'?: string | undefined;

'x-first-death-reason'?: string | undefined;

[key: string]: any;

copyright?: string | undefined;

host: string;

information: string;

platform: string;

product: string;

version: string;

[key: string]: string | undefined;

'original-expiration'?: any;

'routing-keys': string[];

count: number;

exchange: string;

queue: string;

reason: 'rejected' | 'expired' | 'maxlen';

time: {
    '!': 'timestamp';
    value: number;
};