added definition for rsmq-worker

http://smrchy.github.io/rsmq/rsmq-worker/

rsmq-worker/rsmq-worker-tests.ts

@@ -0,0 +1,21 @@
+
+import RSMQWorker = require('rsmq-worker');
+
+var worker = new RSMQWorker("my-queue");
+worker.changeInterval(1);
+worker.changeInterval([0, 1, 5, 10]);
+
+worker.on('message', (message: RedisSMQ.Message, next: Function) => {
+   console.log('received message: "' + message.message + "'");
+    next();
+});
+worker.start();
+
+worker.send('message1');
+worker.send('message2', 1, (e: Error, id:string) => {
+    worker.del(id);
+});
+worker.send('message3', () => {});
+
+worker.stop();
+

rsmq-worker/rsmq-worker.d.ts

@@ -0,0 +1,52 @@
+// Type definitions for rsmq-worker 0.3.5
+// Project: http://smrchy.github.io/rsmq/rsmq-worker/
+// Definitions by: Qubo <https://github.com/MugeSo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path='../rsmq/rsmq.d.ts'/>
+
+declare module "rsmq-worker" {
+    import redis = require('redis');
+    import events = require('events');
+
+    interface CallbackT<R> {
+        (e?:Error, res?:R): void;
+    }
+
+    interface RSMQWorkerStatic {
+        new(queuename: string, options?: WorkerOptions): RSMQWorker;
+    }
+
+    interface WorkerOptions {
+        interval?: number;
+        maxReceiveCount?: number;
+        invisibletime?: number;
+        defaultDelay?: number;
+        autostart?: boolean;
+        timeout: number;
+        customExceedCheck?: CustomExceedCheckCallback;
+        rsmq?: RedisSMQ.Client;
+        redis?: redis.RedisClient;
+        redisPrefix?: string;
+        host?: string;
+        port?: number;
+        options?: redis.ClientOpts;
+    }
+
+    interface CustomExceedCheckCallback {
+        (message: RedisSMQ.Message): boolean;
+    }
+
+
+    interface RSMQWorker extends events.EventEmitter {
+        start(): RSMQWorker;
+        stop(): RSMQWorker;
+        send(message: string, delay?: number, cb?: CallbackT<string>): RSMQWorker;
+        send(message: string, cb: CallbackT<string>): RSMQWorker;
+        del(id: string, cb?: CallbackT<void>): RSMQWorker;
+        changeInterval(interval: number|number[]): RSMQWorker;
+    }
+
+    var worker: RSMQWorkerStatic;
+    export = worker;
+}

rsmq/rsmq.d.ts

@@ -10,6 +10,19 @@ declare module RedisSMQ {
         (e?:Error, res?:R): void;
     }
 
+    interface Client {
+        createQueue(options:QueueOptions, cb:CallbackT<number>): void;
+        changeMessageVisibility(options:VisibilityOptions, cb:CallbackT<number>): void;
+        deleteMessage(options:MessageIdentifier, cb:CallbackT<number>): void;
+        deleteQueue(options:QueueIdentifier, cb:CallbackT<number>): void;
+        getQueueAttributes(options:QueueIdentifier, cb:CallbackT<QueueAttributes>): void;
+        listQueues(cb:CallbackT<string[]>): void;
+        receiveMessage(options:ReceiveOptions, cb:CallbackT<Message>): void;
+        sendMessage(options:NewMessage, cb:CallbackT<string>): void;
+        setQueueAttributes(options:QueueOptions, cb:CallbackT<QueueAttributes>): void;
+        quit(): void;
+    }
+
     interface QueueIdentifier {
         qname: string;
     }
@@ -64,17 +77,7 @@ declare module 'rsmq' {
         new (options:ClientOptions): Client;
     }
 
-    interface Client {
-        createQueue(options:RedisSMQ.QueueOptions, cb:RedisSMQ.CallbackT<number>): void;
-        changeMessageVisibility(options:RedisSMQ.VisibilityOptions, cb:RedisSMQ.CallbackT<number>): void;
-        deleteMessage(options:RedisSMQ.MessageIdentifier, cb:RedisSMQ.CallbackT<number>): void;
-        deleteQueue(options:RedisSMQ.QueueIdentifier, cb:RedisSMQ.CallbackT<number>): void;
-        getQueueAttributes(options:RedisSMQ.QueueIdentifier, cb:RedisSMQ.CallbackT<RedisSMQ.QueueAttributes>): void;
-        listQueues(cb:RedisSMQ.CallbackT<string[]>): void;
-        receiveMessage(options:RedisSMQ.ReceiveOptions, cb:RedisSMQ.CallbackT<RedisSMQ.Message>): void;
-        sendMessage(options:RedisSMQ.NewMessage, cb:RedisSMQ.CallbackT<string>): void;
-        setQueueAttributes(options:RedisSMQ.QueueOptions, cb:RedisSMQ.CallbackT<RedisSMQ.QueueAttributes>): void;
-        quit(): void;
+    interface Client extends RedisSMQ.Client{
         redis: redis.RedisClient;
     }