SortedSetsApi

abstract def execute[A](command: RedisCommand[A]): Result[A]

abstract val serialization: RedisSerialization

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def bzpopmax(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value, Double)]]

Executes BZPOPMAX

def bzpopmax(key: Key, timeout: Int): Result[commons.Opt[(Value, Double)]]

Executes BZPOPMAX

def bzpopmin(keys: Iterable[Key], timeout: Int): Result[commons.Opt[(Key, Value, Double)]]

Executes BZPOPMIN

def bzpopmin(key: Key, timeout: Int): Result[commons.Opt[(Value, Double)]]

Executes BZPOPMIN

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit final def fieldCodec: RedisDataCodec[Field]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

implicit def headOps[T](head: T): HeadOps[T]

final def isInstanceOf[T0]: Boolean

implicit def iterableTailOps[T](tail: Iterable[T]): IterableTailOps[T]

implicit def iteratorTailOps[T](tail: Iterator[T]): IteratorTailOps[T]

implicit final def keyCodec: RedisDataCodec[Key]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit final def recordCodec: RedisRecordCodec[Record]

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

def toString(): String

implicit final def valueCodec: RedisDataCodec[Value]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zadd(key: Key, memberScores: Iterable[(Value, Double)], existence: commons.OptArg[Boolean] = OptArg.Empty, changed: Boolean = false): Result[Int]

Executes ZADD or simply returns 0 when memberScores is empty

def zadd(key: Key, score: Double, members: Iterable[Value]): Result[Int]

Executes ZADD or simply returns 0 when members is empty

def zadd(key: Key, score: Double, member: Value, members: Value*): Result[Int]

Executes ZADD

def zadd(key: Key, member: Value, score: Double): Result[Boolean]

Executes ZADD

def zadd(key: Key, memberScore: (Value, Double), memberScores: (Value, Double)*): Result[Int]

Executes ZADD

def zaddIncr(key: Key, member: Value, score: Double, existence: commons.OptArg[Boolean] = OptArg.Empty): Result[commons.Opt[Double]]

Executes ZADD

def zcard(key: Key): Result[Long]

Executes ZCARD

def zcount(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf): Result[Long]

Executes ZCOUNT

def zincrby(key: Key, increment: Double, member: Value): Result[Double]

Executes ZINCRBY

def zinterstore(destination: Key, keys: Iterable[Key], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

Executes ZINTERSTORE NOTE: keys MUST NOT be empty

def zinterstore(destination: Key, key: Key, keys: Key*): Result[Long]

Executes ZINTERSTORE

def zinterstoreWeights(destination: Key, keysWeights: Iterable[(Key, Double)], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

Executes ZINTERSTORE NOTE: keysWeights MUST NOT be empty

def zinterstoreWeights(destination: Key, keyWeight: (Key, Double), keysWeights: (Key, Double)*): Result[Long]

Executes ZINTERSTORE

def zlexcount(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf): Result[Long]

Executes ZLEXCOUNT

def zpopmax(key: Key, count: Long): Result[Seq[(Value, Double)]]

Executes ZPOPMAX

def zpopmax(key: Key): Result[commons.Opt[(Value, Double)]]

Executes ZPOPMAX

def zpopmin(key: Key, count: Long): Result[Seq[(Value, Double)]]

Executes ZPOPMIN

def zpopmin(key: Key): Result[commons.Opt[(Value, Double)]]

Executes ZPOPMIN]

def zrange(key: Key, start: Long = 0, stop: Long = 1): Result[Seq[Value]]

Executes ZRANGE

def zrangeWithscores(key: Key, start: Long = 0, stop: Long = 1): Result[Seq[(Value, Double)]]

Executes ZRANGE

def zrangebylex(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

Executes ZRANGEBYLEX

def zrangebyscore(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

Executes ZRANGEBYSCORE

def zrangebyscoreWithscores(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[(Value, Double)]]

Executes ZRANGEBYSCORE

def zrank(key: Key, member: Value): Result[commons.Opt[Long]]

Executes ZRANK

def zrem(key: Key, members: Iterable[Value]): Result[Int]

Executes ZREM or simply returns 0 when members is empty

def zrem(key: Key, member: Value, members: Value*): Result[Int]

Executes ZREM

def zrem(key: Key, member: Value): Result[Boolean]

Executes ZREM

def zremrangebylex(key: Key, min: LexLimit[Value] = LexLimit.MinusInf, max: LexLimit[Value] = LexLimit.PlusInf): Result[Long]

Executes ZREMRANGEBYLEX

def zremrangebyrank(key: Key, start: Long = 0, stop: Long = 1): Result[Long]

Executes ZREMRANGEBYRANK

def zremrangebyscore(key: Key, min: ScoreLimit = ScoreLimit.MinusInf, max: ScoreLimit = ScoreLimit.PlusInf): Result[Long]

Executes ZREMRANGEBYSCORE

def zrevrange(key: Key, start: Long = 0, stop: Long = 1): Result[Seq[Value]]

Executes ZREVRANGE

def zrevrangeWithscores(key: Key, start: Long = 0, stop: Long = 1): Result[Seq[(Value, Double)]]

Executes ZREVRANGE

def zrevrangebylex(key: Key, max: LexLimit[Value] = LexLimit.PlusInf, min: LexLimit[Value] = LexLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

Executes ZREVRANGEBYLEX

def zrevrangebyscore(key: Key, max: ScoreLimit = ScoreLimit.PlusInf, min: ScoreLimit = ScoreLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[Value]]

Executes ZREVRANGEBYSCORE

def zrevrangebyscoreWithscores(key: Key, max: ScoreLimit = ScoreLimit.PlusInf, min: ScoreLimit = ScoreLimit.MinusInf, limit: commons.OptArg[Limit] = OptArg.Empty): Result[Seq[(Value, Double)]]

Executes ZREVRANGEBYSCORE

def zrevrank(key: Key, member: Value): Result[commons.Opt[Long]]

Executes ZREVRANK

def zscan(key: Key, cursor: Cursor, matchPattern: commons.OptArg[Value] = OptArg.Empty, count: commons.OptArg[Int] = OptArg.Empty): Result[(Cursor, Seq[(Value, Double)])]

Executes ZSCAN

def zscore(key: Key, member: Value): Result[commons.Opt[Double]]

Executes ZSCORE

def zunionstore(destination: Key, keys: Iterable[Key], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

Executes ZUNIONSTORE NOTE: keys MUST NOT be empty

def zunionstore(destination: Key, key: Key, keys: Key*): Result[Long]

Executes ZUNIONSTORE

def zunionstoreWeights(destination: Key, keysWeights: Iterable[(Key, Double)], aggregation: commons.OptArg[Aggregation] = OptArg.Empty): Result[Long]

Executes ZUNIONSTORE NOTE: keysWeights MUST NOT be empty

def zunionstoreWeights(destination: Key, keyWeight: (Key, Double), keysWeights: (Key, Double)*): Result[Long]

Executes ZUNIONSTORE