PipelineClient

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def append(key: Any, value: Any)(implicit format: Format): Option[Long]

appends the key value with the specified value.

def asAny: Option[Any]

def asBoolean: Boolean

def asBulk[T](implicit parse: Parse[T]): Option[T]

def asBulkWithTime[T](implicit parse: Parse[T]): Option[T]

def asExec(handlers: Seq[() ⇒ Any]): Option[List[Any]]

final def asInstanceOf[T0]: T0

def asInt: Option[Int]

def asList[T](implicit parse: Parse[T]): Option[List[Option[T]]]

def asListPairs[A, B](implicit parseA: Parse[A], parseB: Parse[B]): Option[List[Option[(A, B)]]]

def asListTrios[A, B](implicit parseA: Parse[A], parseB: Parse[B], format: Format): Option[List[Option[(A, B, Double)]]]

def asLong: Option[Long]

def asPair[T](implicit parse: Parse[T]): Option[(Option[Int], Option[List[Option[T]]])]

def asQueuedList: Option[List[Option[String]]]

def asSet[T](implicit arg0: Parse[T]): Option[Set[Option[T]]]

def asString: Option[String]

def auth(secret: Any)(implicit format: Format): Boolean

auths with the server.

def bgrewriteaof: Boolean

def bgsave: Boolean

save the DB in the background.

def bitcount(key: Any, range: Option[(Int, Int)] = None)(implicit format: Format): Option[Int]

Count the number of set bits in the given key within the optional range

def bitop(op: String, destKey: Any, srcKeys: Any*)(implicit format: Format): Option[Int]

Perform a bitwise operation between multiple keys (containing string values) and store the result in the destination key.

def blpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V)]

def brpop[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V)]

def brpoplpush[A](srcKey: Any, dstKey: Any, timeoutInSeconds: Int)(implicit format: Format, parse: Parse[A]): Option[A]

def bulkRead(s: Array[Byte]): Option[Array[Byte]]

val bulkReply: SingleReply

def bzpopmax[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V, Double)]

def bzpopmin[K, V](timeoutInSeconds: Int, key: K, keys: K*)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[(K, V, Double)]

def clearFd(): Unit

def clone(): AnyRef

def close(): Unit

def cmd(args: Seq[Array[Byte]]): Array[Byte]

def connect: Boolean

def connected: Boolean

val database: Int

var db: Int

def dbsize: Option[Long]

returns the size of the db.

def debug(message: String, error: Throwable): Unit

def debug(message: String, values: AnyRef*): Unit

def decr(key: Any)(implicit format: Format): Option[Long]

decrements the specified key by 1

def decrby(key: Any, increment: Long)(implicit format: Format): Option[Long]

decrements the specified key by increment

def del(key: Any, keys: Any*)(implicit format: Format): Option[Long]

deletes the specified keys.

def disconnect: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val errReply: Reply[Nothing]

def error(message: String, error: Throwable): Unit

def error(message: String, values: AnyRef*): Unit

