diff --git a/.eslintignore b/.eslintignore
index a03c4c0..a9c4c03 100644
--- a/.eslintignore
+++ b/.eslintignore
@@ -1 +1,2 @@
-*.test.js
+*.test.ts
+lib
diff --git a/.eslintrc.json b/.eslintrc.json
index 42fa85e..0b8c10e 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -1,5 +1,17 @@
 {
-  "extends": "airbnb-base",
+  "parser": "@typescript-eslint/parser",
+  "plugins": [
+    "@typescript-eslint"
+  ],
+  "extends": [
+    "plugin:@typescript-eslint/recommended",
+    "prettier/@typescript-eslint",
+    "plugin:prettier/recommended"
+  ],
+  "parserOptions": {
+    "ecmaVersion": 2020,
+    "sourceType": "module"
+  },
   "env": {
     "node": true,
     "es6": true
diff --git a/.npmignore b/.npmignore
index cdcff95..6fb3da9 100644
--- a/.npmignore
+++ b/.npmignore
@@ -1,4 +1,4 @@
-test
+__tests__
 *.test.js
 docs
 coverage
diff --git a/.prettierrc.js b/.prettierrc.js
new file mode 100644
index 0000000..f053ebf
--- /dev/null
+++ b/.prettierrc.js
@@ -0,0 +1 @@
+module.exports = {};
diff --git a/.travis.yml b/.travis.yml
index 8ae0c58..39f4ad6 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -18,6 +18,7 @@ before_script:
     done
 script:
   - npm run lint
+  - npm run build
   - npm test
 after_success:
   - './node_modules/.bin/nyc report --reporter=text-lcov | ./node_modules/.bin/coveralls'
diff --git a/bin/faktory-work b/bin/faktory-work
index a348a81..b2e073c 100755
--- a/bin/faktory-work
+++ b/bin/faktory-work
@@ -1,8 +1,6 @@
 #!/usr/bin/env node
 
 const faktory = require("../lib/faktory");
-console.log(faktory);
-process.exit(0);
 const program = require("../lib/cli");
 
 faktory.work(program).catch((error) => {
diff --git a/package.json b/package.json
index fdd3b5a..cb464cb 100644
--- a/package.json
+++ b/package.json
@@ -9,13 +9,15 @@
     "watch": "tsc -w",
     "build": "tsc",
     "clean": "rm -rf lib/*",
-    "test": "nyc --cache ava src/__tests__/*",
+    "test": "nyc --cache ava src/__tests__/**/*",
+    "test:unit": "nyc --cache ava src/__tests__/unit/*",
+    "test:integration": "nyc --cache ava src/__tests__/integration/*",
     "test:watch": "npm run test -- -w",
     "coverage": "nyc report --reporter=html",
-    "lint": "eslint src",
+    "lint": "eslint . --ext .ts",
     "htmldocs": "jsdoc . lib -d docs --readme README.md --pedantic",
     "docs": "jsdoc2md --files lib/*.js --template docs/template.hbs > docs/api.md",
-    "preversion": "npm run lint && npm run test && npm run docs",
+    "preversion": "npm run lint && npm run build && npm run test && npm run docs",
     "version": "git add docs/ package.json",
     "postversion": "git push && git push --tags"
   },
@@ -49,19 +51,27 @@
   "engines": {
     "node": ">=7"
   },
+  "types": "lib/index.d.ts",
   "devDependencies": {
     "@ava/typescript": "^1.1.1",
+    "@types/debug": "^4.1.5",
+    "@types/generic-pool": "^3.1.9",
+    "@types/koa-compose": "^3.2.5",
     "@types/node": "^14.0.11",
     "@types/uuid": "^8.0.0",
+    "@typescript-eslint/eslint-plugin": "^3.1.0",
+    "@typescript-eslint/parser": "^3.1.0",
     "ava": "^3.8.2",
     "coveralls": "3.1.0",
-    "eslint": "^4.10",
-    "eslint-config-airbnb-base": "13.2.0",
-    "eslint-plugin-import": "2.18.2",
+    "eslint": "^7.2.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-import": "^2.21.1",
+    "eslint-plugin-prettier": "^3.1.3",
     "get-port": "4.2.0",
     "jsdoc": "3.6.3",
     "jsdoc-to-markdown": "^3.1.0-1",
     "nyc": "13.3.0",
+    "prettier": "^2.0.5",
     "sinon": "9.0.2",
     "typescript": "^3.9.5"
   },
@@ -69,7 +79,7 @@
     "commander": "2.20.0",
     "debug": "^4.1.0",
     "generic-pool": "3.7.1",
-    "koa-compose": "^4.0.0",
+    "koa-compose": "^4.1.0",
     "redis-parser": "^3.0.0",
     "uuid": "3.3.3"
   }
diff --git a/src/@types/redis-parser/index.d.ts b/src/@types/redis-parser/index.d.ts
new file mode 100644
index 0000000..5d05c0e
--- /dev/null
+++ b/src/@types/redis-parser/index.d.ts
@@ -0,0 +1,15 @@
+declare module "redis-parser" {
+  type Config = {
+    returnReply: (response: string) => void;
+    returnError: (error: Error) => void;
+  };
+
+  class RedisParser {
+    // eslint-disable-next-line  @typescript-eslint/explicit-module-boundary-types
+    constructor(config: Config);
+    execute(buffer: Buffer): (err: Error | null, response: string) => void;
+  }
+
+  // export = RedisParser;
+  export default RedisParser;
+}
diff --git a/src/__tests__/_helper.ts b/src/__tests__/_helper.ts
index 10dda54..81fa5c9 100644
--- a/src/__tests__/_helper.ts
+++ b/src/__tests__/_helper.ts
@@ -1,10 +1,9 @@
-import { TestInterface } from 'ava';
-import { Socket, createServer, Server } from 'net';
-const uuid = require('uuid/v4');
-import getPort from 'get-port';
-import Client from '../client';
+import { TestInterface } from "ava";
+import { Socket, createServer, Server } from "net";
+import { v4 as uuid } from "uuid";
+import getPort from "get-port";
+import Client from "../client";
 import { JobPayload, PartialJobPayload } from "../job";
-import { Command } from "../connection";
 
 export type ServerControl = {
   socket: Socket;
@@ -12,7 +11,7 @@ export type ServerControl = {
   data?: string;
 };
 
-export const mockServer = () => {
+export const mockServer = (): Server => {
   const server = createServer();
 
   server.on("connection", (socket) => {
@@ -38,7 +37,11 @@ export const mockServer = () => {
   return server;
 };
 
-export const mocked = async (fn: (server: Server, port: number) => any | void) => {
+type ServerUser = {
+  (server: Server, port: number): Promise<unknown>;
+};
+
+export const mocked = async (fn: ServerUser): ReturnType<ServerUser> => {
   const server = mockServer();
   const port = await getPort();
   server.listen(port, "127.0.0.1");
@@ -81,15 +84,15 @@ mocked.info = () => ({ socket }: ServerControl) => {
   socket.write(`$${json.length}\r\n${json}\r\n`);
 };
 
-export const sleep = (ms: number, value: any = true) => {
+export const sleep = (ms: number, value?: unknown): Promise<unknown> => {
   return new Promise((resolve) => setTimeout(() => resolve(value), ms));
 };
 
-export const randQueue = (label: string = "test") => {
+export const randQueue = (label = "test"): string => {
   return `${label}-${uuid().slice(0, 6)}`;
 };
 
-export const createJob = (...args: any[]): PartialJobPayload => {
+export const createJob = (...args: unknown[]): PartialJobPayload => {
   return {
     jobtype: "testJob",
     queue: randQueue(),
@@ -97,9 +100,13 @@ export const createJob = (...args: any[]): PartialJobPayload => {
   };
 };
 
-export const push = async (
-  { args, queue, jobtype }: { args?: any[], queue?: string, jobtype?: string } = {}
-) => {
+export const push = async ({
+  args,
+  queue,
+  jobtype,
+}: { args?: unknown[]; queue?: string; jobtype?: string } = {}): Promise<
+  JobPayload
+> => {
   const client = new Client();
 
   const job = client.job(jobtype || "test");
@@ -113,9 +120,9 @@ export const push = async (
   return job;
 };
 
-export const flush = () => new Client().flush();
+export const flush = (): Promise<string> => new Client().flush();
 
-export function registerCleaner(test: TestInterface) {
+export function registerCleaner(test: TestInterface): void {
   test.beforeEach(async () => {
     await flush();
   });
diff --git a/src/__tests__/client.test.ts b/src/__tests__/client.test.ts
index 5b3a201..5b8cec3 100644
--- a/src/__tests__/client.test.ts
+++ b/src/__tests__/client.test.ts
@@ -25,20 +25,22 @@ test("#buildHello: client builds a passwordless ahoy", (t) => {
 });
 
 test("#buildHello: client builds a salty ahoy", (t) => {
-  const client = new Client();
+  const client = new Client({
+    password: "abcde123",
+  });
 
   const hello = client.buildHello({ i: 3, s: "123", v: 3 });
 
   t.is(
     hello.pwdhash,
-    "3180b4071170db0ae9f666167ed379f53468463f152e3c3cfb57d1de45fd01d6"
+    "ef646abadf4ffba660d9bbb8de8e45576970de917b4c9da8cad96b49e64636d9"
   );
 });
 
 test("#buildHello: wid is present in HELLO", (t) => {
   const client = new Client({ wid: "workerid" });
 
-  const hello = client.buildHello({ v: 2, s: 'abc', i: 3 });
+  const hello = client.buildHello({ v: 2, s: "abc", i: 3 });
 
   t.is(hello.wid, client.wid, "wid in ahoy does not match");
 });
@@ -144,7 +146,7 @@ test("#beat: sends a heartbeat", async (t) => {
 });
 
 test("#beat: returns a signal from the server", async (t) => {
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     server.on("BEAT", mocked.beat("quiet"));
     const client = new Client({ port });
 
@@ -170,7 +172,7 @@ test("#connect: rejects if handshake is not successful", async (t) => {
 
 test("#connect: connects explicitly", async (t) => {
   t.plan(2);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     server
       .on("HELLO", () => {
         t.is(1, 1);
@@ -202,7 +204,7 @@ test("#ack: ACKs a job", async (t) => {
 });
 
 test("#fetch: returns null when queue is empty", async (t) => {
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     server.on("FETCH", ({ socket }) => {
       // null bulkstring
       socket.write("$-1\r\n");
@@ -215,7 +217,7 @@ test("#fetch: returns null when queue is empty", async (t) => {
 
 test("#push: defaults job payload values according to spec", async (t) => {
   let serverJob: JobPayload;
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     server.on("PUSH", ({ data, socket }) => {
       serverJob = data;
       socket.write("+OK\r\n");
@@ -282,7 +284,7 @@ test("#job: provides the args to the job", (t) => {
 });
 
 test("#job: push sends job specification to server", async (t) => {
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     server.on("PUSH", ({ data, socket }) => {
       socket.write("+OK\r\n");
       const { jobtype, args, custom, retry } = data;
@@ -302,7 +304,7 @@ test("#job: push sends job specification to server", async (t) => {
 });
 
 test("#job: push resolves with the jid", async (t) => {
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     server.on("PUSH", ({ data, socket }) => {
       socket.write("+OK\r\n");
     });
diff --git a/src/__tests__/connection.test.ts b/src/__tests__/connection.test.ts
index 90cae18..6ebd4f4 100644
--- a/src/__tests__/connection.test.ts
+++ b/src/__tests__/connection.test.ts
@@ -1,31 +1,31 @@
-import test from 'ava';
+import test from "ava";
 
 import Connection from "../connection";
 import { mocked, registerCleaner } from "./_helper";
 
 registerCleaner(test);
 
-test("#open: resolves after HI", (t) => {
-  return mocked(async (server, port) => {
+test("#open: resolves after HI", async (t) => {
+  await mocked(async (server, port) => {
     let acc = "";
     server.on("HI", () => (acc += "A"));
     const conn = new Connection(port);
-    const resolved = await conn.open();
+    await conn.open();
     acc += "B";
     t.is(acc, "AB");
   });
 });
 
-test("#open: resolves with the server greeting", (t) => {
-  return mocked(async (_, port) => {
+test("#open: resolves with the server greeting", async (t) => {
+  await mocked(async (_, port) => {
     const conn = new Connection(port);
     const greeting = await conn.open();
-    t.deepEqual(greeting, { v: 2, s: 'abc', i: 3 });
+    t.deepEqual(greeting, { v: 2, s: "abc", i: 3 });
   });
 });
 
-test("#close: connects after disconnect", (t) => {
-  return mocked(async (server, port) => {
+test("#close: connects after disconnect", async (t) => {
+  await mocked(async (server, port) => {
     let acc = "";
     server.on("connection", () => (acc += "Co"));
     const conn = new Connection(port);
@@ -40,8 +40,8 @@ test("#close: connects after disconnect", (t) => {
   });
 });
 
-test("#close: emits close", (t) => {
-  return mocked(async (_, port) => {
+test("#close: emits close", async (t) => {
+  await mocked(async (_, port) => {
     const conn = new Connection(port);
     conn.on("close", () => t.pass());
     await conn.open();
@@ -81,8 +81,8 @@ test.cb("#open: emits error when connection fails to connect", (t) => {
     .then();
 });
 
-test("#send: resolves with server response", (t) => {
-  return mocked(async (_, port) => {
+test("#send: resolves with server response", async (t) => {
+  await mocked(async (_, port) => {
     const conn = new Connection(port);
     await conn.open();
     const resp = await conn.send(["HELLO", '{ "v": 2, "s": "abc", "i": 3 }']);
@@ -90,8 +90,8 @@ test("#send: resolves with server response", (t) => {
   });
 });
 
-test("#sendWithAssert: throws when response does not match assertion", (t) => {
-  return mocked(async (_, port) => {
+test("#sendWithAssert: throws when response does not match assertion", async (t) => {
+  await mocked(async (_, port) => {
     const conn = new Connection(port);
     await conn.open();
     return t.throwsAsync(
@@ -104,27 +104,31 @@ test("#sendWithAssert: throws when response does not match assertion", (t) => {
   });
 });
 
-test("#sendWithAssert: does not throw when response matches assertion", (t) => {
-  return mocked(async (_, port) => {
+test("#sendWithAssert: does not throw when response matches assertion", async (t) => {
+  await mocked(async (_, port) => {
     const conn = new Connection(port);
     await conn.open();
-    return t.notThrowsAsync(conn.sendWithAssert(["HELLO", '{ "v": 2, "s": "abc", "i": 3 }'], "OK"));
+    return t.notThrowsAsync(
+      conn.sendWithAssert(["HELLO", '{ "v": 2, "s": "abc", "i": 3 }'], "OK")
+    );
   });
 });
 
-test("#send: throws when the server responds with error", (t) => {
-  return mocked(async (server, port) => {
+test("#send: throws when the server responds with error", async (t) => {
+  await mocked(async (server, port) => {
     server.on("INFO", ({ socket }) => {
       socket.write("-ERR Something is wrong\r\n");
     });
     const conn = new Connection(port);
     await conn.open();
-    return t.throwsAsync(conn.send(["INFO"]), { message: /something is wrong/i });
+    return t.throwsAsync(conn.send(["INFO"]), {
+      message: /something is wrong/i,
+    });
   });
 });
 
-test("#send: emits timeout when exceeds deadline", (t) => {
-  return mocked(async (server, port) => {
+test("#send: emits timeout when exceeds deadline", async (t) => {
+  await mocked(async (server, port) => {
     let acc = "";
     server.on("INFO", ({ socket }) => {
       setTimeout(() => mocked.ok()({ socket }), 301);
diff --git a/src/__tests__/faktory.test.ts b/src/__tests__/faktory.test.ts
index 84f1cba..dfae8b8 100644
--- a/src/__tests__/faktory.test.ts
+++ b/src/__tests__/faktory.test.ts
@@ -1,11 +1,11 @@
 import test from "ava";
 
-import create from '../faktory';
-import Client from '../client';
-import Worker from '../worker';
+import create from "../faktory";
+import Client from "../client";
+import Worker from "../worker";
 import { sleep, mocked, registerCleaner } from "./_helper";
 
-// registerCleaner(test);
+registerCleaner(test);
 
 test("#register: returns self", (t) => {
   const faktory = create();
@@ -59,21 +59,23 @@ test(".connect() resolves a client", async (t) => {
   t.truthy(client instanceof Client);
 });
 
-test(".work() creates a worker, runs it and resolve the worker", async (t) => {
-  t.plan(1);
+test(".work() creates a worker, runs, then resolves the worker", async (t) => {
+  t.plan(3);
   await mocked(async (server, port) => {
     server
       .on("BEAT", ({ socket }) => {
         socket.write("+OK\r\n");
+        t.true(true);
       })
       .on("FETCH", async ({ socket }) => {
         await sleep(10);
+        t.true(true);
         socket.write("$-1\r\n");
       });
     const faktory = create();
     const worker = await faktory.work({ port, concurrency: 1 });
 
-    t.truthy(worker.heartbeat, "worker not started (no heartbeat)");
+    t.true(worker instanceof Worker);
 
     await worker.stop();
   });
diff --git a/src/__tests__/hash.test.ts b/src/__tests__/hash.test.ts
index 156aac7..b1b59b8 100644
--- a/src/__tests__/hash.test.ts
+++ b/src/__tests__/hash.test.ts
@@ -1,6 +1,7 @@
-import test from 'ava';
-import { createHash } from 'crypto';
-import hash from '../hash';
+import test from "ava";
+
+import { createHash } from "crypto";
+import hash from "../hash";
 
 test("client builds a hex pwdhash with salt", (t) => {
   const iterations = 10;
diff --git a/src/__tests__/job.test.ts b/src/__tests__/job.test.ts
index 67ad314..ba5633c 100644
--- a/src/__tests__/job.test.ts
+++ b/src/__tests__/job.test.ts
@@ -1,5 +1,5 @@
 import test from "ava";
-import Job from '../job';
+import Job from "../job";
 import Client from "../client";
 
 test(".jid: generates a uuid jid", (t) => {
diff --git a/src/__tests__/middleware.test.ts b/src/__tests__/middleware.test.ts
index fd294a6..fd8916b 100644
--- a/src/__tests__/middleware.test.ts
+++ b/src/__tests__/middleware.test.ts
@@ -1,8 +1,9 @@
 import test from "ava";
 
-import Worker from '../worker';
+import Worker from "../worker";
 import faktoryControlCreator from "../faktory";
 import { sleep, push, registerCleaner } from "./_helper";
+import { MiddlewareContext } from "../types";
 
 registerCleaner(test);
 
@@ -52,12 +53,12 @@ test("invokes middleware in order", async (t) => {
   });
 
   await new Promise((resolve) => {
-    worker.registry[jobtype] = async () => {
+    worker.register(jobtype, async () => {
       recorder.push("run 1");
       await sleep(1);
       recorder.push("run 2");
       resolve();
-    };
+    });
     worker.work();
   });
 
@@ -83,15 +84,19 @@ test(".use() adds middleware to the stack", (t) => {
   );
 });
 
+type MyAppContext = {
+  memo: string[];
+} & MiddlewareContext;
+
 test("middleware context is passed to job thunk", async (t) => {
   const { queue, jobtype } = await push({ args: [1] });
   const control = faktoryControlCreator();
 
-  control.use((ctx, next) => {
+  control.use((ctx: MyAppContext, next) => {
     ctx.memo = ["hello"];
     return next();
   });
-  control.use((ctx, next) => {
+  control.use((ctx: MyAppContext, next) => {
     ctx.memo.push("world");
     return next();
   });
diff --git a/src/__tests__/mutation.test.ts b/src/__tests__/mutation.test.ts
index 83a74bc..871cba5 100644
--- a/src/__tests__/mutation.test.ts
+++ b/src/__tests__/mutation.test.ts
@@ -1,7 +1,7 @@
 import test from "ava";
 
 import Client from "../client";
-import Mutation from "../mutation";
+import Mutation, { SCHEDULED, RETRIES, DEAD } from "../mutation";
 import { mocked, registerCleaner } from "./_helper";
 
 registerCleaner(test);
@@ -87,13 +87,13 @@ test("integration: #requeue moves retries to queue", async (t) => {
 
 test("#clear clears retries", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "clear",
-        target: "retries",
+        target: RETRIES,
         filter: {
           jobtype: "clearsRetries",
           jids: ["123"],
@@ -113,13 +113,13 @@ test("#clear clears retries", async (t) => {
 
 test("#clear clears scheduled jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "clear",
-        target: "scheduled",
+        target: SCHEDULED,
         filter: {
           jobtype: "clearsScheduled",
           jids: ["123"],
@@ -139,13 +139,13 @@ test("#clear clears scheduled jobs", async (t) => {
 
 test("#clear clears dead jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "clear",
-        target: "dead",
+        target: DEAD,
         filter: {
           jobtype: "clearsDead",
           jids: ["123"],
@@ -165,13 +165,13 @@ test("#clear clears dead jobs", async (t) => {
 
 test("#kill kills retries", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "kill",
-        target: "retries",
+        target: RETRIES,
         filter: {
           jobtype: "killsRetries",
           jids: ["123"],
@@ -191,13 +191,13 @@ test("#kill kills retries", async (t) => {
 
 test("#kill kills scheduled jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "kill",
-        target: "scheduled",
+        target: SCHEDULED,
         filter: {
           jobtype: "killsScheduled",
           jids: ["123"],
@@ -217,13 +217,13 @@ test("#kill kills scheduled jobs", async (t) => {
 
 test("#kill kills dead jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "kill",
-        target: "dead",
+        target: DEAD,
         filter: {
           jobtype: "killsDead",
           jids: ["123"],
@@ -243,13 +243,13 @@ test("#kill kills dead jobs", async (t) => {
 
 test("#discard discards retries", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "discard",
-        target: "retries",
+        target: RETRIES,
         filter: {
           jobtype: "discardsRetries",
           jids: ["123"],
@@ -269,13 +269,13 @@ test("#discard discards retries", async (t) => {
 
 test("#discard discards scheduled jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "discard",
-        target: "scheduled",
+        target: SCHEDULED,
         filter: {
           jobtype: "discardsScheduled",
           jids: ["123"],
@@ -295,13 +295,13 @@ test("#discard discards scheduled jobs", async (t) => {
 
 test("#discard discards dead jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "discard",
-        target: "dead",
+        target: DEAD,
         filter: {
           jobtype: "discardsDead",
           jids: ["123"],
@@ -321,13 +321,13 @@ test("#discard discards dead jobs", async (t) => {
 
 test("#requeue requeues retries", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "requeue",
-        target: "retries",
+        target: RETRIES,
         filter: {
           jobtype: "requeuesRetries",
           jids: ["123"],
@@ -347,13 +347,13 @@ test("#requeue requeues retries", async (t) => {
 
 test("#requeue requeues scheduled jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "requeue",
-        target: "scheduled",
+        target: SCHEDULED,
         filter: {
           jobtype: "requeuesScheduled",
           jids: ["123"],
@@ -373,13 +373,13 @@ test("#requeue requeues scheduled jobs", async (t) => {
 
 test("#requeue requeues dead jobs", async (t) => {
   t.plan(1);
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     const client = new Client({ port });
 
     server.on("MUTATE", ({ data, socket }) => {
       t.deepEqual(data, {
         cmd: "requeue",
-        target: "dead",
+        target: DEAD,
         filter: {
           jobtype: "requeuesDead",
           jids: ["123"],
@@ -398,20 +398,26 @@ test("#requeue requeues dead jobs", async (t) => {
 });
 
 test("#matching disallows nonstrings", (t) => {
-  t.throws(() => {
-    const mutation = new Mutation(new Client());
-    // @ts-ignore
-    mutation.matching(new RegExp("something"));
-  }, { message: /redis SCAN/ });
+  t.throws(
+    () => {
+      const mutation = new Mutation(new Client());
+      // @ts-ignore
+      mutation.matching(new RegExp("something"));
+    },
+    { message: /redis SCAN/ }
+  );
 });
 
 test("#ofType disallows nonstring argument", (t) => {
-  t.throws(() => {
-    const mutation = new Mutation(new Client());
-    const MyJob = () => {};
-    // @ts-ignore
-    mutation.ofType(MyJob);
-  }, {
-    message: /must be a string/i
-  });
+  t.throws(
+    () => {
+      const mutation = new Mutation(new Client());
+      const MyJob = () => {};
+      // @ts-ignore
+      mutation.ofType(MyJob);
+    },
+    {
+      message: /must be a string/i,
+    }
+  );
 });
diff --git a/src/__tests__/parser.test.ts b/src/__tests__/parser.test.ts
index b2b56c9..d7f1576 100644
--- a/src/__tests__/parser.test.ts
+++ b/src/__tests__/parser.test.ts
@@ -1,5 +1,6 @@
 import test from "ava";
-import Parser from '../parser';
+
+import Parser from "../parser";
 
 test.cb("parses HI", (t) => {
   const parser = new Parser();
diff --git a/src/__tests__/signals.test.ts b/src/__tests__/signals.test.ts
index b2a2390..acd4b24 100644
--- a/src/__tests__/signals.test.ts
+++ b/src/__tests__/signals.test.ts
@@ -1,6 +1,6 @@
 import test from "ava";
 
-import { Worker } from '../faktory';
+import { Worker } from "../faktory";
 import { sleep, push, mocked, registerCleaner } from "./_helper";
 
 registerCleaner(test);
diff --git a/src/__tests__/work.test.ts b/src/__tests__/work.test.ts
index 1137071..369df6c 100644
--- a/src/__tests__/work.test.ts
+++ b/src/__tests__/work.test.ts
@@ -8,7 +8,7 @@ const concurrency = 1;
 
 registerCleaner(test);
 
-function create(options: WorkerOptions = {}) {
+function create(options: WorkerOptions = {}): Worker {
   return new Worker(Object.assign({ concurrency }, options));
 }
 
@@ -39,7 +39,7 @@ test("awaits async jobfns", async (t) => {
     const worker = create({
       queues: [queue],
       registry: {
-        [jobtype]: async (...args: any[]) => {
+        [jobtype]: async (...args: unknown[]) => {
           await sleep(1);
           t.deepEqual(args, [1, 2, "three"], "args do not match");
           resolve();
@@ -59,7 +59,7 @@ test("handles sync jobfn and sync thunk", async (t) => {
     const worker = create({
       queues: [queue],
       registry: {
-        [jobtype]: (...args: any[]) => ({ job }: MiddlewareContext) => {
+        [jobtype]: (...args) => ({ job }: MiddlewareContext) => {
           t.is(job.jid, jid, "jid does not match");
           t.deepEqual(args, [1, 2, "three"], "args do not match");
           resolve();
@@ -95,20 +95,20 @@ test("handles sync jobfn and async (thunk)", async (t) => {
 test("handles async jobfn and sync thunk", async (t) => {
   const args = [1, 2, "three"];
   const { queue, jobtype, jid } = await push({ args });
-
-  await new Promise((resolve) => {
-    const worker = create({
-      queues: [queue],
-      registry: {
-        [jobtype]: async (...args) => ({ job }: MiddlewareContext) => {
-          t.is(job.jid, jid, "jid does not match");
-          t.deepEqual(args, [1, 2, "three"], "args do not match");
-          resolve();
-        },
-      },
-    });
-
-    worker.work();
+  const worker = create({ queues: [queue] });
+
+  await new Promise(async (resolve) => {
+    worker.register(
+      jobtype,
+      async (...args) => ({ job }: MiddlewareContext) => {
+        t.is(job.jid, jid, "jid does not match");
+        t.deepEqual(args, [1, 2, "three"], "args do not match");
+        resolve();
+      }
+    );
+
+    await worker.work();
+    await worker.stop();
   });
 });
 
@@ -120,7 +120,7 @@ test("handles async jobfn and async thunk", async (t) => {
     const worker = create({
       queues: [queue],
       registry: {
-        [jobtype]: async (...args: any[]) => async ({ job }: MiddlewareContext) => {
+        [jobtype]: async (...args) => async ({ job }: MiddlewareContext) => {
           await sleep(1);
           t.is(job.jid, jid, "jid does not match");
           t.deepEqual(args, [1, 2, "three"], "args do not match");
@@ -134,7 +134,7 @@ test("handles async jobfn and async thunk", async (t) => {
 });
 
 test(".handle() FAILs and throws when no job is registered", async (t) => {
-  const job = { jid: "123", jobtype: "Unknown", args: [], queue: 'default' };
+  const job = { jid: "123", jobtype: "Unknown", args: [], queue: "default" };
   await mocked(async (server, port) => {
     let worker: Worker;
 
@@ -156,7 +156,7 @@ test(".handle() FAILs and throws when no job is registered", async (t) => {
 test(".handle() FAILs and throws when the job throws (sync) during execution", async (t) => {
   const jid = "123";
   const jobtype = "failingjob";
-  const queue = 'default';
+  const queue = "default";
   const job = { jid, jobtype, args: [], queue };
   await mocked(async (server, port) => {
     let worker: Worker;
@@ -188,7 +188,7 @@ test(".handle() FAILs and throws when the job throws (sync) during execution", a
 test(".handle() FAILs and throws when the job rejects (async) during execution", async (t) => {
   const jid = "123";
   const jobtype = "failingjob";
-  const queue = 'default';
+  const queue = "default";
   const job = { jid, jobtype, args: [], queue };
   await mocked(async (server, port) => {
     let worker: Worker;
@@ -220,7 +220,7 @@ test(".handle() FAILs and throws when the job rejects (async) during execution",
 test(".handle() FAILs when the job returns a rejected promise with no error", async (t) => {
   const jid = "123";
   const jobtype = "failingjob";
-  const queue = 'default';
+  const queue = "default";
   const job = { jid, jobtype, args: [], queue };
   await mocked(async (server, port) => {
     let worker: Worker;
diff --git a/src/__tests__/worker.test.ts b/src/__tests__/worker.test.ts
index f8debb4..c5212eb 100644
--- a/src/__tests__/worker.test.ts
+++ b/src/__tests__/worker.test.ts
@@ -1,7 +1,7 @@
 import test from "ava";
 
 import Worker from "../worker";
-import { mocked, registerCleaner } from './_helper';
+import { mocked, registerCleaner } from "./_helper";
 
 registerCleaner(test);
 
@@ -40,11 +40,29 @@ test("passes the password to the client", (t) => {
 test("passes poolSize option to Client", (t) => {
   const worker = new Worker({ poolSize: 8 });
 
-  t.is(worker.client.pool._config.max, 8);
+  t.is(worker.client.pool.size, 8);
+});
+
+test.only("allows registering job functions", async (t) => {
+  await mocked(async (server, port) => {
+    server
+      .on("BEAT", mocked.beat())
+      .on("ACK", mocked.ok())
+      .on(
+        "FETCH",
+        mocked.fetch({ jid: "123", jobtype: "test", args: [], queue: "defaut" })
+      );
+    const worker = new Worker({ concurrency: 1, port });
+
+    worker.register("test", () => t.pass());
+
+    await worker.work();
+    await worker.stop();
+  });
 });
 
 test("hearbeats", async (t) => {
-  return mocked(async (server, port) => {
+  await mocked(async (server, port) => {
     let worker: Worker;
     let called = 0;
 
diff --git a/src/cli.ts b/src/cli.ts
index 7186020..238d501 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,34 +1,43 @@
 #!/usr/bin/env node
 
-const program = require('commander');
-const { version } = require('../package.json');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const program = require("commander");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { version } = require("../package.json");
 
 function collect(val: string, memo: Array<string>) {
   return memo.concat(val);
 }
 
-function collectSplit(val: string, memo: Array<String>) {
-  return memo.concat(val.split(','));
+function collectSplit(val: string, memo: Array<string>) {
+  return memo.concat(val.split(","));
 }
 
 module.exports = program
   .version(`faktory-worker ${version}`)
-  .usage('[options]')
-  .description(`
+  .usage("[options]")
+  .description(
+    `
    ___     __   __                                  __
   / _/__ _/ /__/ /____  ______ __  _    _____  ____/ /_____ ____
  / _/ _ \`/  '_/ __/ _ \\/ __/ // / | |/|/ / _ \\/ __/  '_/ -_) __/
 /_/ \\_,_/_/\\_\\\\__/\\___/_/  \\_, /  |__,__/\\___/_/ /_/\\_\\\\__/_/
                           /___/
-  `)
-  .option('-q, --queue <queue[,weight]>', 'queues to process with optional weights', collectSplit, [])
-  .option('-c, --concurrency <n>', 'number of concurrent workers', parseInt)
-  .option('-t, --timeout <n>', 'shutdown timeout', parseInt)
+  `
+  )
+  .option(
+    "-q, --queue <queue[,weight]>",
+    "queues to process with optional weights",
+    collectSplit,
+    []
+  )
+  .option("-c, --concurrency <n>", "number of concurrent workers", parseInt)
+  .option("-t, --timeout <n>", "shutdown timeout", parseInt)
   // .option('-e, --environment <env>', 'application environment')
-  .option('-l, --label <label>', 'worker label', collect, [])
+  .option("-l, --label <label>", "worker label", collect, [])
   // .option('-r, --require <path>', 'worker directory to require')
-  .option('-v, --verbose', 'print verbose output')
-  .option('-v, --version', 'print version and exit')
+  .option("-v, --verbose", "print verbose output")
+  .option("-v, --version", "print version and exit")
   .parse(process.argv);
 
 program.queues = program.queue;
diff --git a/src/client.ts b/src/client.ts
index 99cfb34..307d911 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -1,19 +1,21 @@
-
-const debug = require("debug")("faktory-worker:client");
-import { URL } from 'url';
-const querystring = require("querystring");
-const os = require("os");
-const { createPool } = require("generic-pool");
-const heartDebug = require("debug")("faktory-worker:client:heart");
-
-import encode from './encode';
-import Job, { JobPayload } from './job';
-import hash from './hash';
-import Mutation, { RETRIES, DEAD, SCHEDULED } from './mutation';
+import { default as makeDebug } from "debug";
+import { URL } from "url";
+import { unescape } from "querystring";
+import { hostname } from "os";
+import { createPool } from "generic-pool";
+
+import encode from "./encode";
+import Job, { JobPayload } from "./job";
+import hash from "./hash";
+import Mutation, { RETRIES, DEAD, SCHEDULED } from "./mutation";
 import Connection, { Greeting } from "./connection";
 import ConnectionFactory from "./connection-factory";
+import { Pool } from "generic-pool";
 import { JobType } from "./types";
-import { Command } from './connection';
+import { Command } from "./connection";
+
+const debug = makeDebug("faktory-worker:client");
+const heartDebug = makeDebug("faktory-worker:client:heart");
 
 const FAKTORY_PROTOCOL_VERSION = 2;
 const FAKTORY_PROVIDER = process.env.FAKTORY_PROVIDER || "FAKTORY_URL";
@@ -30,7 +32,7 @@ export type ClientOptions = {
 };
 
 export type JSONable = {
-  toJSON(): object;
+  toJSON(): Record<string, unknown>;
 };
 
 export type Hello = {
@@ -42,33 +44,24 @@ export type Hello = {
   pwdhash?: string;
 };
 
-interface Pool {
-  use(callback: (conn: Connection) => {}): Promise<any>;
-  drain(): Promise<any>;
-  clear(): Promise<any>;
-  _config: {
-    max: number;
-  }
-};
-
 export type ServerInfo = {
   server_utc_time: string;
   faktory: {
     queues: {
       [name: string]: number;
-    }
+    };
     tasks: {
       Retries: {
         size: number;
-      }
+      };
       Dead: {
         size: number;
-      }
+      };
       Scheduled: {
         size: number;
-      }
-    }
-  }
+      };
+    };
+  };
 };
 
 /**
@@ -87,8 +80,7 @@ export default class Client {
   labels: string[];
   wid?: string;
   connectionFactory: ConnectionFactory;
-  pool: Pool;
-
+  pool: Pool<Connection>;
 
   /**
    * Creates a Client with a connection pool
@@ -109,7 +101,7 @@ export default class Client {
   constructor(options: ClientOptions = {}) {
     const url = new URL(options.url || FAKTORY_URL);
 
-    this.password = options.password || querystring.unescape(url.password);
+    this.password = options.password || unescape(url.password);
     this.labels = options.labels || [];
     this.wid = options.wid;
     this.connectionFactory = new ConnectionFactory({
@@ -128,7 +120,7 @@ export default class Client {
     });
   }
 
-  static assertVersion(version: number) {
+  static assertVersion(version: number): void {
     if (version !== FAKTORY_PROTOCOL_VERSION) {
       throw new Error(`
   Client / server version mismatch
@@ -156,7 +148,7 @@ export default class Client {
    * Closes the connection to the server
    * @return {Promise.<undefined>}
    */
-  async close(): Promise<undefined> {
+  async close(): Promise<void> {
     await this.pool.drain();
     return this.pool.clear();
   }
@@ -168,13 +160,13 @@ export default class Client {
    * @return {Job}            a job builder with attached Client for PUSHing
    * @see  Job
    */
-  job(jobtype: JobType, ...args: any[]) {
+  job(jobtype: JobType, ...args: unknown[]): Job {
     const job = new Job(jobtype, this);
     job.args = args;
     return job;
   }
 
-  handshake(conn: Connection, greeting: Greeting) {
+  handshake(conn: Connection, greeting: Greeting): Promise<string> {
     debug("handshake");
 
     Client.assertVersion(greeting.v);
@@ -194,7 +186,7 @@ export default class Client {
    */
   buildHello({ s: salt, i: iterations }: Greeting): Hello {
     const hello: Hello = {
-      hostname: os.hostname(),
+      hostname: hostname(),
       v: FAKTORY_PROTOCOL_VERSION,
     };
 
@@ -204,7 +196,7 @@ export default class Client {
       hello.wid = this.wid;
     }
 
-    if (salt) {
+    if (salt && this.password) {
       hello.pwdhash = hash(this.password, salt, iterations);
     }
 
@@ -219,12 +211,14 @@ export default class Client {
    * @param {...*} args arguments to {@link Connection.send}
    * @see Connection.send
    */
-  send(command: Command) {
+  send(command: Command): PromiseLike<string> {
     return this.pool.use((conn: Connection) => conn.send(command));
   }
 
-  sendWithAssert(command: Command, assertion: string) {
-    return this.pool.use((conn) => conn.sendWithAssert(command, assertion));
+  sendWithAssert(command: Command, assertion: string): PromiseLike<string> {
+    return this.pool.use((conn: Connection) =>
+      conn.sendWithAssert(command, assertion)
+    );
   }
 
   /**
@@ -232,7 +226,7 @@ export default class Client {
    * @param  {...String} queues list of queues to pull a job from
    * @return {Promise.<object|null>}           a job payload if one is available, otherwise null
    */
-  async fetch(...queues: string[]): Promise<JobPayload|null> {
+  async fetch(...queues: string[]): Promise<JobPayload | null> {
     const response = await this.send(["FETCH", ...queues]);
     return JSON.parse(response);
   }
@@ -257,8 +251,8 @@ export default class Client {
    * @param  {Job|Object} job job payload to push
    * @return {Promise.<string>}         the jid for the pushed job
    */
-  async push(job: JSONable | object): Promise<string> {
-    const payload = ("toJSON" in job) ? (job as JSONable).toJSON() : job;
+  async push(job: JSONable | Record<string, unknown>): Promise<string> {
+    const payload = "toJSON" in job ? (job as JSONable).toJSON() : job;
     const payloadWithDefaults = Object.assign(
       { jid: Job.jid() },
       Job.defaults,
@@ -299,13 +293,13 @@ export default class Client {
    * @param  {Error} e   an error object that caused the job to fail
    * @return {Promise.<string>}     the server's response text
    */
-  fail(jid: string, e: Error): Promise<string> {
+  fail(jid: string, e: Error): PromiseLike<string> {
     return this.sendWithAssert(
       [
         "FAIL",
         encode({
           message: e.message,
-          errtype: (e as any).code,
+          errtype: (e as NodeJS.ErrnoException).code,
           backtrace: (e.stack || "").split("\n").slice(0, 100),
           jid,
         }),
@@ -314,19 +308,19 @@ export default class Client {
     );
   }
 
-  get retries() {
+  get [RETRIES](): Mutation {
     const mutation = new Mutation(this);
     mutation.target = RETRIES;
     return mutation;
   }
 
-  get scheduled() {
+  get [SCHEDULED](): Mutation {
     const mutation = new Mutation(this);
     mutation.target = SCHEDULED;
     return mutation;
   }
 
-  get dead() {
+  get [DEAD](): Mutation {
     const mutation = new Mutation(this);
     mutation.target = DEAD;
     return mutation;
diff --git a/src/connection-factory.ts b/src/connection-factory.ts
index b1094d6..005c794 100644
--- a/src/connection-factory.ts
+++ b/src/connection-factory.ts
@@ -1,18 +1,25 @@
-const debug = require('debug')('faktory-worker:connection-pool');
-import Connection from './connection';
-import sleep from './sleep';
+import makeDebug from "debug";
+import Connection, { Greeting } from "./connection";
+import { Factory } from "generic-pool";
+import sleep from "./sleep";
+
+const debug = makeDebug("faktory-worker:connection-pool");
+
+type handshaker = {
+  (conn: Connection, greeting: Greeting): Promise<string>;
+};
 
 /**
  * pools connections to the faktory server, ensuring that they're
  * connected before lending them
  * @private
  */
-export default class ConnectionFactory {
+export default class ConnectionFactory implements Factory<Connection> {
   host: string;
   port: string | number;
-  handshake: Function;
+  handshake: handshaker;
   attempts: number;
-  onConnectionError: (err: Error) => {};
+  onConnectionError: (err: Error) => void;
 
   /**
    * @param {object} options
@@ -21,7 +28,15 @@ export default class ConnectionFactory {
    * @param {function} handshake a function to perform the handshake for a connection
    *                             after it connects
    */
-  constructor({ host, port, handshake }: { host: string, port: string | number, handshake: Function}) {
+  constructor({
+    host,
+    port,
+    handshake,
+  }: {
+    host: string;
+    port: string | number;
+    handshake: handshaker;
+  }) {
     this.host = host;
     this.port = port;
     this.handshake = handshake;
@@ -34,17 +49,17 @@ export default class ConnectionFactory {
    * connections are not added to the pool until the handshake (server greeting)
    * is complete and successful
    */
-  async create() {
-    debug('+1');
+  async create(): Promise<Connection> {
+    debug("+1");
     const connection = new Connection(this.port, this.host);
-    connection.on('error', this.onConnectionError);
+    connection.on("error", this.onConnectionError);
     try {
       const greeting = await connection.open();
       await this.handshake(connection, greeting);
       this.attempts = 0;
     } catch (e) {
       this.attempts += 1;
-      debug('attempts=%i', this.attempts);
+      debug("attempts=%i", this.attempts);
       await sleep(200 * Math.min(this.attempts, 20));
       throw e;
     }
@@ -54,16 +69,16 @@ export default class ConnectionFactory {
   /**
    * Destroys a connection from the pool
    */
-  destroy(connection: Connection) {
-    debug('-1');
-    connection.on('close', () => connection.removeAllListeners());
+  destroy(connection: Connection): Promise<void> {
+    debug("-1");
+    connection.removeListener("error", this.onConnectionError);
     return connection.close();
   }
 
   /**
    * Validates that a connection from the pool is ready
    */
-  validate(connection: Connection) {
+  async validate(connection: Connection): Promise<boolean> {
     return connection.connected;
   }
 }
diff --git a/src/connection.ts b/src/connection.ts
index 3dc72aa..f9dfd75 100644
--- a/src/connection.ts
+++ b/src/connection.ts
@@ -1,10 +1,12 @@
 import { Socket } from "net";
-const assert = require('assert');
-const EventEmitter = require('events');
-const debug = require('debug')('faktory-worker:connection');
+import { strictEqual } from "assert";
+import { EventEmitter } from "events";
+import makeDebug from "debug";
 
 import Parser from "./parser";
 
+const debug = makeDebug("faktory-worker:connection");
+
 const SOCKET_TIMEOUT = 10000;
 
 /**
@@ -34,7 +36,11 @@ export type ConnectionOptions = {
   host?: string;
   port?: string | number;
   password?: string;
-}
+};
+
+type RequestCallback = {
+  (e: Error | null, response?: string): void;
+};
 
 /**
  * A connection to the faktory server for sending commands
@@ -46,14 +52,19 @@ export type ConnectionOptions = {
  */
 export default class Connection extends EventEmitter {
   connected: boolean;
+  closing: boolean;
+  host: string | undefined;
+  port: string | number;
+  pending: RequestCallback[];
   socket: Socket;
   parser: Parser;
+  lastError: Error;
 
   /**
    * @param {Number} port the port to connect on
    * @param {String} host the hostname to connect to
    */
-  constructor(port?: string | number, host?: string) {
+  constructor(port: string | number, host?: string) {
     super();
     this.host = host;
     this.port = port;
@@ -66,9 +77,8 @@ export default class Connection extends EventEmitter {
   /**
    * Sets the socket timeout
    * @param {Number} ms timeout in milliseconds
-   * @private
    */
-  setTimeout(ms: number = SOCKET_TIMEOUT) {
+  setTimeout(ms: number = SOCKET_TIMEOUT): void {
     this.socket.setTimeout(ms);
   }
 
@@ -77,17 +87,17 @@ export default class Connection extends EventEmitter {
    * @private
    * @return {Connection} self
    */
-  listen(): Connection {
+  private listen(): Connection {
     this.socket
-      .on('connect', this.onConnect.bind(this))
-      .on('data', buffer => this.parser.parse(buffer))
-      .on('timeout', this.onTimeout.bind(this))
-      .on('error', this.onError.bind(this))
-      .on('close', this.onClose.bind(this));
+      .on("connect", this.onConnect.bind(this))
+      .on("data", (buffer) => this.parser.parse(buffer))
+      .on("timeout", this.onTimeout.bind(this))
+      .on("error", this.onError.bind(this))
+      .on("close", this.onClose.bind(this));
 
     this.parser
-      .on('message', this.onMessage.bind(this, null))
-      .on('error', this.onMessage.bind(this));
+      .on("message", this.onMessage.bind(this, null))
+      .on("error", this.onMessage.bind(this));
 
     return this;
   }
@@ -97,25 +107,25 @@ export default class Connection extends EventEmitter {
    * @return {Promise} resolves with the server's greeting
    */
   open(): Promise<Greeting> {
-    debug('connecting');
+    debug("connecting");
 
     return new Promise((resolve, reject) => {
       this.pending = [
         (err: Error, response: string) => {
           if (err) return reject(err);
-          const greeting = JSON.parse(response.split(' ')[1]);
-          this.emit('greeting', greeting);
+          const greeting = JSON.parse(response.split(" ")[1]);
+          this.emit("greeting", greeting);
           return resolve(greeting);
-        }
+        },
       ];
       const onceErrored = (err: Error) => {
         reject(err);
-        this.socket.removeListener('error', onceErrored);
+        this.socket.removeListener("error", onceErrored);
       };
       this.socket
-        .once('error', onceErrored)
-        .connect(this.port, this.host, () => {
-          this.socket.removeListener('error', onceErrored);
+        .once("error", onceErrored)
+        .connect(<number>this.port, this.host || "", () => {
+          this.socket.removeListener("error", onceErrored);
         });
     });
   }
@@ -123,9 +133,9 @@ export default class Connection extends EventEmitter {
   /**
    * @private
    */
-  onConnect() {
+  private onConnect() {
     this.connected = true;
-    this.emit('connect');
+    this.emit("connect");
     this.socket.setKeepAlive(true);
     this.setTimeout();
   }
@@ -133,31 +143,31 @@ export default class Connection extends EventEmitter {
   /**
    * @private
    */
-  clearPending(err: Error) {
-    this.pending.forEach((callback: (err: Error) => {}) => callback(err));
+  private clearPending(err: Error) {
+    this.pending.forEach((callback) => callback(err));
   }
 
   /**
    * @private
    */
-  onClose() {
-    debug('close');
+  private onClose() {
+    debug("close");
 
     this.closing = false;
     this.connected = false;
 
-    this.emit('close');
+    this.emit("close");
 
     // dead letters?
-    this.clearPending(this.lastError || new Error('Connection closed'));
+    this.clearPending(this.lastError || new Error("Connection closed"));
   }
 
   /**
    * @private
    */
-  onTimeout() {
-    this.emit('timeout');
-    debug('timeout');
+  private onTimeout() {
+    this.emit("timeout");
+    debug("timeout");
   }
 
   /**
@@ -170,10 +180,13 @@ export default class Connection extends EventEmitter {
    * @return {String}                  the server's response string
    * @throws {AssertionError}
    */
-  async sendWithAssert(command: Command, expectedResponse: string): Promise<string> {
+  async sendWithAssert(
+    command: Command,
+    expectedResponse: string
+  ): Promise<string> {
     const response = await this.send(command);
 
-    assert.strictEqual(
+    strictEqual(
       response,
       expectedResponse,
       `expected ${expectedResponse} response, but got ${response}`
@@ -190,13 +203,13 @@ export default class Connection extends EventEmitter {
    *                           rejected with an error
    */
   send(command: Command): Promise<string> {
-    const commandString = command.join(' ');
-    debug('SEND: %s', commandString);
+    const commandString = command.join(" ");
+    debug("SEND: %s", commandString);
 
     return new Promise((resolve, reject) => {
       this.socket.write(`${commandString}\r\n`);
       this.pending.push((err: Error, response: string) => {
-        debug('client=%o, server=%o', commandString, response);
+        debug("client=%o, server=%o", commandString, response);
         if (err) return reject(err);
         return resolve(response);
       });
@@ -206,7 +219,7 @@ export default class Connection extends EventEmitter {
   /**
    * @private
    */
-  onMessage(err: Error | null, message: string) {
+  private onMessage(err: Error | null, message: string) {
     debug(err || message);
 
     const callback = this.pending.shift();
@@ -223,9 +236,9 @@ export default class Connection extends EventEmitter {
   /**
    * @private
    */
-  onError(err: Error) {
+  private onError(err: Error) {
     this.lastError = err;
-    this.emit('error', err);
+    this.emit("error", err);
   }
 
   /**
@@ -234,8 +247,8 @@ export default class Connection extends EventEmitter {
    */
   close(): Promise<undefined> {
     this.closing = true;
-    return new Promise(resolve => (
-      this.socket.once('close', () => resolve()).end('END\r\n')
-    ));
+    return new Promise((resolve) =>
+      this.socket.once("close", () => resolve()).end("END\r\n")
+    );
   }
 }
diff --git a/src/encode.ts b/src/encode.ts
index b8eb44f..2e5e112 100644
--- a/src/encode.ts
+++ b/src/encode.ts
@@ -1,3 +1,3 @@
-export default function encode(object: Object): string {
+export default function encode(object: Record<string, unknown>): string {
   return JSON.stringify(object);
-};
+}
diff --git a/src/faktory.ts b/src/faktory.ts
index 6c8f6de..c7986c0 100644
--- a/src/faktory.ts
+++ b/src/faktory.ts
@@ -1,19 +1,21 @@
-const debug = require("debug")("faktory-worker");
-const assert = require("assert");
+import makeDebug from "debug";
+import { strict as assert } from "assert";
 
-import Client from "./client";
-import Worker, { WorkerOptions } from './worker';
-import { JobType, Registry, MiddlewareFunction, JobFunction } from "./types";
+import Client, { ClientOptions } from "./client";
+import Worker, { WorkerOptions } from "./worker";
+import { JobType, Registry, Middleware, JobFunction } from "./types";
+
+const debug = makeDebug("faktory-worker");
 
 export interface FaktoryControl {
   registry: Registry;
-  use(fn: MiddlewareFunction): FaktoryControl;
-  middleware: MiddlewareFunction[];
+  use(fn: Middleware): FaktoryControl;
+  middleware: Middleware[];
   register(name: JobType, fn: JobFunction): FaktoryControl;
-  connect(...arg0: any[]): Promise<Client>;
+  connect(options?: ClientOptions): Promise<Client>;
   work(options?: WorkerOptions): Promise<Worker>;
-  stop(): Promise<any>;
-};
+  stop(): Promise<void>;
+}
 
 export type FaktoryControlCreator = {
   (): FaktoryControl;
@@ -27,7 +29,7 @@ export type FaktoryControlCreator = {
  * @return {FaktoryControl}
  */
 const createControl: FaktoryControlCreator = (): FaktoryControl => {
-  const middleware: MiddlewareFunction[] = [];
+  const middleware: Middleware[] = [];
   const registry: Registry = {};
   let worker: Worker | undefined;
 
@@ -58,7 +60,7 @@ const createControl: FaktoryControlCreator = (): FaktoryControl => {
      * @instance
      * @return {Middleware} array of middleware functions with koa-compose-style signatures
      */
-    get middleware(): MiddlewareFunction[] {
+    get middleware(): Middleware[] {
       return middleware;
     },
 
@@ -78,9 +80,9 @@ const createControl: FaktoryControlCreator = (): FaktoryControl => {
      *   });
      * });
      */
-    use(fn: MiddlewareFunction): FaktoryControl {
+    use(fn: Middleware): FaktoryControl {
       assert(typeof fn === "function");
-      debug("use %s", fn._name || fn.name || "-");
+      debug("use %s", fn.name || "-");
       middleware.push(fn);
       return this;
     },
@@ -115,8 +117,8 @@ const createControl: FaktoryControlCreator = (): FaktoryControl => {
      *
      * await client.push(job);
      */
-    connect(...args: any[]): Promise<Client> {
-      return new Client(...args).connect();
+    connect(options?: ClientOptions): Promise<Client> {
+      return new Client(options).connect();
     },
 
     /**
@@ -147,7 +149,7 @@ const createControl: FaktoryControlCreator = (): FaktoryControl => {
      *
      * faktory.stop();
      */
-    stop(): Promise<any> {
+    stop(): Promise<void> {
       if (worker) {
         const existing: Worker = worker;
         worker = undefined;
@@ -158,9 +160,7 @@ const createControl: FaktoryControlCreator = (): FaktoryControl => {
   };
 };
 
-export {
-  Worker, Client
-}
+export { Worker, Client };
 
 export default <FaktoryControlCreator & FaktoryControl>(
   Object.assign(createControl, createControl())
diff --git a/src/hash.ts b/src/hash.ts
index 9a75372..58da9d3 100644
--- a/src/hash.ts
+++ b/src/hash.ts
@@ -1,4 +1,4 @@
-const crypto = require('crypto');
+import { createHash } from "crypto";
 
 /**
  * hashes the password with server-provided salt
@@ -8,12 +8,16 @@ const crypto = require('crypto');
  * @return {String}            the password hash
  * @private
  */
-export default function hash(password: string, salt: string, iterations: number): string {
-  let current = crypto.createHash('sha256').update(`${password}${salt}`);
+export default function hash(
+  password: string,
+  salt: string,
+  iterations: number
+): string {
+  let hash = createHash("sha256").update(`${password}${salt}`);
 
   for (let i = 1; i < iterations; i += 1) {
-    current = crypto.createHash('sha256').update(current.digest());
+    hash = createHash("sha256").update(hash.digest());
   }
 
-  return current.digest('hex');
-};
+  return hash.digest("hex");
+}
diff --git a/src/job.ts b/src/job.ts
index 57c0272..b777483 100644
--- a/src/job.ts
+++ b/src/job.ts
@@ -1,8 +1,8 @@
-const uuid = require('uuid/v4');
-import Client from './client';
+import { v4 as uuid } from "uuid";
+import Client from "./client";
 
 export interface JobCustomParams {
-  [propName: string]: any;
+  [propName: string]: unknown;
 }
 
 /**
@@ -28,7 +28,7 @@ export type PartialJobPayload = {
   jid?: string;
   jobtype: string;
   queue: string;
-  args: any[];
+  args: unknown[];
   priority?: number;
   retry?: number;
   custom?: JobCustomParams;
@@ -38,8 +38,6 @@ export type PartialJobPayload = {
 
 export type JobPayload = PartialJobPayload & {
   jid: string;
-  queue: string;
-  args: any[];
 };
 
 /**
@@ -66,12 +64,12 @@ export default class Job {
    * @param  {Client} [client]  a client to use for communicating to the server (if calling push)
    */
   constructor(jobtype: string, client: Client) {
-    if (!jobtype) throw new Error('must provide jobtype');
+    if (!jobtype) throw new Error("must provide jobtype");
     this.client = client;
-    this.payload = Object.assign({
+    this.payload = Object.assign(Job.defaults, {
       jid: Job.jid(),
       jobtype,
-    }, Job.defaults);
+    });
   }
 
   get jid(): string {
@@ -110,7 +108,7 @@ export default class Job {
     this.payload.queue = value;
   }
 
-  get args(): any[] {
+  get args(): unknown[] {
     return this.payload.args;
   }
 
@@ -120,11 +118,11 @@ export default class Job {
    * @param  {Array} value array of positional arguments
    * @see  external:JobPayload
    */
-  set args(value: any[]) {
-    this.payload.args = value;
+  set args(args: unknown[]) {
+    this.payload.args = args;
   }
 
-  get priority() {
+  get priority(): number | undefined {
     return this.payload.priority;
   }
 
@@ -134,7 +132,7 @@ export default class Job {
    * @param  {number} value 0-9
    * @see  external:JobPayload
    */
-  set priority(value) {
+  set priority(value: number | undefined) {
     this.payload.priority = value;
   }
 
@@ -163,11 +161,11 @@ export default class Job {
    * @see  external:JobPayload
    */
   set at(value: Date | string | undefined) {
-    const string = typeof value === 'object' ? value.toISOString() : value;
+    const string = typeof value === "object" ? value.toISOString() : value;
     this.payload.at = string;
   }
 
-  get reserveFor() {
+  get reserveFor(): number | undefined {
     return this.payload.reserve_for;
   }
 
@@ -181,7 +179,7 @@ export default class Job {
     this.payload.reserve_for = value;
   }
 
-  get custom() {
+  get custom(): JobCustomParams | undefined {
     return this.payload.custom;
   }
 
@@ -191,8 +189,8 @@ export default class Job {
    * @param  {object} value the custom data
    * @see  external:JobPayload
    */
-  set custom(value: object | undefined) {
-    this.payload.custom = value;
+  set custom(custom: JobCustomParams | undefined) {
+    this.payload.custom = custom;
   }
 
   /**
@@ -216,9 +214,10 @@ export default class Job {
     return this.client.push(this);
   }
 
-  static get defaults() {
+  static get defaults(): PartialJobPayload {
     return {
-      queue: 'default',
+      jobtype: "",
+      queue: "default",
       args: [],
       priority: 5,
       retry: 25,
diff --git a/src/mutation.ts b/src/mutation.ts
index de71063..339b9a3 100644
--- a/src/mutation.ts
+++ b/src/mutation.ts
@@ -1,28 +1,26 @@
-import encode from './encode';
-import { JobType } from './types';
-import Client from './client';
+import encode from "./encode";
+import { JobType } from "./types";
+import Client from "./client";
 
-const MUTATE = 'MUTATE';
+const MUTATE = "MUTATE";
 
 /**
- * commands
  * @private
  */
 enum Verb {
-  CLEAR = 'clear',
-  KILL = 'kill',
-  DISCARD = 'discard',
-  REQUEUE = 'requeue',
+  CLEAR = "clear",
+  KILL = "kill",
+  DISCARD = "discard",
+  REQUEUE = "requeue",
 }
 
 /**
- * targets
  * @private
  */
 enum Target {
-  RETRIES = 'retries',
-  SCHEDULED = 'scheduled',
-  DEAD = 'dead',
+  RETRIES = "retries",
+  SCHEDULED = "scheduled",
+  DEAD = "dead",
 }
 
 export const SCHEDULED = Target.SCHEDULED;
@@ -34,7 +32,13 @@ export type Filter = {
   pattern?: string;
   jids?: Array<string>;
   regexp?: string;
-}
+};
+
+type Command = {
+  cmd: Verb;
+  filter: Filter;
+  target: Target;
+};
 
 /**
  * A wrapper for the [Mutate API](https://github.com/contribsys/faktory/wiki/Mutate-API)
@@ -44,7 +48,7 @@ export type Filter = {
  * !!! Please be warned: MUTATE commands can be slow and/or resource intensive.
  * **They should not be used as part of your application logic.**
  */
-class Mutation {
+export default class Mutation {
   client: Client;
   target: Target;
   filter: Filter;
@@ -69,9 +73,9 @@ class Mutation {
    * @example
    * client.dead.ofType('SendEmail').discard();
    */
-  ofType(jobtype: JobType) {
-    if (typeof jobtype !== 'string') {
-      throw new Error('jobtype given to ofType must be a string');
+  ofType(jobtype: JobType): Mutation {
+    if (typeof jobtype !== "string") {
+      throw new Error("jobtype given to ofType must be a string");
     }
     this.filter.jobtype = jobtype;
     return this;
@@ -87,7 +91,7 @@ class Mutation {
    * @example
    * await client.retries.withJids('1234').requeue();
    */
-  withJids(...jids: string[] | [string[]]) {
+  withJids(...jids: string[] | [string[]]): Mutation {
     let ids: string[];
     if (Array.isArray(jids[0])) {
       ids = jids[0];
@@ -112,14 +116,16 @@ class Mutation {
    * @example
    * await client.retries.matching("*uid:12345*").kill();
    */
-  matching(pattern: string) {
-    if (typeof pattern !== 'string') {
-      throw new Error(`
+  matching(pattern: string): Mutation {
+    if (typeof pattern !== "string") {
+      throw new Error(
+        `
 Argument given to matching() must be a redis SCAN compatible pattern string,
 other object types cannot be translated.
 See the Redis SCAN documentation for pattern matching examples.
 https://redis.io/commands/scan
-      `.trim());
+      `.trim()
+      );
     }
     this.filter.regexp = pattern;
     return this;
@@ -128,16 +134,19 @@ https://redis.io/commands/scan
   /**
    * @private
    */
-  toJSON() {
-    const { cmd, target, filter } = this;
-    return { cmd, target, filter };
+  private toJSON(): Command {
+    return {
+      cmd: this.cmd,
+      target: this.target,
+      filter: this.filter,
+    };
   }
 
   /**
    * Executes a *clear* mutation. This clears the
    * set entirely **and any filtering added does not apply**.
    */
-  clear() {
+  clear(): PromiseLike<string> {
     this.cmd = Verb.CLEAR;
     return this.send();
   }
@@ -145,7 +154,7 @@ https://redis.io/commands/scan
   /**
    * Executes a *kill* mutation. Jobs that are killed are sent to the dead set.
    */
-  kill() {
+  kill(): PromiseLike<string> {
     this.cmd = Verb.KILL;
     return this.send();
   }
@@ -153,7 +162,7 @@ https://redis.io/commands/scan
   /**
    * Executes a *discard* mutation. Jobs that are discarded are permanently deleted.
    */
-  discard() {
+  discard(): PromiseLike<string> {
     this.cmd = Verb.DISCARD;
     return this.send();
   }
@@ -162,7 +171,7 @@ https://redis.io/commands/scan
    * Executes a *requeue* mutation. Jobs that are requeued are sent back to their
    * original queue for processing.
    */
-  requeue() {
+  requeue(): PromiseLike<string> {
     this.cmd = Verb.REQUEUE;
     return this.send();
   }
@@ -170,12 +179,7 @@ https://redis.io/commands/scan
   /**
    * @private
    */
-  send() {
-    return this.client.sendWithAssert(
-      [MUTATE, encode(this.toJSON())],
-      "OK"
-    );
+  send(): PromiseLike<string> {
+    return this.client.sendWithAssert([MUTATE, encode(this.toJSON())], "OK");
   }
 }
-
-export default Mutation;
diff --git a/src/parser.ts b/src/parser.ts
index e0ae1b1..2106768 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,25 +1,26 @@
-const RedisParser = require('redis-parser');
-const EventEmitter = require('events');
+import { EventEmitter } from "events";
 
-type EventHandler = (resp: any) => void | any;
+import RedisParser from "redis-parser";
+
+interface Adapter {
+  execute(buffer: Buffer): void;
+}
 
 /**
  * @private
  */
 export default class Parser extends EventEmitter {
-  on: (event: string, handler: EventHandler) => Parser;
-  emit: (event: string, object: any) => Parser;
+  adapter: Adapter;
 
   constructor() {
     super();
     this.adapter = new RedisParser({
-      returnReply: (response: string) =>
-        this.emit("message", response),
+      returnReply: (response: string) => this.emit("message", response),
       returnError: (err: Error) => this.emit("error", err),
     });
   }
 
-  parse(buffer: Buffer) {
+  parse(buffer: Buffer): void {
     this.adapter.execute(buffer);
   }
 }
diff --git a/src/sleep.ts b/src/sleep.ts
index b637578..a88f3ad 100644
--- a/src/sleep.ts
+++ b/src/sleep.ts
@@ -1,5 +1,3 @@
-export default function sleep(ms: number, value = true) {
-  return new Promise(resolve => (
-    setTimeout(() => resolve(value), ms)
-  ));
-};
+export default function sleep(ms: number, value?: unknown): Promise<unknown> {
+  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+}
diff --git a/src/types.ts b/src/types.ts
index 6f0b1b1..b7bcb46 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,4 +1,5 @@
-import { JobPayload } from './job';
+import { JobPayload } from "./job";
+import { Middleware as KoaMiddleware } from "koa-compose";
 
 /**
  * Discriminator used by a worker to decide how to execute a job. This will be the name you
@@ -42,8 +43,13 @@ export type RFC3339_DateTime = string;
  *   // does something meaningful
  * }
  */
-export type JobFunctionWrapper = (...arg0: any[]) => MiddlewareFunction;
-export type JobFunction = (...arg0: any[]) => any;
+export type JobFunctionContextWrapper = {
+  (...args: unknown[]): ContextProvider;
+};
+export type UnWrappedJobFunction = {
+  (...args: unknown[]): unknown;
+};
+export type JobFunction = JobFunctionContextWrapper | UnWrappedJobFunction;
 
 /**
  * An after-connect initial message from the server to handshake the connection
@@ -80,16 +86,6 @@ export type JobFunction = (...arg0: any[]) => any;
  * @global
  */
 
-export interface NextFunction {
-  (): Promise<any>;
-};
-
-export interface MiddlewareFunction {
-  (ctx: MiddlewareContext, next: NextFunction): any;
-  _name?: string;
-}
-
-
 /**
  * A function returned by a job function that will be called with the job context as its
  * only argument and awaited. This exists to allow you to define simple job functions that
@@ -97,14 +93,14 @@ export interface MiddlewareFunction {
  * or stateful connections (like a database connection) in your job and want to attach
  * a connection for your job function to use without having to create it itself.
  *
- * @typedef JobThunk
+ * @typedef ContextProvider
  * @type {function}
  * @param {object} ctx context object containing the job and any other data attached
  *                     via userland-middleware
  * @example
  * // assumes you have middleware that attaches `db` to `ctx`
  *
- * faktory.register('UserWelcomer', (...args) => (ctx) => {
+ * faktory.register('UserWelcomer', (...args) => async (ctx) => {
  *   const [ id ] = args;
  *   const user = await ctx.db.users.find(id);
  *   const email = new WelcomeEmail(user);
@@ -112,7 +108,8 @@ export interface MiddlewareFunction {
  * });
  * @see  Context
  */
-export type JobThunk = (...arg0: any) => JobFunction;
+
+export type ContextProvider = (ctx: MiddlewareContext) => unknown;
 
 /**
  * A context object passed through middleware and to a job thunk
@@ -124,9 +121,9 @@ export type JobThunk = (...arg0: any) => JobFunction;
  */
 export interface MiddlewareContext {
   job: JobPayload;
-  fn: JobFunction;
-  [propName: string]: any;
+  fn?: JobFunction;
 }
+export type Middleware = KoaMiddleware<MiddlewareContext>;
 
 /**
  * A lookup table holding the jobtype constants mapped to their job functions
@@ -146,5 +143,5 @@ export interface MiddlewareContext {
  * }
  */
 export type Registry = {
-  [JobType: string]: JobFunctionWrapper | JobFunction;
+  [jobtype: string]: JobFunction;
 };
diff --git a/src/worker.ts b/src/worker.ts
index e146507..934855a 100644
--- a/src/worker.ts
+++ b/src/worker.ts
@@ -1,20 +1,23 @@
 import {
-  MiddlewareFunction,
+  Middleware,
   Registry,
+  JobFunction,
+  JobType,
   MiddlewareContext,
-  NextFunction,
 } from "./types";
 import { JobPayload } from "./job";
 
-const debug = require("debug")("faktory-worker:worker");
-const uuid = require("uuid");
-const compose = require("koa-compose");
-const EventEmitter = require("events");
+import makeDebug from "debug";
+import { v4 as uuid } from "uuid";
+import { ComposedMiddleware } from "koa-compose";
+import compose from "koa-compose";
+import { EventEmitter } from "events";
 
 import Client, { ClientOptions } from "./client";
 import wrapNonErrors from "./wrap-non-errors";
 import sleep from "./sleep";
 
+const debug = makeDebug("faktory-worker:worker");
 const START_DELAY = process.env.NODE_ENV === "test" ? 0 : 5;
 
 export type WorkerOptions = {
@@ -23,7 +26,7 @@ export type WorkerOptions = {
   timeout?: number;
   beatInterval?: number;
   queues?: string[];
-  middleware?: MiddlewareFunction[];
+  middleware?: Middleware[];
   registry?: Registry;
   poolSize?: number;
 } & ClientOptions;
@@ -44,16 +47,20 @@ export type WorkerOptions = {
  */
 export default class Worker extends EventEmitter {
   wid: string;
-  concurrency: number;
-  shutdownTimeout: number;
-  beatInterval: number;
+  private concurrency: number;
+  private shutdownTimeout: number;
+  private beatInterval: number;
   queues: string[];
-  middleware: MiddlewareFunction[];
-  registry: Registry;
-  processors: {
-    [name: string]: Promise<any>;
+  private middleware: Middleware[];
+  private registry: Registry;
+  private quieted: boolean | undefined;
+  private processors: {
+    [name: string]: Promise<void>;
   };
+  private execute: ComposedMiddleware<MiddlewareContext>;
+  private heartbeat: NodeJS.Timer;
   client: Client;
+
   /**
    * @param {object} [options]
    * @param  {String} [options.wid=uuid().slice(0, 8)]: the wid the worker will use
@@ -95,11 +102,7 @@ export default class Worker extends EventEmitter {
     });
   }
 
-  /**
-   * @private
-   * @param  {string} pid
-   */
-  async tick(pid: string): Promise<void> {
+  private async tick(pid: string): Promise<void> {
     if (this.quieted) return;
     try {
       const job = await this.fetch();
@@ -115,7 +118,7 @@ export default class Worker extends EventEmitter {
   /**
    * starts the worker fetch loop and job processing
    *
-   * @return {Worker} self, when working has been stopped by a signal or concurrent
+   * @return self, when working has been stopped by a signal or concurrent
    *                        call to stop or quiet
    * @see  Worker.quiet
    * @see  Worker.stop
@@ -136,7 +139,7 @@ export default class Worker extends EventEmitter {
     return this;
   }
 
-  setTick(pid: string) {
+  private setTick(pid: string): void {
     this.processors[pid] = this.tick(pid);
   }
 
@@ -144,11 +147,20 @@ export default class Worker extends EventEmitter {
     console.error(error);
   }
 
+  /**
+   * registers a job function with the worker
+   *
+   * @param jobtype name of the job
+   * @param fn the job function or job function wrapper
+   */
+  register(jobtype: JobType, fn: JobFunction): Worker {
+    this.registry[jobtype] = fn;
+    return this;
+  }
+
   /**
    * Signals to the worker to discontinue fetching new jobs and allows the worker
    * to continue processing any currently-running jobs
-   *
-   * @return {undefined}
    */
   quiet(): void {
     debug("quiet");
@@ -160,11 +172,10 @@ export default class Worker extends EventEmitter {
    *
    * @return {promise} resolved when worker stops
    */
-  async stop(): Promise<void | undefined> {
+  async stop(): Promise<void> {
     Worker.removeSignalHandlers();
     debug("stop");
     this.quiet();
-    this.stopped = true;
     clearInterval(this.heartbeat);
 
     return new Promise(async (resolve) => {
@@ -192,19 +203,14 @@ export default class Worker extends EventEmitter {
   /**
    * Returns an array of promises, each of which is a processor promise
    * doing work or waiting on fetch.
-   *
-   * @return {array} array of processor promises
    */
-  get inProgress(): Array<Promise<any>> {
+  get inProgress(): Array<Promise<void>> {
     return Object.values(this.processors);
   }
 
   /**
    * Sends a heartbeat for this server and interprets the response state (if present)
    * to quiet or terminate the worker
-   *
-   * @private
-   * @return {undefined}
    */
   async beat(): Promise<void> {
     const response = await this.client.beat();
@@ -227,7 +233,7 @@ export default class Worker extends EventEmitter {
    * @return {JobPayload|null} a job payload from the server or null when there are
    *                             no jobs
    */
-  fetch(): Promise<JobPayload | null> {
+  private fetch(): Promise<JobPayload | null> {
     return this.client.fetch(...this.queues);
   }
 
@@ -239,28 +245,23 @@ export default class Worker extends EventEmitter {
    * @private
    * @return {function} entrypoint function to the middleware stack
    */
-  createExecutor(): (ctx: MiddlewareContext) => {} {
+  private createExecutor(): ComposedMiddleware<MiddlewareContext> {
     const { registry } = this;
     return compose([
       ...this.middleware,
-      function getJobFnFromRegistry(
-        ctx: MiddlewareContext,
-        next: NextFunction
-      ) {
+      function getJobFnFromRegistry(ctx, next) {
         const {
           job: { jobtype },
         } = ctx;
         ctx.fn = registry[jobtype];
-
-        if (!ctx.fn) throw new Error(`No jobtype registered: ${jobtype}`);
-
         return next();
       },
-      async function callJobFn(ctx: MiddlewareContext, next: NextFunction) {
+      async function callJobFn(ctx, next) {
         const {
           fn,
-          job: { args },
+          job: { jobtype, args },
         } = ctx;
+        if (!fn) throw new Error(`No jobtype registered: ${jobtype}`);
         const thunkOrPromise = await fn(...args);
         if (typeof thunkOrPromise === "function") {
           await thunkOrPromise(ctx);
@@ -280,7 +281,7 @@ export default class Worker extends EventEmitter {
    * @param  {JobPayload} job the job payload from the server
    * @return {Promise<string>} 'ack' or 'fail' depending on job handling resu
    */
-  async handle(job: JobPayload): Promise<string> {
+  private async handle(job: JobPayload): Promise<string> {
     const { jid } = job;
     try {
       debug(`executing ${jid}`);
@@ -300,7 +301,7 @@ export default class Worker extends EventEmitter {
   /**
    * @private
    */
-  trapSignals() {
+  private trapSignals(): void {
     // istanbul ignore next
     process
       .once("SIGTERM", () => this.stop())
@@ -308,7 +309,7 @@ export default class Worker extends EventEmitter {
       .once("SIGINT", () => this.stop());
   }
 
-  static removeSignalHandlers() {
+  private static removeSignalHandlers(): void {
     process
       .removeAllListeners("SIGTERM")
       .removeAllListeners("SIGTSTP")
diff --git a/src/wrap-non-errors.ts b/src/wrap-non-errors.ts
index 2a3fb14..88d7ea2 100644
--- a/src/wrap-non-errors.ts
+++ b/src/wrap-non-errors.ts
@@ -4,7 +4,9 @@
  * @return {Error}        an error with a warning about throwing non-errors
  * @private
  */
-export default function wrapNonErrors(object: string | Error | undefined): Error {
+export default function wrapNonErrors(
+  object: string | Error | undefined
+): Error {
   if (object instanceof Error) return object;
   console.warn(`
 Job failed without providing an error.
@@ -13,5 +15,5 @@ Ensure your promise was rejected with an *Error* and not a *String*
 correct:\treject(new Error('message'))
 incorrect:\treject('message')
   `);
-  return new Error(object || 'Job failed with no error or message given');
-};
+  return new Error(object || "Job failed with no error or message given");
+}
diff --git a/tsconfig.json b/tsconfig.json
index 28b545a..211314c 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,8 +1,12 @@
 {
   "compileOnSave": true,
   "compilerOptions": {
+    "declaration": true,
     "rootDir": "./src",
     "outDir": "./lib",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
     "allowJs": true,
     "module": "commonjs",
     "target": "ES6",
@@ -14,8 +18,5 @@
   },
   "include": [
     "src/**/*"
-  ],
-  // "exclude": [
-  //   "src/__tests__"
-  // ]
+  ]
 }