callback_api.d.ts

import events = require("events");
import shared = require("./properties")

export import Replies = shared.Replies;
export import Options = shared.Options;
export import Message = shared.Message;

export interface Connection extends events.EventEmitter {
    close(callback?: (err: any) => void): void;
    createChannel(callback: (err: any, channel: Channel) => void): void;
    createConfirmChannel(callback: (err: any, confirmChannel: ConfirmChannel) => void): void;
}

export interface Channel extends events.EventEmitter {
    close(callback: (err: any) => void): void;

    assertQueue(queue?: string, options?: Options.AssertQueue, callback?: (err: any, ok: Replies.AssertQueue) => void): void;
    checkQueue(queue: string, callback?: (err: any, ok: Replies.AssertQueue) => void): void;

    deleteQueue(queue: string, options?: Options.DeleteQueue, callback?: (err: any, ok: Replies.DeleteQueue) => void): void;
    purgeQueue(queue: string, callback?: (err: any, ok: Replies.PurgeQueue) => void): void;

    bindQueue(queue: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;
    unbindQueue(queue: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;

    assertExchange(exchange: string, type: string, options?: Options.AssertExchange, callback?: (err: any, ok: Replies.AssertExchange) => void): void;
    checkExchange(exchange: string, callback?: (err: any, ok: Replies.Empty) => void): void;

    deleteExchange(exchange: string, options?: Options.DeleteExchange, callback?: (err: any, ok: Replies.Empty) => void): void;

    bindExchange(destination: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;
    unbindExchange(destination: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;

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

    consume(queue: string, onMessage: (msg: Message) => any, options?: Options.Consume, callback?: (err: any, ok: Replies.Consume) => void): void;

    cancel(consumerTag: string, callback?: (err: any, ok: Replies.Empty) => void): void;
    get(queue: string, options?: Options.Get, callback?: (err: any, ok: Message | boolean) => void): void;

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

    nack(message: Message, allUpTo?: boolean, requeue?: boolean): void;
    nackAll(requeue?: boolean): void;
    reject(message: Message, requeue?: boolean): void;

    prefetch(count: number, global?: boolean): void;
    recover(callback?: (err: any, ok: Replies.Empty) => void): void;
}

export interface ConfirmChannel extends Channel {
    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(callback?: (err: any) => void): void;
}

export function connect(callback: (err: any, connection: Connection) => void): void;
export function connect(url: string, callback: (err: any, connection: Connection) => void): void;
export function connect(url: string, socketOptions: any, callback: (err: any, connection: Connection) => void): void;