From 67b7508ac31590580eddedd9b6e2168990edfa9a Mon Sep 17 00:00:00 2001
From: chronosis <jayreardon@gmail.com>
Date: Sun, 1 Aug 2021 14:59:51 -0600
Subject: [PATCH] fix: patching type definitions

---
 index.d.ts        | 832 ++++++++++++++++++----------------------------
 package-lock.json |  34 +-
 package.json      |   4 +-
 3 files changed, 352 insertions(+), 518 deletions(-)

diff --git a/index.d.ts b/index.d.ts
index 64f64d3..f2498b6 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -2,15 +2,17 @@ declare module "@outofsync/MemoryCache";
 
 type AnyOrNull = any | null;
 type NumOrNull = number | null;
+type CallbackFn = (err: Error | string, msg: string) => void;
+type StringOrCallback = string | CallbackFn;
 
 export declare class MemoryCacheError extends Error {
   constructor(error: Error | string);
-};
+}
 
 interface MemoryCacheOptions {
   debug: boolean;
   bypassUnsupported: boolean;
-};
+}
 
 declare class MemoryCache extends Event {
   constructor(options?: MemoryCacheOptions);
@@ -19,545 +21,373 @@ declare class MemoryCache extends Event {
   createClient(): MemoryCache;
   quit(): MemoryCache;
   end(): MemoryCache;
-  auth(password: string, callback: function): string;
-  echo(message: string, callback: function): string;
-  ping(message: string, callback: function): string;
-  swapdb(dbIndex1: number, dbIndex2: number, callback: function): string;
-  select(dbIndex: number, callback: function): string;
+  auth(password: StringOrCallback[]): string;
+  echo(message: StringOrCallback[]): string;
+  ping(message: StringOrCallback[]): string;
+  swapdb(dbIndex1: number, dbIndex2: number, callback: CallbackFn): string;
+  select(dbIndex: number, callback: CallbackFn): string;
 
   // Cluster
-  cluster(...params?: any, callback: function): void;
-  readonly(callback: function): void;
-  readwrite(callback: function): void;
+  cluster(...params: StringOrCallback[]): void;
+  readonly(callback: CallbackFn): void;
+  readwrite(callback: CallbackFn): void;
 
   // Geo
-  geoadd(key: string, ...params?: any, callback: function): NumOrNull;
-  geodist(key: string, member1: number, member2: number, ...params?: any, callback: function): string | null;
-  geohash(key: string, ...members?: any, callback: function): string[];
-  geopos(key: string, ...members?: any, callback: function): array<any>;
-  georadius(...members?: any, callback: function): void;
-  georadiusbymember(...members?: any, callback: function): void;
+  geoadd(key: string, ...params: StringOrCallback[]): NumOrNull;
+  geodist(key: string, member1: number, member2: number, ...params: StringOrCallback[]): string | null;
+  geohash(key: string, ...members: StringOrCallback[]): string[];
+  geopos(key: string, ...members: StringOrCallback[]): Array<any>;
+  georadius(...members: StringOrCallback[]): void;
+  georadiusbymember(...members: StringOrCallback[]): void;
 
   // Hash Maps
-  hdel(key: string, ...fields?: string, callback: function): number;
-  hexists(key: string, field: string, callback: function): number;
-  hget(key: string, field: string, callback: function): AnyOrNull;
-  hgetall(key: string, callback: function): any;
-  hincrby(key: string, field: string, value: number, callback: function): number;
-  hincrbyfloat(key: string, field: string, value: number, callback: function): number;
-  hkeys(key: string, callback: function): string[];
-  hlen(key: string, callback: function): number;
-  hmget(key: string, ...fields?: string, callback: function): string[];
-  hmset(key: string, ...params?: any, callback: function): string;
-  hscan(key: string, cursor: any, pattern: any, count: number, callback: function): void;
-  hset(key: string, field: string, value: any, callback: function): number;
-  hsetnx(key: string, field: string, value: any, callback: function): number;
-  hstrlen(key: string, field: string, callback: function): number;
-  hvals(key: string, callback: function): string[];
+  hdel(key: string, ...fields: StringOrCallback[]): number;
+  hexists(key: string, field: StringOrCallback[]): number;
+  hget(key: string, field: StringOrCallback[]): AnyOrNull;
+  hgetall(key: StringOrCallback[]): any;
+  hincrby(key: string, field: string, value: number, callback: CallbackFn): number;
+  hincrbyfloat(key: string, field: string, value: number, callback: CallbackFn): number;
+  hkeys(key: StringOrCallback[]): string[];
+  hlen(key: StringOrCallback[]): number;
+  hmget(key: string, ...fields: StringOrCallback[]): string[];
+  hmset(key: string, ...params: StringOrCallback[]): string;
+  hscan(key: string, cursor: any, pattern: any, count: number, callback: CallbackFn): void;
+  hset(key: string, field: string, value: StringOrCallback[]): number;
+  hsetnx(key: string, field: string, value: StringOrCallback[]): number;
+  hstrlen(key: string, field: StringOrCallback[]): number;
+  hvals(key: StringOrCallback[]): string[];
 
   // HyperLogLog (Unique Lists)
-  pfadd(key: string, ...elements?: any, callback: function): void;
-  pfcount(...keys?: string, callback: function): void;
-  pfmerge(destkey: string, ...srckeys?: sting, callback: function): void;
+  pfadd(key: string, ...elements: StringOrCallback[]): void;
+  pfcount(...keys: StringOrCallback[]): void;
+  pfmerge(destkey: string, ...srckeys: StringOrCallback[]): void;
 
   // Key
-  del(...keys: string, callback: function): number;
-  dump(key: string, callback: function): string;
-  exists(...keys?: string, callback: function): number;
-  expire(key: string, seconds: number, callback: function): number;
-  expireat(key: string, timestamp: number, callback: function): number;
-  keys(pattern: string, callback: function): string[];
-  migrate(...params?: any, callback: function): void;
-  move(key: string, dbIndex: number, callback: function): number;
-  object(subcommand: string, ...params?: any, callback: function): void;
-  persist(key: string, callback: function): number;
-  pexpire(key: string, millisecond: number, callback: function): number;
-  pexpireat(key: string, timestamp: number, callback: function): number;
-  pttl(key: string, callback: function): number;
+  del(...keys: StringOrCallback[]): number;
+  dump(key: StringOrCallback[]): string;
+  exists(...keys: StringOrCallback[]): number;
+  expire(key: string, seconds: number, callback: CallbackFn): number;
+  expireat(key: string, timestamp: number, callback: CallbackFn): number;
+  keys(pattern: StringOrCallback[]): string[];
+  migrate(...params: StringOrCallback[]): void;
+  move(key: string, dbIndex: number, callback: CallbackFn): number;
+  object(subcommand: string, ...params: StringOrCallback[]): void;
+  persist(key: StringOrCallback[]): number;
+  pexpire(key: string, millisecond: number, callback: CallbackFn): number;
+  pexpireat(key: string, timestamp: number, callback: CallbackFn): number;
+  pttl(key: StringOrCallback[]): number;
   randomkey(callback): string;
-  rename(key: string, newkey: string, callback: function): string;
-  renamenx(key: string, newkey: string, callback: function): string;
-  restore(key: string, ttl: number, value: any, replace: boolean, callback: function): string;
-  scan(cursor: any, pattern: string, count: number, callback: function): void;
-  sort(key: string, ...params?: any, callback: function): void;
-  touch(...keys?: string, callback: function): number;
-  ttl(key: string, callback: functions): number;
-  type(key: string, callback: function): string;
-  unlink(...keys?: string, callback: function): number;
-  wait(numslaves: number, timeout: number, callback: function): void;
+  rename(key: string, newkey: StringOrCallback[]): string;
+  renamenx(key: string, newkey: StringOrCallback[]): string;
+  restore(key: string, ttl: number, value: any, replace: boolean, callback: CallbackFn): string;
+  scan(cursor: any, pattern: string, count: number, callback: CallbackFn): void;
+  sort(key: string, ...params: StringOrCallback[]): void;
+  touch(...keys: StringOrCallback[]): number;
+  ttl(key: StringOrCallback[]): number;
+  // @ts-ignore
+  type(key: StringOrCallback[]): string;
+  unlink(...keys: StringOrCallback[]): number;
+  wait(numslaves: number, timeout: number, callback: CallbackFn): void;
 
   // Lists (Array / Queue / Stack)
-  blpop(...params?: any, callback: function): void
-  bepop(...params?: any, callback: function): void
-  bepoplpush(...params?: any, callback: function): void
+  blpop(...params: StringOrCallback[]): void
+  bepop(...params: StringOrCallback[]): void
+  bepoplpush(...params: StringOrCallback[]): void
 
-  lindex(key: string, index: number, callback: function): AnyOrNull;
-  linsert(key: string, before?: boolean | string, pivot: number, value: any, callback: function): number;
-  llen(key: string, callback: function): number;
-  lpop(key: string, callback: function): AnyOrNull;
-  lpush(key: string, value: any, callback: function): number;
-  lpushx(key: string, value: any, callback: function): number;
-  lrange(key: string, start: number, stop: number, callback: function): array<any>;
-  lrem(key: string, count: number, value: any, callback: function): number;
-  lset(key: string, index: number, value: any, callback: function): string;
-  ltrim(key: string, start: number, stop: number, callback: function): array<any>;
+  lindex(key: string, index: number, callback: CallbackFn): AnyOrNull;
+  linsert(key: string, before: boolean | string, pivot: number, value: StringOrCallback[]): number;
+  llen(key: StringOrCallback[]): number;
+  lpop(key: StringOrCallback[]): AnyOrNull;
+  lpush(key: string, value: StringOrCallback[]): number;
+  lpushx(key: string, value: StringOrCallback[]): number;
+  lrange(key: string, start: number, stop: number, callback: CallbackFn): Array<any>;
+  lrem(key: string, count: number, value: StringOrCallback[]): number;
+  lset(key: string, index: number, value: StringOrCallback[]): string;
+  ltrim(key: string, start: number, stop: number, callback: CallbackFn): Array<any>;
 
-  rpop(key: string, callback: function): AnyOrNull;
-  rpoplpush(sourcekey: string, destkey: string, callback: function): AnyOrNull;
-  rpush(key: string, value: any, callback: function): number;
-  rpushx(key: string, value: any, callback: function): number;
+  rpop(key: StringOrCallback[]): AnyOrNull;
+  rpoplpush(sourcekey: string, destkey: StringOrCallback[]): AnyOrNull;
+  rpush(key: string, value: StringOrCallback[]): number;
+  rpushx(key: string, value: StringOrCallback[]): number;
 
   // Pub/Sub
-  psubscribe(...params?: any, callback: function): void;
-  pubsub(...params?: any, callback: function): void;
-  publish(...params?: any, callback: function): void;
-  punsubscribe(...params?: any, callback: function): void;
-  subscribe(...params?: any, callback: function): void;
-  unsubscribe(...params?: any, callback: function): void;
+  psubscribe(...params: StringOrCallback[]): void;
+  pubsub(...params: StringOrCallback[]): void;
+  publish(...params: StringOrCallback[]): void;
+  punsubscribe(...params: StringOrCallback[]): void;
+  subscribe(...params: StringOrCallback[]): void;
+  unsubscribe(...params: StringOrCallback[]): void;
 
   // Scripting
-  eval(...params?: any, callback: function): void;
-  evalsha(...params?: any, callback: function): void;
-  script(...params?: any, callback: function): void;
+  eval(...params: StringOrCallback[]): void;
+  evalsha(...params: StringOrCallback[]): void;
+  script(...params: StringOrCallback[]): void;
 
   // Server
-  bgrewriteaof(callback: function): void;
-  bgsave(callback: function): string;
-  client(...params?: any, callback: function): void;
-  command(...params?: any, callback: function): void;
-  config(...params?: any, callback: function): void;
-  dbsize(callback: function): number;
-  debug(command: string, ...params?: any, callback: function): void;
-  flushall(...params?: any, callback: function): string;
-  flushdb(callback: function): string;
-  info(section: any, callback: function): string;
-  lastsave(callback: function): number;
-  monitor(callback: function): void;
-  role(callback: function): array<any>;
-  save(callback: function): string;
-  shutdown(callback: function): void;
+  bgrewriteaof(callback: CallbackFn): void;
+  bgsave(callback: CallbackFn): string;
+  client(...params: StringOrCallback[]): void;
+  command(...params: StringOrCallback[]): void;
+  config(...params: StringOrCallback[]): void;
+  dbsize(callback: CallbackFn): number;
+  debug(command: string, ...params: StringOrCallback[]): void;
+  flushall(...params: StringOrCallback[]): string;
+  flushdb(callback: CallbackFn): string;
+  info(section: StringOrCallback[]): string;
+  lastsave(callback: CallbackFn): number;
+  monitor(callback: CallbackFn): void;
+  role(callback: CallbackFn): Array<any>;
+  save(callback: CallbackFn): string;
+  shutdown(callback: CallbackFn): void;
   slaveof(host: string, port: number): void;
   slowlog(command: string, param: any): void;
-  sync(callback: function): void;
-  time(callback: function): number;
+  sync(callback: CallbackFn): void;
+  time(callback: CallbackFn): number;
 
   // Sets
-  sadd(key: string, ...members?: any, callback: function): number;
-  scard(key: string, callback: function): number;
-  sdiff(key: string, ...keys?: string, callback: function): number;
-  sdiffstore(destkey: string, key: string, ...keys: string, callback: function): number;
-  sinter(key: string, ...keys: string, callback: function): number;
-  sinterstore(destkey: string, key: string, ...keys: string, callback: function): number;
-  sismember(key: string, member: string, callback: function): number;
-  smembers(key: string, callback: function): string[];
+  sadd(key: string, ...members: StringOrCallback[]): number;
+  scard(key: StringOrCallback[]): number;
+  sdiff(key: string, ...keys: StringOrCallback[]): number;
+  sdiffstore(destkey: string, key: string, ...keys: StringOrCallback[]): number;
+  sinter(key: string, ...keys: StringOrCallback[]): number;
+  sinterstore(destkey: string, key: string, ...keys: StringOrCallback[]): number;
+  sismember(key: string, member: StringOrCallback[]): number;
+  smembers(key: StringOrCallback[]): string[];
   smove(sourcekey: string, destkey: string, member: string, callback): number;
-  spop(key: string, count: number, callback: function): string[];
-  srandmember(key: string, count: number, callback: function): string[];
-  srem(key: string, ...members: string, callback: function): number;
-  sscan(...params?: any, callback: function): void;
-  sunion(key: string,...keys: string, callback: function): number;
-  sunionstore(destkey: string, key: string, ...keys: string, callback: function): number;
+  spop(key: string, count: number, callback: CallbackFn): string[];
+  srandmember(key: string, count: number, callback: CallbackFn): string[];
+  srem(key: string, ...members: StringOrCallback[]): number;
+  sscan(...params: StringOrCallback[]): void;
+  sunion(key: string,...keys: StringOrCallback[]): number;
+  sunionstore(destkey: string, key: string, ...keys: StringOrCallback[]): number;
 
   // Sorted Sets
-  zadd(key: string, ...params: any, callback: function): number;
-  zcard(key: string, callback: function): number;
-  zcount(key: string, min: string, max: string, callback: function): number;
-  zincrby(key: string, increment: number, member: string, callback: function): number;
-  zinterstore(...params: any, callback: function): void;
-  zlexcount(key: string, min: string, max: string, callback: function): number;
-  zrange(key: string, start: number, stop: number, ...params: any, callback: function): string[];
-  zrangebylex(key: string, min: number, max: number, ...params: any, callback: function): string[];
-  zrangebyscore(key: string, min: number, max: number, ...params: any, callback: function): string[];
-  zrank(key: string, member: number, callback: function): NumOrNull;
-  zrem(key: string, ...members: string, callback: function): number;
-  zremrangebylex(key: string, min: string, max: string, callback: function): number;
-  zremrangebyrank(key: string, start: number, stop: number, callback: function): number;
-  zremrangebyscore(key: string, min: number, max: number, callback: function): number;
-  zrevrange(key: string, start: number, stop: number, ...params: any, callback: function): string[];
-  zrevrangebylex(key: string, max: string, min: string, ...params: any, callback: function): string[];
-  zrevrangebyscore(key: string, member: string, callback: function): string[];
-  zrevrank(key: string, member: string, callback: function): NumOrNull;
-  zscore(key: string, member: string, callback: function): string;
-  zunionstore(...params: any, callback: function): void;
-  zscan(...params: any, callback: function): void;
+  zadd(key: string, ...params: StringOrCallback[]): number;
+  zcard(key: StringOrCallback[]): number;
+  zcount(key: string, min: string, max: StringOrCallback[]): number;
+  zincrby(key: string, increment: number, member: StringOrCallback[]): number;
+  zinterstore(...params: StringOrCallback[]): void;
+  zlexcount(key: string, min: string, max: StringOrCallback[]): number;
+  zrange(key: string, start: number, stop: number, ...params: StringOrCallback[]): string[];
+  zrangebylex(key: string, min: number, max: number, ...params: StringOrCallback[]): string[];
+  zrangebyscore(key: string, min: number, max: number, ...params: StringOrCallback[]): string[];
+  zrank(key: string, member: number, callback: CallbackFn): NumOrNull;
+  zrem(key: string, ...members: StringOrCallback[]): number;
+  zremrangebylex(key: string, min: string, max: StringOrCallback[]): number;
+  zremrangebyrank(key: string, start: number, stop: number, callback: CallbackFn): number;
+  zremrangebyscore(key: string, min: number, max: number, callback: CallbackFn): number;
+  zrevrange(key: string, start: number, stop: number, ...params: StringOrCallback[]): string[];
+  zrevrangebylex(key: string, max: string, min: string, ...params: StringOrCallback[]): string[];
+  zrevrangebyscore(key: string, member: StringOrCallback[]): string[];
+  zrevrank(key: string, member: StringOrCallback[]): NumOrNull;
+  zscore(key: string, member: StringOrCallback[]): string;
+  zunionstore(...params: StringOrCallback[]): void;
+  zscan(...params: StringOrCallback[]): void;
 
   // Strings
-  append(key: string, value: string, callback: function): number;
-  bitcount(key: string, ...params: any, callback: function): number;
-  bitfield(...params: any, callback: function): void;
-  bitop(operation: string, destkey: string, ...srckeys: string, callback: function): number;
-  bitpos(key: string, bit: number, start: number, end: number, callback: function): void;
-  decr(key: string, callback: function): number;
-  decrby(key: string, amount: number, callback: function): number;
-  get(key: string, callback: function): string;
-  getbit(key: string, offset: number, callback: function): number;
-  getrange(key: string, start: number, end: number, callback: function): string;
-  getset(key: string, value: string, callback: function): string;
-  incr(key: string, callback: function): number;
-  incrby(key: string, amount: number, callback: function): number;
-  incrbyfloat(key: string, amount: number, callback: function): number;
-  mget(...keys: string, callback: function): string[];
-  mset(...params: string, callback: function): number;
-  msetnx(...params: string, callback: function): number;
-  psetex(key: string, pttl: number, value: string, callback: function): string;
-  set(key: string, value: string, ...params: any, callback: function): string;
-  setbit(key: string, offset: number, value: number, callback: function): number;
-  setex(key: string, ttl: number, value: string, callback: function): number;
-  setnx(key: string, value: string, callback: function): number;
-  setrange(key: string, offset: number, value: string, callback: function): number;
-  strlen(key: string, callback: function): number;
+  append(key: string, value: StringOrCallback[]): number;
+  bitcount(key: string, ...params: StringOrCallback[]): number;
+  bitfield(...params: StringOrCallback[]): void;
+  bitop(operation: string, destkey: string, ...srckeys: StringOrCallback[]): number;
+  bitpos(key: string, bit: number, start: number, end: number, callback: CallbackFn): void;
+  decr(key: StringOrCallback[]): number;
+  decrby(key: string, amount: number, callback: CallbackFn): number;
+  get(key: StringOrCallback[]): string;
+  getbit(key: string, offset: number, callback: CallbackFn): number;
+  getrange(key: string, start: number, end: number, callback: CallbackFn): string;
+  getset(key: string, value: StringOrCallback[]): string;
+  incr(key: StringOrCallback[]): number;
+  incrby(key: string, amount: number, callback: CallbackFn): number;
+  incrbyfloat(key: string, amount: number, callback: CallbackFn): number;
+  mget(...keys: StringOrCallback[]): string[];
+  mset(...params: StringOrCallback[]): number;
+  msetnx(...params: StringOrCallback[]): number;
+  psetex(key: string, pttl: number, value: StringOrCallback[]): string;
+  set(key: string, value: string, ...params: StringOrCallback[]): string;
+  setbit(key: string, offset: number, value: number, callback: CallbackFn): number;
+  setex(key: string, ttl: number, value: StringOrCallback[]): number;
+  setnx(key: string, value: StringOrCallback[]): number;
+  setrange(key: string, offset: number, value: StringOrCallback[]): number;
+  strlen(key: StringOrCallback[]): number;
 
   // Transactions
-  discard(callback: function, silent: boolean): string;
-  exec(callback: function): string;
-  multi(callback: function): string;
-  unwatch(callback: function): void;
-  watch(callback: function): void;
+  discard(callback: CallbackFn, silent: boolean): string;
+  exec(callback: CallbackFn): string;
+  multi(callback: CallbackFn): string;
+  unwatch(callback: CallbackFn): void;
+  watch(callback: CallbackFn): void;
 
   // Async
   createClientAsync(): Promise<MemoryCache>;
   quitAsync(): Promise<MemoryCache>;
   endAsync(): Promise<MemoryCache>;
-  authAsync(password: string, callback: function): Promise<string>;
-  echoAsync(message: string, callback: function): Promise<string>;
-  pingAsync(message: string, callback: function): Promise<string>;
-  swapdbAsync(dbIndex1: number, dbIndex2: number, callback: function): Promise<string>;
-  selectAsync(dbIndex: number, callback: function): Promise<string>;
-  clusterAsync(...params?: any, callback: function): Promise<void>;
-  readonlyAsync(callback: function): Promise<void>;
-  readwriteAsync(callback: function): Promise<void>;
-  geoaddAsync(key: string, ...params?: any, callback: function): Promise<NumOrNull>;
-  geodistAsync(key: string, member1: number, member2: number, ...params?: any, callback: function): Promise<string | null>;
-  geohashAsync(key: string, ...members?: any, callback: function): Promise<string[]>;
-  geoposAsync(key: string, ...members?: any, callback: function): Promise<array<any>>;
-  georadiusAsync(...members?: any, callback: function): Promise<void>;
-  georadiusbymemberAsync(...members?: any, callback: function): Promise<void>;
-  hdelAsync(key: string, ...fields?: string, callback: function): Promise<number>;
-  hexistsAsync(key: string, field: string, callback: function): Promise<number>;
-  hgetAsync(key: string, field: string, callback: function): Promise<AnyOrNull>;
-  hgetallAsync(key: string, callback: function): Promise<any>;
-  hincrbyAsync(key: string, field: string, value: number, callback: function): Promise<number>;
-  hincrbyfloatAsync(key: string, field: string, value: number, callback: function): Promise<number>;
-  hkeysAsync(key: string, callback: function): Promise<string[]>;
-  hlenAsync(key: string, callback: function): Promise<number>;
-  hmgetAsync(key: string, ...fields?: string, callback: function): Promise<string[]>;
-  hmsetAsync(key: string, ...params?: any, callback: function): Promise<string>;
-  hscanAsync(key: string, cursor: any, pattern: any, count: number, callback: function): Promise<void>;
-  hsetAsync(key: string, field: string, value: any, callback: function): Promise<number>;
-  hsetnxAsync(key: string, field: string, value: any, callback: function): Promise<number>;
-  hstrlenAsync(key: string, field: string, callback: function): Promise<number>;
-  hvalsAsync(key: string, callback: function): Promise<string[]>;
-  pfaddAsync(key: string, ...elements?: any, callback: function): Promise<void>;
-  pfcountAsync(...keys?: string, callback: function): Promise<void>;
-  pfmergeAsync(destkey: string, ...srckeys?: sting, callback: function): Promise<void>;
-  delAsync(...keys: string, callback: function): Promise<number>;
-  dumpAsync(key: string, callback: function): Promise<string>;
-  existsAsync(...keys?: string, callback: function): Promise<number>;
-  expireAsync(key: string, seconds: number, callback: function): Promise<number>;
-  expireatAsync(key: string, timestamp: number, callback: function): Promise<number>;
-  keysAsync(pattern: string, callback: function): Promise<string[]>;
-  migrateAsync(...params?: any, callback: function): Promise<void>;
-  moveAsync(key: string, dbIndex: number, callback: function): Promise<number>;
-  objectAsync(subcommand: string, ...params?: any, callback: function): Promise<void>;
-  persistAsync(key: string, callback: function): Promise<number>;
-  pexpireAsync(key: string, millisecond: number, callback: function): Promise<number>;
-  pexpireatAsync(key: string, timestamp: number, callback: function): Promise<number>;
-  pttlAsync(key: string, callback: function): Promise<number>;
+  authAsync(password: StringOrCallback[]): Promise<string>;
+  echoAsync(message: StringOrCallback[]): Promise<string>;
+  pingAsync(message: StringOrCallback[]): Promise<string>;
+  swapdbAsync(dbIndex1: number, dbIndex2: number, callback: CallbackFn): Promise<string>;
+  selectAsync(dbIndex: number, callback: CallbackFn): Promise<string>;
+  clusterAsync(...params: StringOrCallback[]): Promise<void>;
+  readonlyAsync(callback: CallbackFn): Promise<void>;
+  readwriteAsync(callback: CallbackFn): Promise<void>;
+  geoaddAsync(key: string, ...params: StringOrCallback[]): Promise<NumOrNull>;
+  geodistAsync(key: string, member1: number, member2: number, ...params: StringOrCallback[]): Promise<string | null>;
+  geohashAsync(key: string, ...members: StringOrCallback[]): Promise<string[]>;
+  geoposAsync(key: string, ...members: StringOrCallback[]): Promise<Array<any>>;
+  georadiusAsync(...members: StringOrCallback[]): Promise<void>;
+  georadiusbymemberAsync(...members: StringOrCallback[]): Promise<void>;
+  hdelAsync(key: string, ...fields: StringOrCallback[]): Promise<number>;
+  hexistsAsync(key: string, field: StringOrCallback[]): Promise<number>;
+  hgetAsync(key: string, field: StringOrCallback[]): Promise<AnyOrNull>;
+  hgetallAsync(key: StringOrCallback[]): Promise<any>;
+  hincrbyAsync(key: string, field: string, value: number, callback: CallbackFn): Promise<number>;
+  hincrbyfloatAsync(key: string, field: string, value: number, callback: CallbackFn): Promise<number>;
+  hkeysAsync(key: StringOrCallback[]): Promise<string[]>;
+  hlenAsync(key: StringOrCallback[]): Promise<number>;
+  hmgetAsync(key: string, ...fields: StringOrCallback[]): Promise<string[]>;
+  hmsetAsync(key: string, ...params: StringOrCallback[]): Promise<string>;
+  hscanAsync(key: string, cursor: any, pattern: any, count: number, callback: CallbackFn): Promise<void>;
+  hsetAsync(key: string, field: string, value: StringOrCallback[]): Promise<number>;
+  hsetnxAsync(key: string, field: string, value: StringOrCallback[]): Promise<number>;
+  hstrlenAsync(key: string, field: StringOrCallback[]): Promise<number>;
+  hvalsAsync(key: StringOrCallback[]): Promise<string[]>;
+  pfaddAsync(key: string, ...elements: StringOrCallback[]): Promise<void>;
+  pfcountAsync(...keys: StringOrCallback[]): Promise<void>;
+  pfmergeAsync(destkey: string, ...srckeys: StringOrCallback[]): Promise<void>;
+  delAsync(...keys: StringOrCallback[]): Promise<number>;
+  dumpAsync(key: StringOrCallback[]): Promise<string>;
+  existsAsync(...keys: StringOrCallback[]): Promise<number>;
+  expireAsync(key: string, seconds: number, callback: CallbackFn): Promise<number>;
+  expireatAsync(key: string, timestamp: number, callback: CallbackFn): Promise<number>;
+  keysAsync(pattern: StringOrCallback[]): Promise<string[]>;
+  migrateAsync(...params: StringOrCallback[]): Promise<void>;
+  moveAsync(key: string, dbIndex: number, callback: CallbackFn): Promise<number>;
+  objectAsync(subcommand: string, ...params: StringOrCallback[]): Promise<void>;
+  persistAsync(key: StringOrCallback[]): Promise<number>;
+  pexpireAsync(key: string, millisecond: number, callback: CallbackFn): Promise<number>;
+  pexpireatAsync(key: string, timestamp: number, callback: CallbackFn): Promise<number>;
+  pttlAsync(key: StringOrCallback[]): Promise<number>;
   randomkeyAsync(callback): Promise<string>;
-  renameAsync(key: string, newkey: string, callback: function): Promise<string>;
-  renamenxAsync(key: string, newkey: string, callback: function): Promise<string>;
-  restoreAsync(key: string, ttl: number, value: any, replace: boolean, callback: function): Promise<string>;
-  scanAsync(cursor: any, pattern: string, count: number, callback: function): Promise<void>;
-  sortAsync(key: string, ...params?: any, callback: function): Promise<void>;
-  touchAsync(...keys?: string, callback: function): Promise<number>;
-  ttlAsync(key: string, callback: functions): Promise<number>;
-  typeAsync(key: string, callback: function): Promise<string>;
-  unlinkAsync(...keys?: string, callback: function): Promise<number>;
-  waitAsync(numslaves: number, timeout: number, callback: function): Promise<void>;
-  blpopAsync(...params?: any, callback: function): Promise<void>;
-  bepopAsync(...params?: any, callback: function): Promise<void>;
-  bepoplpushAsync(...params?: any, callback: function): Promise<void>;
-  lindexAsync(key: string, index: number, callback: function): Promise<AnyOrNull>;
-  linsertAsync(key: string, before?: boolean | string, pivot: number, value: any, callback: function): Promise<number>;
-  llenAsync(key: string, callback: function): Promise<number>;
-  lpopAsync(key: string, callback: function): Promise<AnyOrNull>;
-  lpushAsync(key: string, value: any, callback: function): Promise<number>;
-  lpushxAsync(key: string, value: any, callback: function): Promise<number>;
-  lrangeAsync(key: string, start: number, stop: number, callback: function): Promise<array<any>>;
-  lremAsync(key: string, count: number, value: any, callback: function): Promise<number>;
-  lsetAsync(key: string, index: number, value: any, callback: function): Promise<string>;
-  ltrimAsync(key: string, start: number, stop: number, callback: function): Promise<array<any>>;
-  rpopAsync(key: string, callback: function): Promise<AnyOrNull>;
-  rpoplpushAsync(sourcekey: string, destkey: string, callback: function): Promise<AnyOrNull>;
-  rpushAsync(key: string, value: any, callback: function): Promise<number>;
-  rpushxAsync(key: string, value: any, callback: function): Promise<number>;
-  psubscribeAsync(...params?: any, callback: function): Promise<void>;
-  pubsubAsync(...params?: any, callback: function): Promise<void>;
-  publishAsync(...params?: any, callback: function): Promise<void>;
-  punsubscribeAsync(...params?: any, callback: function): Promise<void>;
-  subscribeAsync(...params?: any, callback: function): Promise<void>;
-  unsubscribeAsync(...params?: any, callback: function): Promise<void>;
-  evalAsync(...params?: any, callback: function): Promise<void>;
-  evalshaAsync(...params?: any, callback: function): Promise<void>;
-  scriptAsync(...params?: any, callback: function): Promise<void>;
-  bgrewriteaofAsync(callback: function): Promise<void>;
-  bgsaveAsync(callback: function): Promise<string>;
-  clientAsync(...params?: any, callback: function): Promise<void>;
-  commandAsync(...params?: any, callback: function): Promise<void>;
-  configAsync(...params?: any, callback: function): Promise<void>;
-  dbsizeAsync(callback: function): Promise<number>;
-  debugAsync(command: string, ...params?: any, callback: function): Promise<void>;
-  flushallAsync(...params?: any, callback: function): Promise<string>;
-  flushdbAsync(callback: function): Promise<string>;
-  infoAsync(section: any, callback: function): Promise<string>;
-  lastsaveAsync(callback: function): Promise<number>;
-  monitorAsync(callback: function): Promise<void>;
-  roleAsync(callback: function): Promise<array<any>>;
-  saveAsync(callback: function): Promise<string>;
-  shutdownAsync(callback: function): Promise<void>;
+  renameAsync(key: string, newkey: StringOrCallback[]): Promise<string>;
+  renamenxAsync(key: string, newkey: StringOrCallback[]): Promise<string>;
+  restoreAsync(key: string, ttl: number, value: any, replace: boolean, callback: CallbackFn): Promise<string>;
+  scanAsync(cursor: any, pattern: string, count: number, callback: CallbackFn): Promise<void>;
+  sortAsync(key: string, ...params: StringOrCallback[]): Promise<void>;
+  touchAsync(...keys: StringOrCallback[]): Promise<number>;
+  ttlAsync(key: StringOrCallback[]): Promise<number>;
+  typeAsync(key: StringOrCallback[]): Promise<string>;
+  unlinkAsync(...keys: StringOrCallback[]): Promise<number>;
+  waitAsync(numslaves: number, timeout: number, callback: CallbackFn): Promise<void>;
+  blpopAsync(...params: StringOrCallback[]): Promise<void>;
+  bepopAsync(...params: StringOrCallback[]): Promise<void>;
+  bepoplpushAsync(...params: StringOrCallback[]): Promise<void>;
+  lindexAsync(key: string, index: number, callback: CallbackFn): Promise<AnyOrNull>;
+  linsertAsync(key: string, before: boolean | string, pivot: number, value: StringOrCallback[]): Promise<number>;
+  llenAsync(key: StringOrCallback[]): Promise<number>;
+  lpopAsync(key: StringOrCallback[]): Promise<AnyOrNull>;
+  lpushAsync(key: string, value: StringOrCallback[]): Promise<number>;
+  lpushxAsync(key: string, value: StringOrCallback[]): Promise<number>;
+  lrangeAsync(key: string, start: number, stop: number, callback: CallbackFn): Promise<Array<any>>;
+  lremAsync(key: string, count: number, value: StringOrCallback[]): Promise<number>;
+  lsetAsync(key: string, index: number, value: StringOrCallback[]): Promise<string>;
+  ltrimAsync(key: string, start: number, stop: number, callback: CallbackFn): Promise<Array<any>>;
+  rpopAsync(key: StringOrCallback[]): Promise<AnyOrNull>;
+  rpoplpushAsync(sourcekey: string, destkey: StringOrCallback[]): Promise<AnyOrNull>;
+  rpushAsync(key: string, value: StringOrCallback[]): Promise<number>;
+  rpushxAsync(key: string, value: StringOrCallback[]): Promise<number>;
+  psubscribeAsync(...params: StringOrCallback[]): Promise<void>;
+  pubsubAsync(...params: StringOrCallback[]): Promise<void>;
+  publishAsync(...params: StringOrCallback[]): Promise<void>;
+  punsubscribeAsync(...params: StringOrCallback[]): Promise<void>;
+  subscribeAsync(...params: StringOrCallback[]): Promise<void>;
+  unsubscribeAsync(...params: StringOrCallback[]): Promise<void>;
+  evalAsync(...params: StringOrCallback[]): Promise<void>;
+  evalshaAsync(...params: StringOrCallback[]): Promise<void>;
+  scriptAsync(...params: StringOrCallback[]): Promise<void>;
+  bgrewriteaofAsync(callback: CallbackFn): Promise<void>;
+  bgsaveAsync(callback: CallbackFn): Promise<string>;
+  clientAsync(...params: StringOrCallback[]): Promise<void>;
+  commandAsync(...params: StringOrCallback[]): Promise<void>;
+  configAsync(...params: StringOrCallback[]): Promise<void>;
+  dbsizeAsync(callback: CallbackFn): Promise<number>;
+  debugAsync(command: string, ...params: StringOrCallback[]): Promise<void>;
+  flushallAsync(...params: StringOrCallback[]): Promise<string>;
+  flushdbAsync(callback: CallbackFn): Promise<string>;
+  infoAsync(section: StringOrCallback[]): Promise<string>;
+  lastsaveAsync(callback: CallbackFn): Promise<number>;
+  monitorAsync(callback: CallbackFn): Promise<void>;
+  roleAsync(callback: CallbackFn): Promise<Array<any>>;
+  saveAsync(callback: CallbackFn): Promise<string>;
+  shutdownAsync(callback: CallbackFn): Promise<void>;
   slaveofAsync(host: string, port: number): Promise<void>;
   slowlogAsync(command: string, param: any): Promise<void>;
-  syncAsync(callback: function): Promise<void>;
-  timeAsync(callback: function): Promise<number>;
-  saddAsync(key: string, ...members?: any, callback: function): Promise<number>;
-  scardAsync(key: string, callback: function): Promise<number>;
-  sdiffAsync(key: string, ...keys?: string, callback: function): Promise<number>;
-  sdiffstoreAsync(destkey: string, key: string, ...keys: string, callback: function): Promise<number>;
-  sinterAsync(key: string, ...keys: string, callback: function): Promise<number>;
-  sinterstoreAsync(destkey: string, key: string, ...keys: string, callback: function): Promise<number>;
-  sismemberAsync(key: string, member: string, callback: function): Promise<number>;
-  smembersAsync(key: string, callback: function): Promise<string[]>;
+  syncAsync(callback: CallbackFn): Promise<void>;
+  timeAsync(callback: CallbackFn): Promise<number>;
+  saddAsync(key: string, ...members: StringOrCallback[]): Promise<number>;
+  scardAsync(key: StringOrCallback[]): Promise<number>;
+  sdiffAsync(key: string, ...keys: StringOrCallback[]): Promise<number>;
+  sdiffstoreAsync(destkey: string, key: string, ...keys: StringOrCallback[]): Promise<number>;
+  sinterAsync(key: string, ...keys: StringOrCallback[]): Promise<number>;
+  sinterstoreAsync(destkey: string, key: string, ...keys: StringOrCallback[]): Promise<number>;
+  sismemberAsync(key: string, member: StringOrCallback[]): Promise<number>;
+  smembersAsync(key: StringOrCallback[]): Promise<string[]>;
   smoveAsync(sourcekey: string, destkey: string, member: string, callback): Promise<number>;
-  spopAsync(key: string, count: number, callback: function): Promise<string[]>;
-  srandmemberAsync(key: string, count: number, callback: function): Promise<string[]>;
-  sremAsync(key: string, ...members: string, callback: function): Promise<number>;
-  sscanAsync(...params?: any, callback: function): Promise<void>;
-  sunionAsync(key: string,...keys: string, callback: function): Promise<number>;
-  sunionstoreAsync(destkey: string, key: string, ...keys: string, callback: function): Promise<number>;
-  zaddAsync(key: string, ...params: any, callback: function): Promise<number>;
-  zcardAsync(key: string, callback: function): Promise<number>;
-  zcountAsync(key: string, min: string, max: string, callback: function): Promise<number>;
-  zincrbyAsync(key: string, increment: number, member: string, callback: function): Promise<number>;
-  zinterstoreAsync(...params: any, callback: function): Promise<void>;
-  zlexcountAsync(key: string, min: string, max: string, callback: function): Promise<number>;
-  zrangeAsync(key: string, start: number, stop: number, ...params: any, callback: function): Promise<string[]>;
-  zrangebylexAsync(key: string, min: number, max: number, ...params: any, callback: function): Promise<string[]>;
-  zrangebyscoreAsync(key: string, min: number, max: number, ...params: any, callback: function): Promise<string[]>;
-  zrankAsync(key: string, member: number, callback: function): Promise<NumOrNull>;
-  zremAsync(key: string, ...members: string, callback: function): Promise<number>;
-  zremrangebylexAsync(key: string, min: string, max: string, callback: function): Promise<number>;
-  zremrangebyrankAsync(key: string, start: number, stop: number, callback: function): Promise<number>;
-  zremrangebyscoreAsync(key: string, min: number, max: number, callback: function): Promise<number>;
-  zrevrangeAsync(key: string, start: number, stop: number, ...params: any, callback: function): Promise<string[]>;
-  zrevrangebylexAsync(key: string, max: string, min: string, ...params: any, callback: function): Promise<string[]>;
-  zrevrangebyscoreAsync(key: string, member: string, callback: function): Promise<string[]>;
-  zrevrankAsync(key: string, member: string, callback: function): Promise<NumOrNull>;
-  zscoreAsync(key: string, member: string, callback: function): Promise<string>;
-  zunionstoreAsync(...params: any, callback: function): Promise<void>;
-  zscanAsync(...params: any, callback: function): Promise<void>;
-  appendAsync(key: string, value: string, callback: function): Promise<number>;
-  bitcountAsync(key: string, ...params: any, callback: function): Promise<number>;
-  bitfieldAsync(...params: any, callback: function): Promise<void>;
-  bitopAsync(operation: string, destkey: string, ...srckeys: string, callback: function): Promise<number>;
-  bitposAsync(key: string, bit: number, start: number, end: number, callback: function): Promise<void>;
-  decrAsync(key: string, callback: function): Promise<number>;
-  decrbyAsync(key: string, amount: number, callback: function): Promise<number>;
-  getAsync(key: string, callback: function): Promise<string>;
-  getbitAsync(key: string, offset: number, callback: function): Promise<number>;
-  getrangeAsync(key: string, start: number, end: number, callback: function): Promise<string>;
-  getsetAsync(key: string, value: string, callback: function): Promise<string>;
-  incrAsync(key: string, callback: function): Promise<number>;
-  incrbyAsync(key: string, amount: number, callback: function): Promise<number>;
-  incrbyfloatAsync(key: string, amount: number, callback: function): Promise<number>;
-  mgetAsync(...keys: string, callback: function): Promise<string[]>;
-  msetAsync(...params: string, callback: function): Promise<number>;
-  msetnxAsync(...params: string, callback: function): Promise<number>;
-  psetexAsync(key: string, pttl: number, value: string, callback: function): Promise<string>;
-  setAsync(key: string, value: string, ...params: any, callback: function): Promise<string>;
-  setbitAsync(key: string, offset: number, value: number, callback: function): Promise<number>;
-  setexAsync(key: string, ttl: number, value: string, callback: function): Promise<number>;
-  setnxAsync(key: string, value: string, callback: function): Promise<number>;
-  setrangeAsync(key: string, offset: number, value: string, callback: function): Promise<number>;
-  strlenAsync(key: string, callback: function): Promise<number>;
-  discardAsync(callback: function, silent: boolean): Promise<string>;
-  execAsync(callback: function): Promise<string>;
-  multiAsync(callback: function): Promise<string>;
-  unwatchAsync(callback: function): Promise<void>;
-  watchAsync(callback: function): Promise<void>;
+  spopAsync(key: string, count: number, callback: CallbackFn): Promise<string[]>;
+  srandmemberAsync(key: string, count: number, callback: CallbackFn): Promise<string[]>;
+  sremAsync(key: string, ...members: StringOrCallback[]): Promise<number>;
+  sscanAsync(...params: StringOrCallback[]): Promise<void>;
+  sunionAsync(key: string,...keys: StringOrCallback[]): Promise<number>;
+  sunionstoreAsync(destkey: string, key: string, ...keys: StringOrCallback[]): Promise<number>;
+  zaddAsync(key: string, ...params: StringOrCallback[]): Promise<number>;
+  zcardAsync(key: StringOrCallback[]): Promise<number>;
+  zcountAsync(key: string, min: string, max: StringOrCallback[]): Promise<number>;
+  zincrbyAsync(key: string, increment: number, member: StringOrCallback[]): Promise<number>;
+  zinterstoreAsync(...params: StringOrCallback[]): Promise<void>;
+  zlexcountAsync(key: string, min: string, max: StringOrCallback[]): Promise<number>;
+  zrangeAsync(key: string, start: number, stop: number, ...params: StringOrCallback[]): Promise<string[]>;
+  zrangebylexAsync(key: string, min: number, max: number, ...params: StringOrCallback[]): Promise<string[]>;
+  zrangebyscoreAsync(key: string, min: number, max: number, ...params: StringOrCallback[]): Promise<string[]>;
+  zrankAsync(key: string, member: number, callback: CallbackFn): Promise<NumOrNull>;
+  zremAsync(key: string, ...members: StringOrCallback[]): Promise<number>;
+  zremrangebylexAsync(key: string, min: string, max: StringOrCallback[]): Promise<number>;
+  zremrangebyrankAsync(key: string, start: number, stop: number, callback: CallbackFn): Promise<number>;
+  zremrangebyscoreAsync(key: string, min: number, max: number, callback: CallbackFn): Promise<number>;
+  zrevrangeAsync(key: string, start: number, stop: number, ...params: StringOrCallback[]): Promise<string[]>;
+  zrevrangebylexAsync(key: string, max: string, min: string, ...params: StringOrCallback[]): Promise<string[]>;
+  zrevrangebyscoreAsync(key: string, member: StringOrCallback[]): Promise<string[]>;
+  zrevrankAsync(key: string, member: StringOrCallback[]): Promise<NumOrNull>;
+  zscoreAsync(key: string, member: StringOrCallback[]): Promise<string>;
+  zunionstoreAsync(...params: StringOrCallback[]): Promise<void>;
+  zscanAsync(...params: StringOrCallback[]): Promise<void>;
+  appendAsync(key: string, value: StringOrCallback[]): Promise<number>;
+  bitcountAsync(key: string, ...params: StringOrCallback[]): Promise<number>;
+  bitfieldAsync(...params: StringOrCallback[]): Promise<void>;
+  bitopAsync(operation: string, destkey: string, ...srckeys: StringOrCallback[]): Promise<number>;
+  bitposAsync(key: string, bit: number, start: number, end: number, callback: CallbackFn): Promise<void>;
+  decrAsync(key: StringOrCallback[]): Promise<number>;
+  decrbyAsync(key: string, amount: number, callback: CallbackFn): Promise<number>;
+  getAsync(key: StringOrCallback[]): Promise<string>;
+  getbitAsync(key: string, offset: number, callback: CallbackFn): Promise<number>;
+  getrangeAsync(key: string, start: number, end: number, callback: CallbackFn): Promise<string>;
+  getsetAsync(key: string, value: StringOrCallback[]): Promise<string>;
+  incrAsync(key: StringOrCallback[]): Promise<number>;
+  incrbyAsync(key: string, amount: number, callback: CallbackFn): Promise<number>;
+  incrbyfloatAsync(key: string, amount: number, callback: CallbackFn): Promise<number>;
+  mgetAsync(...keys: StringOrCallback[]): Promise<string[]>;
+  msetAsync(...params: StringOrCallback[]): Promise<number>;
+  msetnxAsync(...params: StringOrCallback[]): Promise<number>;
+  psetexAsync(key: string, pttl: number, value: StringOrCallback[]): Promise<string>;
+  setAsync(key: string, value: string, ...params: StringOrCallback[]): Promise<string>;
+  setbitAsync(key: string, offset: number, value: number, callback: CallbackFn): Promise<number>;
+  setexAsync(key: string, ttl: number, value: StringOrCallback[]): Promise<number>;
+  setnxAsync(key: string, value: StringOrCallback[]): Promise<number>;
+  setrangeAsync(key: string, offset: number, value: StringOrCallback[]): Promise<number>;
+  strlenAsync(key: StringOrCallback[]): Promise<number>;
+  discardAsync(callback: CallbackFn, silent: boolean): Promise<string>;
+  execAsync(callback: CallbackFn): Promise<string>;
+  multiAsync(callback: CallbackFn): Promise<string>;
+  unwatchAsync(callback: CallbackFn): Promise<void>;
+  watchAsync(callback: CallbackFn): Promise<void>;
+}
 
-  // UPPER
-  CREATECLIENT = this.createClient;
-  QUIT = this.quit;
-  END = this.end;
-  AUTH = this.auth;
-  ECHO = this.echo;
-  PING = this.ping;
-  SWAPDB = this.swapdb;
-  SELECT = this.select;
-  CLUSTER = this.cluster;
-  READONLY = this.readonly;
-  READWRITE = this.readwrite;
-  GEOADD = this.geoadd;
-  GEODIST = this.geodist;
-  GEOHASH = this.geohash;
-  GEOPOS = this.geopos;
-  GEORADIUS = this.georadius;
-  GEORADIUSBYMEMBER = this.georadiusbymember;
-  HDEL = this.hdel;
-  HEXISTS = this.hexists;
-  HGET = this.hget;
-  HGETALL = this.hgetall;
-  HINCRBY = this.hincrby;
-  HINCRBYFLOAT = this.hincrbyfloat;
-  HKEYS = this.hkeys;
-  HLEN = this.hlen;
-  HMGET = this.hmget;
-  HMSET = this.hmset;
-  HSCAN = this.hscan;
-  HSET = this.hset;
-  HSETNX = this.hsetnx;
-  HSTRLEN = this.hstrlen;
-  HVALS = this.hvals;
-  PFADD = this.pfadd;
-  PFCOUNT = this.pfcount;
-  PFMERGE = this.pfmerge;
-  DEL = this.del;
-  DUMP = this.dump;
-  EXISTS = this.exists;
-  EXPIRE = this.expire;
-  EXPIREAT = this.expireat;
-  KEYS = this.keys;
-  MIGRATE = this.migrate;
-  MOVE = this.move;
-  OBJECT = this.object;
-  PERSIST = this.persist;
-  PEXPIRE = this.pexpire;
-  PEXPIREAT = this.pexpireat;
-  PTTL = this.pttl;
-  RANDOMKEY = this.randomkey;
-  RENAME = this.rename;
-  RENAMENX = this.renamenx;
-  RESTORE = this.restore;
-  SCAN = this.scan;
-  SORT = this.sort;
-  TOUCH = this.touch;
-  TTL = this.ttl;
-  TYPE = this.type;
-  UNLINK = this.unlink;
-  WAIT = this.wait;
-  BLPOP = this.blpop;
-  BEPOP = this.bepop;
-  BEPOPLPUSH = this.bepoplpush;
-  LINDEX = this.lindex;
-  LINSERT = this.linsert;
-  LLEN = this.llen;
-  LPOP = this.lpop;
-  LPUSH = this.lpush;
-  LPUSHX = this.lpushx;
-  LRANGE = this.lrange;
-  LREM = this.lrem;
-  LSET = this.lset;
-  LTRIM = this.ltrim;
-  RPOP = this.rpop;
-  RPOPLPUSH = this.rpoplpush;
-  RPUSH = this.rpush;
-  RPUSHX = this.rpushx;
-  PSUBSCRIBE = this.psubscribe;
-  PUBSUB = this.pubsub;
-  PUBLISH = this.publish;
-  PUNSUBSCRIBE = this.punsubscribe;
-  SUBSCRIBE = this.subscribe;
-  UNSUBSCRIBE = this.unsubscribe;
-  EVAL = this.eval;
-  EVALSHA = this.evalsha;
-  SCRIPT = this.script;
-  BGREWRITEAOF = this.bgrewriteaof;
-  BGSAVE = this.bgsave;
-  CLIENT = this.client;
-  COMMAND = this.command;
-  CONFIG = this.config;
-  DBSIZE = this.dbsize;
-  DEBUG = this.debug;
-  FLUSHALL = this.flushall;
-  FLUSHDB = this.flushdb;
-  INFO = this.info;
-  LASTSAVE = this.lastsave;
-  MONITOR = this.monitor;
-  ROLE = this.role;
-  SAVE = this.save;
-  SHUTDOWN = this.shutdown;
-  SLAVEOF = this.slaveof;
-  SLOWLOG = this.slowlog;
-  SYNC = this.sync;
-  TIME = this.time;
-  SADD = this.sadd;
-  SCARD = this.scard;
-  SDIFF = this.sdiff;
-  SDIFFSTORE = this.sdiffstore;
-  SINTER = this.sinter;
-  SINTERSTORE = this.sinterstore;
-  SISMEMBER = this.sismember;
-  SMEMBERS = this.smembers;
-  SMOVE = this.smove;
-  SPOP = this.spop;
-  SRANDMEMBER = this.srandmember;
-  SREM = this.srem;
-  SSCAN = this.sscan;
-  SUNION = this.sunion;
-  SUNIONSTORE = this.sunionstore;
-  ZADD = this.zadd;
-  ZCARD = this.zcard;
-  ZCOUNT = this.zcount;
-  ZINCRBY = this.zincrby;
-  ZINTERSTORE = this.zinterstore;
-  ZLEXCOUNT = this.zlexcount;
-  ZRANGE = this.zrange;
-  ZRANGEBYLEX = this.zrangebylex;
-  ZRANGEBYSCORE = this.zrangebyscore;
-  ZRANK = this.zrank;
-  ZREM = this.zrem;
-  ZREMRANGEBYLEX = this.zremrangebylex;
-  ZREMRANGEBYRANK = this.zremrangebyrank;
-  ZREMRANGEBYSCORE = this.zremrangebyscore;
-  ZREVRANGE = this.zrevrange;
-  ZREVRANGEBYLEX = this.zrevrangebylex;
-  ZREVRANGEBYSCORE = this.zrevrangebyscore;
-  ZREVRANK = this.zrevrank;
-  ZSCORE = this.zscore;
-  ZUNIONSTORE = this.zunionstore;
-  ZSCAN = this.zscan;
-  APPEND = this.append;
-  BITCOUNT = this.bitcount;
-  BITFIELD = this.bitfield;
-  BITOP = this.bitop;
-  BITPOS = this.bitpos;
-  DECR = this.decr;
-  DECRBY = this.decrby;
-  GET = this.get;
-  GETBIT = this.getbit;
-  GETRANGE = this.getrange;
-  GETSET = this.getset;
-  INCR = this.incr;
-  INCRBY = this.incrby;
-  INCRBYFLOAT = this.incrbyfloat;
-  MGET = this.mget;
-  MSET = this.mset;
-  MSETNX = this.msetnx;
-  PSETEX = this.psetex;
-  SET = this.set;
-  SETBIT = this.setbit;
-  SETEX = this.setex;
-  SETNX = this.setnx;
-  SETRANGE = this.setrange;
-  STRLEN = this.strlen;
-  DISCARD = this.discard;
-  EXEC = this.exec;
-  MULTI = this.multi;
-  UNWATCH = this.unwatch;
-  WATCH = this.watch;
-};
-
-
-
-declare const obj = MemoryCache;
+declare const obj: MemoryCache;
 export default obj;
