RedisCommands

implicit abstract val executionContext: ExecutionContext

abstract def redisConnection: ActorRef

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def append[A](key: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

final def asInstanceOf[T0]: T0

def auth[A](value: A)(implicit convert: RedisValueConverter[A]): Future[Status]

def bitcount(key: String, start: Long, end: Long): Future[Long]

def bitcount(key: String): Future[Long]

def bitop(operation: BitOperator, destkey: String, keys: String*): Future[Long]

def bitopAND(destkey: String, keys: String*): Future[Long]

def bitopNOT(destkey: String, key: String): Future[Long]

def bitopOR(destkey: String, keys: String*): Future[Long]

def bitopXOR(destkey: String, keys: String*): Future[Long]

def clone(): AnyRef

def decr(key: String): Future[Long]

def decrby(key: String, decrement: Long): Future[Long]

def del(keys: String*): Future[Long]

def dump(key: String): Future[Option[ByteString]]

def echo[A](value: A)(implicit convert: RedisValueConverter[A]): Future[Option[ByteString]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eval(script: String, keys: Seq[String] = Seq(), args: Seq[String] = Seq()): Future[RedisReply]

def evalsha(sha1: String, keys: Seq[String] = Seq(), args: Seq[String] = Seq()): Future[RedisReply]

def evalshaOrEval(redisScript: RedisScript, keys: Seq[String] = Seq(), args: Seq[String] = Seq()): Future[RedisReply]

Try EVALSHA, if NOSCRIPT returned, fallback to EVAL

def exists(key: String): Future[Boolean]

def expire(key: String, seconds: Long): Future[Boolean]

def expireat(key: String, seconds: Long): Future[Boolean]

def finalize(): Unit

def get(key: String): Future[Option[ByteString]]

final def getClass(): Class[_]

def getbit(key: String, offset: Long): Future[Boolean]

def getrange(key: String, start: Long, end: Long): Future[Option[ByteString]]

def getset[A](key: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Option[ByteString]]

def hashCode(): Int

def hdel(key: String, fields: String*): Future[Long]

def hexists(key: String, field: String): Future[Boolean]

def hget(key: String, field: String): Future[Option[ByteString]]

def hgetall(key: String): Future[Map[String, ByteString]]

def hincrby(key: String, fields: String, increment: Long): Future[Long]

def hincrbyfloat(key: String, fields: String, increment: Double): Future[Double]

def hkeys(key: String): Future[Seq[String]]

def hlen(key: String): Future[Long]

def hmget(key: String, fields: String*): Future[Seq[Option[ByteString]]]

def hmset[A](key: String, keysValues: Map[String, A])(implicit convert: RedisValueConverter[A]): Future[Boolean]

def hset[A](key: String, field: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def hsetnx[A](key: String, field: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def hvals(key: String): Future[Seq[ByteString]]

def incr(key: String): Future[Long]

def incrby(key: String, increment: Long): Future[Long]

def incrbyfloat(key: String, increment: Double): Future[Option[Double]]

final def isInstanceOf[T0]: Boolean

def keys(pattern: String): Future[Seq[String]]

def lindex(key: String, index: Long): Future[Option[ByteString]]

def linsert[A](key: String, beforeAfter: ListPivot, pivot: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def linsertAfter[A](key: String, pivot: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def linsertBefore[A](key: String, pivot: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def llen(key: String): Future[Long]

def lpop(key: String): Future[Option[ByteString]]

def lpush[A](key: String, values: A*)(implicit convert: RedisValueConverter[A]): Future[Long]

def lpushx[A](key: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def lrange(key: String, start: Long, stop: Long): Future[Seq[ByteString]]

def lrem[A](key: String, count: Long, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def lset[A](key: String, index: Long, value: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def ltrim(key: String, start: Long, stop: Long): Future[Boolean]

def mget(keys: String*): Future[Seq[Option[ByteString]]]

def migrate(host: String, port: Int, key: String, destinationDB: Int, timeout: FiniteDuration): Future[Boolean]

def move(key: String, db: Int): Future[Boolean]

def mset[A](keysValues: Map[String, A])(implicit convert: RedisValueConverter[A]): Future[Boolean]

def msetnx[A](keysValues: Map[String, A])(implicit convert: RedisValueConverter[A]): Future[Boolean]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def objectEncoding(key: String): Future[Option[String]]

def objectIdletime(key: String): Future[Option[Long]]

def objectRefcount(key: String): Future[Option[Long]]

def persist(key: String): Future[Boolean]

def pexpire(key: String, milliseconds: Long): Future[Boolean]

def pexpireat(key: String, millisecondsTimestamp: Long): Future[Boolean]

def ping(): Future[String]

def psetex[A](key: String, milliseconds: Long, value: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def pttl(key: String): Future[Long]

def publish[A](channel: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def quit(): Future[Boolean]

def randomkey(): Future[Option[ByteString]]

def rename(key: String, newkey: String): Future[Boolean]

def renamenx(key: String, newkey: String): Future[Boolean]

def restore[A](key: String, ttl: Long = 0, serializedValue: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def rpop(key: String): Future[Option[ByteString]]

def rpoplpush(source: String, destination: String): Future[Option[ByteString]]

def rpush[A](key: String, values: A*)(implicit convert: RedisValueConverter[A]): Future[Long]

def rpushx[A](key: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def sadd[A](key: String, members: A*)(implicit convert: RedisValueConverter[A]): Future[Long]

def scard(key: String): Future[Long]

def scriptExists(sha1: String*): Future[Seq[Boolean]]

def scriptFlush(): Future[Boolean]

def scriptKill(): Future[Boolean]

def scriptLoad(script: String): Future[String]

def sdiff(key: String, keys: String*): Future[Seq[ByteString]]

def sdiffstore(destination: String, key: String, keys: String*): Future[Long]

def select(index: Int): Future[Boolean]

def send[T](redisCommand: RedisCommand[_ <: RedisReply, T]): Future[T]

def set[A](key: String, value: A, exSeconds: Option[Long] = None, pxMilliseconds: Option[Long] = None, NX: Boolean = false, XX: Boolean = false)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def setbit(key: String, offset: Long, value: Boolean): Future[Boolean]

def setex[A](key: String, seconds: Long, value: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def setnx[A](key: String, value: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def setrange[A](key: String, offset: Long, value: A)(implicit convert: RedisValueConverter[A]): Future[Long]

def sinter(key: String, keys: String*): Future[Seq[ByteString]]

def sinterstore(destination: String, key: String, keys: String*): Future[Long]

def sismember[A](key: String, member: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def smembers(key: String): Future[Seq[ByteString]]

def smove[A](source: String, destination: String, member: A)(implicit convert: RedisValueConverter[A]): Future[Boolean]

def sort(key: String, byPattern: Option[String] = None, limit: Option[LimitOffsetCount] = None, getPatterns: Seq[String] = Seq(), order: Option[Order] = None, alpha: Boolean = false): Future[Seq[ByteString]]

def sortStore(key: String, byPattern: Option[String] = None, limit: Option[LimitOffsetCount] = None, getPatterns: Seq[String] = Seq(), order: Option[Order] = None, alpha: Boolean = false, store: String): Future[Long]

def spop(key: String): Future[Option[ByteString]]

def srandmember(key: String, count: Long): Future[Seq[ByteString]]

def srandmember(key: String): Future[Option[ByteString]]

def srem[A](key: String, members: A*)(implicit convert: RedisValueConverter[A]): Future[Long]

def strlen(key: String): Future[Long]

def sunion(key: String, keys: String*): Future[Seq[ByteString]]

def sunionstore(destination: String, key: String, keys: String*): Future[Long]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def ttl(key: String): Future[Long]

def type(key: String): Future[String]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zadd[A](key: String, scoreMembers: (Double, A)*)(implicit convert: RedisValueConverter[A]): Future[Long]

def zcard(key: String): Future[Long]

def zcount(key: String, min: Limit = Limit(Double.NegativeInfinity), max: Limit = Limit(Double.PositiveInfinity)): Future[Long]

def zincrby[A](key: String, increment: Double, member: A)(implicit convert: RedisValueConverter[A]): Future[Double]

def zinterstore(destination: String, key: String, keys: Seq[String], aggregate: Aggregate = SUM): Future[Long]

def zinterstoreWeighted(destination: String, keys: Seq[(String, Double)], aggregate: Aggregate = SUM): Future[Long]

def zrange(key: String, start: Long, stop: Long): Future[Seq[ByteString]]

def zrangeWithscores(key: String, start: Long, stop: Long): Future[Seq[(ByteString, Double)]]

def zrangebyscore(key: String, min: Limit, max: Limit, limit: Option[(Long, Long)] = None): Future[Seq[ByteString]]

def zrangebyscoreWithscores(key: String, min: Limit, max: Limit, limit: Option[(Long, Long)] = None): Future[Seq[(ByteString, Double)]]

def zrank[A](key: String, member: A)(implicit convert: RedisValueConverter[A]): Future[Option[Long]]

def zrem[A](key: String, members: A*)(implicit convert: RedisValueConverter[A]): Future[Long]

def zremrangebyrank(key: String, start: Long, stop: Long): Future[Long]

def zremrangebyscore(key: String, min: Limit, max: Limit): Future[Long]

def zrevrange(key: String, start: Long, stop: Long): Future[Seq[ByteString]]

def zrevrangeWithscores(key: String, start: Long, stop: Long): Future[Seq[(ByteString, Double)]]

def zrevrangebyscore(key: String, min: Limit, max: Limit, limit: Option[(Long, Long)] = None): Future[Seq[ByteString]]

def zrevrangebyscoreWithscores(key: String, min: Limit, max: Limit, limit: Option[(Long, Long)] = None): Future[Seq[(ByteString, Double)]]

def zrevrank[A](key: String, member: A)(implicit convert: RedisValueConverter[A]): Future[Option[Long]]

def zscore[A](key: String, member: A)(implicit convert: RedisValueConverter[A]): Future[Option[Double]]

def zunionstore(destination: String, key: String, keys: Seq[String], aggregate: Aggregate = SUM): Future[Long]

def zunionstoreWeighted(destination: String, keys: Seq[(String, Double)], aggregate: Aggregate = SUM): Future[Long]