def evalBulk[A](luaCode: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def evalInt(luaCode: String, keys: List[Any], args: List[Any]): Option[Int]

def evalMultiBulk[A](luaCode: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

evaluates lua code on the server.

def evalMultiSHA[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

def evalSHA[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def evalSHABulk[A](shahash: String, keys: List[Any], args: List[Any])(implicit format: Format, parse: Parse[A]): Option[A]

def execReply(handlers: Seq[() ⇒ Any]): PartialFunction[(Char, Array[Byte]), Option[List[Any]]]

def exists(key: Any)(implicit format: Format): Boolean

test if the specified key exists.

def expire(key: Any, ttl: Int)(implicit format: Format): Boolean

sets the expire time (in sec.) for the specified key.

def expireat(key: Any, timestamp: Long)(implicit format: Format): Boolean

sets the expire time for the specified key.

def flattenPairs(in: Iterable[Product2[Any, Any]]): List[Any]

def flushall: Boolean

removes data from all the DB's.

def flushdb: Boolean

removes all the DB data.

val geoRadiusMemberReply: Reply[Option[List[Option[GeoRadiusMember]]]]

Entry point for GEORADIUS result analysis.

def geoadd(key: Any, members: Iterable[Product3[Any, Any, Any]]): Option[Int]

Add the given members in the key geo sorted set

def geodist(key: Any, m1: Any, m2: Any, unit: Option[Any]): Option[String]

def geohash[A](key: Any, members: Iterable[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

Get the geohash for each member in the key geo index.

def geopos[A](key: Any, members: Iterable[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[List[Option[A]]]]]

Retrieve the position of the members in the key geo sorted set.

def georadius(key: Any, longitude: Any, latitude: Any, radius: Any, unit: Any, withCoord: Boolean, withDist: Boolean, withHash: Boolean, count: Option[Int], sort: Option[Any], store: Option[Any], storeDist: Option[Any]): Option[List[Option[GeoRadiusMember]]]

Search for members around an origin point in the key geo sorted set

def georadiusbymember[A](key: Any, member: Any, radius: Any, unit: Any, withCoord: Boolean, withDist: Boolean, withHash: Boolean, count: Option[Int], sort: Option[Any], store: Option[Any], storeDist: Option[Any])(implicit format: Format, parse: Parse[A]): Option[List[Option[GeoRadiusMember]]]

Search for members around a specific memberin the key geo sorted set

def get[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

gets the value for the specified key.

final def getClass(): Class[_]

def getConfig(key: Any = "*")(implicit format: Format): Option[Map[String, Option[String]]]

CONFIG GET

def getType(key: Any)(implicit format: Format): Option[String]

returns the type of the value stored at key in form of a string.

def getbit(key: Any, offset: Int)(implicit format: Format): Option[Int]

Returns the bit value at offset in the string value stored at key

def getrange[A](key: Any, start: Int, end: Int)(implicit format: Format, parse: Parse[A]): Option[A]

Returns the substring of the string value stored at key, determined by the offsets start and end (both are inclusive).

def getset[A](key: Any, value: Any)(implicit format: Format, parse: Parse[A]): Option[A]

is an atomic set this value and return the old value command.

var handlers: Vector[() ⇒ Any]

def hashCode(): Int

def hdel(key: Any, field: Any, fields: Any*)(implicit format: Format): Option[Long]

def hexists(key: Any, field: Any)(implicit format: Format): Boolean

def hget[A](key: Any, field: Any)(implicit format: Format, parse: Parse[A]): Option[A]

def hgetall[K, V](key: Any)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[Map[K, V]]

def hgetall1[K, V](key: Any)(implicit format: Format, parseK: Parse[K], parseV: Parse[V]): Option[Map[K, V]]

def hincrby(key: Any, field: Any, value: Long)(implicit format: Format): Option[Long]

def hincrbyfloat(key: Any, field: Any, value: Float)(implicit format: Format): Option[Float]

def hkeys[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def hlen(key: Any)(implicit format: Format): Option[Long]

def hmget[K, V](key: Any, fields: K*)(implicit format: Format, parseV: Parse[V]): Option[Map[K, V]]

def hmset(key: Any, map: Iterable[Product2[Any, Any]])(implicit format: Format): Boolean

Sets the specified fields to their respective values in the hash stored at key.

val host: String

def hscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate hash fields and associated values (since 2.8)

def hset1(key: Any, field: Any, value: Any)(implicit format: Format): Option[Long]

Sets field in the hash stored at key to value.

def hsetnx(key: Any, field: Any, value: Any)(implicit format: Format): Boolean

Sets field in the hash stored at key to value, only if field does not yet exist.

def hvals[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def ifDebug(message: ⇒ String): Unit

def ifError(message: ⇒ String): Unit

def ifInfo(message: ⇒ String): Unit

def ifTrace(message: ⇒ String): Unit

def ifWarn(message: ⇒ String): Unit

var in: InputStream

def incr(key: Any)(implicit format: Format): Option[Long]

increments the specified key by 1

def incrby(key: Any, increment: Long)(implicit format: Format): Option[Long]

increments the specified key by increment

def incrbyfloat(key: Any, increment: Float)(implicit format: Format): Option[Float]

def info: Option[String]

The info command returns different information and statistics about the server.

def info(message: String, error: Throwable): Unit

def info(message: String, values: AnyRef*): Unit

val integerReply: Reply[Option[Int]]

final def isInstanceOf[T0]: Boolean

def keys[A](pattern: Any = "*")(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

returns all the keys matching the glob-style pattern.

def lastsave: Option[Long]

return the UNIX TIME of the last DB SAVE executed with success.

def lindex[A](key: Any, index: Int)(implicit format: Format, parse: Parse[A]): Option[A]

return the especified element of the list stored at the specified key.

def llen(key: Any)(implicit format: Format): Option[Long]

return the length of the list stored at the specified key.

val longReply: Reply[Option[Long]]

def lpop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

atomically return and remove the first (LPOP) or last (RPOP) element of the list

def lpush(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

add values to the head of the list stored at key (Variadic: >= 2.4)

def lpushx(key: Any, value: Any)(implicit format: Format): Option[Long]

add value to the head of the list stored at key (Variadic: >= 2.4)

def lrange[A](key: Any, start: Int, end: Int)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

return the specified elements of the list stored at the specified key.

def lrem(key: Any, count: Int, value: Any)(implicit format: Format): Option[Long]

Remove the first count occurrences of the value element from the list.

def lset(key: Any, index: Int, value: Any)(implicit format: Format): Boolean

set the list element at index with the new value.

def ltrim(key: Any, start: Int, end: Int)(implicit format: Format): Boolean

Trim an existing list so that it will contain only the specified range of elements specified.

def mget[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

get the values of all the specified keys.

def monitor: Boolean

is a debugging command that outputs the whole sequence of commands received by the Redis server.

def move(key: Any, db: Int)(implicit format: Format): Boolean

Move the specified key from the currently selected DB to the specified destination DB.

def mset(kvs: (Any, Any)*)(implicit format: Format): Boolean

set the respective key value pairs.

def msetnx(kvs: (Any, Any)*)(implicit format: Format): Boolean

set the respective key value pairs.

val multiBulkNested: MultiNestedReply

val multiBulkReply: MultiReply

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onConnect(): Unit

var out: OutputStream

val pairBulkReply: PairReply

def persist(key: Any)(implicit format: Format): Boolean

Remove the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).

def pexpire(key: Any, ttlInMillis: Int)(implicit format: Format): Boolean

sets the expire time (in milli sec.) for the specified key.

def pexpireat(key: Any, timestampInMillis: Long)(implicit format: Format): Boolean

sets the expire timestamp in millis for the specified key.

def pfadd(key: Any, value: Any, values: Any*): Option[Long]

Add a value to the hyperloglog (>= 2.8.9)

def pfcount(keys: Any*): Option[Long]

Get the estimated cardinality from one or more keys (>= 2.8.9)

def pfmerge(destination: Any, sources: Any*): Boolean

Merge existing keys (>= 2.8.9)

def ping: Option[String]

ping

val pong: Option[String]

val port: Int

def psetex(key: Any, expiryInMillis: Long, value: Any)(implicit format: Format): Boolean

def pttl(key: Any)(implicit format: Format): Option[Long]

returns the remaining time to live of a key that has a timeout in millis

def publish(channel: String, msg: String): Option[Long]

def queuedReplyInt: Reply[Option[Int]]

def queuedReplyList: MultiReply

def queuedReplyLong: Reply[Option[Long]]

def quit: Boolean

exits the server.

def randomkey[A](implicit parse: Parse[A]): Option[A]

returns a randomly selected key from the currently selected DB.

def readCounted(count: Int): Array[Byte]

def readLine: Array[Byte]

def receive[T](pf: Reply[T]): T

def rename(oldkey: Any, newkey: Any)(implicit format: Format): Boolean

atomically renames the key oldkey to newkey.

def renamenx(oldkey: Any, newkey: Any)(implicit format: Format): Boolean

rename oldkey into newkey but fails if the destination key newkey already exists.

def rpop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

atomically return and remove the first (LPOP) or last (RPOP) element of the list

def rpoplpush[A](srcKey: Any, dstKey: Any)(implicit format: Format, parse: Parse[A]): Option[A]

Remove the first count occurrences of the value element from the list.

def rpush(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

add values to the tail of the list stored at key (Variadic: >= 2.4)

def rpushx(key: Any, value: Any)(implicit format: Format): Option[Long]

add value to the tail of the list stored at key (Variadic: >= 2.4)

def sadd(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

Add the specified members to the set value stored at key.

def save: Boolean

save the DB on disk now.

def scan[A](cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate the keys space (since 2.8)

def scard(key: Any)(implicit format: Format): Option[Long]

Return the number of elements (the cardinality) of the Set at key.

def scriptExists(shahash: String): Option[Int]

def scriptFlush: Option[String]

def scriptLoad(luaCode: String): Option[String]

def sdiff[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN.

def sdiffstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

Compute the difference between the Set key1 and all the Sets key2, ..., keyN, and store the resulting Set at dstkey.

val secret: Option[Any]

def select(index: Int): Boolean

selects the DB to connect, defaults to 0 (zero).

def send[A](command: String)(result: ⇒ A): A

def send[A](command: String, args: Seq[Any])(result: ⇒ A)(implicit format: Format): A

def set(key: Any, value: Any, whenSet: SetBehaviour = Always, expire: Duration = null)(implicit format: Format): Boolean

sets the key with the specified value.

def setConfig(key: Any, value: Any)(implicit format: Format): Option[String]

CONFIG SET

def setbit(key: Any, offset: Int, value: Any)(implicit format: Format): Option[Int]

Sets or clears the bit at offset in the string value stored at key

def setex(key: Any, expiry: Long, value: Any)(implicit format: Format): Boolean

def setnx(key: Any, value: Any)(implicit format: Format): Boolean

sets the value for the specified key, only if the key is not there.

def setrange(key: Any, offset: Int, value: Any)(implicit format: Format): Option[Long]

SETRANGE key offset value Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value.

def shutdown: Boolean

Stop all the clients, save the DB, then quit the server.

val singleLineReply: SingleReply

def sinter[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

Return the intersection between the Sets stored at key1, key2, ..., keyN.

def sinterstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

Compute the intersection between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey.

def sismember(key: Any, value: Any)(implicit format: Format): Boolean

Test if the specified value is a member of the Set at key.

def slaveof(options: Any): Boolean

The SLAVEOF command can change the replication settings of a slave on the fly.

def smembers[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

Return all the members of the Set value at key.

def smove(sourceKey: Any, destKey: Any, value: Any)(implicit format: Format): Option[Long]

Move the specified member from one Set to another atomically.

var socket: Socket

def sort[A](key: String, limit: Option[(Int, Int)] = None, desc: Boolean = false, alpha: Boolean = false, by: Option[String] = None, get: List[String] = Nil)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

sort keys in a set, and optionally pull values for them

def sortNStore[A](key: String, limit: Option[(Int, Int)] = None, desc: Boolean = false, alpha: Boolean = false, by: Option[String] = None, get: List[String] = Nil, storeAt: String)(implicit format: Format, parse: Parse[A]): Option[Long]

sort keys in a set, and stores result in the supplied key

def spop[A](key: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

Remove and return multiple random elements (pop) from the Set value at key since (3.2).

def spop[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

Remove and return (pop) a random element from the Set value at key.

def srandmember[A](key: Any, count: Int)(implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

Return multiple random elements from a Set (since 2.6)

def srandmember[A](key: Any)(implicit format: Format, parse: Parse[A]): Option[A]

Return a random element from a Set

def srem(key: Any, value: Any, values: Any*)(implicit format: Format): Option[Long]

Remove the specified members from the set value stored at key.

def sscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate Set elements (since 2.8)

val sslContext: Option[SSLContext]

def strlen(key: Any)(implicit format: Format): Option[Long]

gets the length of the value associated with the key

def sunion[A](key: Any, keys: Any*)(implicit format: Format, parse: Parse[A]): Option[Set[Option[A]]]

Return the union between the Sets stored at key1, key2, ..., keyN.

def sunionstore(key: Any, keys: Any*)(implicit format: Format): Option[Long]

Compute the union between the Sets stored at key1, key2, ..., keyN, and store the resulting Set at dstkey.

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

def time[A](implicit format: Format, parse: Parse[A]): Option[List[Option[A]]]

returns the current server time as a two items lists: a Unix timestamp and the amount of microseconds already elapsed in the current second.

val timeout: Int

def toString(): String

def trace(message: String, error: Throwable): Unit

def trace(message: String, values: AnyRef*): Unit

def ttl(key: Any)(implicit format: Format): Option[Long]

returns the remaining time to live of a key that has a timeout

def unwatch(): Boolean

Flushes all the previously watched keys for a transaction

def vexists(key: Any, keys: Any*)(implicit format: Format): Option[Long]

returns the total number of keys existing.

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def warn(message: String, error: Throwable): Unit

def warn(message: String, values: AnyRef*): Unit

def watch(key: Any, keys: Any*)(implicit format: Format): Boolean

Marks the given keys to be watched for conditional execution of a transaction.

def write(data: Array[Byte]): Unit

def write_to_socket(data: Array[Byte])(op: (OutputStream) ⇒ Unit): Unit

def zadd(key: Any, score: Double, member: Any, scoreVals: (Double, Any)*)(implicit format: Format): Option[Long]

Add the specified members having the specified score to the sorted set stored at key.

def zcard(key: Any)(implicit format: Format): Option[Long]

def zcount(key: Any, min: Double = Double.NegativeInfinity, max: Double = Double.PositiveInfinity, minInclusive: Boolean = true, maxInclusive: Boolean = true)(implicit format: Format): Option[Long]

def zincrby(key: Any, incr: Double, member: Any)(implicit format: Format): Option[Double]

def zinterstore(dstKey: Any, keys: Iterable[Any], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zinterstoreWeighted(dstKey: Any, kws: Iterable[Product2[Any, Double]], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zpopmax[A](key: Any, count: Int = 1)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zpopmin[A](key: Any, count: Int = 1)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zrange[A](key: Any, start: Int = 0, end: Int = 1, sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangeWithScore[A](key: Any, start: Int = 0, end: Int = 1, sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zrangebylex[A](key: Any, min: String, max: String, limit: Option[(Int, Int)])(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangebyscore[A](key: Any, min: Double = Double.NegativeInfinity, minInclusive: Boolean = true, max: Double = Double.PositiveInfinity, maxInclusive: Boolean = true, limit: Option[(Int, Int)], sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[A]]

def zrangebyscoreWithScore[A](key: Any, min: Double = Double.NegativeInfinity, minInclusive: Boolean = true, max: Double = Double.PositiveInfinity, maxInclusive: Boolean = true, limit: Option[(Int, Int)], sortAs: SortOrder = ASC)(implicit format: Format, parse: Parse[A]): Option[List[(A, Double)]]

def zrank(key: Any, member: Any, reverse: Boolean = false)(implicit format: Format): Option[Long]

def zrem(key: Any, member: Any, members: Any*)(implicit format: Format): Option[Long]

Remove the specified members from the sorted set value stored at key.

def zremrangebyrank(key: Any, start: Int = 0, end: Int = 1)(implicit format: Format): Option[Long]

def zremrangebyscore(key: Any, start: Double = Double.NegativeInfinity, end: Double = Double.PositiveInfinity)(implicit format: Format): Option[Long]

def zscan[A](key: Any, cursor: Int, pattern: Any = "*", count: Int = 10)(implicit format: Format, parse: Parse[A]): Option[(Option[Int], Option[List[Option[A]]])]

Incrementally iterate sorted sets elements and associated scores (since 2.8)

def zscore(key: Any, element: Any)(implicit format: Format): Option[Double]

def zunionstore(dstKey: Any, keys: Iterable[Any], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def zunionstoreWeighted(dstKey: Any, kws: Iterable[Product2[Any, Double]], aggregate: Aggregate = SUM)(implicit format: Format): Option[Long]

def finalize(): Unit

def hset(key: Any, field: Any, value: Any)(implicit format: Format): Boolean

Sets field in the hash stored at key to value.

def randkey[A](implicit parse: Parse[A]): Option[A]

def set(key: Any, value: Any, onlyIfExists: Boolean, time: SecondsOrMillis): Boolean

def slaveOf(options: Any): Boolean