\ No newline at end of file
diff --git a/package-lock.json b/package-lock.json
index b7ec4c7..3d735c8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
 {
   "name": "@outofsync/memory-cache",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -3054,30 +3054,34 @@
       }
     },
     "gulp-prettier": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/gulp-prettier/-/gulp-prettier-3.0.0.tgz",
-      "integrity": "sha512-vZFyC1F+7EjuI2WDUOcbPt9o3ZjdqjFMjr8a9Yk2K8EmNhP1w6X01QAkv5Ym3dsHCBsBA4AEFcYds2vOTSgx0A==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/gulp-prettier/-/gulp-prettier-4.0.0.tgz",
+      "integrity": "sha512-REx99tBRRKJD7qLPaKpplReM9cq2vFvqhMbcUZtJEVjxGjb5Ji+gN9vi8bsM8UhnDV+l0Zrf5x6L4uZiDmvGFQ==",
       "dev": true,
       "requires": {
         "plugin-error": "^1.0.1",
         "prettier": "^2.0.0",
-        "through2": "^3.0.0"
+        "through2": "^4.0.2"
       },
       "dependencies": {
-        "inherits": {
-          "version": "2.0.4",
-          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-          "dev": true
+        "readable-stream": {
+          "version": "3.6.0",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
+          "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
+          "dev": true,
+          "requires": {
+            "inherits": "^2.0.3",
+            "string_decoder": "^1.1.1",
+            "util-deprecate": "^1.0.1"
+          }
         },
         "through2": {
-          "version": "3.0.2",
-          "resolved": "https://registry.npmjs.org/through2/-/through2-3.0.2.tgz",
-          "integrity": "sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==",
+          "version": "4.0.2",
+          "resolved": "https://registry.npmjs.org/through2/-/through2-4.0.2.tgz",
+          "integrity": "sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==",
           "dev": true,
           "requires": {
-            "inherits": "^2.0.4",
-            "readable-stream": "2 || 3"
+            "readable-stream": "3"
           }
         }
       }
diff --git a/package.json b/package.json
index 4b0b5cc..a543759 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@outofsync/memory-cache",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "A Promise-based, simple, Redis-like, in-memory cache written in pure Javascript",
   "main": "index.js",
   "types": "index.d.ts",
@@ -73,7 +73,7 @@
     "gulp": "^4.0.2",
     "gulp-eslint": "^6.0.0",
     "gulp-mocha": "^8.0.0",
-    "gulp-prettier": "^3.0.0",
+    "gulp-prettier": "^4.0.0",
     "lolex": "^6.0.0",
     "mocha": "^9.0.3",
     "nyc": "^15.1.0",