Fix function args type

.gitignore

@@ -1,5 +1,5 @@
 node_modules
 test.js
 coverage
-dist
+# dist
 .nyc_output

.prettierrc

@@ -0,0 +1,4 @@
+{
+  "printWidth": 120,
+  "singleQuote": true
+}

dist/bind.d.ts

@@ -0,0 +1 @@
+export declare function autoBind(obj: object): void;

dist/bind.js

@@ -0,0 +1,15 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isMethod(propertyName, value) {
+    return propertyName !== 'constructor' && typeof value === 'function';
+}
+function autoBind(obj) {
+    const propertyNames = Object.getOwnPropertyNames(obj.constructor.prototype);
+    propertyNames.forEach((propertyName) => {
+        const value = obj[propertyName];
+        if (isMethod(propertyName, value)) {
+            obj[propertyName] = value.bind(obj);
+        }
+    });
+}
+exports.autoBind = autoBind;

dist/consumer.d.ts

@@ -0,0 +1,71 @@
+import * as SQS from 'aws-sdk/clients/sqs';
+import { EventEmitter } from 'events';
+declare type SQSMessage = SQS.Types.Message;
+export interface ConsumerOptions {
+    queueUrl?: string;
+    attributeNames?: string[];
+    messageAttributeNames?: string[];
+    stopped?: boolean;
+    concurrencyLimit?: number;
+    batchSize?: number;
+    visibilityTimeout?: number;
+    waitTimeSeconds?: number;
+    authenticationErrorTimeout?: number;
+    pollingWaitTimeMs?: number;
+    msDelayOnEmptyBatchSize?: number;
+    terminateVisibilityTimeout?: boolean;
+    sqs?: SQS;
+    region?: string;
+    handleMessageTimeout?: number;
+    handleMessage?(message: SQSMessage): Promise<void>;
+    handleMessageBatch?(messages: SQSMessage[], consumer: Consumer): Promise<void>;
+    pollingStartedInstrumentCallback?(eventData: object): void;
+    pollingFinishedInstrumentCallback?(eventData: object): void;
+    batchStartedInstrumentCallBack?(eventData: object): void;
+    batchFinishedInstrumentCallBack?(eventData: object): void;
+    batchFailedInstrumentCallBack?(eventData: object): void;
+}
+export declare class Consumer extends EventEmitter {
+    private queueUrl;
+    private handleMessage;
+    private handleMessageBatch;
+    private pollingStartedInstrumentCallback?;
+    private pollingFinishedInstrumentCallback?;
+    private batchStartedInstrumentCallBack?;
+    private batchFinishedInstrumentCallBack?;
+    private batchFailedInstrumentCallBack?;
+    private handleMessageTimeout;
+    private attributeNames;
+    private messageAttributeNames;
+    private stopped;
+    private concurrencyLimit;
+    private freeConcurrentSlots;
+    private batchSize;
+    private visibilityTimeout;
+    private waitTimeSeconds;
+    private authenticationErrorTimeout;
+    private pollingWaitTimeMs;
+    private msDelayOnEmptyBatchSize;
+    private terminateVisibilityTimeout;
+    private sqs;
+    constructor(options: ConsumerOptions);
+    readonly isRunning: boolean;
+    static create(options: ConsumerOptions): Consumer;
+    start(): void;
+    stop(): void;
+    setBatchSize(newBatchSize: number): void;
+    setConcurrencyLimit(newConcurrencyLimit: number): void;
+    setPollingWaitTimeMs(newPollingWaitTimeMs: number): void;
+    reportMessageFromBatchFinished(message: SQSMessage, error: Error): Promise<void>;
+    private reportNumberOfMessagesReceived;
+    private handleSqsResponse;
+    private processMessage;
+    private receiveMessage;
+    private deleteMessage;
+    private executeHandler;
+    private terminateVisabilityTimeout;
+    private emitError;
+    private poll;
+    private processMessageBatch;
+}
+export {};