RedisCluster

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def append[V](key: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

final def asInstanceOf[T0]: T0

def asyncRefreshClusterSlots(force: Boolean = false): Future[Unit]

def auth[V](value: V)(implicit arg0: ByteStringSerializer[V]): Future[Status]

def bgrewriteaof(): Future[String]

def bgsave(): Future[String]

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 bitpos(key: String, bit: Long, start: Long = 0, end: Long = 1): Future[Long]

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

def clientGetname(): Future[Option[String]]

def clientKill(ip: String, port: Int): Future[Boolean]

def clientList(): Future[Seq[Map[String, String]]]

def clientSetname(connectionName: String): Future[Boolean]

def clone(): AnyRef

def clusterInfo(): Future[Map[String, String]]

def clusterNodes(): Future[Array[ClusterNodeInfo]]

def clusterSlots(): Future[Seq[ClusterSlot]]

val clusterSlotsRef: Ref[Option[Map[ClusterSlot, RedisConnection]]]

def configGet(parameter: String): Future[Map[String, String]]

def configResetstat(): Future[Boolean]

def configSet(parameter: String, value: String): Future[Boolean]

def dbsize(): Future[Long]

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

def debugSegfault(): Future[String]

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

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

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

def dump[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def echo[V, R](value: V)(implicit arg0: ByteStringSerializer[V], arg1: ByteStringDeserializer[R]): Future[Option[R]]

final def eq(arg0: AnyRef): Boolean

def equalsHostPort(clusterNode: ClusterNode, server: RedisServer): Boolean

def eval[R](script: String, keys: Seq[String] = Seq.empty[String], args: Seq[String] = Seq.empty[String])(implicit arg0: RedisReplyDeserializer[R]): Future[R]

def evalsha[R](sha1: String, keys: Seq[String] = Seq.empty[String], args: Seq[String] = Seq.empty[String])(implicit arg0: RedisReplyDeserializer[R]): Future[R]

def evalshaOrEval[R](redisScript: RedisScript, keys: Seq[String] = Seq.empty[String], args: Seq[String] = Seq.empty[String])(implicit arg0: RedisReplyDeserializer[R]): Future[R]

Try EVALSHA, if NOSCRIPT returned, fallback to EVAL

implicit val executionContext: MessageDispatcher

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

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

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

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

def flushall(): Future[Boolean]

def flushdb(): Future[Boolean]

def geoAdd[K](key: String, lat: Double, lng: Double, loc: String): Future[Long]

def geoDist[K](key: String, member1: String, member2: String, unit: Measurement = Meter): Future[Double]

def geoHash[K](key: String, members: String*): Future[Seq[String]]

def geoPos[K](key: String, members: String*): Future[Seq[String]]

def geoRadius[K](key: String, lat: Double, lng: Double, radius: Double, dim: Measurement = Kilometer): Future[Seq[String]]

def geoRadiusByMember[K](key: String, member: String, dist: Int, dim: Measurement = Meter): Future[Seq[String]]

def geoRadiusByMemberWithOpt[K](key: String, member: String, dist: Int, dim: Measurement = Meter, opt: WithOption = WithDist, count: Int = Int.MaxValue): Future[Seq[String]]

def get[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

final def getClass(): Class[_]

def getClusterAndConnection(slot: Int): Option[(ClusterSlot, RedisConnection)]

def getClusterSlots(): Future[Map[ClusterSlot, RedisConnection]]

def getConnectOperations(server: RedisServer): () ⇒ Seq[Operation[_, _]]

def getConnectionsActive: Seq[ActorRef]

def getRedisActor[T](redisCommand: RedisCommand[_ <: RedisReply, T]): Option[ActorRef]

def getRedisConnection(slot: Int): Option[RedisConnection]

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

def getrange[R](key: String, start: Long, end: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def getset[V, R](key: String, value: V)(implicit arg0: ByteStringSerializer[V], arg1: ByteStringDeserializer[R]): Future[Option[R]]

def groupByCluserServer(keys: Seq[String]): Seq[Seq[String]]

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

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

def hget[R](key: String, field: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def hgetall[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Map[String, R]]

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[R](key: String, fields: String*)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[Option[R]]]

def hmset[V](key: String, keysValues: Map[String, V])(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def hscan[R](key: String, cursor: Int = 0, count: Option[Int] = None, matchGlob: Option[String] = None)(implicit arg0: ByteStringDeserializer[R]): Future[Cursor[Map[String, R]]]

def hset[V](key: String, field: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def hsetnx[V](key: String, field: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def hvals[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

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

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

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

def info(section: String): Future[String]

def info(): Future[String]

final def isInstanceOf[T0]: Boolean

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

def lastsave(): Future[Long]

def lindex[R](key: String, index: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def linsert[V](key: String, beforeAfter: ListPivot, pivot: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def linsertAfter[V](key: String, pivot: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def linsertBefore[V](key: String, pivot: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

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

val lockClusterSlots: Ref[Boolean]

val log: LoggingAdapter

def lpop[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def lpush[V](key: String, values: V*)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def lpushx[V](key: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def lrange[R](key: String, start: Long, stop: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

def lrem[V](key: String, count: Long, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def lset[V](key: String, index: Long, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

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

def makeRedisClientActor(server: RedisServer, active: Ref[Boolean]): ActorRef

def makeRedisConnection(server: RedisServer, defaultActive: Boolean = false): (RedisServer, RedisConnection)

def mget[R](keys: String*)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[Option[R]]]

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

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

def mset[V](keysValues: Map[String, V])(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def msetnx[V](keysValues: Map[String, V])(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

val name: String

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 onConnect(redis: RedisCommands, server: RedisServer): Unit

def onConnectStatus(server: RedisServer, active: Ref[Boolean]): (Boolean) ⇒ Unit

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

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

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

def pfadd[V](key: String, values: V*)(implicit arg0: ByteStringSerializer[V]): Future[Long]

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

def pfmerge(destKey: String, sourceKeys: String*): Future[Boolean]

def ping(): Future[String]

def psetex[V](key: String, milliseconds: Long, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

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

def publish[V](channel: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def quit(): Future[Boolean]

def randomkey[R]()(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

val redirectMessagePattern: Regex

def redisConnectionPool: Seq[ActorRef]

val redisServerConnections: Map[RedisServer, RedisConnection]

val redisServers: Seq[RedisServer]

def refreshConnections(): Unit

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

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

def restore[V](key: String, ttl: Long = 0, serializedValue: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def rpop[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def rpoplpush[R](source: String, destination: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def rpush[V](key: String, values: V*)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def rpushx[V](key: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def sadd[V](key: String, members: V*)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def save(): Future[Boolean]

def scan(cursor: Int = 0, count: Option[Int] = None, matchGlob: Option[String] = None): Future[Cursor[Seq[String]]]

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[R](key: String, keys: String*)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

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 send[T](redisConnection: ActorRef, redisCommand: RedisCommand[_ <: RedisReply, T]): Future[T]

def set[V](key: String, value: V, exSeconds: Option[Long] = None, pxMilliseconds: Option[Long] = None, NX: Boolean = false, XX: Boolean = false)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

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

def setex[V](key: String, seconds: Long, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def setnx[V](key: String, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def setrange[V](key: String, offset: Long, value: V)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def shutdown(modifier: ShutdownModifier): Future[Boolean]

def shutdown(): Future[Boolean]

def sinter[R](key: String, keys: String*)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

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

def sismember[V](key: String, member: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

def slaveof(host: String, port: Int): Future[Boolean]

def slaveofNoOne(): Future[Boolean]

def smembers[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

def smove[V](source: String, destination: String, member: V)(implicit arg0: ByteStringSerializer[V]): Future[Boolean]

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

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[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def srandmember[R](key: String, count: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

def srandmember[R](key: String)(implicit arg0: ByteStringDeserializer[R]): Future[Option[R]]

def srem[V](key: String, members: V*)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def sscan[R](key: String, cursor: Int = 0, count: Option[Int] = None, matchGlob: Option[String] = None)(implicit arg0: ByteStringDeserializer[R]): Future[Cursor[Seq[R]]]

def stop(): Unit

Disconnect from the server (stop the actor)

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

def sunion[R](key: String, keys: String*)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

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

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

def time(): Future[(Long, Long)]

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

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

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def zadd[V](key: String, scoreMembers: (Double, V)*)(implicit arg0: ByteStringSerializer[V]): Future[Long]

def zaddWithOptions[V](key: String, options: Seq[ZaddOption], scoreMembers: (Double, V)*)(implicit arg0: ByteStringSerializer[V]): 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[V](key: String, increment: Double, member: V)(implicit arg0: ByteStringSerializer[V]): Future[Double]

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

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

def zrange[R](key: String, start: Long, stop: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

def zrangeWithscores[R](key: String, start: Long, stop: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[(R, Double)]]

def zrangebylex[R](key: String, min: Option[String], max: Option[String], limit: Option[(Long, Long)] = None)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

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

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

def zrank[V](key: String, member: V)(implicit arg0: ByteStringSerializer[V]): Future[Option[Long]]

def zrem[V](key: String, members: V*)(implicit arg0: ByteStringSerializer[V]): Future[Long]

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

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

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

def zrevrange[R](key: String, start: Long, stop: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

def zrevrangeWithscores[R](key: String, start: Long, stop: Long)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[(R, Double)]]

def zrevrangebylex[R](key: String, max: Option[String], min: Option[String], limit: Option[(Long, Long)] = None)(implicit arg0: ByteStringDeserializer[R]): Future[Seq[R]]

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

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

def zrevrank[V](key: String, member: V)(implicit arg0: ByteStringSerializer[V]): Future[Option[Long]]

def zscan[R](key: String, cursor: Int = 0, count: Option[Int] = None, matchGlob: Option[String] = None)(implicit arg0: ByteStringDeserializer[R]): Future[Cursor[Seq[(Double, R)]]]

def zscore[V](key: String, member: V)(implicit arg0: ByteStringSerializer[V]): Future[Option[Double]]

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

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

def finalize(): Unit